eslint-config-typed 5.7.0 → 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/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

@@ -17,6 +17,7 @@ export declare const tsRestrictionsRules: {
     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":"AASA,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;CAQU,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

@@ -4,6 +4,7 @@ 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 = {
@@ -13,6 +14,7 @@ const tsRestrictionsRules = {
     '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":";;;;;;;;AASO,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,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

@@ -4,6 +4,7 @@ export declare const eslintTsRestrictionsRules: {
     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;;;;;;;;CASQ,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

@@ -6,6 +6,7 @@ const eslintTsRestrictionsRules = {
     '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,kCAAkC,EAAE,OAAO;AAC3C,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

@@ -245,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()`)
  *
@@ -266,6 +280,7 @@ export type EslintTsRestrictionsRules = Readonly<{
     '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<{

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

@@ -1 +1 @@
-{"version":3,"file":"eslint-ts-restrictions-rules.d.mts","sourceRoot":"","sources":["../../../src/types/rules/eslint-ts-restrictions-rules.mts"],"names":[],"mappings":"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"}
+{"version":3,"file":"eslint-ts-restrictions-rules.d.mts","sourceRoot":"","sources":["../../../src/types/rules/eslint-ts-restrictions-rules.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,MAAM,EAAE,MAAM,QAAQ,CAAC;AAErC,KAAK,sBAAsB,CACzB,CAAC,SAAS,SAAS,CAAC,MAAM,CAAC,cAAc,EAAE,OAAO,CAAC,IACjD,CAAC,CAAC,CAAC,CAAC,SAAS,SAAS,OAAO,EAAE,GAC/B,SAAS,CAAC,MAAM,CAAC,cAAc,EAAE,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,GACzC,CAAC,CAAC;AAEN;;;;;;;;;GASG;AACH,kBAAU,8BAA8B,CAAC;IACvC;;;;;;;;;;;;;;;;;;;;;OAqBG;IACH,KAAY,OAAO,GAAG,QAAQ,CAAC;QAC7B;;WAEG;QACH,8BAA8B,CAAC,EAAE,OAAO,CAAC;QACzC;;WAEG;QACH,gBAAgB,CAAC,EAAE,MAAM,CAAC;KAC3B,CAAC,CAAC;IAEH,KAAY,SAAS,GACjB,KAAK,GACL,MAAM,CAAC,QAAQ,GACf,sBAAsB,CAAC,SAAS,CAAC,MAAM,CAAC,cAAc,EAAE,OAAO,CAAC,CAAC,CAAC;CACvE;AAED;;;;;;;;;;GAUG;AACH,kBAAU,oBAAoB,CAAC;IAC7B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA0EG;IACH;;OAEG;IACH,KAAY,OAAO,GAAG,SAAS,CAC3B,MAAM,GACN,QAAQ,CAAC;QACP,IAAI,EAAE,MAAM,CAAC;QACb,OAAO,CAAC,EAAE,QAAQ,CACd;YACE,IAAI,EAAE,MAAM,CAAC;YACb,IAAI,EAAE,MAAM,CAAC;SACd,GACD;YACE,IAAI,EAAE,UAAU,CAAC;YACjB,IAAI,EAAE,MAAM,CAAC;SACd,CACJ,CAAC;KACH,CAAC,CACL,EAAE,CAAC;IAEJ,KAAY,SAAS,GACjB,KAAK,GACL,MAAM,CAAC,QAAQ,GACf,sBAAsB,CAAC,SAAS,CAAC,MAAM,CAAC,cAAc,EAAE,OAAO,CAAC,CAAC,CAAC;CACvE;AAED;;;;;;;;;;;GAWG;AACH,kBAAU,kBAAkB,CAAC;IAC3B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAkCG;IACH;;OAEG;IACH,KAAY,OAAO,GAAG,SAAS,CAC3B,MAAM,GACN,QAAQ,CAAC;QACP,QAAQ,EAAE,MAAM,CAAC;QACjB,OAAO,CAAC,EAAE,MAAM,CAAC;KAClB,CAAC,CACL,EAAE,CAAC;IAEJ,KAAY,SAAS,GACjB,KAAK,GACL,MAAM,CAAC,QAAQ,GACf,sBAAsB,CAAC,SAAS,CAAC,MAAM,CAAC,cAAc,EAAE,OAAO,CAAC,CAAC,CAAC;CACvE;AAED;;;;;;;;;GASG;AACH,kBAAU,cAAc,CAAC;IACvB,KAAY,SAAS,GAAG,MAAM,CAAC,cAAc,CAAC;CAC/C;AAED;;;;;;;;;;GAUG;AACH,kBAAU,sBAAsB,CAAC;IAC/B,KAAY,SAAS,GAAG,MAAM,CAAC,cAAc,CAAC;CAC/C;AAED;;;;;;;;;;GAUG;AACH,kBAAU,8BAA8B,CAAC;IACvC,KAAY,SAAS,GAAG,MAAM,CAAC,cAAc,CAAC;CAC/C;AAED;;;;;;;;;;GAUG;AACH,kBAAU,iBAAiB,CAAC;IAC1B,KAAY,SAAS,GAAG,MAAM,CAAC,cAAc,CAAC;CAC/C;AAED;;;;;;;;;;GAUG;AACH,kBAAU,4BAA4B,CAAC;IACrC,KAAY,SAAS,GAAG,MAAM,CAAC,cAAc,CAAC;CAC/C;AAED,MAAM,MAAM,yBAAyB,GAAG,QAAQ,CAAC;IAC/C,kDAAkD,EAAE,8BAA8B,CAAC,SAAS,CAAC;IAC7F,yCAAyC,EAAE,oBAAoB,CAAC,SAAS,CAAC;IAC1E,sCAAsC,EAAE,kBAAkB,CAAC,SAAS,CAAC;IACrE,kCAAkC,EAAE,cAAc,CAAC,SAAS,CAAC;IAC7D,2CAA2C,EAAE,sBAAsB,CAAC,SAAS,CAAC;IAC9E,mDAAmD,EAAE,8BAA8B,CAAC,SAAS,CAAC;IAC9F,qCAAqC,EAAE,iBAAiB,CAAC,SAAS,CAAC;IACnE,kDAAkD,EAAE,4BAA4B,CAAC,SAAS,CAAC;CAC5F,CAAC,CAAC;AAEH,MAAM,MAAM,+BAA+B,GAAG,QAAQ,CAAC;IACrD,kDAAkD,EAAE,8BAA8B,CAAC,OAAO,CAAC;IAC3F,yCAAyC,EAAE,oBAAoB,CAAC,OAAO,CAAC;IACxE,sCAAsC,EAAE,kBAAkB,CAAC,OAAO,CAAC;CACpE,CAAC,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-config-typed",
-  "version": "5.7.0",
+  "version": "5.8.0",
   "private": false,
   "keywords": [
     "typescript"

package/src/plugins/total-functions/rules/no-partial-division.mts

@@ -35,12 +35,12 @@ export const noPartialDivision = createRule({
 
         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 (

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

@@ -0,0 +1,393 @@
+import {
+  AST_NODE_TYPES,
+  ESLintUtils,
+  type TSESLint,
+  type TSESTree,
+} from '@typescript-eslint/utils';
+import * as ts from 'typescript';
+
+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 const preferCurriedCall: TSESLint.RuleModule<MessageIds, Options> = {
+  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: TSESTree.Node,
+    ): ts.Type =>
+      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: TSESTree.Node,
+    ): boolean => {
+      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: TSESTree.Expression,
+    ): boolean => {
+      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: TSESTree.ArrowFunctionExpression,
+      paramName: string,
+      // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+      argument: TSESTree.Node,
+    ): boolean => {
+      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: [],
+} as const;
+
+/**
+ * `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: ts.Type,
+): boolean => {
+  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: ts.Type,
+  restCount: number,
+): boolean =>
+  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: ts.Signature,
+  argCount: number,
+): boolean =>
+  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: ts.Signature,
+): number => {
+  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: ts.Signature,
+): number => {
+  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: ts.Symbol,
+): boolean => {
+  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: ts.Symbol,
+): boolean => {
+  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: TSESTree.Node,
+): boolean => {
+  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;
+};

package/src/plugins/ts-restrictions/rules/prefer-curried-call.test.mts

@@ -0,0 +1,213 @@
+import parser from '@typescript-eslint/parser';
+import { RuleTester } from '@typescript-eslint/rule-tester';
+import dedent from 'dedent';
+import { preferCurriedCall } from './prefer-curried-call.mjs';
+
+const tester = new RuleTester({
+  languageOptions: {
+    parser,
+    parserOptions: {
+      ecmaVersion: 2020,
+      sourceType: 'module',
+      projectService: {
+        allowDefaultProject: ['*.ts*'],
+      },
+      tsconfigRootDir: `${import.meta.dirname}/../../../..`,
+    },
+  },
+});
+
+/** A curried, data-first function declaration shared by many test cases. */
+const curriedDecls = dedent`
+  declare function toPushed<Ar extends readonly unknown[], V>(
+    array: Ar,
+    v: V,
+  ): readonly [...Ar, V];
+  declare function toPushed<V>(
+    v: V,
+  ): <Ar extends readonly unknown[]>(array: Ar) => readonly [...Ar, V];
+
+  declare function take<Ar extends readonly unknown[]>(
+    array: Ar,
+    n: number,
+  ): Ar;
+  declare function take(
+    n: number,
+  ): <Ar extends readonly unknown[]>(array: Ar) => Ar;
+
+  declare namespace Arr {
+    function toPushed<Ar extends readonly unknown[], V>(
+      array: Ar,
+      v: V,
+    ): readonly [...Ar, V];
+    function toPushed<V>(
+      v: V,
+    ): <Ar extends readonly unknown[]>(array: Ar) => readonly [...Ar, V];
+
+    function isNonEmpty<E>(array: readonly E[]): boolean;
+  }
+
+  declare function isNonEmpty<E>(array: readonly E[]): boolean;
+`;
+
+describe('prefer-curried-call', () => {
+  tester.run('prefer-curried-call', preferCurriedCall, {
+    valid: [
+      {
+        name: 'non-curried multi-argument function is left untouched',
+        code: dedent`
+          declare function add(a: number, b: number): number;
+          declare const xs: readonly number[];
+          const ys = xs.map((a) => add(a, 1));
+        `,
+      },
+      {
+        name: 'eta reduction is skipped when the function is not unary (parseInt/radix footgun)',
+        code: dedent`
+          declare const xs: readonly string[];
+          const ys = xs.map((a) => parseInt(a));
+        `,
+      },
+      {
+        name: 'eta reduction is skipped for instance methods (would drop `this`)',
+        code: dedent`
+          declare const obj: { method(a: number): boolean };
+          declare const xs: readonly number[];
+          const ys = xs.map((a) => obj.method(a));
+        `,
+      },
+      {
+        name: 'parameter used more than once is left untouched',
+        code: dedent`
+          ${curriedDecls}
+          declare const xss: readonly (readonly number[])[];
+          const ys = xss.map((a) => toPushed(a, a));
+        `,
+      },
+      {
+        name: 'parameter that is not the first argument is left untouched',
+        code: dedent`
+          ${curriedDecls}
+          declare const x: readonly number[];
+          declare const xss: readonly (readonly number[])[];
+          const ys = xss.map((a) => toPushed(x, a));
+        `,
+      },
+      {
+        name: 'impure remaining argument is left untouched (evaluation timing)',
+        code: dedent`
+          ${curriedDecls}
+          declare function sideEffect(): number;
+          declare const xss: readonly (readonly number[])[];
+          const ys = xss.map((a) => toPushed(a, sideEffect()));
+        `,
+      },
+      {
+        name: 'annotated parameter is left untouched',
+        code: dedent`
+          ${curriedDecls}
+          const f = (a: readonly number[]) => toPushed(a, 5);
+        `,
+      },
+      {
+        name: 'async wrapper is left untouched',
+        code: dedent`
+          declare function load<E>(array: readonly E[]): Promise<readonly E[]>;
+          declare const xss: readonly (readonly number[])[];
+          const ys = xss.map(async (a) => load(a));
+        `,
+      },
+      {
+        name: 'already-curried callee (a call expression) is left untouched for eta',
+        code: dedent`
+          ${curriedDecls}
+          declare const xss: readonly (readonly number[])[];
+          const ys = xss.map((a) => take(3)(a));
+        `,
+      },
+      {
+        name: 'multi-argument arrow is left untouched',
+        code: dedent`
+          ${curriedDecls}
+          declare const xss: readonly (readonly number[])[];
+          const ys = xss.map((a, i) => toPushed(a, i));
+        `,
+      },
+    ],
+
+    invalid: [
+      {
+        name: 'eta reduction of a standalone unary function',
+        code: dedent`
+          ${curriedDecls}
+          declare const xss: readonly (readonly number[])[];
+          const ys = xss.map((a) => isNonEmpty(a));
+        `,
+        output: dedent`
+          ${curriedDecls}
+          declare const xss: readonly (readonly number[])[];
+          const ys = xss.map(isNonEmpty);
+        `,
+        errors: [{ messageId: 'useFunctionDirectly' }],
+      },
+      {
+        name: 'eta reduction of a namespace-member unary function',
+        code: dedent`
+          ${curriedDecls}
+          declare const xss: readonly (readonly number[])[];
+          const ys = xss.map((a) => Arr.isNonEmpty(a));
+        `,
+        output: dedent`
+          ${curriedDecls}
+          declare const xss: readonly (readonly number[])[];
+          const ys = xss.map(Arr.isNonEmpty);
+        `,
+        errors: [{ messageId: 'useFunctionDirectly' }],
+      },
+      {
+        name: 'curried form of a standalone two-argument function',
+        code: dedent`
+          ${curriedDecls}
+          declare const xss: readonly (readonly number[])[];
+          const ys = xss.map((a) => toPushed(a, 5));
+        `,
+        output: dedent`
+          ${curriedDecls}
+          declare const xss: readonly (readonly number[])[];
+          const ys = xss.map(toPushed(5));
+        `,
+        errors: [{ messageId: 'useCurriedForm' }],
+      },
+      {
+        name: 'curried form of a namespace-member function (the motivating example)',
+        code: dedent`
+          ${curriedDecls}
+          declare const newElem: number;
+          declare const xss: readonly (readonly number[])[];
+          const ys = xss.map((a) => Arr.toPushed(a, newElem));
+        `,
+        output: dedent`
+          ${curriedDecls}
+          declare const newElem: number;
+          declare const xss: readonly (readonly number[])[];
+          const ys = xss.map(Arr.toPushed(newElem));
+        `,
+        errors: [{ messageId: 'useCurriedForm' }],
+      },
+      {
+        name: 'curried form with a counted argument (take)',
+        code: dedent`
+          ${curriedDecls}
+          declare const xss: readonly (readonly number[])[];
+          const ys = xss.map((a) => take(a, 3));
+        `,
+        output: dedent`
+          ${curriedDecls}
+          declare const xss: readonly (readonly number[])[];
+          const ys = xss.map(take(3));
+        `,
+        errors: [{ messageId: 'useCurriedForm' }],
+      },
+    ],
+  });
+});

package/src/plugins/ts-restrictions/rules/rules.mts

@@ -5,6 +5,7 @@ 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';
 
 export const tsRestrictionsRules = {
@@ -14,5 +15,6 @@ export const tsRestrictionsRules = {
   'no-string-spread': noStringSpread,
   'no-unnecessary-array-from': noUnnecessaryArrayFrom,
   'no-unnecessary-coalesce-undefined': noUnnecessaryCoalesceUndefined,
+  'prefer-curried-call': preferCurriedCall,
   'prefer-non-mutating-array-method': preferNonMutatingArrayMethod,
 } as const satisfies ESLintPlugin['rules'];

package/src/rules/eslint-ts-restrictions-rules.mts

@@ -9,6 +9,7 @@ export const eslintTsRestrictionsRules = {
   '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/src/types/rules/eslint-ts-restrictions-rules.mts

@@ -279,6 +279,21 @@ namespace NoUnnecessaryCoalesceUndefined {
   export 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       |
+ *  ```
+ */
+namespace PreferCurriedCall {
+  export 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()`)
  *
@@ -301,6 +316,7 @@ export type EslintTsRestrictionsRules = Readonly<{
   '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;
 }>;