eslint-config-typed 5.6.2 → 5.8.0

package/dist/plugins/total-functions/rules/no-partial-division.mjs

@@ -22,10 +22,10 @@ const noPartialDivision = createRule({
             if (type.isIntersection()) {
                 const numberLiteralParts = intersectionTypeParts(type).filter((t) => isBigIntLiteral(t) || t.isNumberLiteral());
                 return (numberLiteralParts.length > 0 &&
-                    numberLiteralParts.every((t) => isSafeDenominator(t)));
+                    numberLiteralParts.every(isSafeDenominator));
             }
             if (type.isUnion()) {
-                return unionTypeParts(type).every((t) => isSafeDenominator(t));
+                return unionTypeParts(type).every(isSafeDenominator);
             }
             return ((type.isNumberLiteral() && type.value !== 0) ||
                 (isBigIntLiteral(type) && type.value.base10Value !== '0'));

package/dist/plugins/total-functions/rules/no-partial-division.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"no-partial-division.mjs","sources":["../../../../src/plugins/total-functions/rules/no-partial-division.mts"],"sourcesContent":[null],"names":[],"mappings":"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"}
+{"version":3,"file":"no-partial-division.mjs","sources":["../../../../src/plugins/total-functions/rules/no-partial-division.mts"],"sourcesContent":[null],"names":[],"mappings":";;;;AASA;AAEO,MAAM,iBAAiB,GAAG,UAAU,CAAC;AAC1C,IAAA,IAAI,EAAE,qBAAqB;AAC3B,IAAA,IAAI,EAAE;AACJ,QAAA,IAAI,EAAE,SAAS;AACf,QAAA,IAAI,EAAE;AACJ,YAAA,WAAW,EAAE,wBAAwB;AACtC,SAAA;AACD,QAAA,QAAQ,EAAE;AACR,YAAA,kBAAkB,EAChB,2GAA2G;AAC9G,SAAA;AACD,QAAA,MAAM,EAAE,EAAE;AACX,KAAA;AACD,IAAA,MAAM,EAAE,CAAC,OAAO,KAAI;QAClB,MAAM,cAAc,GAAG,WAAW,CAAC,iBAAiB,CAAC,OAAO,CAAC;QAE7D,MAAM,OAAO,GAAG,cAAc,CAAC,OAAO,CAAC,cAAc,EAAE;AAEvD,QAAA,MAAM,iBAAiB,GAAG,CAAC,IAAU,KAAa;AAChD,YAAA,IAAI,IAAI,CAAC,cAAc,EAAE,EAAE;gBACzB,MAAM,kBAAkB,GAAG,qBAAqB,CAAC,IAAI,CAAC,CAAC,MAAM,CAC3D,CAAC,CAAC,KAAK,eAAe,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,eAAe,EAAE,CACjD;AAED,gBAAA,QACE,kBAAkB,CAAC,MAAM,GAAG,CAAC;AAC7B,oBAAA,kBAAkB,CAAC,KAAK,CAAC,iBAAiB,CAAC;YAE/C;AAEA,YAAA,IAAI,IAAI,CAAC,OAAO,EAAE,EAAE;gBAClB,OAAO,cAAc,CAAC,IAAI,CAAC,CAAC,KAAK,CAAC,iBAAiB,CAAC;YACtD;AAEA,YAAA,QACE,CAAC,IAAI,CAAC,eAAe,EAAE,IAAI,IAAI,CAAC,KAAK,KAAK,CAAC;AAC3C,iBAAC,eAAe,CAAC,IAAI,CAAC,IAAI,IAAI,CAAC,KAAK,CAAC,WAAW,KAAK,GAAG,CAAC;AAE7D,QAAA,CAAC;QAED,OAAO;AACL,YAAA,gBAAgB,EAAE,CAAC,IAAI,KAAI;AACzB,gBAAA,IAAI,IAAI,CAAC,QAAQ,KAAK,GAAG,EAAE;;oBAEzB;gBACF;gBAEA,IACE,IAAI,CAAC,KAAK,CAAC,IAAI,KAAK,cAAc,CAAC,OAAO;AAC1C,oBAAA,IAAI,CAAC,KAAK,CAAC,KAAK,KAAK,CAAC;AACtB,oBAAA,IAAI,CAAC,KAAK,CAAC,KAAK,KAAK,EAAE,EACvB;;oBAEA;gBACF;gBAEA,IAAI,IAAI,CAAC,KAAK,CAAC,IAAI,KAAK,cAAc,CAAC,UAAU,EAAE;AACjD,oBAAA,MAAM,eAAe,GAAG,cAAc,CAAC,qBAAqB,CAAC,GAAG,CAC9D,IAAI,CAAC,KAAK,CACX;oBAED,MAAM,mBAAmB,GACvB,OAAO,CAAC,iBAAiB,CAAC,eAAe,CAAC;AAE5C,oBAAA,IAAI,iBAAiB,CAAC,mBAAmB,CAAC,EAAE;wBAC1C;oBACF;gBACF;;gBAIA,OAAO,CAAC,MAAM,CAAC;oBACb,IAAI;AACJ,oBAAA,SAAS,EAAE,oBAAoB;AACvB,iBAAA,CAAC;YACb,CAAC;SACF;IACH,CAAC;AACD,IAAA,cAAc,EAAE,EAAE;AACV,CAAA;AAEV;AACA;AACA;AACA,MAAM,cAAc,GAAG,CAAC,GAAY,KAAyB;IAC3D,MAAM,iBAAiB,GACrB,OAAO,GAAG,KAAK,QAAQ,IAAI,GAAG,KAAK;AACjC,UAAG;UACD,SAAS;IAEf,QACE,iBAAiB,KAAK,SAAS;AAC/B,QAAA,OAAO,iBAAiB,CAAC,WAAW,KAAK,QAAQ;AACjD,QAAA,OAAO,iBAAiB,CAAC,QAAQ,KAAK,SAAS;AAEnD,CAAC;AAED,MAAM,eAAe,GAAG,CAAC,IAAU;AACjC;AACA,cAAc,CAAE,IAAmC,EAAE,KAAK,CAAC;;;;"}

package/dist/plugins/ts-restrictions/rules/no-string-spread.d.mts

@@ -0,0 +1,32 @@
+import { type TSESLint } from '@typescript-eslint/utils';
+type Options = readonly [];
+type MessageIds = 'noStringSpread';
+/**
+ * Disallow spreading a `string` value with the spread operator `...`.
+ *
+ * ## Why
+ *
+ * Spreading a string iterates it into its individual characters, so
+ * `[...someString]` (or `f(...someString)`) evaluates to a `string[]` — the
+ * *exact same result type* as spreading an actual `string[]`. That makes an
+ * accidental string spread silent: neither the reader nor the type checker can
+ * tell `[...anArray]` from `[...aString]` by the result type alone, so a bug
+ * where an array was expected but a `string` slipped in goes unnoticed.
+ *
+ * ## Why not simply "allow array / object types only"
+ *
+ * The naive framing — "only permit `...` on arrays or objects" — would also
+ * reject perfectly idiomatic spreads of other iterables (`Set`, `Map`,
+ * `Map.prototype.keys()`, generators, `NodeList`, typed arrays, `arguments`,
+ * …), which have no equivalent silent hazard. And TypeScript *already* rejects
+ * spreading a non-iterable primitive such as `number` / `boolean` in an
+ * iterable position. The only case TypeScript accepts yet is genuinely
+ * error-prone is `string`, so that is exactly what this rule targets.
+ *
+ * If a character split is really intended, spell it out with
+ * `Array.from(str)` (identical to the spread, code-point aware) or
+ * `str.split('')`.
+ */
+export declare const noStringSpread: TSESLint.RuleModule<MessageIds, Options>;
+export {};
+//# sourceMappingURL=no-string-spread.d.mts.map

package/dist/plugins/ts-restrictions/rules/no-string-spread.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"no-string-spread.d.mts","sourceRoot":"","sources":["../../../../src/plugins/ts-restrictions/rules/no-string-spread.mts"],"names":[],"mappings":"AAAA,OAAO,EAAe,KAAK,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AAGtE,KAAK,OAAO,GAAG,SAAS,EAAE,CAAC;AAE3B,KAAK,UAAU,GAAG,gBAAgB,CAAC;AAanC;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,eAAO,MAAM,cAAc,EAAE,QAAQ,CAAC,UAAU,CAAC,UAAU,EAAE,OAAO,CAyE1D,CAAC"}

package/dist/plugins/ts-restrictions/rules/no-string-spread.mjs

@@ -0,0 +1,102 @@
+import { ESLintUtils } from '@typescript-eslint/utils';
+import * as ts from 'typescript';
+
+/**
+ * Deferred (non-concrete) type flags whose actual members are only known once
+ * the type is instantiated. They are reduced to their base constraint before
+ * checking whether they are string-like.
+ */
+const DEFERRED_TYPE_FLAGS = ts.TypeFlags.TypeParameter |
+    ts.TypeFlags.IndexedAccess |
+    ts.TypeFlags.Conditional |
+    ts.TypeFlags.Substitution;
+/**
+ * Disallow spreading a `string` value with the spread operator `...`.
+ *
+ * ## Why
+ *
+ * Spreading a string iterates it into its individual characters, so
+ * `[...someString]` (or `f(...someString)`) evaluates to a `string[]` — the
+ * *exact same result type* as spreading an actual `string[]`. That makes an
+ * accidental string spread silent: neither the reader nor the type checker can
+ * tell `[...anArray]` from `[...aString]` by the result type alone, so a bug
+ * where an array was expected but a `string` slipped in goes unnoticed.
+ *
+ * ## Why not simply "allow array / object types only"
+ *
+ * The naive framing — "only permit `...` on arrays or objects" — would also
+ * reject perfectly idiomatic spreads of other iterables (`Set`, `Map`,
+ * `Map.prototype.keys()`, generators, `NodeList`, typed arrays, `arguments`,
+ * …), which have no equivalent silent hazard. And TypeScript *already* rejects
+ * spreading a non-iterable primitive such as `number` / `boolean` in an
+ * iterable position. The only case TypeScript accepts yet is genuinely
+ * error-prone is `string`, so that is exactly what this rule targets.
+ *
+ * If a character split is really intended, spell it out with
+ * `Array.from(str)` (identical to the spread, code-point aware) or
+ * `str.split('')`.
+ */
+const noStringSpread = {
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'Disallow spreading a `string` (e.g. `[...str]`), which silently splits it into characters and yields a `string[]` indistinguishable from spreading an array',
+        },
+        schema: [],
+        messages: {
+            noStringSpread: 'Spreading a `string` splits it into individual characters and yields a `string[]` indistinguishable from spreading an array, so accidental string spreads go unnoticed. Spread an array or object instead; if a character split is intended, make it explicit with `Array.from(str)`.',
+        },
+    },
+    create: (context) => {
+        const parserServices = ESLintUtils.getParserServices(context);
+        const checker = parserServices.program.getTypeChecker();
+        /**
+         * Returns `true` if the given type could be spread as a string (it is
+         * string-like, or a union / intersection with a string-like constituent).
+         *
+         * - `any` / `unknown` are treated conservatively as *not* string-like:
+         *   they cannot be proven to be a string, and flagging them would fire on
+         *   every untyped spread.
+         * - Unions are flagged when *any* branch is string-like, because such a
+         *   branch reintroduces the silent char-split hazard.
+         * - Intersections are flagged when *any* constituent is string-like: a
+         *   branded string (`string & Brand`) is still a `string` at runtime.
+         * - A deferred type (type parameter, indexed access, conditional, …) is
+         *   reduced to its base constraint; one with no resolvable constraint is
+         *   left alone to avoid false positives on unconstrained generics.
+         */
+        // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+        const isStringLikeType = (type) => {
+            if ((type.flags & (ts.TypeFlags.Any | ts.TypeFlags.Unknown)) !== 0) {
+                return false;
+            }
+            if (type.isUnion() || type.isIntersection()) {
+                return type.types.some(isStringLikeType);
+            }
+            if ((type.flags & DEFERRED_TYPE_FLAGS) !== 0) {
+                const constraint = checker.getBaseConstraintOfType(type);
+                return constraint !== undefined && isStringLikeType(constraint);
+            }
+            return (type.flags & ts.TypeFlags.StringLike) !== 0;
+        };
+        return {
+            // `SpreadElement` covers every value-spread position: array literals
+            // (`[...x]`), call / new arguments (`f(...x)`), and object literals
+            // (`{...x}`). Destructuring rest (`[a, ...rest]`, `{ ...rest }`) is a
+            // `RestElement` / `RestType` and is intentionally not matched.
+            SpreadElement: (node) => {
+                const argTsNode = parserServices.esTreeNodeToTSNodeMap.get(node.argument);
+                if (!isStringLikeType(checker.getTypeAtLocation(argTsNode)))
+                    return;
+                context.report({
+                    node,
+                    messageId: 'noStringSpread',
+                });
+            },
+        };
+    },
+    defaultOptions: [],
+};
+
+export { noStringSpread };
+//# sourceMappingURL=no-string-spread.mjs.map

package/dist/plugins/ts-restrictions/rules/no-string-spread.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"no-string-spread.mjs","sources":["../../../../src/plugins/ts-restrictions/rules/no-string-spread.mts"],"sourcesContent":[null],"names":[],"mappings":";;;AAOA;;;;AAIG;AACH,MAAM,mBAAmB,GACvB,EAAE,CAAC,SAAS,CAAC,aAAa;IAC1B,EAAE,CAAC,SAAS,CAAC,aAAa;IAC1B,EAAE,CAAC,SAAS,CAAC,WAAW;AACxB,IAAA,EAAE,CAAC,SAAS,CAAC,YAAY;AAE3B;;;;;;;;;;;;;;;;;;;;;;;;;AAyBG;AACI,MAAM,cAAc,GAA6C;AACtE,IAAA,IAAI,EAAE;AACJ,QAAA,IAAI,EAAE,SAAS;AACf,QAAA,IAAI,EAAE;AACJ,YAAA,WAAW,EACT,6JAA6J;AAChK,SAAA;AACD,QAAA,MAAM,EAAE,EAAE;AACV,QAAA,QAAQ,EAAE;AACR,YAAA,cAAc,EACZ,uRAAuR;AAC1R,SAAA;AACF,KAAA;AAED,IAAA,MAAM,EAAE,CAAC,OAAO,KAAI;QAClB,MAAM,cAAc,GAAG,WAAW,CAAC,iBAAiB,CAAC,OAAO,CAAC;QAE7D,MAAM,OAAO,GAAG,cAAc,CAAC,OAAO,CAAC,cAAc,EAAE;AAEvD;;;;;;;;;;;;;;AAcG;;AAEH,QAAA,MAAM,gBAAgB,GAAG,CAAC,IAAa,KAAa;YAClD,IAAI,CAAC,IAAI,CAAC,KAAK,IAAI,EAAE,CAAC,SAAS,CAAC,GAAG,GAAG,EAAE,CAAC,SAAS,CAAC,OAAO,CAAC,MAAM,CAAC,EAAE;AAClE,gBAAA,OAAO,KAAK;YACd;YAEA,IAAI,IAAI,CAAC,OAAO,EAAE,IAAI,IAAI,CAAC,cAAc,EAAE,EAAE;gBAC3C,OAAO,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,gBAAgB,CAAC;YAC1C;YAEA,IAAI,CAAC,IAAI,CAAC,KAAK,GAAG,mBAAmB,MAAM,CAAC,EAAE;gBAC5C,MAAM,UAAU,GAAG,OAAO,CAAC,uBAAuB,CAAC,IAAI,CAAC;gBAExD,OAAO,UAAU,KAAK,SAAS,IAAI,gBAAgB,CAAC,UAAU,CAAC;YACjE;AAEA,YAAA,OAAO,CAAC,IAAI,CAAC,KAAK,GAAG,EAAE,CAAC,SAAS,CAAC,UAAU,MAAM,CAAC;AACrD,QAAA,CAAC;QAED,OAAO;;;;;AAKL,YAAA,aAAa,EAAE,CAAC,IAAI,KAAI;AACtB,gBAAA,MAAM,SAAS,GAAG,cAAc,CAAC,qBAAqB,CAAC,GAAG,CACxD,IAAI,CAAC,QAAQ,CACd;gBAED,IAAI,CAAC,gBAAgB,CAAC,OAAO,CAAC,iBAAiB,CAAC,SAAS,CAAC,CAAC;oBAAE;gBAE7D,OAAO,CAAC,MAAM,CAAC;oBACb,IAAI;AACJ,oBAAA,SAAS,EAAE,gBAAgB;AAC5B,iBAAA,CAAC;YACJ,CAAC;SACF;IACH,CAAC;AACD,IAAA,cAAc,EAAE,EAAE;;;;;"}

package/dist/plugins/ts-restrictions/rules/prefer-curried-call.d.mts

@@ -0,0 +1,22 @@
+import { type TSESLint } from '@typescript-eslint/utils';
+type Options = readonly [];
+type MessageIds = 'useFunctionDirectly' | 'useCurriedForm';
+/**
+ * Replaces a redundant arrow wrapper around a function call with a point-free
+ * form, using the callee's curried version when one exists:
+ *
+ * - `(a) => f(a)` → `f` — only when `f` is effectively unary, so passing it
+ *   directly cannot change behavior even when the wrapper is used as a
+ *   multi-argument callback (`arr.map((a) => f(a))` → `arr.map(f)`). This is
+ *   what keeps the classic `arr.map((s) => parseInt(s))` case (where `parseInt`
+ *   also reads the index) from being rewritten.
+ * - `(a) => f(a, ...rest)` → `f(...rest)` — only when `f` has a curried call
+ *   signature accepting `...rest` and returning a one-argument function, i.e.
+ *   a genuine curried version (`(a) => toPushed(a, x)` → `toPushed(x)`).
+ *
+ * The arrow's single parameter must appear exactly once, as the first argument
+ * of the call, so dropping the wrapper is behavior-preserving.
+ */
+export declare const preferCurriedCall: TSESLint.RuleModule<MessageIds, Options>;
+export {};
+//# sourceMappingURL=prefer-curried-call.d.mts.map

package/dist/plugins/ts-restrictions/rules/prefer-curried-call.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prefer-curried-call.d.mts","sourceRoot":"","sources":["../../../../src/plugins/ts-restrictions/rules/prefer-curried-call.mts"],"names":[],"mappings":"AAAA,OAAO,EAGL,KAAK,QAAQ,EAEd,MAAM,0BAA0B,CAAC;AAGlC,KAAK,OAAO,GAAG,SAAS,EAAE,CAAC;AAE3B,KAAK,UAAU,GAAG,qBAAqB,GAAG,gBAAgB,CAAC;AAE3D;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,iBAAiB,EAAE,QAAQ,CAAC,UAAU,CAAC,UAAU,EAAE,OAAO,CA+L7D,CAAC"}

package/dist/plugins/ts-restrictions/rules/prefer-curried-call.mjs

@@ -0,0 +1,284 @@
+import { ESLintUtils, AST_NODE_TYPES } from '@typescript-eslint/utils';
+import * as ts from 'typescript';
+
+/**
+ * Replaces a redundant arrow wrapper around a function call with a point-free
+ * form, using the callee's curried version when one exists:
+ *
+ * - `(a) => f(a)` → `f` — only when `f` is effectively unary, so passing it
+ *   directly cannot change behavior even when the wrapper is used as a
+ *   multi-argument callback (`arr.map((a) => f(a))` → `arr.map(f)`). This is
+ *   what keeps the classic `arr.map((s) => parseInt(s))` case (where `parseInt`
+ *   also reads the index) from being rewritten.
+ * - `(a) => f(a, ...rest)` → `f(...rest)` — only when `f` has a curried call
+ *   signature accepting `...rest` and returning a one-argument function, i.e.
+ *   a genuine curried version (`(a) => toPushed(a, x)` → `toPushed(x)`).
+ *
+ * The arrow's single parameter must appear exactly once, as the first argument
+ * of the call, so dropping the wrapper is behavior-preserving.
+ */
+const preferCurriedCall = {
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Replace a redundant arrow wrapper with the function itself (`(a) => f(a)` → `f`) or, when the callee has a curried version, its curried form (`(a) => f(a, ...rest)` → `f(...rest)`).',
+        },
+        fixable: 'code',
+        schema: [],
+        messages: {
+            useFunctionDirectly: 'Replace the redundant arrow wrapper `{{original}}` with `{{replacement}}`.',
+            useCurriedForm: 'Replace the arrow wrapper `{{original}}` with the curried call `{{replacement}}`.',
+        },
+    },
+    create: (context) => {
+        const sourceCode = context.sourceCode;
+        const services = ESLintUtils.getParserServices(context);
+        const checker = services.program.getTypeChecker();
+        const getType = (
+        // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+        node) => checker.getTypeAtLocation(services.esTreeNodeToTSNodeMap.get(node));
+        /**
+         * `true` when `node` refers to a module/namespace object (e.g. a namespace
+         * imported as `Arr`). Referencing `Namespace.fn` as a value is safe because
+         * namespace members do not depend on a dynamic `this`, unlike instance
+         * methods (`obj.method`), which would lose their receiver.
+         */
+        const isNamespaceObject = (
+        // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+        node) => {
+            const symbol = checker.getSymbolAtLocation(services.esTreeNodeToTSNodeMap.get(node));
+            if (symbol === undefined)
+                return false;
+            const resolved = (symbol.flags & ts.SymbolFlags.Alias) !== 0
+                ? checker.getAliasedSymbol(symbol)
+                : symbol;
+            return ((resolved.flags &
+                (ts.SymbolFlags.ValueModule | ts.SymbolFlags.NamespaceModule)) !==
+                0);
+        };
+        /**
+         * For the eta reduction `(a) => f(a)` → `f`, the callee must be safe to
+         * reference as a bare value: a plain identifier (a standalone function) or
+         * a namespace member (`Arr.isNonEmpty`). Instance-method callees are
+         * rejected because the point-free form would drop their `this`.
+         */
+        const isEtaSafeCallee = (
+        // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+        callee) => {
+            if (callee.type === AST_NODE_TYPES.Identifier)
+                return true;
+            if (callee.type === AST_NODE_TYPES.MemberExpression) {
+                return !callee.optional && isNamespaceObject(callee.object);
+            }
+            return false;
+        };
+        /**
+         * `true` when the arrow's single parameter is referenced exactly once, at
+         * `argument` — so it appears neither in the callee nor in any other
+         * argument, and dropping the wrapper cannot change behavior.
+         */
+        const paramUsedOnlyAt = (
+        // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+        node, paramName, 
+        // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+        argument) => {
+            const scope = sourceCode.getScope(node);
+            const variable = scope.variables.find((v) => v.name === paramName);
+            if (variable === undefined)
+                return false;
+            const [reference] = variable.references;
+            return (variable.references.length === 1 && reference?.identifier === argument);
+        };
+        return {
+            ArrowFunctionExpression: (node) => {
+                if (node.async || node.params.length !== 1)
+                    return;
+                const [param] = node.params;
+                if (param?.type !== AST_NODE_TYPES.Identifier ||
+                    param.typeAnnotation !== undefined) {
+                    return;
+                }
+                if (node.body.type !== AST_NODE_TYPES.CallExpression)
+                    return;
+                const call = node.body;
+                if (call.optional)
+                    return;
+                const [firstArg, ...restArgs] = call.arguments;
+                if (firstArg?.type !== AST_NODE_TYPES.Identifier ||
+                    firstArg.name !== param.name) {
+                    return;
+                }
+                // A spread in the remaining arguments breaks positional arg counting.
+                if (restArgs.some((arg) => arg.type === AST_NODE_TYPES.SpreadElement)) {
+                    return;
+                }
+                if (!paramUsedOnlyAt(node, param.name, firstArg))
+                    return;
+                const calleeType = getType(call.callee);
+                const calleeText = sourceCode.getText(call.callee);
+                if (restArgs.length === 0) {
+                    // `(a) => f(a)` → `f`
+                    if (!isEtaSafeCallee(call.callee) ||
+                        !isEffectivelyUnary(calleeType)) {
+                        return;
+                    }
+                    context.report({
+                        node,
+                        messageId: 'useFunctionDirectly',
+                        data: {
+                            original: sourceCode.getText(node),
+                            replacement: calleeText,
+                        },
+                        fix: (fixer) => fixer.replaceText(node, calleeText),
+                    });
+                    return;
+                }
+                // `(a) => f(a, ...rest)` → `f(...rest)`
+                // Re-evaluating a side-effecting argument once (at currying time)
+                // instead of on every call would change behavior, so require the
+                // remaining arguments to be free of observable side effects.
+                if (!restArgs.every(isPureExpression) ||
+                    !hasCurriedSignature(calleeType, restArgs.length)) {
+                    return;
+                }
+                const replacement = `${calleeText}(${restArgs
+                    .map((arg) => sourceCode.getText(arg))
+                    .join(', ')})`;
+                context.report({
+                    node,
+                    messageId: 'useCurriedForm',
+                    data: {
+                        original: sourceCode.getText(node),
+                        replacement,
+                    },
+                    fix: (fixer) => fixer.replaceText(node, replacement),
+                });
+            },
+        };
+    },
+    defaultOptions: [],
+};
+/**
+ * `true` when every call signature of `type` accepts at most one argument, so
+ * `(a) => f(a)` is equivalent to `f` even when the wrapper is used as a
+ * multi-argument callback (the extra positional arguments are ignored either
+ * way). Requires at least one call signature.
+ */
+const isEffectivelyUnary = (
+// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+type) => {
+    const signatures = type.getCallSignatures();
+    return (signatures.length > 0 &&
+        signatures.every((signature) => signatureMaxArgs(signature) <= 1));
+};
+/**
+ * `true` when `type` has a curried call signature accepting exactly
+ * `restCount` arguments and returning a function that accepts one argument —
+ * i.e. `f(...rest)` is the curried form of `f(a, ...rest)`.
+ */
+const hasCurriedSignature = (
+// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+type, restCount) => type.getCallSignatures().some((signature) => {
+    if (!isCallableWith(signature, restCount))
+        return false;
+    return signature
+        .getReturnType()
+        .getCallSignatures()
+        .some((inner) => isCallableWith(inner, 1));
+});
+const isCallableWith = (
+// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+signature, argCount) => signatureMinArgs(signature) <= argCount &&
+    argCount <= signatureMaxArgs(signature);
+/** The largest number of positional arguments the signature accepts. */
+const signatureMaxArgs = (
+// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+signature) => {
+    const params = signature.getParameters();
+    const last = params.at(-1);
+    return last !== undefined && isRestParameter(last)
+        ? Number.POSITIVE_INFINITY
+        : params.length;
+};
+/** The number of leading required parameters (before any optional/rest). */
+const signatureMinArgs = (
+// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+signature) => {
+    const firstOptional = signature
+        .getParameters()
+        .findIndex(isOptionalParameter);
+    return firstOptional === -1
+        ? signature.getParameters().length
+        : firstOptional;
+};
+/** A parameter that collects the rest of the arguments (`...args`). */
+const isRestParameter = (
+// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+symbol) => {
+    const declaration = symbol.valueDeclaration ?? symbol.declarations?.[0];
+    return (declaration !== undefined &&
+        ts.isParameter(declaration) &&
+        declaration.dotDotDotToken !== undefined);
+};
+/** A parameter that may be omitted (`x?`, `x = ...`) or is a rest parameter. */
+const isOptionalParameter = (
+// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+symbol) => {
+    const declaration = symbol.valueDeclaration ?? symbol.declarations?.[0];
+    return (declaration !== undefined &&
+        ts.isParameter(declaration) &&
+        (declaration.questionToken !== undefined ||
+            declaration.initializer !== undefined ||
+            declaration.dotDotDotToken !== undefined));
+};
+/**
+ * A conservative purity approximation: `true` only for expressions whose
+ * evaluation has no observable side effects and does not depend on evaluation
+ * count (so hoisting it out of the wrapper is safe). Anything not recognized
+ * (calls, `new`, `await`, assignments, updates) is treated as impure.
+ */
+const isPureExpression = (
+// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+node) => {
+    if (node.type === AST_NODE_TYPES.Literal ||
+        node.type === AST_NODE_TYPES.Identifier ||
+        node.type === AST_NODE_TYPES.ThisExpression ||
+        node.type === AST_NODE_TYPES.ArrowFunctionExpression ||
+        node.type === AST_NODE_TYPES.FunctionExpression) {
+        return true;
+    }
+    if (node.type === AST_NODE_TYPES.TemplateLiteral) {
+        return node.expressions.every(isPureExpression);
+    }
+    if (node.type === AST_NODE_TYPES.MemberExpression) {
+        return node.computed
+            ? isPureExpression(node.object) && isPureExpression(node.property)
+            : isPureExpression(node.object);
+    }
+    if (node.type === AST_NODE_TYPES.UnaryExpression) {
+        return node.operator !== 'delete' && isPureExpression(node.argument);
+    }
+    if (node.type === AST_NODE_TYPES.BinaryExpression ||
+        node.type === AST_NODE_TYPES.LogicalExpression) {
+        return isPureExpression(node.left) && isPureExpression(node.right);
+    }
+    if (node.type === AST_NODE_TYPES.ConditionalExpression) {
+        return (isPureExpression(node.test) &&
+            isPureExpression(node.consequent) &&
+            isPureExpression(node.alternate));
+    }
+    if (node.type === AST_NODE_TYPES.ArrayExpression) {
+        return node.elements.every((element) => element === null ||
+            (element.type !== AST_NODE_TYPES.SpreadElement &&
+                isPureExpression(element)));
+    }
+    if (node.type === AST_NODE_TYPES.ObjectExpression) {
+        return node.properties.every((property) => property.type === AST_NODE_TYPES.Property &&
+            !property.computed &&
+            isPureExpression(property.value));
+    }
+    return false;
+};
+
+export { preferCurriedCall };
+//# sourceMappingURL=prefer-curried-call.mjs.map

package/dist/plugins/ts-restrictions/rules/prefer-curried-call.mjs.map

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

package/dist/plugins/ts-restrictions/rules/rules.d.mts

@@ -14,8 +14,10 @@ export declare const tsRestrictionsRules: {
         }>;
     }>)[], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
     readonly 'no-restricted-syntax': import("eslint").Rule.RuleModule;
+    readonly 'no-string-spread': import("@typescript-eslint/utils/ts-eslint").RuleModule<"noStringSpread", readonly [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
     readonly 'no-unnecessary-array-from': import("@typescript-eslint/utils/ts-eslint").RuleModule<"unnecessaryArrayFrom", readonly [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
     readonly 'no-unnecessary-coalesce-undefined': import("@typescript-eslint/utils/ts-eslint").RuleModule<"unnecessaryCoalesceUndefined", readonly [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+    readonly 'prefer-curried-call': import("@typescript-eslint/utils/ts-eslint").RuleModule<"useFunctionDirectly" | "useCurriedForm", readonly [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
     readonly 'prefer-non-mutating-array-method': import("@typescript-eslint/utils/ts-eslint").RuleModule<"preferNonMutatingMethod", readonly [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
 };
 //# sourceMappingURL=rules.d.mts.map

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

@@ -1 +1 @@
-{"version":3,"file":"rules.d.mts","sourceRoot":"","sources":["../../../../src/plugins/ts-restrictions/rules/rules.mts"],"names":[],"mappings":"AAQA,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;CAOU,CAAC"}
+{"version":3,"file":"rules.d.mts","sourceRoot":"","sources":["../../../../src/plugins/ts-restrictions/rules/rules.mts"],"names":[],"mappings":"AAUA,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;CASU,CAAC"}

package/dist/plugins/ts-restrictions/rules/rules.mjs

@@ -1,16 +1,20 @@
 import { checkDestructuringCompleteness } from './check-destructuring-completeness.mjs';
 import { noRestrictedCastName } from './no-restricted-cast-name.mjs';
 import { noRestrictedSyntax } from './no-restricted-syntax.mjs';
+import { noStringSpread } from './no-string-spread.mjs';
 import { noUnnecessaryArrayFrom } from './no-unnecessary-array-from.mjs';
 import { noUnnecessaryCoalesceUndefined } from './no-unnecessary-coalesce-undefined.mjs';
+import { preferCurriedCall } from './prefer-curried-call.mjs';
 import { preferNonMutatingArrayMethod } from './prefer-non-mutating-array-method.mjs';
 
 const tsRestrictionsRules = {
     'check-destructuring-completeness': checkDestructuringCompleteness,
     'no-restricted-cast-name': noRestrictedCastName,
     'no-restricted-syntax': noRestrictedSyntax,
+    'no-string-spread': noStringSpread,
     'no-unnecessary-array-from': noUnnecessaryArrayFrom,
     'no-unnecessary-coalesce-undefined': noUnnecessaryCoalesceUndefined,
+    'prefer-curried-call': preferCurriedCall,
     'prefer-non-mutating-array-method': preferNonMutatingArrayMethod,
 };
 

package/dist/plugins/ts-restrictions/rules/rules.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"rules.mjs","sources":["../../../../src/plugins/ts-restrictions/rules/rules.mts"],"sourcesContent":[null],"names":[],"mappings":";;;;;;;AAQO,MAAM,mBAAmB,GAAG;AACjC,IAAA,kCAAkC,EAAE,8BAA8B;AAClE,IAAA,yBAAyB,EAAE,oBAAoB;AAC/C,IAAA,sBAAsB,EAAE,kBAAkB;AAC1C,IAAA,2BAA2B,EAAE,sBAAsB;AACnD,IAAA,mCAAmC,EAAE,8BAA8B;AACnE,IAAA,kCAAkC,EAAE,4BAA4B;;;;;"}
+{"version":3,"file":"rules.mjs","sources":["../../../../src/plugins/ts-restrictions/rules/rules.mts"],"sourcesContent":[null],"names":[],"mappings":";;;;;;;;;AAUO,MAAM,mBAAmB,GAAG;AACjC,IAAA,kCAAkC,EAAE,8BAA8B;AAClE,IAAA,yBAAyB,EAAE,oBAAoB;AAC/C,IAAA,sBAAsB,EAAE,kBAAkB;AAC1C,IAAA,kBAAkB,EAAE,cAAc;AAClC,IAAA,2BAA2B,EAAE,sBAAsB;AACnD,IAAA,mCAAmC,EAAE,8BAA8B;AACnE,IAAA,qBAAqB,EAAE,iBAAiB;AACxC,IAAA,kCAAkC,EAAE,4BAA4B;;;;;"}

package/dist/rules/eslint-ts-restrictions-rules.d.mts

@@ -1,8 +1,10 @@
 export declare const eslintTsRestrictionsRules: {
     readonly 'ts-restrictions/no-restricted-syntax': "off";
     readonly 'ts-restrictions/no-restricted-cast-name': "off";
+    readonly 'ts-restrictions/no-string-spread': "error";
     readonly 'ts-restrictions/no-unnecessary-array-from': "error";
     readonly 'ts-restrictions/no-unnecessary-coalesce-undefined': "error";
+    readonly 'ts-restrictions/prefer-curried-call': "error";
     readonly 'ts-restrictions/prefer-non-mutating-array-method': "error";
     readonly 'ts-restrictions/check-destructuring-completeness': 2 | 1;
 };

package/dist/rules/eslint-ts-restrictions-rules.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"eslint-ts-restrictions-rules.d.mts","sourceRoot":"","sources":["../../src/rules/eslint-ts-restrictions-rules.mts"],"names":[],"mappings":"AAKA,eAAO,MAAM,yBAAyB;;;;;;;CAQQ,CAAC"}
+{"version":3,"file":"eslint-ts-restrictions-rules.d.mts","sourceRoot":"","sources":["../../src/rules/eslint-ts-restrictions-rules.mts"],"names":[],"mappings":"AAKA,eAAO,MAAM,yBAAyB;;;;;;;;;CAUQ,CAAC"}

package/dist/rules/eslint-ts-restrictions-rules.mjs

@@ -3,8 +3,10 @@ import { withDefaultOption } from '../types/rule-severity-with-default-option.mj
 const eslintTsRestrictionsRules = {
     'ts-restrictions/no-restricted-syntax': 'off',
     'ts-restrictions/no-restricted-cast-name': 'off',
+    'ts-restrictions/no-string-spread': 'error',
     'ts-restrictions/no-unnecessary-array-from': 'error',
     'ts-restrictions/no-unnecessary-coalesce-undefined': 'error',
+    'ts-restrictions/prefer-curried-call': 'error',
     'ts-restrictions/prefer-non-mutating-array-method': 'error',
     'ts-restrictions/check-destructuring-completeness': withDefaultOption('error'),
 };

package/dist/rules/eslint-ts-restrictions-rules.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"eslint-ts-restrictions-rules.mjs","sources":["../../src/rules/eslint-ts-restrictions-rules.mts"],"sourcesContent":[null],"names":[],"mappings":";;AAKO,MAAM,yBAAyB,GAAG;AACvC,IAAA,sCAAsC,EAAE,KAAK;AAC7C,IAAA,yCAAyC,EAAE,KAAK;AAChD,IAAA,2CAA2C,EAAE,OAAO;AACpD,IAAA,mDAAmD,EAAE,OAAO;AAC5D,IAAA,kDAAkD,EAAE,OAAO;AAC3D,IAAA,kDAAkD,EAChD,iBAAiB,CAAC,OAAO,CAAC;;;;;"}
+{"version":3,"file":"eslint-ts-restrictions-rules.mjs","sources":["../../src/rules/eslint-ts-restrictions-rules.mts"],"sourcesContent":[null],"names":[],"mappings":";;AAKO,MAAM,yBAAyB,GAAG;AACvC,IAAA,sCAAsC,EAAE,KAAK;AAC7C,IAAA,yCAAyC,EAAE,KAAK;AAChD,IAAA,kCAAkC,EAAE,OAAO;AAC3C,IAAA,2CAA2C,EAAE,OAAO;AACpD,IAAA,mDAAmD,EAAE,OAAO;AAC5D,IAAA,qCAAqC,EAAE,OAAO;AAC9C,IAAA,kDAAkD,EAAE,OAAO;AAC3D,IAAA,kDAAkD,EAChD,iBAAiB,CAAC,OAAO,CAAC;;;;;"}

package/dist/types/rules/eslint-ts-restrictions-rules.d.mts

@@ -204,6 +204,19 @@ declare namespace NoRestrictedSyntax {
     }>)[];
     type RuleEntry = 'off' | Linter.Severity | SpreadOptionsIfIsArray<readonly [Linter.StringSeverity, Options]>;
 }
+/**
+ * @description Disallow spreading a `string` (e.g. `[...str]`), which silently splits it into characters and yields a `string[]` indistinguishable from spreading an array
+ *
+ *  ```md
+ *  | key        | value   |
+ *  | :--------- | :------ |
+ *  | type       | problem |
+ *  | deprecated | false   |
+ *  ```
+ */
+declare namespace NoStringSpread {
+    type RuleEntry = Linter.StringSeverity;
+}
 /**
  * @description Disallow wrapping an array in `Array.from()` before a non-mutating array method (e.g. `Array.from(x).toSorted()`), since the method already returns a new array
  *
@@ -232,6 +245,20 @@ declare namespace NoUnnecessaryArrayFrom {
 declare namespace NoUnnecessaryCoalesceUndefined {
     type RuleEntry = Linter.StringSeverity;
 }
+/**
+ * @description Replace a redundant arrow wrapper with the function itself (`(a) => f(a)` → `f`) or, when the callee has a curried version, its curried form (`(a) => f(a, ...rest)` → `f(...rest)`).
+ *
+ *  ```md
+ *  | key        | value      |
+ *  | :--------- | :--------- |
+ *  | type       | suggestion |
+ *  | deprecated | false      |
+ *  | fixable    | code       |
+ *  ```
+ */
+declare namespace PreferCurriedCall {
+    type RuleEntry = Linter.StringSeverity;
+}
 /**
  * @description Disallow calling a mutating array method on a defensive `Array.from()` copy of an array (e.g. `Array.from(x).sort()`); use the non-mutating counterpart on the original array instead (e.g. `x.toSorted()`)
  *
@@ -250,8 +277,10 @@ export type EslintTsRestrictionsRules = Readonly<{
     'ts-restrictions/check-destructuring-completeness': CheckDestructuringCompleteness.RuleEntry;
     'ts-restrictions/no-restricted-cast-name': NoRestrictedCastName.RuleEntry;
     'ts-restrictions/no-restricted-syntax': NoRestrictedSyntax.RuleEntry;
+    'ts-restrictions/no-string-spread': NoStringSpread.RuleEntry;
     'ts-restrictions/no-unnecessary-array-from': NoUnnecessaryArrayFrom.RuleEntry;
     'ts-restrictions/no-unnecessary-coalesce-undefined': NoUnnecessaryCoalesceUndefined.RuleEntry;
+    'ts-restrictions/prefer-curried-call': PreferCurriedCall.RuleEntry;
     'ts-restrictions/prefer-non-mutating-array-method': PreferNonMutatingArrayMethod.RuleEntry;
 }>;
 export type EslintTsRestrictionsRulesOption = Readonly<{