crankscript 0.5.1 → 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.5.1",
+    "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/commands/GenerateTypes/GenerateTypesCommand.d.ts

@@ -4,6 +4,7 @@ export declare class GenerateTypesCommand extends RenderableCommand {
     static paths: string[][];
     static usage: import("clipanion").Usage;
     output: string;
+    overwriteJson: boolean;
     version: any;
     render(): React.JSX.Element;
 }

package/src/commands/GenerateTypes/GenerateTypesCommand.js

@@ -11,7 +11,8 @@ export class GenerateTypesCommand extends RenderableCommand {
         const output = this.output.endsWith('.d.ts') ? this.output : join(this.output, 'playdate.d.ts');
         return /*#__PURE__*/ React.createElement(GenerateTypes, {
             output: output,
-            version: this.version
+            version: this.version,
+            overwriteJson: this.overwriteJson
         });
     }
     constructor(...args){
@@ -20,6 +21,9 @@ export class GenerateTypesCommand extends RenderableCommand {
             description: `Where to generate the playdate.d.ts file. Defaults to the current working directory ("${process.cwd()}")`,
             validator: t.isString()
         });
+        this.overwriteJson = Option.Boolean('-j,--overwrite-json', false, {
+            description: 'Overwrite the JSON data file with the new data'
+        });
         this.version = Option.String({
             name: 'version',
             validator: t.isOneOf([

package/src/commands/GenerateTypes/GenerateTypesCommand.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../../libs/cli/src/commands/GenerateTypes/GenerateTypesCommand.tsx"],"sourcesContent":["import { join } from 'node:path';\nimport * as process from 'node:process';\nimport { Command, Option } from 'clipanion';\nimport React from 'react';\nimport * as t from 'typanion';\nimport { AnyStrictValidator } from 'typanion';\nimport { RenderableCommand } from '@/cli/commands/RenderableCommand.js';\nimport { PlaydateSdkVersionIdentifier } from '@/cli/types.js';\nimport { GenerateTypes } from './components/GenerateTypes.js';\n\nexport class GenerateTypesCommand extends RenderableCommand {\n    static override paths = [['generate-types']];\n    static override usage = Command.Usage({\n        description: 'Generate types from the Playdate SDK documentation',\n    });\n\n    output = Option.String('-o,--output', process.cwd(), {\n        description: `Where to generate the playdate.d.ts file. Defaults to the current working directory (\"${process.cwd()}\")`,\n        validator: t.isString(),\n    });\n\n    version = Option.String({\n        name: 'version',\n        validator: t.isOneOf([\n            t.isLiteral(PlaydateSdkVersionIdentifier.Latest),\n            t.matchesRegExp(/^[0-9]+\\.[0-9]+\\.[0-9]+$/) as AnyStrictValidator,\n        ]),\n    });\n\n    override render() {\n        const output = this.output.endsWith('.d.ts')\n            ? this.output\n            : join(this.output, 'playdate.d.ts');\n\n        return <GenerateTypes output={output} version={this.version} />;\n    }\n}\n"],"names":["join","process","Command","Option","React","t","RenderableCommand","PlaydateSdkVersionIdentifier","GenerateTypes","GenerateTypesCommand","render","output","endsWith","version","String","cwd","description","validator","isString","name","isOneOf","isLiteral","Latest","matchesRegExp","paths","usage","Usage"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAAA,SAASA,IAAI,QAAQ,YAAY;AACjC,YAAYC,aAAa,eAAe;AACxC,SAASC,OAAO,EAAEC,MAAM,QAAQ,YAAY;AAC5C,OAAOC,WAAW,QAAQ;AAC1B,YAAYC,OAAO,WAAW;AAE9B,SAASC,iBAAiB,QAAQ,sCAAsC;AACxE,SAASC,4BAA4B,QAAQ,iBAAiB;AAC9D,SAASC,aAAa,QAAQ,gCAAgC;AAE9D,OAAO,MAAMC,6BAA6BH;IAmB7BI,SAAS;QACd,MAAMC,SAAS,IAAI,CAACA,MAAM,CAACC,QAAQ,CAAC,WAC9B,IAAI,CAACD,MAAM,GACXX,KAAK,IAAI,CAACW,MAAM,EAAE;QAExB,qBAAO,oBAACH;YAAcG,QAAQA;YAAQE,SAAS,IAAI,CAACA,OAAO;;IAC/D;;;aAnBAF,SAASR,OAAOW,MAAM,CAAC,eAAeb,QAAQc,GAAG,IAAI;YACjDC,aAAa,CAAC,sFAAsF,EAAEf,QAAQc,GAAG,GAAG,EAAE,CAAC;YACvHE,WAAWZ,EAAEa,QAAQ;QACzB;aAEAL,UAAUV,OAAOW,MAAM,CAAC;YACpBK,MAAM;YACNF,WAAWZ,EAAEe,OAAO,CAAC;gBACjBf,EAAEgB,SAAS,CAACd,6BAA6Be,MAAM;gBAC/CjB,EAAEkB,aAAa,CAAC;aACnB;QACL;;AASJ;AA1Bad,qBACOe,QAAQ;IAAC;QAAC;KAAiB;CAAC;AADnCf,qBAEOgB,QAAQvB,QAAQwB,KAAK,CAAC;IAClCV,aAAa;AACjB"}
+{"version":3,"sources":["../../../../../../libs/cli/src/commands/GenerateTypes/GenerateTypesCommand.tsx"],"sourcesContent":["import { join } from 'node:path';\nimport * as process from 'node:process';\nimport { Command, Option } from 'clipanion';\nimport React from 'react';\nimport * as t from 'typanion';\nimport { AnyStrictValidator } from 'typanion';\nimport { RenderableCommand } from '@/cli/commands/RenderableCommand.js';\nimport { PlaydateSdkVersionIdentifier } from '@/cli/types.js';\nimport { GenerateTypes } from './components/GenerateTypes.js';\n\nexport class GenerateTypesCommand extends RenderableCommand {\n    static override paths = [['generate-types']];\n    static override usage = Command.Usage({\n        description: 'Generate types from the Playdate SDK documentation',\n    });\n\n    output = Option.String('-o,--output', process.cwd(), {\n        description: `Where to generate the playdate.d.ts file. Defaults to the current working directory (\"${process.cwd()}\")`,\n        validator: t.isString(),\n    });\n\n    overwriteJson = Option.Boolean('-j,--overwrite-json', false, {\n        description: 'Overwrite the JSON data file with the new data',\n    });\n\n    version = Option.String({\n        name: 'version',\n        validator: t.isOneOf([\n            t.isLiteral(PlaydateSdkVersionIdentifier.Latest),\n            t.matchesRegExp(/^[0-9]+\\.[0-9]+\\.[0-9]+$/) as AnyStrictValidator,\n        ]),\n    });\n\n    override render() {\n        const output = this.output.endsWith('.d.ts')\n            ? this.output\n            : join(this.output, 'playdate.d.ts');\n\n        return (\n            <GenerateTypes\n                output={output}\n                version={this.version}\n                overwriteJson={this.overwriteJson}\n            />\n        );\n    }\n}\n"],"names":["join","process","Command","Option","React","t","RenderableCommand","PlaydateSdkVersionIdentifier","GenerateTypes","GenerateTypesCommand","render","output","endsWith","version","overwriteJson","String","cwd","description","validator","isString","Boolean","name","isOneOf","isLiteral","Latest","matchesRegExp","paths","usage","Usage"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAAA,SAASA,IAAI,QAAQ,YAAY;AACjC,YAAYC,aAAa,eAAe;AACxC,SAASC,OAAO,EAAEC,MAAM,QAAQ,YAAY;AAC5C,OAAOC,WAAW,QAAQ;AAC1B,YAAYC,OAAO,WAAW;AAE9B,SAASC,iBAAiB,QAAQ,sCAAsC;AACxE,SAASC,4BAA4B,QAAQ,iBAAiB;AAC9D,SAASC,aAAa,QAAQ,gCAAgC;AAE9D,OAAO,MAAMC,6BAA6BH;IAuB7BI,SAAS;QACd,MAAMC,SAAS,IAAI,CAACA,MAAM,CAACC,QAAQ,CAAC,WAC9B,IAAI,CAACD,MAAM,GACXX,KAAK,IAAI,CAACW,MAAM,EAAE;QAExB,qBACI,oBAACH;YACGG,QAAQA;YACRE,SAAS,IAAI,CAACA,OAAO;YACrBC,eAAe,IAAI,CAACA,aAAa;;IAG7C;;;aA7BAH,SAASR,OAAOY,MAAM,CAAC,eAAed,QAAQe,GAAG,IAAI;YACjDC,aAAa,CAAC,sFAAsF,EAAEhB,QAAQe,GAAG,GAAG,EAAE,CAAC;YACvHE,WAAWb,EAAEc,QAAQ;QACzB;aAEAL,gBAAgBX,OAAOiB,OAAO,CAAC,uBAAuB,OAAO;YACzDH,aAAa;QACjB;aAEAJ,UAAUV,OAAOY,MAAM,CAAC;YACpBM,MAAM;YACNH,WAAWb,EAAEiB,OAAO,CAAC;gBACjBjB,EAAEkB,SAAS,CAAChB,6BAA6BiB,MAAM;gBAC/CnB,EAAEoB,aAAa,CAAC;aACnB;QACL;;AAeJ;AApCahB,qBACOiB,QAAQ;IAAC;QAAC;KAAiB;CAAC;AADnCjB,qBAEOkB,QAAQzB,QAAQ0B,KAAK,CAAC;IAClCX,aAAa;AACjB"}

package/src/commands/GenerateTypes/components/GenerateTypes.d.ts

@@ -3,6 +3,7 @@ import { PlaydateSdkVersion } from '../../../types.js';
 interface Props {
     output: string;
     version: PlaydateSdkVersion;
+    overwriteJson: boolean;
 }
-export declare const GenerateTypes: ({ output, version }: Props) => React.JSX.Element;
+export declare const GenerateTypes: ({ output, version, overwriteJson }: Props) => React.JSX.Element;
 export {};

package/src/commands/GenerateTypes/components/GenerateTypes.js

@@ -5,12 +5,12 @@ import { useGetVersion } from '../../../commands/GenerateTypes/hooks/useGetVersi
 import { useParseDocumentation } from '../../../commands/GenerateTypes/hooks/useParseDocumentation.js';
 import { CheckList } from '../../../components/CheckList/index.js';
 import { useQuitOnCtrlC } from '../../../hooks/useQuitOnCtrlC.js';
-export const GenerateTypes = ({ output, version })=>{
+export const GenerateTypes = ({ output, version, overwriteJson })=>{
     useQuitOnCtrlC();
-    const { fetchedVersion, getVersion } = useGetVersion(version);
+    const { typeProvider, fetchedVersion, getVersion } = useGetVersion(version);
     const { html, fetchHtml } = useFetchHtml(fetchedVersion);
     const { definitions, parseDocumentation } = useParseDocumentation(html, version);
-    const { generateTypeFile } = useGenerateTypeFile(output, definitions);
+    const { generateTypeFile } = useGenerateTypeFile(output, definitions, typeProvider);
     const items = useMemo(()=>{
         return [
             getVersion,
@@ -21,11 +21,17 @@ export const GenerateTypes = ({ output, version })=>{
     }, [
         fetchedVersion,
         html,
-        definitions
+        definitions,
+        typeProvider
     ]);
     return /*#__PURE__*/ React.createElement(CheckList, {
         items: items,
-        onFinish: process.exit
+        onFinish: ()=>{
+            if (overwriteJson) {
+                typeProvider == null ? void 0 : typeProvider.save();
+            }
+            process.exit();
+        }
     });
 };
 

package/src/commands/GenerateTypes/components/GenerateTypes.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../../../libs/cli/src/commands/GenerateTypes/components/GenerateTypes.tsx"],"sourcesContent":["import React, { useMemo } from 'react';\nimport { useFetchHtml } from '@/cli/commands/GenerateTypes/hooks/useFetchHtml.js';\nimport { useGenerateTypeFile } from '@/cli/commands/GenerateTypes/hooks/useGenerateTypeFile.js';\nimport { useGetVersion } from '@/cli/commands/GenerateTypes/hooks/useGetVersion.js';\nimport { useParseDocumentation } from '@/cli/commands/GenerateTypes/hooks/useParseDocumentation.js';\nimport { CheckList } from '@/cli/components/CheckList/index.js';\nimport { useQuitOnCtrlC } from '@/cli/hooks/useQuitOnCtrlC.js';\nimport { CheckListItem, PlaydateSdkVersion } from '@/cli/types.js';\n\ninterface Props {\n    output: string;\n    version: PlaydateSdkVersion;\n}\n\nexport const GenerateTypes = ({ output, version }: Props) => {\n    useQuitOnCtrlC();\n\n    const { fetchedVersion, getVersion } = useGetVersion(version);\n    const { html, fetchHtml } = useFetchHtml(fetchedVersion);\n    const { definitions, parseDocumentation } = useParseDocumentation(\n        html,\n        version\n    );\n    const { generateTypeFile } = useGenerateTypeFile(output, definitions);\n\n    const items = useMemo(() => {\n        return [\n            getVersion,\n            fetchHtml,\n            parseDocumentation,\n            generateTypeFile,\n        ] as CheckListItem<unknown>[];\n    }, [fetchedVersion, html, definitions]);\n\n    return <CheckList items={items} onFinish={process.exit} />;\n};\n"],"names":["React","useMemo","useFetchHtml","useGenerateTypeFile","useGetVersion","useParseDocumentation","CheckList","useQuitOnCtrlC","GenerateTypes","output","version","fetchedVersion","getVersion","html","fetchHtml","definitions","parseDocumentation","generateTypeFile","items","onFinish","process","exit"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAAA,OAAOA,SAASC,OAAO,QAAQ,QAAQ;AACvC,SAASC,YAAY,QAAQ,qDAAqD;AAClF,SAASC,mBAAmB,QAAQ,4DAA4D;AAChG,SAASC,aAAa,QAAQ,sDAAsD;AACpF,SAASC,qBAAqB,QAAQ,8DAA8D;AACpG,SAASC,SAAS,QAAQ,sCAAsC;AAChE,SAASC,cAAc,QAAQ,gCAAgC;AAQ/D,OAAO,MAAMC,gBAAgB,CAAC,EAAEC,MAAM,EAAEC,OAAO,EAAS;IACpDH;IAEA,MAAM,EAAEI,cAAc,EAAEC,UAAU,EAAE,GAAGR,cAAcM;IACrD,MAAM,EAAEG,IAAI,EAAEC,SAAS,EAAE,GAAGZ,aAAaS;IACzC,MAAM,EAAEI,WAAW,EAAEC,kBAAkB,EAAE,GAAGX,sBACxCQ,MACAH;IAEJ,MAAM,EAAEO,gBAAgB,EAAE,GAAGd,oBAAoBM,QAAQM;IAEzD,MAAMG,QAAQjB,QAAQ;QAClB,OAAO;YACHW;YACAE;YACAE;YACAC;SACH;IACL,GAAG;QAACN;QAAgBE;QAAME;KAAY;IAEtC,qBAAO,oBAACT;QAAUY,OAAOA;QAAOC,UAAUC,QAAQC,IAAI;;AAC1D,EAAE"}
+{"version":3,"sources":["../../../../../../../libs/cli/src/commands/GenerateTypes/components/GenerateTypes.tsx"],"sourcesContent":["import React, { useMemo } from 'react';\nimport { useFetchHtml } from '@/cli/commands/GenerateTypes/hooks/useFetchHtml.js';\nimport { useGenerateTypeFile } from '@/cli/commands/GenerateTypes/hooks/useGenerateTypeFile.js';\nimport { useGetVersion } from '@/cli/commands/GenerateTypes/hooks/useGetVersion.js';\nimport { useParseDocumentation } from '@/cli/commands/GenerateTypes/hooks/useParseDocumentation.js';\nimport { CheckList } from '@/cli/components/CheckList/index.js';\nimport { useQuitOnCtrlC } from '@/cli/hooks/useQuitOnCtrlC.js';\nimport { CheckListItem, PlaydateSdkVersion } from '@/cli/types.js';\n\ninterface Props {\n    output: string;\n    version: PlaydateSdkVersion;\n    overwriteJson: boolean;\n}\n\nexport const GenerateTypes = ({ output, version, overwriteJson }: Props) => {\n    useQuitOnCtrlC();\n\n    const { typeProvider, fetchedVersion, getVersion } = useGetVersion(version);\n    const { html, fetchHtml } = useFetchHtml(fetchedVersion);\n    const { definitions, parseDocumentation } = useParseDocumentation(\n        html,\n        version\n    );\n    const { generateTypeFile } = useGenerateTypeFile(\n        output,\n        definitions,\n        typeProvider\n    );\n\n    const items = useMemo(() => {\n        return [\n            getVersion,\n            fetchHtml,\n            parseDocumentation,\n            generateTypeFile,\n        ] as CheckListItem<unknown>[];\n    }, [fetchedVersion, html, definitions, typeProvider]);\n\n    return (\n        <CheckList\n            items={items}\n            onFinish={() => {\n                if (overwriteJson) {\n                    typeProvider?.save();\n                }\n\n                process.exit();\n            }}\n        />\n    );\n};\n"],"names":["React","useMemo","useFetchHtml","useGenerateTypeFile","useGetVersion","useParseDocumentation","CheckList","useQuitOnCtrlC","GenerateTypes","output","version","overwriteJson","typeProvider","fetchedVersion","getVersion","html","fetchHtml","definitions","parseDocumentation","generateTypeFile","items","onFinish","save","process","exit"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAAA,OAAOA,SAASC,OAAO,QAAQ,QAAQ;AACvC,SAASC,YAAY,QAAQ,qDAAqD;AAClF,SAASC,mBAAmB,QAAQ,4DAA4D;AAChG,SAASC,aAAa,QAAQ,sDAAsD;AACpF,SAASC,qBAAqB,QAAQ,8DAA8D;AACpG,SAASC,SAAS,QAAQ,sCAAsC;AAChE,SAASC,cAAc,QAAQ,gCAAgC;AAS/D,OAAO,MAAMC,gBAAgB,CAAC,EAAEC,MAAM,EAAEC,OAAO,EAAEC,aAAa,EAAS;IACnEJ;IAEA,MAAM,EAAEK,YAAY,EAAEC,cAAc,EAAEC,UAAU,EAAE,GAAGV,cAAcM;IACnE,MAAM,EAAEK,IAAI,EAAEC,SAAS,EAAE,GAAGd,aAAaW;IACzC,MAAM,EAAEI,WAAW,EAAEC,kBAAkB,EAAE,GAAGb,sBACxCU,MACAL;IAEJ,MAAM,EAAES,gBAAgB,EAAE,GAAGhB,oBACzBM,QACAQ,aACAL;IAGJ,MAAMQ,QAAQnB,QAAQ;QAClB,OAAO;YACHa;YACAE;YACAE;YACAC;SACH;IACL,GAAG;QAACN;QAAgBE;QAAME;QAAaL;KAAa;IAEpD,qBACI,oBAACN;QACGc,OAAOA;QACPC,UAAU;YACN,IAAIV,eAAe;gBACfC,gCAAAA,aAAcU,IAAI;YACtB;YAEAC,QAAQC,IAAI;QAChB;;AAGZ,EAAE"}

package/src/commands/GenerateTypes/fn/generateFunction.d.ts

@@ -0,0 +1,4 @@
+import { ModuleDeclaration, SourceFile } from 'ts-morph';
+import { createTypeProvider } from '../../../commands/GenerateTypes/utils/createTypeProvider.js';
+import { FunctionDescription } from '../../../types.js';
+export declare const generateFunction: (func: FunctionDescription, subject: SourceFile | ModuleDeclaration, typeProvider: ReturnType<typeof createTypeProvider>) => void;

package/src/commands/GenerateTypes/fn/generateFunction.js

@@ -0,0 +1,28 @@
+import { _ as _extends } from "@swc/helpers/_/_extends";
+import { TypescriptReservedNamed } from '../../../constants.js';
+export const generateFunction = (func, subject, typeProvider)=>{
+    const isReserved = TypescriptReservedNamed.includes(func.name);
+    const name = isReserved ? `_${func.name}` : func.name;
+    var _typeProvider_getFunctionOverrideOptions;
+    subject.addFunction(_extends({
+        name,
+        docs: [
+            func.docs
+        ],
+        isExported: !isReserved,
+        returnType: typeProvider.getFunctionReturnType(func),
+        parameters: typeProvider.getParameters(func)
+    }, (_typeProvider_getFunctionOverrideOptions = typeProvider.getFunctionOverrideOptions(func)) != null ? _typeProvider_getFunctionOverrideOptions : {}));
+    if (isReserved) {
+        subject.addExportDeclaration({
+            namedExports: [
+                {
+                    name,
+                    alias: func.name
+                }
+            ]
+        });
+    }
+};
+
+//# sourceMappingURL=generateFunction.js.map

package/src/commands/GenerateTypes/fn/generateFunction.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../libs/cli/src/commands/GenerateTypes/fn/generateFunction.ts"],"sourcesContent":["import {\n    FunctionDeclarationStructure,\n    ModuleDeclaration,\n    SourceFile,\n} from 'ts-morph';\nimport { createTypeProvider } from '@/cli/commands/GenerateTypes/utils/createTypeProvider.js';\nimport { TypescriptReservedNamed } from '@/cli/constants.js';\nimport { FunctionDescription } from '@/cli/types.js';\n\nexport const generateFunction = (\n    func: FunctionDescription,\n    subject: SourceFile | ModuleDeclaration,\n    typeProvider: ReturnType<typeof createTypeProvider>\n) => {\n    const isReserved = TypescriptReservedNamed.includes(func.name);\n\n    const name = isReserved ? `_${func.name}` : func.name;\n\n    subject.addFunction({\n        name,\n        docs: [func.docs],\n        isExported: !isReserved,\n        returnType: typeProvider.getFunctionReturnType(func),\n        parameters: typeProvider.getParameters(func),\n        ...((typeProvider.getFunctionOverrideOptions(\n            func\n        ) as Partial<FunctionDeclarationStructure>) ?? {}),\n    });\n\n    if (isReserved) {\n        subject.addExportDeclaration({\n            namedExports: [\n                {\n                    name,\n                    alias: func.name,\n                },\n            ],\n        });\n    }\n};\n"],"names":["TypescriptReservedNamed","generateFunction","func","subject","typeProvider","isReserved","includes","name","addFunction","docs","isExported","returnType","getFunctionReturnType","parameters","getParameters","getFunctionOverrideOptions","addExportDeclaration","namedExports","alias"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";AAMA,SAASA,uBAAuB,QAAQ,qBAAqB;AAG7D,OAAO,MAAMC,mBAAmB,CAC5BC,MACAC,SACAC;IAEA,MAAMC,aAAaL,wBAAwBM,QAAQ,CAACJ,KAAKK,IAAI;IAE7D,MAAMA,OAAOF,aAAa,CAAC,CAAC,EAAEH,KAAKK,IAAI,CAAC,CAAC,GAAGL,KAAKK,IAAI;QAQ5CH;IANTD,QAAQK,WAAW,CAAC;QAChBD;QACAE,MAAM;YAACP,KAAKO,IAAI;SAAC;QACjBC,YAAY,CAACL;QACbM,YAAYP,aAAaQ,qBAAqB,CAACV;QAC/CW,YAAYT,aAAaU,aAAa,CAACZ;OACnC,CAACE,2CAAAA,aAAaW,0BAA0B,CACxCb,iBADCE,2CAE0C,CAAC;IAGpD,IAAIC,YAAY;QACZF,QAAQa,oBAAoB,CAAC;YACzBC,cAAc;gBACV;oBACIV;oBACAW,OAAOhB,KAAKK,IAAI;gBACpB;aACH;QACL;IACJ;AACJ,EAAE"}

package/src/commands/GenerateTypes/fn/generateNamespace.d.ts

@@ -1,3 +1,4 @@
-import { ModuleDeclaration, SourceFile } from 'ts-morph';
-import { PlaydateNamespace } from '../../../types.js';
-export declare const generateNamespace: (subject: SourceFile | ModuleDeclaration, namespace: string, namespaceDescription: PlaydateNamespace, nextNamespaces: string[]) => void;
+import { InterfaceDeclaration, ModuleDeclaration, SourceFile } from 'ts-morph';
+import { createTypeProvider } from '../../../commands/GenerateTypes/utils/createTypeProvider.js';
+import { PlaydateNamespace, PlaydateType } from '../../../types.js';
+export declare const generateNamespace: (namespaceDescription: PlaydateNamespace, namespaces: string[], subjects: Map<string, SourceFile | ModuleDeclaration>, typeSubjects: Map<string, InterfaceDeclaration>, typeProvider: ReturnType<typeof createTypeProvider>, types: Record<string, PlaydateType>) => void;

package/src/commands/GenerateTypes/fn/generateNamespace.js

@@ -1,32 +1,79 @@
-import { TypescriptReservedNamed } from '../../../constants.js';
-export const generateNamespace = (subject, namespace, namespaceDescription, nextNamespaces)=>{
+import { _ as _extends } from "@swc/helpers/_/_extends";
+import { VariableDeclarationKind } from 'ts-morph';
+import { generateFunction } from '../../../commands/GenerateTypes/fn/generateFunction.js';
+export const generateNamespace = (namespaceDescription, namespaces, subjects, typeSubjects, typeProvider, types)=>{
+    const subjectName = namespaces.slice(0, -1).join('.');
+    const namespaceName = namespaces[namespaces.length - 1];
+    const isRoot = namespaces.length === 1 && namespaces[0] === 'playdate';
+    const subject = namespaces.length === 1 ? subjects.get('root') : subjects.get(subjectName);
+    if (!subject) {
+        return;
+    }
     const module = subject.addModule({
-        name: namespace.trim()
+        name: namespaceName
     });
-    if (nextNamespaces.length) {
-        generateNamespace(module, nextNamespaces[0], namespaceDescription, nextNamespaces.slice(1));
-    } else {
-        for (const func of namespaceDescription.functions){
-            const isReserved = TypescriptReservedNamed.includes(func.name);
-            const name = isReserved ? `_${func.name}` : func.name;
-            module.addFunction({
-                name,
+    const addMethods = (typeName, subj, methods)=>{
+        const interfaceName = typeName.split('.').map((name)=>name[0].toUpperCase() + name.slice(1)).join('');
+        const typeInterface = subj.addInterface({
+            name: interfaceName
+        });
+        typeSubjects.set(typeName, typeInterface);
+        for (const func of methods){
+            const parameters = typeProvider.getParameters(func);
+            typeInterface.addMethod(_extends({
+                name: func.name,
                 docs: [
                     func.docs
                 ],
-                isExported: !isReserved
-            });
-            if (isReserved) {
-                module.addExportDeclaration({
-                    namedExports: [
-                        {
-                            name,
-                            alias: func.name
-                        }
-                    ]
+                returnType: typeProvider.getFunctionReturnType(func),
+                parameters
+            }, typeProvider.getFunctionOverrideOptions(func)));
+        }
+    };
+    if (isRoot) {
+        module.addJsDoc({
+            description: 'Playdate SDK'
+        });
+        module.addStatements(typeProvider.getStatements());
+        Object.keys(types).forEach((eachType)=>{
+            addMethods(eachType, module, types[eachType].methods);
+        });
+    }
+    subjects.set(namespaces.join('.'), module);
+    if (namespaceDescription.methods.length > 0) {
+        addMethods(namespaces.join('.'), subjects.get('playdate'), namespaceDescription.methods);
+    }
+    for (const property of namespaceDescription.properties){
+        const propertyDetails = typeProvider.getPropertyDetails(property);
+        if (!propertyDetails.isStatic) {
+            const typeName = namespaces.join('.');
+            if (typeSubjects.has(typeName)) {
+                const typeInterface = typeSubjects.get(typeName);
+                typeInterface.addProperty({
+                    name: property.name,
+                    type: propertyDetails.type,
+                    docs: [
+                        property.docs
+                    ],
+                    isReadonly: propertyDetails.isReadOnly
                 });
             }
+            continue;
         }
+        const propertyType = propertyDetails.type;
+        module.addVariableStatement({
+            isExported: true,
+            declarationKind: VariableDeclarationKind.Const,
+            declarations: [
+                {
+                    name: property.name,
+                    type: propertyType
+                }
+            ]
+        });
+    }
+    for (const func of namespaceDescription.functions){
+        generateFunction(func, module, typeProvider);
     }
 };