crankscript 0.10.7 → 0.11.0

package/assets/ImportMap/ImportMap.d.ts

@@ -0,0 +1,8 @@
+export declare class ImportMap {
+    private imports;
+    toArray(): string[];
+    map(callback: Parameters<ReturnType<typeof this.toArray>['map']>[0]): unknown[];
+    add(importName: string): void;
+    processName(name: string): void;
+    private static map;
+}

package/assets/ImportMap/ImportMap.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "ImportMap", {
+    enumerable: true,
+    get: function() {
+        return ImportMap;
+    }
+});
+let ImportMap = class ImportMap {
+    toArray() {
+        return Array.from(this.imports);
+    }
+    map(callback) {
+        return this.toArray().map(callback);
+    }
+    add(importName) {
+        this.imports.add(importName);
+    }
+    processName(name) {
+        for (const [key, value] of Object.entries(ImportMap.map)){
+            if (value.has(name)) {
+                this.add(key);
+            }
+        }
+    }
+    constructor(){
+        this.imports = new Set();
+    }
+};
+ImportMap.map = {
+    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'
+    ])
+};
+
+//# sourceMappingURL=ImportMap.js.map

package/assets/ImportMap/ImportMap.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../libs/tstl-plugin/src/ImportMap/ImportMap.ts"],"sourcesContent":["export class ImportMap {\n    private imports = new Set<string>();\n\n    toArray() {\n        return Array.from(this.imports);\n    }\n\n    map(callback: Parameters<ReturnType<typeof this.toArray>['map']>[0]) {\n        return this.toArray().map(callback);\n    }\n\n    add(importName: string) {\n        this.imports.add(importName);\n    }\n\n    processName(name: string) {\n        for (const [key, value] of Object.entries(ImportMap.map)) {\n            if (value.has(name)) {\n                this.add(key);\n            }\n        }\n    }\n\n    private static map = {\n        graphics: new Set(['graphics']),\n        sprites: new Set(['sprite']),\n        crank: new Set(['getCrankTicks']),\n        object: new Set(['printTable']),\n        'utilities/where': new Set(['where']),\n        easing: new Set(['easingFunctions']),\n        nineSlice: new Set(['nineSlice']),\n        qrcode: new Set(['generateQRCode']),\n        animation: new Set(['animation']),\n        animator: new Set(['animator']),\n        keyboard: new Set(['keyboard']),\n        math: new Set(['math']),\n        string: new Set(['string']),\n        timer: new Set(['timer']),\n        frameTimer: new Set(['frameTimer']),\n        ui: new Set(['ui']),\n    };\n}\n"],"names":["ImportMap","toArray","Array","from","imports","map","callback","add","importName","processName","name","key","value","Object","entries","has","Set","graphics","sprites","crank","object","easing","nineSlice","qrcode","animation","animator","keyboard","math","string","timer","frameTimer","ui"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;+BAAaA;;;eAAAA;;;AAAN,IAAA,AAAMA,YAAN,MAAMA;IAGTC,UAAU;QACN,OAAOC,MAAMC,IAAI,CAAC,IAAI,CAACC,OAAO;IAClC;IAEAC,IAAIC,QAA+D,EAAE;QACjE,OAAO,IAAI,CAACL,OAAO,GAAGI,GAAG,CAACC;IAC9B;IAEAC,IAAIC,UAAkB,EAAE;QACpB,IAAI,CAACJ,OAAO,CAACG,GAAG,CAACC;IACrB;IAEAC,YAAYC,IAAY,EAAE;QACtB,KAAK,MAAM,CAACC,KAAKC,MAAM,IAAIC,OAAOC,OAAO,CAACd,UAAUK,GAAG,EAAG;YACtD,IAAIO,MAAMG,GAAG,CAACL,OAAO;gBACjB,IAAI,CAACH,GAAG,CAACI;YACb;QACJ;IACJ;;aApBQP,UAAU,IAAIY;;AAwC1B;AAzCahB,UAuBMK,MAAM;IACjBY,UAAU,IAAID,IAAI;QAAC;KAAW;IAC9BE,SAAS,IAAIF,IAAI;QAAC;KAAS;IAC3BG,OAAO,IAAIH,IAAI;QAAC;KAAgB;IAChCI,QAAQ,IAAIJ,IAAI;QAAC;KAAa;IAC9B,mBAAmB,IAAIA,IAAI;QAAC;KAAQ;IACpCK,QAAQ,IAAIL,IAAI;QAAC;KAAkB;IACnCM,WAAW,IAAIN,IAAI;QAAC;KAAY;IAChCO,QAAQ,IAAIP,IAAI;QAAC;KAAiB;IAClCQ,WAAW,IAAIR,IAAI;QAAC;KAAY;IAChCS,UAAU,IAAIT,IAAI;QAAC;KAAW;IAC9BU,UAAU,IAAIV,IAAI;QAAC;KAAW;IAC9BW,MAAM,IAAIX,IAAI;QAAC;KAAO;IACtBY,QAAQ,IAAIZ,IAAI;QAAC;KAAS;IAC1Ba,OAAO,IAAIb,IAAI;QAAC;KAAQ;IACxBc,YAAY,IAAId,IAAI;QAAC;KAAa;IAClCe,IAAI,IAAIf,IAAI;QAAC;KAAK;AACtB"}

package/assets/ImportMap/index.d.ts

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

package/assets/ImportMap/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("./ImportMap"), exports);
+
+//# sourceMappingURL=index.js.map

package/assets/ImportMap/index.js.map

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

package/assets/beforeEmit/getBeforeEmit.d.ts

@@ -0,0 +1,2 @@
+import { ImportMap } from '../ImportMap';
+export declare const getBeforeEmit: (importMap: ImportMap) => (_: import("typescript").Program, __: import("typescript-to-lua").CompilerOptions, ___: import("typescript-to-lua").EmitHost, result: import("typescript-to-lua").EmitFile[]) => void;

package/assets/beforeEmit/getBeforeEmit.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "getBeforeEmit", {
+    enumerable: true,
+    get: function() {
+        return getBeforeEmit;
+    }
+});
+const _withAutomaticImportWarning = require("./withAutomaticImportWarning");
+const getBeforeEmit = (importMap)=>{
+    return (_, __, ___, result)=>{
+        const importsString = importMap.map((importString)=>`import "CoreLibs/${importString}"`).join('\n');
+        if (importsString.trim() === '') {
+            return;
+        }
+        result[0].code = (0, _withAutomaticImportWarning.withAutomaticImportWarning)(importsString, result[0].code);
+    };
+};
+
+//# sourceMappingURL=getBeforeEmit.js.map

package/assets/beforeEmit/getBeforeEmit.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../libs/tstl-plugin/src/beforeEmit/getBeforeEmit.ts"],"sourcesContent":["import { Plugin } from 'typescript-to-lua';\nimport { withAutomaticImportWarning } from './withAutomaticImportWarning';\nimport { ImportMap } from '../ImportMap';\n\nexport const getBeforeEmit = (importMap: ImportMap) => {\n    return ((_, __, ___, result) => {\n        const importsString = importMap\n            .map((importString) => `import \"CoreLibs/${importString}\"`)\n            .join('\\n');\n\n        if (importsString.trim() === '') {\n            return;\n        }\n\n        result[0].code = withAutomaticImportWarning(\n            importsString,\n            result[0].code\n        );\n    }) satisfies Plugin['beforeEmit'];\n};\n"],"names":["getBeforeEmit","importMap","_","__","___","result","importsString","map","importString","join","trim","code","withAutomaticImportWarning"],"rangeMappings":";;;;;;;;;;;;;;;;;;;","mappings":";;;;+BAIaA;;;eAAAA;;;4CAH8B;AAGpC,MAAMA,gBAAgB,CAACC;IAC1B,OAAQ,CAACC,GAAGC,IAAIC,KAAKC;QACjB,MAAMC,gBAAgBL,UACjBM,GAAG,CAAC,CAACC,eAAiB,CAAC,iBAAiB,EAAEA,aAAa,CAAC,CAAC,EACzDC,IAAI,CAAC;QAEV,IAAIH,cAAcI,IAAI,OAAO,IAAI;YAC7B;QACJ;QAEAL,MAAM,CAAC,EAAE,CAACM,IAAI,GAAGC,IAAAA,sDAA0B,EACvCN,eACAD,MAAM,CAAC,EAAE,CAACM,IAAI;IAEtB;AACJ"}

package/assets/beforeEmit/index.d.ts

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

package/assets/beforeEmit/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("./getBeforeEmit"), exports);
+
+//# sourceMappingURL=index.js.map

package/assets/beforeEmit/index.js.map

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

package/assets/beforeEmit/withAutomaticImportWarning.d.ts

@@ -0,0 +1 @@
+export declare const withAutomaticImportWarning: (importsString: string, code: string) => string;

package/assets/beforeEmit/withAutomaticImportWarning.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "withAutomaticImportWarning", {
+    enumerable: true,
+    get: function() {
+        return withAutomaticImportWarning;
+    }
+});
+const withAutomaticImportWarning = (importsString, code)=>{
+    return `-- These imports were added automatically\n\n${importsString}\n\n-- End of automatic imports\n\n${code}`;
+};
+
+//# sourceMappingURL=withAutomaticImportWarning.js.map

package/assets/beforeEmit/withAutomaticImportWarning.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../libs/tstl-plugin/src/beforeEmit/withAutomaticImportWarning.ts"],"sourcesContent":["export const withAutomaticImportWarning = (\n    importsString: string,\n    code: string\n) => {\n    return `-- These imports were added automatically\\n\\n${importsString}\\n\\n-- End of automatic imports\\n\\n${code}`;\n};\n"],"names":["withAutomaticImportWarning","importsString","code"],"rangeMappings":";;;;;;;;;;;;","mappings":";;;;+BAAaA;;;eAAAA;;;AAAN,MAAMA,6BAA6B,CACtCC,eACAC;IAEA,OAAO,CAAC,6CAA6C,EAAED,cAAc,mCAAmC,EAAEC,KAAK,CAAC;AACpH"}

package/assets/index.d.ts

@@ -0,0 +1,14 @@
+import * as ts from 'typescript';
+declare const _default: {
+    beforeEmit: (_: ts.Program, __: import("typescript-to-lua").CompilerOptions, ___: import("typescript-to-lua").EmitHost, result: import("typescript-to-lua").EmitFile[]) => void;
+    visitors: {
+        263: (declaration: ts.ClassLikeDeclaration, context: import("typescript-to-lua").TransformationContext) => import("typescript-to-lua").Statement[];
+        108: (expression: ts.SuperExpression, context: import("typescript-to-lua").TransformationContext & {
+            classSuperInfos?: import("./types").ClassSuperInfo[];
+        }) => import("typescript-to-lua").Identifier | import("typescript-to-lua").TableIndexExpression;
+        214: (node: ts.NewExpression, context: import("typescript-to-lua").TransformationContext) => import("typescript-to-lua").CallExpression;
+        211: (node: ts.PropertyAccessExpression, context: import("typescript-to-lua").TransformationContext) => import("typescript-to-lua").Expression;
+        213: (node: ts.CallExpression, context: import("typescript-to-lua").TransformationContext) => import("typescript-to-lua").Expression;
+    };
+};
+export default _default;

package/assets/index.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return _default;
+    }
+});
+const _interop_require_wildcard = require("@swc/helpers/_/_interop_require_wildcard");
+const _typescript = /*#__PURE__*/ _interop_require_wildcard._(require("typescript"));
+const _beforeEmit = require("./beforeEmit");
+const _ImportMap = require("./ImportMap");
+const _transformCallExpression = require("./transformCallExpression");
+const _transformClassDeclaration = require("./transformClassDeclaration");
+const _transformNewExpression = require("./transformNewExpression");
+const _transformPropertyAccessExpression = require("./transformPropertyAccessExpression");
+const _transformSuperExpression = require("./transformSuperExpression");
+const importMap = new _ImportMap.ImportMap();
+const _default = {
+    beforeEmit: (0, _beforeEmit.getBeforeEmit)(importMap),
+    visitors: {
+        [_typescript.SyntaxKind.ClassDeclaration]: (0, _transformClassDeclaration.getTransformClassDeclaration)(importMap),
+        [_typescript.SyntaxKind.SuperKeyword]: _transformSuperExpression.transformSuperExpression,
+        [_typescript.SyntaxKind.NewExpression]: _transformNewExpression.transformNewExpression,
+        [_typescript.SyntaxKind.PropertyAccessExpression]: (0, _transformPropertyAccessExpression.getTransformPropertyAccessExpression)(importMap),
+        [_typescript.SyntaxKind.CallExpression]: (0, _transformCallExpression.getTransformCallExpression)(importMap)
+    }
+};
+
+//# sourceMappingURL=index.js.map

package/assets/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../libs/tstl-plugin/src/index.ts"],"sourcesContent":["import * as ts from 'typescript';\nimport { Plugin } from 'typescript-to-lua';\nimport { getBeforeEmit } from './beforeEmit';\nimport { ImportMap } from './ImportMap';\nimport { getTransformCallExpression } from './transformCallExpression';\nimport { getTransformClassDeclaration } from './transformClassDeclaration';\nimport { transformNewExpression } from './transformNewExpression';\nimport { getTransformPropertyAccessExpression } from './transformPropertyAccessExpression';\nimport { transformSuperExpression } from './transformSuperExpression';\n\nconst importMap = new ImportMap();\n\nexport default {\n    beforeEmit: getBeforeEmit(importMap),\n    visitors: {\n        [ts.SyntaxKind.ClassDeclaration]:\n            getTransformClassDeclaration(importMap),\n        [ts.SyntaxKind.SuperKeyword]: transformSuperExpression,\n        [ts.SyntaxKind.NewExpression]: transformNewExpression,\n        [ts.SyntaxKind.PropertyAccessExpression]:\n            getTransformPropertyAccessExpression(importMap),\n        [ts.SyntaxKind.CallExpression]: getTransformCallExpression(importMap),\n    },\n} satisfies Plugin;\n"],"names":["importMap","ImportMap","beforeEmit","getBeforeEmit","visitors","ts","SyntaxKind","ClassDeclaration","getTransformClassDeclaration","SuperKeyword","transformSuperExpression","NewExpression","transformNewExpression","PropertyAccessExpression","getTransformPropertyAccessExpression","CallExpression","getTransformCallExpression"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;+BAYA;;;eAAA;;;;sEAZoB;4BAEU;2BACJ;yCACiB;2CACE;wCACN;mDACc;0CACZ;AAEzC,MAAMA,YAAY,IAAIC,oBAAS;MAE/B,WAAe;IACXC,YAAYC,IAAAA,yBAAa,EAACH;IAC1BI,UAAU;QACN,CAACC,YAAGC,UAAU,CAACC,gBAAgB,CAAC,EAC5BC,IAAAA,uDAA4B,EAACR;QACjC,CAACK,YAAGC,UAAU,CAACG,YAAY,CAAC,EAAEC,kDAAwB;QACtD,CAACL,YAAGC,UAAU,CAACK,aAAa,CAAC,EAAEC,8CAAsB;QACrD,CAACP,YAAGC,UAAU,CAACO,wBAAwB,CAAC,EACpCC,IAAAA,uEAAoC,EAACd;QACzC,CAACK,YAAGC,UAAU,CAACS,cAAc,CAAC,EAAEC,IAAAA,mDAA0B,EAAChB;IAC/D;AACJ"}

package/assets/transformCallExpression/getTransformCallExpression.d.ts

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

package/assets/transformCallExpression/getTransformCallExpression.js

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

package/assets/transformCallExpression/getTransformCallExpression.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../libs/tstl-plugin/src/transformCallExpression/getTransformCallExpression.ts"],"sourcesContent":["import * as ts from 'typescript';\nimport { Expression, FunctionVisitor } from 'typescript-to-lua';\nimport { ImportMap } from '../ImportMap';\n\nexport const getTransformCallExpression = (importMap: ImportMap) => {\n    return ((node, context) => {\n        if (ts.isIdentifier(node.expression)) {\n            importMap.processName(node.expression.escapedText.toString());\n        }\n\n        if (\n            ts.isIdentifier(node.expression) &&\n            node.expression.escapedText === 'require'\n        ) {\n            const normalNode = context.superTransformExpression(\n                node\n            ) as unknown as {\n                expression: { text: string; originalName: string };\n            };\n\n            normalNode.expression.text = 'import';\n            normalNode.expression.originalName = 'import';\n\n            return normalNode as unknown as Expression;\n        } else {\n            return context.superTransformExpression(node);\n        }\n    }) satisfies FunctionVisitor<ts.CallExpression>;\n};\n"],"names":["getTransformCallExpression","importMap","node","context","ts","isIdentifier","expression","processName","escapedText","toString","normalNode","superTransformExpression","text","originalName"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;+BAIaA;;;eAAAA;;;;sEAJO;AAIb,MAAMA,6BAA6B,CAACC;IACvC,OAAQ,CAACC,MAAMC;QACX,IAAIC,YAAGC,YAAY,CAACH,KAAKI,UAAU,GAAG;YAClCL,UAAUM,WAAW,CAACL,KAAKI,UAAU,CAACE,WAAW,CAACC,QAAQ;QAC9D;QAEA,IACIL,YAAGC,YAAY,CAACH,KAAKI,UAAU,KAC/BJ,KAAKI,UAAU,CAACE,WAAW,KAAK,WAClC;YACE,MAAME,aAAaP,QAAQQ,wBAAwB,CAC/CT;YAKJQ,WAAWJ,UAAU,CAACM,IAAI,GAAG;YAC7BF,WAAWJ,UAAU,CAACO,YAAY,GAAG;YAErC,OAAOH;QACX,OAAO;YACH,OAAOP,QAAQQ,wBAAwB,CAACT;QAC5C;IACJ;AACJ"}

package/assets/transformCallExpression/index.d.ts

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

package/assets/transformCallExpression/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("./getTransformCallExpression"), exports);
+
+//# sourceMappingURL=index.js.map

package/assets/transformCallExpression/index.js.map

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

package/assets/transformClassDeclaration/createClasCall.d.ts

@@ -0,0 +1,3 @@
+import * as ts from 'typescript';
+import * as tstl from 'typescript-to-lua';
+export declare const createClassCall: (context: tstl.TransformationContext, className: tstl.Identifier, extendsNode?: ts.ExpressionWithTypeArguments) => tstl.Statement;

package/assets/transformClassDeclaration/createClasCall.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "createClassCall", {
+    enumerable: true,
+    get: function() {
+        return createClassCall;
+    }
+});
+const _interop_require_wildcard = require("@swc/helpers/_/_interop_require_wildcard");
+const _typescripttolua = /*#__PURE__*/ _interop_require_wildcard._(require("typescript-to-lua"));
+const createClassCall = (context, className, extendsNode)=>{
+    // class('X')
+    const classCall = _typescripttolua.createCallExpression(_typescripttolua.createIdentifier('class'), [
+        _typescripttolua.createStringLiteral(className.text)
+    ]);
+    let classCreationExpression;
+    if (extendsNode) {
+        // class('X').extends(Blah)
+        classCreationExpression = _typescripttolua.createCallExpression(_typescripttolua.createTableIndexExpression(classCall, _typescripttolua.createStringLiteral('extends')), [
+            context.transformExpression(extendsNode.expression)
+        ]);
+    } else {
+        classCreationExpression = _typescripttolua.createCallExpression(_typescripttolua.createTableIndexExpression(classCall, _typescripttolua.createStringLiteral('extends')), [
+            _typescripttolua.createIdentifier('Object')
+        ]);
+    }
+    return _typescripttolua.createExpressionStatement(classCreationExpression);
+};
+
+//# sourceMappingURL=createClasCall.js.map

package/assets/transformClassDeclaration/createClasCall.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../libs/tstl-plugin/src/transformClassDeclaration/createClasCall.ts"],"sourcesContent":["import * as ts from 'typescript';\nimport * as tstl from 'typescript-to-lua';\n\nexport const createClassCall = (\n    context: tstl.TransformationContext,\n    className: tstl.Identifier,\n    extendsNode?: ts.ExpressionWithTypeArguments\n): tstl.Statement => {\n    // class('X')\n    const classCall = tstl.createCallExpression(\n        tstl.createIdentifier('class'),\n        [tstl.createStringLiteral(className.text)]\n    );\n    let classCreationExpression: tstl.Expression;\n    if (extendsNode) {\n        // class('X').extends(Blah)\n        classCreationExpression = tstl.createCallExpression(\n            tstl.createTableIndexExpression(\n                classCall,\n                tstl.createStringLiteral('extends')\n            ),\n            [context.transformExpression(extendsNode.expression)]\n        );\n    } else {\n        classCreationExpression = tstl.createCallExpression(\n            tstl.createTableIndexExpression(\n                classCall,\n                tstl.createStringLiteral('extends')\n            ),\n            [tstl.createIdentifier('Object')]\n        );\n    }\n    return tstl.createExpressionStatement(classCreationExpression);\n};\n"],"names":["createClassCall","context","className","extendsNode","classCall","tstl","createCallExpression","createIdentifier","createStringLiteral","text","classCreationExpression","createTableIndexExpression","transformExpression","expression","createExpressionStatement"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;+BAGaA;;;eAAAA;;;;2EAFS;AAEf,MAAMA,kBAAkB,CAC3BC,SACAC,WACAC;IAEA,aAAa;IACb,MAAMC,YAAYC,iBAAKC,oBAAoB,CACvCD,iBAAKE,gBAAgB,CAAC,UACtB;QAACF,iBAAKG,mBAAmB,CAACN,UAAUO,IAAI;KAAE;IAE9C,IAAIC;IACJ,IAAIP,aAAa;QACb,2BAA2B;QAC3BO,0BAA0BL,iBAAKC,oBAAoB,CAC/CD,iBAAKM,0BAA0B,CAC3BP,WACAC,iBAAKG,mBAAmB,CAAC,aAE7B;YAACP,QAAQW,mBAAmB,CAACT,YAAYU,UAAU;SAAE;IAE7D,OAAO;QACHH,0BAA0BL,iBAAKC,oBAAoB,CAC/CD,iBAAKM,0BAA0B,CAC3BP,WACAC,iBAAKG,mBAAmB,CAAC,aAE7B;YAACH,iBAAKE,gBAAgB,CAAC;SAAU;IAEzC;IACA,OAAOF,iBAAKS,yBAAyB,CAACJ;AAC1C"}

package/assets/transformClassDeclaration/getExportedClassDeclarationStatements.d.ts

@@ -0,0 +1,3 @@
+import * as ts from 'typescript';
+import * as tstl from 'typescript-to-lua';
+export declare const getExportedClassDeclarationStatements: (className: tstl.Identifier, declaration: ts.ClassLikeDeclaration) => tstl.AssignmentStatement[];

package/assets/transformClassDeclaration/getExportedClassDeclarationStatements.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "getExportedClassDeclarationStatements", {
+    enumerable: true,
+    get: function() {
+        return getExportedClassDeclarationStatements;
+    }
+});
+const _interop_require_wildcard = require("@swc/helpers/_/_interop_require_wildcard");
+const _typescripttolua = /*#__PURE__*/ _interop_require_wildcard._(require("typescript-to-lua"));
+const getExportedClassDeclarationStatements = (className, declaration)=>{
+    if ('localSymbol' in declaration && declaration.localSymbol && typeof declaration.localSymbol === 'object' && 'exportSymbol' in declaration.localSymbol && declaration.localSymbol.exportSymbol && typeof declaration.localSymbol.exportSymbol === 'object' && 'escapedName' in declaration.localSymbol.exportSymbol && typeof declaration.localSymbol.exportSymbol.escapedName === 'string') {
+        const escapedName = declaration.localSymbol.exportSymbol.escapedName;
+        return [
+            _typescripttolua.createAssignmentStatement(_typescripttolua.createTableIndexExpression(_typescripttolua.createIdentifier('____exports'), _typescripttolua.createStringLiteral(escapedName)), className)
+        ];
+    }
+    return [];
+};
+
+//# sourceMappingURL=getExportedClassDeclarationStatements.js.map

package/assets/transformClassDeclaration/getExportedClassDeclarationStatements.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../libs/tstl-plugin/src/transformClassDeclaration/getExportedClassDeclarationStatements.ts"],"sourcesContent":["import * as ts from 'typescript';\nimport * as tstl from 'typescript-to-lua';\n\nexport const getExportedClassDeclarationStatements = (\n    className: tstl.Identifier,\n    declaration: ts.ClassLikeDeclaration\n) => {\n    if (\n        'localSymbol' in declaration &&\n        declaration.localSymbol &&\n        typeof declaration.localSymbol === 'object' &&\n        'exportSymbol' in declaration.localSymbol &&\n        declaration.localSymbol.exportSymbol &&\n        typeof declaration.localSymbol.exportSymbol === 'object' &&\n        'escapedName' in declaration.localSymbol.exportSymbol &&\n        typeof declaration.localSymbol.exportSymbol.escapedName === 'string'\n    ) {\n        const escapedName = declaration.localSymbol.exportSymbol.escapedName;\n\n        return [\n            tstl.createAssignmentStatement(\n                tstl.createTableIndexExpression(\n                    tstl.createIdentifier('____exports'),\n                    tstl.createStringLiteral(escapedName)\n                ),\n                className\n            ),\n        ];\n    }\n\n    return [];\n};\n"],"names":["getExportedClassDeclarationStatements","className","declaration","localSymbol","exportSymbol","escapedName","tstl","createAssignmentStatement","createTableIndexExpression","createIdentifier","createStringLiteral"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;","mappings":";;;;+BAGaA;;;eAAAA;;;;2EAFS;AAEf,MAAMA,wCAAwC,CACjDC,WACAC;IAEA,IACI,iBAAiBA,eACjBA,YAAYC,WAAW,IACvB,OAAOD,YAAYC,WAAW,KAAK,YACnC,kBAAkBD,YAAYC,WAAW,IACzCD,YAAYC,WAAW,CAACC,YAAY,IACpC,OAAOF,YAAYC,WAAW,CAACC,YAAY,KAAK,YAChD,iBAAiBF,YAAYC,WAAW,CAACC,YAAY,IACrD,OAAOF,YAAYC,WAAW,CAACC,YAAY,CAACC,WAAW,KAAK,UAC9D;QACE,MAAMA,cAAcH,YAAYC,WAAW,CAACC,YAAY,CAACC,WAAW;QAEpE,OAAO;YACHC,iBAAKC,yBAAyB,CAC1BD,iBAAKE,0BAA0B,CAC3BF,iBAAKG,gBAAgB,CAAC,gBACtBH,iBAAKI,mBAAmB,CAACL,eAE7BJ;SAEP;IACL;IAEA,OAAO,EAAE;AACb"}

package/assets/transformClassDeclaration/getTransformClassDeclaration.d.ts

@@ -0,0 +1,5 @@
+import * as ts from 'typescript';
+import { TransformationContext } from 'typescript-to-lua';
+import * as tstl from 'typescript-to-lua';
+import { ImportMap } from '../ImportMap';
+export declare const getTransformClassDeclaration: (importMap: ImportMap) => (declaration: ts.ClassLikeDeclaration, context: TransformationContext) => tstl.Statement[];

package/assets/transformClassDeclaration/getTransformClassDeclaration.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "getTransformClassDeclaration", {
+    enumerable: true,
+    get: function() {
+        return getTransformClassDeclaration;
+    }
+});
+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 _utils = require("typescript-to-lua/dist/transformation/visitors/class/utils");
+const _getExportedClassDeclarationStatements = require("./getExportedClassDeclarationStatements");
+const _createClasCall = require("./createClasCall");
+const _transformConstructor = require("./transformConstructor");
+const _transformMethodDeclaration = require("./transformMethodDeclaration");
+const hasSuperInfos = (context)=>{
+    return 'classSuperInfos' in context;
+};
+const getTransformClassDeclaration = (importMap)=>{
+    return (declaration, context)=>{
+        importMap.add('object');
+        let className;
+        if (declaration.name) {
+            className = _typescripttolua.createIdentifier(declaration.name.text);
+        } else {
+            className = _typescripttolua.createIdentifier(context.createTempName('class'), declaration);
+        }
+        const extension = (0, _utils.getExtendedNode)(declaration);
+        if (hasSuperInfos(context)) {
+            if (context.classSuperInfos) {
+                context.classSuperInfos.push({
+                    className,
+                    extendedTypeNode: extension
+                });
+            } else {
+                context.classSuperInfos = [
+                    {
+                        className,
+                        extendedTypeNode: extension
+                    }
+                ];
+            }
+        }
+        // Get all properties with value
+        const properties = declaration.members.filter(_typescript.isPropertyDeclaration).filter((member)=>member.initializer);
+        // Divide properties into static and non-static
+        const instanceFields = properties.filter((prop)=>!(0, _utils.isStaticNode)(prop));
+        const statements = [];
+        // class('X')
+        statements.push((0, _createClasCall.createClassCall)(context, className, extension));
+        // function X:init()
+        //   X.super.init(self)
+        // end
+        const constructor = declaration.members.find((n)=>_typescript.isConstructorDeclaration(n) && n.body !== undefined);
+        if (!constructor) {
+            return [];
+        }
+        const transformedConstructor = (0, _transformConstructor.transformConstructor)(context, className, instanceFields, constructor);
+        if (transformedConstructor) {
+            statements.push(transformedConstructor);
+        }
+        const methods = declaration.members.filter(_typescript.isMethodDeclaration).map((method)=>(0, _transformMethodDeclaration.transformMethodDeclaration)(context, method, className)).filter((method)=>method !== undefined);
+        statements.push(...methods);
+        statements.push(...(0, _getExportedClassDeclarationStatements.getExportedClassDeclarationStatements)(className, declaration));
+        return statements;
+    };
+};
+
+//# sourceMappingURL=getTransformClassDeclaration.js.map

package/assets/transformClassDeclaration/getTransformClassDeclaration.js.map

@@ -0,0 +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 {\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\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        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","statements","createClassCall","constructor","find","n","isConstructorDeclaration","body","undefined","transformedConstructor","transformConstructor","methods","isMethodDeclaration","map","method","transformMethodDeclaration","getExportedClassDeclarationStatements"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;+BAsBaA;;;eAAAA;;;;sEAtBO;2EAEE;uBAIf;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,CAAC,CAACG,SAAWA,OAAOC,WAAW;QAE1C,+CAA+C;QAC/C,MAAMC,iBAAiBP,WAAWE,MAAM,CAAC,CAACM,OAAS,CAACC,IAAAA,mBAAY,EAACD;QAEjE,MAAME,aAA+B,EAAE;QAEvC,aAAa;QACbA,WAAWZ,IAAI,CAACa,IAAAA,+BAAe,EAAC1B,SAASI,WAAWM;QAEpD,oBAAoB;QACpB,uBAAuB;QACvB,MAAM;QACN,MAAMiB,cAAczB,YAAYc,OAAO,CAACY,IAAI,CACxC,CAACC,IACGX,YAAGY,wBAAwB,CAACD,MAAMA,EAAEE,IAAI,KAAKC;QAGrD,IAAI,CAACL,aAAa;YACd,OAAO,EAAE;QACb;QAEA,MAAMM,yBAAyBC,IAAAA,0CAAoB,EAC/ClC,SACAI,WACAkB,gBACAK;QAEJ,IAAIM,wBAAwB;YACxBR,WAAWZ,IAAI,CAACoB;QACpB;QAEA,MAAME,UAAUjC,YAAYc,OAAO,CAC9BC,MAAM,CAACC,YAAGkB,mBAAmB,EAC7BC,GAAG,CAAC,CAACC,SACFC,IAAAA,sDAA0B,EAACvC,SAASsC,QAAQlC,YAE/Ca,MAAM,CAAC,CAACqB,SAAqCA,WAAWN;QAC7DP,WAAWZ,IAAI,IAAIsB;QAEnBV,WAAWZ,IAAI,IACR2B,IAAAA,4EAAqC,EAACpC,WAAWF;QAGxD,OAAOuB;IACX;AACJ"}

package/assets/transformClassDeclaration/index.d.ts

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

package/assets/transformClassDeclaration/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("./getTransformClassDeclaration"), exports);
+
+//# sourceMappingURL=index.js.map

package/assets/transformClassDeclaration/index.js.map

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

package/assets/transformClassDeclaration/transformConstructor.d.ts

@@ -0,0 +1,4 @@
+import * as ts from 'typescript';
+import { TransformationContext } from 'typescript-to-lua';
+import * as tstl from 'typescript-to-lua';
+export declare const transformConstructor: (context: TransformationContext, className: tstl.Identifier, instanceFields: ts.PropertyDeclaration[], constructor: ts.ConstructorDeclaration) => tstl.Statement | undefined;

package/assets/transformClassDeclaration/transformConstructor.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "transformConstructor", {
+    enumerable: true,
+    get: function() {
+        return transformConstructor;
+    }
+});
+const _extends = require("@swc/helpers/_/_extends");
+const _interop_require_wildcard = require("@swc/helpers/_/_interop_require_wildcard");
+const _typescripttolua = /*#__PURE__*/ _interop_require_wildcard._(require("typescript-to-lua"));
+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 transformConstructor = (context, className, instanceFields, constructor)=>{
+    const methodName = 'init';
+    context.pushScope(_scope.ScopeType.Function);
+    let bodyStatements = [];
+    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);
+    if (constructor == null ? void 0 : constructor.body) {
+        const body = (0, _function.transformFunctionBodyContent)(context, constructor.body);
+        bodyStatements.push(...body);
+        bodyStatements = bodyStatements.reduce((previous, current)=>{
+            if (_typescripttolua.isExpressionStatement(current) && _typescripttolua.isCallExpression(current.expression) && _typescripttolua.isTableIndexExpression(current.expression.expression) && _typescripttolua.isStringLiteral(current.expression.expression.index) && current.expression.expression.index.value === '____constructor') {
+                return [
+                    _extends._({}, current, {
+                        expression: _extends._({}, current.expression, {
+                            expression: _extends._({}, current.expression.expression, {
+                                index: _typescripttolua.createStringLiteral('init')
+                            }),
+                            params: current.expression.params.slice(1)
+                        })
+                    }),
+                    ...previous
+                ];
+            }
+            return [
+                ...previous,
+                current
+            ];
+        }, []);
+    }
+    context.popScope();
+    return _typescripttolua.createAssignmentStatement(_typescripttolua.createTableIndexExpression(className, _typescripttolua.createStringLiteral(methodName)), _typescripttolua.createFunctionExpression(_typescripttolua.createBlock(bodyStatements), params));
+};
+
+//# sourceMappingURL=transformConstructor.js.map

package/assets/transformClassDeclaration/transformConstructor.js.map

@@ -0,0 +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    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","body","transformFunctionBodyContent","reduce","previous","current","isExpressionStatement","isCallExpression","expression","isTableIndexExpression","isStringLiteral","index","value","createStringLiteral","slice","popScope","createAssignmentStatement","createTableIndexExpression","createFunctionExpression","createBlock"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;+BAUaA;;;eAAAA;;;;;2EARS;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,IAAIX,+BAAAA,YAAac,IAAI,EAAE;QACnB,MAAMA,OAAOC,IAAAA,sCAA4B,EAAClB,SAASG,YAAYc,IAAI;QAEnET,eAAeQ,IAAI,IAAIC;QACvBT,iBAAiBA,eAAeW,MAAM,CAAC,CAACC,UAAUC;YAC9C,IACIT,iBAAKU,qBAAqB,CAACD,YAC3BT,iBAAKW,gBAAgB,CAACF,QAAQG,UAAU,KACxCZ,iBAAKa,sBAAsB,CAACJ,QAAQG,UAAU,CAACA,UAAU,KACzDZ,iBAAKc,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,OAAOf,iBAAKiB,mBAAmB,CAAC;;4BAEpCpB,QAAQY,QAAQG,UAAU,CAACf,MAAM,CAACqB,KAAK,CAAC;;;uBAG7CV;iBACN;YACL;YAEA,OAAO;mBAAIA;gBAAUC;aAAQ;QACjC,GAAG,EAAE;IACT;IACArB,QAAQ+B,QAAQ;IAChB,OAAOnB,iBAAKoB,yBAAyB,CACjCpB,iBAAKqB,0BAA0B,CAC3BhC,WACAW,iBAAKiB,mBAAmB,CAACzB,cAE7BQ,iBAAKsB,wBAAwB,CAACtB,iBAAKuB,WAAW,CAAC3B,iBAAiBC;AAExE"}

package/assets/transformClassDeclaration/transformMethodDeclaration.d.ts

@@ -0,0 +1,4 @@
+import * as ts from 'typescript';
+import { TransformationContext } from 'typescript-to-lua';
+import * as tstl from 'typescript-to-lua';
+export declare const transformMethodDeclaration: (context: TransformationContext, node: ts.MethodDeclaration, className: tstl.Identifier) => tstl.Statement | undefined;

package/assets/transformClassDeclaration/transformMethodDeclaration.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "transformMethodDeclaration", {
+    enumerable: true,
+    get: function() {
+        return transformMethodDeclaration;
+    }
+});
+const _interop_require_wildcard = require("@swc/helpers/_/_interop_require_wildcard");
+const _typescripttolua = /*#__PURE__*/ _interop_require_wildcard._(require("typescript-to-lua"));
+const _function = require("typescript-to-lua/dist/transformation/visitors/function");
+const _transformPropertyName = require("./transformPropertyName");
+const transformMethodDeclaration = (context, node, className)=>{
+    const [functionExpression] = (0, _function.transformFunctionToExpression)(context, node);
+    return _typescripttolua.createAssignmentStatement(_typescripttolua.createTableIndexExpression(className, (0, _transformPropertyName.transformPropertyName)(context, node.name)), functionExpression);
+};
+
+//# sourceMappingURL=transformMethodDeclaration.js.map

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,6 +1,6 @@
 {
     "name": "crankscript",
-    "version": "0.10.7",
+    "version": "0.11.0",
     "scripts": {
         "dev": "tsx src/index.ts",
         "post-build": "tsc-alias --project tsconfig.json"

package/src/commands/GenerateTypes/hooks/useGenerateTypeFile.js

@@ -1,7 +1,7 @@
 import { _ as _extends } from "@swc/helpers/_/_extends";
 import { writeFileSync } from 'node:fs';
 import { useMemo } from 'react';
-import { Project } from 'ts-morph';
+import { Project, VariableDeclarationKind } from 'ts-morph';
 import { TypescriptReservedNamed } from '../../../constants.js';
 export const useGenerateTypeFile = (path, definitions, typeProvider)=>{
     const generateTypeFile = useMemo(()=>{
@@ -50,6 +50,15 @@ const generateNamespace = (apiObject, incomingSubject, typeProvider, namespace,
     if (name === 'playdate') {
         subject.addStatements(typeProvider.getStatements());
     }
+    for (const constant of typeProvider.getConstants(fullNamespaceName)){
+        subject.addVariableStatement({
+            declarations: [
+                constant
+            ],
+            isExported: true,
+            declarationKind: VariableDeclarationKind.Const
+        });
+    }
     for (const func of apiObject.functions){
         const isFunctionNameReserved = TypescriptReservedNamed.includes(func.name);
         const resolvedName = `_${func.name}`;

package/src/commands/GenerateTypes/hooks/useGenerateTypeFile.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../../../libs/cli/src/commands/GenerateTypes/hooks/useGenerateTypeFile.ts"],"sourcesContent":["import { writeFileSync } from 'node:fs';\nimport { useMemo } from 'react';\nimport {\n    ClassDeclaration,\n    FunctionDeclarationStructure,\n    MethodDeclarationStructure,\n    ModuleDeclaration,\n    Project,\n    SourceFile,\n} from 'ts-morph';\nimport { createTypeProvider } from '@/cli/commands/GenerateTypes/utils/createTypeProvider.js';\nimport { TypescriptReservedNamed } from '@/cli/constants.js';\nimport { ApiDefinitions, ApiObject, CheckListItem } from '@/cli/types.js';\n\nexport const useGenerateTypeFile = (\n    path: string,\n    definitions: ApiDefinitions | null,\n    typeProvider: ReturnType<typeof createTypeProvider> | null\n) => {\n    const generateTypeFile = useMemo(() => {\n        return {\n            waitingDescription: 'Waiting to generate the type file...',\n            errorDescription: 'Failed to generate the type file',\n            finishedDescription: () => 'Type file generated',\n            runningDescription: 'Generating the type file...',\n            runner: async () => {\n                if (!definitions) {\n                    throw new Error('Definitions are not set');\n                }\n\n                if (!typeProvider) {\n                    throw new Error('Type provider is not set');\n                }\n\n                const project = new Project();\n                const typeFile = project.createSourceFile(path, '', {\n                    overwrite: true,\n                });\n\n                const globalNamespace = definitions.global;\n\n                typeFile.addStatements(typeProvider.getGlobalStatements());\n\n                generateNamespace(globalNamespace, typeFile, typeProvider, '');\n\n                writeFileSync(\n                    path,\n                    typeFile.getFullText().replace('*/', '*/\\n')\n                );\n            },\n            ready: definitions !== null && typeProvider !== null,\n        } satisfies CheckListItem<void>;\n    }, [definitions, typeProvider]);\n\n    return {\n        generateTypeFile,\n    };\n};\n\nconst generateNamespace = (\n    apiObject: ApiObject,\n    incomingSubject: SourceFile | ModuleDeclaration,\n    typeProvider: ReturnType<typeof createTypeProvider>,\n    namespace: string,\n    name?: string\n) => {\n    let subject = incomingSubject;\n    const fullNamespaceName = [namespace, name].filter(Boolean).join('.');\n\n    if (name) {\n        subject = incomingSubject.addModule({\n            name,\n        });\n    }\n\n    if (name === 'playdate') {\n        subject.addStatements(typeProvider.getStatements());\n    }\n\n    for (const func of apiObject.functions) {\n        const isFunctionNameReserved = TypescriptReservedNamed.includes(\n            func.name\n        );\n        const resolvedName = `_${func.name}`;\n        const parameters = typeProvider.getParameters(func);\n\n        subject.addFunction({\n            name: isFunctionNameReserved ? resolvedName : func.name,\n            docs: [func.docs],\n            parameters,\n            returnType: typeProvider.getFunctionReturnType(func),\n            isExported: !!name,\n            ...(typeProvider.getFunctionOverrideOptions(\n                func\n            ) as FunctionDeclarationStructure),\n        });\n\n        if (isFunctionNameReserved) {\n            subject.addExportDeclaration({\n                namedExports: [\n                    {\n                        name: resolvedName,\n                        alias: func.name,\n                    },\n                ],\n            });\n        }\n    }\n\n    let propertiesSubject: ClassDeclaration | null = null;\n\n    if (name && apiObject.methods.length > 0) {\n        const typeClass = incomingSubject.addClass({\n            name,\n            ...typeProvider.getClassOptions(fullNamespaceName),\n        });\n        propertiesSubject = typeClass;\n\n        for (const method of apiObject.methods) {\n            const parameters = typeProvider.getParameters(method);\n\n            typeClass.addMethod({\n                name: method.name,\n                docs: [method.docs],\n                parameters,\n                returnType: typeProvider.getFunctionReturnType(method),\n                ...(typeProvider.getFunctionOverrideOptions(\n                    method\n                ) as Partial<MethodDeclarationStructure>),\n            });\n        }\n    }\n\n    for (const property of apiObject.properties) {\n        const propertyDetails = typeProvider.getPropertyDetails(property);\n\n        if (propertiesSubject) {\n            propertiesSubject.addProperty({\n                name: property.name,\n                docs: [property.docs],\n                type: propertyDetails.type,\n                isStatic: propertyDetails.isStatic,\n                isReadonly: propertyDetails.isReadOnly,\n            });\n        } else {\n            subject.addVariableStatement({\n                docs: [property.docs],\n                declarations: [\n                    {\n                        name: property.name,\n                        type: propertyDetails.type,\n                    },\n                ],\n            });\n        }\n    }\n\n    for (const eachNamespace of Object.entries(apiObject.namespaces)) {\n        generateNamespace(\n            eachNamespace[1],\n            subject,\n            typeProvider,\n            fullNamespaceName,\n            eachNamespace[0]\n        );\n    }\n};\n"],"names":["writeFileSync","useMemo","Project","TypescriptReservedNamed","useGenerateTypeFile","path","definitions","typeProvider","generateTypeFile","waitingDescription","errorDescription","finishedDescription","runningDescription","runner","Error","project","typeFile","createSourceFile","overwrite","globalNamespace","global","addStatements","getGlobalStatements","generateNamespace","getFullText","replace","ready","apiObject","incomingSubject","namespace","name","subject","fullNamespaceName","filter","Boolean","join","addModule","getStatements","func","functions","isFunctionNameReserved","includes","resolvedName","parameters","getParameters","addFunction","docs","returnType","getFunctionReturnType","isExported","getFunctionOverrideOptions","addExportDeclaration","namedExports","alias","propertiesSubject","methods","length","typeClass","addClass","getClassOptions","method","addMethod","property","properties","propertyDetails","getPropertyDetails","addProperty","type","isStatic","isReadonly","isReadOnly","addVariableStatement","declarations","eachNamespace","Object","entries","namespaces"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"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"}
+{"version":3,"sources":["../../../../../../../libs/cli/src/commands/GenerateTypes/hooks/useGenerateTypeFile.ts"],"sourcesContent":["import { writeFileSync } from 'node:fs';\nimport { useMemo } from 'react';\nimport {\n    ClassDeclaration,\n    FunctionDeclarationStructure,\n    MethodDeclarationStructure,\n    ModuleDeclaration,\n    Project,\n    SourceFile,\n    VariableDeclarationKind,\n} from 'ts-morph';\nimport { createTypeProvider } from '@/cli/commands/GenerateTypes/utils/createTypeProvider.js';\nimport { TypescriptReservedNamed } from '@/cli/constants.js';\nimport { ApiDefinitions, ApiObject, CheckListItem } from '@/cli/types.js';\n\nexport const useGenerateTypeFile = (\n    path: string,\n    definitions: ApiDefinitions | null,\n    typeProvider: ReturnType<typeof createTypeProvider> | null\n) => {\n    const generateTypeFile = useMemo(() => {\n        return {\n            waitingDescription: 'Waiting to generate the type file...',\n            errorDescription: 'Failed to generate the type file',\n            finishedDescription: () => 'Type file generated',\n            runningDescription: 'Generating the type file...',\n            runner: async () => {\n                if (!definitions) {\n                    throw new Error('Definitions are not set');\n                }\n\n                if (!typeProvider) {\n                    throw new Error('Type provider is not set');\n                }\n\n                const project = new Project();\n                const typeFile = project.createSourceFile(path, '', {\n                    overwrite: true,\n                });\n\n                const globalNamespace = definitions.global;\n\n                typeFile.addStatements(typeProvider.getGlobalStatements());\n\n                generateNamespace(globalNamespace, typeFile, typeProvider, '');\n\n                writeFileSync(\n                    path,\n                    typeFile.getFullText().replace('*/', '*/\\n')\n                );\n            },\n            ready: definitions !== null && typeProvider !== null,\n        } satisfies CheckListItem<void>;\n    }, [definitions, typeProvider]);\n\n    return {\n        generateTypeFile,\n    };\n};\n\nconst generateNamespace = (\n    apiObject: ApiObject,\n    incomingSubject: SourceFile | ModuleDeclaration,\n    typeProvider: ReturnType<typeof createTypeProvider>,\n    namespace: string,\n    name?: string\n) => {\n    let subject = incomingSubject;\n    const fullNamespaceName = [namespace, name].filter(Boolean).join('.');\n\n    if (name) {\n        subject = incomingSubject.addModule({\n            name,\n        });\n    }\n\n    if (name === 'playdate') {\n        subject.addStatements(typeProvider.getStatements());\n    }\n\n    for (const constant of typeProvider.getConstants(fullNamespaceName)) {\n        subject.addVariableStatement({\n            declarations: [constant],\n            isExported: true,\n            declarationKind: VariableDeclarationKind.Const,\n        });\n    }\n\n    for (const func of apiObject.functions) {\n        const isFunctionNameReserved = TypescriptReservedNamed.includes(\n            func.name\n        );\n        const resolvedName = `_${func.name}`;\n        const parameters = typeProvider.getParameters(func);\n\n        subject.addFunction({\n            name: isFunctionNameReserved ? resolvedName : func.name,\n            docs: [func.docs],\n            parameters,\n            returnType: typeProvider.getFunctionReturnType(func),\n            isExported: !!name,\n            ...(typeProvider.getFunctionOverrideOptions(\n                func\n            ) as FunctionDeclarationStructure),\n        });\n\n        if (isFunctionNameReserved) {\n            subject.addExportDeclaration({\n                namedExports: [\n                    {\n                        name: resolvedName,\n                        alias: func.name,\n                    },\n                ],\n            });\n        }\n    }\n\n    let propertiesSubject: ClassDeclaration | null = null;\n\n    if (name && apiObject.methods.length > 0) {\n        const typeClass = incomingSubject.addClass({\n            name,\n            ...typeProvider.getClassOptions(fullNamespaceName),\n        });\n        propertiesSubject = typeClass;\n\n        for (const method of apiObject.methods) {\n            const parameters = typeProvider.getParameters(method);\n\n            typeClass.addMethod({\n                name: method.name,\n                docs: [method.docs],\n                parameters,\n                returnType: typeProvider.getFunctionReturnType(method),\n                ...(typeProvider.getFunctionOverrideOptions(\n                    method\n                ) as Partial<MethodDeclarationStructure>),\n            });\n        }\n    }\n\n    for (const property of apiObject.properties) {\n        const propertyDetails = typeProvider.getPropertyDetails(property);\n\n        if (propertiesSubject) {\n            propertiesSubject.addProperty({\n                name: property.name,\n                docs: [property.docs],\n                type: propertyDetails.type,\n                isStatic: propertyDetails.isStatic,\n                isReadonly: propertyDetails.isReadOnly,\n            });\n        } else {\n            subject.addVariableStatement({\n                docs: [property.docs],\n                declarations: [\n                    {\n                        name: property.name,\n                        type: propertyDetails.type,\n                    },\n                ],\n            });\n        }\n    }\n\n    for (const eachNamespace of Object.entries(apiObject.namespaces)) {\n        generateNamespace(\n            eachNamespace[1],\n            subject,\n            typeProvider,\n            fullNamespaceName,\n            eachNamespace[0]\n        );\n    }\n};\n"],"names":["writeFileSync","useMemo","Project","VariableDeclarationKind","TypescriptReservedNamed","useGenerateTypeFile","path","definitions","typeProvider","generateTypeFile","waitingDescription","errorDescription","finishedDescription","runningDescription","runner","Error","project","typeFile","createSourceFile","overwrite","globalNamespace","global","addStatements","getGlobalStatements","generateNamespace","getFullText","replace","ready","apiObject","incomingSubject","namespace","name","subject","fullNamespaceName","filter","Boolean","join","addModule","getStatements","constant","getConstants","addVariableStatement","declarations","isExported","declarationKind","Const","func","functions","isFunctionNameReserved","includes","resolvedName","parameters","getParameters","addFunction","docs","returnType","getFunctionReturnType","getFunctionOverrideOptions","addExportDeclaration","namedExports","alias","propertiesSubject","methods","length","typeClass","addClass","getClassOptions","method","addMethod","property","properties","propertyDetails","getPropertyDetails","addProperty","type","isStatic","isReadonly","isReadOnly","eachNamespace","Object","entries","namespaces"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"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"}

package/src/commands/GenerateTypes/hooks/useGetVersion.d.ts

@@ -48,6 +48,11 @@ export declare const useGetVersion: (version: PlaydateSdkVersion) => {
                 kind?: import("ts-morph").StructureKind.FunctionOverload | undefined;
             })[];
         };
+        getConstants: (fullNamespace: string) => {
+            kind: import("ts-morph").StructureKind.VariableDeclaration;
+            name: string;
+            type: string;
+        }[];
         save: () => void;
     } | null;
 };

package/src/commands/GenerateTypes/utils/createTypeProvider.d.ts

@@ -39,5 +39,10 @@ export declare const createTypeProvider: (version: string) => {
             kind?: StructureKind.FunctionOverload | undefined;
         })[];
     };
+    getConstants: (fullNamespace: string) => {
+        kind: StructureKind.VariableDeclaration;
+        name: string;
+        type: string;
+    }[];
     save: () => void;
 };

package/src/commands/GenerateTypes/utils/createTypeProvider.js

@@ -11,6 +11,7 @@ export const createTypeProvider = (version)=>{
     const path = join(DataFolder, `${version}.json`);
     const fallbackProvider = existsSync(path) ? JSON.parse(readFileSync(path, 'utf-8')) : {
         globalStatements: [],
+        constants: {},
         statements: [],
         classes: {},
         properties: {},
@@ -18,6 +19,7 @@ export const createTypeProvider = (version)=>{
     };
     const provider = {
         globalStatements: fallbackProvider.globalStatements,
+        constants: fallbackProvider.constants,
         statements: fallbackProvider.statements,
         classes: fallbackProvider.classes,
         properties: {},
@@ -136,6 +138,16 @@ export const createTypeProvider = (version)=>{
         }
         return options;
     };
+    const getConstants = (fullNamespace)=>{
+        var _provider_constants_fullNamespace;
+        return ((_provider_constants_fullNamespace = provider.constants[fullNamespace]) != null ? _provider_constants_fullNamespace : []).map((constant)=>{
+            return {
+                kind: StructureKind.VariableDeclaration,
+                name: typeof constant === 'string' ? constant : constant.name,
+                type: typeof constant === 'string' ? 'number' : constant.type
+            };
+        });
+    };
     const save = ()=>{
         const contents = JSON.stringify(provider, null, 4) + '\n';
         writeFileSync(path, contents, 'utf-8');
@@ -149,6 +161,7 @@ export const createTypeProvider = (version)=>{
         getParameterDetails,
         getParameters,
         getFunctionOverrideOptions,
+        getConstants,
         save
     };
 };

package/src/commands/GenerateTypes/utils/createTypeProvider.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../../../libs/cli/src/commands/GenerateTypes/utils/createTypeProvider.ts"],"sourcesContent":["import { readFileSync } from 'fs';\nimport { existsSync, writeFileSync } from 'node:fs';\nimport { join } from 'node:path';\nimport {\n    FunctionDeclarationStructure,\n    ParameterDeclarationStructure,\n    StructureKind,\n} from 'ts-morph';\nimport { DataFolder } from '@/cli/constants.js';\nimport {\n    FunctionDescription,\n    FunctionDetails,\n    ParameterDetails,\n    PropertyDescription,\n    PropertyDetails,\n    TypeProviderData,\n} from '@/cli/types.js';\n\nfunction kebabToCamelCase(str: string): string {\n    return str.replace(/-([a-z])/g, (_, letter) => letter.toUpperCase());\n}\n\nexport const createTypeProvider = (version: string) => {\n    const path = join(DataFolder, `${version}.json`);\n    const fallbackProvider = existsSync(path)\n        ? (JSON.parse(readFileSync(path, 'utf-8')) as TypeProviderData)\n        : ({\n              globalStatements: [],\n              statements: [],\n              classes: {},\n              properties: {},\n              functions: {},\n          } satisfies TypeProviderData);\n    const provider = {\n        globalStatements: fallbackProvider.globalStatements,\n        statements: fallbackProvider.statements,\n        classes: fallbackProvider.classes,\n        properties: {},\n        functions: {},\n    } as TypeProviderData;\n    const visitedProperties = new Map<string, PropertyDetails>();\n    const visitedFunctions = new Map<string, FunctionDetails>();\n\n    const getClassOptions = (className: string) => {\n        return provider.classes[className] ?? {};\n    };\n\n    const getPropertyDetails = (property: PropertyDescription) => {\n        if (visitedProperties.has(property.signature)) {\n            return visitedProperties.get(property.signature) as PropertyDetails;\n        }\n\n        let result: PropertyDetails;\n        let prop = provider.properties[property.signature];\n\n        if (!prop) {\n            prop = fallbackProvider.properties[property.signature];\n        }\n\n        if (!prop) {\n            const details = {\n                signature: property.signature,\n                type: 'any',\n            } satisfies PropertyDetails;\n\n            provider.properties[property.signature] = details;\n\n            result = details;\n        } else {\n            provider.properties[property.signature] = prop;\n\n            result = prop;\n        }\n\n        visitedProperties.set(property.signature, result);\n\n        return result;\n    };\n\n    const getFunctionDetails = (func: FunctionDescription): FunctionDetails => {\n        if (visitedFunctions.has(func.signature)) {\n            return visitedFunctions.get(func.signature) as FunctionDetails;\n        }\n\n        let result: FunctionDetails;\n        let fn = provider.functions[func.signature];\n\n        if (!fn) {\n            fn = fallbackProvider.functions[func.signature];\n        }\n\n        if (!fn) {\n            const details = {\n                signature: func.signature,\n                parameters: func.parameters.map((p) => ({\n                    name: p.name,\n                    type: 'any',\n                })),\n                returnType: 'any',\n            } satisfies FunctionDetails;\n\n            provider.functions[func.signature] = details;\n\n            result = details;\n        } else {\n            provider.functions[func.signature] = fn;\n\n            result = fn;\n        }\n\n        visitedFunctions.set(func.signature, result);\n\n        return result;\n    };\n\n    const getGlobalStatements = () => {\n        return provider.globalStatements;\n    };\n\n    const getStatements = () => {\n        return provider.statements;\n    };\n\n    const getFunctionReturnType = (func: FunctionDescription) => {\n        const { returnType } = getFunctionDetails(func);\n\n        return returnType;\n    };\n\n    const getParameterDetails = (\n        func: FunctionDescription,\n        parameter: string\n    ) => {\n        const { parameters } = getFunctionDetails(func);\n        const param = parameters.find((p) => p.name === parameter);\n\n        if (!param) {\n            return {\n                name: parameter,\n                type: 'any',\n            } satisfies ParameterDetails;\n        }\n\n        return param;\n    };\n\n    const getParameters = (\n        func: FunctionDescription\n    ): FunctionDeclarationStructure['parameters'] => {\n        const { overrideParameters = false, parameters } =\n            getFunctionDetails(func);\n        const getParameterFromDetails = (parameter: ParameterDetails) => {\n            return {\n                kind: StructureKind.Parameter,\n                name: kebabToCamelCase(parameter.name),\n                type: parameter.type,\n                ...(parameter.overrideOptions ?? {}),\n            } satisfies ParameterDeclarationStructure;\n        };\n\n        if (overrideParameters) {\n            return parameters.map((details) => {\n                return getParameterFromDetails(details);\n            });\n        }\n\n        return func.parameters.map((parameter) => {\n            const details = getParameterDetails(func, parameter.name);\n\n            return {\n                hasQuestionToken: !parameter.required,\n                ...getParameterFromDetails(details),\n            } satisfies ParameterDeclarationStructure;\n        });\n    };\n\n    const getFunctionOverrideOptions = (func: FunctionDescription) => {\n        const options = getFunctionDetails(func).overrideOptions ?? {};\n\n        if ('overloads' in options && Array.isArray(options.overloads)) {\n            return {\n                overloads: options.overloads.map((overload) => ({\n                    ...overload,\n                    docs: [func.docs],\n                })),\n            };\n        }\n\n        return options;\n    };\n\n    const save = () => {\n        const contents = JSON.stringify(provider, null, 4) + '\\n';\n\n        writeFileSync(path, contents, 'utf-8');\n    };\n\n    return {\n        getGlobalStatements,\n        getStatements,\n        getClassOptions,\n        getPropertyDetails,\n        getFunctionReturnType,\n        getParameterDetails,\n        getParameters,\n        getFunctionOverrideOptions,\n        save,\n    };\n};\n"],"names":["readFileSync","existsSync","writeFileSync","join","StructureKind","DataFolder","kebabToCamelCase","str","replace","_","letter","toUpperCase","createTypeProvider","version","path","fallbackProvider","JSON","parse","globalStatements","statements","classes","properties","functions","provider","visitedProperties","Map","visitedFunctions","getClassOptions","className","getPropertyDetails","property","has","signature","get","result","prop","details","type","set","getFunctionDetails","func","fn","parameters","map","p","name","returnType","getGlobalStatements","getStatements","getFunctionReturnType","getParameterDetails","parameter","param","find","getParameters","overrideParameters","getParameterFromDetails","kind","Parameter","overrideOptions","hasQuestionToken","required","getFunctionOverrideOptions","options","Array","isArray","overloads","overload","docs","save","contents","stringify"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"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"}
+{"version":3,"sources":["../../../../../../../libs/cli/src/commands/GenerateTypes/utils/createTypeProvider.ts"],"sourcesContent":["import { readFileSync } from 'fs';\nimport { existsSync, writeFileSync } from 'node:fs';\nimport { join } from 'node:path';\nimport {\n    FunctionDeclarationStructure,\n    ParameterDeclarationStructure,\n    StructureKind,\n    VariableDeclarationStructure,\n} from 'ts-morph';\nimport { DataFolder } from '@/cli/constants.js';\nimport {\n    FunctionDescription,\n    FunctionDetails,\n    ParameterDetails,\n    PropertyDescription,\n    PropertyDetails,\n    TypeProviderData,\n} from '@/cli/types.js';\n\nfunction kebabToCamelCase(str: string): string {\n    return str.replace(/-([a-z])/g, (_, letter) => letter.toUpperCase());\n}\n\nexport const createTypeProvider = (version: string) => {\n    const path = join(DataFolder, `${version}.json`);\n    const fallbackProvider = existsSync(path)\n        ? (JSON.parse(readFileSync(path, 'utf-8')) as TypeProviderData)\n        : ({\n              globalStatements: [],\n              constants: {},\n              statements: [],\n              classes: {},\n              properties: {},\n              functions: {},\n          } satisfies TypeProviderData);\n    const provider = {\n        globalStatements: fallbackProvider.globalStatements,\n        constants: fallbackProvider.constants,\n        statements: fallbackProvider.statements,\n        classes: fallbackProvider.classes,\n        properties: {},\n        functions: {},\n    } as TypeProviderData;\n    const visitedProperties = new Map<string, PropertyDetails>();\n    const visitedFunctions = new Map<string, FunctionDetails>();\n\n    const getClassOptions = (className: string) => {\n        return provider.classes[className] ?? {};\n    };\n\n    const getPropertyDetails = (property: PropertyDescription) => {\n        if (visitedProperties.has(property.signature)) {\n            return visitedProperties.get(property.signature) as PropertyDetails;\n        }\n\n        let result: PropertyDetails;\n        let prop = provider.properties[property.signature];\n\n        if (!prop) {\n            prop = fallbackProvider.properties[property.signature];\n        }\n\n        if (!prop) {\n            const details = {\n                signature: property.signature,\n                type: 'any',\n            } satisfies PropertyDetails;\n\n            provider.properties[property.signature] = details;\n\n            result = details;\n        } else {\n            provider.properties[property.signature] = prop;\n\n            result = prop;\n        }\n\n        visitedProperties.set(property.signature, result);\n\n        return result;\n    };\n\n    const getFunctionDetails = (func: FunctionDescription): FunctionDetails => {\n        if (visitedFunctions.has(func.signature)) {\n            return visitedFunctions.get(func.signature) as FunctionDetails;\n        }\n\n        let result: FunctionDetails;\n        let fn = provider.functions[func.signature];\n\n        if (!fn) {\n            fn = fallbackProvider.functions[func.signature];\n        }\n\n        if (!fn) {\n            const details = {\n                signature: func.signature,\n                parameters: func.parameters.map((p) => ({\n                    name: p.name,\n                    type: 'any',\n                })),\n                returnType: 'any',\n            } satisfies FunctionDetails;\n\n            provider.functions[func.signature] = details;\n\n            result = details;\n        } else {\n            provider.functions[func.signature] = fn;\n\n            result = fn;\n        }\n\n        visitedFunctions.set(func.signature, result);\n\n        return result;\n    };\n\n    const getGlobalStatements = () => {\n        return provider.globalStatements;\n    };\n\n    const getStatements = () => {\n        return provider.statements;\n    };\n\n    const getFunctionReturnType = (func: FunctionDescription) => {\n        const { returnType } = getFunctionDetails(func);\n\n        return returnType;\n    };\n\n    const getParameterDetails = (\n        func: FunctionDescription,\n        parameter: string\n    ) => {\n        const { parameters } = getFunctionDetails(func);\n        const param = parameters.find((p) => p.name === parameter);\n\n        if (!param) {\n            return {\n                name: parameter,\n                type: 'any',\n            } satisfies ParameterDetails;\n        }\n\n        return param;\n    };\n\n    const getParameters = (\n        func: FunctionDescription\n    ): FunctionDeclarationStructure['parameters'] => {\n        const { overrideParameters = false, parameters } =\n            getFunctionDetails(func);\n        const getParameterFromDetails = (parameter: ParameterDetails) => {\n            return {\n                kind: StructureKind.Parameter,\n                name: kebabToCamelCase(parameter.name),\n                type: parameter.type,\n                ...(parameter.overrideOptions ?? {}),\n            } satisfies ParameterDeclarationStructure;\n        };\n\n        if (overrideParameters) {\n            return parameters.map((details) => {\n                return getParameterFromDetails(details);\n            });\n        }\n\n        return func.parameters.map((parameter) => {\n            const details = getParameterDetails(func, parameter.name);\n\n            return {\n                hasQuestionToken: !parameter.required,\n                ...getParameterFromDetails(details),\n            } satisfies ParameterDeclarationStructure;\n        });\n    };\n\n    const getFunctionOverrideOptions = (func: FunctionDescription) => {\n        const options = getFunctionDetails(func).overrideOptions ?? {};\n\n        if ('overloads' in options && Array.isArray(options.overloads)) {\n            return {\n                overloads: options.overloads.map((overload) => ({\n                    ...overload,\n                    docs: [func.docs],\n                })),\n            };\n        }\n\n        return options;\n    };\n\n    const getConstants = (fullNamespace: string) => {\n        return (provider.constants[fullNamespace] ?? []).map((constant) => {\n            return {\n                kind: StructureKind.VariableDeclaration,\n                name: typeof constant === 'string' ? constant : constant.name,\n                type: typeof constant === 'string' ? 'number' : constant.type,\n            } satisfies VariableDeclarationStructure;\n        });\n    };\n\n    const save = () => {\n        const contents = JSON.stringify(provider, null, 4) + '\\n';\n\n        writeFileSync(path, contents, 'utf-8');\n    };\n\n    return {\n        getGlobalStatements,\n        getStatements,\n        getClassOptions,\n        getPropertyDetails,\n        getFunctionReturnType,\n        getParameterDetails,\n        getParameters,\n        getFunctionOverrideOptions,\n        getConstants,\n        save,\n    };\n};\n"],"names":["readFileSync","existsSync","writeFileSync","join","StructureKind","DataFolder","kebabToCamelCase","str","replace","_","letter","toUpperCase","createTypeProvider","version","path","fallbackProvider","JSON","parse","globalStatements","constants","statements","classes","properties","functions","provider","visitedProperties","Map","visitedFunctions","getClassOptions","className","getPropertyDetails","property","has","signature","get","result","prop","details","type","set","getFunctionDetails","func","fn","parameters","map","p","name","returnType","getGlobalStatements","getStatements","getFunctionReturnType","getParameterDetails","parameter","param","find","getParameters","overrideParameters","getParameterFromDetails","kind","Parameter","overrideOptions","hasQuestionToken","required","getFunctionOverrideOptions","options","Array","isArray","overloads","overload","docs","getConstants","fullNamespace","constant","VariableDeclaration","save","contents","stringify"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"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"}

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

@@ -0,0 +1,3 @@
+printTable(playdate.graphics);
+
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../../../../libs/cli/src/commands/TranspileCommand/fn/_tests/test-automatic-imports/src/index.ts"],"sourcesContent":["printTable(playdate.graphics);\n"],"names":["printTable","playdate","graphics"],"rangeMappings":"","mappings":"AAAAA,WAAWC,SAASC,QAAQ"}

package/src/types.d.ts

@@ -81,9 +81,14 @@ export interface FunctionDetails {
     overrideParameters?: boolean;
     overrideOptions?: Partial<FunctionDeclarationStructure | MethodDeclarationStructure>;
 }
+export interface ConstantDefinition {
+    name: string;
+    type: string;
+}
 export type TypeProviderData = {
     globalStatements: string[];
     statements: string[];
+    constants: Record<string, (ConstantDefinition | string)[]>;
     classes: Record<string, Partial<ClassDeclarationStructure>>;
     properties: Record<string, PropertyDetails>;
     functions: Record<string, FunctionDetails>;

package/src/types.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../libs/cli/src/types.ts"],"sourcesContent":["import {\n    ClassDeclarationStructure,\n    FunctionDeclarationStructure,\n    MethodDeclarationStructure,\n    ParameterDeclarationStructure,\n} from 'ts-morph';\nimport { Environment } from '@/cli/environment/dto/Environment.js';\nimport { PlaydateSdkPath } from '@/cli/environment/path/dto/PlaydateSdkPath.js';\n\nexport enum PlaydateSdkVersionIdentifier {\n    Latest = 'latest',\n}\n\nexport type PlaydateSdkVersion = PlaydateSdkVersionIdentifier.Latest | string;\n\nexport type EnvironmentHealthResult =\n    | {\n          isHealthy: true;\n          environment: Environment;\n          health: EnvironmentHealth;\n      }\n    | {\n          isHealthy: false;\n          health: EnvironmentHealth;\n      };\n\nexport enum HealthCheckStatusType {\n    Healthy = 'Healthy',\n    Unhealthy = 'Unhealthy',\n    Unknown = 'Unknown',\n}\n\nexport type HealthCheckStatus<TArgument> =\n    | {\n          healthStatus:\n              | HealthCheckStatusType.Unknown\n              | HealthCheckStatusType.Unhealthy;\n      }\n    | {\n          healthStatus: HealthCheckStatusType.Healthy;\n          argument: TArgument;\n      };\n\nexport interface EnvironmentHealth {\n    sdkPathKnown: HealthCheckStatus<PlaydateSdkPath>;\n}\n\nexport type CheckListItem<TResult> = {\n    runningDescription: string;\n    waitingDescription: string;\n    errorDescription: string;\n    finishedDescription: (result: TResult) => string;\n    runner: () => Promise<TResult> | Promise<false>;\n    onFinish?: (result: TResult) => void;\n    ready?: boolean;\n};\n\nexport interface ParameterDescription {\n    name: string;\n    required: boolean;\n}\n\nexport interface PropertyDescription {\n    signature: string;\n    name: string;\n    namespaces: string[];\n    docs: string;\n}\n\nexport interface FunctionDescription {\n    signature: string;\n    name: string;\n    namespaces: string[];\n    parameters: ParameterDescription[];\n    hasSelf: boolean;\n    docs: string;\n}\n\nexport interface ApiObject {\n    functions: FunctionDescription[];\n    methods: FunctionDescription[];\n    properties: PropertyDescription[];\n    namespaces: Record<string, ApiObject>;\n}\n\nexport interface ApiDefinitions {\n    global: ApiObject;\n}\n\nexport interface ParameterDetails {\n    name: string;\n    type: string;\n    overrideOptions?: Partial<\n        Omit<ParameterDeclarationStructure, 'kind' | 'name' | 'type'>\n    >;\n}\n\nexport interface PropertyDetails {\n    signature: string;\n    type: string;\n    isStatic?: boolean;\n    isReadOnly?: boolean;\n}\n\nexport interface FunctionDetails {\n    signature: string;\n    parameters: ParameterDetails[];\n    returnType: string;\n    overrideParameters?: boolean;\n    overrideOptions?: Partial<\n        FunctionDeclarationStructure | MethodDeclarationStructure\n    >;\n}\n\nexport type TypeProviderData = {\n    globalStatements: string[];\n    statements: string[];\n    classes: Record<string, Partial<ClassDeclarationStructure>>;\n    properties: Record<string, PropertyDetails>;\n    functions: Record<string, FunctionDetails>;\n};\n\nexport type FunctionTypeOverrideMap = Record<string, { isMethod: boolean }>;\n\nexport enum TemplateName {\n    Blank = 'blank',\n}\n"],"names":["PlaydateSdkVersionIdentifier","HealthCheckStatusType","TemplateName"],"rangeMappings":";;;;;;;;;;;;;","mappings":";UASYA;;GAAAA,iCAAAA;;UAiBAC;;;;GAAAA,0BAAAA;;UAkGAC;;GAAAA,iBAAAA"}
+{"version":3,"sources":["../../../../libs/cli/src/types.ts"],"sourcesContent":["import {\n    ClassDeclarationStructure,\n    FunctionDeclarationStructure,\n    MethodDeclarationStructure,\n    ParameterDeclarationStructure,\n} from 'ts-morph';\nimport { Environment } from '@/cli/environment/dto/Environment.js';\nimport { PlaydateSdkPath } from '@/cli/environment/path/dto/PlaydateSdkPath.js';\n\nexport enum PlaydateSdkVersionIdentifier {\n    Latest = 'latest',\n}\n\nexport type PlaydateSdkVersion = PlaydateSdkVersionIdentifier.Latest | string;\n\nexport type EnvironmentHealthResult =\n    | {\n          isHealthy: true;\n          environment: Environment;\n          health: EnvironmentHealth;\n      }\n    | {\n          isHealthy: false;\n          health: EnvironmentHealth;\n      };\n\nexport enum HealthCheckStatusType {\n    Healthy = 'Healthy',\n    Unhealthy = 'Unhealthy',\n    Unknown = 'Unknown',\n}\n\nexport type HealthCheckStatus<TArgument> =\n    | {\n          healthStatus:\n              | HealthCheckStatusType.Unknown\n              | HealthCheckStatusType.Unhealthy;\n      }\n    | {\n          healthStatus: HealthCheckStatusType.Healthy;\n          argument: TArgument;\n      };\n\nexport interface EnvironmentHealth {\n    sdkPathKnown: HealthCheckStatus<PlaydateSdkPath>;\n}\n\nexport type CheckListItem<TResult> = {\n    runningDescription: string;\n    waitingDescription: string;\n    errorDescription: string;\n    finishedDescription: (result: TResult) => string;\n    runner: () => Promise<TResult> | Promise<false>;\n    onFinish?: (result: TResult) => void;\n    ready?: boolean;\n};\n\nexport interface ParameterDescription {\n    name: string;\n    required: boolean;\n}\n\nexport interface PropertyDescription {\n    signature: string;\n    name: string;\n    namespaces: string[];\n    docs: string;\n}\n\nexport interface FunctionDescription {\n    signature: string;\n    name: string;\n    namespaces: string[];\n    parameters: ParameterDescription[];\n    hasSelf: boolean;\n    docs: string;\n}\n\nexport interface ApiObject {\n    functions: FunctionDescription[];\n    methods: FunctionDescription[];\n    properties: PropertyDescription[];\n    namespaces: Record<string, ApiObject>;\n}\n\nexport interface ApiDefinitions {\n    global: ApiObject;\n}\n\nexport interface ParameterDetails {\n    name: string;\n    type: string;\n    overrideOptions?: Partial<\n        Omit<ParameterDeclarationStructure, 'kind' | 'name' | 'type'>\n    >;\n}\n\nexport interface PropertyDetails {\n    signature: string;\n    type: string;\n    isStatic?: boolean;\n    isReadOnly?: boolean;\n}\n\nexport interface FunctionDetails {\n    signature: string;\n    parameters: ParameterDetails[];\n    returnType: string;\n    overrideParameters?: boolean;\n    overrideOptions?: Partial<\n        FunctionDeclarationStructure | MethodDeclarationStructure\n    >;\n}\n\nexport interface ConstantDefinition {\n    name: string;\n    type: string;\n}\n\nexport type TypeProviderData = {\n    globalStatements: string[];\n    statements: string[];\n    constants: Record<string, (ConstantDefinition | string)[]>;\n    classes: Record<string, Partial<ClassDeclarationStructure>>;\n    properties: Record<string, PropertyDetails>;\n    functions: Record<string, FunctionDetails>;\n};\n\nexport type FunctionTypeOverrideMap = Record<string, { isMethod: boolean }>;\n\nexport enum TemplateName {\n    Blank = 'blank',\n}\n"],"names":["PlaydateSdkVersionIdentifier","HealthCheckStatusType","TemplateName"],"rangeMappings":";;;;;;;;;;;;;","mappings":";UASYA;;GAAAA,iCAAAA;;UAiBAC;;;;GAAAA,0BAAAA;;UAwGAC;;GAAAA,iBAAAA"}