crankscript 0.10.6 → 0.10.8

package/assets/transformClassDeclaration/transformMethodDeclaration.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../libs/tstl-plugin/src/transformClassDeclaration/transformMethodDeclaration.ts"],"sourcesContent":["import * as ts from 'typescript';\nimport { TransformationContext } from 'typescript-to-lua';\nimport * as tstl from 'typescript-to-lua';\nimport { transformFunctionToExpression } from 'typescript-to-lua/dist/transformation/visitors/function';\nimport { transformPropertyName } from './transformPropertyName';\n\nexport const transformMethodDeclaration = (\n    context: TransformationContext,\n    node: ts.MethodDeclaration,\n    className: tstl.Identifier\n): tstl.Statement | undefined => {\n    const [functionExpression] = transformFunctionToExpression(context, node);\n    return tstl.createAssignmentStatement(\n        tstl.createTableIndexExpression(\n            className,\n            transformPropertyName(context, node.name)\n        ),\n        functionExpression\n    );\n};\n"],"names":["transformMethodDeclaration","context","node","className","functionExpression","transformFunctionToExpression","tstl","createAssignmentStatement","createTableIndexExpression","transformPropertyName","name"],"rangeMappings":";;;;;;;;;;;;;;;;;","mappings":";;;;+BAMaA;;;eAAAA;;;;2EAJS;0BACwB;uCACR;AAE/B,MAAMA,6BAA6B,CACtCC,SACAC,MACAC;IAEA,MAAM,CAACC,mBAAmB,GAAGC,IAAAA,uCAA6B,EAACJ,SAASC;IACpE,OAAOI,iBAAKC,yBAAyB,CACjCD,iBAAKE,0BAA0B,CAC3BL,WACAM,IAAAA,4CAAqB,EAACR,SAASC,KAAKQ,IAAI,IAE5CN;AAER"}

package/assets/transformClassDeclaration/transformPropertyName.d.ts

@@ -0,0 +1,3 @@
+import * as ts from 'typescript';
+import { TransformationContext } from 'typescript-to-lua';
+export declare const transformPropertyName: (context: TransformationContext, node: ts.PropertyName) => import("typescript-to-lua").Expression;

package/assets/transformClassDeclaration/transformPropertyName.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "transformPropertyName", {
+    enumerable: true,
+    get: function() {
+        return transformPropertyName;
+    }
+});
+const _interop_require_wildcard = require("@swc/helpers/_/_interop_require_wildcard");
+const _typescript = /*#__PURE__*/ _interop_require_wildcard._(require("typescript"));
+const _typescripttolua = require("typescript-to-lua");
+const transformPropertyName = (context, node)=>{
+    if (_typescript.isComputedPropertyName(node)) {
+        return context.transformExpression(node.expression);
+    } else if (_typescript.isIdentifier(node)) {
+        return (0, _typescripttolua.createStringLiteral)(node.text);
+    } else if (_typescript.isPrivateIdentifier(node)) {
+        throw new Error('PrivateIdentifier is not supported');
+    } else {
+        return context.transformExpression(node);
+    }
+};
+
+//# sourceMappingURL=transformPropertyName.js.map

package/assets/transformClassDeclaration/transformPropertyName.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../libs/tstl-plugin/src/transformClassDeclaration/transformPropertyName.ts"],"sourcesContent":["import * as ts from 'typescript';\nimport { createStringLiteral } from 'typescript-to-lua';\nimport { TransformationContext } from 'typescript-to-lua';\n\nexport const transformPropertyName = (\n    context: TransformationContext,\n    node: ts.PropertyName\n) => {\n    if (ts.isComputedPropertyName(node)) {\n        return context.transformExpression(node.expression);\n    } else if (ts.isIdentifier(node)) {\n        return createStringLiteral(node.text);\n    } else if (ts.isPrivateIdentifier(node)) {\n        throw new Error('PrivateIdentifier is not supported');\n    } else {\n        return context.transformExpression(node);\n    }\n};\n"],"names":["transformPropertyName","context","node","ts","isComputedPropertyName","transformExpression","expression","isIdentifier","createStringLiteral","text","isPrivateIdentifier","Error"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;+BAIaA;;;eAAAA;;;;sEAJO;iCACgB;AAG7B,MAAMA,wBAAwB,CACjCC,SACAC;IAEA,IAAIC,YAAGC,sBAAsB,CAACF,OAAO;QACjC,OAAOD,QAAQI,mBAAmB,CAACH,KAAKI,UAAU;IACtD,OAAO,IAAIH,YAAGI,YAAY,CAACL,OAAO;QAC9B,OAAOM,IAAAA,oCAAmB,EAACN,KAAKO,IAAI;IACxC,OAAO,IAAIN,YAAGO,mBAAmB,CAACR,OAAO;QACrC,MAAM,IAAIS,MAAM;IACpB,OAAO;QACH,OAAOV,QAAQI,mBAAmB,CAACH;IACvC;AACJ"}

package/assets/transformNewExpression/index.d.ts

@@ -0,0 +1 @@
+export * from './transformNewExpression';

package/assets/transformNewExpression/index.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+const _export_star = require("@swc/helpers/_/_export_star");
+_export_star._(require("./transformNewExpression"), exports);
+
+//# sourceMappingURL=index.js.map

package/assets/transformNewExpression/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../libs/tstl-plugin/src/transformNewExpression/index.ts"],"sourcesContent":["export * from './transformNewExpression';\n"],"names":[],"rangeMappings":";;;;;","mappings":";;;;;uBAAc"}

package/assets/transformNewExpression/transformNewExpression.d.ts

@@ -0,0 +1,3 @@
+import * as ts from 'typescript';
+import * as tstl from 'typescript-to-lua';
+export declare const transformNewExpression: (node: ts.NewExpression, context: tstl.TransformationContext) => tstl.CallExpression;

package/assets/transformNewExpression/transformNewExpression.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "transformNewExpression", {
+    enumerable: true,
+    get: function() {
+        return transformNewExpression;
+    }
+});
+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 _call = require("typescript-to-lua/dist/transformation/visitors/call");
+const transformNewExpression = (node, context)=>{
+    const signature = context.checker.getResolvedSignature(node);
+    var _node_arguments;
+    const [name, params] = (0, _call.transformCallAndArguments)(context, node.expression, (_node_arguments = node.arguments) != null ? _node_arguments : [
+        _typescript.factory.createTrue()
+    ], signature);
+    return _typescripttolua.createCallExpression(name, params);
+};
+
+//# sourceMappingURL=transformNewExpression.js.map

package/assets/transformNewExpression/transformNewExpression.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../libs/tstl-plugin/src/transformNewExpression/transformNewExpression.ts"],"sourcesContent":["import * as ts from 'typescript';\nimport { FunctionVisitor } from 'typescript-to-lua';\nimport * as tstl from 'typescript-to-lua';\nimport { transformCallAndArguments } from 'typescript-to-lua/dist/transformation/visitors/call';\n\nexport const transformNewExpression = ((node, context) => {\n    const signature = context.checker.getResolvedSignature(node);\n    const [name, params] = transformCallAndArguments(\n        context,\n        node.expression,\n        node.arguments ?? [ts.factory.createTrue()],\n        signature\n    );\n    return tstl.createCallExpression(name, params);\n}) satisfies FunctionVisitor<ts.NewExpression>;\n"],"names":["transformNewExpression","node","context","signature","checker","getResolvedSignature","name","params","transformCallAndArguments","expression","arguments","ts","factory","createTrue","tstl","createCallExpression"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;","mappings":";;;;+BAKaA;;;eAAAA;;;;sEALO;2EAEE;sBACoB;AAEnC,MAAMA,yBAA0B,CAACC,MAAMC;IAC1C,MAAMC,YAAYD,QAAQE,OAAO,CAACC,oBAAoB,CAACJ;QAInDA;IAHJ,MAAM,CAACK,MAAMC,OAAO,GAAGC,IAAAA,+BAAyB,EAC5CN,SACAD,KAAKQ,UAAU,EACfR,CAAAA,kBAAAA,KAAKS,SAAS,YAAdT,kBAAkB;QAACU,YAAGC,OAAO,CAACC,UAAU;KAAG,EAC3CV;IAEJ,OAAOW,iBAAKC,oBAAoB,CAACT,MAAMC;AAC3C"}

package/assets/transformPropertyAccessExpression/getTransformPropertyAccessExpression.d.ts

@@ -0,0 +1,3 @@
+import * as ts from 'typescript';
+import { ImportMap } from '../ImportMap';
+export declare const getTransformPropertyAccessExpression: (importMap: ImportMap) => (node: ts.PropertyAccessExpression, context: import("typescript-to-lua").TransformationContext) => import("typescript-to-lua").Expression;

package/assets/transformPropertyAccessExpression/getTransformPropertyAccessExpression.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "getTransformPropertyAccessExpression", {
+    enumerable: true,
+    get: function() {
+        return getTransformPropertyAccessExpression;
+    }
+});
+const _interop_require_wildcard = require("@swc/helpers/_/_interop_require_wildcard");
+const _typescript = /*#__PURE__*/ _interop_require_wildcard._(require("typescript"));
+const getTransformPropertyAccessExpression = (importMap)=>{
+    return (node, context)=>{
+        if (_typescript.isIdentifier(node.expression)) {
+            importMap.processName(node.name.text);
+        }
+        return context.superTransformExpression(node);
+    };
+};
+
+//# sourceMappingURL=getTransformPropertyAccessExpression.js.map

package/assets/transformPropertyAccessExpression/getTransformPropertyAccessExpression.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../libs/tstl-plugin/src/transformPropertyAccessExpression/getTransformPropertyAccessExpression.ts"],"sourcesContent":["import * as ts from 'typescript';\nimport { FunctionVisitor } from 'typescript-to-lua';\nimport { ImportMap } from '../ImportMap';\n\nexport const getTransformPropertyAccessExpression = (importMap: ImportMap) => {\n    return ((node, context) => {\n        if (ts.isIdentifier(node.expression)) {\n            importMap.processName(node.name.text);\n        }\n\n        return context.superTransformExpression(node);\n    }) satisfies FunctionVisitor<ts.PropertyAccessExpression>;\n};\n"],"names":["getTransformPropertyAccessExpression","importMap","node","context","ts","isIdentifier","expression","processName","name","text","superTransformExpression"],"rangeMappings":";;;;;;;;;;;;;;;;;;;","mappings":";;;;+BAIaA;;;eAAAA;;;;sEAJO;AAIb,MAAMA,uCAAuC,CAACC;IACjD,OAAQ,CAACC,MAAMC;QACX,IAAIC,YAAGC,YAAY,CAACH,KAAKI,UAAU,GAAG;YAClCL,UAAUM,WAAW,CAACL,KAAKM,IAAI,CAACC,IAAI;QACxC;QAEA,OAAON,QAAQO,wBAAwB,CAACR;IAC5C;AACJ"}

package/assets/transformPropertyAccessExpression/index.d.ts

@@ -0,0 +1 @@
+export * from './getTransformPropertyAccessExpression';

package/assets/transformPropertyAccessExpression/index.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+const _export_star = require("@swc/helpers/_/_export_star");
+_export_star._(require("./getTransformPropertyAccessExpression"), exports);
+
+//# sourceMappingURL=index.js.map

package/assets/transformPropertyAccessExpression/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../libs/tstl-plugin/src/transformPropertyAccessExpression/index.ts"],"sourcesContent":["export * from './getTransformPropertyAccessExpression';\n"],"names":[],"rangeMappings":";;;;;","mappings":";;;;;uBAAc"}

package/assets/transformSuperExpression/index.d.ts

@@ -0,0 +1 @@
+export * from './transformSuperExpression';

package/assets/transformSuperExpression/index.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+const _export_star = require("@swc/helpers/_/_export_star");
+_export_star._(require("./transformSuperExpression"), exports);
+
+//# sourceMappingURL=index.js.map

package/assets/transformSuperExpression/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../libs/tstl-plugin/src/transformSuperExpression/index.ts"],"sourcesContent":["export * from './transformSuperExpression';\n"],"names":[],"rangeMappings":";;;;;","mappings":";;;;;uBAAc"}

package/assets/transformSuperExpression/transformSuperExpression.d.ts

@@ -0,0 +1,7 @@
+import * as ts from 'typescript';
+import { TransformationContext } from 'typescript-to-lua';
+import * as lua from 'typescript-to-lua/dist/LuaAST';
+import { ClassSuperInfo } from '../types';
+export declare const transformSuperExpression: (expression: ts.SuperExpression, context: TransformationContext & {
+    classSuperInfos?: ClassSuperInfo[];
+}) => lua.Identifier | lua.TableIndexExpression;

package/assets/transformSuperExpression/transformSuperExpression.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "transformSuperExpression", {
+    enumerable: true,
+    get: function() {
+        return transformSuperExpression;
+    }
+});
+const _interop_require_wildcard = require("@swc/helpers/_/_interop_require_wildcard");
+const _LuaAST = /*#__PURE__*/ _interop_require_wildcard._(require("typescript-to-lua/dist/LuaAST"));
+const transformSuperExpression = (expression, context)=>{
+    const superInfos = context.classSuperInfos;
+    let superInfo = undefined;
+    if (superInfos) {
+        superInfo = superInfos[superInfos.length - 1];
+    }
+    if (!superInfo) return _LuaAST.createAnonymousIdentifier(expression);
+    const { className } = superInfo;
+    return _LuaAST.createTableIndexExpression(className, _LuaAST.createStringLiteral('super'));
+};
+
+//# sourceMappingURL=transformSuperExpression.js.map

package/assets/transformSuperExpression/transformSuperExpression.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../libs/tstl-plugin/src/transformSuperExpression/transformSuperExpression.ts"],"sourcesContent":["import * as ts from 'typescript';\nimport { FunctionVisitor, TransformationContext } from 'typescript-to-lua';\nimport * as lua from 'typescript-to-lua/dist/LuaAST';\nimport { ClassSuperInfo } from '../types';\n\nexport const transformSuperExpression = ((\n    expression,\n    context: TransformationContext & { classSuperInfos?: ClassSuperInfo[] }\n) => {\n    const superInfos = context.classSuperInfos;\n    let superInfo: ClassSuperInfo | undefined = undefined;\n    if (superInfos) {\n        superInfo = superInfos[superInfos.length - 1];\n    }\n    if (!superInfo) return lua.createAnonymousIdentifier(expression);\n    const { className } = superInfo;\n\n    return lua.createTableIndexExpression(\n        className,\n        lua.createStringLiteral('super')\n    );\n}) satisfies FunctionVisitor<ts.SuperExpression>;\n"],"names":["transformSuperExpression","expression","context","superInfos","classSuperInfos","superInfo","undefined","length","lua","createAnonymousIdentifier","className","createTableIndexExpression","createStringLiteral"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;","mappings":";;;;+BAKaA;;;eAAAA;;;;kEAHQ;AAGd,MAAMA,2BAA4B,CACrCC,YACAC;IAEA,MAAMC,aAAaD,QAAQE,eAAe;IAC1C,IAAIC,YAAwCC;IAC5C,IAAIH,YAAY;QACZE,YAAYF,UAAU,CAACA,WAAWI,MAAM,GAAG,EAAE;IACjD;IACA,IAAI,CAACF,WAAW,OAAOG,QAAIC,yBAAyB,CAACR;IACrD,MAAM,EAAES,SAAS,EAAE,GAAGL;IAEtB,OAAOG,QAAIG,0BAA0B,CACjCD,WACAF,QAAII,mBAAmB,CAAC;AAEhC"}

package/assets/types.d.ts

@@ -0,0 +1,6 @@
+import * as ts from 'typescript';
+import * as lua from 'typescript-to-lua/dist/LuaAST';
+export interface ClassSuperInfo {
+    className: lua.Identifier;
+    extendedTypeNode?: ts.ExpressionWithTypeArguments;
+}

package/assets/types.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+
+//# sourceMappingURL=types.js.map

package/assets/types.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../libs/tstl-plugin/src/types.ts"],"names":[],"rangeMappings":"","mappings":""}

package/package.json

@@ -1,10 +1,9 @@
 {
     "name": "crankscript",
-    "version": "0.10.6",
+    "version": "0.10.8",
     "scripts": {
         "dev": "tsx src/index.ts",
-        "post-build": "tsc-alias --project tsconfig.json",
-        "prepare-assets": "npx tsc -p assets/tsconfig.json"
+        "post-build": "tsc-alias --project tsconfig.json"
     },
     "bin": {
         "crankscript": "./src/index.js"

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

@@ -0,0 +1,23 @@
+const getString = ()=>{
+    return 'some-string';
+};
+let A = class A {
+    constructor(firstArgument, otherArgument){
+        print(firstArgument);
+        print(otherArgument);
+    }
+};
+let B = class B extends A {
+    constructor(firstArgument, secondArgument, thirdArgument){
+        print(firstArgument);
+        print(secondArgument);
+        print(thirdArgument);
+        var _getString;
+        super(firstArgument, (_getString = getString()) != null ? _getString : 'hello');
+    }
+};
+playdate.update = ()=>{
+    printTable(new B(0, 1, 2));
+};
+
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../../../../libs/cli/src/commands/TranspileCommand/fn/_tests/test-super/src/index.ts"],"sourcesContent":["const getString = () => {\n    return 'some-string';\n};\n\nclass A {\n    constructor(firstArgument: number, otherArgument: string) {\n        print(firstArgument);\n        print(otherArgument);\n    }\n}\n\nclass B extends A {\n    constructor(\n        firstArgument: number,\n        secondArgument: number,\n        thirdArgument: number\n    ) {\n        print(firstArgument);\n        print(secondArgument);\n        print(thirdArgument);\n\n        super(firstArgument, getString() ?? 'hello');\n    }\n}\n\nplaydate.update = () => {\n    printTable(new B(0, 1, 2));\n};\n"],"names":["getString","A","constructor","firstArgument","otherArgument","print","B","secondArgument","thirdArgument","playdate","update","printTable"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;","mappings":"AAAA,MAAMA,YAAY;IACd,OAAO;AACX;AAEA,IAAA,AAAMC,IAAN,MAAMA;IACFC,YAAYC,aAAqB,EAAEC,aAAqB,CAAE;QACtDC,MAAMF;QACNE,MAAMD;IACV;AACJ;AAEA,IAAA,AAAME,IAAN,MAAMA,UAAUL;IACZC,YACIC,aAAqB,EACrBI,cAAsB,EACtBC,aAAqB,CACvB;QACEH,MAAMF;QACNE,MAAME;QACNF,MAAMG;YAEeR;QAArB,KAAK,CAACG,eAAeH,CAAAA,aAAAA,uBAAAA,aAAe;IACxC;AACJ;AAEAS,SAASC,MAAM,GAAG;IACdC,WAAW,IAAIL,EAAE,GAAG,GAAG;AAC3B"}

package/src/commands/TranspileCommand/fn/transpile.d.ts

@@ -1 +1,2 @@
-export declare const transpile: (path: string) => void;
+import * as tstl from 'typescript-to-lua';
+export declare const transpile: (path: string) => tstl.EmitResult;

package/src/commands/TranspileCommand/fn/transpile.js

@@ -3,14 +3,14 @@ import * as tstl from 'typescript-to-lua';
 import { LuaTarget } from 'typescript-to-lua';
 import { RootFolder } from '../../../constants.js';
 export const transpile = (path)=>{
-    tstl.transpileProject(join(path, 'tsconfig.json'), {
+    return tstl.transpileProject(join(path, 'tsconfig.json'), {
         luaTarget: LuaTarget.Lua54,
         outDir: join(path, 'Source'),
         luaBundle: 'main.lua',
         luaBundleEntry: join(path, 'src', 'index.ts'),
         luaPlugins: [
             {
-                name: join(RootFolder, 'assets', 'plugin.js')
+                name: join(RootFolder, 'assets', 'index.js')
             }
         ]
     });

package/src/commands/TranspileCommand/fn/transpile.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../../../libs/cli/src/commands/TranspileCommand/fn/transpile.ts"],"sourcesContent":["import { join } from 'node:path';\nimport * as tstl from 'typescript-to-lua';\nimport { LuaTarget } from 'typescript-to-lua';\nimport { RootFolder } from '@/cli/constants.js';\n\nexport const transpile = (path: string) => {\n    tstl.transpileProject(join(path, 'tsconfig.json'), {\n        luaTarget: LuaTarget.Lua54,\n        outDir: join(path, 'Source'),\n        luaBundle: 'main.lua',\n        luaBundleEntry: join(path, 'src', 'index.ts'),\n        luaPlugins: [\n            {\n                name: join(RootFolder, 'assets', 'plugin.js'),\n            },\n        ],\n    });\n};\n"],"names":["join","tstl","LuaTarget","RootFolder","transpile","path","transpileProject","luaTarget","Lua54","outDir","luaBundle","luaBundleEntry","luaPlugins","name"],"rangeMappings":";;;;;;;;;;;;;;;;","mappings":"AAAA,SAASA,IAAI,QAAQ,YAAY;AACjC,YAAYC,UAAU,oBAAoB;AAC1C,SAASC,SAAS,QAAQ,oBAAoB;AAC9C,SAASC,UAAU,QAAQ,qBAAqB;AAEhD,OAAO,MAAMC,YAAY,CAACC;IACtBJ,KAAKK,gBAAgB,CAACN,KAAKK,MAAM,kBAAkB;QAC/CE,WAAWL,UAAUM,KAAK;QAC1BC,QAAQT,KAAKK,MAAM;QACnBK,WAAW;QACXC,gBAAgBX,KAAKK,MAAM,OAAO;QAClCO,YAAY;YACR;gBACIC,MAAMb,KAAKG,YAAY,UAAU;YACrC;SACH;IACL;AACJ,EAAE"}
+{"version":3,"sources":["../../../../../../../libs/cli/src/commands/TranspileCommand/fn/transpile.ts"],"sourcesContent":["import { join } from 'node:path';\nimport * as tstl from 'typescript-to-lua';\nimport { LuaTarget } from 'typescript-to-lua';\nimport { RootFolder } from '@/cli/constants.js';\n\nexport const transpile = (path: string) => {\n    return tstl.transpileProject(join(path, 'tsconfig.json'), {\n        luaTarget: LuaTarget.Lua54,\n        outDir: join(path, 'Source'),\n        luaBundle: 'main.lua',\n        luaBundleEntry: join(path, 'src', 'index.ts'),\n        luaPlugins: [\n            {\n                name: join(RootFolder, 'assets', 'index.js'),\n            },\n        ],\n    });\n};\n"],"names":["join","tstl","LuaTarget","RootFolder","transpile","path","transpileProject","luaTarget","Lua54","outDir","luaBundle","luaBundleEntry","luaPlugins","name"],"rangeMappings":";;;;;;;;;;;;;;;;","mappings":"AAAA,SAASA,IAAI,QAAQ,YAAY;AACjC,YAAYC,UAAU,oBAAoB;AAC1C,SAASC,SAAS,QAAQ,oBAAoB;AAC9C,SAASC,UAAU,QAAQ,qBAAqB;AAEhD,OAAO,MAAMC,YAAY,CAACC;IACtB,OAAOJ,KAAKK,gBAAgB,CAACN,KAAKK,MAAM,kBAAkB;QACtDE,WAAWL,UAAUM,KAAK;QAC1BC,QAAQT,KAAKK,MAAM;QACnBK,WAAW;QACXC,gBAAgBX,KAAKK,MAAM,OAAO;QAClCO,YAAY;YACR;gBACIC,MAAMb,KAAKG,YAAY,UAAU;YACrC;SACH;IACL;AACJ,EAAE"}

package/assets/plugin.js

@@ -1,260 +0,0 @@
-"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 (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-var _a;
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.transformSuperExpression = exports.transformClassDeclaration = void 0;
-exports.transformPropertyName = transformPropertyName;
-var ts = __importStar(require("typescript"));
-var tstl = __importStar(require("typescript-to-lua"));
-var lua = __importStar(require("typescript-to-lua/dist/LuaAST"));
-var scope_1 = require("typescript-to-lua/dist/transformation/utils/scope");
-var call_1 = require("typescript-to-lua/dist/transformation/visitors/call");
-var fields_1 = require("typescript-to-lua/dist/transformation/visitors/class/members/fields");
-var utils_1 = require("typescript-to-lua/dist/transformation/visitors/class/utils");
-var function_1 = require("typescript-to-lua/dist/transformation/visitors/function");
-var importMap = {
-    graphics: new Set(['graphics']),
-    sprites: new Set(['sprite']),
-    crank: new Set(['getCrankTicks']),
-    object: new Set(['printTable']),
-    'utilities/where': new Set(['where']),
-    easing: new Set(['easingFunctions']),
-    nineSlice: new Set(['nineSlice']),
-    qrcode: new Set(['generateQRCode']),
-    animation: new Set(['animation']),
-    animator: new Set(['animator']),
-    keyboard: new Set(['keyboard']),
-    math: new Set(['math']),
-    string: new Set(['string']),
-    timer: new Set(['timer']),
-    frameTimer: new Set(['frameTimer']),
-    ui: new Set(['ui']),
-};
-var imports = new Set();
-function createClassCall(context, className, extendsNode) {
-    // class('X')
-    var classCall = tstl.createCallExpression(tstl.createIdentifier('class'), [tstl.createStringLiteral(className.text)]);
-    var classCreationExpression;
-    if (extendsNode) {
-        // class('X').extends(Blah)
-        classCreationExpression = tstl.createCallExpression(tstl.createTableIndexExpression(classCall, tstl.createStringLiteral('extends')), [context.transformExpression(extendsNode.expression)]);
-    }
-    else {
-        classCreationExpression = tstl.createCallExpression(tstl.createTableIndexExpression(classCall, tstl.createStringLiteral('extends')), [tstl.createIdentifier('Object')]);
-    }
-    return tstl.createExpressionStatement(classCreationExpression);
-}
-function transformPropertyName(context, node) {
-    if (ts.isComputedPropertyName(node)) {
-        return context.transformExpression(node.expression);
-    }
-    else if (ts.isIdentifier(node)) {
-        return tstl.createStringLiteral(node.text);
-    }
-    else if (ts.isPrivateIdentifier(node)) {
-        throw new Error('PrivateIdentifier is not supported');
-    }
-    else {
-        return context.transformExpression(node);
-    }
-}
-function transformConstructor(context, className, instanceFields, constructor) {
-    var methodName = 'init';
-    context.pushScope(scope_1.ScopeType.Function);
-    var bodyStatements = [];
-    var params;
-    if (constructor) {
-        params = (0, function_1.transformParameters)(context, constructor === null || constructor === void 0 ? void 0 : constructor.parameters, tstl.createIdentifier('self'))[0];
-    }
-    else {
-        params = [tstl.createIdentifier('self')];
-    }
-    bodyStatements.push(tstl.createExpressionStatement(tstl.createCallExpression(tstl.createTableIndexExpression(tstl.createTableIndexExpression(className, tstl.createStringLiteral('super')), tstl.createStringLiteral('init')), params)));
-    var classInstanceFields = (0, fields_1.transformClassInstanceFields)(context, instanceFields);
-    // initializers have to come before any body of the constructor
-    bodyStatements.push.apply(bodyStatements, classInstanceFields);
-    if (constructor === null || constructor === void 0 ? void 0 : constructor.body) {
-        var body = (0, function_1.transformFunctionBodyContent)(context, constructor.body);
-        // if the first expression in the body is a super call, ignore it, because we have
-        // constructed our own super call.
-        // if it's not, make sure to include the entire body.
-        var firstStatement = constructor.body.statements[0];
-        if (firstStatement &&
-            ts.isExpressionStatement(firstStatement) &&
-            ts.isCallExpression(firstStatement.expression) &&
-            firstStatement.expression.expression.kind ===
-                ts.SyntaxKind.SuperKeyword) {
-            bodyStatements.push.apply(bodyStatements, body.slice(1));
-        }
-        else {
-            bodyStatements.push.apply(bodyStatements, body);
-        }
-    }
-    context.popScope();
-    return tstl.createAssignmentStatement(tstl.createTableIndexExpression(className, tstl.createStringLiteral(methodName)), tstl.createFunctionExpression(tstl.createBlock(bodyStatements), params));
-}
-function transformMethodDeclaration(context, node, className) {
-    var functionExpression = (0, function_1.transformFunctionToExpression)(context, node)[0];
-    return tstl.createAssignmentStatement(tstl.createTableIndexExpression(className, transformPropertyName(context, node.name)), functionExpression);
-}
-var transformClassDeclaration = function (declaration, context) {
-    imports.add('object');
-    var className;
-    if (declaration.name) {
-        className = tstl.createIdentifier(declaration.name.text);
-    }
-    else {
-        className = tstl.createIdentifier(context.createTempName('class'), declaration);
-    }
-    var extension = (0, utils_1.getExtendedNode)(declaration);
-    if (context.classSuperInfos) {
-        context.classSuperInfos.push({
-            className: className,
-            extendedTypeNode: extension,
-        });
-    }
-    else {
-        context.classSuperInfos = [{ className: className, extendedTypeNode: extension }];
-    }
-    // Get all properties with value
-    var properties = declaration.members
-        .filter(ts.isPropertyDeclaration)
-        .filter(function (member) { return member.initializer; });
-    // Divide properties into static and non-static
-    var instanceFields = properties.filter(function (prop) { return !(0, utils_1.isStaticNode)(prop); });
-    var statements = [];
-    // class('X')
-    statements.push(createClassCall(context, className, extension));
-    // function X:init()
-    //   X.super.init(self)
-    // end
-    var constructor = declaration.members.find(function (n) {
-        return ts.isConstructorDeclaration(n) && n.body !== undefined;
-    });
-    var transformedConstructor = transformConstructor(context, className, instanceFields, constructor);
-    if (transformedConstructor) {
-        statements.push(transformedConstructor);
-    }
-    var methods = declaration.members
-        .filter(ts.isMethodDeclaration)
-        .map(function (method) { return transformMethodDeclaration(context, method, className); })
-        .filter(function (method) { return method !== undefined; });
-    statements.push.apply(statements, methods);
-    // export the class if needed
-    // todo: check if there is a cleaner way to do this
-    if ('localSymbol' in declaration &&
-        typeof declaration.localSymbol === 'object' &&
-        'exportSymbol' in declaration.localSymbol &&
-        typeof declaration.localSymbol.exportSymbol === 'object' &&
-        'escapedName' in declaration.localSymbol.exportSymbol &&
-        typeof declaration.localSymbol.exportSymbol.escapedName === 'string') {
-        var escapedName = declaration.localSymbol.exportSymbol.escapedName;
-        statements.push(tstl.createAssignmentStatement(tstl.createTableIndexExpression(tstl.createIdentifier('____exports'), tstl.createStringLiteral(escapedName)), className));
-    }
-    return statements;
-};
-exports.transformClassDeclaration = transformClassDeclaration;
-var transformNewExpression = function (node, context) {
-    var _a;
-    var signature = context.checker.getResolvedSignature(node);
-    var _b = (0, call_1.transformCallAndArguments)(context, node.expression, (_a = node.arguments) !== null && _a !== void 0 ? _a : [ts.factory.createTrue()], signature), name = _b[0], params = _b[1];
-    return tstl.createCallExpression(name, params);
-};
-var transformSuperExpression = function (expression, context) {
-    var superInfos = context.classSuperInfos;
-    var superInfo = undefined;
-    if (superInfos) {
-        superInfo = superInfos[superInfos.length - 1];
-    }
-    if (!superInfo)
-        return lua.createAnonymousIdentifier(expression);
-    var className = superInfo.className;
-    // Using `super` without extended type node is a TypeScript error
-    // const extendsExpression = extendedTypeNode?.expression;
-    // let baseClassName: lua.AssignmentLeftHandSideExpression | undefined;
-    // if (extendsExpression && ts.isIdentifier(extendsExpression)) {
-    //     const symbol = context.checker.getSymbolAtLocation(extendsExpression);
-    //     if (symbol && !isSymbolExported(context, symbol)) {
-    //         // Use "baseClassName" if base is a simple identifier
-    //         baseClassName = transformIdentifier(context, extendsExpression);
-    //     }
-    // }
-    // if (!baseClassName) {
-    //     // Use "className.____super" if the base is not a simple identifier
-    //     baseClassName = lua.createTableIndexExpression(
-    //         className,
-    //         lua.createStringLiteral('____super'),
-    //         expression
-    //     );
-    // }
-    return lua.createTableIndexExpression(className, lua.createStringLiteral('super'));
-};
-exports.transformSuperExpression = transformSuperExpression;
-var processName = function (name) {
-    for (var _i = 0, _a = Object.entries(importMap); _i < _a.length; _i++) {
-        var _b = _a[_i], key = _b[0], value = _b[1];
-        if (value instanceof Set && value.has(name)) {
-            imports.add(key);
-        }
-    }
-};
-var plugin = {
-    beforeEmit: function (_, __, ___, result) {
-        var importsString = Array.from(imports)
-            .map(function (importString) { return "import \"CoreLibs/".concat(importString, "\""); })
-            .join('\n');
-        if (importsString.trim() === '') {
-            return;
-        }
-        result[0].code = "-- These imports were added automatically\n\n".concat(importsString, "\n\n-- End of automatic imports\n\n").concat(result[0].code);
-    },
-    visitors: (_a = {},
-        _a[ts.SyntaxKind.ClassDeclaration] = exports.transformClassDeclaration,
-        _a[ts.SyntaxKind.SuperKeyword] = exports.transformSuperExpression,
-        _a[ts.SyntaxKind.NewExpression] = transformNewExpression,
-        _a[ts.SyntaxKind.PropertyAccessExpression] = function (node, context) {
-            if (ts.isIdentifier(node.expression)) {
-                processName(node.name.text);
-            }
-            return context.superTransformExpression(node);
-        },
-        _a[ts.SyntaxKind.CallExpression] = function (node, context) {
-            if (ts.isIdentifier(node.expression)) {
-                processName(node.expression.escapedText.toString());
-            }
-            if (ts.isIdentifier(node.expression) &&
-                node.expression.escapedText === 'require') {
-                var normalNode = context.superTransformExpression(node);
-                normalNode.expression.text = 'import';
-                normalNode.expression.originalName = 'import';
-                return normalNode;
-            }
-            else {
-                return context.superTransformExpression(node);
-            }
-        },
-        _a),
-};
-exports.default = plugin;