ts-transform-args 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 swe
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,69 @@
+# ts-transform-args
+
+TypeScript compiler transformer that rewrites option objects into positional arguments at compile time. Eliminates short-lived allocations on hot paths while keeping source code readable.
+
+```ts
+// source
+createParticle({ x: pos.x, y: pos.y, vx: 0.1, vy: -0.3, ttl: 60 });
+
+// emitted JS
+createParticle(pos.x, pos.y, 0.1, -0.3, 60);
+```
+
+Function bodies are rewritten too (`opts.x` becomes `x`), so the option object is fully eliminated.
+
+## Setup
+
+```bash
+npm install ts-transform-args typescript ts-patch
+npx ts-patch install
+```
+
+**tsconfig.json:**
+
+```json
+{
+  "compilerOptions": {
+    "types": ["ts-transform-args"],
+    "plugins": [{ "transform": "ts-transform-args" }]
+  }
+}
+```
+
+Adding `"ts-transform-args"` to `types` makes the `CallArgs` interface available globally without imports. If you use other type packages (e.g. `@types/node`), include them too since an explicit `types` array overrides automatic `@types` resolution.
+
+## Usage
+
+Define an interface extending `CallArgs`. Property declaration order determines argument position.
+
+```ts
+interface Opts extends CallArgs {
+  name: string;
+  age: number;
+  active: boolean;
+}
+
+declare function createUser(opts: Opts): void;
+
+createUser({ active: true, name: "alice", age: 30 });
+// emits: createUser("alice", 30, true)
+```
+
+Multiple CallArgs parameters, plain parameters mixed with CallArgs, constructors, and methods are all supported.
+
+## Programmatic API
+
+```ts
+import { transformSource } from 'ts-transform-args/compile';
+
+const js = transformSource(`
+  interface Opts extends CallArgs { x: number; y: number; }
+  declare function move(opts: Opts): void;
+  move({ x: 10, y: 20 });
+`);
+// js => 'move(10, 20);'
+```
+
+## License
+
+MIT

package/dist/compile.d.ts

@@ -0,0 +1,6 @@
+import * as ts from 'typescript';
+import type { TransformerOptions } from './transformer';
+/** Compile files with the args transformer applied. */
+export declare function compile(fileNames: string[], compilerOptions: ts.CompilerOptions, transformerOpts?: TransformerOptions): ts.EmitResult;
+/** Transform a single source string and return the emitted JS. */
+export declare function transformSource(source: string, transformerOpts?: TransformerOptions): string;

package/dist/compile.js

@@ -0,0 +1,81 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compile = compile;
+exports.transformSource = transformSource;
+const ts = __importStar(require("typescript"));
+const transformer_1 = __importDefault(require("./transformer"));
+/** Compile files with the args transformer applied. */
+function compile(fileNames, compilerOptions, transformerOpts) {
+    const program = ts.createProgram(fileNames, compilerOptions);
+    const result = program.emit(undefined, undefined, undefined, false, {
+        before: [(0, transformer_1.default)(program, transformerOpts)],
+    });
+    return result;
+}
+/** Transform a single source string and return the emitted JS. */
+function transformSource(source, transformerOpts) {
+    const fileName = 'input.ts';
+    const sourceFile = ts.createSourceFile(fileName, source, ts.ScriptTarget.Latest, true);
+    const compilerOptions = {
+        target: ts.ScriptTarget.ES2020,
+        module: ts.ModuleKind.CommonJS,
+        strict: false,
+    };
+    const defaultHost = ts.createCompilerHost(compilerOptions);
+    const customHost = {
+        ...defaultHost,
+        getSourceFile: (name, languageVersion) => {
+            if (name === fileName)
+                return sourceFile;
+            return defaultHost.getSourceFile(name, languageVersion);
+        },
+        fileExists: (name) => name === fileName || defaultHost.fileExists(name),
+        readFile: (name) => name === fileName ? source : defaultHost.readFile(name),
+    };
+    const program = ts.createProgram([fileName], compilerOptions, customHost);
+    let output = '';
+    program.emit(undefined, (emittedFileName, data) => {
+        if (emittedFileName.endsWith('.js')) {
+            output = data;
+        }
+    }, undefined, false, {
+        before: [(0, transformer_1.default)(program, transformerOpts)],
+    });
+    return output;
+}

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export { default as transformer } from './transformer';
+export { default } from './transformer';
+export type { TransformerOptions } from './transformer';
+export type { CallArgs } from './types';

package/dist/index.js

@@ -0,0 +1,10 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = exports.transformer = void 0;
+var transformer_1 = require("./transformer");
+Object.defineProperty(exports, "transformer", { enumerable: true, get: function () { return __importDefault(transformer_1).default; } });
+var transformer_2 = require("./transformer");
+Object.defineProperty(exports, "default", { enumerable: true, get: function () { return __importDefault(transformer_2).default; } });

package/dist/transformer.d.ts

@@ -0,0 +1,8 @@
+import type ts from 'typescript';
+export interface TransformerOptions {
+    /** @default "CallArgs" */
+    markerName?: string;
+}
+/** ts-patch / ttypescript compatible transformer factory. */
+declare function transformer(program: ts.Program, opts?: TransformerOptions): ts.TransformerFactory<ts.SourceFile>;
+export default transformer;

package/dist/transformer.js

@@ -0,0 +1,190 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const call_args_1 = require("./util/call-args");
+const update_node_1 = require("./util/update-node");
+const ts_helpers_1 = require("./util/ts-helpers");
+/** ts-patch / ttypescript compatible transformer factory. */
+function transformer(program, opts) {
+    const markerName = opts?.markerName ?? 'CallArgs';
+    const checker = program.getTypeChecker();
+    return (context) => {
+        const { factory } = context;
+        /** Rewrites `paramName.prop` and `paramName["prop"]` to `prop`. */
+        function createBodyRewriter(paramName, propOrder) {
+            const propSet = new Set(propOrder);
+            const bodyVisitor = (node) => {
+                if ((0, ts_helpers_1.isPropertyAccessExpression)(node)) {
+                    const propAccess = node;
+                    if ((0, ts_helpers_1.isIdentifier)(propAccess.expression) &&
+                        propAccess.expression.text === paramName &&
+                        propSet.has(propAccess.name.text)) {
+                        return factory.createIdentifier(propAccess.name.text);
+                    }
+                }
+                if ((0, ts_helpers_1.isElementAccessExpression)(node)) {
+                    const elemAccess = node;
+                    if ((0, ts_helpers_1.isIdentifier)(elemAccess.expression) &&
+                        elemAccess.expression.text === paramName &&
+                        (0, ts_helpers_1.isStringLiteral)(elemAccess.argumentExpression) &&
+                        propSet.has(elemAccess.argumentExpression.text)) {
+                        return factory.createIdentifier(elemAccess.argumentExpression.text);
+                    }
+                }
+                return (0, ts_helpers_1.visitEachChild)(node, bodyVisitor, context);
+            };
+            return bodyVisitor;
+        }
+        /** Analyze params and return info about which are CallArgs. */
+        function analyzeParams(params) {
+            const infos = [];
+            let hasAny = false;
+            for (const param of params) {
+                const paramSymbol = checker.getSymbolAtLocation(param.name);
+                if (!paramSymbol) {
+                    infos.push({ isCallArgs: false, paramName: '', propOrder: null, original: param });
+                    continue;
+                }
+                const paramType = checker.getTypeOfSymbolAtLocation(paramSymbol, param);
+                if ((0, call_args_1.extendsCallArgs)(paramType, checker, markerName)) {
+                    const propOrder = (0, call_args_1.getPropertyOrder)(paramType, checker);
+                    if (!propOrder) {
+                        infos.push({ isCallArgs: false, paramName: '', propOrder: null, original: param });
+                        continue;
+                    }
+                    hasAny = true;
+                    infos.push({
+                        isCallArgs: true,
+                        paramName: param.name.getText(),
+                        propOrder,
+                        original: param,
+                    });
+                }
+                else {
+                    infos.push({ isCallArgs: false, paramName: '', propOrder: null, original: param });
+                }
+            }
+            return hasAny ? infos : null;
+        }
+        /** Expand CallArgs params into positional params, keep others. */
+        function buildNewParams(infos) {
+            const result = [];
+            for (const info of infos) {
+                if (info.isCallArgs && info.propOrder) {
+                    for (const name of info.propOrder) {
+                        result.push(factory.createParameterDeclaration(undefined, undefined, factory.createIdentifier(name), undefined, undefined, undefined));
+                    }
+                }
+                else {
+                    result.push(factory.createParameterDeclaration(info.original.modifiers, info.original.dotDotDotToken, info.original.name, info.original.questionToken, undefined, info.original.initializer));
+                }
+            }
+            return result;
+        }
+        /** Rewrite function body, replacing all CallArgs param accesses. */
+        function rewriteBody(body, infos) {
+            let result = body;
+            for (const info of infos) {
+                if (info.isCallArgs && info.propOrder) {
+                    const rewriter = createBodyRewriter(info.paramName, info.propOrder);
+                    result = (0, ts_helpers_1.visitNode)(result, rewriter);
+                }
+            }
+            return result;
+        }
+        /** Transform a function-like declaration if it has CallArgs params. */
+        function tryTransformFunction(node) {
+            if (node.parameters.length === 0)
+                return null;
+            const infos = analyzeParams(node.parameters);
+            if (!infos)
+                return null;
+            const newParams = buildNewParams(infos);
+            const newBody = node.body ? rewriteBody(node.body, infos) : node.body;
+            return (0, update_node_1.updateFunctionLike)(node, factory, newParams, newBody);
+        }
+        /** Try expanding a CallArgs object literal arg into positional args. */
+        function tryExpandArg(arg, sigParam) {
+            if (!(0, ts_helpers_1.isObjectLiteralExpression)(arg))
+                return null;
+            const paramType = checker.getTypeOfSymbolAtLocation(sigParam, sigParam.valueDeclaration);
+            if (!(0, call_args_1.extendsCallArgs)(paramType, checker, markerName))
+                return null;
+            const propOrder = (0, call_args_1.getPropertyOrder)(paramType, checker);
+            if (!propOrder)
+                return null;
+            const objLiteral = arg;
+            const propExpressions = new Map();
+            for (const prop of objLiteral.properties) {
+                if ((0, ts_helpers_1.isPropertyAssignment)(prop) && prop.name) {
+                    const name = prop.name.getText();
+                    propExpressions.set(name, (0, ts_helpers_1.visitNode)(prop.initializer, visitor));
+                }
+                else if ((0, ts_helpers_1.isShorthandPropertyAssignment)(prop)) {
+                    const name = prop.name.getText();
+                    propExpressions.set(name, (0, ts_helpers_1.visitNode)(prop.name, visitor));
+                }
+            }
+            const expanded = [];
+            for (const name of propOrder) {
+                const expr = propExpressions.get(name);
+                if (!expr)
+                    return null;
+                expanded.push(expr);
+            }
+            return expanded;
+        }
+        /** Transform call/new expression args, expanding CallArgs objects. */
+        function tryTransformCallArgs(callOrNew) {
+            if (!callOrNew.arguments || callOrNew.arguments.length === 0)
+                return null;
+            const signature = checker.getResolvedSignature(callOrNew);
+            if (!signature)
+                return null;
+            const sigParams = signature.getParameters();
+            if (sigParams.length === 0)
+                return null;
+            const newArgs = [];
+            let anyExpanded = false;
+            for (let i = 0; i < callOrNew.arguments.length; i++) {
+                const arg = callOrNew.arguments[i];
+                const sigParam = i < sigParams.length ? sigParams[i] : null;
+                if (sigParam) {
+                    const expanded = tryExpandArg(arg, sigParam);
+                    if (expanded) {
+                        newArgs.push(...expanded);
+                        anyExpanded = true;
+                        continue;
+                    }
+                }
+                newArgs.push((0, ts_helpers_1.visitNode)(arg, visitor));
+            }
+            return anyExpanded ? newArgs : null;
+        }
+        const visitor = (node) => {
+            if ((0, ts_helpers_1.isFunctionLike)(node)) {
+                const transformed = tryTransformFunction(node);
+                if (transformed)
+                    return transformed;
+                return (0, ts_helpers_1.visitEachChild)(node, visitor, context);
+            }
+            if (!(0, ts_helpers_1.isCallExpression)(node) && !(0, ts_helpers_1.isNewExpression)(node)) {
+                return (0, ts_helpers_1.visitEachChild)(node, visitor, context);
+            }
+            const callOrNew = node;
+            const newArgs = tryTransformCallArgs(callOrNew);
+            if (!newArgs) {
+                return (0, ts_helpers_1.visitEachChild)(node, visitor, context);
+            }
+            if ((0, ts_helpers_1.isCallExpression)(node)) {
+                const call = node;
+                return factory.updateCallExpression(call, (0, ts_helpers_1.visitNode)(call.expression, visitor), call.typeArguments, newArgs);
+            }
+            const newExpr = node;
+            return factory.updateNewExpression(newExpr, (0, ts_helpers_1.visitNode)(newExpr.expression, visitor), newExpr.typeArguments, newArgs);
+        };
+        return (sourceFile) => {
+            return (0, ts_helpers_1.visitNode)(sourceFile, visitor);
+        };
+    };
+}
+exports.default = transformer;

package/dist/types.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Marker interface. Extending this opts-in an interface for
+ * object-to-positional-args transformation at compile time.
+ */
+export interface CallArgs {
+    readonly __callArgs?: never;
+}
+declare global {
+    interface CallArgs {
+        readonly __callArgs?: never;
+    }
+}

package/dist/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/util/call-args.d.ts

@@ -0,0 +1,6 @@
+import type ts from 'typescript';
+export declare const BRAND_FIELD = "__callArgs";
+/** Structural + nominal check for CallArgs marker. */
+export declare function extendsCallArgs(type: ts.Type, checker: ts.TypeChecker, markerName: string): boolean;
+/** Property names in declaration order (excluding brand). */
+export declare function getPropertyOrder(type: ts.Type, _checker: ts.TypeChecker): string[] | null;

package/dist/util/call-args.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BRAND_FIELD = void 0;
+exports.extendsCallArgs = extendsCallArgs;
+exports.getPropertyOrder = getPropertyOrder;
+exports.BRAND_FIELD = '__callArgs';
+/** Structural + nominal check for CallArgs marker. */
+function extendsCallArgs(type, checker, markerName) {
+    if (type.getProperty(exports.BRAND_FIELD))
+        return true;
+    const baseTypes = type.getBaseTypes?.() ?? [];
+    for (const base of baseTypes) {
+        const sym = base.getSymbol?.();
+        if (sym && sym.getName() === markerName)
+            return true;
+        if (extendsCallArgs(base, checker, markerName))
+            return true;
+    }
+    return false;
+}
+/** Property names in declaration order (excluding brand). */
+function getPropertyOrder(type, _checker) {
+    const properties = type.getProperties();
+    if (properties.length === 0)
+        return null;
+    const names = [];
+    for (const prop of properties) {
+        const name = prop.getName();
+        if (name === exports.BRAND_FIELD)
+            continue;
+        names.push(name);
+    }
+    return names.length > 0 ? names : null;
+}

package/dist/util/ts-helpers.d.ts

@@ -0,0 +1,19 @@
+import type ts from 'typescript';
+export declare function getTS(): typeof ts;
+export declare function isCallExpression(node: ts.Node): node is ts.CallExpression;
+export declare function isNewExpression(node: ts.Node): node is ts.NewExpression;
+export declare function isObjectLiteralExpression(node: ts.Node): node is ts.ObjectLiteralExpression;
+export declare function isPropertyAssignment(node: ts.Node): node is ts.PropertyAssignment;
+export declare function isShorthandPropertyAssignment(node: ts.Node): node is ts.ShorthandPropertyAssignment;
+export declare function isPropertyAccessExpression(node: ts.Node): node is ts.PropertyAccessExpression;
+export declare function isElementAccessExpression(node: ts.Node): node is ts.ElementAccessExpression;
+export declare function isIdentifier(node: ts.Node): node is ts.Identifier;
+export declare function isStringLiteral(node: ts.Node): node is ts.StringLiteral;
+export declare function isFunctionDeclaration(node: ts.Node): node is ts.FunctionDeclaration;
+export declare function isFunctionExpression(node: ts.Node): node is ts.FunctionExpression;
+export declare function isArrowFunction(node: ts.Node): node is ts.ArrowFunction;
+export declare function isMethodDeclaration(node: ts.Node): node is ts.MethodDeclaration;
+export declare function isConstructorDeclaration(node: ts.Node): node is ts.ConstructorDeclaration;
+export declare function isFunctionLike(node: ts.Node): node is ts.FunctionDeclaration | ts.FunctionExpression | ts.ArrowFunction | ts.MethodDeclaration | ts.ConstructorDeclaration;
+export declare function visitNode(node: ts.Node, visitor: ts.Visitor): ts.Node | undefined;
+export declare function visitEachChild(node: ts.Node, visitor: ts.Visitor, context: ts.TransformationContext): ts.Node;

package/dist/util/ts-helpers.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTS = getTS;
+exports.isCallExpression = isCallExpression;
+exports.isNewExpression = isNewExpression;
+exports.isObjectLiteralExpression = isObjectLiteralExpression;
+exports.isPropertyAssignment = isPropertyAssignment;
+exports.isShorthandPropertyAssignment = isShorthandPropertyAssignment;
+exports.isPropertyAccessExpression = isPropertyAccessExpression;
+exports.isElementAccessExpression = isElementAccessExpression;
+exports.isIdentifier = isIdentifier;
+exports.isStringLiteral = isStringLiteral;
+exports.isFunctionDeclaration = isFunctionDeclaration;
+exports.isFunctionExpression = isFunctionExpression;
+exports.isArrowFunction = isArrowFunction;
+exports.isMethodDeclaration = isMethodDeclaration;
+exports.isConstructorDeclaration = isConstructorDeclaration;
+exports.isFunctionLike = isFunctionLike;
+exports.visitNode = visitNode;
+exports.visitEachChild = visitEachChild;
+let _ts;
+function getTS() {
+    if (!_ts) {
+        _ts = require('typescript');
+    }
+    return _ts;
+}
+function isCallExpression(node) {
+    return node.kind === getTS().SyntaxKind.CallExpression;
+}
+function isNewExpression(node) {
+    return node.kind === getTS().SyntaxKind.NewExpression;
+}
+function isObjectLiteralExpression(node) {
+    return node.kind === getTS().SyntaxKind.ObjectLiteralExpression;
+}
+function isPropertyAssignment(node) {
+    return node.kind === getTS().SyntaxKind.PropertyAssignment;
+}
+function isShorthandPropertyAssignment(node) {
+    return node.kind === getTS().SyntaxKind.ShorthandPropertyAssignment;
+}
+function isPropertyAccessExpression(node) {
+    return node.kind === getTS().SyntaxKind.PropertyAccessExpression;
+}
+function isElementAccessExpression(node) {
+    return node.kind === getTS().SyntaxKind.ElementAccessExpression;
+}
+function isIdentifier(node) {
+    return node.kind === getTS().SyntaxKind.Identifier;
+}
+function isStringLiteral(node) {
+    return node.kind === getTS().SyntaxKind.StringLiteral;
+}
+function isFunctionDeclaration(node) {
+    return node.kind === getTS().SyntaxKind.FunctionDeclaration;
+}
+function isFunctionExpression(node) {
+    return node.kind === getTS().SyntaxKind.FunctionExpression;
+}
+function isArrowFunction(node) {
+    return node.kind === getTS().SyntaxKind.ArrowFunction;
+}
+function isMethodDeclaration(node) {
+    return node.kind === getTS().SyntaxKind.MethodDeclaration;
+}
+function isConstructorDeclaration(node) {
+    return node.kind === getTS().SyntaxKind.Constructor;
+}
+function isFunctionLike(node) {
+    return (isFunctionDeclaration(node) ||
+        isFunctionExpression(node) ||
+        isArrowFunction(node) ||
+        isMethodDeclaration(node) ||
+        isConstructorDeclaration(node));
+}
+function visitNode(node, visitor) {
+    return getTS().visitNode(node, visitor);
+}
+function visitEachChild(node, visitor, context) {
+    return getTS().visitEachChild(node, visitor, context);
+}

package/dist/util/update-node.d.ts

@@ -0,0 +1,5 @@
+import type ts from 'typescript';
+type FunctionLikeNode = ts.FunctionDeclaration | ts.FunctionExpression | ts.ArrowFunction | ts.MethodDeclaration | ts.ConstructorDeclaration;
+/** Update any function-like node with new params and body. */
+export declare function updateFunctionLike(node: FunctionLikeNode, factory: ts.NodeFactory, newParams: ts.ParameterDeclaration[], newBody: typeof node.body): ts.Node | null;
+export {};

package/dist/util/update-node.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.updateFunctionLike = updateFunctionLike;
+const ts_helpers_1 = require("./ts-helpers");
+/** Update any function-like node with new params and body. */
+function updateFunctionLike(node, factory, newParams, newBody) {
+    if ((0, ts_helpers_1.isFunctionDeclaration)(node)) {
+        return factory.updateFunctionDeclaration(node, node.modifiers, node.asteriskToken, node.name, node.typeParameters, newParams, undefined, newBody);
+    }
+    if ((0, ts_helpers_1.isFunctionExpression)(node)) {
+        return factory.updateFunctionExpression(node, node.modifiers, node.asteriskToken, node.name, node.typeParameters, newParams, undefined, newBody);
+    }
+    if ((0, ts_helpers_1.isArrowFunction)(node)) {
+        return factory.updateArrowFunction(node, node.modifiers, node.typeParameters, newParams, undefined, node.equalsGreaterThanToken, newBody);
+    }
+    if ((0, ts_helpers_1.isMethodDeclaration)(node)) {
+        return factory.updateMethodDeclaration(node, node.modifiers, node.asteriskToken, node.name, node.questionToken, node.typeParameters, newParams, undefined, newBody);
+    }
+    if ((0, ts_helpers_1.isConstructorDeclaration)(node)) {
+        return factory.updateConstructorDeclaration(node, node.modifiers, newParams, newBody);
+    }
+    return null;
+}

package/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "ts-transform-args",
+  "version": "0.1.0",
+  "description": "TypeScript transformer that eliminates option object allocations by converting them into positional arguments at compile time. Readable code, zero GC overhead",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "prepublish": "npm run build",
+    "build": "tsc",
+    "test": "npm run build && cd example-project && npm install && npm run build && npm start && cd .. && node tests/snapshot-test.js"
+  },
+  "keywords": [
+    "typescript",
+    "transformer",
+    "ts-patch",
+    "arguments"
+  ],
+  "license": "MIT",
+  "peerDependencies": {
+    "typescript": ">=4.7.0"
+  },
+  "devDependencies": {
+    "@types/node": "^25.3.0",
+    "ts-patch": "^3.1.0",
+    "typescript": "^5.3.0"
+  }
+}