crankscript 0.9.5 → 0.9.7

package/assets/package.json

@@ -0,0 +1,4 @@
+{
+    "name": "assets",
+    "module": "commonjs"
+}

package/assets/plugin.js

@@ -0,0 +1,204 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformSuperExpression = exports.transformClassDeclaration = void 0;
+exports.transformPropertyName = transformPropertyName;
+var ts = __importStar(require("typescript"));
+var tstl = __importStar(require("typescript-to-lua"));
+var lua = __importStar(require("typescript-to-lua/dist/LuaAST"));
+var scope_1 = require("typescript-to-lua/dist/transformation/utils/scope");
+var call_1 = require("typescript-to-lua/dist/transformation/visitors/call");
+var fields_1 = require("typescript-to-lua/dist/transformation/visitors/class/members/fields");
+var utils_1 = require("typescript-to-lua/dist/transformation/visitors/class/utils");
+var function_1 = require("typescript-to-lua/dist/transformation/visitors/function");
+function createClassCall(context, className, extendsNode) {
+    // class('X')
+    var classCall = tstl.createCallExpression(tstl.createIdentifier('class'), [tstl.createStringLiteral(className.text)]);
+    var classCreationExpression;
+    if (extendsNode) {
+        // class('X').extends(Blah)
+        classCreationExpression = tstl.createCallExpression(tstl.createTableIndexExpression(classCall, tstl.createStringLiteral('extends')), [context.transformExpression(extendsNode.expression)]);
+    }
+    else {
+        classCreationExpression = tstl.createCallExpression(tstl.createTableIndexExpression(classCall, tstl.createStringLiteral('extends')), [tstl.createIdentifier('Object')]);
+    }
+    return tstl.createExpressionStatement(classCreationExpression);
+}
+function transformPropertyName(context, node) {
+    if (ts.isComputedPropertyName(node)) {
+        return context.transformExpression(node.expression);
+    }
+    else if (ts.isIdentifier(node)) {
+        return tstl.createStringLiteral(node.text);
+    }
+    else if (ts.isPrivateIdentifier(node)) {
+        throw new Error('PrivateIdentifier is not supported');
+    }
+    else {
+        return context.transformExpression(node);
+    }
+}
+function transformConstructor(context, className, instanceFields, constructor) {
+    var methodName = 'init';
+    context.pushScope(scope_1.ScopeType.Function);
+    var bodyStatements = [];
+    var params;
+    if (constructor) {
+        params = (0, function_1.transformParameters)(context, constructor === null || constructor === void 0 ? void 0 : constructor.parameters, tstl.createIdentifier('self'))[0];
+    }
+    else {
+        params = [tstl.createIdentifier('self')];
+    }
+    bodyStatements.push(tstl.createExpressionStatement(tstl.createCallExpression(tstl.createTableIndexExpression(tstl.createTableIndexExpression(className, tstl.createStringLiteral('super')), tstl.createStringLiteral('init')), params)));
+    var classInstanceFields = (0, fields_1.transformClassInstanceFields)(context, instanceFields);
+    // initializers have to come before any body of the constructor
+    bodyStatements.push.apply(bodyStatements, classInstanceFields);
+    if (constructor === null || constructor === void 0 ? void 0 : constructor.body) {
+        var body = (0, function_1.transformFunctionBodyContent)(context, constructor.body);
+        // if the first expression in the body is a super call, ignore it, because we have
+        // constructed our own super call.
+        // if it's not, make sure to include the entire body.
+        var firstStatement = constructor.body.statements[0];
+        if (firstStatement &&
+            ts.isExpressionStatement(firstStatement) &&
+            ts.isCallExpression(firstStatement.expression) &&
+            firstStatement.expression.expression.kind ===
+                ts.SyntaxKind.SuperKeyword) {
+            bodyStatements.push.apply(bodyStatements, body.slice(1));
+        }
+        else {
+            bodyStatements.push.apply(bodyStatements, body);
+        }
+    }
+    context.popScope();
+    return tstl.createAssignmentStatement(tstl.createTableIndexExpression(className, tstl.createStringLiteral(methodName)), tstl.createFunctionExpression(tstl.createBlock(bodyStatements), params));
+}
+function transformMethodDeclaration(context, node, className) {
+    var functionExpression = (0, function_1.transformFunctionToExpression)(context, node)[0];
+    return tstl.createAssignmentStatement(tstl.createTableIndexExpression(className, transformPropertyName(context, node.name)), functionExpression);
+}
+var transformClassDeclaration = function (declaration, context) {
+    var className;
+    if (declaration.name) {
+        className = tstl.createIdentifier(declaration.name.text);
+    }
+    else {
+        className = tstl.createIdentifier(context.createTempName('class'), declaration);
+    }
+    var extension = (0, utils_1.getExtendedNode)(declaration);
+    if (context.classSuperInfos) {
+        context.classSuperInfos.push({
+            className: className,
+            extendedTypeNode: extension,
+        });
+    }
+    else {
+        context.classSuperInfos = [{ className: className, extendedTypeNode: extension }];
+    }
+    // Get all properties with value
+    var properties = declaration.members
+        .filter(ts.isPropertyDeclaration)
+        .filter(function (member) { return member.initializer; });
+    // Divide properties into static and non-static
+    var instanceFields = properties.filter(function (prop) { return !(0, utils_1.isStaticNode)(prop); });
+    var statements = [];
+    // class('X')
+    statements.push(createClassCall(context, className, extension));
+    // function X:init()
+    //   X.super.init(self)
+    // end
+    var constructor = declaration.members.find(function (n) {
+        return ts.isConstructorDeclaration(n) && n.body !== undefined;
+    });
+    var transformedConstructor = transformConstructor(context, className, instanceFields, constructor);
+    if (transformedConstructor) {
+        statements.push(transformedConstructor);
+    }
+    var methods = declaration.members
+        .filter(ts.isMethodDeclaration)
+        .map(function (method) { return transformMethodDeclaration(context, method, className); })
+        .filter(function (method) { return method !== undefined; });
+    statements.push.apply(statements, methods);
+    return statements;
+};
+exports.transformClassDeclaration = transformClassDeclaration;
+var transformNewExpression = function (node, context) {
+    var _a;
+    var signature = context.checker.getResolvedSignature(node);
+    var _b = (0, call_1.transformCallAndArguments)(context, node.expression, (_a = node.arguments) !== null && _a !== void 0 ? _a : [ts.factory.createTrue()], signature), name = _b[0], params = _b[1];
+    return tstl.createCallExpression(name, params);
+};
+var transformSuperExpression = function (expression, context) {
+    var superInfos = context.classSuperInfos;
+    var superInfo = undefined;
+    if (superInfos) {
+        superInfo = superInfos[superInfos.length - 1];
+    }
+    if (!superInfo)
+        return lua.createAnonymousIdentifier(expression);
+    var className = superInfo.className;
+    // Using `super` without extended type node is a TypeScript error
+    // const extendsExpression = extendedTypeNode?.expression;
+    // let baseClassName: lua.AssignmentLeftHandSideExpression | undefined;
+    // if (extendsExpression && ts.isIdentifier(extendsExpression)) {
+    //     const symbol = context.checker.getSymbolAtLocation(extendsExpression);
+    //     if (symbol && !isSymbolExported(context, symbol)) {
+    //         // Use "baseClassName" if base is a simple identifier
+    //         baseClassName = transformIdentifier(context, extendsExpression);
+    //     }
+    // }
+    // if (!baseClassName) {
+    //     // Use "className.____super" if the base is not a simple identifier
+    //     baseClassName = lua.createTableIndexExpression(
+    //         className,
+    //         lua.createStringLiteral('____super'),
+    //         expression
+    //     );
+    // }
+    return lua.createTableIndexExpression(className, lua.createStringLiteral('super'));
+};
+exports.transformSuperExpression = transformSuperExpression;
+var plugin = {
+    visitors: (_a = {},
+        _a[ts.SyntaxKind.ClassDeclaration] = exports.transformClassDeclaration,
+        _a[ts.SyntaxKind.SuperKeyword] = exports.transformSuperExpression,
+        _a[ts.SyntaxKind.NewExpression] = transformNewExpression,
+        _a[ts.SyntaxKind.CallExpression] = function (node, context) {
+            if (ts.isIdentifier(node.expression) &&
+                node.expression.escapedText === 'require') {
+                console.log(1);
+                var normalNode = context.superTransformExpression(node);
+                normalNode.expression.text = 'import';
+                normalNode.expression.originalName = 'import';
+                return normalNode;
+            }
+            else {
+                return context.superTransformExpression(node);
+            }
+        },
+        _a),
+};
+exports.default = plugin;

package/assets/plugin.ts

@@ -276,7 +276,6 @@ const plugin = {
                 ts.isIdentifier(node.expression) &&
                 node.expression.escapedText === 'require'
             ) {
-                console.log(1);
                 const normalNode = context.superTransformExpression(
                     node
                 ) as unknown as {

package/assets/tsconfig.json

@@ -0,0 +1,10 @@
+{
+    "compilerOptions": {
+        "target": "ES5",
+        "module": "Node16",
+        "moduleResolution": "Node16"
+    },
+    "files": [
+        "plugin.ts"
+    ]
+}

package/package.json

@@ -1,9 +1,10 @@
 {
     "name": "crankscript",
-    "version": "0.9.5",
+    "version": "0.9.7",
     "scripts": {
         "dev": "tsx src/index.ts",
-        "post-build": "tsc-alias --project tsconfig.json"
+        "post-build": "tsc-alias --project tsconfig.json",
+        "prepare-assets": "npx tsc -p assets/tsconfig.json"
     },
     "bin": {
         "crankscript": "./src/index.js"
@@ -17,9 +18,7 @@
         "ink": "^5.0.1",
         "react": "^18.3.1",
         "ts-morph": "^23.0.0",
-        "ts-node": "^10.9.2",
         "typanion": "^3.14.0",
-        "typescript": "~5.6.2",
         "typescript-to-lua": "^1.27.0"
     },
     "type": "module",

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

@@ -1,6 +1,2 @@
-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>;
-};
+import { ApiDefinitions, FunctionDescription, PropertyDescription } from '../../../types.js';
+export declare const getApiDefinitions: (functions: FunctionDescription[], properties: PropertyDescription[]) => ApiDefinitions;

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

@@ -1,88 +1,37 @@
 export const getApiDefinitions = (functions, properties)=>{
-    const rootNamespace = {
+    const global = {
         functions: [],
         methods: [],
-        properties: []
+        properties: [],
+        namespaces: {}
     };
-    const namespaces = {};
-    const types = {};
-    const realNamespaces = new Set();
-    const potentialNamespaces = new Set();
-    functions.forEach((func)=>{
-        if (!func.hasSelf) {
-            let currentNamespace = '';
-            func.namespaces.forEach((ns)=>{
-                currentNamespace = currentNamespace ? `${currentNamespace}.${ns}` : ns;
-                const realNamespaceName = currentNamespace.trim();
-                if (!realNamespaces.has(realNamespaceName)) {
-                    realNamespaces.add(realNamespaceName);
-                }
-            });
-        }
-    });
-    properties.forEach((prop)=>{
-        let currentNamespace = '';
-        prop.namespaces.forEach((ns)=>{
-            currentNamespace = currentNamespace ? `${currentNamespace}.${ns}` : ns;
-            const realNamespaceName = currentNamespace.trim();
-            if (!realNamespaces.has(realNamespaceName)) {
-                realNamespaces.add(realNamespaceName);
+    const getOrCreateNamespace = (path, root)=>{
+        return path.reduce((currentNamespace, ns)=>{
+            if (!currentNamespace.namespaces[ns]) {
+                currentNamespace.namespaces[ns] = {
+                    functions: [],
+                    methods: [],
+                    properties: [],
+                    namespaces: {}
+                };
             }
-        });
-    });
+            return currentNamespace.namespaces[ns];
+        }, root);
+    };
     functions.forEach((func)=>{
+        const targetNamespace = getOrCreateNamespace(func.namespaces, global);
         if (func.hasSelf) {
-            let currentNamespace = '';
-            func.namespaces.forEach((ns)=>{
-                currentNamespace = currentNamespace ? `${currentNamespace}.${ns}` : ns;
-                if (!potentialNamespaces.has(currentNamespace)) {
-                    potentialNamespaces.add(currentNamespace);
-                }
-            });
-        }
-    });
-    realNamespaces.forEach((ns)=>{
-        namespaces[ns] = {
-            functions: [],
-            methods: [],
-            properties: []
-        };
-    });
-    functions.forEach((func)=>{
-        const fullNamespacePath = func.namespaces.join('.');
-        if (realNamespaces.has(fullNamespacePath)) {
-            if (func.hasSelf) {
-                namespaces[fullNamespacePath].methods.push(func);
-            } else {
-                namespaces[fullNamespacePath].functions.push(func);
-            }
-        } else if (potentialNamespaces.has(fullNamespacePath)) {
-            if (!types[fullNamespacePath]) {
-                types[fullNamespacePath] = {
-                    methods: []
-                };
-            }
-            types[fullNamespacePath].methods.push(func);
-        } else if (fullNamespacePath === '') {
-            if (func.hasSelf) {
-                rootNamespace.methods.push(func);
-            } else {
-                rootNamespace.functions.push(func);
-            }
+            targetNamespace.methods.push(func);
+        } else {
+            targetNamespace.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);
-        }
+        const targetNamespace = getOrCreateNamespace(prop.namespaces, global);
+        targetNamespace.properties.push(prop);
     });
     return {
-        rootNamespace,
-        namespaces,
-        types
+        global
     };
 };
 

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 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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"}
+{"version":3,"sources":["../../../../../../../libs/cli/src/commands/GenerateTypes/fn/getApiDefinitions.ts"],"sourcesContent":["import {\n    ApiDefinitions,\n    FunctionDescription,\n    ApiObject,\n    PropertyDescription,\n} from '@/cli/types.js';\n\nexport const getApiDefinitions = (\n    functions: FunctionDescription[],\n    properties: PropertyDescription[]\n): ApiDefinitions => {\n    const global: ApiObject = {\n        functions: [],\n        methods: [],\n        properties: [],\n        namespaces: {},\n    };\n\n    const getOrCreateNamespace = (\n        path: string[],\n        root: ApiObject\n    ): ApiObject => {\n        return path.reduce((currentNamespace, ns) => {\n            if (!currentNamespace.namespaces[ns]) {\n                currentNamespace.namespaces[ns] = {\n                    functions: [],\n                    methods: [],\n                    properties: [],\n                    namespaces: {},\n                };\n            }\n            return currentNamespace.namespaces[ns];\n        }, root);\n    };\n\n    functions.forEach((func) => {\n        const targetNamespace = getOrCreateNamespace(func.namespaces, global);\n        if (func.hasSelf) {\n            targetNamespace.methods.push(func);\n        } else {\n            targetNamespace.functions.push(func);\n        }\n    });\n\n    properties.forEach((prop) => {\n        const targetNamespace = getOrCreateNamespace(prop.namespaces, global);\n        targetNamespace.properties.push(prop);\n    });\n\n    return { global };\n};\n"],"names":["getApiDefinitions","functions","properties","global","methods","namespaces","getOrCreateNamespace","path","root","reduce","currentNamespace","ns","forEach","func","targetNamespace","hasSelf","push","prop"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAOA,OAAO,MAAMA,oBAAoB,CAC7BC,WACAC;IAEA,MAAMC,SAAoB;QACtBF,WAAW,EAAE;QACbG,SAAS,EAAE;QACXF,YAAY,EAAE;QACdG,YAAY,CAAC;IACjB;IAEA,MAAMC,uBAAuB,CACzBC,MACAC;QAEA,OAAOD,KAAKE,MAAM,CAAC,CAACC,kBAAkBC;YAClC,IAAI,CAACD,iBAAiBL,UAAU,CAACM,GAAG,EAAE;gBAClCD,iBAAiBL,UAAU,CAACM,GAAG,GAAG;oBAC9BV,WAAW,EAAE;oBACbG,SAAS,EAAE;oBACXF,YAAY,EAAE;oBACdG,YAAY,CAAC;gBACjB;YACJ;YACA,OAAOK,iBAAiBL,UAAU,CAACM,GAAG;QAC1C,GAAGH;IACP;IAEAP,UAAUW,OAAO,CAAC,CAACC;QACf,MAAMC,kBAAkBR,qBAAqBO,KAAKR,UAAU,EAAEF;QAC9D,IAAIU,KAAKE,OAAO,EAAE;YACdD,gBAAgBV,OAAO,CAACY,IAAI,CAACH;QACjC,OAAO;YACHC,gBAAgBb,SAAS,CAACe,IAAI,CAACH;QACnC;IACJ;IAEAX,WAAWU,OAAO,CAAC,CAACK;QAChB,MAAMH,kBAAkBR,qBAAqBW,KAAKZ,UAAU,EAAEF;QAC9DW,gBAAgBZ,UAAU,CAACc,IAAI,CAACC;IACpC;IAEA,OAAO;QAAEd;IAAO;AACpB,EAAE"}

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

@@ -1,7 +1,8 @@
+import { _ as _extends } from "@swc/helpers/_/_extends";
 import { writeFileSync } from 'node:fs';
 import { useMemo } from 'react';
 import { Project } from 'ts-morph';
-import { generateNamespace } from '../../../commands/GenerateTypes/fn/generateNamespace.js';
+import { TypescriptReservedNamed } from '../../../constants.js';
 export const useGenerateTypeFile = (path, definitions, typeProvider)=>{
     const generateTypeFile = useMemo(()=>{
         return {
@@ -20,16 +21,9 @@ export const useGenerateTypeFile = (path, definitions, typeProvider)=>{
                 const typeFile = project.createSourceFile(path, '', {
                     overwrite: true
                 });
+                const globalNamespace = definitions.global;
                 typeFile.addStatements(typeProvider.getGlobalStatements());
-                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);
-                });
+                generateNamespace(globalNamespace, typeFile, typeProvider);
                 writeFileSync(path, typeFile.getFullText().replace('/**', '\n/**'));
             },
             ready: definitions !== null && typeProvider !== null
@@ -42,5 +36,86 @@ export const useGenerateTypeFile = (path, definitions, typeProvider)=>{
         generateTypeFile
     };
 };
+const generateNamespace = (apiObject, incomingSubject, typeProvider, name)=>{
+    let subject = incomingSubject;
+    if (name) {
+        subject = incomingSubject.addModule({
+            name
+        });
+    }
+    if (name === 'playdate') {
+        subject.addStatements(typeProvider.getStatements());
+    }
+    for (const func of apiObject.functions){
+        const isFunctionNameReserved = TypescriptReservedNamed.includes(func.name);
+        const resolvedName = `_${func.name}`;
+        const parameters = typeProvider.getParameters(func);
+        subject.addFunction(_extends({
+            name: isFunctionNameReserved ? resolvedName : func.name,
+            docs: [
+                func.docs
+            ],
+            parameters,
+            returnType: typeProvider.getFunctionReturnType(func)
+        }, typeProvider.getFunctionOverrideOptions(func)));
+        if (isFunctionNameReserved) {
+            subject.addExportDeclaration({
+                namedExports: [
+                    {
+                        name: resolvedName,
+                        alias: func.name
+                    }
+                ]
+            });
+        }
+    }
+    let propertiesSubject = null;
+    if (name && apiObject.methods.length > 0) {
+        const typeClass = incomingSubject.addClass({
+            name
+        });
+        propertiesSubject = typeClass;
+        for (const method of apiObject.methods){
+            const parameters = typeProvider.getParameters(method);
+            typeClass.addMethod(_extends({
+                name: method.name,
+                docs: [
+                    method.docs
+                ],
+                parameters,
+                returnType: typeProvider.getFunctionReturnType(method)
+            }, typeProvider.getFunctionOverrideOptions(method)));
+        }
+    }
+    for (const property of apiObject.properties){
+        const propertyDetails = typeProvider.getPropertyDetails(property);
+        if (propertiesSubject) {
+            propertiesSubject.addProperty({
+                name: property.name,
+                docs: [
+                    property.docs
+                ],
+                type: propertyDetails.type,
+                isStatic: propertyDetails.isStatic,
+                isReadonly: propertyDetails.isReadOnly
+            });
+        } else {
+            subject.addVariableStatement({
+                docs: [
+                    property.docs
+                ],
+                declarations: [
+                    {
+                        name: property.name,
+                        type: propertyDetails.type
+                    }
+                ]
+            });
+        }
+    }
+    for (const namespace of Object.entries(apiObject.namespaces)){
+        generateNamespace(namespace[1], subject, typeProvider, namespace[0]);
+    }
+};
 
 //# sourceMappingURL=useGenerateTypeFile.js.map

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

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

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

@@ -6,11 +6,7 @@ export declare const useParseDocumentation: (html: string | null, version: strin
         errorDescription: string;
         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>;
-        }>;
+        runner: () => Promise<ApiDefinitions>;
         onFinish: (result: ApiDefinitions) => void;
         ready: boolean;
     };

package/src/commands/TranspileCommand/components/Transpile.js

@@ -13,7 +13,7 @@ const transpile = (path)=>{
         luaBundleEntry: join(path, 'src', 'index.ts'),
         luaPlugins: [
             {
-                name: join(RootFolder, 'assets', 'plugin.ts')
+                name: join(RootFolder, 'assets', 'plugin.js')
             }
         ]
     });

package/src/commands/TranspileCommand/components/Transpile.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../../../libs/cli/src/commands/TranspileCommand/components/Transpile.tsx"],"sourcesContent":["import { join } from 'node:path';\nimport React from 'react';\nimport { useMemo } from 'react';\nimport * as tstl from 'typescript-to-lua';\nimport { LuaTarget } from 'typescript-to-lua';\nimport { CheckList } from '@/cli/components/CheckList/index.js';\nimport { RootFolder } from '@/cli/constants.js';\nimport { CheckListItem } from '@/cli/types.js';\n\nconst transpile = (path: string) => {\n    tstl.transpileProject(join(path, 'tsconfig.json'), {\n        luaTarget: LuaTarget.Lua54,\n        outDir: join(path, 'Source'),\n        luaBundle: 'main.lua',\n        luaBundleEntry: join(path, 'src', 'index.ts'),\n        luaPlugins: [\n            {\n                name: join(RootFolder, 'assets', 'plugin.ts'),\n            },\n        ],\n    });\n};\n\nexport const Transpile = ({ path }: { path: string }) => {\n    const items = useMemo(\n        () => [\n            {\n                waitingDescription: 'Waiting to transpile code...',\n                errorDescription: 'Could not transpile code',\n                runningDescription: 'Transpiling code...',\n                finishedDescription: () => 'Code transpiled',\n                runner: async () => {\n                    transpile(path);\n                },\n                ready: true,\n            },\n        ],\n        []\n    ) as CheckListItem<unknown>[];\n\n    return <CheckList items={items} onFinish={process.exit} />;\n};\n"],"names":["join","React","useMemo","tstl","LuaTarget","CheckList","RootFolder","transpile","path","transpileProject","luaTarget","Lua54","outDir","luaBundle","luaBundleEntry","luaPlugins","name","Transpile","items","waitingDescription","errorDescription","runningDescription","finishedDescription","runner","ready","onFinish","process","exit"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAAA,SAASA,IAAI,QAAQ,YAAY;AACjC,OAAOC,WAAW,QAAQ;AAC1B,SAASC,OAAO,QAAQ,QAAQ;AAChC,YAAYC,UAAU,oBAAoB;AAC1C,SAASC,SAAS,QAAQ,oBAAoB;AAC9C,SAASC,SAAS,QAAQ,sCAAsC;AAChE,SAASC,UAAU,QAAQ,qBAAqB;AAGhD,MAAMC,YAAY,CAACC;IACfL,KAAKM,gBAAgB,CAACT,KAAKQ,MAAM,kBAAkB;QAC/CE,WAAWN,UAAUO,KAAK;QAC1BC,QAAQZ,KAAKQ,MAAM;QACnBK,WAAW;QACXC,gBAAgBd,KAAKQ,MAAM,OAAO;QAClCO,YAAY;YACR;gBACIC,MAAMhB,KAAKM,YAAY,UAAU;YACrC;SACH;IACL;AACJ;AAEA,OAAO,MAAMW,YAAY,CAAC,EAAET,IAAI,EAAoB;IAChD,MAAMU,QAAQhB,QACV,IAAM;YACF;gBACIiB,oBAAoB;gBACpBC,kBAAkB;gBAClBC,oBAAoB;gBACpBC,qBAAqB,IAAM;gBAC3BC,QAAQ;oBACJhB,UAAUC;gBACd;gBACAgB,OAAO;YACX;SACH,EACD,EAAE;IAGN,qBAAO,oBAACnB;QAAUa,OAAOA;QAAOO,UAAUC,QAAQC,IAAI;;AAC1D,EAAE"}
+{"version":3,"sources":["../../../../../../../libs/cli/src/commands/TranspileCommand/components/Transpile.tsx"],"sourcesContent":["import { join } from 'node:path';\nimport React from 'react';\nimport { useMemo } from 'react';\nimport * as tstl from 'typescript-to-lua';\nimport { LuaTarget } from 'typescript-to-lua';\nimport { CheckList } from '@/cli/components/CheckList/index.js';\nimport { RootFolder } from '@/cli/constants.js';\nimport { CheckListItem } from '@/cli/types.js';\n\nconst transpile = (path: string) => {\n    tstl.transpileProject(join(path, 'tsconfig.json'), {\n        luaTarget: LuaTarget.Lua54,\n        outDir: join(path, 'Source'),\n        luaBundle: 'main.lua',\n        luaBundleEntry: join(path, 'src', 'index.ts'),\n        luaPlugins: [\n            {\n                name: join(RootFolder, 'assets', 'plugin.js'),\n            },\n        ],\n    });\n};\n\nexport const Transpile = ({ path }: { path: string }) => {\n    const items = useMemo(\n        () => [\n            {\n                waitingDescription: 'Waiting to transpile code...',\n                errorDescription: 'Could not transpile code',\n                runningDescription: 'Transpiling code...',\n                finishedDescription: () => 'Code transpiled',\n                runner: async () => {\n                    transpile(path);\n                },\n                ready: true,\n            },\n        ],\n        []\n    ) as CheckListItem<unknown>[];\n\n    return <CheckList items={items} onFinish={process.exit} />;\n};\n"],"names":["join","React","useMemo","tstl","LuaTarget","CheckList","RootFolder","transpile","path","transpileProject","luaTarget","Lua54","outDir","luaBundle","luaBundleEntry","luaPlugins","name","Transpile","items","waitingDescription","errorDescription","runningDescription","finishedDescription","runner","ready","onFinish","process","exit"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAAA,SAASA,IAAI,QAAQ,YAAY;AACjC,OAAOC,WAAW,QAAQ;AAC1B,SAASC,OAAO,QAAQ,QAAQ;AAChC,YAAYC,UAAU,oBAAoB;AAC1C,SAASC,SAAS,QAAQ,oBAAoB;AAC9C,SAASC,SAAS,QAAQ,sCAAsC;AAChE,SAASC,UAAU,QAAQ,qBAAqB;AAGhD,MAAMC,YAAY,CAACC;IACfL,KAAKM,gBAAgB,CAACT,KAAKQ,MAAM,kBAAkB;QAC/CE,WAAWN,UAAUO,KAAK;QAC1BC,QAAQZ,KAAKQ,MAAM;QACnBK,WAAW;QACXC,gBAAgBd,KAAKQ,MAAM,OAAO;QAClCO,YAAY;YACR;gBACIC,MAAMhB,KAAKM,YAAY,UAAU;YACrC;SACH;IACL;AACJ;AAEA,OAAO,MAAMW,YAAY,CAAC,EAAET,IAAI,EAAoB;IAChD,MAAMU,QAAQhB,QACV,IAAM;YACF;gBACIiB,oBAAoB;gBACpBC,kBAAkB;gBAClBC,oBAAoB;gBACpBC,qBAAqB,IAAM;gBAC3BC,QAAQ;oBACJhB,UAAUC;gBACd;gBACAgB,OAAO;YACX;SACH,EACD,EAAE;IAGN,qBAAO,oBAACnB;QAAUa,OAAOA;QAAOO,UAAUC,QAAQC,IAAI;;AAC1D,EAAE"}

package/src/types.d.ts

@@ -54,27 +54,14 @@ export interface FunctionDescription {
     hasSelf: boolean;
     docs: string;
 }
-export interface ConstantDescription {
-    name: string;
-    docs: string;
-    values: {
-        name: string;
-        value: number;
-        docs: string;
-    }[];
-}
-export interface PlaydateNamespace {
+export interface ApiObject {
     functions: FunctionDescription[];
     methods: FunctionDescription[];
     properties: PropertyDescription[];
-}
-export interface PlaydateType {
-    methods: FunctionDescription[];
+    namespaces: Record<string, ApiObject>;
 }
 export interface ApiDefinitions {
-    rootNamespace: PlaydateNamespace;
-    namespaces: Record<string, PlaydateNamespace>;
-    types: Record<string, PlaydateType>;
+    global: ApiObject;
 }
 export interface ParameterDetails {
     name: string;

package/src/types.js.map

@@ -1 +1 @@
-{"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"}
+{"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}\nexport interface ApiObject {\n    functions: FunctionDescription[];\n    methods: FunctionDescription[];\n    properties: PropertyDescription[];\n    namespaces: Record<string, ApiObject>;\n}\n\nexport interface ApiDefinitions {\n    global: ApiObject;\n}\n\nexport interface ParameterDetails {\n    name: string;\n    type: string;\n    overrideOptions?: Partial<\n        Omit<ParameterDeclarationStructure, 'kind' | 'name' | 'type'>\n    >;\n}\n\nexport interface PropertyDetails {\n    signature: string;\n    type: string;\n    isStatic?: boolean;\n    isReadOnly?: boolean;\n}\n\nexport interface FunctionDetails {\n    signature: string;\n    parameters: ParameterDetails[];\n    returnType: string;\n    overrideParameters?: boolean;\n    overrideOptions?: Partial<\n        FunctionDeclarationStructure | MethodDeclarationStructure\n    >;\n}\n\nexport type TypeProviderData = {\n    globalStatements: string[];\n    statements: string[];\n    properties: Record<string, PropertyDetails>;\n    functions: Record<string, FunctionDetails>;\n};\n"],"names":["PlaydateSdkVersionIdentifier","HealthCheckStatusType"],"rangeMappings":";;;;;;;;;","mappings":";UAQYA;;GAAAA,iCAAAA;;UAiBAC;;;;GAAAA,0BAAAA"}

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

@@ -1,4 +0,0 @@
-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

@@ -1,27 +0,0 @@
-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
-        ],
-        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

@@ -1 +0,0 @@
-{"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        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","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;QAO5CH;IALTD,QAAQK,WAAW,CAAC;QAChBD;QACAE,MAAM;YAACP,KAAKO,IAAI;SAAC;QACjBC,YAAYN,aAAaO,qBAAqB,CAACT;QAC/CU,YAAYR,aAAaS,aAAa,CAACX;OACnC,CAACE,2CAAAA,aAAaU,0BAA0B,CACxCZ,iBADCE,2CAE0C,CAAC;IAGpD,IAAIC,YAAY;QACZF,QAAQY,oBAAoB,CAAC;YACzBC,cAAc;gBACV;oBACIT;oBACAU,OAAOf,KAAKK,IAAI;gBACpB;aACH;QACL;IACJ;AACJ,EAAE"}

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

@@ -1,4 +0,0 @@
-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, ClassDeclaration>, typeProvider: ReturnType<typeof createTypeProvider>, types: Record<string, PlaydateType>) => void;

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

@@ -1,81 +0,0 @@
-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 = 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 typeClass = subj.addClass({
-            name: interfaceName
-        });
-        typeSubjects.set(typeName, typeClass);
-        for (const func of methods){
-            const parameters = typeProvider.getParameters(func);
-            typeClass.addMethod(_extends({
-                name: func.name,
-                docs: [
-                    func.docs
-                ],
-                returnType: typeProvider.getFunctionReturnType(func),
-                parameters
-            }, typeProvider.getFunctionOverrideOptions(func)));
-        }
-    };
-    if (isRoot && 'addJsDoc' in module) {
-        module.addJsDoc({
-            description: 'Playdate SDK'
-        });
-        module.addStatements(typeProvider.getStatements());
-        Object.keys(types).forEach((eachType)=>{
-            addMethods(eachType, module, types[eachType].methods);
-        });
-    }
-    if (namespaces.length > 0) {
-        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({
-            declarationKind: VariableDeclarationKind.Const,
-            declarations: [
-                {
-                    name: property.name,
-                    type: propertyType
-                }
-            ]
-        });
-    }
-    for (const func of namespaceDescription.functions){
-        generateFunction(func, module, typeProvider);
-    }
-};
-
-//# sourceMappingURL=generateNamespace.js.map

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

@@ -1 +0,0 @@
-{"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            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","declarationKind","Const","declarations","functions"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"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"}