eslint-config-typed 5.3.3 → 5.4.0

package/dist/plugins/ts-data-forge/rules/prefer-canonical-array-slicing.d.mts

@@ -0,0 +1,6 @@
+import { type TSESLint } from '@typescript-eslint/utils';
+type Options = readonly [];
+type MessageIds = 'preferCanonicalArraySlicing';
+export declare const preferCanonicalArraySlicing: TSESLint.RuleModule<MessageIds, Options>;
+export {};
+//# sourceMappingURL=prefer-canonical-array-slicing.d.mts.map

package/dist/plugins/ts-data-forge/rules/prefer-canonical-array-slicing.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prefer-canonical-array-slicing.d.mts","sourceRoot":"","sources":["../../../../src/plugins/ts-data-forge/rules/prefer-canonical-array-slicing.mts"],"names":[],"mappings":"AAAA,OAAO,EAGL,KAAK,QAAQ,EAEd,MAAM,0BAA0B,CAAC;AAUlC,KAAK,OAAO,GAAG,SAAS,EAAE,CAAC;AAE3B,KAAK,UAAU,GAAG,6BAA6B,CAAC;AA6IhD,eAAO,MAAM,2BAA2B,EAAE,QAAQ,CAAC,UAAU,CAC3D,UAAU,EACV,OAAO,CAsnBC,CAAC"}

package/dist/plugins/ts-data-forge/rules/prefer-canonical-array-slicing.mjs

@@ -0,0 +1,522 @@
+import { ESLintUtils, AST_NODE_TYPES } from '@typescript-eslint/utils';
+import * as ts from 'typescript';
+import { getTsDataForgeImport, getImportedLocalName, buildImportFixes } from './import-utils.mjs';
+
+/** `skip 1` / `skipLast 1` have dedicated single-element names. */
+const normalizeCountedOp = (fn, count) => count < 1
+    ? undefined
+    : fn === 'skip' && count === 1
+        ? { fn: 'tail' }
+        : fn === 'skipLast' && count === 1
+            ? { fn: 'butLast' }
+            : { fn, count };
+const asNonNegativeIntegerLiteral = (node) => node.type === AST_NODE_TYPES.Literal &&
+    typeof node.value === 'number' &&
+    Number.isInteger(node.value) &&
+    node.value >= 0
+    ? node.value
+    : undefined;
+/** Matches `-N` (unary minus of a positive integer literal) and returns `N`. */
+const asNegatedPositiveIntegerLiteral = (node) => {
+    if (node.type !== AST_NODE_TYPES.UnaryExpression ||
+        node.operator !== '-' ||
+        node.argument.type !== AST_NODE_TYPES.Literal) {
+        return undefined;
+    }
+    const n = asNonNegativeIntegerLiteral(node.argument);
+    return n !== undefined && n >= 1 ? n : undefined;
+};
+/**
+ * Whether re-reading the expression is free of side effects (a plain variable
+ * or a non-computed property chain). Required for patterns that reference the
+ * receiver twice, such as `xs.filter((_, i) => i < xs.length - 1)`.
+ */
+const isSimpleReference = (node) => node.type === AST_NODE_TYPES.Identifier ||
+    node.type === AST_NODE_TYPES.ThisExpression ||
+    (node.type === AST_NODE_TYPES.MemberExpression &&
+        !node.computed &&
+        node.property.type === AST_NODE_TYPES.Identifier &&
+        isSimpleReference(node.object));
+const rootIdentifierName = (node) => node.type === AST_NODE_TYPES.Identifier
+    ? node.name
+    : node.type === AST_NODE_TYPES.MemberExpression
+        ? rootIdentifierName(node.object)
+        : undefined;
+const COMPARISON_OPERATORS = new Set([
+    '!==',
+    '<',
+    '<=',
+    '>',
+    '>=',
+]);
+/** Mirror of each comparison when its operands are swapped. */
+const FLIPPED_OPERATORS = {
+    '!==': '!==',
+    '<': '>',
+    '<=': '>=',
+    '>': '<',
+    '>=': '<=',
+};
+/** Classifies `index OP N` (a comparison against an integer literal). */
+const classifyLiteralComparison = (op, n) => {
+    switch (op) {
+        case '>=':
+            return normalizeCountedOp('skip', n);
+        case '>':
+            return normalizeCountedOp('skip', n + 1);
+        case '!==':
+            return n === 0 ? { fn: 'tail' } : undefined;
+        case '<':
+            return normalizeCountedOp('take', n);
+        case '<=':
+            return normalizeCountedOp('take', n + 1);
+    }
+};
+/** Classifies `index OP <xs>.length - M`. */
+const classifyLengthComparison = (op, m) => {
+    switch (op) {
+        case '<':
+            return normalizeCountedOp('skipLast', m);
+        case '<=':
+            return normalizeCountedOp('skipLast', m - 1);
+        case '!==':
+            return m === 1 ? { fn: 'butLast' } : undefined;
+        case '>=':
+            return normalizeCountedOp('takeLast', m);
+        case '>':
+            return normalizeCountedOp('takeLast', m - 1);
+    }
+};
+const preferCanonicalArraySlicing = {
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Unify non-mutating array element addition/removal patterns (`slice` / `toSpliced` / `filter` / `concat` / spread) into the corresponding ts-data-forge functions: `Arr.tail`, `Arr.skip`, `Arr.take`, `Arr.butLast`, `Arr.skipLast`, `Arr.takeLast`, `Arr.toUnshifted`, `Arr.toPushed`.',
+        },
+        fixable: 'code',
+        schema: [],
+        messages: {
+            preferCanonicalArraySlicing: 'Replace with `{{replacement}}` from ts-data-forge.',
+        },
+    },
+    create: (context) => {
+        const sourceCode = context.sourceCode;
+        const program = sourceCode.ast;
+        const tsDataForgeImport = getTsDataForgeImport(program);
+        const parserServices = ESLintUtils.getParserServices(context);
+        const checker = parserServices.program.getTypeChecker();
+        /**
+         * The in-scope way to reference the `Arr` namespace: a named import
+         * (possibly aliased), a namespace import member, or the canonical `Arr`
+         * (added by the import fix when nothing is imported yet).
+         */
+        const arrLocalName = getImportedLocalName(tsDataForgeImport, 'Arr');
+        const namespaceLocalName = tsDataForgeImport?.specifiers.find((specifier) => specifier.type === AST_NODE_TYPES.ImportNamespaceSpecifier)?.local.name;
+        const arrRef = arrLocalName ??
+            (namespaceLocalName === undefined ? 'Arr' : `${namespaceLocalName}.Arr`);
+        const needsArrImport = arrLocalName === undefined && namespaceLocalName === undefined;
+        /**
+         * Deferred (non-concrete) types are reduced to their base constraint
+         * before checking; `any` / `unknown` are conservatively not array-like.
+         */
+        const isArrayOrTupleType = (type) => {
+            if ((type.flags & (ts.TypeFlags.Any | ts.TypeFlags.Unknown)) !== 0) {
+                return false;
+            }
+            if (type.isUnion()) {
+                return type.types.every(isArrayOrTupleType);
+            }
+            if ((type.flags &
+                (ts.TypeFlags.TypeParameter |
+                    ts.TypeFlags.IndexedAccess |
+                    ts.TypeFlags.Conditional |
+                    ts.TypeFlags.Substitution)) !==
+                0) {
+                const constraint = checker.getBaseConstraintOfType(type);
+                return constraint !== undefined && isArrayOrTupleType(constraint);
+            }
+            return checker.isArrayType(type) || checker.isTupleType(type);
+        };
+        const getTypeOf = (node) => checker.getTypeAtLocation(parserServices.esTreeNodeToTSNodeMap.get(node));
+        /**
+         * `true` only when the type can never be an array in any branch, so
+         * `xs.concat(v)` is guaranteed to append `v` as one element rather than
+         * flattening it.
+         */
+        const isDefinitelyNotArrayType = (type) => {
+            if ((type.flags & (ts.TypeFlags.Any | ts.TypeFlags.Unknown)) !== 0) {
+                return false;
+            }
+            if (type.isUnion()) {
+                return type.types.every(isDefinitelyNotArrayType);
+            }
+            if ((type.flags &
+                (ts.TypeFlags.TypeParameter |
+                    ts.TypeFlags.IndexedAccess |
+                    ts.TypeFlags.Conditional |
+                    ts.TypeFlags.Substitution)) !==
+                0) {
+                const constraint = checker.getBaseConstraintOfType(type);
+                return constraint !== undefined && isDefinitelyNotArrayType(constraint);
+            }
+            return !checker.isArrayType(type) && !checker.isTupleType(type);
+        };
+        /** Argument-position text; a comma (sequence) expression needs parens. */
+        const toArgText = (node) => {
+            const text = sourceCode.getText(node);
+            return node.type === AST_NODE_TYPES.SequenceExpression
+                ? `(${text})`
+                : text;
+        };
+        const toReplacementText = (op, xsText) => {
+            switch (op.fn) {
+                case 'tail':
+                case 'butLast':
+                    return `${arrRef}.${op.fn}(${xsText})`;
+                case 'skip':
+                case 'take':
+                case 'skipLast':
+                case 'takeLast':
+                    return `${arrRef}.${op.fn}(${xsText}, ${op.count})`;
+                case 'toUnshifted':
+                case 'toPushed':
+                    return `${arrRef}.${op.fn}(${xsText}, ${op.itemText})`;
+            }
+        };
+        const mut_nodesToFix = [];
+        const report = (node, op, xsText) => {
+            mut_nodesToFix.push({
+                node,
+                replacement: toReplacementText(op, xsText),
+            });
+        };
+        /** Matches `<xsText>.length` (non-computed). */
+        const isReceiverLengthAccess = (node, receiverText) => node.type === AST_NODE_TYPES.MemberExpression &&
+            !node.computed &&
+            node.property.type === AST_NODE_TYPES.Identifier &&
+            node.property.name === 'length' &&
+            sourceCode.getText(node.object) === receiverText;
+        /** Matches `<xsText>.length - M` (M ≥ 1) and returns `M`. */
+        const matchLengthMinus = (node, receiverText) => {
+            if (node.type !== AST_NODE_TYPES.BinaryExpression ||
+                node.operator !== '-' ||
+                !isReceiverLengthAccess(node.left, receiverText)) {
+                return undefined;
+            }
+            const m = asNonNegativeIntegerLiteral(node.right);
+            return m !== undefined && m >= 1 ? m : undefined;
+        };
+        /**
+         * Matches an index-only filter callback (`(_, i) => <comparison>`) and
+         * classifies the comparison. Both a leading index (`i >= 1`) and a
+         * trailing index (`1 <= i`) operand order are accepted.
+         */
+        const classifyFilterCallback = (callback, receiver, receiverText) => {
+            if (callback.type !== AST_NODE_TYPES.ArrowFunctionExpression ||
+                callback.async ||
+                callback.body.type === AST_NODE_TYPES.BlockStatement ||
+                callback.params.length !== 2) {
+                return undefined;
+            }
+            const [elementParam, indexParam] = callback.params;
+            if (elementParam === undefined ||
+                indexParam === undefined ||
+                elementParam.type !== AST_NODE_TYPES.Identifier ||
+                indexParam.type !== AST_NODE_TYPES.Identifier) {
+                return undefined;
+            }
+            // A callback parameter shadowing the receiver's root binding (e.g.
+            // `xs.filter((xs, i) => i < xs.length - 1)`) would make the textual
+            // `xs.length` comparison refer to the element, not the receiver.
+            const receiverRoot = rootIdentifierName(receiver);
+            if (receiverRoot !== undefined &&
+                (elementParam.name === receiverRoot || indexParam.name === receiverRoot)) {
+                return undefined;
+            }
+            const body = callback.body;
+            if (body.type !== AST_NODE_TYPES.BinaryExpression ||
+                !COMPARISON_OPERATORS.has(body.operator)) {
+                return undefined;
+            }
+            // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+            const rawOperator = body.operator;
+            const isIndex = (side) => side.type === AST_NODE_TYPES.Identifier &&
+                side.name === indexParam.name;
+            const [op, other] = isIndex(body.left)
+                ? [rawOperator, body.right]
+                : isIndex(body.right)
+                    ? [FLIPPED_OPERATORS[rawOperator], body.left]
+                    : [undefined, undefined];
+            // `op` and `other` are set together (both from the same tuple), so
+            // checking `op` also guarantees `other` is defined.
+            if (op === undefined || isIndex(other)) {
+                return undefined;
+            }
+            // The element parameter must not participate in the comparison (only
+            // the index side and a receiver-independent bound are recognized, so
+            // reaching here with an element reference is impossible for literals,
+            // but `xs.length - N` needs a stable receiver).
+            const n = asNonNegativeIntegerLiteral(other);
+            if (n !== undefined) {
+                return classifyLiteralComparison(op, n);
+            }
+            if (!isSimpleReference(receiver))
+                return undefined;
+            const m = matchLengthMinus(other, receiverText);
+            return m === undefined ? undefined : classifyLengthComparison(op, m);
+        };
+        const classifySliceArgs = (args, receiver) => {
+            if (args.length === 1) {
+                const [start] = args;
+                if (start === undefined)
+                    return undefined;
+                const n = asNonNegativeIntegerLiteral(start);
+                if (n !== undefined)
+                    return normalizeCountedOp('skip', n);
+                const negated = asNegatedPositiveIntegerLiteral(start);
+                return negated === undefined
+                    ? undefined
+                    : normalizeCountedOp('takeLast', negated);
+            }
+            if (args.length === 2) {
+                const [start, end] = args;
+                if (start === undefined ||
+                    end === undefined ||
+                    asNonNegativeIntegerLiteral(start) !== 0) {
+                    return undefined;
+                }
+                const n = asNonNegativeIntegerLiteral(end);
+                if (n !== undefined)
+                    return normalizeCountedOp('take', n);
+                const negated = asNegatedPositiveIntegerLiteral(end);
+                if (negated !== undefined) {
+                    return normalizeCountedOp('skipLast', negated);
+                }
+                if (!isSimpleReference(receiver))
+                    return undefined;
+                const m = matchLengthMinus(end, sourceCode.getText(receiver));
+                return m === undefined ? undefined : normalizeCountedOp('skipLast', m);
+            }
+            return undefined;
+        };
+        const classifyToSplicedArgs = (args, receiver, receiverText) => {
+            if (args.length === 1) {
+                const [start] = args;
+                if (start === undefined)
+                    return undefined;
+                const n = asNonNegativeIntegerLiteral(start);
+                // `xs.toSpliced(N)` removes everything from index N on → take N.
+                if (n !== undefined)
+                    return normalizeCountedOp('take', n);
+                const negated = asNegatedPositiveIntegerLiteral(start);
+                // `xs.toSpliced(-N)` removes the last N elements → skipLast N.
+                return negated === undefined
+                    ? undefined
+                    : normalizeCountedOp('skipLast', negated);
+            }
+            if (args.length === 2) {
+                const [start, deleteCount] = args;
+                if (start === undefined ||
+                    deleteCount === undefined ||
+                    asNonNegativeIntegerLiteral(start) !== 0) {
+                    return undefined;
+                }
+                // `xs.toSpliced(0, N)` removes the first N elements → skip N.
+                const n = asNonNegativeIntegerLiteral(deleteCount);
+                if (n !== undefined)
+                    return normalizeCountedOp('skip', n);
+                // `xs.toSpliced(0, xs.length - N)` keeps the last N → takeLast N.
+                // (Note: `xs.toSpliced(0, -N)` clamps the delete count to 0 and is a
+                // plain copy, so it is deliberately NOT treated as takeLast.)
+                if (!isSimpleReference(receiver))
+                    return undefined;
+                const m = matchLengthMinus(deleteCount, receiverText);
+                return m === undefined ? undefined : normalizeCountedOp('takeLast', m);
+            }
+            if (args.length === 3) {
+                const [start, deleteCount, item] = args;
+                if (start === undefined ||
+                    deleteCount === undefined ||
+                    item === undefined ||
+                    item.type === AST_NODE_TYPES.SpreadElement ||
+                    asNonNegativeIntegerLiteral(deleteCount) !== 0) {
+                    return undefined;
+                }
+                // `xs.toSpliced(0, 0, item)` prepends → toUnshifted.
+                if (asNonNegativeIntegerLiteral(start) === 0) {
+                    return { fn: 'toUnshifted', itemText: toArgText(item) };
+                }
+                // `xs.toSpliced(xs.length, 0, item)` appends → toPushed.
+                if (isSimpleReference(receiver) &&
+                    isReceiverLengthAccess(start, receiverText)) {
+                    return { fn: 'toPushed', itemText: toArgText(item) };
+                }
+                return undefined;
+            }
+            return undefined;
+        };
+        return {
+            CallExpression: (node) => {
+                const callee = node.callee;
+                if (callee.type !== AST_NODE_TYPES.MemberExpression ||
+                    callee.computed ||
+                    callee.property.type !== AST_NODE_TYPES.Identifier) {
+                    return;
+                }
+                const methodName = callee.property.name;
+                const receiver = callee.object;
+                // `Arr.skip(xs, 1)` → `Arr.tail(xs)`, `Arr.skipLast(xs, 1)` →
+                // `Arr.butLast(xs)` (also via a namespace import or an alias).
+                if (methodName === 'skip' || methodName === 'skipLast') {
+                    const isArrObject = (receiver.type === AST_NODE_TYPES.Identifier &&
+                        receiver.name === arrLocalName) ||
+                        (receiver.type === AST_NODE_TYPES.MemberExpression &&
+                            !receiver.computed &&
+                            receiver.object.type === AST_NODE_TYPES.Identifier &&
+                            receiver.object.name === namespaceLocalName &&
+                            receiver.property.type === AST_NODE_TYPES.Identifier &&
+                            receiver.property.name === 'Arr');
+                    const [arrayArg, countArg] = node.arguments;
+                    if (isArrObject &&
+                        node.arguments.length === 2 &&
+                        arrayArg !== undefined &&
+                        arrayArg.type !== AST_NODE_TYPES.SpreadElement &&
+                        countArg !== undefined &&
+                        asNonNegativeIntegerLiteral(countArg) === 1) {
+                        report(node, { fn: methodName === 'skip' ? 'tail' : 'butLast' }, toArgText(arrayArg));
+                    }
+                    return;
+                }
+                // `[item].concat(xs)` → `Arr.toUnshifted(xs, item)`.
+                if (methodName === 'concat' &&
+                    receiver.type === AST_NODE_TYPES.ArrayExpression) {
+                    const [element] = receiver.elements;
+                    const [arg] = node.arguments;
+                    if (receiver.elements.length === 1 &&
+                        element !== null &&
+                        element !== undefined &&
+                        element.type !== AST_NODE_TYPES.SpreadElement &&
+                        node.arguments.length === 1 &&
+                        arg !== undefined &&
+                        arg.type !== AST_NODE_TYPES.SpreadElement &&
+                        isArrayOrTupleType(getTypeOf(arg))) {
+                        report(node, { fn: 'toUnshifted', itemText: toArgText(element) }, toArgText(arg));
+                    }
+                    return;
+                }
+                if (methodName !== 'slice' &&
+                    methodName !== 'toSpliced' &&
+                    methodName !== 'filter' &&
+                    methodName !== 'concat') {
+                    return;
+                }
+                // The receiver must be an array or tuple (not a string / typed array
+                // / other object that happens to share the method name).
+                if (!isArrayOrTupleType(getTypeOf(receiver)))
+                    return;
+                const receiverText = sourceCode.getText(receiver);
+                switch (methodName) {
+                    case 'slice': {
+                        const op = classifySliceArgs(node.arguments, receiver);
+                        if (op !== undefined)
+                            report(node, op, toArgText(receiver));
+                        return;
+                    }
+                    case 'toSpliced': {
+                        const op = classifyToSplicedArgs(node.arguments, receiver, receiverText);
+                        if (op !== undefined)
+                            report(node, op, toArgText(receiver));
+                        return;
+                    }
+                    case 'filter': {
+                        const [callback] = node.arguments;
+                        if (callback === undefined || node.arguments.length !== 1) {
+                            return;
+                        }
+                        const op = classifyFilterCallback(callback, receiver, receiverText);
+                        if (op !== undefined)
+                            report(node, op, toArgText(receiver));
+                        return;
+                    }
+                    case 'concat': {
+                        const [arg] = node.arguments;
+                        if (node.arguments.length !== 1 ||
+                            arg === undefined ||
+                            arg.type === AST_NODE_TYPES.SpreadElement) {
+                            return;
+                        }
+                        // `xs.concat([item])` → `Arr.toPushed(xs, item)`.
+                        if (arg.type === AST_NODE_TYPES.ArrayExpression) {
+                            const [element] = arg.elements;
+                            if (arg.elements.length === 1 &&
+                                element !== null &&
+                                element !== undefined &&
+                                element.type !== AST_NODE_TYPES.SpreadElement) {
+                                report(node, { fn: 'toPushed', itemText: toArgText(element) }, toArgText(receiver));
+                            }
+                            return;
+                        }
+                        // `xs.concat(item)` appends only when `item` can never be an
+                        // array (otherwise `concat` would flatten it).
+                        if (isDefinitelyNotArrayType(getTypeOf(arg))) {
+                            report(node, { fn: 'toPushed', itemText: toArgText(arg) }, toArgText(receiver));
+                        }
+                    }
+                }
+            },
+            ArrayExpression: (node) => {
+                // `[item, ...xs]` → `Arr.toUnshifted(xs, item)`,
+                // `[...xs, item]` → `Arr.toPushed(xs, item)`.
+                if (node.elements.length !== 2)
+                    return;
+                const [first, second] = node.elements;
+                if (first === null ||
+                    first === undefined ||
+                    second === null ||
+                    second === undefined) {
+                    return;
+                }
+                const [spread, item, fn] = first.type === AST_NODE_TYPES.SpreadElement &&
+                    second.type !== AST_NODE_TYPES.SpreadElement
+                    ? [first, second, 'toPushed']
+                    : first.type !== AST_NODE_TYPES.SpreadElement &&
+                        second.type === AST_NODE_TYPES.SpreadElement
+                        ? [second, first, 'toUnshifted']
+                        : [undefined, undefined, undefined];
+                // `spread`, `item`, and `fn` are set together (all from the same
+                // tuple), so checking `spread` also guarantees the others are
+                // defined.
+                if (spread === undefined)
+                    return;
+                // Spreading a non-array iterable (`[v, ...someSet]`) is a genuine
+                // conversion, not an element addition to an array.
+                if (!isArrayOrTupleType(getTypeOf(spread.argument)))
+                    return;
+                report(node, { fn, itemText: toArgText(item) }, toArgText(spread.argument));
+            },
+            'Program:exit': () => {
+                for (const [index, nodeInfo] of mut_nodesToFix.entries()) {
+                    context.report({
+                        node: nodeInfo.node,
+                        messageId: 'preferCanonicalArraySlicing',
+                        data: { replacement: nodeInfo.replacement },
+                        fix: (fixer) => {
+                            const importFixes = index === 0 && needsArrImport
+                                ? buildImportFixes(fixer, program, tsDataForgeImport, ['Arr'])
+                                : [];
+                            return [
+                                ...importFixes,
+                                fixer.replaceText(nodeInfo.node, nodeInfo.replacement),
+                            ];
+                        },
+                    });
+                }
+            },
+        };
+    },
+    defaultOptions: [],
+};
+/* eslint-enable @typescript-eslint/prefer-readonly-parameter-types */
+
+export { preferCanonicalArraySlicing };
+//# sourceMappingURL=prefer-canonical-array-slicing.mjs.map

package/dist/plugins/ts-data-forge/rules/prefer-canonical-array-slicing.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"prefer-canonical-array-slicing.mjs","sources":["../../../../src/plugins/ts-data-forge/rules/prefer-canonical-array-slicing.mts"],"sourcesContent":[null],"names":[],"mappings":"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"}

package/dist/plugins/ts-data-forge/rules/rules.d.mts

@@ -1,4 +1,5 @@
 export declare const tsDataForgeRules: {
+    readonly 'prefer-canonical-array-slicing': import("@typescript-eslint/utils/ts-eslint").RuleModule<"preferCanonicalArraySlicing", readonly [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
     readonly 'prefer-arr-is-array-at-least-length': import("@typescript-eslint/utils/ts-eslint").RuleModule<"useIsArrayAtLeastLength", readonly [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
     readonly 'prefer-arr-is-array-of-length': import("@typescript-eslint/utils/ts-eslint").RuleModule<"useIsArrayOfLength", readonly [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
     readonly 'prefer-arr-is-array': import("@typescript-eslint/utils/ts-eslint").RuleModule<"useArrIsArray", readonly [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener>;

package/dist/plugins/ts-data-forge/rules/rules.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"rules.d.mts","sourceRoot":"","sources":["../../../../src/plugins/ts-data-forge/rules/rules.mts"],"names":[],"mappings":"AAeA,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;CAca,CAAC"}
+{"version":3,"file":"rules.d.mts","sourceRoot":"","sources":["../../../../src/plugins/ts-data-forge/rules/rules.mts"],"names":[],"mappings":"AAgBA,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;CAea,CAAC"}

package/dist/plugins/ts-data-forge/rules/rules.mjs

@@ -5,6 +5,7 @@ import { preferArrIsArray } from './prefer-arr-is-array.mjs';
 import { preferArrIsNonEmpty } from './prefer-arr-is-non-empty.mjs';
 import { preferArrSum } from './prefer-arr-sum.mjs';
 import { preferAsInt } from './prefer-as-int.mjs';
+import { preferCanonicalArraySlicing } from './prefer-canonical-array-slicing.mjs';
 import { preferComparisonOverNullishGuard } from './prefer-comparison-over-nullish-guard.mjs';
 import { preferIsNonNullObject } from './prefer-is-non-null-object.mjs';
 import { preferIsRecordAndHasKey } from './prefer-is-record-and-has-key.mjs';
@@ -13,6 +14,7 @@ import { preferNumSafeParseInt } from './prefer-num-safe-parse-int.mjs';
 import { preferRangeForLoop } from './prefer-range-for-loop.mjs';
 
 const tsDataForgeRules = {
+    'prefer-canonical-array-slicing': preferCanonicalArraySlicing,
     'prefer-arr-is-array-at-least-length': preferArrIsArrayAtLeastLength,
     'prefer-arr-is-array-of-length': preferArrIsArrayOfLength,
     'prefer-arr-is-array': preferArrIsArray,

package/dist/plugins/ts-data-forge/rules/rules.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"rules.mjs","sources":["../../../../src/plugins/ts-data-forge/rules/rules.mts"],"sourcesContent":[null],"names":[],"mappings":";;;;;;;;;;;;;;AAeO,MAAM,gBAAgB,GAAG;AAC9B,IAAA,qCAAqC,EAAE,6BAA6B;AACpE,IAAA,+BAA+B,EAAE,wBAAwB;AACzD,IAAA,qBAAqB,EAAE,gBAAgB;AACvC,IAAA,yBAAyB,EAAE,mBAAmB;AAC9C,IAAA,gBAAgB,EAAE,YAAY;AAC9B,IAAA,eAAe,EAAE,WAAW;AAC5B,IAAA,2BAA2B,EAAE,qBAAqB;AAClD,IAAA,uBAAuB,EAAE,kBAAkB;AAC3C,IAAA,8BAA8B,EAAE,uBAAuB;AACvD,IAAA,2BAA2B,EAAE,qBAAqB;AAClD,IAAA,6BAA6B,EAAE,uBAAuB;AACtD,IAAA,2BAA2B,EAAE,sBAAsB;AACnD,IAAA,sCAAsC,EAAE,gCAAgC;;;;;"}
+{"version":3,"file":"rules.mjs","sources":["../../../../src/plugins/ts-data-forge/rules/rules.mts"],"sourcesContent":[null],"names":[],"mappings":";;;;;;;;;;;;;;;AAgBO,MAAM,gBAAgB,GAAG;AAC9B,IAAA,gCAAgC,EAAE,2BAA2B;AAC7D,IAAA,qCAAqC,EAAE,6BAA6B;AACpE,IAAA,+BAA+B,EAAE,wBAAwB;AACzD,IAAA,qBAAqB,EAAE,gBAAgB;AACvC,IAAA,yBAAyB,EAAE,mBAAmB;AAC9C,IAAA,gBAAgB,EAAE,YAAY;AAC9B,IAAA,eAAe,EAAE,WAAW;AAC5B,IAAA,2BAA2B,EAAE,qBAAqB;AAClD,IAAA,uBAAuB,EAAE,kBAAkB;AAC3C,IAAA,8BAA8B,EAAE,uBAAuB;AACvD,IAAA,2BAA2B,EAAE,qBAAqB;AAClD,IAAA,6BAA6B,EAAE,uBAAuB;AACtD,IAAA,2BAA2B,EAAE,sBAAsB;AACnD,IAAA,sCAAsC,EAAE,gCAAgC;;;;;"}

package/dist/plugins/ts-restrictions/rules/array-type-utils.d.mts

@@ -0,0 +1,24 @@
+import { AST_NODE_TYPES, type TSESTree } from '@typescript-eslint/utils';
+import * as ts from 'typescript';
+/**
+ * Builds a predicate that returns `true` if every constituent of the given type
+ * is an array or tuple type. Unions must be array-like in all branches for a
+ * defensive `Array.from()` to be safely removable; `any` / `unknown` are
+ * treated conservatively as not array-like because they could be a `Set` /
+ * `Map` / iterable that genuinely relies on `Array.from()` to be materialized
+ * into an array.
+ */
+export declare const createIsArrayOrTupleType: (checker: ts.TypeChecker) => ((type: ts.Type) => boolean);
+/**
+ * Wraps the source text of an expression in parentheses when it cannot be used
+ * directly as the object of a member expression.
+ */
+export declare const toMemberObjectText: (argText: string, argNodeType: AST_NODE_TYPES) => string;
+/**
+ * Matches a call expression of the shape `Array.from(<arg>)` (exactly one
+ * non-spread argument) and returns the argument, or `undefined` when the node
+ * has a different shape. `Array.from(x, mapFn)` maps each element, so it is not
+ * a plain defensive copy and is not matched.
+ */
+export declare const matchArrayFromCall: (node: TSESTree.Expression) => TSESTree.Expression | undefined;
+//# sourceMappingURL=array-type-utils.d.mts.map

package/dist/plugins/ts-restrictions/rules/array-type-utils.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"array-type-utils.d.mts","sourceRoot":"","sources":["../../../../src/plugins/ts-restrictions/rules/array-type-utils.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,KAAK,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AACzE,OAAO,KAAK,EAAE,MAAM,YAAY,CAAC;AAajC;;;;;;;GAOG;AACH,eAAO,MAAM,wBAAwB,GAEnC,SAAS,EAAE,CAAC,WAAW,KAEtB,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,KAAK,OAAO,CAqB7B,CAAC;AAgBF;;;GAGG;AACH,eAAO,MAAM,kBAAkB,GAC7B,SAAS,MAAM,EACf,aAAa,cAAc,KAC1B,MAG4B,CAAC;AAEhC;;;;;GAKG;AACH,eAAO,MAAM,kBAAkB,GAE7B,MAAM,QAAQ,CAAC,UAAU,KACxB,QAAQ,CAAC,UAAU,GAAG,SAyBxB,CAAC"}