crankscript 0.6.0 → 0.7.0

package/README.md

@@ -1,11 +1 @@
-# cli
-
-This library was generated with [Nx](https://nx.dev).
-
-## Building
-
-Run `nx build cli` to build the library.
-
-## Running unit tests
-
-Run `nx test cli` to execute the unit tests via [Jest](https://jestjs.io).
+# Cli

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "crankscript",
-    "version": "0.6.0",
+    "version": "0.7.0",
     "scripts": {
         "dev": "tsx src/index.ts",
         "post-build": "tsc-alias --project tsconfig.json"
@@ -17,7 +17,9 @@
         "ink": "^5.0.1",
         "react": "^18.3.1",
         "ts-morph": "^23.0.0",
-        "typanion": "^3.14.0"
+        "typanion": "^3.14.0",
+        "typescript-to-lua": "^1.27.0",
+        "typescript": "~5.6.2"
     },
     "type": "module",
     "main": "./src/index.js",

package/src/commands/CompileCommand/CompileCommand.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+import { RenderableCommand } from '../../commands/RenderableCommand.js';
+export declare class CompileCommand extends RenderableCommand {
+    static paths: string[][];
+    projectPath: string;
+    render(): React.JSX.Element;
+}

package/src/commands/CompileCommand/CompileCommand.js

@@ -0,0 +1,49 @@
+import { join } from 'node:path';
+import process from 'node:process';
+import { Option } from 'clipanion';
+import React, { useEffect } from 'react';
+import * as t from 'typanion';
+import * as tstl from 'typescript-to-lua';
+import { LuaTarget } from 'typescript-to-lua';
+import { RenderableCommand } from '../../commands/RenderableCommand.js';
+import { RootFolder } from '../../constants.js';
+const compile = (path)=>{
+    const result = tstl.transpileProject(join(path, 'tsconfig.json'), {
+        luaTarget: LuaTarget.Lua54,
+        outDir: join(path, 'Source'),
+        luaBundle: 'game.lua',
+        luaBundleEntry: join(path, 'src', 'index.ts'),
+        luaPlugins: [
+            {
+                name: join(RootFolder, 'src', 'commands', 'CompileCommand', 'plugin.cts')
+            }
+        ]
+    });
+};
+const Compile = ({ path })=>{
+    useEffect(()=>{
+        compile(path);
+    }, []);
+    return null;
+};
+export class CompileCommand extends RenderableCommand {
+    render() {
+        return /*#__PURE__*/ React.createElement(Compile, {
+            path: this.projectPath
+        });
+    }
+    constructor(...args){
+        super(...args);
+        this.projectPath = Option.String('-p,--path', process.cwd(), {
+            description: `Where to find the project. Defaults to the current working directory ("${process.cwd()}")`,
+            validator: t.isString()
+        });
+    }
+}
+CompileCommand.paths = [
+    [
+        'compile'
+    ]
+];
+
+//# sourceMappingURL=CompileCommand.js.map

package/src/commands/CompileCommand/CompileCommand.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../libs/cli/src/commands/CompileCommand/CompileCommand.tsx"],"sourcesContent":["import { join } from 'node:path';\nimport process from 'node:process';\nimport { Option } from 'clipanion';\nimport React, { useEffect } from 'react';\nimport * as t from 'typanion';\nimport * as tstl from 'typescript-to-lua';\nimport { LuaTarget } from 'typescript-to-lua';\nimport { RenderableCommand } from '@/cli/commands/RenderableCommand.js';\nimport { RootFolder } from '@/cli/constants.js';\n\nconst compile = (path: string) => {\n    const result = tstl.transpileProject(join(path, 'tsconfig.json'), {\n        luaTarget: LuaTarget.Lua54,\n        outDir: join(path, 'Source'),\n        luaBundle: 'game.lua',\n        luaBundleEntry: join(path, 'src', 'index.ts'),\n        luaPlugins: [\n            {\n                name: join(\n                    RootFolder,\n                    'src',\n                    'commands',\n                    'CompileCommand',\n                    'plugin.cts'\n                ),\n            },\n        ],\n    });\n};\n\nconst Compile = ({ path }: { path: string }) => {\n    useEffect(() => {\n        compile(path);\n    }, []);\n\n    return null;\n};\n\nexport class CompileCommand extends RenderableCommand {\n    static override paths = [['compile']];\n\n    projectPath = Option.String('-p,--path', process.cwd(), {\n        description: `Where to find the project. Defaults to the current working directory (\"${process.cwd()}\")`,\n        validator: t.isString(),\n    });\n\n    override render() {\n        return <Compile path={this.projectPath} />;\n    }\n}\n"],"names":["join","process","Option","React","useEffect","t","tstl","LuaTarget","RenderableCommand","RootFolder","compile","path","result","transpileProject","luaTarget","Lua54","outDir","luaBundle","luaBundleEntry","luaPlugins","name","Compile","CompileCommand","render","projectPath","String","cwd","description","validator","isString","paths"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAAA,SAASA,IAAI,QAAQ,YAAY;AACjC,OAAOC,aAAa,eAAe;AACnC,SAASC,MAAM,QAAQ,YAAY;AACnC,OAAOC,SAASC,SAAS,QAAQ,QAAQ;AACzC,YAAYC,OAAO,WAAW;AAC9B,YAAYC,UAAU,oBAAoB;AAC1C,SAASC,SAAS,QAAQ,oBAAoB;AAC9C,SAASC,iBAAiB,QAAQ,sCAAsC;AACxE,SAASC,UAAU,QAAQ,qBAAqB;AAEhD,MAAMC,UAAU,CAACC;IACb,MAAMC,SAASN,KAAKO,gBAAgB,CAACb,KAAKW,MAAM,kBAAkB;QAC9DG,WAAWP,UAAUQ,KAAK;QAC1BC,QAAQhB,KAAKW,MAAM;QACnBM,WAAW;QACXC,gBAAgBlB,KAAKW,MAAM,OAAO;QAClCQ,YAAY;YACR;gBACIC,MAAMpB,KACFS,YACA,OACA,YACA,kBACA;YAER;SACH;IACL;AACJ;AAEA,MAAMY,UAAU,CAAC,EAAEV,IAAI,EAAoB;IACvCP,UAAU;QACNM,QAAQC;IACZ,GAAG,EAAE;IAEL,OAAO;AACX;AAEA,OAAO,MAAMW,uBAAuBd;IAQvBe,SAAS;QACd,qBAAO,oBAACF;YAAQV,MAAM,IAAI,CAACa,WAAW;;IAC1C;;;aAPAA,cAActB,OAAOuB,MAAM,CAAC,aAAaxB,QAAQyB,GAAG,IAAI;YACpDC,aAAa,CAAC,uEAAuE,EAAE1B,QAAQyB,GAAG,GAAG,EAAE,CAAC;YACxGE,WAAWvB,EAAEwB,QAAQ;QACzB;;AAKJ;AAXaP,eACOQ,QAAQ;IAAC;QAAC;KAAU;CAAC"}

package/src/commands/CompileCommand/index.d.ts

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

package/src/commands/CompileCommand/index.js

@@ -0,0 +1,3 @@
+export * from './CompileCommand.js';
+
+//# sourceMappingURL=index.js.map

package/src/commands/CompileCommand/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../libs/cli/src/commands/CompileCommand/index.ts"],"sourcesContent":["export * from './CompileCommand.js';\n"],"names":[],"rangeMappings":"","mappings":"AAAA,cAAc,sBAAsB"}

package/src/commands/CompileCommand/plugin.js

@@ -0,0 +1,168 @@
+import * as ts from 'typescript';
+import * as tstl from 'typescript-to-lua';
+import * as lua from 'typescript-to-lua/dist/LuaAST';
+import { ScopeType } from 'typescript-to-lua/dist/transformation/utils/scope';
+import { transformCallAndArguments } from 'typescript-to-lua/dist/transformation/visitors/call';
+import { transformClassInstanceFields } from 'typescript-to-lua/dist/transformation/visitors/class/members/fields';
+import { getExtendedNode, isStaticNode } from 'typescript-to-lua/dist/transformation/visitors/class/utils';
+import { transformFunctionBodyContent, transformFunctionToExpression, transformParameters } from 'typescript-to-lua/dist/transformation/visitors/function';
+function createClassCall(context, className, extendsNode) {
+    // class('X')
+    const classCall = tstl.createCallExpression(tstl.createIdentifier('class'), [
+        tstl.createStringLiteral(className.text)
+    ]);
+    let classCreationExpression;
+    if (extendsNode) {
+        // class('X').extends(Blah)
+        classCreationExpression = tstl.createCallExpression(tstl.createTableIndexExpression(classCall, tstl.createStringLiteral('extends')), [
+            context.transformExpression(extendsNode.expression)
+        ]);
+    } else {
+        classCreationExpression = tstl.createCallExpression(tstl.createTableIndexExpression(classCall, tstl.createStringLiteral('extends')), [
+            tstl.createIdentifier('Object')
+        ]);
+    }
+    return tstl.createExpressionStatement(classCreationExpression);
+}
+export function transformPropertyName(context, node) {
+    if (ts.isComputedPropertyName(node)) {
+        return context.transformExpression(node.expression);
+    } else if (ts.isIdentifier(node)) {
+        return tstl.createStringLiteral(node.text);
+    } else if (ts.isPrivateIdentifier(node)) {
+        throw new Error('PrivateIdentifier is not supported');
+    } else {
+        return context.transformExpression(node);
+    }
+}
+function transformConstructor(context, className, instanceFields, constructor) {
+    const methodName = 'init';
+    context.pushScope(ScopeType.Function);
+    const bodyStatements = [];
+    let params;
+    if (constructor) {
+        [params] = transformParameters(context, constructor == null ? void 0 : constructor.parameters, tstl.createIdentifier('self'));
+    } else {
+        params = [
+            tstl.createIdentifier('self')
+        ];
+    }
+    bodyStatements.push(tstl.createExpressionStatement(tstl.createCallExpression(tstl.createTableIndexExpression(tstl.createTableIndexExpression(className, tstl.createStringLiteral('super')), tstl.createStringLiteral('init')), params)));
+    const classInstanceFields = transformClassInstanceFields(context, instanceFields);
+    // initializers have to come before any body of the constructor
+    bodyStatements.push(...classInstanceFields);
+    if (constructor == null ? void 0 : constructor.body) {
+        const body = transformFunctionBodyContent(context, constructor.body);
+        // if the first expression in the body is a super call, ignore it, because we have
+        // constructed our own super call.
+        // if it's not, make sure to include the entire body.
+        const firstStatement = constructor.body.statements[0];
+        if (firstStatement && ts.isExpressionStatement(firstStatement) && ts.isCallExpression(firstStatement.expression) && firstStatement.expression.expression.kind === ts.SyntaxKind.SuperKeyword) {
+            bodyStatements.push(...body.slice(1));
+        } else {
+            bodyStatements.push(...body);
+        }
+    }
+    context.popScope();
+    return tstl.createAssignmentStatement(tstl.createTableIndexExpression(className, tstl.createStringLiteral(methodName)), tstl.createFunctionExpression(tstl.createBlock(bodyStatements), params));
+}
+function transformMethodDeclaration(context, node, className) {
+    const [functionExpression] = transformFunctionToExpression(context, node);
+    return tstl.createAssignmentStatement(tstl.createTableIndexExpression(className, transformPropertyName(context, node.name)), functionExpression);
+}
+export const transformClassDeclaration = (declaration, context)=>{
+    let className;
+    if (declaration.name) {
+        className = tstl.createIdentifier(declaration.name.text);
+    } else {
+        className = tstl.createIdentifier(context.createTempName('class'), declaration);
+    }
+    const extension = getExtendedNode(declaration);
+    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(ts.isPropertyDeclaration).filter((member)=>member.initializer);
+    // Divide properties into static and non-static
+    const instanceFields = properties.filter((prop)=>!isStaticNode(prop));
+    const statements = [];
+    // class('X')
+    statements.push(createClassCall(context, className, extension));
+    // function X:init()
+    //   X.super.init(self)
+    // end
+    const constructor = declaration.members.find((n)=>ts.isConstructorDeclaration(n) && n.body !== undefined);
+    const transformedConstructor = transformConstructor(context, className, instanceFields, constructor);
+    if (transformedConstructor) {
+        statements.push(transformedConstructor);
+    }
+    const methods = declaration.members.filter(ts.isMethodDeclaration).map((method)=>transformMethodDeclaration(context, method, className)).filter((method)=>method !== undefined);
+    statements.push(...methods);
+    return statements;
+};
+const transformNewExpression = (node, context)=>{
+    const signature = context.checker.getResolvedSignature(node);
+    var _node_arguments;
+    const [name, params] = transformCallAndArguments(context, node.expression, (_node_arguments = node.arguments) != null ? _node_arguments : [
+        ts.factory.createTrue()
+    ], signature);
+    return tstl.createCallExpression(name, params);
+};
+export const transformSuperExpression = (expression, context)=>{
+    const superInfos = context.classSuperInfos;
+    let superInfo = undefined;
+    if (superInfos) {
+        superInfo = superInfos[superInfos.length - 1];
+    }
+    if (!superInfo) return lua.createAnonymousIdentifier(expression);
+    const { className } = superInfo;
+    // Using `super` without extended type node is a TypeScript error
+    // const extendsExpression = extendedTypeNode?.expression;
+    // let baseClassName: lua.AssignmentLeftHandSideExpression | undefined;
+    // if (extendsExpression && ts.isIdentifier(extendsExpression)) {
+    //     const symbol = context.checker.getSymbolAtLocation(extendsExpression);
+    //     if (symbol && !isSymbolExported(context, symbol)) {
+    //         // Use "baseClassName" if base is a simple identifier
+    //         baseClassName = transformIdentifier(context, extendsExpression);
+    //     }
+    // }
+    // if (!baseClassName) {
+    //     // Use "className.____super" if the base is not a simple identifier
+    //     baseClassName = lua.createTableIndexExpression(
+    //         className,
+    //         lua.createStringLiteral('____super'),
+    //         expression
+    //     );
+    // }
+    return lua.createTableIndexExpression(className, lua.createStringLiteral('super'));
+};
+const plugin = {
+    visitors: {
+        [ts.SyntaxKind.ClassDeclaration]: transformClassDeclaration,
+        [ts.SyntaxKind.SuperKeyword]: transformSuperExpression,
+        [ts.SyntaxKind.NewExpression]: transformNewExpression,
+        [ts.SyntaxKind.CallExpression]: (node, context)=>{
+            if (ts.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);
+            }
+        }
+    }
+};
+export default plugin;
+
+//# sourceMappingURL=plugin.js.map

package/src/commands/CompileCommand/plugin.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../libs/cli/src/commands/CompileCommand/plugin.cts"],"sourcesContent":["import * as ts from 'typescript';\nimport * as tstl from 'typescript-to-lua';\nimport { FunctionVisitor, TransformationContext } from 'typescript-to-lua';\nimport * as lua from 'typescript-to-lua/dist/LuaAST';\nimport { ScopeType } from 'typescript-to-lua/dist/transformation/utils/scope';\nimport { transformCallAndArguments } from 'typescript-to-lua/dist/transformation/visitors/call';\nimport { transformClassInstanceFields } from 'typescript-to-lua/dist/transformation/visitors/class/members/fields';\nimport {\n    getExtendedNode,\n    isStaticNode,\n} from 'typescript-to-lua/dist/transformation/visitors/class/utils';\nimport {\n    transformFunctionBodyContent,\n    transformFunctionToExpression,\n    transformParameters,\n} from 'typescript-to-lua/dist/transformation/visitors/function';\n\nfunction 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\nexport function transformPropertyName(\n    context: TransformationContext,\n    node: ts.PropertyName\n): tstl.Expression {\n    if (ts.isComputedPropertyName(node)) {\n        return context.transformExpression(node.expression);\n    } else if (ts.isIdentifier(node)) {\n        return tstl.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\nfunction 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    const bodyStatements: tstl.Statement[] = [];\n    let params: tstl.Identifier[];\n    if (constructor) {\n        [params] = transformParameters(\n            context,\n            constructor?.parameters,\n            tstl.createIdentifier('self')\n        );\n    } else {\n        params = [tstl.createIdentifier('self')];\n    }\n    bodyStatements.push(\n        tstl.createExpressionStatement(\n            tstl.createCallExpression(\n                tstl.createTableIndexExpression(\n                    tstl.createTableIndexExpression(\n                        className,\n                        tstl.createStringLiteral('super')\n                    ),\n                    tstl.createStringLiteral('init')\n                ),\n                params\n            )\n        )\n    );\n    const classInstanceFields = transformClassInstanceFields(\n        context,\n        instanceFields\n    );\n    // initializers have to come before any body of the constructor\n    bodyStatements.push(...classInstanceFields);\n    if (constructor?.body) {\n        const body = transformFunctionBodyContent(context, constructor.body);\n        // if the first expression in the body is a super call, ignore it, because we have\n        // constructed our own super call.\n        // if it's not, make sure to include the entire body.\n        const firstStatement = constructor.body.statements[0];\n        if (\n            firstStatement &&\n            ts.isExpressionStatement(firstStatement) &&\n            ts.isCallExpression(firstStatement.expression) &&\n            firstStatement.expression.expression.kind ===\n                ts.SyntaxKind.SuperKeyword\n        ) {\n            bodyStatements.push(...body.slice(1));\n        } else {\n            bodyStatements.push(...body);\n        }\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\nfunction 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}\ninterface ClassSuperInfo {\n    className: lua.Identifier;\n    extendedTypeNode?: ts.ExpressionWithTypeArguments;\n}\n\nexport const transformClassDeclaration: FunctionVisitor<\n    ts.ClassLikeDeclaration\n> = (\n    declaration,\n    context: TransformationContext & { classSuperInfos?: [ClassSuperInfo] }\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    if (context.classSuperInfos) {\n        context.classSuperInfos.push({\n            className,\n            extendedTypeNode: extension,\n        });\n    } else {\n        context.classSuperInfos = [{ className, extendedTypeNode: extension }];\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    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) => transformMethodDeclaration(context, method, className))\n        .filter((method): method is tstl.Statement => method !== undefined);\n    statements.push(...methods);\n\n    return statements;\n};\n\nconst transformNewExpression: FunctionVisitor<ts.NewExpression> = (\n    node,\n    context\n) => {\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};\n\nexport const transformSuperExpression: FunctionVisitor<ts.SuperExpression> = (\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    // Using `super` without extended type node is a TypeScript error\n    // const extendsExpression = extendedTypeNode?.expression;\n    // let baseClassName: lua.AssignmentLeftHandSideExpression | undefined;\n\n    // if (extendsExpression && ts.isIdentifier(extendsExpression)) {\n    //     const symbol = context.checker.getSymbolAtLocation(extendsExpression);\n    //     if (symbol && !isSymbolExported(context, symbol)) {\n    //         // Use \"baseClassName\" if base is a simple identifier\n    //         baseClassName = transformIdentifier(context, extendsExpression);\n    //     }\n    // }\n\n    // if (!baseClassName) {\n    //     // Use \"className.____super\" if the base is not a simple identifier\n    //     baseClassName = lua.createTableIndexExpression(\n    //         className,\n    //         lua.createStringLiteral('____super'),\n    //         expression\n    //     );\n    // }\n\n    return lua.createTableIndexExpression(\n        className,\n        lua.createStringLiteral('super')\n    );\n};\n\nconst plugin = {\n    visitors: {\n        [ts.SyntaxKind.ClassDeclaration]: transformClassDeclaration,\n        [ts.SyntaxKind.SuperKeyword]: transformSuperExpression,\n        [ts.SyntaxKind.NewExpression]: transformNewExpression,\n        [ts.SyntaxKind.CallExpression]: (node, context) => {\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 lua.Expression;\n            } else {\n                return context.superTransformExpression(node);\n            }\n        },\n    },\n} satisfies tstl.Plugin;\n\nexport default plugin;\n"],"names":["ts","tstl","lua","ScopeType","transformCallAndArguments","transformClassInstanceFields","getExtendedNode","isStaticNode","transformFunctionBodyContent","transformFunctionToExpression","transformParameters","createClassCall","context","className","extendsNode","classCall","createCallExpression","createIdentifier","createStringLiteral","text","classCreationExpression","createTableIndexExpression","transformExpression","expression","createExpressionStatement","transformPropertyName","node","isComputedPropertyName","isIdentifier","isPrivateIdentifier","Error","transformConstructor","instanceFields","constructor","methodName","pushScope","Function","bodyStatements","params","parameters","push","classInstanceFields","body","firstStatement","statements","isExpressionStatement","isCallExpression","kind","SyntaxKind","SuperKeyword","slice","popScope","createAssignmentStatement","createFunctionExpression","createBlock","transformMethodDeclaration","functionExpression","name","transformClassDeclaration","declaration","createTempName","extension","classSuperInfos","extendedTypeNode","properties","members","filter","isPropertyDeclaration","member","initializer","prop","find","n","isConstructorDeclaration","undefined","transformedConstructor","methods","isMethodDeclaration","map","method","transformNewExpression","signature","checker","getResolvedSignature","arguments","factory","createTrue","transformSuperExpression","superInfos","superInfo","length","createAnonymousIdentifier","plugin","visitors","ClassDeclaration","NewExpression","CallExpression","escapedText","normalNode","superTransformExpression","originalName"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"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"}

package/src/index.js

@@ -2,8 +2,9 @@
 import { readFileSync } from 'fs';
 import { join } from 'node:path';
 import { Cli } from 'clipanion';
+import { CompileCommand } from './commands/CompileCommand/index.js';
 import { DoctorCommand } from './commands/DoctorCommand.js';
-import { GenerateTypesCommand } from './commands/GenerateTypes/GenerateTypesCommand.js';
+import { GenerateTypesCommand } from './commands/GenerateTypes/index.js';
 import { RootFolder } from './constants.js';
 const packageJsonContents = readFileSync(join(RootFolder, 'package.json'), 'utf-8');
 const packageJson = JSON.parse(packageJsonContents);
@@ -15,6 +16,7 @@ const cli = new Cli({
 });
 cli.register(DoctorCommand);
 cli.register(GenerateTypesCommand);
+cli.register(CompileCommand);
 cli.runExit(args);
 
 //# sourceMappingURL=index.js.map

package/src/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../libs/cli/src/index.ts"],"sourcesContent":["#!/usr/bin/env node --no-warnings=ExperimentalWarning\n\nimport { readFileSync } from 'fs';\nimport { join } from 'node:path';\nimport { Cli } from 'clipanion';\nimport { DoctorCommand } from '@/cli/commands/DoctorCommand.js';\nimport { GenerateTypesCommand } from '@/cli/commands/GenerateTypes/GenerateTypesCommand.js';\nimport { RootFolder } from '@/cli/constants.js';\n\nconst packageJsonContents = readFileSync(\n    join(RootFolder, 'package.json'),\n    'utf-8'\n);\nconst packageJson = JSON.parse(packageJsonContents);\n\nconst args = process.argv.slice(2);\n\nconst cli = new Cli({\n    binaryLabel: 'crankscript',\n    binaryName: 'crankscript',\n    binaryVersion: packageJson.version,\n});\n\ncli.register(DoctorCommand);\ncli.register(GenerateTypesCommand);\ncli.runExit(args);\n"],"names":["readFileSync","join","Cli","DoctorCommand","GenerateTypesCommand","RootFolder","packageJsonContents","packageJson","JSON","parse","args","process","argv","slice","cli","binaryLabel","binaryName","binaryVersion","version","register","runExit"],"rangeMappings":";;;;;;;;;;;;;;;;;","mappings":";AAEA,SAASA,YAAY,QAAQ,KAAK;AAClC,SAASC,IAAI,QAAQ,YAAY;AACjC,SAASC,GAAG,QAAQ,YAAY;AAChC,SAASC,aAAa,QAAQ,kCAAkC;AAChE,SAASC,oBAAoB,QAAQ,uDAAuD;AAC5F,SAASC,UAAU,QAAQ,qBAAqB;AAEhD,MAAMC,sBAAsBN,aACxBC,KAAKI,YAAY,iBACjB;AAEJ,MAAME,cAAcC,KAAKC,KAAK,CAACH;AAE/B,MAAMI,OAAOC,QAAQC,IAAI,CAACC,KAAK,CAAC;AAEhC,MAAMC,MAAM,IAAIZ,IAAI;IAChBa,aAAa;IACbC,YAAY;IACZC,eAAeV,YAAYW,OAAO;AACtC;AAEAJ,IAAIK,QAAQ,CAAChB;AACbW,IAAIK,QAAQ,CAACf;AACbU,IAAIM,OAAO,CAACV"}
+{"version":3,"sources":["../../../../libs/cli/src/index.ts"],"sourcesContent":["#!/usr/bin/env node --no-warnings=ExperimentalWarning\n\nimport { readFileSync } from 'fs';\nimport { join } from 'node:path';\nimport { Cli } from 'clipanion';\nimport { CompileCommand } from '@/cli/commands/CompileCommand/index.js';\nimport { DoctorCommand } from '@/cli/commands/DoctorCommand.js';\nimport { GenerateTypesCommand } from '@/cli/commands/GenerateTypes/index.js';\nimport { RootFolder } from '@/cli/constants.js';\n\nconst packageJsonContents = readFileSync(\n    join(RootFolder, 'package.json'),\n    'utf-8'\n);\nconst packageJson = JSON.parse(packageJsonContents);\n\nconst args = process.argv.slice(2);\n\nconst cli = new Cli({\n    binaryLabel: 'crankscript',\n    binaryName: 'crankscript',\n    binaryVersion: packageJson.version,\n});\n\ncli.register(DoctorCommand);\ncli.register(GenerateTypesCommand);\ncli.register(CompileCommand);\ncli.runExit(args);\n"],"names":["readFileSync","join","Cli","CompileCommand","DoctorCommand","GenerateTypesCommand","RootFolder","packageJsonContents","packageJson","JSON","parse","args","process","argv","slice","cli","binaryLabel","binaryName","binaryVersion","version","register","runExit"],"rangeMappings":";;;;;;;;;;;;;;;;;;;","mappings":";AAEA,SAASA,YAAY,QAAQ,KAAK;AAClC,SAASC,IAAI,QAAQ,YAAY;AACjC,SAASC,GAAG,QAAQ,YAAY;AAChC,SAASC,cAAc,QAAQ,yCAAyC;AACxE,SAASC,aAAa,QAAQ,kCAAkC;AAChE,SAASC,oBAAoB,QAAQ,wCAAwC;AAC7E,SAASC,UAAU,QAAQ,qBAAqB;AAEhD,MAAMC,sBAAsBP,aACxBC,KAAKK,YAAY,iBACjB;AAEJ,MAAME,cAAcC,KAAKC,KAAK,CAACH;AAE/B,MAAMI,OAAOC,QAAQC,IAAI,CAACC,KAAK,CAAC;AAEhC,MAAMC,MAAM,IAAIb,IAAI;IAChBc,aAAa;IACbC,YAAY;IACZC,eAAeV,YAAYW,OAAO;AACtC;AAEAJ,IAAIK,QAAQ,CAAChB;AACbW,IAAIK,QAAQ,CAACf;AACbU,IAAIK,QAAQ,CAACjB;AACbY,IAAIM,OAAO,CAACV"}