@angular-eslint/eslint-plugin-template 17.3.1-alpha.1 → 17.3.1-alpha.11

package/dist/index.d.ts

@@ -0,0 +1,152 @@
+declare const _default: {
+    configs: {
+        all: {
+            parser: string;
+            plugins: string[];
+            rules: {
+                "@angular-eslint/template/alt-text": string;
+                "@angular-eslint/template/attributes-order": string;
+                "@angular-eslint/template/banana-in-box": string;
+                "@angular-eslint/template/button-has-type": string;
+                "@angular-eslint/template/click-events-have-key-events": string;
+                "@angular-eslint/template/conditional-complexity": string;
+                "@angular-eslint/template/cyclomatic-complexity": string;
+                "@angular-eslint/template/elements-content": string;
+                "@angular-eslint/template/eqeqeq": string;
+                "@angular-eslint/template/i18n": string;
+                "@angular-eslint/template/interactive-supports-focus": string;
+                "@angular-eslint/template/label-has-associated-control": string;
+                "@angular-eslint/template/mouse-events-have-key-events": string;
+                "@angular-eslint/template/no-any": string;
+                "@angular-eslint/template/no-autofocus": string;
+                "@angular-eslint/template/no-call-expression": string;
+                "@angular-eslint/template/no-distracting-elements": string;
+                "@angular-eslint/template/no-duplicate-attributes": string;
+                "@angular-eslint/template/no-inline-styles": string;
+                "@angular-eslint/template/no-interpolation-in-attributes": string;
+                "@angular-eslint/template/no-negated-async": string;
+                "@angular-eslint/template/no-positive-tabindex": string;
+                "@angular-eslint/template/prefer-control-flow": string;
+                "@angular-eslint/template/prefer-ngsrc": string;
+                "@angular-eslint/template/prefer-self-closing-tags": string;
+                "@angular-eslint/template/role-has-required-aria": string;
+                "@angular-eslint/template/table-scope": string;
+                "@angular-eslint/template/use-track-by-function": string;
+                "@angular-eslint/template/valid-aria": string;
+            };
+        };
+        recommended: {
+            parser: string;
+            plugins: string[];
+            rules: {
+                "@angular-eslint/template/banana-in-box": string;
+                "@angular-eslint/template/eqeqeq": string;
+                "@angular-eslint/template/no-negated-async": string;
+            };
+        };
+        accessibility: {
+            parser: string;
+            plugins: string[];
+            rules: {
+                "@angular-eslint/template/alt-text": string;
+                "@angular-eslint/template/click-events-have-key-events": string;
+                "@angular-eslint/template/elements-content": string;
+                "@angular-eslint/template/interactive-supports-focus": string;
+                "@angular-eslint/template/label-has-associated-control": string;
+                "@angular-eslint/template/mouse-events-have-key-events": string;
+                "@angular-eslint/template/no-autofocus": string;
+                "@angular-eslint/template/no-distracting-elements": string;
+                "@angular-eslint/template/role-has-required-aria": string;
+                "@angular-eslint/template/table-scope": string;
+                "@angular-eslint/template/valid-aria": string;
+            };
+        };
+        'process-inline-templates': {
+            parser: string;
+            parserOptions: {
+                ecmaVersion: number;
+                sourceType: string;
+            };
+            plugins: string[];
+            processor: string;
+        };
+    };
+    processors: {
+        'extract-inline-html': {
+            preprocess: typeof import("./processors").preprocessComponentFile;
+            postprocess: typeof import("./processors").postprocessComponentFile;
+            supportsAutofix: boolean;
+        };
+    };
+    rules: {
+        "alt-text": import("@typescript-eslint/utils/ts-eslint").RuleModule<"altText", [], import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+        "attributes-order": import("@typescript-eslint/utils/ts-eslint").RuleModule<"attributesOrder", [{
+            readonly alphabetical: boolean;
+            readonly order: readonly import("./rules/attributes-order").OrderType[];
+        }], import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+        "banana-in-box": import("@typescript-eslint/utils/ts-eslint").RuleModule<"bananaInBox", [], import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+        "button-has-type": import("@typescript-eslint/utils/ts-eslint").RuleModule<import("./rules/button-has-type").MessageIds, [], import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+        "click-events-have-key-events": import("@typescript-eslint/utils/ts-eslint").RuleModule<"clickEventsHaveKeyEvents", [], import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+        "conditional-complexity": import("@typescript-eslint/utils/ts-eslint").RuleModule<"conditionalComplexity", [{
+            maxComplexity: number;
+        }], import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+        "cyclomatic-complexity": import("@typescript-eslint/utils/ts-eslint").RuleModule<"cyclomaticComplexity", [{
+            maxComplexity: number;
+        }], import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+        "elements-content": import("@typescript-eslint/utils/ts-eslint").RuleModule<"elementsContent", [{
+            readonly allowList?: readonly string[] | undefined;
+        }], import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+        eqeqeq: import("@typescript-eslint/utils/ts-eslint").RuleModule<import("./rules/eqeqeq").MessageIds, [{
+            readonly allowNullOrUndefined?: boolean | undefined;
+        }], import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+        i18n: import("@typescript-eslint/utils/ts-eslint").RuleModule<import("./rules/i18n").MessageIds, [{
+            readonly boundTextAllowedPattern?: string | undefined;
+            readonly checkAttributes?: boolean | undefined;
+            readonly checkDuplicateId?: boolean | undefined;
+            readonly checkId?: boolean | undefined;
+            readonly checkText?: boolean | undefined;
+            readonly ignoreAttributes?: readonly string[] | undefined;
+            readonly ignoreTags?: readonly string[] | undefined;
+            readonly requireDescription?: boolean | undefined;
+            readonly requireMeaning?: boolean | undefined;
+        }], import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+        "interactive-supports-focus": import("@typescript-eslint/utils/ts-eslint").RuleModule<"interactiveSupportsFocus", [], import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+        "label-has-associated-control": import("@typescript-eslint/utils/ts-eslint").RuleModule<"labelHasAssociatedControl", [{
+            readonly controlComponents?: readonly string[] | undefined;
+            readonly labelComponents?: readonly {
+                readonly inputs?: readonly string[] | undefined;
+                readonly selector: string;
+            }[] | undefined;
+        }], import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+        "mouse-events-have-key-events": import("@typescript-eslint/utils/ts-eslint").RuleModule<"mouseEventsHaveKeyEvents", [], import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+        "no-any": import("@typescript-eslint/utils/ts-eslint").RuleModule<import("./rules/no-any").MessageIds, [], import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+        "no-autofocus": import("@typescript-eslint/utils/ts-eslint").RuleModule<"noAutofocus", [], import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+        "no-call-expression": import("@typescript-eslint/utils/ts-eslint").RuleModule<"noCallExpression", [{
+            readonly allowList?: readonly string[] | undefined;
+        }], import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+        "no-distracting-elements": import("@typescript-eslint/utils/ts-eslint").RuleModule<"noDistractingElements", [], import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+        "no-duplicate-attributes": import("@typescript-eslint/utils/ts-eslint").RuleModule<import("./rules/no-duplicate-attributes").MessageIds, [{
+            readonly allowTwoWayDataBinding?: boolean | undefined;
+            readonly allowStylePrecedenceDuplicates?: boolean | undefined;
+            readonly ignore?: readonly string[] | undefined;
+        }], import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+        "no-inline-styles": import("@typescript-eslint/utils/ts-eslint").RuleModule<"noInlineStyles", [{
+            readonly allowNgStyle?: boolean | undefined;
+            readonly allowBindToStyle?: boolean | undefined;
+        }], import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+        "no-interpolation-in-attributes": import("@typescript-eslint/utils/ts-eslint").RuleModule<"noInterpolationInAttributes", [], import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+        "no-negated-async": import("@typescript-eslint/utils/ts-eslint").RuleModule<import("./rules/no-negated-async").MessageIds, [], import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+        "no-positive-tabindex": import("@typescript-eslint/utils/ts-eslint").RuleModule<import("./rules/no-positive-tabindex").MessageIds, [], import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+        "prefer-control-flow": import("@typescript-eslint/utils/ts-eslint").RuleModule<"preferControlFlow", [], import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+        "prefer-self-closing-tags": import("@typescript-eslint/utils/ts-eslint").RuleModule<"preferSelfClosingTags", [], import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+        "prefer-ngsrc": import("@typescript-eslint/utils/ts-eslint").RuleModule<import("./rules/prefer-ngsrc").MessageIds, [], import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+        "role-has-required-aria": import("@typescript-eslint/utils/ts-eslint").RuleModule<import("./rules/role-has-required-aria").MessageIds, [], import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+        "table-scope": import("@typescript-eslint/utils/ts-eslint").RuleModule<"tableScope", [], import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+        "use-track-by-function": import("@typescript-eslint/utils/ts-eslint").RuleModule<"useTrackByFunction", [{
+            readonly alias: readonly string[];
+        }], import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+        "valid-aria": import("@typescript-eslint/utils/ts-eslint").RuleModule<import("./rules/valid-aria").MessageIds, [], import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+    };
+};
+export = _default;
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAmFA,kBAuCE"}

package/dist/processors.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Because ultimately a user is in control of how and when this processor gets invoked,
+ * we can't fully protect them against doing more work than is necessary in all cases.
+ *
+ * Therefore, before we do a full parse of a TypeScript file to try and extract one or
+ * more Component declarations we want to do a really quick check for whether or not
+ * a file is likely to contain them.
+ */
+export declare function isFileLikelyToContainComponentDeclarations(text: string, filename: string): boolean;
+type PreprocessResult = (string | {
+    text: string;
+    filename: string;
+})[];
+export declare function preprocessComponentFile(text: string, filename: string): PreprocessResult;
+export declare function postprocessComponentFile(multiDimensionalMessages: {
+    ruleId: string;
+    severity: number;
+    message: string;
+    line: number;
+    column: number;
+    nodeType: string;
+    messageId: string;
+    endLine: number;
+    endColumn: number;
+    fix?: {
+        range: number[];
+        text: string;
+    };
+}[][], filename: string): readonly unknown[];
+declare const _default: {
+    'extract-inline-html': {
+        preprocess: typeof preprocessComponentFile;
+        postprocess: typeof postprocessComponentFile;
+        supportsAutofix: boolean;
+    };
+};
+export default _default;
+//# sourceMappingURL=processors.d.ts.map

package/dist/processors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"processors.d.ts","sourceRoot":"","sources":["../src/processors.ts"],"names":[],"mappings":"AAMA;;;;;;;GAOG;AACH,wBAAgB,0CAA0C,CACxD,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,MAAM,GACf,OAAO,CA2BT;AAED,KAAK,gBAAgB,GAAG,CAAC,MAAM,GAAG;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,CAAC,EAAE,CAAC;AAExE,wBAAgB,uBAAuB,CACrC,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,MAAM,GACf,gBAAgB,CAsJlB;AAED,wBAAgB,wBAAwB,CACtC,wBAAwB,EAAE;IACxB,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;IAClB,GAAG,CAAC,EAAE;QACJ,KAAK,EAAE,MAAM,EAAE,CAAC;QAChB,IAAI,EAAE,MAAM,CAAC;KACd,CAAC;CACH,EAAE,EAAE,EACL,QAAQ,EAAE,MAAM,GACf,SAAS,OAAO,EAAE,CAmDpB;;;;;;;;AAED,wBAME"}

package/dist/rules/alt-text.d.ts

@@ -0,0 +1,5 @@
+export type MessageIds = 'altText';
+export declare const RULE_NAME = "alt-text";
+declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule<"altText", [], import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+export default _default;
+//# sourceMappingURL=alt-text.d.ts.map

package/dist/rules/alt-text.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"alt-text.d.ts","sourceRoot":"","sources":["../../src/rules/alt-text.ts"],"names":[],"mappings":"AASA,MAAM,MAAM,UAAU,GAAG,SAAS,CAAC;AACnC,eAAO,MAAM,SAAS,aAAa,CAAC;;AAEpC,wBAsCG"}

package/dist/rules/attributes-order.d.ts

@@ -0,0 +1,19 @@
+export declare enum OrderType {
+    TemplateReferenceVariable = "TEMPLATE_REFERENCE",
+    StructuralDirective = "STRUCTURAL_DIRECTIVE",
+    AttributeBinding = "ATTRIBUTE_BINDING",
+    InputBinding = "INPUT_BINDING",
+    OutputBinding = "OUTPUT_BINDING",
+    TwoWayBinding = "TWO_WAY_BINDING"
+}
+type Options = [
+    {
+        readonly alphabetical: boolean;
+        readonly order: readonly OrderType[];
+    }
+];
+export type MessageIds = 'attributesOrder';
+export declare const RULE_NAME = "attributes-order";
+declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule<"attributesOrder", Options, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+export default _default;
+//# sourceMappingURL=attributes-order.d.ts.map

package/dist/rules/attributes-order.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"attributes-order.d.ts","sourceRoot":"","sources":["../../src/rules/attributes-order.ts"],"names":[],"mappings":"AAiBA,oBAAY,SAAS;IACnB,yBAAyB,uBAAuB;IAChD,mBAAmB,yBAAyB;IAC5C,gBAAgB,sBAAsB;IACtC,YAAY,kBAAkB;IAC9B,aAAa,mBAAmB;IAChC,aAAa,oBAAoB;CAClC;AAED,KAAK,OAAO,GAAG;IACb;QACE,QAAQ,CAAC,YAAY,EAAE,OAAO,CAAC;QAC/B,QAAQ,CAAC,KAAK,EAAE,SAAS,SAAS,EAAE,CAAC;KACtC;CACF,CAAC;AA6BF,MAAM,MAAM,UAAU,GAAG,iBAAiB,CAAC;AAC3C,eAAO,MAAM,SAAS,qBAAqB,CAAC;;AAgB5C,wBAmJG"}

package/dist/rules/attributes-order.js

@@ -1,17 +1,26 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.RULE_NAME = void 0;
+exports.RULE_NAME = exports.OrderType = void 0;
 const bundled_angular_compiler_1 = require("@angular-eslint/bundled-angular-compiler");
 const utils_1 = require("@angular-eslint/utils");
 const create_eslint_rule_1 = require("../utils/create-eslint-rule");
+var OrderType;
+(function (OrderType) {
+    OrderType["TemplateReferenceVariable"] = "TEMPLATE_REFERENCE";
+    OrderType["StructuralDirective"] = "STRUCTURAL_DIRECTIVE";
+    OrderType["AttributeBinding"] = "ATTRIBUTE_BINDING";
+    OrderType["InputBinding"] = "INPUT_BINDING";
+    OrderType["OutputBinding"] = "OUTPUT_BINDING";
+    OrderType["TwoWayBinding"] = "TWO_WAY_BINDING";
+})(OrderType || (exports.OrderType = OrderType = {}));
 exports.RULE_NAME = 'attributes-order';
 const DEFAULT_ORDER = [
-    "STRUCTURAL_DIRECTIVE" /* OrderType.StructuralDirective */,
-    "TEMPLATE_REFERENCE" /* OrderType.TemplateReferenceVariable */,
-    "ATTRIBUTE_BINDING" /* OrderType.AttributeBinding */,
-    "INPUT_BINDING" /* OrderType.InputBinding */,
-    "TWO_WAY_BINDING" /* OrderType.TwoWayBinding */,
-    "OUTPUT_BINDING" /* OrderType.OutputBinding */,
+    OrderType.StructuralDirective,
+    OrderType.TemplateReferenceVariable,
+    OrderType.AttributeBinding,
+    OrderType.InputBinding,
+    OrderType.TwoWayBinding,
+    OrderType.OutputBinding,
 ];
 const DEFAULT_OPTIONS = {
     alphabetical: false,
@@ -57,7 +66,7 @@ exports.default = (0, create_eslint_rule_1.createESLintRule)({
         function getLocation(attr) {
             const loc = parserServices.convertNodeSourceSpanToLoc(attr.sourceSpan);
             switch (attr.orderType) {
-                case "STRUCTURAL_DIRECTIVE" /* OrderType.StructuralDirective */:
+                case OrderType.StructuralDirective:
                     return {
                         start: {
                             line: loc.start.line,
@@ -74,7 +83,6 @@ exports.default = (0, create_eslint_rule_1.createESLintRule)({
         }
         return {
             ['Element$1, Template'](node) {
-                var _a;
                 if (isImplicitTemplate(node)) {
                     return;
                 }
@@ -96,7 +104,7 @@ exports.default = (0, create_eslint_rule_1.createESLintRule)({
                 let errorRange;
                 for (let i = 0; i < sortedAttributes.length; i++) {
                     if (sortedAttributes[i] !== expectedAttributes[i]) {
-                        errorRange = [(_a = errorRange === null || errorRange === void 0 ? void 0 : errorRange[0]) !== null && _a !== void 0 ? _a : i, i];
+                        errorRange = [errorRange?.[0] ?? i, i];
                     }
                 }
                 if (errorRange) {
@@ -149,12 +157,11 @@ function byLocation(one, other) {
 }
 function byOrder(order, alphabetical) {
     return function (one, other) {
-        var _a, _b, _c, _d;
         const orderComparison = getOrderIndex(one, order) - getOrderIndex(other, order);
         if (alphabetical && orderComparison === 0) {
-            const oneName = (_b = (_a = one.keySpan) === null || _a === void 0 ? void 0 : _a.details) !== null && _b !== void 0 ? _b : one.name;
+            const oneName = one.keySpan?.details ?? one.name;
             const oneNormalised = oneName.replace(/^i18n-/, '');
-            const otherName = (_d = (_c = other.keySpan) === null || _c === void 0 ? void 0 : _c.details) !== null && _d !== void 0 ? _d : other.name;
+            const otherName = other.keySpan?.details ?? other.name;
             const otherNormalised = otherName.replace(/^i18n-/, '');
             if (oneNormalised === otherNormalised) {
                 return /^i18n-/.test(oneName) ? 1 : -1;
@@ -168,33 +175,53 @@ function getOrderIndex(attr, order) {
     return order.indexOf(attr.orderType);
 }
 function toAttributeBindingOrderType(attribute) {
-    return Object.assign(Object.assign({}, attribute), { orderType: "ATTRIBUTE_BINDING" /* OrderType.AttributeBinding */ });
+    return {
+        ...attribute,
+        orderType: OrderType.AttributeBinding,
+    };
 }
 function toInputBindingOrderType(input) {
-    return Object.assign(Object.assign({}, input), { orderType: "INPUT_BINDING" /* OrderType.InputBinding */ });
+    return {
+        ...input,
+        orderType: OrderType.InputBinding,
+    };
 }
 function toStructuralDirectiveOrderType(attributeOrInput) {
-    return Object.assign(Object.assign({}, attributeOrInput), { orderType: "STRUCTURAL_DIRECTIVE" /* OrderType.StructuralDirective */ });
+    return {
+        ...attributeOrInput,
+        orderType: OrderType.StructuralDirective,
+    };
 }
 function toOutputBindingOrderType(output) {
-    return Object.assign(Object.assign({}, output), { orderType: "OUTPUT_BINDING" /* OrderType.OutputBinding */ });
+    return {
+        ...output,
+        orderType: OrderType.OutputBinding,
+    };
 }
 function toTwoWayBindingOrderType(output) {
-    return Object.assign(Object.assign({}, output), { orderType: "TWO_WAY_BINDING" /* OrderType.TwoWayBinding */ });
+    return {
+        ...output,
+        orderType: OrderType.TwoWayBinding,
+    };
 }
 function toTemplateReferenceVariableOrderType(reference) {
-    return Object.assign(Object.assign({}, reference), { orderType: "TEMPLATE_REFERENCE" /* OrderType.TemplateReferenceVariable */ });
+    return {
+        ...reference,
+        orderType: OrderType.TemplateReferenceVariable,
+    };
 }
 function isImplicitTemplate(node) {
     return isTmplAstTemplate(node) && node.tagName !== 'ng-template';
 }
 function extractTemplateAttrs(node) {
-    var _a, _b, _c, _d, _e, _f;
     if (isTmplAstTemplate(node)) {
         return node.templateAttrs.map(toStructuralDirectiveOrderType).concat(node.variables.map((x) => {
-            return Object.assign(Object.assign({}, toAttributeBindingOrderType(x)), { 
+            return {
+                ...toAttributeBindingOrderType(x),
                 // `let-` is excluded from the keySpan and name - add it back in
-                keySpan: new bundled_angular_compiler_1.ParseSourceSpan(x.keySpan.start.moveBy(-4), x.keySpan.end), name: 'let-' + x.name });
+                keySpan: new bundled_angular_compiler_1.ParseSourceSpan(x.keySpan.start.moveBy(-4), x.keySpan.end),
+                name: 'let-' + x.name,
+            };
         }));
     }
     if (!isImplicitTemplate(node.parent)) {
@@ -207,22 +234,25 @@ function extractTemplateAttrs(node) {
      * will parsed as two attributes (`ngFor` and `ngForOf`)
      */
     const attrs = node.parent.templateAttrs.map(toStructuralDirectiveOrderType);
-    let keyEnd = (_a = attrs[0].keySpan) === null || _a === void 0 ? void 0 : _a.end;
-    if (((_b = keyEnd === null || keyEnd === void 0 ? void 0 : keyEnd.getContext(0, 0)) === null || _b === void 0 ? void 0 : _b.after) === '=') {
+    let keyEnd = attrs[0].keySpan?.end;
+    if (keyEnd?.getContext(0, 0)?.after === '=') {
         keyEnd = keyEnd.moveBy(1);
-        const apos = (_c = keyEnd.getContext(0, 0)) === null || _c === void 0 ? void 0 : _c.after;
+        const apos = keyEnd.getContext(0, 0)?.after;
         if (apos === "'" || apos === '"') {
             do {
                 keyEnd = keyEnd.moveBy(1);
-            } while (((_d = keyEnd.getContext(0, 0)) === null || _d === void 0 ? void 0 : _d.after) !== apos);
+            } while (keyEnd.getContext(0, 0)?.after !== apos);
         }
         else {
-            while (!/[\s>]/.test((_f = (_e = keyEnd.getContext(0, 0)) === null || _e === void 0 ? void 0 : _e.after) !== null && _f !== void 0 ? _f : '')) {
+            while (!/[\s>]/.test(keyEnd.getContext(0, 0)?.after ?? '')) {
                 keyEnd = keyEnd.moveBy(1);
             }
         }
         return [
-            Object.assign(Object.assign({}, attrs[0]), { sourceSpan: new bundled_angular_compiler_1.ParseSourceSpan(attrs[0].sourceSpan.start, keyEnd) }),
+            {
+                ...attrs[0],
+                sourceSpan: new bundled_angular_compiler_1.ParseSourceSpan(attrs[0].sourceSpan.start, keyEnd),
+            },
         ];
     }
     return [attrs[0]];
@@ -248,25 +278,24 @@ function isOnSameLocation(input, output) {
         input.sourceSpan.end === output.sourceSpan.end);
 }
 function getMessageName(expected) {
-    var _a, _b;
-    const fullName = (_b = (_a = expected.keySpan) === null || _a === void 0 ? void 0 : _a.details) !== null && _b !== void 0 ? _b : expected.name;
+    const fullName = expected.keySpan?.details ?? expected.name;
     switch (expected.orderType) {
-        case "STRUCTURAL_DIRECTIVE" /* OrderType.StructuralDirective */:
+        case OrderType.StructuralDirective:
             return `*${fullName}`;
-        case "TEMPLATE_REFERENCE" /* OrderType.TemplateReferenceVariable */:
+        case OrderType.TemplateReferenceVariable:
             return `#${fullName}`;
-        case "INPUT_BINDING" /* OrderType.InputBinding */:
+        case OrderType.InputBinding:
             return `[${fullName}]`;
-        case "OUTPUT_BINDING" /* OrderType.OutputBinding */:
+        case OrderType.OutputBinding:
             return `(${fullName})`;
-        case "TWO_WAY_BINDING" /* OrderType.TwoWayBinding */:
+        case OrderType.TwoWayBinding:
             return `[(${fullName})]`;
         default:
             return fullName;
     }
 }
 function isValuelessStructuralDirective(attr) {
-    if (attr.orderType !== "STRUCTURAL_DIRECTIVE" /* OrderType.StructuralDirective */ || !attr.keySpan) {
+    if (attr.orderType !== OrderType.StructuralDirective || !attr.keySpan) {
         return false;
     }
     const attrSpan = attr.sourceSpan;
@@ -285,7 +314,7 @@ function isValuelessStructuralDirective(attr) {
 }
 function getStartPos(expected) {
     switch (expected.orderType) {
-        case "STRUCTURAL_DIRECTIVE" /* OrderType.StructuralDirective */:
+        case OrderType.StructuralDirective:
             return expected.sourceSpan.start.offset - 1;
         default:
             return expected.sourceSpan.start.offset;
@@ -293,7 +322,7 @@ function getStartPos(expected) {
 }
 function getEndPos(expected) {
     switch (expected.orderType) {
-        case "STRUCTURAL_DIRECTIVE" /* OrderType.StructuralDirective */:
+        case OrderType.StructuralDirective:
             return (expected.sourceSpan.end.offset +
                 (isValuelessStructuralDirective(expected) ? 0 : 1));
         default:

package/dist/rules/banana-in-box.d.ts

@@ -0,0 +1,5 @@
+export type MessageIds = 'bananaInBox';
+export declare const RULE_NAME = "banana-in-box";
+declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule<"bananaInBox", [], import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+export default _default;
+//# sourceMappingURL=banana-in-box.d.ts.map

package/dist/rules/banana-in-box.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"banana-in-box.d.ts","sourceRoot":"","sources":["../../src/rules/banana-in-box.ts"],"names":[],"mappings":"AAKA,MAAM,MAAM,UAAU,GAAG,aAAa,CAAC;AACvC,eAAO,MAAM,SAAS,kBAAkB,CAAC;;AAKzC,wBA2CG"}

package/dist/rules/button-has-type.d.ts

@@ -0,0 +1,6 @@
+export declare const RULE_NAME = "button-has-type";
+export declare const INVALID_TYPE_DATA_KEY = "type";
+export type MessageIds = 'invalidType' | 'missingType';
+declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule<MessageIds, [], import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+export default _default;
+//# sourceMappingURL=button-has-type.d.ts.map

package/dist/rules/button-has-type.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"button-has-type.d.ts","sourceRoot":"","sources":["../../src/rules/button-has-type.ts"],"names":[],"mappings":"AAWA,eAAO,MAAM,SAAS,oBAAoB,CAAC;AAC3C,eAAO,MAAM,qBAAqB,SAAS,CAAC;AAC5C,MAAM,MAAM,UAAU,GAAG,aAAa,GAAG,aAAa,CAAC;;AAWvD,wBAyCG"}

package/dist/rules/click-events-have-key-events.d.ts

@@ -0,0 +1,5 @@
+export type MessageIds = 'clickEventsHaveKeyEvents';
+export declare const RULE_NAME = "click-events-have-key-events";
+declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule<"clickEventsHaveKeyEvents", [], import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+export default _default;
+//# sourceMappingURL=click-events-have-key-events.d.ts.map

package/dist/rules/click-events-have-key-events.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"click-events-have-key-events.d.ts","sourceRoot":"","sources":["../../src/rules/click-events-have-key-events.ts"],"names":[],"mappings":"AASA,MAAM,MAAM,UAAU,GAAG,0BAA0B,CAAC;AACpD,eAAO,MAAM,SAAS,iCAAiC,CAAC;;AAExD,wBAwDG"}

package/dist/rules/conditional-complexity.d.ts

@@ -0,0 +1,8 @@
+type Options = [{
+    maxComplexity: number;
+}];
+export type MessageIds = 'conditionalComplexity';
+export declare const RULE_NAME = "conditional-complexity";
+declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule<"conditionalComplexity", Options, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+export default _default;
+//# sourceMappingURL=conditional-complexity.d.ts.map

package/dist/rules/conditional-complexity.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"conditional-complexity.d.ts","sourceRoot":"","sources":["../../src/rules/conditional-complexity.ts"],"names":[],"mappings":"AAgBA,KAAK,OAAO,GAAG,CAAC;IAAE,aAAa,EAAE,MAAM,CAAA;CAAE,CAAC,CAAC;AAC3C,MAAM,MAAM,UAAU,GAAG,uBAAuB,CAAC;AACjD,eAAO,MAAM,SAAS,2BAA2B,CAAC;;AAIlD,wBAkFG"}

package/dist/rules/cyclomatic-complexity.d.ts

@@ -0,0 +1,8 @@
+type Options = [{
+    maxComplexity: number;
+}];
+export type MessageIds = 'cyclomaticComplexity';
+export declare const RULE_NAME = "cyclomatic-complexity";
+declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule<"cyclomaticComplexity", Options, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+export default _default;
+//# sourceMappingURL=cyclomatic-complexity.d.ts.map

package/dist/rules/cyclomatic-complexity.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cyclomatic-complexity.d.ts","sourceRoot":"","sources":["../../src/rules/cyclomatic-complexity.ts"],"names":[],"mappings":"AAOA,KAAK,OAAO,GAAG,CAAC;IAAE,aAAa,EAAE,MAAM,CAAA;CAAE,CAAC,CAAC;AAC3C,MAAM,MAAM,UAAU,GAAG,sBAAsB,CAAC;AAChD,eAAO,MAAM,SAAS,0BAA0B,CAAC;;AAIjD,wBA+CG"}

package/dist/rules/elements-content.d.ts

@@ -0,0 +1,10 @@
+type Options = [
+    {
+        readonly allowList?: readonly string[];
+    }
+];
+export type MessageIds = 'elementsContent';
+export declare const RULE_NAME = "elements-content";
+declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule<"elementsContent", Options, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+export default _default;
+//# sourceMappingURL=elements-content.d.ts.map

package/dist/rules/elements-content.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"elements-content.d.ts","sourceRoot":"","sources":["../../src/rules/elements-content.ts"],"names":[],"mappings":"AAKA,KAAK,OAAO,GAAG;IACb;QACE,QAAQ,CAAC,SAAS,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;KACxC;CACF,CAAC;AACF,MAAM,MAAM,UAAU,GAAG,iBAAiB,CAAC;AAC3C,eAAO,MAAM,SAAS,qBAAqB,CAAC;;AAa5C,wBAwDG"}

package/dist/rules/elements-content.js

@@ -50,7 +50,7 @@ exports.default = (0, create_eslint_rule_1.createESLintRule)({
                 const { attributes, inputs, name: element, sourceSpan } = node;
                 const safelistAttributes = new Set([
                     ...DEFAULT_SAFELIST_ATTRIBUTES,
-                    ...(allowList !== null && allowList !== void 0 ? allowList : []),
+                    ...(allowList ?? []),
                 ]);
                 const hasAttributeSafelisted = [...attributes, ...inputs]
                     .map(({ name }) => name)

package/dist/rules/eqeqeq.d.ts

@@ -0,0 +1,9 @@
+import type { TSESLint } from '@typescript-eslint/utils';
+type Options = [{
+    readonly allowNullOrUndefined?: boolean;
+}];
+export type MessageIds = 'eqeqeq' | 'suggestStrictEquality';
+export declare const RULE_NAME = "eqeqeq";
+declare const _default: TSESLint.RuleModule<MessageIds, Options, TSESLint.RuleListener>;
+export default _default;
+//# sourceMappingURL=eqeqeq.d.ts.map

package/dist/rules/eqeqeq.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"eqeqeq.d.ts","sourceRoot":"","sources":["../../src/rules/eqeqeq.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AAIzD,KAAK,OAAO,GAAG,CAAC;IAAE,QAAQ,CAAC,oBAAoB,CAAC,EAAE,OAAO,CAAA;CAAE,CAAC,CAAC;AAC7D,MAAM,MAAM,UAAU,GAAG,QAAQ,GAAG,uBAAuB,CAAC;AAC5D,eAAO,MAAM,SAAS,WAAW,CAAC;;AAGlC,wBA4EG"}

package/dist/rules/eqeqeq.js

@@ -48,22 +48,27 @@ exports.default = (0, create_eslint_rule_1.createESLintRule)({
                     actualOperation: operation,
                     expectedOperation: `${operation}=`,
                 };
-                context.report(Object.assign({ loc: {
+                context.report({
+                    loc: {
                         start: sourceCode.getLocFromIndex(start),
                         end: sourceCode.getLocFromIndex(end),
-                    }, messageId: 'eqeqeq', data }, (isStringNonNumericValue(left) || isStringNonNumericValue(right)
-                    ? {
-                        fix: (fixer) => getFix({ node, right, end, sourceCode, fixer }),
-                    }
-                    : {
-                        suggest: [
-                            {
-                                messageId: 'suggestStrictEquality',
-                                fix: (fixer) => getFix({ node, right, end, sourceCode, fixer }),
-                                data,
-                            },
-                        ],
-                    })));
+                    },
+                    messageId: 'eqeqeq',
+                    data,
+                    ...(isStringNonNumericValue(left) || isStringNonNumericValue(right)
+                        ? {
+                            fix: (fixer) => getFix({ node, right, end, sourceCode, fixer }),
+                        }
+                        : {
+                            suggest: [
+                                {
+                                    messageId: 'suggestStrictEquality',
+                                    fix: (fixer) => getFix({ node, right, end, sourceCode, fixer }),
+                                    data,
+                                },
+                            ],
+                        }),
+                });
             },
         };
     },

package/dist/rules/i18n.d.ts

@@ -0,0 +1,19 @@
+import type { TSESLint } from '@typescript-eslint/utils';
+type Options = [
+    {
+        readonly boundTextAllowedPattern?: string;
+        readonly checkAttributes?: boolean;
+        readonly checkDuplicateId?: boolean;
+        readonly checkId?: boolean;
+        readonly checkText?: boolean;
+        readonly ignoreAttributes?: readonly string[];
+        readonly ignoreTags?: readonly string[];
+        readonly requireDescription?: boolean;
+        readonly requireMeaning?: boolean;
+    }
+];
+export type MessageIds = 'i18nAttribute' | 'i18nAttributeOnIcuOrText' | 'i18nCustomIdOnAttribute' | 'i18nCustomIdOnElement' | 'i18nDuplicateCustomId' | 'suggestAddI18nAttribute' | 'i18nMissingDescription' | 'i18nMissingMeaning';
+export declare const RULE_NAME = "i18n";
+declare const _default: TSESLint.RuleModule<MessageIds, Options, TSESLint.RuleListener>;
+export default _default;
+//# sourceMappingURL=i18n.d.ts.map

package/dist/rules/i18n.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"i18n.d.ts","sourceRoot":"","sources":["../../src/rules/i18n.ts"],"names":[],"mappings":"AAkBA,OAAO,KAAK,EAAE,QAAQ,EAAY,MAAM,0BAA0B,CAAC;AA6CnE,KAAK,OAAO,GAAG;IACb;QACE,QAAQ,CAAC,uBAAuB,CAAC,EAAE,MAAM,CAAC;QAC1C,QAAQ,CAAC,eAAe,CAAC,EAAE,OAAO,CAAC;QACnC,QAAQ,CAAC,gBAAgB,CAAC,EAAE,OAAO,CAAC;QACpC,QAAQ,CAAC,OAAO,CAAC,EAAE,OAAO,CAAC;QAC3B,QAAQ,CAAC,SAAS,CAAC,EAAE,OAAO,CAAC;QAC7B,QAAQ,CAAC,gBAAgB,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;QAC9C,QAAQ,CAAC,UAAU,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;QACxC,QAAQ,CAAC,kBAAkB,CAAC,EAAE,OAAO,CAAC;QACtC,QAAQ,CAAC,cAAc,CAAC,EAAE,OAAO,CAAC;KACnC;CACF,CAAC;AACF,MAAM,MAAM,UAAU,GAClB,eAAe,GACf,0BAA0B,GAC1B,yBAAyB,GACzB,uBAAuB,GACvB,uBAAuB,GACvB,yBAAyB,GACzB,wBAAwB,GACxB,oBAAoB,CAAC;AAqBzB,eAAO,MAAM,SAAS,SAAS,CAAC;;AAiBhC,wBAqTG"}