ts-transform-args 0.1.0 → 0.1.1

package/dist/transformer.js

@@ -7,6 +7,19 @@ const ts_helpers_1 = require("./util/ts-helpers");
 function transformer(program, opts) {
     const markerName = opts?.markerName ?? 'CallArgs';
     const checker = program.getTypeChecker();
+    const RESERVED_NAMES = new Set([
+        'arguments', 'eval',
+        'break', 'case', 'catch', 'continue', 'debugger', 'default', 'delete',
+        'do', 'else', 'finally', 'for', 'function', 'if', 'in', 'instanceof',
+        'new', 'return', 'switch', 'this', 'throw', 'try', 'typeof', 'var',
+        'void', 'while', 'with', 'class', 'const', 'enum', 'export', 'extends',
+        'import', 'super', 'implements', 'interface', 'let', 'package',
+        'private', 'protected', 'public', 'static', 'yield', 'await',
+    ]);
+    /** Return a safe identifier name, prefixing reserved words with `_`. */
+    function safeName(name) {
+        return RESERVED_NAMES.has(name) ? `_${name}` : name;
+    }
     return (context) => {
         const { factory } = context;
         /** Rewrites `paramName.prop` and `paramName["prop"]` to `prop`. */
@@ -18,7 +31,7 @@ function transformer(program, opts) {
                     if ((0, ts_helpers_1.isIdentifier)(propAccess.expression) &&
                         propAccess.expression.text === paramName &&
                         propSet.has(propAccess.name.text)) {
-                        return factory.createIdentifier(propAccess.name.text);
+                        return factory.createIdentifier(safeName(propAccess.name.text));
                     }
                 }
                 if ((0, ts_helpers_1.isElementAccessExpression)(node)) {
@@ -27,9 +40,24 @@ function transformer(program, opts) {
                         elemAccess.expression.text === paramName &&
                         (0, ts_helpers_1.isStringLiteral)(elemAccess.argumentExpression) &&
                         propSet.has(elemAccess.argumentExpression.text)) {
-                        return factory.createIdentifier(elemAccess.argumentExpression.text);
+                        return factory.createIdentifier(safeName(elemAccess.argumentExpression.text));
                     }
                 }
+                if ((0, ts_helpers_1.isCallExpression)(node) || (0, ts_helpers_1.isNewExpression)(node)) {
+                    const callOrNew = node;
+                    const callArgsInfo = analyzeCallArgs(callOrNew);
+                    // Rewrite children first (property accesses → identifiers)
+                    const rewritten = (0, ts_helpers_1.visitEachChild)(node, bodyVisitor, context);
+                    if (callArgsInfo) {
+                        return applyCallArgsExpansion(rewritten, callArgsInfo);
+                    }
+                    return rewritten;
+                }
+                if ((0, ts_helpers_1.isFunctionLike)(node)) {
+                    const rewritten = (0, ts_helpers_1.visitEachChild)(node, bodyVisitor, context);
+                    const transformed = tryTransformFunction(rewritten);
+                    return transformed ?? rewritten;
+                }
                 return (0, ts_helpers_1.visitEachChild)(node, bodyVisitor, context);
             };
             return bodyVisitor;
@@ -71,7 +99,7 @@ function transformer(program, opts) {
             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));
+                        result.push(factory.createParameterDeclaration(undefined, undefined, factory.createIdentifier(safeName(name)), undefined, undefined, undefined));
                     }
                 }
                 else {
@@ -127,12 +155,90 @@ function transformer(program, opts) {
             const expanded = [];
             for (const name of propOrder) {
                 const expr = propExpressions.get(name);
-                if (!expr)
-                    return null;
-                expanded.push(expr);
+                expanded.push(expr ?? factory.createVoidZero());
+            }
+            // Trim trailing `void 0` args (optional properties at the end)
+            while (expanded.length > 0 &&
+                expanded[expanded.length - 1].kind === (0, ts_helpers_1.getTS)().SyntaxKind.VoidExpression) {
+                expanded.pop();
             }
             return expanded;
         }
+        function analyzeCallArgs(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 argExpansions = [];
+            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 && (0, ts_helpers_1.isObjectLiteralExpression)(arg)) {
+                    const paramType = sigParam.valueDeclaration
+                        ? checker.getTypeOfSymbolAtLocation(sigParam, sigParam.valueDeclaration)
+                        : null;
+                    if (paramType && (0, call_args_1.extendsCallArgs)(paramType, checker, markerName)) {
+                        const propOrder = (0, call_args_1.getPropertyOrder)(paramType, checker);
+                        if (propOrder) {
+                            argExpansions.push(propOrder);
+                            anyExpanded = true;
+                            continue;
+                        }
+                    }
+                }
+                argExpansions.push(null);
+            }
+            return anyExpanded ? { argExpansions } : null;
+        }
+        function applyCallArgsExpansion(callOrNew, info) {
+            const args = callOrNew.arguments;
+            const newArgs = [];
+            for (let i = 0; i < args.length; i++) {
+                const arg = args[i];
+                const propOrder = info.argExpansions[i];
+                if (propOrder && (0, ts_helpers_1.isObjectLiteralExpression)(arg)) {
+                    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, prop.initializer);
+                        }
+                        else if ((0, ts_helpers_1.isShorthandPropertyAssignment)(prop)) {
+                            const name = prop.name.getText();
+                            propExpressions.set(name, prop.name);
+                        }
+                    }
+                    const expanded = [];
+                    for (const name of propOrder) {
+                        const expr = propExpressions.get(name);
+                        expanded.push(expr ?? factory.createVoidZero());
+                    }
+                    // Trim trailing `void 0` args (optional properties at the end)
+                    while (expanded.length > 0 &&
+                        expanded[expanded.length - 1].kind === (0, ts_helpers_1.getTS)().SyntaxKind.VoidExpression) {
+                        expanded.pop();
+                    }
+                    {
+                        newArgs.push(...expanded);
+                        continue;
+                    }
+                }
+                // Pass through unchanged
+                newArgs.push(arg);
+            }
+            if ((0, ts_helpers_1.isCallExpression)(callOrNew)) {
+                const call = callOrNew;
+                return factory.updateCallExpression(call, call.expression, call.typeArguments, newArgs);
+            }
+            const newExpr = callOrNew;
+            return factory.updateNewExpression(newExpr, newExpr.expression, newExpr.typeArguments, newArgs);
+        }
         /** Transform call/new expression args, expanding CallArgs objects. */
         function tryTransformCallArgs(callOrNew) {
             if (!callOrNew.arguments || callOrNew.arguments.length === 0)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ts-transform-args",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "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",