@ugo-studio/jspp 0.2.7 → 0.2.9

package/dist/analysis/typeAnalyzer.js

@@ -450,39 +450,54 @@ export class TypeAnalyzer {
                         }
                         if (isAmbient)
                             return;
-                        const name = node.name.getText();
                         const isBlockScoped = (node.parent.flags &
                             (ts.NodeFlags.Let | ts.NodeFlags.Const)) !== 0;
                         const isConst = (node.parent.flags & ts.NodeFlags.Const) !== 0;
-                        let type = "auto";
-                        let needsHeap = false;
-                        if (node.initializer) {
-                            if (ts.isArrayLiteralExpression(node.initializer)) {
-                                type = "array";
-                            }
-                            else if (ts.isArrowFunction(node.initializer) ||
-                                ts.isFunctionExpression(node.initializer)) {
-                                type = "function";
-                                needsHeap = true;
+                        const defineName = (nameNode) => {
+                            if (ts.isIdentifier(nameNode)) {
+                                const name = nameNode.text;
+                                let type = "auto";
+                                let needsHeap = false;
+                                // Type inference only for simple identifiers
+                                if (nameNode === node.name && node.initializer) {
+                                    if (ts.isArrayLiteralExpression(node.initializer)) {
+                                        type = "array";
+                                    }
+                                    else if (ts.isArrowFunction(node.initializer) ||
+                                        ts.isFunctionExpression(node.initializer)) {
+                                        type = "function";
+                                        needsHeap = true;
+                                    }
+                                    else if (ts.isIdentifier(node.initializer)) {
+                                        const typeInfo = this.scopeManager
+                                            .lookup(node.initializer.text);
+                                        needsHeap =
+                                            typeInfo?.needsHeapAllocation ??
+                                                false;
+                                    }
+                                }
+                                const typeInfo = {
+                                    type,
+                                    declaration: node,
+                                    isConst,
+                                    needsHeapAllocation: needsHeap,
+                                };
+                                if (isBlockScoped) {
+                                    this.scopeManager.define(name, typeInfo);
+                                }
+                                else {
+                                    this.scopeManager.defineVar(name, typeInfo);
+                                }
                             }
-                            else if (ts.isIdentifier(node.initializer)) {
-                                const typeInfo = this.scopeManager.lookup(node.initializer.text);
-                                needsHeap = typeInfo?.needsHeapAllocation ??
-                                    false;
+                            else {
+                                nameNode.elements.forEach((element) => {
+                                    if (ts.isBindingElement(element)) {
+                                        defineName(element.name);
+                                    }
+                                });
                             }
-                        }
-                        const typeInfo = {
-                            type,
-                            declaration: node,
-                            isConst,
-                            needsHeapAllocation: needsHeap,
                         };
-                        if (isBlockScoped) {
-                            this.scopeManager.define(name, typeInfo);
-                        }
-                        else {
-                            this.scopeManager.defineVar(name, typeInfo);
-                        }
+                        defineName(node.name);
                     }
                 },
             },

package/dist/core/codegen/class-handlers.js

@@ -42,7 +42,7 @@ export function visitClassDeclaration(node, context) {
         // Default constructor
         if (parentName) {
             constructorLambda =
-                `jspp::AnyValue::make_class([=](const jspp::AnyValue& ${this.globalThisVar}, std::span<const jspp::AnyValue> args) mutable -> jspp::AnyValue {
+                `jspp::AnyValue::make_class([=](jspp::AnyValue ${this.globalThisVar}, std::span<const jspp::AnyValue> args) mutable -> jspp::AnyValue {
                  auto __parent = ${parentName};
                  __parent.call(${this.globalThisVar}, args, "super");
                  return jspp::Constants::UNDEFINED;
@@ -50,7 +50,7 @@ export function visitClassDeclaration(node, context) {
         }
         else {
             constructorLambda =
-                `jspp::AnyValue::make_class([=](const jspp::AnyValue& ${this.globalThisVar}, std::span<const jspp::AnyValue> args) mutable -> jspp::AnyValue {
+                `jspp::AnyValue::make_class([=](jspp::AnyValue ${this.globalThisVar}, std::span<const jspp::AnyValue> args) mutable -> jspp::AnyValue {
                  return jspp::Constants::UNDEFINED;
              }, "${className}")`;
         }

package/dist/core/codegen/control-flow-handlers.js

@@ -234,11 +234,11 @@ export function visitForOfStatement(node, context) {
     code += `${this.indent()}auto ${iterableRef} = ${derefIterable};\n`;
     if (isAwait) {
         code +=
-            `${this.indent()}auto ${iterator} = jspp::Access::get_async_object_value_iterator(${iterableRef}, ${varName});\n`;
+            `${this.indent()}auto ${iterator} = jspp::Access::get_object_async_iterator(${iterableRef}, ${varName});\n`;
     }
     else {
         code +=
-            `${this.indent()}auto ${iterator} = jspp::Access::get_object_value_iterator(${iterableRef}, ${varName});\n`;
+            `${this.indent()}auto ${iterator} = jspp::Access::get_object_iterator(${iterableRef}, ${varName});\n`;
     }
     code +=
         `${this.indent()}auto ${nextFunc} = ${iterator}.get_own_property("next");\n`;
@@ -459,8 +459,8 @@ export function visitSwitchStatement(node, context) {
         const nativeLambda = this.generateNativeLambda(lambdaComps);
         code += `${this.indent()}auto ${nativeName} = ${nativeLambda};\n`;
         // Generate AnyValue wrapper
-        if (this.isFunctionUsedAsValue(stmt, node) ||
-            this.isFunctionUsedBeforeDeclaration(funcName, node)) {
+        if (this.isDeclarationUsedAsValue(stmt, node) ||
+            this.isDeclarationUsedBeforeInitialization(funcName, node)) {
             const wrappedLambda = this.generateWrappedLambda(lambdaComps);
             code += `${this.indent()}*${funcName} = ${wrappedLambda};\n`;
         }

package/dist/core/codegen/declaration-handlers.js

@@ -9,6 +9,13 @@ export function visitVariableDeclarationList(node, context) {
 }
 export function visitVariableDeclaration(node, context) {
     const varDecl = node;
+    if (!ts.isIdentifier(varDecl.name)) {
+        // Handle destructuring
+        const rhsCode = varDecl.initializer
+            ? this.visit(varDecl.initializer, context)
+            : "jspp::Constants::UNDEFINED";
+        return this.generateDestructuring(varDecl.name, rhsCode, context);
+    }
     const name = varDecl.name.getText();
     const scope = this.getScopeForNode(varDecl);
     const typeInfo = this.typeAnalyzer.scopeManager.lookupFromScope(name, scope);
@@ -45,6 +52,9 @@ export function visitVariableDeclaration(node, context) {
                 lambdaName: name, // Use the variable name as function name
             };
             const nativeName = this.generateUniqueName(`__${name}_native_`, context.localScopeSymbols, context.globalScopeSymbols);
+            const scopeNode = ts.isVariableDeclarationList(varDecl.parent)
+                ? varDecl.parent.parent.parent
+                : varDecl.parent;
             // Mark before further visits
             context.localScopeSymbols.update(name, {
                 features: {
@@ -61,11 +71,19 @@ export function visitVariableDeclaration(node, context) {
                 nativeName,
                 noTypeSignature: true,
             });
-            const nativeLambda = this.generateNativeLambda(lambdaComps);
             // Generate native lambda
-            nativeLambdaCode = `auto ${nativeName} = ${nativeLambda}`;
+            if (this.isDeclarationCalledAsFunction(varDecl, scopeNode)) {
+                const nativeLambda = this.generateNativeLambda(lambdaComps);
+                nativeLambdaCode = `auto ${nativeName} = ${nativeLambda}`;
+            }
             // Generate AnyValue wrapper
-            initText = this.generateWrappedLambda(lambdaComps);
+            if (this.isDeclarationUsedAsValue(varDecl, scopeNode) ||
+                this.isDeclarationUsedBeforeInitialization(name, scopeNode)) {
+                initText = this.generateWrappedLambda(lambdaComps);
+            }
+            else {
+                return nativeLambdaCode;
+            }
         }
         initializer = " = " + initText;
     }

package/dist/core/codegen/destructuring-handlers.js

@@ -0,0 +1,187 @@
+import ts from "typescript";
+import { visitObjectPropertyName } from "./expression-handlers.js";
+import { CodeGenerator } from "./index.js";
+import {} from "./visitor.js";
+export function generateDestructuring(lhs, rhsCode, context) {
+    const declaredSymbols = this.getDeclaredSymbols(lhs);
+    const sourceVar = this.generateUniqueName("__destruct_src", declaredSymbols, context.localScopeSymbols, context.globalScopeSymbols);
+    let code = `([&]() {\n`;
+    this.indentationLevel++;
+    code += `${this.indent()}auto ${sourceVar} = ${rhsCode};\n`;
+    const genAssignment = (pattern, valueCode) => {
+        if (ts.isIdentifier(pattern)) {
+            const name = pattern.text;
+            const scope = this.getScopeForNode(pattern);
+            const typeInfo = this.typeAnalyzer.scopeManager.lookupFromScope(name, scope);
+            // Mark initialized if it's a declaration
+            this.markSymbolAsInitialized(name, context.globalScopeSymbols, context.localScopeSymbols);
+            let target = this.visit(pattern, context);
+            if (typeInfo?.needsHeapAllocation) {
+                target = `(*${target})`;
+            }
+            return `${this.indent()}${target} = ${valueCode};\n`;
+        }
+        else if (ts.isPropertyAccessExpression(pattern)) {
+            const objCode = this.visit(pattern.expression, context);
+            const propName = visitObjectPropertyName.call(this, pattern.name, context);
+            return `${this.indent()}${objCode}.set_own_property(${propName}, ${valueCode});\n`;
+        }
+        else if (ts.isElementAccessExpression(pattern)) {
+            const objCode = this.visit(pattern.expression, context);
+            const argCode = visitObjectPropertyName.call(this, pattern.argumentExpression, { ...context, isBracketNotationPropertyAccess: true });
+            return `${this.indent()}${objCode}.set_own_property(${argCode}, ${valueCode});\n`;
+        }
+        else if (ts.isArrayBindingPattern(pattern) ||
+            ts.isArrayLiteralExpression(pattern)) {
+            let innerCode = "";
+            const elements = ts.isArrayBindingPattern(pattern)
+                ? pattern.elements
+                : pattern.elements;
+            const iterVar = this.generateUniqueName("__destruct_iter", declaredSymbols, context.localScopeSymbols, context.globalScopeSymbols);
+            const nextVar = this.generateUniqueName("__destruct_next", declaredSymbols, context.localScopeSymbols, context.globalScopeSymbols);
+            innerCode +=
+                `${this.indent()}auto ${iterVar} = jspp::Access::get_object_iterator(${valueCode}, "destructuring");\n`;
+            innerCode +=
+                `${this.indent()}auto ${nextVar} = ${iterVar}.get_own_property("next");\n`;
+            elements.forEach((element) => {
+                if (ts.isOmittedExpression(element)) {
+                    innerCode +=
+                        `${this.indent()}${nextVar}.call(${iterVar}, {}, "next");\n`;
+                    return;
+                }
+                let target;
+                let initializer;
+                let isRest = false;
+                if (ts.isBindingElement(element)) {
+                    target = element.name;
+                    initializer = element.initializer;
+                    isRest = !!element.dotDotDotToken;
+                }
+                else if (ts.isSpreadElement(element)) {
+                    target = element.expression;
+                    isRest = true;
+                }
+                else {
+                    target = element;
+                }
+                if (isRest) {
+                    const restVecVar = this.generateUniqueName("__rest_vec", declaredSymbols, context.localScopeSymbols, context.globalScopeSymbols);
+                    innerCode +=
+                        `${this.indent()}std::vector<jspp::AnyValue> ${restVecVar};\n`;
+                    innerCode += `${this.indent()}while(true) {\n`;
+                    this.indentationLevel++;
+                    const resVar = this.generateUniqueName("__res", declaredSymbols, context.localScopeSymbols, context.globalScopeSymbols);
+                    innerCode +=
+                        `${this.indent()}auto ${resVar} = ${nextVar}.call(${iterVar}, {}, "next");\n`;
+                    innerCode +=
+                        `${this.indent()}if (jspp::is_truthy(${resVar}.get_own_property("done"))) break;\n`;
+                    innerCode +=
+                        `${this.indent()}${restVecVar}.push_back(${resVar}.get_own_property("value"));\n`;
+                    this.indentationLevel--;
+                    innerCode += `${this.indent()}}\n`;
+                    innerCode += genAssignment(target, `jspp::AnyValue::make_array(std::move(${restVecVar}))`);
+                }
+                else {
+                    const resVar = this.generateUniqueName("__res", declaredSymbols, context.localScopeSymbols, context.globalScopeSymbols);
+                    innerCode +=
+                        `${this.indent()}auto ${resVar} = ${nextVar}.call(${iterVar}, {}, "next");\n`;
+                    let elementValueCode;
+                    if (initializer) {
+                        const valVar = this.generateUniqueName("__val", declaredSymbols, context.localScopeSymbols, context.globalScopeSymbols);
+                        innerCode +=
+                            `${this.indent()}auto ${valVar} = (jspp::is_truthy(${resVar}.get_own_property("done")) ? jspp::Constants::UNDEFINED : ${resVar}.get_own_property("value"));\n`;
+                        const initCode = this.visit(initializer, context);
+                        elementValueCode =
+                            `(${valVar}.is_undefined() ? ${initCode} : ${valVar})`;
+                    }
+                    else {
+                        elementValueCode =
+                            `(jspp::is_truthy(${resVar}.get_own_property("done")) ? jspp::Constants::UNDEFINED : ${resVar}.get_own_property("value"))`;
+                    }
+                    innerCode += genAssignment(target, elementValueCode);
+                }
+            });
+            // Call the return method to clean resources
+            innerCode +=
+                `${this.indent()}jspp::Access::call_optional_property_with_optional_call(${iterVar}, "return", {}, "return");\n`;
+            return innerCode;
+        }
+        else if (ts.isObjectBindingPattern(pattern) ||
+            ts.isObjectLiteralExpression(pattern)) {
+            let innerCode = "";
+            const properties = ts.isObjectBindingPattern(pattern)
+                ? pattern.elements
+                : pattern.properties;
+            const seenKeys = [];
+            properties.forEach((prop) => {
+                let target;
+                let propertyName;
+                let initializer;
+                let isRest = false;
+                if (ts.isBindingElement(prop)) {
+                    if (prop.dotDotDotToken) {
+                        isRest = true;
+                        target = prop.name;
+                    }
+                    else {
+                        target = prop.name;
+                        propertyName = prop.propertyName
+                            ? visitObjectPropertyName.call(this, prop.propertyName, context)
+                            : (ts.isIdentifier(prop.name)
+                                ? `"${prop.name.text}"`
+                                : undefined);
+                        initializer = prop.initializer;
+                    }
+                }
+                else if (ts.isPropertyAssignment(prop)) {
+                    target = prop.initializer;
+                    propertyName = visitObjectPropertyName.call(this, prop.name, context);
+                }
+                else if (ts.isShorthandPropertyAssignment(prop)) {
+                    target = prop.name;
+                    propertyName = `"${prop.name.text}"`;
+                }
+                else if (ts.isSpreadAssignment(prop)) {
+                    isRest = true;
+                    target = prop.expression;
+                }
+                else {
+                    return;
+                }
+                if (isRest) {
+                    const keysArray = `{${seenKeys.map((k) => k.startsWith('"') && k.endsWith('"')
+                        ? k
+                        : `(${k}).to_property_key()`).join(", ")}}`;
+                    const restValueCode = `jspp::Access::get_rest_object(${valueCode}, std::vector<std::string>${keysArray})`;
+                    innerCode += genAssignment(target, restValueCode);
+                }
+                else {
+                    if (propertyName) {
+                        seenKeys.push(propertyName);
+                        let elementValueCode;
+                        if (initializer) {
+                            const valVar = this.generateUniqueName("__val", declaredSymbols, context.localScopeSymbols, context.globalScopeSymbols);
+                            innerCode +=
+                                `${this.indent()}auto ${valVar} = ${valueCode}.get_own_property(${propertyName});\n`;
+                            const initCode = this.visit(initializer, context);
+                            elementValueCode =
+                                `(${valVar}.is_undefined() ? ${initCode} : ${valVar})`;
+                        }
+                        else {
+                            elementValueCode =
+                                `${valueCode}.get_own_property(${propertyName})`;
+                        }
+                        innerCode += genAssignment(target, elementValueCode);
+                    }
+                }
+            });
+            return innerCode;
+        }
+        return "";
+    };
+    code += genAssignment(lhs, sourceVar);
+    code += `${this.indent()}return ${sourceVar};\n`;
+    this.indentationLevel--;
+    code += `${this.indent()}})()`;
+    return code;
+}

package/dist/core/codegen/expression-handlers.js

@@ -554,6 +554,13 @@ export function visitBinaryExpression(node, context) {
             }
             return `${finalObjExpr}.set_own_property(${argText}, ${finalRightText})`;
         }
+        // Array/Object destructuring assignment
+        if (ts.isArrayLiteralExpression(binExpr.left) ||
+            ts.isObjectLiteralExpression(binExpr.left)) {
+            const rhsCode = this.visit(binExpr.right, visitContext);
+            return this.generateDestructuring(binExpr.left, rhsCode, visitContext);
+        }
+        // Simple variable or property assignment
         const leftText = this.visit(binExpr.left, visitContext);
         const scope = this.getScopeForNode(binExpr.left);
         const typeInfo = this.typeAnalyzer.scopeManager.lookupFromScope(binExpr.left.text, scope);

package/dist/core/codegen/function-handlers.js

@@ -17,10 +17,12 @@ export function generateLambdaComponents(node, context, options) {
         : (isInsideGeneratorFunction
             ? "jspp::JsIterator<jspp::AnyValue>"
             : (isInsideAsyncFunction ? "jspp::JsPromise" : "jspp::AnyValue"));
-    // Lambda arguments are ALWAYS const references/spans to avoid copy overhead for normal functions.
-    // For generators/async, we manually copy them inside the body.
-    const paramThisType = "const jspp::AnyValue&";
-    const paramArgsType = "std::span<const jspp::AnyValue>";
+    // Lambda arguments: regular functions use std::span for performance.
+    // Generators and async functions use std::vector to ensure they are safely copied into the coroutine frame.
+    const paramThisType = "jspp::AnyValue";
+    const paramArgsType = (isInsideGeneratorFunction || isInsideAsyncFunction)
+        ? "std::vector<jspp::AnyValue>"
+        : "std::span<const jspp::AnyValue>";
     const globalScopeSymbols = this.prepareScopeSymbolsForVisit(context.globalScopeSymbols, context.localScopeSymbols);
     const visitContext = {
         currentScopeNode: context.currentScopeNode,
@@ -44,7 +46,7 @@ export function generateLambdaComponents(node, context, options) {
         finalArgsParamName = this.generateUniqueName("__args_ref", declaredSymbols);
     }
     const thisArgParam = isArrow
-        ? "const jspp::AnyValue&" // Arrow functions use captured 'this' or are never generators in this parser context
+        ? "jspp::AnyValue" // Arrow functions use captured 'this' or are never generators in this parser context
         : `${paramThisType} ${finalThisParamName}`;
     const funcArgs = `${paramArgsType} ${finalArgsParamName}`;
     // Preamble to copy arguments for coroutines
@@ -57,41 +59,62 @@ export function generateLambdaComponents(node, context, options) {
             nativePreamble +=
                 `${this.indent()}jspp::AnyValue ${this.globalThisVar} = ${finalThisParamName};\n`;
         }
-        // Note: Do not add argument copy to native lambda
+        // Note: Arguments are now automatically copied into the coroutine frame because 
+        // the lambda parameter is passed by value (std::vector).
+        // We just need to define argsName as a reference to the parameter.
         preamble +=
-            `${this.indent()}std::vector<jspp::AnyValue> ${argsName}(${finalArgsParamName}.begin(), ${finalArgsParamName}.end());\n`;
+            `${this.indent()}auto& ${argsName} = ${finalArgsParamName};\n`;
     }
     // Native function arguments for native lambda
     let nativeFuncArgs = "";
     let nativeParamsContent = "";
     this.validateFunctionParams(node.parameters).forEach((p, i) => {
-        const name = p.name.getText();
+        const name = ts.isIdentifier(p.name)
+            ? p.name.text
+            : this.generateUniqueName(`__param_native_${i}_`, visitContext.localScopeSymbols);
         const defaultValue = p.initializer
             ? this.visit(p.initializer, visitContext)
             : !!p.dotDotDotToken
                 ? "jspp::AnyValue::make_array(std::vector<jspp::AnyValue>{})"
                 : "jspp::Constants::UNDEFINED";
-        nativeFuncArgs += `, const jspp::AnyValue& ${name} = ${defaultValue}`;
+        nativeFuncArgs += `, jspp::AnyValue ${name} = ${defaultValue}`;
+        if (!ts.isIdentifier(p.name)) {
+            nativeParamsContent += this.generateDestructuring(p.name, name, visitContext) + ";\n";
+        }
     });
     // Extract lambda parameters from arguments span/vector
     const generateParamsBuilder = () => {
         let paramsCode = "";
         this.validateFunctionParams(node.parameters).forEach((p, i) => {
-            const name = p.name.getText();
-            const defaultValue = p.initializer
-                ? this.visit(p.initializer, visitContext)
-                : "jspp::Constants::UNDEFINED";
-            // Add paramerter to local context
-            visitContext.localScopeSymbols.add(name, {
-                type: DeclarationType.let,
-                checks: { initialized: true },
-            });
-            const scope = this.getScopeForNode(p);
-            const typeInfo = this.typeAnalyzer.scopeManager.lookupFromScope(name, scope);
-            // Handle rest parameters
-            if (!!p.dotDotDotToken) {
-                const initValue = `jspp::AnyValue::make_array(${argsName}.subspan(${i}))`;
-                if (typeInfo.needsHeapAllocation) {
+            if (ts.isIdentifier(p.name)) {
+                const name = p.name.text;
+                const defaultValue = p.initializer
+                    ? this.visit(p.initializer, visitContext)
+                    : "jspp::Constants::UNDEFINED";
+                // Add paramerter to local context
+                visitContext.localScopeSymbols.add(name, {
+                    type: DeclarationType.let,
+                    checks: { initialized: true },
+                });
+                const scope = this.getScopeForNode(p);
+                const typeInfo = this.typeAnalyzer.scopeManager
+                    .lookupFromScope(name, scope);
+                // Handle rest parameters
+                if (!!p.dotDotDotToken) {
+                    const initValue = `jspp::AnyValue::make_array(${argsName}.subspan(${i}))`;
+                    if (typeInfo.needsHeapAllocation) {
+                        paramsCode +=
+                            `${this.indent()}auto ${name} = std::make_shared<jspp::AnyValue>(${initValue});\n`;
+                    }
+                    else {
+                        paramsCode +=
+                            `${this.indent()}jspp::AnyValue ${name} = ${initValue};\n`;
+                    }
+                    return;
+                }
+                // Normal parameter
+                const initValue = `${argsName}.size() > ${i} ? ${argsName}[${i}] : ${defaultValue}`;
+                if (typeInfo && typeInfo.needsHeapAllocation) {
                     paramsCode +=
                         `${this.indent()}auto ${name} = std::make_shared<jspp::AnyValue>(${initValue});\n`;
                 }
@@ -99,17 +122,16 @@ export function generateLambdaComponents(node, context, options) {
                     paramsCode +=
                         `${this.indent()}jspp::AnyValue ${name} = ${initValue};\n`;
                 }
-                return;
-            }
-            // Normal parameter
-            const initValue = `${argsName}.size() > ${i} ? ${argsName}[${i}] : ${defaultValue}`;
-            if (typeInfo && typeInfo.needsHeapAllocation) {
-                paramsCode +=
-                    `${this.indent()}auto ${name} = std::make_shared<jspp::AnyValue>(${initValue});\n`;
             }
             else {
+                const tempName = this.generateUniqueName(`__param_tmp_${i}_`, visitContext.localScopeSymbols);
+                const defaultValue = p.initializer
+                    ? this.visit(p.initializer, visitContext)
+                    : "jspp::Constants::UNDEFINED";
+                const initValue = `${argsName}.size() > ${i} ? ${argsName}[${i}] : ${defaultValue}`;
                 paramsCode +=
-                    `${this.indent()}jspp::AnyValue ${name} = ${initValue};\n`;
+                    `${this.indent()}auto ${tempName} = ${initValue};\n`;
+                paramsCode += this.generateDestructuring(p.name, tempName, visitContext) + ";\n";
             }
         });
         return paramsCode;
@@ -204,14 +226,14 @@ export function generateWrappedLambda(comps) {
     if (isInsideGeneratorFunction) {
         if (isInsideAsyncFunction) {
             if (!noTypeSignature) {
-                const signature = "jspp::JsAsyncIterator<jspp::AnyValue>(const jspp::AnyValue&, std::span<const jspp::AnyValue>)";
+                const signature = "jspp::JsAsyncIterator<jspp::AnyValue>(jspp::AnyValue, std::vector<jspp::AnyValue>)";
                 callable = `std::function<${signature}>(${lambda})`;
             }
             method = `jspp::AnyValue::make_async_generator`;
         }
         else {
             if (!noTypeSignature) {
-                const signature = "jspp::JsIterator<jspp::AnyValue>(const jspp::AnyValue&, std::span<const jspp::AnyValue>)";
+                const signature = "jspp::JsIterator<jspp::AnyValue>(jspp::AnyValue, std::vector<jspp::AnyValue>)";
                 callable = `std::function<${signature}>(${lambda})`;
             }
             method = `jspp::AnyValue::make_generator`;
@@ -219,14 +241,14 @@ export function generateWrappedLambda(comps) {
     } // Handle async function
     else if (isInsideAsyncFunction) {
         if (!noTypeSignature) {
-            const signature = "jspp::JsPromise(const jspp::AnyValue&, std::span<const jspp::AnyValue>)";
+            const signature = "jspp::JsPromise(jspp::AnyValue, std::vector<jspp::AnyValue>)";
             callable = `std::function<${signature}>(${lambda})`;
         }
         method = `jspp::AnyValue::make_async_function`;
     } // Handle normal function
     else {
         if (!noTypeSignature) {
-            const signature = `jspp::AnyValue(const jspp::AnyValue&, std::span<const jspp::AnyValue>)`;
+            const signature = `jspp::AnyValue(jspp::AnyValue, std::span<const jspp::AnyValue>)`;
             callable = `std::function<${signature}>(${lambda})`;
         }
         if (options?.isClass) {