jsii
Version:
[](https://cdk.dev) [ || function (receiver, state, value, kind, f) {
if (kind === "m") throw new TypeError("Private method is not writable");
if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
};
var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
};
var _Code_defaultCategory, _Code_category, _Code_formatter, _JsiiDiagnostic_formatted;
Object.defineProperty(exports, "__esModule", { value: true });
exports.configureCategories = exports.JsiiDiagnostic = exports.Code = void 0;
const spec = require("@jsii/spec");
const case_1 = require("case");
const ts = require("typescript");
const deprecation_warnings_1 = require("./transforms/deprecation-warnings");
const utils_1 = require("./utils");
/**
* Descriptors for all valid jsii diagnostic codes.
*
* The `category` or non-error codes can be updated, for example to treat
* warnings as errors, or to suppress certain undesirable warnings.
*/
class Code {
/**
* @internal
*/
static message({ code, name, formatter, }) {
return new Code(code, name, ts.DiagnosticCategory.Message, formatter);
}
/**
* @internal
*/
static suggestion({ code, name, formatter, }) {
return new Code(code, name, ts.DiagnosticCategory.Suggestion, formatter);
}
/**
* @internal
*/
static warning({ code, name, formatter, }) {
return new Code(code, name, ts.DiagnosticCategory.Warning, formatter);
}
/**
* @internal
*/
static error({ code, name, formatter, }) {
return new Code(code, name, ts.DiagnosticCategory.Error, formatter);
}
/**
* Get a diagnostic code by code or name.
*
* @param codeOrName the looked up diagnostic code or name.
*
* @returns the JsiiDiagnosticCode instande, if one exists, or `undefined`
*
* @experimental this module is under active development and the error codes
* and names may change in the future.
*/
static lookup(codeOrName) {
if (typeof codeOrName === 'number') {
return this.byCode[codeOrName];
}
return this.byName[codeOrName];
}
/**
* Registers a new diagnostic code.
*
* @param code the numeric code for the diagnostic
* @param name the symbolic name for the diagnostic
* @param defaultCategory the default category this diagnostic ranks in
* @param formatter a message formatter for easy creation of diagnostics
*/
constructor(code, name, defaultCategory, formatter) {
this.code = code;
this.name = name;
// eslint-disable-next-line @typescript-eslint/explicit-member-accessibility
_Code_defaultCategory.set(this, void 0);
// eslint-disable-next-line @typescript-eslint/explicit-member-accessibility
_Code_category.set(this, void 0);
// eslint-disable-next-line @typescript-eslint/explicit-member-accessibility
_Code_formatter.set(this, void 0);
__classPrivateFieldSet(this, _Code_defaultCategory, defaultCategory, "f");
__classPrivateFieldSet(this, _Code_formatter, formatter, "f");
if (code in Code.byCode) {
throw new Error(`Attempted to create two instances of ${this.constructor.name} with code ${code}`);
}
if (name in Code.byName) {
throw new Error(`Attempted to create two instances of ${this.constructor.name} with name ${name}`);
}
Code.byCode[code] = Code.byName[name] = this;
}
/**
* Determines whether this diagnostic is a compilation error. Diagnostics
* where this is `true` cannot have their `category` overridden to a lower
* category.
*/
get isError() {
return __classPrivateFieldGet(this, _Code_defaultCategory, "f") === ts.DiagnosticCategory.Error;
}
/**
* The diagnostic category this particular code is filed as.
*/
get category() {
return __classPrivateFieldGet(this, _Code_category, "f") ?? __classPrivateFieldGet(this, _Code_defaultCategory, "f");
}
/**
* Update the diagnostic category for this particular code. If `isError` is
* `true`, attempting to set anything other than `ts.DiagnosticCategory.Error`
* will result in an error being throw.
*
* @param newValue the new diagnostic category to be used.
*/
set category(newValue) {
if (this.isError && newValue !== ts.DiagnosticCategory.Error) {
throw new Error(`Illegal attempt to override category of error ${this.code} to ${ts.DiagnosticCategory[newValue]}`);
}
__classPrivateFieldSet(this, _Code_category, newValue, "f");
}
/**
* Creates a new `JsiiDiagnostic` message without any source code location
* data.
*
* @param args the arguments to the message formatter.
*
* @deprecated It is preferred to specify a source code location for problem
* markers. Prefer the use of `create` while providing a value
* for the `location` parameter whenever possible.
*/
createDetached(...args) {
return new JsiiDiagnostic(this, __classPrivateFieldGet(this, _Code_formatter, "f").call(this, ...args));
}
/**
* Creates a new `JsiiDiagnostic` message with source code location denoted
* by the provided `location` node.
*
* @param location the source code location attachment of the message.
* @param args the arguments to the message formatter.
*/
create(location, ...args) {
return new JsiiDiagnostic(this, __classPrivateFieldGet(this, _Code_formatter, "f").call(this, ...args), location);
}
}
exports.Code = Code;
_Code_defaultCategory = new WeakMap(), _Code_category = new WeakMap(), _Code_formatter = new WeakMap();
Code.byCode = {};
Code.byName = {};
/**
* A jsii-specific diagnostic entry.
*/
class JsiiDiagnostic {
//////////////////////////////////////////////////////////////////////////////
/**
* Determines whether a `Diagnostic` instance is a `JsiiDiagnostic` or not.
* @param diag
*/
static isJsiiDiagnostic(diag) {
return diag.domain === JsiiDiagnostic.DOMAIN;
}
/**
* Creates a new `JsiiDiagnostic` with the provided properties.
*
* @internal
*/
constructor(code, messageText, location) {
this.domain = JsiiDiagnostic.DOMAIN;
this.code = utils_1.JSII_DIAGNOSTICS_CODE;
this.relatedInformation = new Array();
// eslint-disable-next-line @typescript-eslint/explicit-member-accessibility
_JsiiDiagnostic_formatted.set(this, void 0);
this.category = code.category;
this.jsiiCode = code.code;
this.messageText = messageText;
if (location != null) {
this.file = location.getSourceFile();
this.start = location.getStart(this.file);
this.length = location.getEnd() - this.start;
}
}
addRelatedInformation(node, message) {
// Don't relate info into the TypeScript standard library
if (!/[\\/]typescript[\\/]lib[\\/]lib\..+\.d\.ts$/.test(node.getSourceFile().fileName)) {
this.relatedInformation.push(JsiiDiagnostic.JSII_9999_RELATED_INFO.create(node, message));
}
// Clearing out #formatted, as this would no longer be the correct string.
__classPrivateFieldSet(this, _JsiiDiagnostic_formatted, undefined, "f");
return this;
}
/**
* Links the provided `node` with the specified `message` as related to the
* current diagnostic, unless `node` is undefined.
*
* @param node the node where the message should be attached, if any.
* @param message the message to be attached to the diagnostic entry.
*
* @returns `this`
*/
addRelatedInformationIf(node, message) {
if (node != null) {
return this.addRelatedInformation(node, message);
}
else {
return this;
}
}
/**
* Adds related information to this `JsiiDiagnostic` instance if the provided
* `node` is defined.
*
* @param node the node to bind as related information, or `undefined`.
* @param message the message to attach to the related information.
*
* @returns `this`
*/
maybeAddRelatedInformation(node, message) {
if (node == null) {
return this;
}
this.relatedInformation.push(JsiiDiagnostic.JSII_9999_RELATED_INFO.create(node, message));
// Clearing out #formatted, as this would no longer be the correct string.
__classPrivateFieldSet(this, _JsiiDiagnostic_formatted, undefined, "f");
return this;
}
/**
* Formats this diagnostic with color and context if possible, and returns it.
* The formatted diagnostic is cached, so that it can be re-used. This is
* useful for diagnostic messages involving trivia -- as the trivia may have
* been obliterated from the `SourceFile` by the `TsCommentReplacer`, which
* makes the error messages really confusing.
*/
format(projectRoot) {
if (__classPrivateFieldGet(this, _JsiiDiagnostic_formatted, "f") == null) {
__classPrivateFieldSet(this, _JsiiDiagnostic_formatted, (0, utils_1._formatDiagnostic)(this, projectRoot), "f");
}
return __classPrivateFieldGet(this, _JsiiDiagnostic_formatted, "f");
}
}
exports.JsiiDiagnostic = JsiiDiagnostic;
_JsiiDiagnostic_formatted = new WeakMap();
//////////////////////////////////////////////////////////////////////////////
// 0001 => 0999 -- PACKAGE METADATA PROBLEMS
JsiiDiagnostic.JSII_0001_PKG_MISSING_DESCRIPTION = Code.suggestion({
code: 1,
formatter: () => 'A "description" field should be specified in "package.json"',
name: 'metadata/package-json-missing-description',
});
JsiiDiagnostic.JSII_0002_PKG_MISSING_HOMEPAGE = Code.suggestion({
code: 2,
formatter: () => 'A "homepage" field should be specified in "package.json"',
name: 'metadata/package-json-missing-homepage',
});
JsiiDiagnostic.JSII_0003_MISSING_README = Code.warning({
code: 3,
formatter: () => 'There is no "README.md" file. It is required in order to generate valid PyPI (Python) packages.',
name: 'metadata/missing-readme',
});
JsiiDiagnostic.JSII_0004_COULD_NOT_FIND_ENTRYPOINT = Code.error({
code: 4,
formatter: (mainFile) => `Could not find "main" file: ${mainFile}`,
name: 'metadata/could-not-find-entrypoint',
});
JsiiDiagnostic.JSII_0005_MISSING_PEER_DEPENDENCY = Code.warning({
code: 5,
formatter: (assm, reference) => `The type "${reference}" is exposed in the public API of this module. ` +
`Therefore, the module "${assm}" must also be defined under "peerDependencies". ` +
'This will be auto-corrected unless --no-fix-peer-dependencies was specified.',
name: 'metadata/missing-peer-dependency',
});
// NOTE: currently not possible to change the severity of this code,
// as it's being emitted before the overrides have been loaded
JsiiDiagnostic.JSII_0006_MISSING_DEV_DEPENDENCY = Code.warning({
code: 6,
formatter: (dependencyName, peerRange, minVersion, actual) => `A "peerDependency" on "${dependencyName}" at "${peerRange}" means you ` +
`should take a "devDependency" on "${dependencyName}" at "${minVersion}" ` +
`(found ${JSON.stringify(actual)})`,
name: 'metadata/missing-dev-dependency',
});
JsiiDiagnostic.JSII_0007_MISSING_WARNINGS_EXPORT = Code.error({
code: 7,
formatter: () => 'If you are compiling with --add-deprecation-warnings and your package.json ' +
`declares subpath exports, you must include { "./${deprecation_warnings_1.WARNINGSCODE_FILE_NAME}": "./${deprecation_warnings_1.WARNINGSCODE_FILE_NAME}" } ` +
'in the set of exports.',
name: 'metadata/missing-warnings-export',
});
//////////////////////////////////////////////////////////////////////////////
// 1000 => 1999 -- TYPESCRIPT LANGUAGE RESTRICTIONS
JsiiDiagnostic.JSII_1000_NO_CONST_ENUM = Code.error({
code: 1000,
formatter: () => 'Exported "const enum" declarations are not allowed',
name: 'typescript-restrictions/no-const-enum',
});
JsiiDiagnostic.JSII_1001_TYPE_HAS_NO_SYMBOL = Code.error({
code: 1001,
formatter: () => 'Non-primitive types without a symbol cannot be processed.',
name: 'typescript-restrictions/type-has-no-symbol',
});
JsiiDiagnostic.JSII_1002_UNSPECIFIED_PROMISE = Code.error({
code: 1002,
formatter: () => 'Un-specified promise type. Specify it using "Promise<T>"',
name: 'typescript-restrictions/unspecified-promise',
});
JsiiDiagnostic.JSII_1003_UNSUPPORTED_TYPE = Code.error({
code: 1003,
formatter: (messageText) => messageText,
name: 'typescript-restrictions/unsupported-type',
});
JsiiDiagnostic.JSII_1004_DUPLICATE_ENUM_VALUE = Code.error({
code: 1004,
formatter: (enumValue, enumMemberNames) => `Value ${enumValue} is used for multiple enum values: ${enumMemberNames.join(', ')}`,
name: 'typescript-restrictions/duplicate-enum-value',
});
JsiiDiagnostic.JSII_1005_SEPARATE_WRITE_TYPE = Code.error({
code: 1005,
formatter: () => 'Visible property signatures cannot use a separate write type. Use the same type as the getter.',
name: 'typescript-restrictions/separate-write-type',
});
JsiiDiagnostic.JSII_1006_GENERIC_TYPE = Code.error({
code: 1006,
formatter: () => 'Generic types are not supported because semantics are not uniform in target languages.',
name: 'typescript-restriction/generic-type',
});
JsiiDiagnostic.JSII_1999_UNSUPPORTED = Code.error({
code: 1999,
formatter: ({ what, alternative, suggestInternal, }) => `${what} are not supported in jsii APIs.${alternative ? ` Consider using ${alternative} instead.` : ''}${suggestInternal
? ` This declaration must${alternative ? ' otherwise' : ''} be marked "@internal" or "@jsii ignore".`
: ''}`,
name: 'typescript-restrictions/unsupported',
});
//////////////////////////////////////////////////////////////////////////////
// 2000 => 2999 -- INCORRECT USE OF THE @jsii DIRECTIVE
JsiiDiagnostic.JSII_2000_MISSING_DIRECTIVE_ARGUMENT = Code.warning({
code: 2000,
formatter: () => 'Missing argument to @jsii directive. Refer to the jsii compiler documentation for more information.',
name: 'jsii-directive/missing-argument',
});
JsiiDiagnostic.JSII_2100_STRUCT_ON_NON_INTERFACE = Code.warning({
code: 2100,
formatter: () => 'The "@jsii struct" directive is only applicable to interface declarations.',
name: 'jsii-directive/struct-on-non-interface',
});
JsiiDiagnostic.JSII_2999_UNKNOWN_DIRECTIVE = Code.warning({
code: 2999,
formatter: (text) => `Unknown @jsii directive: ${JSON.stringify(text)}. Refer to the jsii compiler documentation for more information.`,
name: 'jsii-directive/unknown',
});
//////////////////////////////////////////////////////////////////////////////
// 3000 => 3999 -- TYPE MODEL COHERENCE
JsiiDiagnostic.JSII_3000_EXPORTED_API_USES_HIDDEN_TYPE = Code.error({
code: 3000,
formatter: (badFqn) => `Exported APIs cannot use un-exported type "${badFqn}"`,
name: 'type-model/exported-api-cannot-use-unexported-type',
});
JsiiDiagnostic.JSII_3001_EXPOSED_INTERNAL_TYPE = Code.error({
code: 3001,
formatter: (symbol, isThisType, typeUse) => `Type ${isThisType ? `"this" (aka: "${symbol.name}")` : `"${symbol.name}"`} cannot be used as the ${typeUse} because it is private or @internal`,
name: 'type-model/use-of-internal-type',
});
JsiiDiagnostic.JSII_3002_USE_OF_UNEXPORTED_FOREIGN_TYPE = Code.error({
code: 3002,
formatter: (fqn, typeUse, pkg) => `Type "${fqn}" cannot be used as a ${typeUse} because it is not exported from ${pkg.name}`,
name: 'type-model/unexported-foreign-type',
});
JsiiDiagnostic.JSII_3003_SYMBOL_IS_EXPORTED_TWICE = Code.error({
code: 3003,
formatter: (ns1, ns2) => `Symbol is exported under two distinct submodules: ${ns1} and ${ns2}`,
name: 'type-model/symbol-is-exported-twice',
});
JsiiDiagnostic.JSII_3004_INVALID_SUPERTYPE = Code.error({
code: 3004,
formatter: (clause, badDeclaration) => {
return `Illegal ${clauseType(clause.token)} clause for an exported API: ${ts.SyntaxKind[badDeclaration.kind]}`;
function clauseType(token) {
switch (token) {
case ts.SyntaxKind.ExtendsKeyword:
return 'extends';
case ts.SyntaxKind.ImplementsKeyword:
return 'implements';
default:
return ts.SyntaxKind[token];
}
}
},
name: 'type-model/invalid-supertype',
});
JsiiDiagnostic.JSII_3005_TYPE_USED_AS_INTERFACE = Code.error({
code: 3005,
formatter: (badType) => `Type "${spec.describeTypeReference(badType)}" cannot be used as an interface`,
name: 'type-model/type-used-as-interface',
});
JsiiDiagnostic.JSII_3006_TYPE_USED_AS_CLASS = Code.error({
code: 3006,
formatter: (badType) => `Type "${spec.describeTypeReference(badType)}" cannot be used as a class`,
name: 'type-model/type-used-as-class',
});
JsiiDiagnostic.JSII_3007_ILLEGAL_STRUCT_EXTENSION = Code.error({
code: 3007,
formatter: (offender, struct) => `Attempt to extend or implement struct "${struct.fqn}" from "${offender.fqn}"`,
name: 'type-model/illegal-struct-extension',
});
JsiiDiagnostic.JSII_3008_STRUCT_PROPS_MUST_BE_READONLY = Code.error({
code: 3008,
formatter: (propName, struct) => `The "${propName}" property of struct "${struct.fqn}" must be "readonly". Rename "${struct.fqn}" to "I${struct.name}" if it is meant to be a behavioral interface.`,
name: 'type-model/struct-props-must-be-readonly',
});
JsiiDiagnostic.JSII_3009_OPTIONAL_PARAMETER_BEFORE_REQUIRED = Code.error({
code: 3009,
formatter: (param, nextParam) => `Parameter "${param.name}" cannot be optional, as it precedes required parameter "${nextParam.name}"`,
name: 'type-model/optional-parameter-before-required',
});
JsiiDiagnostic.JSII_3999_INCOHERENT_TYPE_MODEL = Code.error({
code: 3999,
formatter: (messageText) => messageText,
name: 'type-model/incoherent-type-model',
});
//////////////////////////////////////////////////////////////////////////////
// 4000 => 4999 -- TYPESCRIPT & JSII CONFIG ERRORS
JsiiDiagnostic.JSII_4000_FAILED_TSCONFIG_VALIDATION = Code.error({
code: 4000,
formatter: (config, ruleSet, violations) => {
return `Typescript compiler options in "${config}" are not passing validation against rule set "${ruleSet}", found the following rule violations:\n${violations
.map((v) => ` - ${v.field}: ${v.message}`)
.join('\n')}`;
},
name: 'typescript-config/invalid-tsconfig',
});
JsiiDiagnostic.JSII_4009_DISABLED_TSCONFIG_VALIDATION = Code.warning({
code: 4009,
formatter: (config) => `Validation of typescript config "${config}" is disabled. This is intended for experimental setups only. Compilation might fail or produce incompatible artifacts.`,
name: 'typescript-config/disabled-tsconfig-validation',
});
//////////////////////////////////////////////////////////////////////////////
// 5000 => 5999 -- LANGUAGE COMPATIBILITY ERRORS
JsiiDiagnostic.JSII_5000_JAVA_GETTERS = Code.error({
code: 5000,
formatter: (badName, typeName) => `Methods and properties cannot have names like "getXxx": those conflict with Java property getters. Rename "${typeName}.${badName}"`,
name: 'language-compatibility/potential-java-getter-conflict',
});
JsiiDiagnostic.JSII_5001_JAVA_SETTERS = Code.error({
code: 5001,
formatter: (badName, typeName) => `Methods and properties cannot have names like "setXxx": those conflict with Java property setters. Rename "${typeName}.${badName}"`,
name: 'language-compatibility/potential-java-setter-conflict',
});
JsiiDiagnostic.JSII_5002_OVERRIDE_CHANGES_VISIBILITY = Code.error({
code: 5002,
formatter: (newElement, action, newValue, oldValue) => `"${newElement}" changes visibility to ${newValue} when ${action}. Change it to ${oldValue}`,
name: 'language-compatibility/override-changes-visibility',
});
JsiiDiagnostic.JSII_5003_OVERRIDE_CHANGES_RETURN_TYPE = Code.error({
code: 5003,
formatter: (newElement, action, newValue, oldValue) => `"${newElement}" changes the return type to "${newValue}" when ${action}. Change it to "${oldValue}"`,
name: 'language-compatibility/override-changes-return-type',
});
JsiiDiagnostic.JSII_5004_OVERRIDE_CHANGES_PROP_TYPE = Code.error({
code: 5004,
formatter: (newElement, action, newType, oldType) => `"${newElement}" changes the property type to "${spec.describeTypeReference(newType)}" when ${action}. Change it to "${spec.describeTypeReference(oldType)}"`,
name: 'language-compatibility/override-changes-property-type',
});
JsiiDiagnostic.JSII_5005_OVERRIDE_CHANGES_PARAM_COUNT = Code.error({
code: 5005,
formatter: (newElement, action, newCount, oldCount) => `"${newElement}" has ${newCount} parameters when ${action}. It should accept ${oldCount} parameters`,
name: 'language-compatibility/override-changes-param-count',
});
JsiiDiagnostic.JSII_5006_OVERRIDE_CHANGES_PARAM_TYPE = Code.error({
code: 5006,
formatter: (newElement, action, newParam, oldParam) => `"${newElement}" changes the type of parameter "${newParam.name}" to ${spec.describeTypeReference(newParam.type)} when ${action}. Change it to ${spec.describeTypeReference(oldParam.type)}`,
name: 'language-compatibility/override-changes-param-type',
});
JsiiDiagnostic.JSII_5007_OVERRIDE_CHANGES_VARIADIC = Code.error({
code: 5007,
formatter: (newElement, action, newVariadic = false, oldVariadic = false) => `"${newElement}" turns ${newVariadic ? 'variadic' : 'non variadic'} when ${action}. Make it ${oldVariadic ? 'variadic' : 'non-variadic'}`,
name: 'language-compatibility/override-changes-variadic',
});
JsiiDiagnostic.JSII_5008_OVERRIDE_CHANGES_PARAM_OPTIONAL = Code.error({
code: 5008,
formatter: (newElement, action, newParam, oldParam) => `"${newElement}" turns parameter "${newParam.name}" ${newParam.optional ? 'optional' : 'required'} when ${action}. Make it ${oldParam.optional ? 'optional' : 'required'}`,
name: 'language-compatibility/override-changes-param-optional',
});
JsiiDiagnostic.JSII_5009_OVERRIDE_CHANGES_PROP_OPTIONAL = Code.error({
code: 5009,
formatter: (newElement, action, newOptional = false, oldOptional = false) => `"${newElement}" turns ${newOptional ? 'optional' : 'required'} when ${action}. Make it ${oldOptional ? 'optional' : 'required'}`,
name: 'language-compatibility/override-changes-prop-optional',
});
JsiiDiagnostic.JSII_5010_OVERRIDE_CHANGES_MUTABILITY = Code.error({
code: 5010,
formatter: (newElement, action, newReadonly = false, oldReadonly = false) => `"${newElement}" turns ${newReadonly ? 'readonly' : 'mutable'} when ${action}. Make it ${oldReadonly ? 'readonly' : 'mutable'}`,
name: 'language-compatibility/override-changes-mutability',
});
JsiiDiagnostic.JSII_5011_SUBMODULE_NAME_CONFLICT = Code.error({
code: 5011,
formatter: (submoduleName, typeName, reserved) => `Submodule "${submoduleName}" conflicts with "${typeName}, as different languages could represent it as: ${reserved
.map((x) => `"${x}"`)
.join(', ')}"`,
name: 'language-compatibility/submodule-name-conflicts',
});
JsiiDiagnostic.JSII_5012_NAMESPACE_IN_TYPE = Code.error({
code: 5012,
formatter: (typeName, namespaceName) => `All entities nested under a type (e.g: "${typeName}") must be concrete types, but "${namespaceName}" is a namespace. This structure cannot be supported in all languages (e.g: Java)`,
name: 'language-compatibility/namespace-in-type',
});
JsiiDiagnostic.JSII_5013_STATIC_INSTANCE_CONFLICT = Code.error({
code: 5013,
formatter: (member, type) => `Member "${member}" of class "${type.fqn}" has both a static and an instance delcaration`,
name: 'language-compatibility/static-instance-conflict',
});
JsiiDiagnostic.JSII_5014_INHERITED_STATIC_CONFLICT = Code.error({
code: 5014,
formatter: (member, type, baseMember, baseType) => `${member.static ? 'Static' : 'Instance'} member "${member.name}" of class "${type.fqn}" conflicts with ${baseMember.static ? 'static' : 'instance'} member in ancestor "${baseType.fqn}"`,
name: 'language-compatibility/inherited-static-conflict',
});
JsiiDiagnostic.JSII_5015_REDECLARED_INTERFACE_MEMBER = Code.error({
code: 5015,
formatter: (memberName, iface) => `Interface "${iface.fqn}" re-declares member "${memberName}". This is not supported as it results in invalid C#.`,
name: 'language-compatibility/redeclared-interface-member',
});
JsiiDiagnostic.JSII_5016_PROHIBITED_MEMBER_NAME = Code.error({
code: 5016,
formatter: (badName) => `Members cannot be named "${badName}" as it conflicts with synthetic declarations in some languages.`,
name: 'language-compatibility/prohibited-member-name',
});
JsiiDiagnostic.JSII_5017_POSITIONAL_KEYWORD_CONFLICT = Code.error({
code: 5017,
formatter: (badName) => `Parameter name "${badName}" is also the name of a property in a struct parameter. Rename the positional parameter.`,
name: 'language-compatibility/positional-keyword-conflict',
});
JsiiDiagnostic.JSII_5018_RESERVED_WORD = Code.warning({
code: 5018,
formatter: (badName, languages) => `"${badName}" is a reserved word in ${languages.join(', ')}. Using this name may cause problems when generating language bindings. Consider a different name.`,
name: 'language-compatibility/reserved-word',
});
JsiiDiagnostic.JSII_5019_MEMBER_TYPE_NAME_CONFLICT = Code.warning({
code: 5019,
formatter: (memberKind, memberSymbol, declaringType) => `The ${memberKind} name "${memberSymbol.name}" conflicts with the declaring ${declaringType.kind} "${declaringType.name}". This will result in renaming the ${declaringType.kind} to "_${declaringType.name}" in C#. Consider renaming "${memberSymbol.name}".`,
name: 'language-compatibility/member-name-conflicts-with-type-name',
});
JsiiDiagnostic.JSII_5020_STATIC_MEMBER_CONFLICTS_WITH_NESTED_TYPE = Code.error({
code: 5020,
formatter: (nestingType, staticMember, nestedType) => `The static member "${nestingType.name}.${staticMember.name}" has the same PascalCased representation as nested type "${nestingType.name}.${nestedType.name}". This would result in invalid code in Go.`,
name: 'language-compatibility/static-member-name-conflicts-with-nested-type',
});
//////////////////////////////////////////////////////////////////////////////
// 6000 => 6999 -- RESERVED
//////////////////////////////////////////////////////////////////////////////
// 7000 => 7999 -- DOCUMENTATION ERRORS
JsiiDiagnostic.JSII_7000_NON_EXISTENT_PARAMETER = Code.warning({
code: 7000,
formatter: (method, param) => `Documentation for method "${method.name}" refers to non-existent @param "${param}"`,
name: 'documentation/non-existent-parameter',
});
JsiiDiagnostic.JSII_7001_ILLEGAL_HINT = Code.error({
code: 7001,
formatter: (hint, ...valid) => `Illegal use of "@${hint}" hint. It is only valid on ${valid.join(', ')}.`,
name: 'documentation/illegal-hint',
});
JsiiDiagnostic.JSII_7999_DOCUMENTATION_ERROR = Code.error({
code: 7999,
formatter: (messageText) => messageText,
name: 'documentation/documentation-error',
});
//////////////////////////////////////////////////////////////////////////////
// 8000 => 8999 -- JSII STYLE ENFORCEMENT
JsiiDiagnostic.JSII_8000_PASCAL_CASED_TYPE_NAMES = Code.error({
code: 8000,
formatter: (badName, expectedName = (0, case_1.pascal)(badName)) => `Type names must be PascalCased. Rename "${badName}" to "${expectedName}"`,
name: 'code-style/type-names-must-use-pascal-case',
});
JsiiDiagnostic.JSII_8001_ALL_CAPS_ENUM_MEMBERS = Code.error({
code: 8001,
formatter: (badName, typeName) => `Enum members must be ALL_CAPS. Rename "${typeName}.${badName}" to "${(0, case_1.constant)(badName)}"`,
name: 'code-style/enum-members-must-use-all-caps',
});
JsiiDiagnostic.JSII_8002_CAMEL_CASED_MEMBERS = Code.error({
code: 8002,
formatter: (badName, typeName) => `Method and property (unless they are static readonly) names must use camelCase. Rename "${typeName}.${badName}" to "${(0, case_1.camel)(badName)}"`,
name: 'code-style/member-names-must-use-camel-case',
});
JsiiDiagnostic.JSII_8003_STATIC_CONST_CASING = Code.error({
code: 8003,
formatter: (badName, typeName) => `Static constant names must use ALL_CAPS, PascalCase, or camelCase. Rename "${typeName}.${badName}" to "${(0, case_1.constant)(badName)}"`,
name: 'code-style/static-readonly-property-casing',
});
JsiiDiagnostic.JSII_8004_SUBMOULE_NAME_CASING = Code.error({
code: 8004,
formatter: (badName) => `Submodule namespaces must be camelCased or snake_cased. Rename "${badName}" to ${(0, case_1.camel)(badName)}`,
name: 'code-style/submodule-name-casing',
});
JsiiDiagnostic.JSII_8005_INTERNAL_UNDERSCORE = Code.error({
code: 8005,
formatter: (badName) => `Members marked with @internal must have a name starting with "_". Rename "${badName}" to "_${badName}"`,
name: 'code-style/internal-members-underscore-prefix',
});
JsiiDiagnostic.JSII_8006_UNDERSCORE_INTERNAL = Code.error({
code: 8006,
formatter: (badName) => `Members with a name starting with "_" (e.g: "${badName}") must be marked @internal`,
name: 'code-style/underscored-members-must-be-internal',
});
JsiiDiagnostic.JSII_8007_BEHAVIORAL_INTERFACE_NAME = Code.error({
code: 8007,
formatter: (badName) => `Interface contains behavior. Rename "${badName}" to "I${badName}"`,
name: 'code-style/behavioral-interface-name',
});
//////////////////////////////////////////////////////////////////////////////
// 9000 => 9999 -- SURPRISING ERRORS & INFORMATIONAL MESSAGES
JsiiDiagnostic.JSII_9000_UNKNOWN_MODULE = Code.error({
code: 9000,
formatter: (moduleName) => `Encountered use of module that is not declared in "dependencies" or "peerDependencies": "${moduleName}"`,
name: 'miscellaneous/unknown-module',
});
JsiiDiagnostic.JSII_9001_TYPE_NOT_FOUND = Code.error({
code: 9001,
formatter: (typeRef) => `Type not found in the corresponding assembly: "${typeRef.fqn}"`,
name: 'miscellaneous/type-not-found',
});
JsiiDiagnostic.JSII_9002_UNRESOLVEABLE_TYPE = Code.error({
code: 9002,
formatter: (reference) => `Unable to resolve type "${reference}". It may be @internal or not exported from the module's entry point (as configured in "package.json" as "main").`,
name: 'miscellaneous/unresolveable-type',
});
JsiiDiagnostic.JSII_9003_UNRESOLVEABLE_MODULE = Code.error({
code: 9003,
formatter: (location) => `Unable to resolve module location "${location}"`,
name: 'miscellaneous/unresolveable-module',
});
JsiiDiagnostic.JSII_9004_UNABLE_TO_COMPUTE_SIGNATURE = Code.error({
code: 9004,
formatter: (methodName, type) => `Unable to compute signature for method "${methodName}" of "${type.fqn}"`,
name: 'miscellaneous/unable-to-compute-signature',
});
JsiiDiagnostic.JSII_9996_UNNECESSARY_TOKEN = Code.message({
code: 9996,
formatter: () => 'Unnecessary token, consider removing it',
name: 'miscellaneous/unnecessary-token',
});
JsiiDiagnostic.JSII_9997_UNKNOWN_ERROR = Code.error({
code: 9997,
formatter: (error) => `Unknown error: ${error.message} -- ${error.stack}`,
name: 'miscellaneous/unknown-error',
});
JsiiDiagnostic.JSII_9998_UNSUPPORTED_NODE = Code.message({
code: 9998,
formatter: (kindOrMessage) => typeof kindOrMessage === 'string'
? kindOrMessage
: `Unsupported ${ts.SyntaxKind[kindOrMessage]} node. This declaration will not be accessible from other languages.`,
name: 'miscellaneous/unsupported-node',
});
//////////////////////////////////////////////////////////////////////////////
JsiiDiagnostic.JSII_9999_RELATED_INFO = Code.suggestion({
code: 9999,
formatter: (messageText) => messageText,
name: 'miscellaneous/related-info',
});
//////////////////////////////////////////////////////////////////////////////
/**
* This symbol unequivocally identifies the `JsiiDiagnostic` domain.
*/
JsiiDiagnostic.DOMAIN = Symbol('jsii');
function configureCategories(records) {
for (const [code, category] of Object.entries(records)) {
const diagCode = Code.lookup(diagnosticCode(code));
if (!diagCode) {
throw new Error(`Unrecognized diagnostic code '${code}'`);
}
diagCode.category = category;
}
}
exports.configureCategories = configureCategories;
function diagnosticCode(str) {
if (str.toLowerCase().startsWith('jsii')) {
const re = /^JSII(\d+)$/i.exec(str);
if (re) {
return parseInt(re[1], 10);
}
throw new Error(`Invalid diagnostic code ${str}. A number must follow code that starts with 'JSII'`);
}
return str;
}
//# sourceMappingURL=jsii-diagnostic.js.map