@angular-eslint/utils 17.5.3-alpha.1 → 17.5.3

package/README.md

@@ -1,5 +1 @@
 # @angular-eslint/utils
-
-Please see https://github.com/angular-eslint/angular-eslint for full usage instructions and guidance.
-
-The `@angular-eslint/utils` package is a set of utility functions and types which are used across the `@angular-eslint` packages and are helpful when writing your own custom ESLint rules for Angular workspaces.

package/dist/convert-annotated-source-to-failure-case.d.ts

@@ -0,0 +1,61 @@
+import type { TSESLint } from '@typescript-eslint/utils';
+/**
+ * When leveraging the convertAnnotatedSourceToFailureCase() utility, the
+ * following characters are eligible to be used in the source code of expected
+ * failure cases within ESLint unit tests in order to provide an easy way to
+ * annotate where one or more ESLint errors are expected to occur within that
+ * source.
+ *
+ * See the convertAnnotatedSourceToFailureCase() utility itself for more details.
+ */
+export declare const SPECIAL_UNDERLINE_CHARS: readonly ["~", "^", "#", "%", "¶", "*", "¨", "@"];
+type MultipleErrorOptions<TMessageIds extends string> = BaseErrorOptions & {
+    readonly messages: readonly (Message<TMessageIds> & {
+        readonly char: (typeof SPECIAL_UNDERLINE_CHARS)[number];
+    })[];
+};
+type BaseErrorOptions = {
+    readonly description: string;
+    readonly annotatedSource: string;
+    readonly options?: readonly unknown[];
+    readonly annotatedOutput?: string;
+    readonly filename?: string;
+    readonly only?: boolean;
+};
+type Message<TMessageIds extends string> = {
+    readonly messageId: TMessageIds;
+    readonly data?: Record<string, unknown>;
+    readonly suggestions?: TSESLint.SuggestionOutput<TMessageIds>[];
+};
+type SingleErrorOptions<TMessageIds extends string> = BaseErrorOptions & Message<TMessageIds>;
+/**
+ * convertAnnotatedSourceToFailureCase() provides an ergonomic way to easily write
+ * expected failure cases for ESLint rules by allowing you to directly annotate the
+ * source code for the case with one or more of the values in `SPECIAL_UNDERLINE_CHARS`.
+ *
+ * This not only makes the unit tests easier to write because of the time saved in figuring
+ * out location data in terms of lines and columns, but also far easier to read, which is
+ * arguably much more important.
+ *
+ * Here is a real-world example of using the utility:
+ *
+ * ```ts
+ *  convertAnnotatedSourceToFailureCase({
+ *    description: 'should fail when Pipe has no prefix ng',
+ *    annotatedSource: `
+ *        @Pipe({
+ *          name: 'foo-bar'
+ *                ~~~~~~~~~
+ *        })
+ *        class Test {}
+ *    `,
+ *    messageId: 'pipePrefix,
+ *    options: [{ prefixes: ['ng'] }],
+ *    data: { prefixes: '"ng"' },
+ *  }),
+ * ```
+ */
+export declare function convertAnnotatedSourceToFailureCase<TMessageIds extends string>(errorOptions: SingleErrorOptions<TMessageIds>): TSESLint.InvalidTestCase<TMessageIds, readonly unknown[]>;
+export declare function convertAnnotatedSourceToFailureCase<TMessageIds extends string>(errorOptions: MultipleErrorOptions<TMessageIds>): TSESLint.InvalidTestCase<TMessageIds, readonly unknown[]>;
+export {};
+//# sourceMappingURL=convert-annotated-source-to-failure-case.d.ts.map

package/dist/convert-annotated-source-to-failure-case.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"convert-annotated-source-to-failure-case.d.ts","sourceRoot":"","sources":["../src/convert-annotated-source-to-failure-case.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AAEzD;;;;;;;;GAQG;AACH,eAAO,MAAM,uBAAuB,mDAS1B,CAAC;AAEX,KAAK,oBAAoB,CAAC,WAAW,SAAS,MAAM,IAAI,gBAAgB,GAAG;IACzE,QAAQ,CAAC,QAAQ,EAAE,SAAS,CAAC,OAAO,CAAC,WAAW,CAAC,GAAG;QAClD,QAAQ,CAAC,IAAI,EAAE,CAAC,OAAO,uBAAuB,CAAC,CAAC,MAAM,CAAC,CAAC;KACzD,CAAC,EAAE,CAAC;CACN,CAAC;AAEF,KAAK,gBAAgB,GAAG;IACtB,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAC;IACjC,QAAQ,CAAC,OAAO,CAAC,EAAE,SAAS,OAAO,EAAE,CAAC;IACtC,QAAQ,CAAC,eAAe,CAAC,EAAE,MAAM,CAAC;IAClC,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,IAAI,CAAC,EAAE,OAAO,CAAC;CACzB,CAAC;AAEF,KAAK,OAAO,CAAC,WAAW,SAAS,MAAM,IAAI;IACzC,QAAQ,CAAC,SAAS,EAAE,WAAW,CAAC;IAChC,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACxC,QAAQ,CAAC,WAAW,CAAC,EAAE,QAAQ,CAAC,gBAAgB,CAAC,WAAW,CAAC,EAAE,CAAC;CACjE,CAAC;AAEF,KAAK,kBAAkB,CAAC,WAAW,SAAS,MAAM,IAAI,gBAAgB,GACpE,OAAO,CAAC,WAAW,CAAC,CAAC;AAEvB;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAgB,mCAAmC,CAAC,WAAW,SAAS,MAAM,EAC5E,YAAY,EAAE,kBAAkB,CAAC,WAAW,CAAC,GAC5C,QAAQ,CAAC,eAAe,CAAC,WAAW,EAAE,SAAS,OAAO,EAAE,CAAC,CAAC;AAC7D,wBAAgB,mCAAmC,CAAC,WAAW,SAAS,MAAM,EAC5E,YAAY,EAAE,oBAAoB,CAAC,WAAW,CAAC,GAC9C,QAAQ,CAAC,eAAe,CAAC,WAAW,EAAE,SAAS,OAAO,EAAE,CAAC,CAAC"}

package/dist/convert-annotated-source-to-failure-case.js

@@ -0,0 +1,138 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertAnnotatedSourceToFailureCase = exports.SPECIAL_UNDERLINE_CHARS = void 0;
+/**
+ * When leveraging the convertAnnotatedSourceToFailureCase() utility, the
+ * following characters are eligible to be used in the source code of expected
+ * failure cases within ESLint unit tests in order to provide an easy way to
+ * annotate where one or more ESLint errors are expected to occur within that
+ * source.
+ *
+ * See the convertAnnotatedSourceToFailureCase() utility itself for more details.
+ */
+exports.SPECIAL_UNDERLINE_CHARS = [
+    '~',
+    '^',
+    '#',
+    '%',
+    '¶',
+    '*',
+    '¨',
+    '@',
+];
+function convertAnnotatedSourceToFailureCase(errorOptions) {
+    const messages = 'messageId' in errorOptions
+        ? [{ ...errorOptions, char: '~' }]
+        : errorOptions.messages;
+    let parsedSource = '';
+    const errors = messages.map(({ char: currentValueChar, data, messageId, suggestions }) => {
+        const otherChars = messages
+            .map(({ char }) => char)
+            .filter((char) => char !== currentValueChar);
+        const parsedForChar = parseInvalidSource(errorOptions.annotatedSource, currentValueChar, otherChars);
+        const { failure: { endPosition, startPosition }, } = parsedForChar;
+        parsedSource = parsedForChar.source;
+        if (!endPosition || !startPosition) {
+            throw Error(`Char '${currentValueChar}' has been specified in \`messages\`, however it is not present in the source of the failure case`);
+        }
+        return {
+            data,
+            messageId,
+            line: startPosition.line + 1,
+            column: startPosition.character + 1,
+            endLine: endPosition.line + 1,
+            endColumn: endPosition.character + 1,
+            suggestions,
+        };
+    });
+    return {
+        name: errorOptions.description,
+        code: parsedSource,
+        filename: errorOptions.filename,
+        options: errorOptions.options ?? [],
+        errors,
+        only: errorOptions.only ?? false,
+        output: errorOptions.annotatedOutput
+            ? parseInvalidSource(errorOptions.annotatedOutput).source
+            : null,
+    };
+}
+exports.convertAnnotatedSourceToFailureCase = convertAnnotatedSourceToFailureCase;
+function escapeRegexp(value) {
+    return value.replace(/[-/\\^$*+?.()|[\]{}]/g, '\\$&');
+}
+/**
+ * When testing a failure, we also test to see if the linter will report the correct place where
+ * the source code doesn't match the rule.
+ *
+ * For example, if you use a private property in your template, the linter should report _where_
+ * did it happen. Because it's tedious to supply actual line/column number in the spec, we use
+ * some custom syntax with "underlining" the problematic part with tildes:
+ *
+ * ```
+ * template: '{{ foo }}'
+ *               ~~~
+ * ```
+ *
+ * When giving a spec which we expect to fail, we give it "source code" such as above, with tildes.
+ * We call this kind of source code "annotated". This source code cannot be compiled (and thus
+ * cannot be linted/tested), so we use this function to get rid of tildes, but maintain the
+ * information about where the linter is supposed to catch error.
+ *
+ * The result of the function contains "cleaned" source (`.source`) and a `.failure` object which
+ * contains the `.startPosition` and `.endPosition` of the tildes.
+ *
+ * @param source The annotated source code with tildes.
+ * @param specialChar The character to look for; in the above example that's ~.
+ * @param otherChars All other characters which should be ignored. Used when asserting multiple
+ *                   failures where there are multiple invalid characters.
+ * @returns {{source: string, failure: {message: string, startPosition: null, endPosition: any}}}
+ */
+function parseInvalidSource(source, specialChar = '~', otherChars = []) {
+    let replacedSource;
+    if (otherChars.length === 0) {
+        replacedSource = source;
+    }
+    else {
+        const patternAsStr = `[${otherChars.map(escapeRegexp).join('')}]`;
+        const pattern = RegExp(patternAsStr, 'g');
+        replacedSource = source.replace(pattern, ' ');
+    }
+    let col = 0;
+    let line = 0;
+    let lastCol = 0;
+    let lastLine = 0;
+    let startPosition;
+    for (const currentChar of replacedSource) {
+        if (currentChar === '\n') {
+            col = 0;
+            line++;
+            continue;
+        }
+        col++;
+        if (currentChar !== specialChar)
+            continue;
+        if (!startPosition) {
+            startPosition = {
+                character: col - 1,
+                line: line - 1,
+            };
+        }
+        lastCol = col;
+        lastLine = line - 1;
+    }
+    const endPosition = {
+        character: lastCol,
+        line: lastLine,
+    };
+    const newSource = replacedSource.replace(RegExp(escapeRegexp(specialChar), 'g'), '');
+    return {
+        failure: {
+            endPosition,
+            message: '',
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+            startPosition: startPosition,
+        },
+        source: newSource,
+    };
+}

package/dist/eslint-plugin/ast-utils.d.ts

@@ -77,7 +77,7 @@ export declare const angularLifecycleInterfaceKeys: readonly ("AfterContentCheck
 export declare const angularLifecycleMethodKeys: readonly ("ngAfterContentChecked" | "ngAfterContentInit" | "ngAfterViewChecked" | "ngAfterViewInit" | "ngDoBootstrap" | "ngDoCheck" | "ngOnChanges" | "ngOnDestroy" | "ngOnInit")[];
 /**
  * See lifecycle event sequence:
- * https://angular.dev/guide/components/lifecycle
+ * https://angular.io/guide/lifecycle-hooks#lifecycle-event-sequence
  */
 export declare const angularLifecycleMethodsOrdered: AngularLifecycleMethods[];
 export declare const ANGULAR_CLASS_DECORATOR_LIFECYCLE_METHOD_MAPPER: ReadonlyMap<AngularClassDecoratorKeys, ReadonlySet<AngularLifecycleMethodKeys>>;

package/dist/eslint-plugin/ast-utils.js

@@ -72,7 +72,7 @@ exports.angularLifecycleInterfaceKeys = (0, utils_2.objectKeys)(AngularLifecycle
 exports.angularLifecycleMethodKeys = (0, utils_2.objectKeys)(AngularLifecycleMethods);
 /**
  * See lifecycle event sequence:
- * https://angular.dev/guide/components/lifecycle
+ * https://angular.io/guide/lifecycle-hooks#lifecycle-event-sequence
  */
 exports.angularLifecycleMethodsOrdered = [
     AngularLifecycleMethods.ngOnChanges,

package/dist/eslint-plugin-template/parser-services.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"parser-services.d.ts","sourceRoot":"","sources":["../../src/eslint-plugin-template/parser-services.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,eAAe,EACf,cAAc,EACf,MAAM,0CAA0C,CAAC;AAClD,OAAO,KAAK,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AAEnE,MAAM,WAAW,sBAAsB;IACrC,0BAA0B,EAAE,CAC1B,UAAU,EAAE,eAAe,KACxB,QAAQ,CAAC,cAAc,CAAC;IAC7B,6BAA6B,EAAE,CAC7B,OAAO,EAAE,QAAQ,CAAC,QAAQ,CAAC,WAAW,CAAC,MAAM,EAAE,SAAS,OAAO,EAAE,CAAC,CAAC,EACnE,IAAI,EAAE,cAAc,KACjB,QAAQ,CAAC,cAAc,CAAC;CAC9B;AAED,wBAAgB,yBAAyB,CACvC,OAAO,EAAE,QAAQ,CAAC,QAAQ,CAAC,WAAW,CAAC,MAAM,EAAE,SAAS,OAAO,EAAE,CAAC,CAAC,GAClE,sBAAsB,CAGxB;AAED;;;GAGG;AACH,wBAAgB,oBAAoB,CAClC,OAAO,EAAE,QAAQ,CAAC,QAAQ,CAAC,WAAW,CAAC,MAAM,EAAE,SAAS,OAAO,EAAE,CAAC,CAAC,GAClE,IAAI,CAgBN"}
+{"version":3,"file":"parser-services.d.ts","sourceRoot":"","sources":["../../src/eslint-plugin-template/parser-services.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,eAAe,EACf,cAAc,EACf,MAAM,0CAA0C,CAAC;AAClD,OAAO,KAAK,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AAEnE,MAAM,WAAW,sBAAsB;IACrC,0BAA0B,EAAE,CAC1B,UAAU,EAAE,eAAe,KACxB,QAAQ,CAAC,cAAc,CAAC;IAC7B,6BAA6B,EAAE,CAC7B,OAAO,EAAE,QAAQ,CAAC,QAAQ,CAAC,WAAW,CAAC,MAAM,EAAE,SAAS,OAAO,EAAE,CAAC,CAAC,EACnE,IAAI,EAAE,cAAc,KACjB,QAAQ,CAAC,cAAc,CAAC;CAC9B;AAED,wBAAgB,yBAAyB,CACvC,OAAO,EAAE,QAAQ,CAAC,QAAQ,CAAC,WAAW,CAAC,MAAM,EAAE,SAAS,OAAO,EAAE,CAAC,CAAC,GAClE,sBAAsB,CAGxB;AAED;;;GAGG;AACH,wBAAgB,oBAAoB,CAClC,OAAO,EAAE,QAAQ,CAAC,QAAQ,CAAC,WAAW,CAAC,MAAM,EAAE,SAAS,OAAO,EAAE,CAAC,CAAC,GAClE,IAAI,CAeN"}

package/dist/eslint-plugin-template/parser-services.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ensureTemplateParser = exports.getTemplateParserServices = void 0;
 function getTemplateParserServices(context) {
     ensureTemplateParser(context);
-    return context.sourceCode.parserServices;
+    return context.parserServices;
 }
 exports.getTemplateParserServices = getTemplateParserServices;
 /**
@@ -11,10 +11,10 @@ exports.getTemplateParserServices = getTemplateParserServices;
  * If @angular-eslint/template-parser is not the configured parser when the function is invoked it will throw
  */
 function ensureTemplateParser(context) {
-    const parserServices = context.sourceCode
-        .parserServices;
-    if (!parserServices?.convertNodeSourceSpanToLoc ||
-        !parserServices?.convertElementSourceSpanToLoc) {
+    if (!context.parserServices
+        ?.convertNodeSourceSpanToLoc ||
+        !context.parserServices
+            ?.convertElementSourceSpanToLoc) {
         /**
          * The user needs to have configured "parser" in their eslint config and set it
          * to @angular-eslint/template-parser

package/dist/index.d.ts

@@ -1,3 +1,5 @@
+export * from './convert-annotated-source-to-failure-case';
+export * from './rules-tester';
 export { toHumanReadableText, arrayify, isNotNullOrUndefined, toPattern, kebabToCamelCase, withoutBracketsAndWhitespaces, capitalize, } from './utils';
 export { getAriaAttributeKeys } from './eslint-plugin/get-aria-attribute-keys';
 export { getNativeEventNames } from './eslint-plugin/get-native-event-names';

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,mBAAmB,EACnB,QAAQ,EACR,oBAAoB,EACpB,SAAS,EACT,gBAAgB,EAChB,6BAA6B,EAC7B,UAAU,GACX,MAAM,SAAS,CAAC;AAEjB,OAAO,EAAE,oBAAoB,EAAE,MAAM,yCAAyC,CAAC;AAC/E,OAAO,EAAE,mBAAmB,EAAE,MAAM,wCAAwC,CAAC;AAE7E,OAAO,KAAK,QAAQ,MAAM,2BAA2B,CAAC;AACtD,OAAO,KAAK,SAAS,MAAM,4BAA4B,CAAC;AACxD,OAAO,KAAK,SAAS,MAAM,2BAA2B,CAAC;AACvD,OAAO,KAAK,aAAa,MAAM,gCAAgC,CAAC;AAEhE,YAAY,EAAE,sBAAsB,EAAE,MAAM,0CAA0C,CAAC;AACvF,OAAO,EACL,oBAAoB,EACpB,yBAAyB,GAC1B,MAAM,0CAA0C,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,4CAA4C,CAAC;AAC3D,cAAc,gBAAgB,CAAC;AAE/B,OAAO,EACL,mBAAmB,EACnB,QAAQ,EACR,oBAAoB,EACpB,SAAS,EACT,gBAAgB,EAChB,6BAA6B,EAC7B,UAAU,GACX,MAAM,SAAS,CAAC;AAEjB,OAAO,EAAE,oBAAoB,EAAE,MAAM,yCAAyC,CAAC;AAC/E,OAAO,EAAE,mBAAmB,EAAE,MAAM,wCAAwC,CAAC;AAE7E,OAAO,KAAK,QAAQ,MAAM,2BAA2B,CAAC;AACtD,OAAO,KAAK,SAAS,MAAM,4BAA4B,CAAC;AACxD,OAAO,KAAK,SAAS,MAAM,2BAA2B,CAAC;AACvD,OAAO,KAAK,aAAa,MAAM,gCAAgC,CAAC;AAEhE,YAAY,EAAE,sBAAsB,EAAE,MAAM,0CAA0C,CAAC;AACvF,OAAO,EACL,oBAAoB,EACpB,yBAAyB,GAC1B,MAAM,0CAA0C,CAAC"}

package/dist/index.js

@@ -15,6 +15,9 @@ var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (
 }) : function(o, v) {
     o["default"] = v;
 });
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
 var __importStar = (this && this.__importStar) || function (mod) {
     if (mod && mod.__esModule) return mod;
     var result = {};
@@ -24,6 +27,8 @@ var __importStar = (this && this.__importStar) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getTemplateParserServices = exports.ensureTemplateParser = exports.SelectorUtils = exports.Selectors = exports.RuleFixes = exports.ASTUtils = exports.getNativeEventNames = exports.getAriaAttributeKeys = exports.capitalize = exports.withoutBracketsAndWhitespaces = exports.kebabToCamelCase = exports.toPattern = exports.isNotNullOrUndefined = exports.arrayify = exports.toHumanReadableText = void 0;
+__exportStar(require("./convert-annotated-source-to-failure-case"), exports);
+__exportStar(require("./rules-tester"), exports);
 var utils_1 = require("./utils");
 Object.defineProperty(exports, "toHumanReadableText", { enumerable: true, get: function () { return utils_1.toHumanReadableText; } });
 Object.defineProperty(exports, "arrayify", { enumerable: true, get: function () { return utils_1.arrayify; } });

package/dist/rules-tester.d.ts

@@ -0,0 +1,12 @@
+import { TSESLint } from '@typescript-eslint/utils';
+declare const VALID_PARSERS: readonly ["@angular-eslint/template-parser", "@typescript-eslint/parser"];
+type RuleTesterConfig = Omit<TSESLint.RuleTesterConfig, 'parser'> & {
+    parser: (typeof VALID_PARSERS)[number];
+};
+export declare class RuleTester extends TSESLint.RuleTester {
+    private filename?;
+    constructor(options: RuleTesterConfig);
+    run<TMessageIds extends string, TOptions extends readonly unknown[]>(name: string, rule: TSESLint.RuleModule<TMessageIds, TOptions>, { valid, invalid }: TSESLint.RunTests<TMessageIds, TOptions>): void;
+}
+export {};
+//# sourceMappingURL=rules-tester.d.ts.map

package/dist/rules-tester.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rules-tester.d.ts","sourceRoot":"","sources":["../src/rules-tester.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AAGpD,QAAA,MAAM,aAAa,2EAGT,CAAC;AAEX,KAAK,gBAAgB,GAAG,IAAI,CAAC,QAAQ,CAAC,gBAAgB,EAAE,QAAQ,CAAC,GAAG;IAClE,MAAM,EAAE,CAAC,OAAO,aAAa,CAAC,CAAC,MAAM,CAAC,CAAC;CACxC,CAAC;AAYF,qBAAa,UAAW,SAAQ,QAAQ,CAAC,UAAU;IACjD,OAAO,CAAC,QAAQ,CAAC,CAAS;gBAKd,OAAO,EAAE,gBAAgB;IA8B5B,GAAG,CAAC,WAAW,SAAS,MAAM,EAAE,QAAQ,SAAS,SAAS,OAAO,EAAE,EAC1E,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,QAAQ,CAAC,UAAU,CAAC,WAAW,EAAE,QAAQ,CAAC,EAChD,EAAE,KAAK,EAAE,OAAO,EAAE,EAAE,QAAQ,CAAC,QAAQ,CAAC,WAAW,EAAE,QAAQ,CAAC,GAC3D,IAAI;CA0BR"}

package/dist/rules-tester.js

@@ -0,0 +1,93 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RuleTester = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+const path = __importStar(require("path"));
+const VALID_PARSERS = [
+    '@angular-eslint/template-parser',
+    '@typescript-eslint/parser',
+];
+function getFixturesRootDir() {
+    return path.join(process.cwd(), 'tests/fixtures/');
+}
+function isValidParser(parser) {
+    return VALID_PARSERS.includes(parser);
+}
+class RuleTester extends utils_1.TSESLint.RuleTester {
+    filename;
+    // as of eslint 6 you have to provide an absolute path to the parser
+    // but that's not as clean to type, this saves us trying to manually enforce
+    // that contributors require.resolve everything
+    constructor(options) {
+        super({
+            ...options,
+            parser: require.resolve(options.parser),
+        });
+        if (options.parserOptions?.project) {
+            this.filename = path.join(options.parserOptions?.tsconfigRootDir ?? getFixturesRootDir(), 'file.ts');
+        }
+        // make sure that the parser doesn't hold onto file handles between tests
+        // on linux (i.e. our CI env), there can be very a limited number of watch handles available
+        afterAll(() => {
+            try {
+                // instead of creating a hard dependency, just use a soft require
+                // a bit weird, but if they're using this tooling, it'll be installed
+                // eslint-disable-next-line @typescript-eslint/no-var-requires
+                require(options.parser).clearCaches();
+            }
+            catch {
+                // ignored
+            }
+        });
+    }
+    // as of eslint 6 you have to provide an absolute path to the parser
+    // If you don't do that at the test level, the test will fail somewhat cryptically...
+    // This is a lot more explicit
+    run(name, rule, { valid, invalid }) {
+        const errorMessage = `Do not set the parser at the test level unless you want to use a parser other than ${VALID_PARSERS.join(', ')}`;
+        const parsedTests = {
+            valid: valid.map((test) => {
+                if (typeof test !== 'string' && isValidParser(test.parser)) {
+                    throw Error(errorMessage);
+                }
+                return typeof test === 'string'
+                    ? { code: test, filename: this.filename }
+                    : { ...test, filename: test.filename ?? this.filename };
+            }),
+            invalid: invalid.map((test) => {
+                if (isValidParser(test.parser)) {
+                    throw Error(errorMessage);
+                }
+                return {
+                    ...test,
+                    filename: test.filename ?? this.filename,
+                };
+            }),
+        };
+        super.run(name, rule, parsedTests);
+    }
+}
+exports.RuleTester = RuleTester;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@angular-eslint/utils",
-  "version": "17.5.3-alpha.1",
+  "version": "17.5.3",
   "license": "MIT",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -17,12 +17,12 @@
     "LICENSE"
   ],
   "peerDependencies": {
-    "eslint": "^8.57.0 || ^9.0.0",
+    "eslint": "^7.20.0 || ^8.0.0",
     "typescript": "*"
   },
   "dependencies": {
-    "@angular-eslint/bundled-angular-compiler": "17.5.3-alpha.1",
-    "@typescript-eslint/utils": "8.0.0-alpha.20"
+    "@angular-eslint/bundled-angular-compiler": "17.5.3",
+    "@typescript-eslint/utils": "7.11.0"
   },
   "gitHead": "e2006e5e9c99e5a943d1a999e0efa5247d29ec24"
 }