crankscript 0.11.12 → 0.11.13

package/assets/transformClassDeclaration/transformConstructor.js

@@ -12,9 +12,20 @@ const _extends = require("@swc/helpers/_/_extends");
 const _interop_require_wildcard = require("@swc/helpers/_/_interop_require_wildcard");
 const _typescript = /*#__PURE__*/ _interop_require_wildcard._(require("typescript"));
 const _typescripttolua = /*#__PURE__*/ _interop_require_wildcard._(require("typescript-to-lua"));
+const _precedingstatements = require("typescript-to-lua/dist/transformation/utils/preceding-statements");
 const _scope = require("typescript-to-lua/dist/transformation/utils/scope");
 const _fields = require("typescript-to-lua/dist/transformation/visitors/class/members/fields");
 const _function = require("typescript-to-lua/dist/transformation/visitors/function");
+const transformParameterDefaultValue = (context, paramName, value)=>{
+    if (!value) return undefined;
+    const { precedingStatements, result: parameterValue } = (0, _precedingstatements.transformInPrecedingStatementScope)(context, ()=>context.transformExpression(value));
+    if (!_typescripttolua.isNilLiteral(parameterValue)) {
+        precedingStatements.push(_typescripttolua.createAssignmentStatement(paramName, parameterValue));
+    }
+    if (precedingStatements.length === 0) return undefined;
+    const nilCondition = _typescripttolua.createBinaryExpression(paramName, _typescripttolua.createNilLiteral(), _typescripttolua.SyntaxKind.EqualityOperator);
+    return _typescripttolua.createIfStatement(nilCondition, _typescripttolua.createBlock(precedingStatements), undefined);
+};
 const transformConstructor = (context, className, instanceFields, constructor)=>{
     const methodName = 'init';
     context.pushScope(_scope.ScopeType.Function);
@@ -22,6 +33,14 @@ const transformConstructor = (context, className, instanceFields, constructor)=>
     const params = (0, _function.transformParameters)(context, constructor == null ? void 0 : constructor.parameters, _typescripttolua.createIdentifier('self'))[0];
     const classInstanceFields = (0, _fields.transformClassInstanceFields)(context, instanceFields);
     bodyStatements.push(...classInstanceFields);
+    const defaultParamStatements = constructor == null ? void 0 : constructor.parameters.filter((param)=>param.initializer !== undefined).map((param)=>{
+        if (_typescript.isIdentifier(param.name) && param.initializer) {
+            const paramName = _typescripttolua.createIdentifier(param.name.text);
+            return transformParameterDefaultValue(context, paramName, param.initializer);
+        }
+        return undefined;
+    }).filter((stmt)=>stmt !== undefined);
+    bodyStatements.push(...defaultParamStatements);
     const parameterAssignments = constructor == null ? void 0 : constructor.parameters.filter((param)=>param.name && param.modifiers && param.modifiers.length > 0).map((param)=>{
         if (_typescript.isIdentifier(param.name)) {
             const paramName = param.name.text;

package/assets/transformClassDeclaration/transformConstructor.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../libs/tstl-plugin/src/transformClassDeclaration/transformConstructor.ts"],"sourcesContent":["import * as ts from 'typescript';\nimport { TransformationContext } from 'typescript-to-lua';\nimport * as tstl from 'typescript-to-lua';\nimport { ScopeType } from 'typescript-to-lua/dist/transformation/utils/scope';\nimport { transformClassInstanceFields } from 'typescript-to-lua/dist/transformation/visitors/class/members/fields';\nimport {\n    transformFunctionBodyContent,\n    transformParameters,\n} from 'typescript-to-lua/dist/transformation/visitors/function';\n\nexport const transformConstructor = (\n    context: TransformationContext,\n    className: tstl.Identifier,\n    instanceFields: ts.PropertyDeclaration[],\n    constructor: ts.ConstructorDeclaration,\n): tstl.Statement | undefined => {\n    const methodName = 'init';\n    context.pushScope(ScopeType.Function);\n    let bodyStatements: tstl.Statement[] = [];\n    const params = transformParameters(\n        context,\n        constructor?.parameters,\n        tstl.createIdentifier('self'),\n    )[0];\n    const classInstanceFields = transformClassInstanceFields(\n        context,\n        instanceFields,\n    );\n\n    bodyStatements.push(...classInstanceFields);\n\n    const parameterAssignments = constructor?.parameters\n        .filter(\n            param =>\n                param.name && param.modifiers && param.modifiers.length > 0,\n        )\n        .map(param => {\n            if (ts.isIdentifier(param.name)) {\n                const paramName = param.name.text;\n                return tstl.createAssignmentStatement(\n                    tstl.createTableIndexExpression(\n                        tstl.createIdentifier('self'),\n                        tstl.createStringLiteral(paramName),\n                    ),\n                    tstl.createIdentifier(paramName),\n                );\n            }\n            return undefined;\n        })\n        .filter((stmt): stmt is tstl.AssignmentStatement => stmt !== undefined);\n\n    bodyStatements.push(...parameterAssignments);\n\n    if (constructor?.body) {\n        const body = transformFunctionBodyContent(context, constructor.body);\n\n        bodyStatements.push(...body);\n        bodyStatements = bodyStatements.reduce((previous, current) => {\n            if (\n                tstl.isExpressionStatement(current) &&\n                tstl.isCallExpression(current.expression) &&\n                tstl.isTableIndexExpression(current.expression.expression) &&\n                tstl.isStringLiteral(current.expression.expression.index) &&\n                current.expression.expression.index.value === '____constructor'\n            ) {\n                return [\n                    {\n                        ...current,\n                        expression: {\n                            ...current.expression,\n                            expression: {\n                                ...current.expression.expression,\n                                index: tstl.createStringLiteral('init'),\n                            },\n                            params: current.expression.params.slice(1),\n                        },\n                    },\n                    ...previous,\n                ];\n            }\n\n            return [...previous, current];\n        }, [] as tstl.Statement[]);\n    }\n    context.popScope();\n    return tstl.createAssignmentStatement(\n        tstl.createTableIndexExpression(\n            className,\n            tstl.createStringLiteral(methodName),\n        ),\n        tstl.createFunctionExpression(tstl.createBlock(bodyStatements), params),\n    );\n};\n"],"names":["transformConstructor","context","className","instanceFields","constructor","methodName","pushScope","ScopeType","Function","bodyStatements","params","transformParameters","parameters","tstl","createIdentifier","classInstanceFields","transformClassInstanceFields","push","parameterAssignments","filter","param","name","modifiers","length","map","ts","isIdentifier","paramName","text","createAssignmentStatement","createTableIndexExpression","createStringLiteral","undefined","stmt","body","transformFunctionBodyContent","reduce","previous","current","isExpressionStatement","isCallExpression","expression","isTableIndexExpression","isStringLiteral","index","value","slice","popScope","createFunctionExpression","createBlock"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;+BAUaA;;;eAAAA;;;;;sEAVO;2EAEE;uBACI;wBACmB;0BAItC;AAEA,MAAMA,uBAAuB,CAChCC,SACAC,WACAC,gBACAC;IAEA,MAAMC,aAAa;IACnBJ,QAAQK,SAAS,CAACC,gBAAS,CAACC,QAAQ;IACpC,IAAIC,iBAAmC,EAAE;IACzC,MAAMC,SAASC,IAAAA,6BAAmB,EAC9BV,SACAG,+BAAAA,YAAaQ,UAAU,EACvBC,iBAAKC,gBAAgB,CAAC,QACzB,CAAC,EAAE;IACJ,MAAMC,sBAAsBC,IAAAA,oCAA4B,EACpDf,SACAE;IAGJM,eAAeQ,IAAI,IAAIF;IAEvB,MAAMG,uBAAuBd,+BAAAA,YAAaQ,UAAU,CAC/CO,MAAM,CACHC,CAAAA,QACIA,MAAMC,IAAI,IAAID,MAAME,SAAS,IAAIF,MAAME,SAAS,CAACC,MAAM,GAAG,GAEjEC,GAAG,CAACJ,CAAAA;QACD,IAAIK,YAAGC,YAAY,CAACN,MAAMC,IAAI,GAAG;YAC7B,MAAMM,YAAYP,MAAMC,IAAI,CAACO,IAAI;YACjC,OAAOf,iBAAKgB,yBAAyB,CACjChB,iBAAKiB,0BAA0B,CAC3BjB,iBAAKC,gBAAgB,CAAC,SACtBD,iBAAKkB,mBAAmB,CAACJ,aAE7Bd,iBAAKC,gBAAgB,CAACa;QAE9B;QACA,OAAOK;IACX,GACCb,MAAM,CAAC,CAACc,OAA2CA,SAASD;IAEjEvB,eAAeQ,IAAI,IAAIC;IAEvB,IAAId,+BAAAA,YAAa8B,IAAI,EAAE;QACnB,MAAMA,OAAOC,IAAAA,sCAA4B,EAAClC,SAASG,YAAY8B,IAAI;QAEnEzB,eAAeQ,IAAI,IAAIiB;QACvBzB,iBAAiBA,eAAe2B,MAAM,CAAC,CAACC,UAAUC;YAC9C,IACIzB,iBAAK0B,qBAAqB,CAACD,YAC3BzB,iBAAK2B,gBAAgB,CAACF,QAAQG,UAAU,KACxC5B,iBAAK6B,sBAAsB,CAACJ,QAAQG,UAAU,CAACA,UAAU,KACzD5B,iBAAK8B,eAAe,CAACL,QAAQG,UAAU,CAACA,UAAU,CAACG,KAAK,KACxDN,QAAQG,UAAU,CAACA,UAAU,CAACG,KAAK,CAACC,KAAK,KAAK,mBAChD;gBACE,OAAO;oBACH,eACOP;wBACHG,YAAY,eACLH,QAAQG,UAAU;4BACrBA,YAAY,eACLH,QAAQG,UAAU,CAACA,UAAU;gCAChCG,OAAO/B,iBAAKkB,mBAAmB,CAAC;;4BAEpCrB,QAAQ4B,QAAQG,UAAU,CAAC/B,MAAM,CAACoC,KAAK,CAAC;;;uBAG7CT;iBACN;YACL;YAEA,OAAO;mBAAIA;gBAAUC;aAAQ;QACjC,GAAG,EAAE;IACT;IACArC,QAAQ8C,QAAQ;IAChB,OAAOlC,iBAAKgB,yBAAyB,CACjChB,iBAAKiB,0BAA0B,CAC3B5B,WACAW,iBAAKkB,mBAAmB,CAAC1B,cAE7BQ,iBAAKmC,wBAAwB,CAACnC,iBAAKoC,WAAW,CAACxC,iBAAiBC;AAExE"}
+{"version":3,"sources":["../../../../../libs/tstl-plugin/src/transformClassDeclaration/transformConstructor.ts"],"sourcesContent":["import * as ts from 'typescript';\nimport { TransformationContext } from 'typescript-to-lua';\nimport * as tstl from 'typescript-to-lua';\nimport { transformInPrecedingStatementScope } from 'typescript-to-lua/dist/transformation/utils/preceding-statements';\nimport { ScopeType } from 'typescript-to-lua/dist/transformation/utils/scope';\nimport { transformClassInstanceFields } from 'typescript-to-lua/dist/transformation/visitors/class/members/fields';\nimport {\n    transformFunctionBodyContent,\n    transformParameters,\n} from 'typescript-to-lua/dist/transformation/visitors/function';\n\nconst transformParameterDefaultValue = (\n    context: TransformationContext,\n    paramName: tstl.Identifier,\n    value: ts.Expression,\n): tstl.Statement | undefined => {\n    if (!value) return undefined;\n\n    const { precedingStatements, result: parameterValue } =\n        transformInPrecedingStatementScope(context, () =>\n            context.transformExpression(value),\n        );\n\n    if (!tstl.isNilLiteral(parameterValue)) {\n        precedingStatements.push(\n            tstl.createAssignmentStatement(paramName, parameterValue),\n        );\n    }\n\n    if (precedingStatements.length === 0) return undefined;\n\n    const nilCondition = tstl.createBinaryExpression(\n        paramName,\n        tstl.createNilLiteral(),\n        tstl.SyntaxKind.EqualityOperator,\n    );\n\n    return tstl.createIfStatement(\n        nilCondition,\n        tstl.createBlock(precedingStatements),\n        undefined,\n    );\n};\n\nexport const transformConstructor = (\n    context: TransformationContext,\n    className: tstl.Identifier,\n    instanceFields: ts.PropertyDeclaration[],\n    constructor: ts.ConstructorDeclaration,\n): tstl.Statement | undefined => {\n    const methodName = 'init';\n    context.pushScope(ScopeType.Function);\n    let bodyStatements: tstl.Statement[] = [];\n    const params = transformParameters(\n        context,\n        constructor?.parameters,\n        tstl.createIdentifier('self'),\n    )[0];\n    const classInstanceFields = transformClassInstanceFields(\n        context,\n        instanceFields,\n    );\n\n    bodyStatements.push(...classInstanceFields);\n\n    const defaultParamStatements = constructor?.parameters\n        .filter(param => param.initializer !== undefined)\n        .map(param => {\n            if (ts.isIdentifier(param.name) && param.initializer) {\n                const paramName = tstl.createIdentifier(param.name.text);\n\n                return transformParameterDefaultValue(\n                    context,\n                    paramName,\n                    param.initializer,\n                );\n            }\n\n            return undefined;\n        })\n        .filter((stmt): stmt is tstl.Statement => stmt !== undefined);\n\n    bodyStatements.push(...defaultParamStatements);\n\n    const parameterAssignments = constructor?.parameters\n        .filter(\n            param =>\n                param.name && param.modifiers && param.modifiers.length > 0,\n        )\n        .map(param => {\n            if (ts.isIdentifier(param.name)) {\n                const paramName = param.name.text;\n                return tstl.createAssignmentStatement(\n                    tstl.createTableIndexExpression(\n                        tstl.createIdentifier('self'),\n                        tstl.createStringLiteral(paramName),\n                    ),\n                    tstl.createIdentifier(paramName),\n                );\n            }\n            return undefined;\n        })\n        .filter((stmt): stmt is tstl.AssignmentStatement => stmt !== undefined);\n\n    bodyStatements.push(...parameterAssignments);\n\n    if (constructor?.body) {\n        const body = transformFunctionBodyContent(context, constructor.body);\n\n        bodyStatements.push(...body);\n        bodyStatements = bodyStatements.reduce((previous, current) => {\n            if (\n                tstl.isExpressionStatement(current) &&\n                tstl.isCallExpression(current.expression) &&\n                tstl.isTableIndexExpression(current.expression.expression) &&\n                tstl.isStringLiteral(current.expression.expression.index) &&\n                current.expression.expression.index.value === '____constructor'\n            ) {\n                return [\n                    {\n                        ...current,\n                        expression: {\n                            ...current.expression,\n                            expression: {\n                                ...current.expression.expression,\n                                index: tstl.createStringLiteral('init'),\n                            },\n                            params: current.expression.params.slice(1),\n                        },\n                    },\n                    ...previous,\n                ];\n            }\n\n            return [...previous, current];\n        }, [] as tstl.Statement[]);\n    }\n    context.popScope();\n    return tstl.createAssignmentStatement(\n        tstl.createTableIndexExpression(\n            className,\n            tstl.createStringLiteral(methodName),\n        ),\n        tstl.createFunctionExpression(tstl.createBlock(bodyStatements), params),\n    );\n};\n"],"names":["transformConstructor","transformParameterDefaultValue","context","paramName","value","undefined","precedingStatements","result","parameterValue","transformInPrecedingStatementScope","transformExpression","tstl","isNilLiteral","push","createAssignmentStatement","length","nilCondition","createBinaryExpression","createNilLiteral","SyntaxKind","EqualityOperator","createIfStatement","createBlock","className","instanceFields","constructor","methodName","pushScope","ScopeType","Function","bodyStatements","params","transformParameters","parameters","createIdentifier","classInstanceFields","transformClassInstanceFields","defaultParamStatements","filter","param","initializer","map","ts","isIdentifier","name","text","stmt","parameterAssignments","modifiers","createTableIndexExpression","createStringLiteral","body","transformFunctionBodyContent","reduce","previous","current","isExpressionStatement","isCallExpression","expression","isTableIndexExpression","isStringLiteral","index","slice","popScope","createFunctionExpression"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "crankscript",
-    "version": "0.11.12",
+    "version": "0.11.13",
     "scripts": {
         "dev": "tsx src/index.ts",
         "post-build": "tsc-alias --project tsconfig.json"

package/src/commands/TranspileCommand/fn/_tests/test-default-parameters/src/index.js

@@ -0,0 +1,17 @@
+let A = class A {
+    method(c, d = 5) {
+        console.log(c, d);
+    }
+    constructor(a, b = 5){
+        console.log(a, b);
+    }
+};
+function test(x, y = 5) {
+    console.log(x, y);
+}
+playdate.update = ()=>{
+    printTable(new A(1));
+    test(1);
+};
+
+//# sourceMappingURL=index.js.map

package/src/commands/TranspileCommand/fn/_tests/test-default-parameters/src/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../../../../libs/cli/src/commands/TranspileCommand/fn/_tests/test-default-parameters/src/index.ts"],"sourcesContent":["class A {\n    constructor(a: number, b = 5) {\n        console.log(a, b);\n    }\n\n    method(c: number, d = 5) {\n        console.log(c, d);\n    }\n}\n\nfunction test(x: number, y = 5) {\n    console.log(x, y);\n}\n\nplaydate.update = () => {\n    printTable(new A(1));\n    test(1);\n};\n"],"names":["A","method","c","d","console","log","constructor","a","b","test","x","y","playdate","update","printTable"],"rangeMappings":";;;;;;;;;;;;;;","mappings":"AAAA,IAAA,AAAMA,IAAN,MAAMA;IAKFC,OAAOC,CAAS,EAAEC,IAAI,CAAC,EAAE;QACrBC,QAAQC,GAAG,CAACH,GAAGC;IACnB;IANAG,YAAYC,CAAS,EAAEC,IAAI,CAAC,CAAE;QAC1BJ,QAAQC,GAAG,CAACE,GAAGC;IACnB;AAKJ;AAEA,SAASC,KAAKC,CAAS,EAAEC,IAAI,CAAC;IAC1BP,QAAQC,GAAG,CAACK,GAAGC;AACnB;AAEAC,SAASC,MAAM,GAAG;IACdC,WAAW,IAAId,EAAE;IACjBS,KAAK;AACT"}