crankscript 0.11.11 → 0.11.13

package/assets/transformClassDeclaration/getTransformClassDeclaration.js

@@ -59,10 +59,8 @@ const getTransformClassDeclaration = (importMap)=>{
         const staticFieldStatements = staticFields.map((field)=>(0, _fields.transformStaticPropertyDeclaration)(context, field, className)).filter((stmt)=>stmt !== undefined);
         statements.push(...staticFieldStatements);
         const constructor = declaration.members.find((n)=>_typescript.isConstructorDeclaration(n) && n.body !== undefined);
-        if (!constructor) {
-            return [];
-        }
-        const transformedConstructor = (0, _transformConstructor.transformConstructor)(context, className, instanceFields, constructor);
+        const constructorToUse = constructor || _typescript.factory.createConstructorDeclaration(undefined, [], _typescript.factory.createBlock([], true));
+        const transformedConstructor = (0, _transformConstructor.transformConstructor)(context, className, instanceFields, constructorToUse);
         if (transformedConstructor) {
             statements.push(transformedConstructor);
         }

package/assets/transformClassDeclaration/getTransformClassDeclaration.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../libs/tstl-plugin/src/transformClassDeclaration/getTransformClassDeclaration.ts"],"sourcesContent":["import * as ts from 'typescript';\nimport { FunctionVisitor, TransformationContext } from 'typescript-to-lua';\nimport * as tstl from 'typescript-to-lua';\nimport { transformStaticPropertyDeclaration } from 'typescript-to-lua/dist/transformation/visitors/class/members/fields';\nimport {\n    getExtendedNode,\n    isStaticNode,\n} from 'typescript-to-lua/dist/transformation/visitors/class/utils';\nimport { getExportedClassDeclarationStatements } from './getExportedClassDeclarationStatements';\nimport { ImportMap } from '../ImportMap';\nimport { ClassSuperInfo } from '../types';\nimport { createClassCall } from './createClasCall';\nimport { transformConstructor } from './transformConstructor';\nimport { transformMethodDeclaration } from './transformMethodDeclaration';\n\nconst hasSuperInfos = (\n    context: TransformationContext,\n): context is TransformationContext & {\n    classSuperInfos?: [ClassSuperInfo];\n} => {\n    return 'classSuperInfos' in context;\n};\n\nexport const getTransformClassDeclaration = (importMap: ImportMap) => {\n    return ((declaration, context: TransformationContext) => {\n        importMap.add('object');\n\n        let className: tstl.Identifier;\n        if (declaration.name) {\n            className = tstl.createIdentifier(declaration.name.text);\n        } else {\n            className = tstl.createIdentifier(\n                context.createTempName('class'),\n                declaration,\n            );\n        }\n\n        const extension = getExtendedNode(declaration);\n\n        if (hasSuperInfos(context)) {\n            if (context.classSuperInfos) {\n                context.classSuperInfos.push({\n                    className,\n                    extendedTypeNode: extension,\n                });\n            } else {\n                context.classSuperInfos = [\n                    { className, extendedTypeNode: extension },\n                ];\n            }\n        }\n\n        // Get all properties with value\n        const properties = declaration.members\n            .filter(ts.isPropertyDeclaration)\n            .filter(member => member.initializer);\n\n        // Divide properties into static and non-static\n        const instanceFields = properties.filter(prop => !isStaticNode(prop));\n        const staticFields = properties.filter(prop => isStaticNode(prop));\n\n        const statements: tstl.Statement[] = [];\n\n        // class('X')\n        statements.push(createClassCall(context, className, extension));\n\n        // function X:init()\n        //   X.super.init(self)\n        // end\n\n        const staticFieldStatements = staticFields\n            .map(field =>\n                transformStaticPropertyDeclaration(context, field, className),\n            )\n            .filter(\n                (stmt): stmt is tstl.AssignmentStatement => stmt !== undefined,\n            );\n        statements.push(...staticFieldStatements);\n\n        const constructor = declaration.members.find(\n            (n): n is ts.ConstructorDeclaration =>\n                ts.isConstructorDeclaration(n) && n.body !== undefined,\n        );\n\n        if (!constructor) {\n            return [];\n        }\n\n        const transformedConstructor = transformConstructor(\n            context,\n            className,\n            instanceFields,\n            constructor,\n        );\n        if (transformedConstructor) {\n            statements.push(transformedConstructor);\n        }\n\n        const methods = declaration.members\n            .filter(ts.isMethodDeclaration)\n            .map(method =>\n                transformMethodDeclaration(context, method, className),\n            )\n            .filter((method): method is tstl.Statement => method !== undefined);\n        statements.push(...methods);\n\n        statements.push(\n            ...getExportedClassDeclarationStatements(className, declaration),\n        );\n\n        return statements;\n    }) satisfies FunctionVisitor<ts.ClassLikeDeclaration>;\n};\n"],"names":["getTransformClassDeclaration","hasSuperInfos","context","importMap","declaration","add","className","name","tstl","createIdentifier","text","createTempName","extension","getExtendedNode","classSuperInfos","push","extendedTypeNode","properties","members","filter","ts","isPropertyDeclaration","member","initializer","instanceFields","prop","isStaticNode","staticFields","statements","createClassCall","staticFieldStatements","map","field","transformStaticPropertyDeclaration","stmt","undefined","constructor","find","n","isConstructorDeclaration","body","transformedConstructor","transformConstructor","methods","isMethodDeclaration","method","transformMethodDeclaration","getExportedClassDeclarationStatements"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;+BAuBaA;;;eAAAA;;;;sEAvBO;2EAEE;wBAC6B;uBAI5C;uDAC+C;gCAGtB;sCACK;4CACM;AAE3C,MAAMC,gBAAgB,CAClBC;IAIA,OAAO,qBAAqBA;AAChC;AAEO,MAAMF,+BAA+B,CAACG;IACzC,OAAQ,CAACC,aAAaF;QAClBC,UAAUE,GAAG,CAAC;QAEd,IAAIC;QACJ,IAAIF,YAAYG,IAAI,EAAE;YAClBD,YAAYE,iBAAKC,gBAAgB,CAACL,YAAYG,IAAI,CAACG,IAAI;QAC3D,OAAO;YACHJ,YAAYE,iBAAKC,gBAAgB,CAC7BP,QAAQS,cAAc,CAAC,UACvBP;QAER;QAEA,MAAMQ,YAAYC,IAAAA,sBAAe,EAACT;QAElC,IAAIH,cAAcC,UAAU;YACxB,IAAIA,QAAQY,eAAe,EAAE;gBACzBZ,QAAQY,eAAe,CAACC,IAAI,CAAC;oBACzBT;oBACAU,kBAAkBJ;gBACtB;YACJ,OAAO;gBACHV,QAAQY,eAAe,GAAG;oBACtB;wBAAER;wBAAWU,kBAAkBJ;oBAAU;iBAC5C;YACL;QACJ;QAEA,gCAAgC;QAChC,MAAMK,aAAab,YAAYc,OAAO,CACjCC,MAAM,CAACC,YAAGC,qBAAqB,EAC/BF,MAAM,CAACG,CAAAA,SAAUA,OAAOC,WAAW;QAExC,+CAA+C;QAC/C,MAAMC,iBAAiBP,WAAWE,MAAM,CAACM,CAAAA,OAAQ,CAACC,IAAAA,mBAAY,EAACD;QAC/D,MAAME,eAAeV,WAAWE,MAAM,CAACM,CAAAA,OAAQC,IAAAA,mBAAY,EAACD;QAE5D,MAAMG,aAA+B,EAAE;QAEvC,aAAa;QACbA,WAAWb,IAAI,CAACc,IAAAA,+BAAe,EAAC3B,SAASI,WAAWM;QAEpD,oBAAoB;QACpB,uBAAuB;QACvB,MAAM;QAEN,MAAMkB,wBAAwBH,aACzBI,GAAG,CAACC,CAAAA,QACDC,IAAAA,0CAAkC,EAAC/B,SAAS8B,OAAO1B,YAEtDa,MAAM,CACH,CAACe,OAA2CA,SAASC;QAE7DP,WAAWb,IAAI,IAAIe;QAEnB,MAAMM,cAAchC,YAAYc,OAAO,CAACmB,IAAI,CACxC,CAACC,IACGlB,YAAGmB,wBAAwB,CAACD,MAAMA,EAAEE,IAAI,KAAKL;QAGrD,IAAI,CAACC,aAAa;YACd,OAAO,EAAE;QACb;QAEA,MAAMK,yBAAyBC,IAAAA,0CAAoB,EAC/CxC,SACAI,WACAkB,gBACAY;QAEJ,IAAIK,wBAAwB;YACxBb,WAAWb,IAAI,CAAC0B;QACpB;QAEA,MAAME,UAAUvC,YAAYc,OAAO,CAC9BC,MAAM,CAACC,YAAGwB,mBAAmB,EAC7Bb,GAAG,CAACc,CAAAA,SACDC,IAAAA,sDAA0B,EAAC5C,SAAS2C,QAAQvC,YAE/Ca,MAAM,CAAC,CAAC0B,SAAqCA,WAAWV;QAC7DP,WAAWb,IAAI,IAAI4B;QAEnBf,WAAWb,IAAI,IACRgC,IAAAA,4EAAqC,EAACzC,WAAWF;QAGxD,OAAOwB;IACX;AACJ"}
+{"version":3,"sources":["../../../../../libs/tstl-plugin/src/transformClassDeclaration/getTransformClassDeclaration.ts"],"sourcesContent":["import * as ts from 'typescript';\nimport { FunctionVisitor, TransformationContext } from 'typescript-to-lua';\nimport * as tstl from 'typescript-to-lua';\nimport { transformStaticPropertyDeclaration } from 'typescript-to-lua/dist/transformation/visitors/class/members/fields';\nimport {\n    getExtendedNode,\n    isStaticNode,\n} from 'typescript-to-lua/dist/transformation/visitors/class/utils';\nimport { getExportedClassDeclarationStatements } from './getExportedClassDeclarationStatements';\nimport { ImportMap } from '../ImportMap';\nimport { ClassSuperInfo } from '../types';\nimport { createClassCall } from './createClasCall';\nimport { transformConstructor } from './transformConstructor';\nimport { transformMethodDeclaration } from './transformMethodDeclaration';\n\nconst hasSuperInfos = (\n    context: TransformationContext,\n): context is TransformationContext & {\n    classSuperInfos?: [ClassSuperInfo];\n} => {\n    return 'classSuperInfos' in context;\n};\n\nexport const getTransformClassDeclaration = (importMap: ImportMap) => {\n    return ((declaration, context: TransformationContext) => {\n        importMap.add('object');\n\n        let className: tstl.Identifier;\n        if (declaration.name) {\n            className = tstl.createIdentifier(declaration.name.text);\n        } else {\n            className = tstl.createIdentifier(\n                context.createTempName('class'),\n                declaration,\n            );\n        }\n\n        const extension = getExtendedNode(declaration);\n\n        if (hasSuperInfos(context)) {\n            if (context.classSuperInfos) {\n                context.classSuperInfos.push({\n                    className,\n                    extendedTypeNode: extension,\n                });\n            } else {\n                context.classSuperInfos = [\n                    { className, extendedTypeNode: extension },\n                ];\n            }\n        }\n\n        // Get all properties with value\n        const properties = declaration.members\n            .filter(ts.isPropertyDeclaration)\n            .filter(member => member.initializer);\n\n        // Divide properties into static and non-static\n        const instanceFields = properties.filter(prop => !isStaticNode(prop));\n        const staticFields = properties.filter(prop => isStaticNode(prop));\n\n        const statements: tstl.Statement[] = [];\n\n        // class('X')\n        statements.push(createClassCall(context, className, extension));\n\n        // function X:init()\n        //   X.super.init(self)\n        // end\n\n        const staticFieldStatements = staticFields\n            .map(field =>\n                transformStaticPropertyDeclaration(context, field, className),\n            )\n            .filter(\n                (stmt): stmt is tstl.AssignmentStatement => stmt !== undefined,\n            );\n        statements.push(...staticFieldStatements);\n\n        const constructor = declaration.members.find(\n            (n): n is ts.ConstructorDeclaration =>\n                ts.isConstructorDeclaration(n) && n.body !== undefined,\n        );\n\n        const constructorToUse =\n            constructor ||\n            ts.factory.createConstructorDeclaration(\n                undefined,\n                [],\n                ts.factory.createBlock([], true),\n            );\n\n        const transformedConstructor = transformConstructor(\n            context,\n            className,\n            instanceFields,\n            constructorToUse,\n        );\n\n        if (transformedConstructor) {\n            statements.push(transformedConstructor);\n        }\n\n        const methods = declaration.members\n            .filter(ts.isMethodDeclaration)\n            .map(method =>\n                transformMethodDeclaration(context, method, className),\n            )\n            .filter((method): method is tstl.Statement => method !== undefined);\n        statements.push(...methods);\n\n        statements.push(\n            ...getExportedClassDeclarationStatements(className, declaration),\n        );\n\n        return statements;\n    }) satisfies FunctionVisitor<ts.ClassLikeDeclaration>;\n};\n"],"names":["getTransformClassDeclaration","hasSuperInfos","context","importMap","declaration","add","className","name","tstl","createIdentifier","text","createTempName","extension","getExtendedNode","classSuperInfos","push","extendedTypeNode","properties","members","filter","ts","isPropertyDeclaration","member","initializer","instanceFields","prop","isStaticNode","staticFields","statements","createClassCall","staticFieldStatements","map","field","transformStaticPropertyDeclaration","stmt","undefined","constructor","find","n","isConstructorDeclaration","body","constructorToUse","factory","createConstructorDeclaration","createBlock","transformedConstructor","transformConstructor","methods","isMethodDeclaration","method","transformMethodDeclaration","getExportedClassDeclarationStatements"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;+BAuBaA;;;eAAAA;;;;sEAvBO;2EAEE;wBAC6B;uBAI5C;uDAC+C;gCAGtB;sCACK;4CACM;AAE3C,MAAMC,gBAAgB,CAClBC;IAIA,OAAO,qBAAqBA;AAChC;AAEO,MAAMF,+BAA+B,CAACG;IACzC,OAAQ,CAACC,aAAaF;QAClBC,UAAUE,GAAG,CAAC;QAEd,IAAIC;QACJ,IAAIF,YAAYG,IAAI,EAAE;YAClBD,YAAYE,iBAAKC,gBAAgB,CAACL,YAAYG,IAAI,CAACG,IAAI;QAC3D,OAAO;YACHJ,YAAYE,iBAAKC,gBAAgB,CAC7BP,QAAQS,cAAc,CAAC,UACvBP;QAER;QAEA,MAAMQ,YAAYC,IAAAA,sBAAe,EAACT;QAElC,IAAIH,cAAcC,UAAU;YACxB,IAAIA,QAAQY,eAAe,EAAE;gBACzBZ,QAAQY,eAAe,CAACC,IAAI,CAAC;oBACzBT;oBACAU,kBAAkBJ;gBACtB;YACJ,OAAO;gBACHV,QAAQY,eAAe,GAAG;oBACtB;wBAAER;wBAAWU,kBAAkBJ;oBAAU;iBAC5C;YACL;QACJ;QAEA,gCAAgC;QAChC,MAAMK,aAAab,YAAYc,OAAO,CACjCC,MAAM,CAACC,YAAGC,qBAAqB,EAC/BF,MAAM,CAACG,CAAAA,SAAUA,OAAOC,WAAW;QAExC,+CAA+C;QAC/C,MAAMC,iBAAiBP,WAAWE,MAAM,CAACM,CAAAA,OAAQ,CAACC,IAAAA,mBAAY,EAACD;QAC/D,MAAME,eAAeV,WAAWE,MAAM,CAACM,CAAAA,OAAQC,IAAAA,mBAAY,EAACD;QAE5D,MAAMG,aAA+B,EAAE;QAEvC,aAAa;QACbA,WAAWb,IAAI,CAACc,IAAAA,+BAAe,EAAC3B,SAASI,WAAWM;QAEpD,oBAAoB;QACpB,uBAAuB;QACvB,MAAM;QAEN,MAAMkB,wBAAwBH,aACzBI,GAAG,CAACC,CAAAA,QACDC,IAAAA,0CAAkC,EAAC/B,SAAS8B,OAAO1B,YAEtDa,MAAM,CACH,CAACe,OAA2CA,SAASC;QAE7DP,WAAWb,IAAI,IAAIe;QAEnB,MAAMM,cAAchC,YAAYc,OAAO,CAACmB,IAAI,CACxC,CAACC,IACGlB,YAAGmB,wBAAwB,CAACD,MAAMA,EAAEE,IAAI,KAAKL;QAGrD,MAAMM,mBACFL,eACAhB,YAAGsB,OAAO,CAACC,4BAA4B,CACnCR,WACA,EAAE,EACFf,YAAGsB,OAAO,CAACE,WAAW,CAAC,EAAE,EAAE;QAGnC,MAAMC,yBAAyBC,IAAAA,0CAAoB,EAC/C5C,SACAI,WACAkB,gBACAiB;QAGJ,IAAII,wBAAwB;YACxBjB,WAAWb,IAAI,CAAC8B;QACpB;QAEA,MAAME,UAAU3C,YAAYc,OAAO,CAC9BC,MAAM,CAACC,YAAG4B,mBAAmB,EAC7BjB,GAAG,CAACkB,CAAAA,SACDC,IAAAA,sDAA0B,EAAChD,SAAS+C,QAAQ3C,YAE/Ca,MAAM,CAAC,CAAC8B,SAAqCA,WAAWd;QAC7DP,WAAWb,IAAI,IAAIgC;QAEnBnB,WAAWb,IAAI,IACRoC,IAAAA,4EAAqC,EAAC7C,WAAWF;QAGxD,OAAOwB;IACX;AACJ"}

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.11",
+    "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"}

package/src/commands/TranspileCommand/fn/_tests/test-implicit-constructor/src/index.js

@@ -0,0 +1,10 @@
+let A = class A {
+    method() {
+        return 'test';
+    }
+};
+playdate.update = ()=>{
+    printTable(new A());
+};
+
+//# sourceMappingURL=index.js.map

package/src/commands/TranspileCommand/fn/_tests/test-implicit-constructor/src/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../../../../libs/cli/src/commands/TranspileCommand/fn/_tests/test-implicit-constructor/src/index.ts"],"sourcesContent":["class A {\n    method() {\n        return 'test';\n    }\n}\n\nplaydate.update = () => {\n    printTable(new A());\n};\n"],"names":["A","method","playdate","update","printTable"],"rangeMappings":";;;;;;;","mappings":"AAAA,IAAA,AAAMA,IAAN,MAAMA;IACFC,SAAS;QACL,OAAO;IACX;AACJ;AAEAC,SAASC,MAAM,GAAG;IACdC,WAAW,IAAIJ;AACnB"}

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

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../../../../../../libs/cli/src/commands/TranspileCommand/fn/_tests/test-static/src/index.ts"],"sourcesContent":["class A {\n    static staticField = 'staticField';\n    constructor() {\n        // eslint-disable-next-line @typescript-eslint/no-unused-vars\n        const someVar = 1;\n    }\n}\n\nclass B extends A {\n    constructor() {\n        super();\n    }\n}\n\nplaydate.update = () => {\n    printTable(new A());\n    printTable(new B());\n};\n"],"names":["A","constructor","someVar","staticField","B","playdate","update","printTable"],"rangeMappings":";;;;;;;;;;;;;;;","mappings":"AAAA,IAAA,AAAMA,IAAN,MAAMA;IAEFC,aAAc;QACV,6DAA6D;QAC7D,MAAMC,UAAU;IACpB;AACJ;AANMF,EACKG,cAAc;AAOzB,IAAA,AAAMC,IAAN,MAAMA,UAAUJ;IACZC,aAAc;QACV,KAAK;IACT;AACJ;AAEAI,SAASC,MAAM,GAAG;IACdC,WAAW,IAAIP;IACfO,WAAW,IAAIH;AACnB"}
+{"version":3,"sources":["../../../../../../../../../../libs/cli/src/commands/TranspileCommand/fn/_tests/test-static/src/index.ts"],"sourcesContent":["class A {\n    static staticField = 'staticField';\n\n    constructor() {\n        // eslint-disable-next-line @typescript-eslint/no-unused-vars\n        const someVar = 1;\n    }\n}\n\nclass B extends A {\n    constructor() {\n        super();\n    }\n}\n\nplaydate.update = () => {\n    printTable(new A());\n    printTable(new B());\n};\n"],"names":["A","constructor","someVar","staticField","B","playdate","update","printTable"],"rangeMappings":";;;;;;;;;;;;;;;","mappings":"AAAA,IAAA,AAAMA,IAAN,MAAMA;IAGFC,aAAc;QACV,6DAA6D;QAC7D,MAAMC,UAAU;IACpB;AACJ;AAPMF,EACKG,cAAc;AAQzB,IAAA,AAAMC,IAAN,MAAMA,UAAUJ;IACZC,aAAc;QACV,KAAK;IACT;AACJ;AAEAI,SAASC,MAAM,GAAG;IACdC,WAAW,IAAIP;IACfO,WAAW,IAAIH;AACnB"}