crankscript 0.6.0 → 0.8.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.8.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/fn/generateNamespace.d.ts

@@ -1,4 +1,4 @@
-import { InterfaceDeclaration, ModuleDeclaration, SourceFile } from 'ts-morph';
+import { ClassDeclaration, 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;
+export declare const generateNamespace: (namespaceDescription: PlaydateNamespace, namespaces: string[], subjects: Map<string, SourceFile | ModuleDeclaration>, typeSubjects: Map<string, ClassDeclaration>, typeProvider: ReturnType<typeof createTypeProvider>, types: Record<string, PlaydateType>) => void;

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

@@ -5,22 +5,22 @@ export const generateNamespace = (namespaceDescription, namespaces, subjects, ty
     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);
+    const subject = namespaces.length <= 1 ? subjects.get('root') : subjects.get(subjectName);
     if (!subject) {
         return;
     }
-    const module = subject.addModule({
+    const module = namespaces.length > 0 ? subject.addModule({
         name: namespaceName
-    });
+    }) : subject;
     const addMethods = (typeName, subj, methods)=>{
         const interfaceName = typeName.split('.').map((name)=>name[0].toUpperCase() + name.slice(1)).join('');
-        const typeInterface = subj.addInterface({
+        const typeClass = subj.addClass({
             name: interfaceName
         });
-        typeSubjects.set(typeName, typeInterface);
+        typeSubjects.set(typeName, typeClass);
         for (const func of methods){
             const parameters = typeProvider.getParameters(func);
-            typeInterface.addMethod(_extends({
+            typeClass.addMethod(_extends({
                 name: func.name,
                 docs: [
                     func.docs
@@ -30,7 +30,7 @@ export const generateNamespace = (namespaceDescription, namespaces, subjects, ty
             }, typeProvider.getFunctionOverrideOptions(func)));
         }
     };
-    if (isRoot) {
+    if (isRoot && 'addJsDoc' in module) {
         module.addJsDoc({
             description: 'Playdate SDK'
         });
@@ -39,7 +39,9 @@ export const generateNamespace = (namespaceDescription, namespaces, subjects, ty
             addMethods(eachType, module, types[eachType].methods);
         });
     }
-    subjects.set(namespaces.join('.'), module);
+    if (namespaces.length > 0) {
+        subjects.set(namespaces.join('.'), module);
+    }
     if (namespaceDescription.methods.length > 0) {
         addMethods(namespaces.join('.'), subjects.get('playdate'), namespaceDescription.methods);
     }

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

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../../../libs/cli/src/commands/GenerateTypes/fn/generateNamespace.ts"],"sourcesContent":["import {\n    InterfaceDeclaration,\n    MethodSignatureStructure,\n    ModuleDeclaration,\n    SourceFile,\n    VariableDeclarationKind,\n} from 'ts-morph';\nimport { generateFunction } from '@/cli/commands/GenerateTypes/fn/generateFunction.js';\nimport { createTypeProvider } from '@/cli/commands/GenerateTypes/utils/createTypeProvider.js';\nimport {\n    FunctionDescription,\n    PlaydateNamespace,\n    PlaydateType,\n} from '@/cli/types.js';\n\nexport const generateNamespace = (\n    namespaceDescription: PlaydateNamespace,\n    namespaces: string[],\n    subjects: Map<string, SourceFile | ModuleDeclaration>,\n    typeSubjects: Map<string, InterfaceDeclaration>,\n    typeProvider: ReturnType<typeof createTypeProvider>,\n    types: Record<string, PlaydateType>\n) => {\n    const subjectName = namespaces.slice(0, -1).join('.');\n    const namespaceName = namespaces[namespaces.length - 1];\n    const isRoot = namespaces.length === 1 && namespaces[0] === 'playdate';\n    const subject =\n        namespaces.length === 1\n            ? subjects.get('root')\n            : subjects.get(subjectName);\n\n    if (!subject) {\n        return;\n    }\n\n    const module = subject.addModule({\n        name: namespaceName,\n    });\n\n    const addMethods = (\n        typeName: string,\n        subj: ModuleDeclaration,\n        methods: FunctionDescription[]\n    ) => {\n        const interfaceName = typeName\n            .split('.')\n            .map((name) => name[0].toUpperCase() + name.slice(1))\n            .join('');\n        const typeInterface = subj.addInterface({\n            name: interfaceName,\n        });\n        typeSubjects.set(typeName, typeInterface);\n\n        for (const func of methods) {\n            const parameters = typeProvider.getParameters(func);\n\n            typeInterface.addMethod({\n                name: func.name,\n                docs: [func.docs],\n                returnType: typeProvider.getFunctionReturnType(func),\n                parameters,\n                ...(typeProvider.getFunctionOverrideOptions(\n                    func\n                ) as Partial<MethodSignatureStructure>),\n            });\n        }\n    };\n\n    if (isRoot) {\n        module.addJsDoc({\n            description: 'Playdate SDK',\n        });\n        module.addStatements(typeProvider.getStatements());\n\n        Object.keys(types).forEach((eachType) => {\n            addMethods(eachType, module, types[eachType].methods);\n        });\n    }\n\n    subjects.set(namespaces.join('.'), module);\n\n    if (namespaceDescription.methods.length > 0) {\n        addMethods(\n            namespaces.join('.'),\n            subjects.get('playdate') as ModuleDeclaration,\n            namespaceDescription.methods\n        );\n    }\n\n    for (const property of namespaceDescription.properties) {\n        const propertyDetails = typeProvider.getPropertyDetails(property);\n        if (!propertyDetails.isStatic) {\n            const typeName = namespaces.join('.');\n\n            if (typeSubjects.has(typeName)) {\n                const typeInterface = typeSubjects.get(\n                    typeName\n                ) as InterfaceDeclaration;\n\n                typeInterface.addProperty({\n                    name: property.name,\n                    type: propertyDetails.type,\n                    docs: [property.docs],\n                    isReadonly: propertyDetails.isReadOnly,\n                });\n            }\n\n            continue;\n        }\n\n        const propertyType = propertyDetails.type;\n\n        module.addVariableStatement({\n            isExported: true,\n            declarationKind: VariableDeclarationKind.Const,\n            declarations: [\n                {\n                    name: property.name,\n                    type: propertyType,\n                },\n            ],\n        });\n    }\n\n    for (const func of namespaceDescription.functions) {\n        generateFunction(func, module, typeProvider);\n    }\n};\n"],"names":["VariableDeclarationKind","generateFunction","generateNamespace","namespaceDescription","namespaces","subjects","typeSubjects","typeProvider","types","subjectName","slice","join","namespaceName","length","isRoot","subject","get","module","addModule","name","addMethods","typeName","subj","methods","interfaceName","split","map","toUpperCase","typeInterface","addInterface","set","func","parameters","getParameters","addMethod","docs","returnType","getFunctionReturnType","getFunctionOverrideOptions","addJsDoc","description","addStatements","getStatements","Object","keys","forEach","eachType","property","properties","propertyDetails","getPropertyDetails","isStatic","has","addProperty","type","isReadonly","isReadOnly","propertyType","addVariableStatement","isExported","declarationKind","Const","declarations","functions"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";AAAA,SAKIA,uBAAuB,QACpB,WAAW;AAClB,SAASC,gBAAgB,QAAQ,sDAAsD;AAQvF,OAAO,MAAMC,oBAAoB,CAC7BC,sBACAC,YACAC,UACAC,cACAC,cACAC;IAEA,MAAMC,cAAcL,WAAWM,KAAK,CAAC,GAAG,CAAC,GAAGC,IAAI,CAAC;IACjD,MAAMC,gBAAgBR,UAAU,CAACA,WAAWS,MAAM,GAAG,EAAE;IACvD,MAAMC,SAASV,WAAWS,MAAM,KAAK,KAAKT,UAAU,CAAC,EAAE,KAAK;IAC5D,MAAMW,UACFX,WAAWS,MAAM,KAAK,IAChBR,SAASW,GAAG,CAAC,UACbX,SAASW,GAAG,CAACP;IAEvB,IAAI,CAACM,SAAS;QACV;IACJ;IAEA,MAAME,SAASF,QAAQG,SAAS,CAAC;QAC7BC,MAAMP;IACV;IAEA,MAAMQ,aAAa,CACfC,UACAC,MACAC;QAEA,MAAMC,gBAAgBH,SACjBI,KAAK,CAAC,KACNC,GAAG,CAAC,CAACP,OAASA,IAAI,CAAC,EAAE,CAACQ,WAAW,KAAKR,KAAKT,KAAK,CAAC,IACjDC,IAAI,CAAC;QACV,MAAMiB,gBAAgBN,KAAKO,YAAY,CAAC;YACpCV,MAAMK;QACV;QACAlB,aAAawB,GAAG,CAACT,UAAUO;QAE3B,KAAK,MAAMG,QAAQR,QAAS;YACxB,MAAMS,aAAazB,aAAa0B,aAAa,CAACF;YAE9CH,cAAcM,SAAS,CAAC;gBACpBf,MAAMY,KAAKZ,IAAI;gBACfgB,MAAM;oBAACJ,KAAKI,IAAI;iBAAC;gBACjBC,YAAY7B,aAAa8B,qBAAqB,CAACN;gBAC/CC;eACIzB,aAAa+B,0BAA0B,CACvCP;QAGZ;IACJ;IAEA,IAAIjB,QAAQ;QACRG,OAAOsB,QAAQ,CAAC;YACZC,aAAa;QACjB;QACAvB,OAAOwB,aAAa,CAAClC,aAAamC,aAAa;QAE/CC,OAAOC,IAAI,CAACpC,OAAOqC,OAAO,CAAC,CAACC;YACxB1B,WAAW0B,UAAU7B,QAAQT,KAAK,CAACsC,SAAS,CAACvB,OAAO;QACxD;IACJ;IAEAlB,SAASyB,GAAG,CAAC1B,WAAWO,IAAI,CAAC,MAAMM;IAEnC,IAAId,qBAAqBoB,OAAO,CAACV,MAAM,GAAG,GAAG;QACzCO,WACIhB,WAAWO,IAAI,CAAC,MAChBN,SAASW,GAAG,CAAC,aACbb,qBAAqBoB,OAAO;IAEpC;IAEA,KAAK,MAAMwB,YAAY5C,qBAAqB6C,UAAU,CAAE;QACpD,MAAMC,kBAAkB1C,aAAa2C,kBAAkB,CAACH;QACxD,IAAI,CAACE,gBAAgBE,QAAQ,EAAE;YAC3B,MAAM9B,WAAWjB,WAAWO,IAAI,CAAC;YAEjC,IAAIL,aAAa8C,GAAG,CAAC/B,WAAW;gBAC5B,MAAMO,gBAAgBtB,aAAaU,GAAG,CAClCK;gBAGJO,cAAcyB,WAAW,CAAC;oBACtBlC,MAAM4B,SAAS5B,IAAI;oBACnBmC,MAAML,gBAAgBK,IAAI;oBAC1BnB,MAAM;wBAACY,SAASZ,IAAI;qBAAC;oBACrBoB,YAAYN,gBAAgBO,UAAU;gBAC1C;YACJ;YAEA;QACJ;QAEA,MAAMC,eAAeR,gBAAgBK,IAAI;QAEzCrC,OAAOyC,oBAAoB,CAAC;YACxBC,YAAY;YACZC,iBAAiB5D,wBAAwB6D,KAAK;YAC9CC,cAAc;gBACV;oBACI3C,MAAM4B,SAAS5B,IAAI;oBACnBmC,MAAMG;gBACV;aACH;QACL;IACJ;IAEA,KAAK,MAAM1B,QAAQ5B,qBAAqB4D,SAAS,CAAE;QAC/C9D,iBAAiB8B,MAAMd,QAAQV;IACnC;AACJ,EAAE"}
+{"version":3,"sources":["../../../../../../../libs/cli/src/commands/GenerateTypes/fn/generateNamespace.ts"],"sourcesContent":["import {\n    ClassDeclaration,\n    MethodDeclarationStructure,\n    ModuleDeclaration,\n    SourceFile,\n    VariableDeclarationKind,\n} from 'ts-morph';\nimport { generateFunction } from '@/cli/commands/GenerateTypes/fn/generateFunction.js';\nimport { createTypeProvider } from '@/cli/commands/GenerateTypes/utils/createTypeProvider.js';\nimport {\n    FunctionDescription,\n    PlaydateNamespace,\n    PlaydateType,\n} from '@/cli/types.js';\n\nexport const generateNamespace = (\n    namespaceDescription: PlaydateNamespace,\n    namespaces: string[],\n    subjects: Map<string, SourceFile | ModuleDeclaration>,\n    typeSubjects: Map<string, ClassDeclaration>,\n    typeProvider: ReturnType<typeof createTypeProvider>,\n    types: Record<string, PlaydateType>\n) => {\n    const subjectName = namespaces.slice(0, -1).join('.');\n    const namespaceName = namespaces[namespaces.length - 1];\n    const isRoot = namespaces.length === 1 && namespaces[0] === 'playdate';\n    const subject =\n        namespaces.length <= 1\n            ? subjects.get('root')\n            : subjects.get(subjectName);\n\n    if (!subject) {\n        return;\n    }\n\n    const module =\n        namespaces.length > 0\n            ? subject.addModule({\n                  name: namespaceName,\n              })\n            : subject;\n\n    const addMethods = (\n        typeName: string,\n        subj: ModuleDeclaration,\n        methods: FunctionDescription[]\n    ) => {\n        const interfaceName = typeName\n            .split('.')\n            .map((name) => name[0].toUpperCase() + name.slice(1))\n            .join('');\n        const typeClass = subj.addClass({\n            name: interfaceName,\n        });\n        typeSubjects.set(typeName, typeClass);\n\n        for (const func of methods) {\n            const parameters = typeProvider.getParameters(func);\n\n            typeClass.addMethod({\n                name: func.name,\n                docs: [func.docs],\n                returnType: typeProvider.getFunctionReturnType(func),\n                parameters,\n                ...(typeProvider.getFunctionOverrideOptions(\n                    func\n                ) as Partial<MethodDeclarationStructure>),\n            });\n        }\n    };\n\n    if (isRoot && 'addJsDoc' in module) {\n        module.addJsDoc({\n            description: 'Playdate SDK',\n        });\n        module.addStatements(typeProvider.getStatements());\n\n        Object.keys(types).forEach((eachType) => {\n            addMethods(eachType, module, types[eachType].methods);\n        });\n    }\n\n    if (namespaces.length > 0) {\n        subjects.set(namespaces.join('.'), module);\n    }\n\n    if (namespaceDescription.methods.length > 0) {\n        addMethods(\n            namespaces.join('.'),\n            subjects.get('playdate') as ModuleDeclaration,\n            namespaceDescription.methods\n        );\n    }\n\n    for (const property of namespaceDescription.properties) {\n        const propertyDetails = typeProvider.getPropertyDetails(property);\n        if (!propertyDetails.isStatic) {\n            const typeName = namespaces.join('.');\n\n            if (typeSubjects.has(typeName)) {\n                const typeInterface = typeSubjects.get(\n                    typeName\n                ) as ClassDeclaration;\n\n                typeInterface.addProperty({\n                    name: property.name,\n                    type: propertyDetails.type,\n                    docs: [property.docs],\n                    isReadonly: propertyDetails.isReadOnly,\n                });\n            }\n\n            continue;\n        }\n\n        const propertyType = propertyDetails.type;\n\n        module.addVariableStatement({\n            isExported: true,\n            declarationKind: VariableDeclarationKind.Const,\n            declarations: [\n                {\n                    name: property.name,\n                    type: propertyType,\n                },\n            ],\n        });\n    }\n\n    for (const func of namespaceDescription.functions) {\n        generateFunction(func, module, typeProvider);\n    }\n};\n"],"names":["VariableDeclarationKind","generateFunction","generateNamespace","namespaceDescription","namespaces","subjects","typeSubjects","typeProvider","types","subjectName","slice","join","namespaceName","length","isRoot","subject","get","module","addModule","name","addMethods","typeName","subj","methods","interfaceName","split","map","toUpperCase","typeClass","addClass","set","func","parameters","getParameters","addMethod","docs","returnType","getFunctionReturnType","getFunctionOverrideOptions","addJsDoc","description","addStatements","getStatements","Object","keys","forEach","eachType","property","properties","propertyDetails","getPropertyDetails","isStatic","has","typeInterface","addProperty","type","isReadonly","isReadOnly","propertyType","addVariableStatement","isExported","declarationKind","Const","declarations","functions"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"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"}

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

@@ -1,5 +1,6 @@
 import { FunctionDescription, PlaydateNamespace, PlaydateType, PropertyDescription } from '../../../types.js';
 export declare const getApiDefinitions: (functions: FunctionDescription[], properties: PropertyDescription[]) => {
+    rootNamespace: PlaydateNamespace;
     namespaces: Record<string, PlaydateNamespace>;
     types: Record<string, PlaydateType>;
 };

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

@@ -1,4 +1,9 @@
 export const getApiDefinitions = (functions, properties)=>{
+    const rootNamespace = {
+        functions: [],
+        methods: [],
+        properties: []
+    };
     const namespaces = {};
     const types = {};
     const realNamespaces = new Set();
@@ -58,15 +63,24 @@ export const getApiDefinitions = (functions, properties)=>{
                 };
             }
             types[fullNamespacePath].methods.push(func);
+        } else if (fullNamespacePath === '') {
+            if (func.hasSelf) {
+                rootNamespace.methods.push(func);
+            } else {
+                rootNamespace.functions.push(func);
+            }
         }
     });
     properties.forEach((prop)=>{
         const fullNamespacePath = prop.namespaces.join('.');
         if (realNamespaces.has(fullNamespacePath)) {
             namespaces[fullNamespacePath].properties.push(prop);
+        } else if (fullNamespacePath === '') {
+            rootNamespace.properties.push(prop);
         }
     });
     return {
+        rootNamespace,
         namespaces,
         types
     };

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

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../../../libs/cli/src/commands/GenerateTypes/fn/getApiDefinitions.ts"],"sourcesContent":["import {\n    ApiDefinitions,\n    FunctionDescription,\n    PlaydateNamespace,\n    PlaydateType,\n    PropertyDescription,\n} from '@/cli/types.js';\n\nexport const getApiDefinitions = (\n    functions: FunctionDescription[],\n    properties: PropertyDescription[]\n) => {\n    const namespaces: Record<string, PlaydateNamespace> = {};\n    const types: Record<string, PlaydateType> = {};\n    const realNamespaces = new Set<string>();\n    const potentialNamespaces = new Set<string>();\n\n    functions.forEach((func) => {\n        if (!func.hasSelf) {\n            let currentNamespace = '';\n            func.namespaces.forEach((ns) => {\n                currentNamespace = currentNamespace\n                    ? `${currentNamespace}.${ns}`\n                    : ns;\n\n                const realNamespaceName = currentNamespace.trim();\n\n                if (!realNamespaces.has(realNamespaceName)) {\n                    realNamespaces.add(realNamespaceName);\n                }\n            });\n        }\n    });\n\n    properties.forEach((prop) => {\n        let currentNamespace = '';\n        prop.namespaces.forEach((ns) => {\n            currentNamespace = currentNamespace\n                ? `${currentNamespace}.${ns}`\n                : ns;\n\n            const realNamespaceName = currentNamespace.trim();\n\n            if (!realNamespaces.has(realNamespaceName)) {\n                realNamespaces.add(realNamespaceName);\n            }\n        });\n    });\n\n    functions.forEach((func) => {\n        if (func.hasSelf) {\n            let currentNamespace = '';\n            func.namespaces.forEach((ns) => {\n                currentNamespace = currentNamespace\n                    ? `${currentNamespace}.${ns}`\n                    : ns;\n\n                if (!potentialNamespaces.has(currentNamespace)) {\n                    potentialNamespaces.add(currentNamespace);\n                }\n            });\n        }\n    });\n\n    realNamespaces.forEach((ns) => {\n        namespaces[ns] = {\n            functions: [],\n            methods: [],\n            properties: [],\n        };\n    });\n\n    functions.forEach((func) => {\n        const fullNamespacePath = func.namespaces.join('.');\n\n        if (realNamespaces.has(fullNamespacePath)) {\n            if (func.hasSelf) {\n                namespaces[fullNamespacePath].methods.push(func);\n            } else {\n                namespaces[fullNamespacePath].functions.push(func);\n            }\n        } else if (potentialNamespaces.has(fullNamespacePath)) {\n            if (!types[fullNamespacePath]) {\n                types[fullNamespacePath] = { methods: [] };\n            }\n            types[fullNamespacePath].methods.push(func);\n        }\n    });\n\n    properties.forEach((prop) => {\n        const fullNamespacePath = prop.namespaces.join('.');\n\n        if (realNamespaces.has(fullNamespacePath)) {\n            namespaces[fullNamespacePath].properties.push(prop);\n        }\n    });\n\n    return {\n        namespaces,\n        types,\n    } satisfies ApiDefinitions;\n};\n"],"names":["getApiDefinitions","functions","properties","namespaces","types","realNamespaces","Set","potentialNamespaces","forEach","func","hasSelf","currentNamespace","ns","realNamespaceName","trim","has","add","prop","methods","fullNamespacePath","join","push"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAQA,OAAO,MAAMA,oBAAoB,CAC7BC,WACAC;IAEA,MAAMC,aAAgD,CAAC;IACvD,MAAMC,QAAsC,CAAC;IAC7C,MAAMC,iBAAiB,IAAIC;IAC3B,MAAMC,sBAAsB,IAAID;IAEhCL,UAAUO,OAAO,CAAC,CAACC;QACf,IAAI,CAACA,KAAKC,OAAO,EAAE;YACf,IAAIC,mBAAmB;YACvBF,KAAKN,UAAU,CAACK,OAAO,CAAC,CAACI;gBACrBD,mBAAmBA,mBACb,CAAC,EAAEA,iBAAiB,CAAC,EAAEC,GAAG,CAAC,GAC3BA;gBAEN,MAAMC,oBAAoBF,iBAAiBG,IAAI;gBAE/C,IAAI,CAACT,eAAeU,GAAG,CAACF,oBAAoB;oBACxCR,eAAeW,GAAG,CAACH;gBACvB;YACJ;QACJ;IACJ;IAEAX,WAAWM,OAAO,CAAC,CAACS;QAChB,IAAIN,mBAAmB;QACvBM,KAAKd,UAAU,CAACK,OAAO,CAAC,CAACI;YACrBD,mBAAmBA,mBACb,CAAC,EAAEA,iBAAiB,CAAC,EAAEC,GAAG,CAAC,GAC3BA;YAEN,MAAMC,oBAAoBF,iBAAiBG,IAAI;YAE/C,IAAI,CAACT,eAAeU,GAAG,CAACF,oBAAoB;gBACxCR,eAAeW,GAAG,CAACH;YACvB;QACJ;IACJ;IAEAZ,UAAUO,OAAO,CAAC,CAACC;QACf,IAAIA,KAAKC,OAAO,EAAE;YACd,IAAIC,mBAAmB;YACvBF,KAAKN,UAAU,CAACK,OAAO,CAAC,CAACI;gBACrBD,mBAAmBA,mBACb,CAAC,EAAEA,iBAAiB,CAAC,EAAEC,GAAG,CAAC,GAC3BA;gBAEN,IAAI,CAACL,oBAAoBQ,GAAG,CAACJ,mBAAmB;oBAC5CJ,oBAAoBS,GAAG,CAACL;gBAC5B;YACJ;QACJ;IACJ;IAEAN,eAAeG,OAAO,CAAC,CAACI;QACpBT,UAAU,CAACS,GAAG,GAAG;YACbX,WAAW,EAAE;YACbiB,SAAS,EAAE;YACXhB,YAAY,EAAE;QAClB;IACJ;IAEAD,UAAUO,OAAO,CAAC,CAACC;QACf,MAAMU,oBAAoBV,KAAKN,UAAU,CAACiB,IAAI,CAAC;QAE/C,IAAIf,eAAeU,GAAG,CAACI,oBAAoB;YACvC,IAAIV,KAAKC,OAAO,EAAE;gBACdP,UAAU,CAACgB,kBAAkB,CAACD,OAAO,CAACG,IAAI,CAACZ;YAC/C,OAAO;gBACHN,UAAU,CAACgB,kBAAkB,CAAClB,SAAS,CAACoB,IAAI,CAACZ;YACjD;QACJ,OAAO,IAAIF,oBAAoBQ,GAAG,CAACI,oBAAoB;YACnD,IAAI,CAACf,KAAK,CAACe,kBAAkB,EAAE;gBAC3Bf,KAAK,CAACe,kBAAkB,GAAG;oBAAED,SAAS,EAAE;gBAAC;YAC7C;YACAd,KAAK,CAACe,kBAAkB,CAACD,OAAO,CAACG,IAAI,CAACZ;QAC1C;IACJ;IAEAP,WAAWM,OAAO,CAAC,CAACS;QAChB,MAAME,oBAAoBF,KAAKd,UAAU,CAACiB,IAAI,CAAC;QAE/C,IAAIf,eAAeU,GAAG,CAACI,oBAAoB;YACvChB,UAAU,CAACgB,kBAAkB,CAACjB,UAAU,CAACmB,IAAI,CAACJ;QAClD;IACJ;IAEA,OAAO;QACHd;QACAC;IACJ;AACJ,EAAE"}
+{"version":3,"sources":["../../../../../../../libs/cli/src/commands/GenerateTypes/fn/getApiDefinitions.ts"],"sourcesContent":["import {\n    ApiDefinitions,\n    FunctionDescription,\n    PlaydateNamespace,\n    PlaydateType,\n    PropertyDescription,\n} from '@/cli/types.js';\n\nexport const getApiDefinitions = (\n    functions: FunctionDescription[],\n    properties: PropertyDescription[]\n) => {\n    const rootNamespace: PlaydateNamespace = {\n        functions: [],\n        methods: [],\n        properties: [],\n    };\n    const namespaces: Record<string, PlaydateNamespace> = {};\n    const types: Record<string, PlaydateType> = {};\n    const realNamespaces = new Set<string>();\n    const potentialNamespaces = new Set<string>();\n\n    functions.forEach((func) => {\n        if (!func.hasSelf) {\n            let currentNamespace = '';\n            func.namespaces.forEach((ns) => {\n                currentNamespace = currentNamespace\n                    ? `${currentNamespace}.${ns}`\n                    : ns;\n\n                const realNamespaceName = currentNamespace.trim();\n\n                if (!realNamespaces.has(realNamespaceName)) {\n                    realNamespaces.add(realNamespaceName);\n                }\n            });\n        }\n    });\n\n    properties.forEach((prop) => {\n        let currentNamespace = '';\n        prop.namespaces.forEach((ns) => {\n            currentNamespace = currentNamespace\n                ? `${currentNamespace}.${ns}`\n                : ns;\n\n            const realNamespaceName = currentNamespace.trim();\n\n            if (!realNamespaces.has(realNamespaceName)) {\n                realNamespaces.add(realNamespaceName);\n            }\n        });\n    });\n\n    functions.forEach((func) => {\n        if (func.hasSelf) {\n            let currentNamespace = '';\n            func.namespaces.forEach((ns) => {\n                currentNamespace = currentNamespace\n                    ? `${currentNamespace}.${ns}`\n                    : ns;\n\n                if (!potentialNamespaces.has(currentNamespace)) {\n                    potentialNamespaces.add(currentNamespace);\n                }\n            });\n        }\n    });\n\n    realNamespaces.forEach((ns) => {\n        namespaces[ns] = {\n            functions: [],\n            methods: [],\n            properties: [],\n        };\n    });\n\n    functions.forEach((func) => {\n        const fullNamespacePath = func.namespaces.join('.');\n\n        if (realNamespaces.has(fullNamespacePath)) {\n            if (func.hasSelf) {\n                namespaces[fullNamespacePath].methods.push(func);\n            } else {\n                namespaces[fullNamespacePath].functions.push(func);\n            }\n        } else if (potentialNamespaces.has(fullNamespacePath)) {\n            if (!types[fullNamespacePath]) {\n                types[fullNamespacePath] = { methods: [] };\n            }\n            types[fullNamespacePath].methods.push(func);\n        } else if (fullNamespacePath === '') {\n            if (func.hasSelf) {\n                rootNamespace.methods.push(func);\n            } else {\n                rootNamespace.functions.push(func);\n            }\n        }\n    });\n\n    properties.forEach((prop) => {\n        const fullNamespacePath = prop.namespaces.join('.');\n\n        if (realNamespaces.has(fullNamespacePath)) {\n            namespaces[fullNamespacePath].properties.push(prop);\n        } else if (fullNamespacePath === '') {\n            rootNamespace.properties.push(prop);\n        }\n    });\n\n    return {\n        rootNamespace,\n        namespaces,\n        types,\n    } satisfies ApiDefinitions;\n};\n"],"names":["getApiDefinitions","functions","properties","rootNamespace","methods","namespaces","types","realNamespaces","Set","potentialNamespaces","forEach","func","hasSelf","currentNamespace","ns","realNamespaceName","trim","has","add","prop","fullNamespacePath","join","push"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"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"}

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

@@ -25,8 +25,8 @@ export const getDescriptionsFromHtml = (html, version)=>{
         var _$_attr;
         const id = (_$_attr = $(element).attr('id')) != null ? _$_attr : '';
         const isProperty = id.startsWith('v-');
-        const titleText = $(element).find('.title').text();
-        if (titleText.indexOf('#') !== -1 || /[a-zA-Z]\[/.test(titleText)) {
+        const titleText = $(element).find('> .title').text();
+        if (titleText.indexOf('#') !== -1 || /[a-zA-Z]\[/.test(titleText) || /^-[a-zA-Z]/.test(titleText) || /[+*/]/.test(titleText) || titleText.indexOf(' - ') !== -1 || titleText.indexOf(' .. ') !== -1) {
             continue;
         }
         const titles = isProperty ? titleText.split('  ') : extractFunctionCalls(titleText);

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

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../../../libs/cli/src/commands/GenerateTypes/fn/getDescriptionsFromHtml.ts"],"sourcesContent":["import { load } from 'cheerio';\nimport { PlaydateSdkUrl } from '@/cli/commands/GenerateTypes/constants.js';\nimport { parseFunctionSignature } from '@/cli/commands/GenerateTypes/fn/parseFunctionSignature.js';\nimport { FunctionDescription, PropertyDescription } from '@/cli/types.js';\n\nconst extractFunctionCalls = (input: string) => {\n    const functionCallRegex =\n        /([a-zA-Z_]\\w*(\\.[a-zA-Z_]\\w*)*(?::[a-zA-Z_]\\w*)?)\\s*(\\([^)]*\\))?/g;\n    const matches: string[] = [];\n    let match;\n\n    while ((match = functionCallRegex.exec(input)) !== null) {\n        matches.push(match[0].trim());\n    }\n\n    return matches;\n};\n\nconst normalizeSignature = (signature: string) => {\n    const closingParenIndex = signature.indexOf(')');\n    return closingParenIndex !== -1\n        ? signature.slice(0, closingParenIndex + 1)\n        : signature;\n};\n\nexport const getDescriptionsFromHtml = (html: string, version: string) => {\n    const $ = load(html);\n\n    const functionSignatures = $(\n        '[id^=\"m-\"], [id^=\"f-\"], [id^=\"c-\"], [id^=\"v-\"]'\n    ).toArray();\n    const functions: FunctionDescription[] = [];\n    const properties: PropertyDescription[] = [];\n    const visitedSignatures: string[] = [];\n\n    for (const element of functionSignatures) {\n        const id = $(element).attr('id') ?? '';\n        const isProperty = id.startsWith('v-');\n        const titleText = $(element).find('.title').text();\n\n        if (titleText.indexOf('#') !== -1 || /[a-zA-Z]\\[/.test(titleText)) {\n            continue;\n        }\n\n        const titles = isProperty\n            ? titleText.split('  ')\n            : extractFunctionCalls(titleText);\n\n        let docsString = ($(element).find('.content').html() ?? '').trim();\n\n        if (docsString.startsWith('<div class=\"paragraph\">')) {\n            docsString = docsString.slice('<div class=\"paragraph\">'.length);\n        }\n\n        if (docsString.endsWith('</div>')) {\n            docsString = docsString.slice(\n                0,\n                docsString.length - '</div>'.length\n            );\n        }\n\n        docsString = docsString.replace(\n            /<a href=\"#/g,\n            '<a href=\"' + PlaydateSdkUrl + version + '#'\n        );\n\n        const baseDocs = id\n            ? `${docsString}\\n[Read more](${PlaydateSdkUrl}${version}#${id})`\n            : docsString;\n\n        for (const title of titles) {\n            const signature = normalizeSignature(title);\n\n            if (visitedSignatures.includes(signature)) {\n                continue;\n            }\n\n            visitedSignatures.push(signature);\n\n            if (isProperty) {\n                properties.push({\n                    name: title.split('.').slice(-1)[0],\n                    namespaces: signature.split('.').slice(0, -1),\n                    signature,\n                    docs: baseDocs,\n                });\n            } else {\n                try {\n                    const description = parseFunctionSignature(signature);\n\n                    const docs = description.hasSelf\n                        ? baseDocs\n                        : `${baseDocs}\\n\\n@noSelf`;\n\n                    functions.push({\n                        ...description,\n                        docs,\n                    });\n                } catch (e) {\n                    // Ignore\n                }\n            }\n        }\n    }\n\n    return { functions, properties };\n};\n"],"names":["load","PlaydateSdkUrl","parseFunctionSignature","extractFunctionCalls","input","functionCallRegex","matches","match","exec","push","trim","normalizeSignature","signature","closingParenIndex","indexOf","slice","getDescriptionsFromHtml","html","version","$","functionSignatures","toArray","functions","properties","visitedSignatures","element","id","attr","isProperty","startsWith","titleText","find","text","test","titles","split","docsString","length","endsWith","replace","baseDocs","title","includes","name","namespaces","docs","description","hasSelf","e"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";AAAA,SAASA,IAAI,QAAQ,UAAU;AAC/B,SAASC,cAAc,QAAQ,4CAA4C;AAC3E,SAASC,sBAAsB,QAAQ,4DAA4D;AAGnG,MAAMC,uBAAuB,CAACC;IAC1B,MAAMC,oBACF;IACJ,MAAMC,UAAoB,EAAE;IAC5B,IAAIC;IAEJ,MAAO,AAACA,CAAAA,QAAQF,kBAAkBG,IAAI,CAACJ,MAAK,MAAO,KAAM;QACrDE,QAAQG,IAAI,CAACF,KAAK,CAAC,EAAE,CAACG,IAAI;IAC9B;IAEA,OAAOJ;AACX;AAEA,MAAMK,qBAAqB,CAACC;IACxB,MAAMC,oBAAoBD,UAAUE,OAAO,CAAC;IAC5C,OAAOD,sBAAsB,CAAC,IACxBD,UAAUG,KAAK,CAAC,GAAGF,oBAAoB,KACvCD;AACV;AAEA,OAAO,MAAMI,0BAA0B,CAACC,MAAcC;IAClD,MAAMC,IAAInB,KAAKiB;IAEf,MAAMG,qBAAqBD,EACvB,kDACFE,OAAO;IACT,MAAMC,YAAmC,EAAE;IAC3C,MAAMC,aAAoC,EAAE;IAC5C,MAAMC,oBAA8B,EAAE;IAEtC,KAAK,MAAMC,WAAWL,mBAAoB;YAC3BD;QAAX,MAAMO,KAAKP,CAAAA,UAAAA,EAAEM,SAASE,IAAI,CAAC,iBAAhBR,UAAyB;QACpC,MAAMS,aAAaF,GAAGG,UAAU,CAAC;QACjC,MAAMC,YAAYX,EAAEM,SAASM,IAAI,CAAC,UAAUC,IAAI;QAEhD,IAAIF,UAAUhB,OAAO,CAAC,SAAS,CAAC,KAAK,aAAamB,IAAI,CAACH,YAAY;YAC/D;QACJ;QAEA,MAAMI,SAASN,aACTE,UAAUK,KAAK,CAAC,QAChBhC,qBAAqB2B;YAETX;QAAlB,IAAIiB,aAAa,AAACjB,CAAAA,CAAAA,eAAAA,EAAEM,SAASM,IAAI,CAAC,YAAYd,IAAI,cAAhCE,eAAsC,EAAC,EAAGT,IAAI;QAEhE,IAAI0B,WAAWP,UAAU,CAAC,4BAA4B;YAClDO,aAAaA,WAAWrB,KAAK,CAAC,0BAA0BsB,MAAM;QAClE;QAEA,IAAID,WAAWE,QAAQ,CAAC,WAAW;YAC/BF,aAAaA,WAAWrB,KAAK,CACzB,GACAqB,WAAWC,MAAM,GAAG,SAASA,MAAM;QAE3C;QAEAD,aAAaA,WAAWG,OAAO,CAC3B,eACA,cAActC,iBAAiBiB,UAAU;QAG7C,MAAMsB,WAAWd,KACX,CAAC,EAAEU,WAAW,cAAc,EAAEnC,eAAe,EAAEiB,QAAQ,CAAC,EAAEQ,GAAG,CAAC,CAAC,GAC/DU;QAEN,KAAK,MAAMK,SAASP,OAAQ;YACxB,MAAMtB,YAAYD,mBAAmB8B;YAErC,IAAIjB,kBAAkBkB,QAAQ,CAAC9B,YAAY;gBACvC;YACJ;YAEAY,kBAAkBf,IAAI,CAACG;YAEvB,IAAIgB,YAAY;gBACZL,WAAWd,IAAI,CAAC;oBACZkC,MAAMF,MAAMN,KAAK,CAAC,KAAKpB,KAAK,CAAC,CAAC,EAAE,CAAC,EAAE;oBACnC6B,YAAYhC,UAAUuB,KAAK,CAAC,KAAKpB,KAAK,CAAC,GAAG,CAAC;oBAC3CH;oBACAiC,MAAML;gBACV;YACJ,OAAO;gBACH,IAAI;oBACA,MAAMM,cAAc5C,uBAAuBU;oBAE3C,MAAMiC,OAAOC,YAAYC,OAAO,GAC1BP,WACA,CAAC,EAAEA,SAAS,WAAW,CAAC;oBAE9BlB,UAAUb,IAAI,CAAC,aACRqC;wBACHD;;gBAER,EAAE,OAAOG,GAAG;gBACR,SAAS;gBACb;YACJ;QACJ;IACJ;IAEA,OAAO;QAAE1B;QAAWC;IAAW;AACnC,EAAE"}
+{"version":3,"sources":["../../../../../../../libs/cli/src/commands/GenerateTypes/fn/getDescriptionsFromHtml.ts"],"sourcesContent":["import { load } from 'cheerio';\nimport { PlaydateSdkUrl } from '@/cli/commands/GenerateTypes/constants.js';\nimport { parseFunctionSignature } from '@/cli/commands/GenerateTypes/fn/parseFunctionSignature.js';\nimport { FunctionDescription, PropertyDescription } from '@/cli/types.js';\n\nconst extractFunctionCalls = (input: string) => {\n    const functionCallRegex =\n        /([a-zA-Z_]\\w*(\\.[a-zA-Z_]\\w*)*(?::[a-zA-Z_]\\w*)?)\\s*(\\([^)]*\\))?/g;\n    const matches: string[] = [];\n    let match;\n\n    while ((match = functionCallRegex.exec(input)) !== null) {\n        matches.push(match[0].trim());\n    }\n\n    return matches;\n};\n\nconst normalizeSignature = (signature: string) => {\n    const closingParenIndex = signature.indexOf(')');\n    return closingParenIndex !== -1\n        ? signature.slice(0, closingParenIndex + 1)\n        : signature;\n};\n\nexport const getDescriptionsFromHtml = (html: string, version: string) => {\n    const $ = load(html);\n\n    const functionSignatures = $(\n        '[id^=\"m-\"], [id^=\"f-\"], [id^=\"c-\"], [id^=\"v-\"]'\n    ).toArray();\n    const functions: FunctionDescription[] = [];\n    const properties: PropertyDescription[] = [];\n    const visitedSignatures: string[] = [];\n\n    for (const element of functionSignatures) {\n        const id = $(element).attr('id') ?? '';\n        const isProperty = id.startsWith('v-');\n        const titleText = $(element).find('> .title').text();\n\n        if (\n            titleText.indexOf('#') !== -1 ||\n            /[a-zA-Z]\\[/.test(titleText) ||\n            /^-[a-zA-Z]/.test(titleText) ||\n            /[+*/]/.test(titleText) ||\n            titleText.indexOf(' - ') !== -1 ||\n            titleText.indexOf(' .. ') !== -1\n        ) {\n            continue;\n        }\n\n        const titles = isProperty\n            ? titleText.split('  ')\n            : extractFunctionCalls(titleText);\n\n        let docsString = ($(element).find('.content').html() ?? '').trim();\n\n        if (docsString.startsWith('<div class=\"paragraph\">')) {\n            docsString = docsString.slice('<div class=\"paragraph\">'.length);\n        }\n\n        if (docsString.endsWith('</div>')) {\n            docsString = docsString.slice(\n                0,\n                docsString.length - '</div>'.length\n            );\n        }\n\n        docsString = docsString.replace(\n            /<a href=\"#/g,\n            '<a href=\"' + PlaydateSdkUrl + version + '#'\n        );\n\n        const baseDocs = id\n            ? `${docsString}\\n[Read more](${PlaydateSdkUrl}${version}#${id})`\n            : docsString;\n\n        for (const title of titles) {\n            const signature = normalizeSignature(title);\n\n            if (visitedSignatures.includes(signature)) {\n                continue;\n            }\n\n            visitedSignatures.push(signature);\n\n            if (isProperty) {\n                properties.push({\n                    name: title.split('.').slice(-1)[0],\n                    namespaces: signature.split('.').slice(0, -1),\n                    signature,\n                    docs: baseDocs,\n                });\n            } else {\n                try {\n                    const description = parseFunctionSignature(signature);\n\n                    const docs = description.hasSelf\n                        ? baseDocs\n                        : `${baseDocs}\\n\\n@noSelf`;\n\n                    functions.push({\n                        ...description,\n                        docs,\n                    });\n                } catch (e) {\n                    // Ignore\n                }\n            }\n        }\n    }\n\n    return { functions, properties };\n};\n"],"names":["load","PlaydateSdkUrl","parseFunctionSignature","extractFunctionCalls","input","functionCallRegex","matches","match","exec","push","trim","normalizeSignature","signature","closingParenIndex","indexOf","slice","getDescriptionsFromHtml","html","version","$","functionSignatures","toArray","functions","properties","visitedSignatures","element","id","attr","isProperty","startsWith","titleText","find","text","test","titles","split","docsString","length","endsWith","replace","baseDocs","title","includes","name","namespaces","docs","description","hasSelf","e"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"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"}

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

@@ -24,12 +24,13 @@ export const useGenerateTypeFile = (path, definitions, typeProvider)=>{
                 const subjects = new Map();
                 const typeSubjects = new Map();
                 subjects.set('root', typeFile);
+                generateNamespace(definitions.rootNamespace, [], subjects, typeSubjects, typeProvider, definitions.types);
                 Object.keys(definitions.namespaces).forEach((namespace)=>{
                     const namespaceDescription = definitions.namespaces[namespace];
                     const namespaces = namespace.split('.');
                     generateNamespace(namespaceDescription, namespaces, subjects, typeSubjects, typeProvider, definitions.types);
                 });
-                writeFileSync(path, typeFile.getFullText().replace('/** Playdate SDK */', '\n/** Playdate SDK */'));
+                writeFileSync(path, typeFile.getFullText().replace('/**', '\n/**'));
             },
             ready: definitions !== null && typeProvider !== null
         };

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    InterfaceDeclaration,\n    ModuleDeclaration,\n    Project,\n    SourceFile,\n} from 'ts-morph';\nimport { generateNamespace } from '@/cli/commands/GenerateTypes/fn/generateNamespace.js';\nimport { createTypeProvider } from '@/cli/commands/GenerateTypes/utils/createTypeProvider.js';\nimport { ApiDefinitions, 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                typeFile.addStatements(typeProvider.getGlobalStatements());\n\n                const subjects = new Map<\n                    string,\n                    SourceFile | ModuleDeclaration\n                >();\n                const typeSubjects = new Map<string, InterfaceDeclaration>();\n                subjects.set('root', typeFile);\n\n                Object.keys(definitions.namespaces).forEach((namespace) => {\n                    const namespaceDescription =\n                        definitions.namespaces[namespace];\n                    const namespaces = namespace.split('.');\n                    generateNamespace(\n                        namespaceDescription,\n                        namespaces,\n                        subjects,\n                        typeSubjects,\n                        typeProvider,\n                        definitions.types\n                    );\n                });\n\n                writeFileSync(\n                    path,\n                    typeFile\n                        .getFullText()\n                        .replace('/** Playdate SDK */', '\\n/** Playdate SDK */')\n                );\n            },\n            ready: definitions !== null && typeProvider !== null,\n        } satisfies CheckListItem<void>;\n    }, [definitions, typeProvider]);\n\n    return {\n        generateTypeFile,\n    };\n};\n"],"names":["writeFileSync","useMemo","Project","generateNamespace","useGenerateTypeFile","path","definitions","typeProvider","generateTypeFile","waitingDescription","errorDescription","finishedDescription","runningDescription","runner","Error","project","typeFile","createSourceFile","overwrite","addStatements","getGlobalStatements","subjects","Map","typeSubjects","set","Object","keys","namespaces","forEach","namespace","namespaceDescription","split","types","getFullText","replace","ready"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAAA,SAASA,aAAa,QAAQ,UAAU;AACxC,SAASC,OAAO,QAAQ,QAAQ;AAChC,SAGIC,OAAO,QAEJ,WAAW;AAClB,SAASC,iBAAiB,QAAQ,uDAAuD;AAIzF,OAAO,MAAMC,sBAAsB,CAC/BC,MACAC,aACAC;IAEA,MAAMC,mBAAmBP,QAAQ;QAC7B,OAAO;YACHQ,oBAAoB;YACpBC,kBAAkB;YAClBC,qBAAqB,IAAM;YAC3BC,oBAAoB;YACpBC,QAAQ;gBACJ,IAAI,CAACP,aAAa;oBACd,MAAM,IAAIQ,MAAM;gBACpB;gBAEA,IAAI,CAACP,cAAc;oBACf,MAAM,IAAIO,MAAM;gBACpB;gBAEA,MAAMC,UAAU,IAAIb;gBACpB,MAAMc,WAAWD,QAAQE,gBAAgB,CAACZ,MAAM,IAAI;oBAChDa,WAAW;gBACf;gBACAF,SAASG,aAAa,CAACZ,aAAaa,mBAAmB;gBAEvD,MAAMC,WAAW,IAAIC;gBAIrB,MAAMC,eAAe,IAAID;gBACzBD,SAASG,GAAG,CAAC,QAAQR;gBAErBS,OAAOC,IAAI,CAACpB,YAAYqB,UAAU,EAAEC,OAAO,CAAC,CAACC;oBACzC,MAAMC,uBACFxB,YAAYqB,UAAU,CAACE,UAAU;oBACrC,MAAMF,aAAaE,UAAUE,KAAK,CAAC;oBACnC5B,kBACI2B,sBACAH,YACAN,UACAE,cACAhB,cACAD,YAAY0B,KAAK;gBAEzB;gBAEAhC,cACIK,MACAW,SACKiB,WAAW,GACXC,OAAO,CAAC,uBAAuB;YAE5C;YACAC,OAAO7B,gBAAgB,QAAQC,iBAAiB;QACpD;IACJ,GAAG;QAACD;QAAaC;KAAa;IAE9B,OAAO;QACHC;IACJ;AACJ,EAAE"}
+{"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    ModuleDeclaration,\n    Project,\n    SourceFile,\n} from 'ts-morph';\nimport { generateNamespace } from '@/cli/commands/GenerateTypes/fn/generateNamespace.js';\nimport { createTypeProvider } from '@/cli/commands/GenerateTypes/utils/createTypeProvider.js';\nimport { ApiDefinitions, 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                typeFile.addStatements(typeProvider.getGlobalStatements());\n\n                const subjects = new Map<\n                    string,\n                    SourceFile | ModuleDeclaration\n                >();\n                const typeSubjects = new Map<string, ClassDeclaration>();\n                subjects.set('root', typeFile);\n\n                generateNamespace(\n                    definitions.rootNamespace,\n                    [],\n                    subjects,\n                    typeSubjects,\n                    typeProvider,\n                    definitions.types\n                );\n\n                Object.keys(definitions.namespaces).forEach((namespace) => {\n                    const namespaceDescription =\n                        definitions.namespaces[namespace];\n                    const namespaces = namespace.split('.');\n                    generateNamespace(\n                        namespaceDescription,\n                        namespaces,\n                        subjects,\n                        typeSubjects,\n                        typeProvider,\n                        definitions.types\n                    );\n                });\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"],"names":["writeFileSync","useMemo","Project","generateNamespace","useGenerateTypeFile","path","definitions","typeProvider","generateTypeFile","waitingDescription","errorDescription","finishedDescription","runningDescription","runner","Error","project","typeFile","createSourceFile","overwrite","addStatements","getGlobalStatements","subjects","Map","typeSubjects","set","rootNamespace","types","Object","keys","namespaces","forEach","namespace","namespaceDescription","split","getFullText","replace","ready"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAAA,SAASA,aAAa,QAAQ,UAAU;AACxC,SAASC,OAAO,QAAQ,QAAQ;AAChC,SAGIC,OAAO,QAEJ,WAAW;AAClB,SAASC,iBAAiB,QAAQ,uDAAuD;AAIzF,OAAO,MAAMC,sBAAsB,CAC/BC,MACAC,aACAC;IAEA,MAAMC,mBAAmBP,QAAQ;QAC7B,OAAO;YACHQ,oBAAoB;YACpBC,kBAAkB;YAClBC,qBAAqB,IAAM;YAC3BC,oBAAoB;YACpBC,QAAQ;gBACJ,IAAI,CAACP,aAAa;oBACd,MAAM,IAAIQ,MAAM;gBACpB;gBAEA,IAAI,CAACP,cAAc;oBACf,MAAM,IAAIO,MAAM;gBACpB;gBAEA,MAAMC,UAAU,IAAIb;gBACpB,MAAMc,WAAWD,QAAQE,gBAAgB,CAACZ,MAAM,IAAI;oBAChDa,WAAW;gBACf;gBACAF,SAASG,aAAa,CAACZ,aAAaa,mBAAmB;gBAEvD,MAAMC,WAAW,IAAIC;gBAIrB,MAAMC,eAAe,IAAID;gBACzBD,SAASG,GAAG,CAAC,QAAQR;gBAErBb,kBACIG,YAAYmB,aAAa,EACzB,EAAE,EACFJ,UACAE,cACAhB,cACAD,YAAYoB,KAAK;gBAGrBC,OAAOC,IAAI,CAACtB,YAAYuB,UAAU,EAAEC,OAAO,CAAC,CAACC;oBACzC,MAAMC,uBACF1B,YAAYuB,UAAU,CAACE,UAAU;oBACrC,MAAMF,aAAaE,UAAUE,KAAK,CAAC;oBACnC9B,kBACI6B,sBACAH,YACAR,UACAE,cACAhB,cACAD,YAAYoB,KAAK;gBAEzB;gBAEA1B,cACIK,MACAW,SAASkB,WAAW,GAAGC,OAAO,CAAC,OAAO;YAE9C;YACAC,OAAO9B,gBAAgB,QAAQC,iBAAiB;QACpD;IACJ,GAAG;QAACD;QAAaC;KAAa;IAE9B,OAAO;QACHC;IACJ;AACJ,EAAE"}

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

@@ -16,7 +16,7 @@ export declare const useGetVersion: (version: PlaydateSdkVersion) => {
         getFunctionReturnType: (func: import("../../../types.js").FunctionDescription) => string;
         getParameterDetails: (func: import("../../../types.js").FunctionDescription, parameter: string) => import("../../../types.js").ParameterDetails;
         getParameters: (func: import("../../../types.js").FunctionDescription) => import("ts-morph").FunctionDeclarationStructure["parameters"];
-        getFunctionOverrideOptions: (func: import("../../../types.js").FunctionDescription) => Partial<import("ts-morph").FunctionDeclarationStructure | import("ts-morph").MethodSignatureStructure>;
+        getFunctionOverrideOptions: (func: import("../../../types.js").FunctionDescription) => Partial<import("ts-morph").FunctionDeclarationStructure | import("ts-morph").MethodDeclarationStructure>;
         save: () => void;
     } | null;
 };

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

@@ -7,6 +7,7 @@ export declare const useParseDocumentation: (html: string | null, version: strin
         finishedDescription: () => string;
         runningDescription: string;
         runner: () => Promise<{
+            rootNamespace: import("../../../types.js").PlaydateNamespace;
             namespaces: Record<string, import("../../../types.js").PlaydateNamespace>;
             types: Record<string, import("../../../types.js").PlaydateType>;
         }>;

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

@@ -7,6 +7,6 @@ export declare const createTypeProvider: (version: string) => {
     getFunctionReturnType: (func: FunctionDescription) => string;
     getParameterDetails: (func: FunctionDescription, parameter: string) => ParameterDetails;
     getParameters: (func: FunctionDescription) => FunctionDeclarationStructure["parameters"];
-    getFunctionOverrideOptions: (func: FunctionDescription) => Partial<FunctionDeclarationStructure | import("ts-morph").MethodSignatureStructure>;
+    getFunctionOverrideOptions: (func: FunctionDescription) => Partial<FunctionDeclarationStructure | import("ts-morph").MethodDeclarationStructure>;
     save: () => void;
 };

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"}

package/src/types.d.ts

@@ -1,4 +1,4 @@
-import { FunctionDeclarationStructure, MethodSignatureStructure, ParameterDeclarationStructure } from 'ts-morph';
+import { FunctionDeclarationStructure, MethodDeclarationStructure, ParameterDeclarationStructure } from 'ts-morph';
 import { Environment } from './environment/dto/Environment.js';
 import { PlaydateSdkPath } from './environment/path/dto/PlaydateSdkPath.js';
 export declare enum PlaydateSdkVersionIdentifier {
@@ -72,6 +72,7 @@ export interface PlaydateType {
     methods: FunctionDescription[];
 }
 export interface ApiDefinitions {
+    rootNamespace: PlaydateNamespace;
     namespaces: Record<string, PlaydateNamespace>;
     types: Record<string, PlaydateType>;
 }
@@ -91,7 +92,7 @@ export interface FunctionDetails {
     parameters: ParameterDetails[];
     returnType: string;
     overrideParameters?: boolean;
-    overrideOptions?: Partial<FunctionDeclarationStructure | MethodSignatureStructure>;
+    overrideOptions?: Partial<FunctionDeclarationStructure | MethodDeclarationStructure>;
 }
 export type TypeProviderData = {
     globalStatements: string[];

package/src/types.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../libs/cli/src/types.ts"],"sourcesContent":["import {\n    FunctionDeclarationStructure,\n    MethodSignatureStructure,\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 ConstantDescription {\n    name: string;\n    docs: string;\n    values: {\n        name: string;\n        value: number;\n        docs: string;\n    }[];\n}\n\nexport interface PlaydateNamespace {\n    functions: FunctionDescription[];\n    methods: FunctionDescription[];\n    properties: PropertyDescription[];\n}\n\nexport interface PlaydateType {\n    methods: FunctionDescription[];\n}\n\nexport interface ApiDefinitions {\n    namespaces: Record<string, PlaydateNamespace>;\n    types: Record<string, PlaydateType>;\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 | MethodSignatureStructure\n    >;\n}\n\nexport type TypeProviderData = {\n    globalStatements: string[];\n    statements: string[];\n    properties: Record<string, PropertyDetails>;\n    functions: Record<string, FunctionDetails>;\n};\n"],"names":["PlaydateSdkVersionIdentifier","HealthCheckStatusType"],"rangeMappings":";;;;;;;;;","mappings":";UAQYA;;GAAAA,iCAAAA;;UAiBAC;;;;GAAAA,0BAAAA"}
+{"version":3,"sources":["../../../../libs/cli/src/types.ts"],"sourcesContent":["import {\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 ConstantDescription {\n    name: string;\n    docs: string;\n    values: {\n        name: string;\n        value: number;\n        docs: string;\n    }[];\n}\n\nexport interface PlaydateNamespace {\n    functions: FunctionDescription[];\n    methods: FunctionDescription[];\n    properties: PropertyDescription[];\n}\n\nexport interface PlaydateType {\n    methods: FunctionDescription[];\n}\n\nexport interface ApiDefinitions {\n    rootNamespace: PlaydateNamespace;\n    namespaces: Record<string, PlaydateNamespace>;\n    types: Record<string, PlaydateType>;\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    properties: Record<string, PropertyDetails>;\n    functions: Record<string, FunctionDetails>;\n};\n"],"names":["PlaydateSdkVersionIdentifier","HealthCheckStatusType"],"rangeMappings":";;;;;;;;;","mappings":";UAQYA;;GAAAA,iCAAAA;;UAiBAC;;;;GAAAA,0BAAAA"}