@depup/angular-eslint__utils 21.3.1-depup.0

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

@@ -0,0 +1,269 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getApplicableConfig = exports.normalizeOptionsToConfigs = exports.isMultipleConfigOption = exports.checkSelector = exports.checkValidOptions = exports.getActualSelectorType = exports.parseSelectorNode = exports.reportTypeError = exports.reportStyleAndPrefixError = exports.reportStyleError = exports.reportSelectorAfterPrefixError = exports.reportPrefixError = exports.SelectorValidator = exports.OPTION_TYPE_ELEMENT = exports.OPTION_TYPE_ATTRS = exports.OPTION_TYPE_ATTRIBUTE = void 0;
+const bundled_angular_compiler_1 = require("@angular-eslint/bundled-angular-compiler");
+const ast_utils_1 = require("./ast-utils");
+const utils_1 = require("../utils");
+exports.OPTION_TYPE_ATTRIBUTE = 'attribute';
+exports.OPTION_TYPE_ATTRS = 'attrs';
+exports.OPTION_TYPE_ELEMENT = 'element';
+const SELECTOR_TYPE_MAPPER = {
+    [exports.OPTION_TYPE_ATTRIBUTE]: exports.OPTION_TYPE_ATTRS,
+    [exports.OPTION_TYPE_ELEMENT]: exports.OPTION_TYPE_ELEMENT,
+};
+exports.SelectorValidator = {
+    attribute(selector) {
+        return selector.length !== 0;
+    },
+    camelCase(selector) {
+        return /^[a-zA-Z0-9[\]]+$/.test(selector);
+    },
+    element(selector) {
+        return selector !== null;
+    },
+    kebabCase(selector) {
+        return /^[a-z0-9]+(-[a-z0-9]+)*$/.test(selector);
+    },
+    prefixRegex(prefix) {
+        return new RegExp(`^\\[?(${prefix})`);
+    },
+    prefix(prefix, selectorStyle) {
+        const regex = this.prefixRegex(prefix);
+        return (selector) => {
+            if (!prefix)
+                return true;
+            if (!regex.test(selector))
+                return false;
+            const selectorAfterPrefix = selector.replace(regex, '');
+            if (selectorStyle === ast_utils_1.OPTION_STYLE_CAMEL_CASE) {
+                return (!selectorAfterPrefix ||
+                    selectorAfterPrefix[0] === selectorAfterPrefix[0].toUpperCase());
+            }
+            else if (selectorStyle === ast_utils_1.OPTION_STYLE_KEBAB_CASE) {
+                return !selectorAfterPrefix || selectorAfterPrefix[0] === '-';
+            }
+            throw Error('Invalid selector style!');
+        };
+    },
+    selectorAfterPrefix(prefix) {
+        const regex = this.prefixRegex(prefix);
+        return (selector) => {
+            const selectorAfterPrefix = selector.replace(regex, '');
+            return Boolean(selectorAfterPrefix);
+        };
+    },
+};
+const getValidSelectors = (selectors, types) => {
+    return selectors.reduce((previousValue, currentValue) => {
+        const validSelectors = types.reduce((accumulator, type) => {
+            const value = currentValue[type];
+            return value ? accumulator.concat(value) : accumulator;
+        }, []);
+        return previousValue.concat(validSelectors);
+    }, []);
+};
+const reportPrefixError = (node, prefix, context) => {
+    const prefixArray = prefix ? (0, utils_1.arrayify)(prefix) : [];
+    context.report({
+        node,
+        messageId: 'prefixFailure',
+        data: {
+            prefix: (0, utils_1.toHumanReadableText)(prefixArray),
+        },
+    });
+};
+exports.reportPrefixError = reportPrefixError;
+const reportSelectorAfterPrefixError = (node, prefix, context) => {
+    const prefixArray = prefix ? (0, utils_1.arrayify)(prefix) : [];
+    context.report({
+        node,
+        messageId: 'selectorAfterPrefixFailure',
+        data: {
+            prefix: (0, utils_1.toHumanReadableText)(prefixArray),
+        },
+    });
+};
+exports.reportSelectorAfterPrefixError = reportSelectorAfterPrefixError;
+const reportStyleError = (node, style, context) => {
+    context.report({
+        node,
+        messageId: 'styleFailure',
+        data: {
+            style,
+        },
+    });
+};
+exports.reportStyleError = reportStyleError;
+const reportStyleAndPrefixError = (node, style, prefix, context) => {
+    const prefixArray = prefix ? (0, utils_1.arrayify)(prefix) : [];
+    context.report({
+        node,
+        messageId: 'styleAndPrefixFailure',
+        data: {
+            style,
+            prefix: (0, utils_1.toHumanReadableText)(prefixArray),
+        },
+    });
+};
+exports.reportStyleAndPrefixError = reportStyleAndPrefixError;
+const reportTypeError = (node, type, context) => {
+    context.report({
+        node,
+        messageId: 'typeFailure',
+        data: {
+            type,
+        },
+    });
+};
+exports.reportTypeError = reportTypeError;
+const parseSelectorNode = (node) => {
+    if ((0, ast_utils_1.isLiteral)(node)) {
+        return bundled_angular_compiler_1.CssSelector.parse(node.raw);
+    }
+    else if ((0, ast_utils_1.isTemplateLiteral)(node) && node.quasis[0]) {
+        return bundled_angular_compiler_1.CssSelector.parse(node.quasis[0].value.raw);
+    }
+    return null;
+};
+exports.parseSelectorNode = parseSelectorNode;
+const getActualSelectorType = (node) => {
+    const listSelectors = (0, exports.parseSelectorNode)(node);
+    if (!listSelectors || listSelectors.length === 0) {
+        return null;
+    }
+    // Check the first selector to determine type
+    const firstSelector = listSelectors[0];
+    // Attribute selectors have attrs populated (e.g., [appFoo])
+    // CssSelector.attrs is an array where each attribute is stored as [name, value]
+    if (Array.isArray(firstSelector.attrs) && firstSelector.attrs.length > 0) {
+        return exports.OPTION_TYPE_ATTRIBUTE;
+    }
+    // Element selectors have a non-null, non-empty element (e.g., app-foo)
+    if (firstSelector.element != null &&
+        firstSelector.element !== '' &&
+        firstSelector.element !== '*') {
+        return exports.OPTION_TYPE_ELEMENT;
+    }
+    return null;
+};
+exports.getActualSelectorType = getActualSelectorType;
+const checkValidOptions = (type, prefix, style) => {
+    // Get options
+    const typeOption = (0, utils_1.arrayify)(type);
+    const styleOption = style;
+    // Check if options are valid
+    const isTypeOptionValid = typeOption.length > 0 &&
+        typeOption.every((argument) => [exports.OPTION_TYPE_ELEMENT, exports.OPTION_TYPE_ATTRIBUTE].indexOf(argument) !== -1);
+    // Prefix is optional - allow undefined, empty string, or empty array
+    // If provided, it should be non-empty
+    const isPrefixOptionValid = prefix === undefined ||
+        prefix === '' ||
+        (Array.isArray(prefix) && prefix.length === 0) ||
+        prefix.length > 0;
+    const isStyleOptionValid = [ast_utils_1.OPTION_STYLE_CAMEL_CASE, ast_utils_1.OPTION_STYLE_KEBAB_CASE].indexOf(styleOption) !==
+        -1;
+    return isTypeOptionValid && isPrefixOptionValid && isStyleOptionValid;
+};
+exports.checkValidOptions = checkValidOptions;
+const checkSelector = (node, typeOption, prefixOption, styleOption, parsedSelectors) => {
+    // Get valid list of selectors
+    const types = (0, utils_1.arrayify)(typeOption || [exports.OPTION_TYPE_ATTRS, exports.OPTION_TYPE_ELEMENT]).reduce((previousValue, currentValue) => previousValue.concat(SELECTOR_TYPE_MAPPER[currentValue]), []);
+    const styleValidator = styleOption === ast_utils_1.OPTION_STYLE_KEBAB_CASE
+        ? exports.SelectorValidator.kebabCase
+        : exports.SelectorValidator.camelCase;
+    // Use provided parsed selectors or parse them
+    const listSelectors = parsedSelectors ?? (0, exports.parseSelectorNode)(node);
+    if (!listSelectors) {
+        return null;
+    }
+    const validSelectors = getValidSelectors(listSelectors, types);
+    // If no prefix is required (empty or undefined), consider prefix check as passed
+    const prefixArray = prefixOption ? (0, utils_1.arrayify)(prefixOption) : [];
+    const hasExpectedPrefix = !prefixOption ||
+        prefixArray.length === 0 ||
+        validSelectors.some((selector) => prefixArray.some((prefix) => exports.SelectorValidator.prefix(prefix, styleOption)(selector)));
+    // Style validation should ONLY check if the selector matches the style pattern
+    const hasExpectedStyle = validSelectors.some((selector) => styleValidator(selector));
+    const hasExpectedType = validSelectors.length > 0;
+    // Only check for selector after prefix if prefix is actually required
+    const hasSelectorAfterPrefix = !prefixOption ||
+        prefixArray.length === 0 ||
+        validSelectors.some((selector) => {
+            return prefixArray.some((prefix) => {
+                return exports.SelectorValidator.selectorAfterPrefix(prefix)(selector);
+            });
+        });
+    return {
+        hasExpectedPrefix,
+        hasExpectedType,
+        hasExpectedStyle,
+        hasSelectorAfterPrefix,
+    };
+};
+exports.checkSelector = checkSelector;
+// Type guard for multiple configs
+const isMultipleConfigOption = (option) => {
+    return (Array.isArray(option) &&
+        option.length >= 1 &&
+        option.length <= 2 &&
+        option.every((config) => typeof config.type === 'string'));
+};
+exports.isMultipleConfigOption = isMultipleConfigOption;
+// Normalize options to a consistent format
+const normalizeOptionsToConfigs = (option) => {
+    const configByType = new Map();
+    if ((0, exports.isMultipleConfigOption)(option)) {
+        // Validate no duplicate types
+        const types = option.map((config) => config.type);
+        if (new Set(types).size !== types.length) {
+            throw new Error('Invalid rule config: Each config object in the options array must have a unique "type" property (either "element" or "attribute")');
+        }
+        // Build lookup map by type
+        for (const config of option) {
+            configByType.set(config.type, config);
+        }
+    }
+    else {
+        // Single config - normalize to map format
+        // Handle both single type and array of types
+        const types = (0, utils_1.arrayify)(option.type);
+        for (const type of types) {
+            configByType.set(type, {
+                type,
+                prefix: option.prefix,
+                style: option.style,
+            });
+        }
+    }
+    return configByType;
+};
+exports.normalizeOptionsToConfigs = normalizeOptionsToConfigs;
+/**
+ * Get the applicable config for a given selector node
+ */
+const getApplicableConfig = (rawSelectors, configByType) => {
+    // For multiple configs, determine the actual selector type
+    let applicableConfig = null;
+    if (configByType.size > 1) {
+        // Multiple configs - need to determine which one applies
+        const actualType = (0, exports.getActualSelectorType)(rawSelectors);
+        if (!actualType) {
+            return null;
+        }
+        const config = configByType.get(actualType);
+        if (!config) {
+            // No config defined for this selector type
+            return null;
+        }
+        applicableConfig = config;
+    }
+    else {
+        // Single config or single type extracted from array
+        const firstEntry = configByType.entries().next();
+        if (!firstEntry.done) {
+            applicableConfig = firstEntry.value[1];
+        }
+    }
+    return applicableConfig;
+};
+exports.getApplicableConfig = getApplicableConfig;

package/dist/eslint-plugin/selectors.d.ts

@@ -0,0 +1,28 @@
+export declare const COMPONENT_OR_DIRECTIVE_CLASS_DECORATOR = "ClassDeclaration > Decorator[expression.callee.name=/^(Component|Directive)$/]";
+export declare const COMPONENT_CLASS_DECORATOR = "ClassDeclaration > Decorator[expression.callee.name=\"Component\"]";
+export declare const DIRECTIVE_CLASS_DECORATOR = "ClassDeclaration > Decorator[expression.callee.name=\"Directive\"]";
+export declare const PIPE_CLASS_DECORATOR = "ClassDeclaration > Decorator[expression.callee.name=\"Pipe\"]";
+export declare const INJECTABLE_CLASS_DECORATOR = "ClassDeclaration > Decorator[expression.callee.name=\"Injectable\"]";
+export declare const MODULE_CLASS_DECORATOR = "ClassDeclaration > Decorator[expression.callee.name=\"NgModule\"]";
+export declare const INPUT_DECORATOR = "Decorator[expression.callee.name=\"Input\"]";
+export declare const OUTPUT_DECORATOR = "Decorator[expression.callee.name=\"Output\"]";
+export declare const HOST_BINDING_DECORATOR = "Decorator[expression.callee.name=\"HostBinding\"]";
+export declare const HOST_LISTENER_DECORATOR = "Decorator[expression.callee.name=\"HostListener\"]";
+export declare const LITERAL_OR_TEMPLATE_ELEMENT = ":matches(Literal, TemplateElement)";
+export declare const ALIAS_PROPERTY_VALUE = "ObjectExpression > Property[key.name='alias'] :matches(Literal, TemplateElement)";
+export declare function decoratorDefinition(decoratorName: RegExp): string;
+export declare function decoratorDefinition<TDecoratorName extends string>(decoratorName: TDecoratorName): `ClassDeclaration:has(Decorator[expression.callee.name=${TDecoratorName}])`;
+export declare function metadataProperty(key: RegExp): string;
+export declare function metadataProperty<TKey extends string>(key: TKey): `Property:matches([key.name=${TKey}][computed=false], [key.value=${TKey}], [key.quasis.0.value.raw=${TKey}])`;
+export declare function methodDefinition(key: RegExp): string;
+export declare function methodDefinition<TKey extends string>(key: TKey): `MethodDefinition:matches([key.name=${TKey}][computed=false], [key.value=${TKey}], [key.quasis.0.value.raw=${TKey}])`;
+export declare const COMPONENT_SELECTOR_LITERAL: string;
+export declare const DIRECTIVE_SELECTOR_LITERAL: string;
+export declare const COMPONENT_OR_DIRECTIVE_SELECTOR_LITERAL: string;
+export declare const INPUTS_METADATA_PROPERTY_LITERAL: string;
+export declare const INPUT_ALIAS: string;
+export declare const INPUT_PROPERTY_OR_SETTER = ":matches(PropertyDefinition, MethodDefinition[kind='set'])[computed=false]:has(Decorator[expression.callee.name=\"Input\"]) > :matches(Identifier, Literal)";
+export declare const OUTPUTS_METADATA_PROPERTY_LITERAL: string;
+export declare const OUTPUT_ALIAS: string;
+export declare const OUTPUT_PROPERTY_OR_GETTER: string;
+//# sourceMappingURL=selectors.d.ts.map

package/dist/eslint-plugin/selectors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"selectors.d.ts","sourceRoot":"","sources":["../../src/eslint-plugin/selectors.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,sCAAsC,mFAC+B,CAAC;AAEnF,eAAO,MAAM,yBAAyB,uEAC8B,CAAC;AAErE,eAAO,MAAM,yBAAyB,uEAC8B,CAAC;AAErE,eAAO,MAAM,oBAAoB,kEAC8B,CAAC;AAEhE,eAAO,MAAM,0BAA0B,wEAC8B,CAAC;AAEtE,eAAO,MAAM,sBAAsB,sEACgC,CAAC;AAEpE,eAAO,MAAM,eAAe,gDAA8C,CAAC;AAE3E,eAAO,MAAM,gBAAgB,iDAA+C,CAAC;AAE7E,eAAO,MAAM,sBAAsB,sDACgB,CAAC;AACpD,eAAO,MAAM,uBAAuB,uDACgB,CAAC;AAErD,eAAO,MAAM,2BAA2B,uCAAuC,CAAC;AAEhF,eAAO,MAAM,oBAAoB,qFAAiF,CAAC;AAEnH,wBAAgB,mBAAmB,CAAC,aAAa,EAAE,MAAM,GAAG,MAAM,CAAC;AACnE,wBAAgB,mBAAmB,CAAC,cAAc,SAAS,MAAM,EAC/D,aAAa,EAAE,cAAc,GAC5B,yDAAyD,cAAc,IAAI,CAAC;AAK/E,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAAC;AACtD,wBAAgB,gBAAgB,CAAC,IAAI,SAAS,MAAM,EAClD,GAAG,EAAE,IAAI,GACR,8BAA8B,IAAI,iCAAiC,IAAI,8BAA8B,IAAI,IAAI,CAAC;AAKjH,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAAC;AACtD,wBAAgB,gBAAgB,CAAC,IAAI,SAAS,MAAM,EAClD,GAAG,EAAE,IAAI,GACR,sCAAsC,IAAI,iCAAiC,IAAI,8BAA8B,IAAI,IAAI,CAAC;AAKzH,eAAO,MAAM,0BAA0B,QAEL,CAAC;AAEnC,eAAO,MAAM,0BAA0B,QAEL,CAAC;AAEnC,eAAO,MAAM,uCAAuC,QAA2E,CAAC;AAEhI,eAAO,MAAM,gCAAgC,QAEO,CAAC;AAErD,eAAO,MAAM,WAAW,QAMb,CAAC;AAEZ,eAAO,MAAM,wBAAwB,gKAAuI,CAAC;AAE7K,eAAO,MAAM,iCAAiC,QAEM,CAAC;AAErD,eAAO,MAAM,YAAY,QAGd,CAAC;AAEZ,eAAO,MAAM,yBAAyB,QAG3B,CAAC"}

package/dist/eslint-plugin/selectors.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OUTPUT_PROPERTY_OR_GETTER = exports.OUTPUT_ALIAS = exports.OUTPUTS_METADATA_PROPERTY_LITERAL = exports.INPUT_PROPERTY_OR_SETTER = exports.INPUT_ALIAS = exports.INPUTS_METADATA_PROPERTY_LITERAL = exports.COMPONENT_OR_DIRECTIVE_SELECTOR_LITERAL = exports.DIRECTIVE_SELECTOR_LITERAL = exports.COMPONENT_SELECTOR_LITERAL = exports.ALIAS_PROPERTY_VALUE = exports.LITERAL_OR_TEMPLATE_ELEMENT = exports.HOST_LISTENER_DECORATOR = exports.HOST_BINDING_DECORATOR = exports.OUTPUT_DECORATOR = exports.INPUT_DECORATOR = exports.MODULE_CLASS_DECORATOR = exports.INJECTABLE_CLASS_DECORATOR = exports.PIPE_CLASS_DECORATOR = exports.DIRECTIVE_CLASS_DECORATOR = exports.COMPONENT_CLASS_DECORATOR = exports.COMPONENT_OR_DIRECTIVE_CLASS_DECORATOR = void 0;
+exports.decoratorDefinition = decoratorDefinition;
+exports.metadataProperty = metadataProperty;
+exports.methodDefinition = methodDefinition;
+exports.COMPONENT_OR_DIRECTIVE_CLASS_DECORATOR = 'ClassDeclaration > Decorator[expression.callee.name=/^(Component|Directive)$/]';
+exports.COMPONENT_CLASS_DECORATOR = 'ClassDeclaration > Decorator[expression.callee.name="Component"]';
+exports.DIRECTIVE_CLASS_DECORATOR = 'ClassDeclaration > Decorator[expression.callee.name="Directive"]';
+exports.PIPE_CLASS_DECORATOR = 'ClassDeclaration > Decorator[expression.callee.name="Pipe"]';
+exports.INJECTABLE_CLASS_DECORATOR = 'ClassDeclaration > Decorator[expression.callee.name="Injectable"]';
+exports.MODULE_CLASS_DECORATOR = 'ClassDeclaration > Decorator[expression.callee.name="NgModule"]';
+exports.INPUT_DECORATOR = 'Decorator[expression.callee.name="Input"]';
+exports.OUTPUT_DECORATOR = 'Decorator[expression.callee.name="Output"]';
+exports.HOST_BINDING_DECORATOR = 'Decorator[expression.callee.name="HostBinding"]';
+exports.HOST_LISTENER_DECORATOR = 'Decorator[expression.callee.name="HostListener"]';
+exports.LITERAL_OR_TEMPLATE_ELEMENT = ':matches(Literal, TemplateElement)';
+exports.ALIAS_PROPERTY_VALUE = `ObjectExpression > Property[key.name='alias'] ${exports.LITERAL_OR_TEMPLATE_ELEMENT}`;
+function decoratorDefinition(decoratorName) {
+    return `ClassDeclaration:has(Decorator[expression.callee.name=${decoratorName}])`;
+}
+function metadataProperty(key) {
+    return `Property:matches([key.name=${key}][computed=false], [key.value=${key}], [key.quasis.0.value.raw=${key}])`;
+}
+function methodDefinition(key) {
+    return `MethodDefinition:matches([key.name=${key}][computed=false], [key.value=${key}], [key.quasis.0.value.raw=${key}])`;
+}
+exports.COMPONENT_SELECTOR_LITERAL = `${exports.COMPONENT_CLASS_DECORATOR} ${metadataProperty('selector')} ${exports.LITERAL_OR_TEMPLATE_ELEMENT}`;
+exports.DIRECTIVE_SELECTOR_LITERAL = `${exports.DIRECTIVE_CLASS_DECORATOR} ${metadataProperty('selector')} ${exports.LITERAL_OR_TEMPLATE_ELEMENT}`;
+exports.COMPONENT_OR_DIRECTIVE_SELECTOR_LITERAL = `:matches(${exports.COMPONENT_SELECTOR_LITERAL}, ${exports.DIRECTIVE_SELECTOR_LITERAL})`;
+exports.INPUTS_METADATA_PROPERTY_LITERAL = `${exports.COMPONENT_OR_DIRECTIVE_CLASS_DECORATOR} ${metadataProperty('inputs')} > ArrayExpression ${exports.LITERAL_OR_TEMPLATE_ELEMENT}`;
+exports.INPUT_ALIAS = [
+    `:matches(PropertyDefinition, MethodDefinition[kind='set']) ${exports.INPUT_DECORATOR} > CallExpression > Literal`,
+    `:matches(PropertyDefinition, MethodDefinition[kind='set']) ${exports.INPUT_DECORATOR} > CallExpression > TemplateLiteral > TemplateElement`,
+    `:matches(PropertyDefinition, MethodDefinition[kind='set']) ${exports.INPUT_DECORATOR} > CallExpression > ${exports.ALIAS_PROPERTY_VALUE}`,
+    `PropertyDefinition > CallExpression[callee.name='input'] > ${exports.ALIAS_PROPERTY_VALUE}`,
+    `PropertyDefinition > CallExpression:has(MemberExpression[object.name='input'][property.name='required']) > ${exports.ALIAS_PROPERTY_VALUE}`,
+].join(',');
+exports.INPUT_PROPERTY_OR_SETTER = `:matches(PropertyDefinition, MethodDefinition[kind='set'])[computed=false]:has(${exports.INPUT_DECORATOR}) > :matches(Identifier, Literal)`;
+exports.OUTPUTS_METADATA_PROPERTY_LITERAL = `${exports.COMPONENT_OR_DIRECTIVE_CLASS_DECORATOR} ${metadataProperty('outputs')} > ArrayExpression ${exports.LITERAL_OR_TEMPLATE_ELEMENT}`;
+exports.OUTPUT_ALIAS = [
+    `:matches(PropertyDefinition, MethodDefinition[kind='get']) ${exports.OUTPUT_DECORATOR} ${exports.LITERAL_OR_TEMPLATE_ELEMENT}`,
+    `PropertyDefinition > CallExpression[callee.name='output'] > ${exports.ALIAS_PROPERTY_VALUE}`,
+].join(',');
+exports.OUTPUT_PROPERTY_OR_GETTER = [
+    `:matches(PropertyDefinition, MethodDefinition[kind='get'])[computed=false]:has(${exports.OUTPUT_DECORATOR}) > :matches(Identifier, Literal)`,
+    `PropertyDefinition[computed=false]:has(CallExpression[callee.name='output']) > :matches(Identifier, Literal)`,
+].join(',');

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

@@ -0,0 +1,13 @@
+import type { ParseSourceSpan, TmplAstElement } from '@angular-eslint/bundled-angular-compiler';
+import type { TSESLint, TSESTree } from '@typescript-eslint/utils';
+export interface TemplateParserServices {
+    convertNodeSourceSpanToLoc: (sourceSpan: ParseSourceSpan) => TSESTree.SourceLocation;
+    convertElementSourceSpanToLoc: (context: Readonly<TSESLint.RuleContext<string, readonly unknown[]>>, node: TmplAstElement) => TSESTree.SourceLocation;
+}
+export declare function getTemplateParserServices(context: Readonly<TSESLint.RuleContext<string, readonly unknown[]>>): TemplateParserServices;
+/**
+ * Utility for rule authors to ensure that their rule is correctly being used with @angular-eslint/template-parser
+ * If @angular-eslint/template-parser is not the configured parser when the function is invoked it will throw
+ */
+export declare function ensureTemplateParser(context: Readonly<TSESLint.RuleContext<string, readonly unknown[]>>): void;
+//# sourceMappingURL=parser-services.d.ts.map

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

@@ -0,0 +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"}

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

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTemplateParserServices = getTemplateParserServices;
+exports.ensureTemplateParser = ensureTemplateParser;
+function getTemplateParserServices(context) {
+    ensureTemplateParser(context);
+    return context.sourceCode.parserServices;
+}
+/**
+ * Utility for rule authors to ensure that their rule is correctly being used with @angular-eslint/template-parser
+ * 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) {
+        /**
+         * The user needs to have configured "parser" in their eslint config and set it
+         * to @angular-eslint/template-parser
+         */
+        throw new Error("You have used a rule which requires '@angular-eslint/template-parser' to be used as the 'parser' in your ESLint config.");
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,11 @@
+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';
+export * as ASTUtils from './eslint-plugin/ast-utils';
+export * as CommentUtils from './eslint-plugin/comment-utils';
+export * as RuleFixes from './eslint-plugin/rule-fixes';
+export * as Selectors from './eslint-plugin/selectors';
+export * as SelectorUtils from './eslint-plugin/selector-utils';
+export type { TemplateParserServices } from './eslint-plugin-template/parser-services';
+export { ensureTemplateParser, getTemplateParserServices, } from './eslint-plugin-template/parser-services';
+//# 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":"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,YAAY,MAAM,+BAA+B,CAAC;AAC9D,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

@@ -0,0 +1,56 @@
+"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 () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTemplateParserServices = exports.ensureTemplateParser = exports.SelectorUtils = exports.Selectors = exports.RuleFixes = exports.CommentUtils = exports.ASTUtils = exports.getNativeEventNames = exports.getAriaAttributeKeys = exports.capitalize = exports.withoutBracketsAndWhitespaces = exports.kebabToCamelCase = exports.toPattern = exports.isNotNullOrUndefined = exports.arrayify = exports.toHumanReadableText = void 0;
+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; } });
+Object.defineProperty(exports, "isNotNullOrUndefined", { enumerable: true, get: function () { return utils_1.isNotNullOrUndefined; } });
+Object.defineProperty(exports, "toPattern", { enumerable: true, get: function () { return utils_1.toPattern; } });
+Object.defineProperty(exports, "kebabToCamelCase", { enumerable: true, get: function () { return utils_1.kebabToCamelCase; } });
+Object.defineProperty(exports, "withoutBracketsAndWhitespaces", { enumerable: true, get: function () { return utils_1.withoutBracketsAndWhitespaces; } });
+Object.defineProperty(exports, "capitalize", { enumerable: true, get: function () { return utils_1.capitalize; } });
+var get_aria_attribute_keys_1 = require("./eslint-plugin/get-aria-attribute-keys");
+Object.defineProperty(exports, "getAriaAttributeKeys", { enumerable: true, get: function () { return get_aria_attribute_keys_1.getAriaAttributeKeys; } });
+var get_native_event_names_1 = require("./eslint-plugin/get-native-event-names");
+Object.defineProperty(exports, "getNativeEventNames", { enumerable: true, get: function () { return get_native_event_names_1.getNativeEventNames; } });
+exports.ASTUtils = __importStar(require("./eslint-plugin/ast-utils"));
+exports.CommentUtils = __importStar(require("./eslint-plugin/comment-utils"));
+exports.RuleFixes = __importStar(require("./eslint-plugin/rule-fixes"));
+exports.Selectors = __importStar(require("./eslint-plugin/selectors"));
+exports.SelectorUtils = __importStar(require("./eslint-plugin/selector-utils"));
+var parser_services_1 = require("./eslint-plugin-template/parser-services");
+Object.defineProperty(exports, "ensureTemplateParser", { enumerable: true, get: function () { return parser_services_1.ensureTemplateParser; } });
+Object.defineProperty(exports, "getTemplateParserServices", { enumerable: true, get: function () { return parser_services_1.getTemplateParserServices; } });

package/dist/utils.d.ts

@@ -0,0 +1,27 @@
+/**
+ * ===============================================================================
+ *
+ * This file contains general purpose utilities which are not specific to one of
+ * the plugins.
+ *
+ * ===============================================================================
+ */
+/**
+ * Return the last item of the given array.
+ */
+export declare function getLast<T extends readonly unknown[]>(items: T): T[number];
+export declare const objectKeys: <T>(o: T) => readonly Extract<keyof T, string>[];
+/**
+ * Enforces the invariant that the input is an array.
+ */
+export declare function arrayify<T>(value: T | readonly T[]): readonly T[];
+export declare const isNotNullOrUndefined: <T>(input: null | undefined | T) => input is T;
+export declare const kebabToCamelCase: (value: string) => string;
+/**
+ * Convert an array to human-readable text.
+ */
+export declare const toHumanReadableText: (items: readonly string[]) => string;
+export declare const toPattern: (value: readonly unknown[]) => RegExp;
+export declare function capitalize<T extends string>(text: T): Capitalize<T>;
+export declare function withoutBracketsAndWhitespaces(text: string): string;
+//# sourceMappingURL=utils.d.ts.map

package/dist/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../src/utils.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH;;GAEG;AACH,wBAAgB,OAAO,CAAC,CAAC,SAAS,SAAS,OAAO,EAAE,EAAE,KAAK,EAAE,CAAC,GAAG,CAAC,CAAC,MAAM,CAAC,CAEzE;AAED,eAAO,MAAM,UAAU,EAAkB,CAAC,CAAC,EACzC,CAAC,EAAE,CAAC,KACD,SAAS,OAAO,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC,EAAE,CAAC;AAEzC;;GAEG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,SAAS,CAAC,EAAE,GAAG,SAAS,CAAC,EAAE,CAKjE;AAID,eAAO,MAAM,oBAAoB,GAAI,CAAC,EACpC,OAAO,IAAI,GAAG,SAAS,GAAG,CAAC,KAC1B,KAAK,IAAI,CAA0C,CAAC;AAEvD,eAAO,MAAM,gBAAgB,GAAI,OAAO,MAAM,KAAG,MAG9C,CAAC;AAEJ;;GAEG;AACH,eAAO,MAAM,mBAAmB,GAAI,OAAO,SAAS,MAAM,EAAE,KAAG,MAW9D,CAAC;AAEF,eAAO,MAAM,SAAS,GAAI,OAAO,SAAS,OAAO,EAAE,KAAG,MACpB,CAAC;AAEnC,wBAAgB,UAAU,CAAC,CAAC,SAAS,MAAM,EAAE,IAAI,EAAE,CAAC,GAAG,UAAU,CAAC,CAAC,CAAC,CAEnE;AAED,wBAAgB,6BAA6B,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAElE"}

package/dist/utils.js

@@ -0,0 +1,59 @@
+"use strict";
+/**
+ * ===============================================================================
+ *
+ * This file contains general purpose utilities which are not specific to one of
+ * the plugins.
+ *
+ * ===============================================================================
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toPattern = exports.toHumanReadableText = exports.kebabToCamelCase = exports.isNotNullOrUndefined = exports.objectKeys = void 0;
+exports.getLast = getLast;
+exports.arrayify = arrayify;
+exports.capitalize = capitalize;
+exports.withoutBracketsAndWhitespaces = withoutBracketsAndWhitespaces;
+/**
+ * Return the last item of the given array.
+ */
+function getLast(items) {
+    return items.slice(-1)[0];
+}
+exports.objectKeys = Object.keys;
+/**
+ * Enforces the invariant that the input is an array.
+ */
+function arrayify(value) {
+    if (Array.isArray(value)) {
+        return value;
+    }
+    return (value ? [value] : []);
+}
+// Needed because in the current Typescript version (TS 3.3.3333), Boolean() cannot be used to perform a null check.
+// For more, see: https://github.com/Microsoft/TypeScript/issues/16655
+const isNotNullOrUndefined = (input) => input !== null && input !== undefined;
+exports.isNotNullOrUndefined = isNotNullOrUndefined;
+const kebabToCamelCase = (value) => value.replace(/-[a-zA-Z]/g, ({ 1: letterAfterDash }) => letterAfterDash.toUpperCase());
+exports.kebabToCamelCase = kebabToCamelCase;
+/**
+ * Convert an array to human-readable text.
+ */
+const toHumanReadableText = (items) => {
+    const itemsLength = items.length;
+    if (itemsLength === 1) {
+        return `"${items[0]}"`;
+    }
+    return `${items
+        .map((item) => `"${item}"`)
+        .slice(0, itemsLength - 1)
+        .join(', ')} or "${[...items].pop()}"`;
+};
+exports.toHumanReadableText = toHumanReadableText;
+const toPattern = (value) => RegExp(`^(${value.join('|')})$`);
+exports.toPattern = toPattern;
+function capitalize(text) {
+    return `${text[0].toUpperCase()}${text.slice(1)}`;
+}
+function withoutBracketsAndWhitespaces(text) {
+    return text.replace(/[[\]\s]/g, '');
+}

package/package.json

@@ -0,0 +1,61 @@
+{
+  "name": "@depup/angular-eslint__utils",
+  "version": "21.3.1-depup.0",
+  "license": "MIT",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/angular-eslint/angular-eslint.git",
+    "directory": "packages/utils"
+  },
+  "files": [
+    "dist",
+    "!**/*.tsbuildinfo",
+    "package.json",
+    "README.md",
+    "LICENSE",
+    "changes.json"
+  ],
+  "peerDependencies": {
+    "@typescript-eslint/utils": "^7.11.0 || ^8.0.0",
+    "eslint": "^8.57.0 || ^9.0.0 || ^10.0.0",
+    "typescript": "*"
+  },
+  "dependencies": {
+    "@angular-eslint/bundled-angular-compiler": "21.3.1"
+  },
+  "nx": {
+    "namedInputs": {
+      "projectSpecificFiles": [
+        "{workspaceRoot}/tools/scripts/update-native-event-names.ts"
+      ]
+    },
+    "targets": {
+      "update-native-event-names": {
+        "outputs": [
+          "{projectRoot}/src/eslint-plugin/get-native-event-names"
+        ],
+        "command": "npx tsx ./tools/scripts/update-native-event-names.ts"
+      }
+    }
+  },
+  "gitHead": "e2006e5e9c99e5a943d1a999e0efa5247d29ec24",
+  "description": "@angular-eslint/utils with all dependencies updated to latest",
+  "keywords": [
+    "@angular-eslint/utils",
+    "depup",
+    "updated-dependencies",
+    "security",
+    "latest",
+    "patched"
+  ],
+  "depup": {
+    "changes": {},
+    "depsUpdated": 0,
+    "originalPackage": "@angular-eslint/utils",
+    "originalVersion": "21.3.1",
+    "processedAt": "2026-03-22T00:36:55.599Z",
+    "smokeTest": "passed"
+  }
+}