@taiga-ui/eslint-plugin-experience-next 0.365.0 → 0.366.0

package/README.md

@@ -42,6 +42,7 @@ export default [
 | array-as-const                      | Exported array of class references should be marked with `as const`                                 |     | 🔧  |     |
 | class-property-naming               | Enforce custom naming for class properties based on their type                                      |     | 🔧  |     |
 | decorator-key-sort                  | Sorts the keys of the object passed to the `@Component/@Injectable/@NgModule/@Pipe` decorator       | ✅  | 🔧  |     |
+| flat-exports                        | Spread nested arrays when exporting Angular entity collections                                      |     | 🔧  |     |
 | injection-token-description         | They are required to provide a description for `InjectionToken`                                     | ✅  |     |     |
 | no-deep-imports                     | Disables deep imports of Taiga UI packages                                                          | ✅  | 🔧  |     |
 | no-deep-imports-to-indexed-packages | Disallow deep imports from packages that expose an index.ts next to ng-package.json or package.json | ✅  | 🔧  |     |

package/configs/taiga-specific.d.ts

@@ -1,2 +1,2 @@
-declare const _default: import("typescript-eslint").FlatConfig.ConfigArray;
+declare const _default: import("@eslint/config-helpers").Config[];
 export default _default;

package/index.d.ts

@@ -13,6 +13,7 @@ declare const plugin: {
         'array-as-const': import("eslint").Rule.RuleModule;
         'class-property-naming': import("@typescript-eslint/utils/ts-eslint").RuleModule<"invalidName", [import("./rules/class-property-naming").RuleConfig[]], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
         'decorator-key-sort': import("eslint").Rule.RuleModule;
+        'flat-exports': import("@typescript-eslint/utils/ts-eslint").RuleModule<"spreadArrays", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
         'injection-token-description': import("@typescript-eslint/utils/ts-eslint").RuleModule<"invalid-injection-token-description", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
         'no-deep-imports': import("@typescript-eslint/utils/ts-eslint").RuleModule<"no-deep-imports", [{
             currentProject: string;

package/index.esm.js

@@ -1138,7 +1138,7 @@ const allPackageJSONs = globSync('**/package.json', {
 }).filter((path) => !readJSON(path).private);
 const packageNames = allPackageJSONs.map((path) => readJSON(path).name).filter(Boolean);
 const packageSourceGlobs = allPackageJSONs.map((p) => p.replaceAll(/\\+/g, '/').replace('package.json', '**/*.ts'));
-var taigaSpecific = tseslint.config([
+var taigaSpecific = defineConfig([
     {
         files: packageSourceGlobs,
         ignores: ['**/*.spec.ts', '**/*.cy.ts'],
@@ -1176,6 +1176,7 @@ var taigaSpecific = tseslint.config([
                     },
                 ],
             ],
+            '@taiga-ui/experience-next/flat-exports': 'error',
             '@taiga-ui/experience-next/strict-tui-doc-example': 'error',
             '@typescript-eslint/naming-convention': [
                 'error',
@@ -1301,8 +1302,8 @@ function intersect(a, b) {
     return a.some((type) => origin.has(type));
 }
 
-const createRule$6 = ESLintUtils.RuleCreator((name) => name);
-var classPropertyNaming = createRule$6({
+const createRule$7 = ESLintUtils.RuleCreator((name) => name);
+var classPropertyNaming = createRule$7({
     create(context, [configs]) {
         const parserServices = ESLintUtils.getParserServices(context);
         const typeChecker = parserServices.program.getTypeChecker();
@@ -1431,6 +1432,173 @@ function getCorrectOrderRelative(correct, current) {
     return correct.filter((item) => current.includes(item));
 }
 
+function getConstArray(node) {
+    if (!node || node.type !== AST_NODE_TYPES$1.TSAsExpression) {
+        return null;
+    }
+    const annotation = node.typeAnnotation;
+    const isConst = annotation.type === AST_NODE_TYPES$1.TSTypeReference &&
+        annotation.typeName.type === AST_NODE_TYPES$1.Identifier &&
+        annotation.typeName.name === 'const';
+    if (!isConst) {
+        return null;
+    }
+    if (node.expression.type === AST_NODE_TYPES$1.ArrayExpression) {
+        return node.expression;
+    }
+    return null;
+}
+
+function isClassType(type) {
+    const symbol = type.getSymbol();
+    if (!symbol) {
+        return false;
+    }
+    return (symbol
+        .getDeclarations()
+        ?.some((d) => ts.isClassDeclaration(d) || ts.isClassExpression(d)) ?? false);
+}
+
+function isExternalPureTuple(typeChecker, type) {
+    if (!typeChecker.isTupleType(type)) {
+        return false;
+    }
+    const typeRef = type;
+    const typeArgs = typeChecker.getTypeArguments(typeRef);
+    if (typeArgs.length === 0) {
+        return false;
+    }
+    return typeArgs.every((item) => isClassType(item));
+}
+
+const createRule$6 = ESLintUtils.RuleCreator((name) => name);
+const MESSAGE_ID$5 = 'spreadArrays';
+var flatExports = createRule$6({
+    create(context) {
+        const parserServices = ESLintUtils.getParserServices(context);
+        const typeChecker = parserServices.program.getTypeChecker();
+        const arrays = new Map();
+        const purityCache = new WeakMap();
+        const isPureArray = (arr) => {
+            if (purityCache.has(arr)) {
+                return purityCache.get(arr);
+            }
+            if (arr.isDirty) {
+                purityCache.set(arr, false);
+                return false;
+            }
+            for (const el of arr.elements) {
+                if (el.isClass) {
+                    continue;
+                }
+                if (el.isArrayLike) {
+                    const nested = arrays.get(el.name);
+                    if (nested) {
+                        if (!isPureArray(nested)) {
+                            purityCache.set(arr, false);
+                            return false;
+                        }
+                        continue;
+                    }
+                    if (isExternalPureTuple(typeChecker, el.type)) {
+                        continue;
+                    }
+                    purityCache.set(arr, false);
+                    return false;
+                }
+                purityCache.set(arr, false);
+                return false;
+            }
+            purityCache.set(arr, true);
+            return true;
+        };
+        return {
+            'Program:exit'() {
+                for (const [, arr] of arrays) {
+                    if (!isPureArray(arr)) {
+                        continue;
+                    }
+                    arr.elements.forEach((meta, index) => {
+                        if (!meta.isArrayLike) {
+                            return;
+                        }
+                        const elementNode = arr.node.elements[index];
+                        if (!elementNode ||
+                            elementNode.type !== AST_NODE_TYPES.Identifier) {
+                            return;
+                        }
+                        const hasLocalArrayMeta = arrays.has(meta.name);
+                        const isExternalPure = !hasLocalArrayMeta
+                            ? isExternalPureTuple(typeChecker, meta.type)
+                            : false;
+                        if (!hasLocalArrayMeta && !isExternalPure) {
+                            return;
+                        }
+                        context.report({
+                            data: { name: meta.name },
+                            fix(fixer) {
+                                return fixer.replaceText(elementNode, `...${meta.name}`);
+                            },
+                            messageId: MESSAGE_ID$5,
+                            node: elementNode,
+                        });
+                    });
+                }
+            },
+            VariableDeclarator(node) {
+                if (node.id.type !== AST_NODE_TYPES.Identifier) {
+                    return;
+                }
+                const name = node.id.name;
+                const arrayExpression = getConstArray(node.init);
+                if (!arrayExpression) {
+                    return;
+                }
+                const elements = [];
+                let isDirty = false;
+                for (const el of arrayExpression.elements) {
+                    if (!el || el.type !== AST_NODE_TYPES.Identifier) {
+                        isDirty = true;
+                        continue;
+                    }
+                    const tsNode = parserServices.esTreeNodeToTSNodeMap.get(el);
+                    const elType = typeChecker.getTypeAtLocation(tsNode);
+                    const isClass = isClassType(elType);
+                    const isArrayLike = typeChecker.isArrayLikeType(elType) ||
+                        typeChecker.isTupleType(elType);
+                    elements.push({
+                        isArrayLike,
+                        isClass,
+                        name: el.name,
+                        type: elType,
+                    });
+                    if (!isClass && !isArrayLike) {
+                        isDirty = true;
+                    }
+                }
+                arrays.set(name, {
+                    elements,
+                    isDirty,
+                    node: arrayExpression,
+                });
+            },
+        };
+    },
+    defaultOptions: [],
+    meta: {
+        docs: {
+            description: 'Ensure exported const tuples contain spread arrays in pure entity chains.',
+        },
+        fixable: 'code',
+        messages: {
+            [MESSAGE_ID$5]: 'Spread "{{ name }}" to avoid nested arrays in exported entities.',
+        },
+        schema: [],
+        type: 'suggestion',
+    },
+    name: 'flat-exports',
+});
+
 const MESSAGE_ID$4 = 'invalid-injection-token-description';
 const ERROR_MESSAGE$3 = "InjectionToken's description should contain token's name";
 const createRule$5 = ESLintUtils.RuleCreator((name) => name);
@@ -2224,6 +2392,7 @@ const plugin = {
         'array-as-const': config$4,
         'class-property-naming': classPropertyNaming,
         'decorator-key-sort': config$3,
+        'flat-exports': flatExports,
         'injection-token-description': rule$4,
         'no-deep-imports': rule$3,
         'no-deep-imports-to-indexed-packages': noDeepImportsToIndexedPackages,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@taiga-ui/eslint-plugin-experience-next",
-  "version": "0.365.0",
+  "version": "0.366.0",
   "description": "An ESLint plugin to enforce a consistent code styles across taiga-ui projects",
   "license": "Apache-2.0",
   "type": "module",

package/rules/flat-exports.d.ts

@@ -0,0 +1,3 @@
+import { ESLintUtils } from '@typescript-eslint/utils';
+declare const _default: ESLintUtils.RuleModule<"spreadArrays", [], unknown, ESLintUtils.RuleListener>;
+export default _default;

package/rules/utils/get-const-array.d.ts

@@ -0,0 +1,2 @@
+import { type TSESTree } from '@typescript-eslint/utils';
+export declare function getConstArray(node: TSESTree.Expression | null): TSESTree.ArrayExpression | null;

package/rules/utils/is-class-type.d.ts

@@ -0,0 +1,2 @@
+import ts from 'typescript';
+export declare function isClassType(type: ts.Type): boolean;

package/rules/utils/is-external-tuple.d.ts

@@ -0,0 +1,2 @@
+import { type Type, type TypeChecker } from 'typescript';
+export declare function isExternalPureTuple(typeChecker: TypeChecker, type: Type): boolean;