crankscript 0.5.1 → 0.7.0

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

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../../../libs/cli/src/commands/GenerateTypes/fn/generateNamespace.ts"],"sourcesContent":["import { ModuleDeclaration, SourceFile } from 'ts-morph';\nimport { TypescriptReservedNamed } from '@/cli/constants.js';\nimport { PlaydateNamespace } from '@/cli/types.js';\n\nexport const generateNamespace = (\n    subject: SourceFile | ModuleDeclaration,\n    namespace: string,\n    namespaceDescription: PlaydateNamespace,\n    nextNamespaces: string[]\n) => {\n    const module = subject.addModule({\n        name: namespace.trim(),\n    });\n\n    if (nextNamespaces.length) {\n        generateNamespace(\n            module,\n            nextNamespaces[0],\n            namespaceDescription,\n            nextNamespaces.slice(1)\n        );\n    } else {\n        for (const func of namespaceDescription.functions) {\n            const isReserved = TypescriptReservedNamed.includes(func.name);\n\n            const name = isReserved ? `_${func.name}` : func.name;\n\n            module.addFunction({\n                name,\n                docs: [func.docs],\n                isExported: !isReserved,\n            });\n\n            if (isReserved) {\n                module.addExportDeclaration({\n                    namedExports: [\n                        {\n                            name,\n                            alias: func.name,\n                        },\n                    ],\n                });\n            }\n        }\n    }\n};\n"],"names":["TypescriptReservedNamed","generateNamespace","subject","namespace","namespaceDescription","nextNamespaces","module","addModule","name","trim","length","slice","func","functions","isReserved","includes","addFunction","docs","isExported","addExportDeclaration","namedExports","alias"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AACA,SAASA,uBAAuB,QAAQ,qBAAqB;AAG7D,OAAO,MAAMC,oBAAoB,CAC7BC,SACAC,WACAC,sBACAC;IAEA,MAAMC,SAASJ,QAAQK,SAAS,CAAC;QAC7BC,MAAML,UAAUM,IAAI;IACxB;IAEA,IAAIJ,eAAeK,MAAM,EAAE;QACvBT,kBACIK,QACAD,cAAc,CAAC,EAAE,EACjBD,sBACAC,eAAeM,KAAK,CAAC;IAE7B,OAAO;QACH,KAAK,MAAMC,QAAQR,qBAAqBS,SAAS,CAAE;YAC/C,MAAMC,aAAad,wBAAwBe,QAAQ,CAACH,KAAKJ,IAAI;YAE7D,MAAMA,OAAOM,aAAa,CAAC,CAAC,EAAEF,KAAKJ,IAAI,CAAC,CAAC,GAAGI,KAAKJ,IAAI;YAErDF,OAAOU,WAAW,CAAC;gBACfR;gBACAS,MAAM;oBAACL,KAAKK,IAAI;iBAAC;gBACjBC,YAAY,CAACJ;YACjB;YAEA,IAAIA,YAAY;gBACZR,OAAOa,oBAAoB,CAAC;oBACxBC,cAAc;wBACV;4BACIZ;4BACAa,OAAOT,KAAKJ,IAAI;wBACpB;qBACH;gBACL;YACJ;QACJ;IACJ;AACJ,EAAE"}
+{"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"}

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

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

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

@@ -1,5 +1,4 @@
-import { playdateConstants } from '../../../commands/GenerateTypes/utils/playdateConstants.js';
-export const getApiDefinitions = (functions)=>{
+export const getApiDefinitions = (functions, properties)=>{
     const namespaces = {};
     const types = {};
     const realNamespaces = new Set();
@@ -9,17 +8,29 @@ export const getApiDefinitions = (functions)=>{
             let currentNamespace = '';
             func.namespaces.forEach((ns)=>{
                 currentNamespace = currentNamespace ? `${currentNamespace}.${ns}` : ns;
-                // Add to realNamespaces because there's a non-method function here
-                realNamespaces.add(currentNamespace);
+                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);
+            }
+        });
+    });
     functions.forEach((func)=>{
         if (func.hasSelf) {
             let currentNamespace = '';
             func.namespaces.forEach((ns)=>{
                 currentNamespace = currentNamespace ? `${currentNamespace}.${ns}` : ns;
-                if (!realNamespaces.has(currentNamespace)) {
+                if (!potentialNamespaces.has(currentNamespace)) {
                     potentialNamespaces.add(currentNamespace);
                 }
             });
@@ -28,14 +39,15 @@ export const getApiDefinitions = (functions)=>{
     realNamespaces.forEach((ns)=>{
         namespaces[ns] = {
             functions: [],
-            callbacks: []
+            methods: [],
+            properties: []
         };
     });
     functions.forEach((func)=>{
         const fullNamespacePath = func.namespaces.join('.');
         if (realNamespaces.has(fullNamespacePath)) {
             if (func.hasSelf) {
-                namespaces[fullNamespacePath].callbacks.push(func);
+                namespaces[fullNamespacePath].methods.push(func);
             } else {
                 namespaces[fullNamespacePath].functions.push(func);
             }
@@ -48,10 +60,15 @@ export const getApiDefinitions = (functions)=>{
             types[fullNamespacePath].methods.push(func);
         }
     });
+    properties.forEach((prop)=>{
+        const fullNamespacePath = prop.namespaces.join('.');
+        if (realNamespaces.has(fullNamespacePath)) {
+            namespaces[fullNamespacePath].properties.push(prop);
+        }
+    });
     return {
         namespaces,
-        types,
-        constants: playdateConstants
+        types
     };
 };
 

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

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../../../libs/cli/src/commands/GenerateTypes/fn/getApiDefinitions.ts"],"sourcesContent":["import { playdateConstants } from '@/cli/commands/GenerateTypes/utils/playdateConstants.js';\nimport {\n    ApiDefinitions,\n    FunctionDescription,\n    PlaydateNamespace,\n    PlaydateType,\n} from '@/cli/types.js';\n\nexport const getApiDefinitions = (functions: FunctionDescription[]) => {\n    const namespaces: Record<string, PlaydateNamespace> = {};\n    const types: Record<string, PlaydateType> = {};\n    const realNamespaces = new Set<string>();\n    const potentialNamespaces: Set<string> = new Set();\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                // Add to realNamespaces because there's a non-method function here\n                realNamespaces.add(currentNamespace);\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 (!realNamespaces.has(currentNamespace)) {\n                    potentialNamespaces.add(currentNamespace);\n                }\n            });\n        }\n    });\n\n    realNamespaces.forEach((ns) => {\n        namespaces[ns] = {\n            functions: [],\n            callbacks: [],\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].callbacks.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    return {\n        namespaces,\n        types,\n        constants: playdateConstants,\n    } satisfies ApiDefinitions;\n};\n"],"names":["playdateConstants","getApiDefinitions","functions","namespaces","types","realNamespaces","Set","potentialNamespaces","forEach","func","hasSelf","currentNamespace","ns","add","has","callbacks","fullNamespacePath","join","push","methods","constants"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAAA,SAASA,iBAAiB,QAAQ,0DAA0D;AAQ5F,OAAO,MAAMC,oBAAoB,CAACC;IAC9B,MAAMC,aAAgD,CAAC;IACvD,MAAMC,QAAsC,CAAC;IAC7C,MAAMC,iBAAiB,IAAIC;IAC3B,MAAMC,sBAAmC,IAAID;IAE7CJ,UAAUM,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,mEAAmE;gBACnEP,eAAeQ,GAAG,CAACF;YACvB;QACJ;IACJ;IAEAT,UAAUM,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,CAACP,eAAeS,GAAG,CAACH,mBAAmB;oBACvCJ,oBAAoBM,GAAG,CAACF;gBAC5B;YACJ;QACJ;IACJ;IAEAN,eAAeG,OAAO,CAAC,CAACI;QACpBT,UAAU,CAACS,GAAG,GAAG;YACbV,WAAW,EAAE;YACba,WAAW,EAAE;QACjB;IACJ;IAEAb,UAAUM,OAAO,CAAC,CAACC;QACf,MAAMO,oBAAoBP,KAAKN,UAAU,CAACc,IAAI,CAAC;QAE/C,IAAIZ,eAAeS,GAAG,CAACE,oBAAoB;YACvC,IAAIP,KAAKC,OAAO,EAAE;gBACdP,UAAU,CAACa,kBAAkB,CAACD,SAAS,CAACG,IAAI,CAACT;YACjD,OAAO;gBACHN,UAAU,CAACa,kBAAkB,CAACd,SAAS,CAACgB,IAAI,CAACT;YACjD;QACJ,OAAO,IAAIF,oBAAoBO,GAAG,CAACE,oBAAoB;YACnD,IAAI,CAACZ,KAAK,CAACY,kBAAkB,EAAE;gBAC3BZ,KAAK,CAACY,kBAAkB,GAAG;oBAAEG,SAAS,EAAE;gBAAC;YAC7C;YACAf,KAAK,CAACY,kBAAkB,CAACG,OAAO,CAACD,IAAI,CAACT;QAC1C;IACJ;IAEA,OAAO;QACHN;QACAC;QACAgB,WAAWpB;IACf;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 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"}

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

@@ -0,0 +1,5 @@
+import { FunctionDescription, PropertyDescription } from '../../../types.js';
+export declare const getDescriptionsFromHtml: (html: string, version: string) => {
+    functions: FunctionDescription[];
+    properties: PropertyDescription[];
+};

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

@@ -0,0 +1,75 @@
+import { _ as _extends } from "@swc/helpers/_/_extends";
+import { load } from 'cheerio';
+import { PlaydateSdkUrl } from '../../../commands/GenerateTypes/constants.js';
+import { parseFunctionSignature } from '../../../commands/GenerateTypes/fn/parseFunctionSignature.js';
+const extractFunctionCalls = (input)=>{
+    const functionCallRegex = /([a-zA-Z_]\w*(\.[a-zA-Z_]\w*)*(?::[a-zA-Z_]\w*)?)\s*(\([^)]*\))?/g;
+    const matches = [];
+    let match;
+    while((match = functionCallRegex.exec(input)) !== null){
+        matches.push(match[0].trim());
+    }
+    return matches;
+};
+const normalizeSignature = (signature)=>{
+    const closingParenIndex = signature.indexOf(')');
+    return closingParenIndex !== -1 ? signature.slice(0, closingParenIndex + 1) : signature;
+};
+export const getDescriptionsFromHtml = (html, version)=>{
+    const $ = load(html);
+    const functionSignatures = $('[id^="m-"], [id^="f-"], [id^="c-"], [id^="v-"]').toArray();
+    const functions = [];
+    const properties = [];
+    const visitedSignatures = [];
+    for (const element of functionSignatures){
+        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)) {
+            continue;
+        }
+        const titles = isProperty ? titleText.split('  ') : extractFunctionCalls(titleText);
+        var _$_find_html;
+        let docsString = ((_$_find_html = $(element).find('.content').html()) != null ? _$_find_html : '').trim();
+        if (docsString.startsWith('<div class="paragraph">')) {
+            docsString = docsString.slice('<div class="paragraph">'.length);
+        }
+        if (docsString.endsWith('</div>')) {
+            docsString = docsString.slice(0, docsString.length - '</div>'.length);
+        }
+        docsString = docsString.replace(/<a href="#/g, '<a href="' + PlaydateSdkUrl + version + '#');
+        const baseDocs = id ? `${docsString}\n[Read more](${PlaydateSdkUrl}${version}#${id})` : docsString;
+        for (const title of titles){
+            const signature = normalizeSignature(title);
+            if (visitedSignatures.includes(signature)) {
+                continue;
+            }
+            visitedSignatures.push(signature);
+            if (isProperty) {
+                properties.push({
+                    name: title.split('.').slice(-1)[0],
+                    namespaces: signature.split('.').slice(0, -1),
+                    signature,
+                    docs: baseDocs
+                });
+            } else {
+                try {
+                    const description = parseFunctionSignature(signature);
+                    const docs = description.hasSelf ? baseDocs : `${baseDocs}\n\n@noSelf`;
+                    functions.push(_extends({}, description, {
+                        docs
+                    }));
+                } catch (e) {
+                // Ignore
+                }
+            }
+        }
+    }
+    return {
+        functions,
+        properties
+    };
+};
+
+//# sourceMappingURL=getDescriptionsFromHtml.js.map

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

@@ -0,0 +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"}

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

@@ -1,9 +1,9 @@
 export declare const parseFunctionSignature: (signature: string) => {
+    signature: string;
     name: string;
     namespaces: string[];
     parameters: {
         name: string;
-        type: string;
         required: boolean;
     }[];
     hasSelf: boolean;

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

@@ -1,8 +1,6 @@
 export const parseFunctionSignature = (signature)=>{
-    if (!signature.includes('(')) {
-        throw new Error('Invalid signature');
-    }
-    const [fullyQualifiedName, paramString] = signature.split('(');
+    const normalizedSignature = signature.includes('(') ? signature : signature + '()';
+    const [fullyQualifiedName, paramString] = normalizedSignature.split('(');
     const hasSelf = fullyQualifiedName.includes(':');
     const normalizedFullyQualifiedName = fullyQualifiedName.replace(':', '.');
     const segments = normalizedFullyQualifiedName.split('.');
@@ -10,11 +8,11 @@ export const parseFunctionSignature = (signature)=>{
     const namespaces = segments.slice(0, -1);
     const params = paramString.split(')')[0].split(',').filter(Boolean);
     return {
+        signature,
         name: functionName,
         namespaces,
         parameters: params.map((eachParam)=>({
-                name: eachParam.replace(/\[/g, '').replace(/\]/g, '').trim(),
-                type: 'unknown',
+                name: eachParam.replace(/\[/g, '').replace(/]/g, '').trim(),
                 required: !eachParam.includes('[')
             })),
         hasSelf

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

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../../../libs/cli/src/commands/GenerateTypes/fn/parseFunctionSignature.ts"],"sourcesContent":["import { FunctionDescription } from '@/cli/types.js';\n\nexport const parseFunctionSignature = (signature: string) => {\n    if (!signature.includes('(')) {\n        throw new Error('Invalid signature');\n    }\n\n    const [fullyQualifiedName, paramString] = signature.split('(');\n    const hasSelf = fullyQualifiedName.includes(':');\n    const normalizedFullyQualifiedName = fullyQualifiedName.replace(':', '.');\n    const segments = normalizedFullyQualifiedName.split('.');\n    const functionName = segments[segments.length - 1];\n    const namespaces = segments.slice(0, -1);\n    const params = paramString.split(')')[0].split(',').filter(Boolean);\n\n    return {\n        name: functionName,\n        namespaces,\n        parameters: params.map((eachParam) => ({\n            name: eachParam.replace(/\\[/g, '').replace(/\\]/g, '').trim(),\n            type: 'unknown',\n            required: !eachParam.includes('['),\n        })),\n        hasSelf,\n    } satisfies Omit<FunctionDescription, 'docs'>;\n};\n"],"names":["parseFunctionSignature","signature","includes","Error","fullyQualifiedName","paramString","split","hasSelf","normalizedFullyQualifiedName","replace","segments","functionName","length","namespaces","slice","params","filter","Boolean","name","parameters","map","eachParam","trim","type","required"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;","mappings":"AAEA,OAAO,MAAMA,yBAAyB,CAACC;IACnC,IAAI,CAACA,UAAUC,QAAQ,CAAC,MAAM;QAC1B,MAAM,IAAIC,MAAM;IACpB;IAEA,MAAM,CAACC,oBAAoBC,YAAY,GAAGJ,UAAUK,KAAK,CAAC;IAC1D,MAAMC,UAAUH,mBAAmBF,QAAQ,CAAC;IAC5C,MAAMM,+BAA+BJ,mBAAmBK,OAAO,CAAC,KAAK;IACrE,MAAMC,WAAWF,6BAA6BF,KAAK,CAAC;IACpD,MAAMK,eAAeD,QAAQ,CAACA,SAASE,MAAM,GAAG,EAAE;IAClD,MAAMC,aAAaH,SAASI,KAAK,CAAC,GAAG,CAAC;IACtC,MAAMC,SAASV,YAAYC,KAAK,CAAC,IAAI,CAAC,EAAE,CAACA,KAAK,CAAC,KAAKU,MAAM,CAACC;IAE3D,OAAO;QACHC,MAAMP;QACNE;QACAM,YAAYJ,OAAOK,GAAG,CAAC,CAACC,YAAe,CAAA;gBACnCH,MAAMG,UAAUZ,OAAO,CAAC,OAAO,IAAIA,OAAO,CAAC,OAAO,IAAIa,IAAI;gBAC1DC,MAAM;gBACNC,UAAU,CAACH,UAAUnB,QAAQ,CAAC;YAClC,CAAA;QACAK;IACJ;AACJ,EAAE"}
+{"version":3,"sources":["../../../../../../../libs/cli/src/commands/GenerateTypes/fn/parseFunctionSignature.ts"],"sourcesContent":["import { FunctionDescription } from '@/cli/types.js';\n\nexport const parseFunctionSignature = (signature: string) => {\n    const normalizedSignature = signature.includes('(')\n        ? signature\n        : signature + '()';\n\n    const [fullyQualifiedName, paramString] = normalizedSignature.split('(');\n    const hasSelf = fullyQualifiedName.includes(':');\n    const normalizedFullyQualifiedName = fullyQualifiedName.replace(':', '.');\n    const segments = normalizedFullyQualifiedName.split('.');\n    const functionName = segments[segments.length - 1];\n    const namespaces = segments.slice(0, -1);\n    const params = paramString.split(')')[0].split(',').filter(Boolean);\n\n    return {\n        signature,\n        name: functionName,\n        namespaces,\n        parameters: params.map((eachParam) => ({\n            name: eachParam.replace(/\\[/g, '').replace(/]/g, '').trim(),\n            required: !eachParam.includes('['),\n        })),\n        hasSelf,\n    } satisfies Omit<FunctionDescription, 'docs'>;\n};\n"],"names":["parseFunctionSignature","signature","normalizedSignature","includes","fullyQualifiedName","paramString","split","hasSelf","normalizedFullyQualifiedName","replace","segments","functionName","length","namespaces","slice","params","filter","Boolean","name","parameters","map","eachParam","trim","required"],"rangeMappings":";;;;;;;;;;;;;;;;;;;","mappings":"AAEA,OAAO,MAAMA,yBAAyB,CAACC;IACnC,MAAMC,sBAAsBD,UAAUE,QAAQ,CAAC,OACzCF,YACAA,YAAY;IAElB,MAAM,CAACG,oBAAoBC,YAAY,GAAGH,oBAAoBI,KAAK,CAAC;IACpE,MAAMC,UAAUH,mBAAmBD,QAAQ,CAAC;IAC5C,MAAMK,+BAA+BJ,mBAAmBK,OAAO,CAAC,KAAK;IACrE,MAAMC,WAAWF,6BAA6BF,KAAK,CAAC;IACpD,MAAMK,eAAeD,QAAQ,CAACA,SAASE,MAAM,GAAG,EAAE;IAClD,MAAMC,aAAaH,SAASI,KAAK,CAAC,GAAG,CAAC;IACtC,MAAMC,SAASV,YAAYC,KAAK,CAAC,IAAI,CAAC,EAAE,CAACA,KAAK,CAAC,KAAKU,MAAM,CAACC;IAE3D,OAAO;QACHhB;QACAiB,MAAMP;QACNE;QACAM,YAAYJ,OAAOK,GAAG,CAAC,CAACC,YAAe,CAAA;gBACnCH,MAAMG,UAAUZ,OAAO,CAAC,OAAO,IAAIA,OAAO,CAAC,MAAM,IAAIa,IAAI;gBACzDC,UAAU,CAACF,UAAUlB,QAAQ,CAAC;YAClC,CAAA;QACAI;IACJ;AACJ,EAAE"}

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

@@ -1,5 +1,6 @@
+import { createTypeProvider } from '../../../commands/GenerateTypes/utils/createTypeProvider.js';
 import { ApiDefinitions } from '../../../types.js';
-export declare const useGenerateTypeFile: (path: string, definitions: ApiDefinitions | null) => {
+export declare const useGenerateTypeFile: (path: string, definitions: ApiDefinitions | null, typeProvider: ReturnType<typeof createTypeProvider> | null) => {
     generateTypeFile: {
         waitingDescription: string;
         errorDescription: string;

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

@@ -1,7 +1,8 @@
+import { writeFileSync } from 'node:fs';
 import { useMemo } from 'react';
 import { Project } from 'ts-morph';
 import { generateNamespace } from '../../../commands/GenerateTypes/fn/generateNamespace.js';
-export const useGenerateTypeFile = (path, definitions)=>{
+export const useGenerateTypeFile = (path, definitions, typeProvider)=>{
     const generateTypeFile = useMemo(()=>{
         return {
             waitingDescription: 'Waiting to generate the type file...',
@@ -12,39 +13,29 @@ export const useGenerateTypeFile = (path, definitions)=>{
                 if (!definitions) {
                     throw new Error('Definitions are not set');
                 }
+                if (!typeProvider) {
+                    throw new Error('Type provider is not set');
+                }
                 const project = new Project();
                 const typeFile = project.createSourceFile(path, '', {
                     overwrite: true
                 });
-                typeFile.addStatements('/// <reference types="lua-types/5.4" />');
-                for (const constantDefinition of definitions.constants){
-                    typeFile.addEnum({
-                        name: constantDefinition.name,
-                        docs: [
-                            constantDefinition.docs
-                        ],
-                        isConst: true,
-                        isExported: true,
-                        members: constantDefinition.values.map((value)=>({
-                                name: value.name,
-                                docs: [
-                                    value.docs
-                                ],
-                                value: value.value
-                            }))
-                    });
-                }
+                typeFile.addStatements(typeProvider.getGlobalStatements());
+                const subjects = new Map();
+                const typeSubjects = new Map();
+                subjects.set('root', typeFile);
                 Object.keys(definitions.namespaces).forEach((namespace)=>{
                     const namespaceDescription = definitions.namespaces[namespace];
                     const namespaces = namespace.split('.');
-                    generateNamespace(typeFile, namespaces[0], namespaceDescription, namespaces.slice(1));
+                    generateNamespace(namespaceDescription, namespaces, subjects, typeSubjects, typeProvider, definitions.types);
                 });
-                typeFile.saveSync();
+                writeFileSync(path, typeFile.getFullText().replace('/** Playdate SDK */', '\n/** Playdate SDK */'));
             },
-            ready: definitions !== null
+            ready: definitions !== null && typeProvider !== null
         };
     }, [
-        definitions
+        definitions,
+        typeProvider
     ]);
     return {
         generateTypeFile

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

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../../../libs/cli/src/commands/GenerateTypes/hooks/useGenerateTypeFile.ts"],"sourcesContent":["import { useMemo } from 'react';\nimport { Project } from 'ts-morph';\nimport { generateNamespace } from '@/cli/commands/GenerateTypes/fn/generateNamespace.js';\nimport { CheckListItem, ApiDefinitions } from '@/cli/types.js';\n\nexport const useGenerateTypeFile = (\n    path: string,\n    definitions: ApiDefinitions | 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                const project = new Project();\n                const typeFile = project.createSourceFile(path, '', {\n                    overwrite: true,\n                });\n\n                typeFile.addStatements(\n                    '/// <reference types=\"lua-types/5.4\" />'\n                );\n\n                for (const constantDefinition of definitions.constants) {\n                    typeFile.addEnum({\n                        name: constantDefinition.name,\n                        docs: [constantDefinition.docs],\n                        isConst: true,\n                        isExported: true,\n                        members: constantDefinition.values.map((value) => ({\n                            name: value.name,\n                            docs: [value.docs],\n                            value: value.value,\n                        })),\n                    });\n                }\n\n                Object.keys(definitions.namespaces).forEach((namespace) => {\n                    const namespaceDescription =\n                        definitions.namespaces[namespace];\n                    const namespaces = namespace.split('.');\n                    generateNamespace(\n                        typeFile,\n                        namespaces[0],\n                        namespaceDescription,\n                        namespaces.slice(1)\n                    );\n                });\n\n                typeFile.saveSync();\n            },\n            ready: definitions !== null,\n        } satisfies CheckListItem<void>;\n    }, [definitions]);\n\n    return {\n        generateTypeFile,\n    };\n};\n"],"names":["useMemo","Project","generateNamespace","useGenerateTypeFile","path","definitions","generateTypeFile","waitingDescription","errorDescription","finishedDescription","runningDescription","runner","Error","project","typeFile","createSourceFile","overwrite","addStatements","constantDefinition","constants","addEnum","name","docs","isConst","isExported","members","values","map","value","Object","keys","namespaces","forEach","namespace","namespaceDescription","split","slice","saveSync","ready"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAAA,SAASA,OAAO,QAAQ,QAAQ;AAChC,SAASC,OAAO,QAAQ,WAAW;AACnC,SAASC,iBAAiB,QAAQ,uDAAuD;AAGzF,OAAO,MAAMC,sBAAsB,CAC/BC,MACAC;IAEA,MAAMC,mBAAmBN,QAAQ;QAC7B,OAAO;YACHO,oBAAoB;YACpBC,kBAAkB;YAClBC,qBAAqB,IAAM;YAC3BC,oBAAoB;YACpBC,QAAQ;gBACJ,IAAI,CAACN,aAAa;oBACd,MAAM,IAAIO,MAAM;gBACpB;gBAEA,MAAMC,UAAU,IAAIZ;gBACpB,MAAMa,WAAWD,QAAQE,gBAAgB,CAACX,MAAM,IAAI;oBAChDY,WAAW;gBACf;gBAEAF,SAASG,aAAa,CAClB;gBAGJ,KAAK,MAAMC,sBAAsBb,YAAYc,SAAS,CAAE;oBACpDL,SAASM,OAAO,CAAC;wBACbC,MAAMH,mBAAmBG,IAAI;wBAC7BC,MAAM;4BAACJ,mBAAmBI,IAAI;yBAAC;wBAC/BC,SAAS;wBACTC,YAAY;wBACZC,SAASP,mBAAmBQ,MAAM,CAACC,GAAG,CAAC,CAACC,QAAW,CAAA;gCAC/CP,MAAMO,MAAMP,IAAI;gCAChBC,MAAM;oCAACM,MAAMN,IAAI;iCAAC;gCAClBM,OAAOA,MAAMA,KAAK;4BACtB,CAAA;oBACJ;gBACJ;gBAEAC,OAAOC,IAAI,CAACzB,YAAY0B,UAAU,EAAEC,OAAO,CAAC,CAACC;oBACzC,MAAMC,uBACF7B,YAAY0B,UAAU,CAACE,UAAU;oBACrC,MAAMF,aAAaE,UAAUE,KAAK,CAAC;oBACnCjC,kBACIY,UACAiB,UAAU,CAAC,EAAE,EACbG,sBACAH,WAAWK,KAAK,CAAC;gBAEzB;gBAEAtB,SAASuB,QAAQ;YACrB;YACAC,OAAOjC,gBAAgB;QAC3B;IACJ,GAAG;QAACA;KAAY;IAEhB,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    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"}

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

@@ -9,4 +9,14 @@ export declare const useGetVersion: (version: PlaydateSdkVersion) => {
         runner: () => Promise<string>;
         onFinish: (result: string) => void;
     };
+    typeProvider: {
+        getGlobalStatements: () => string[];
+        getStatements: () => string[];
+        getPropertyDetails: (property: import("../../../types.js").PropertyDescription) => import("../../../types.js").PropertyDetails;
+        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>;
+        save: () => void;
+    } | null;
 };

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

@@ -1,7 +1,9 @@
 import { useCallback, useMemo, useState } from 'react';
 import { PlaydateSdkUrl } from '../../../commands/GenerateTypes/constants.js';
+import { createTypeProvider } from '../../../commands/GenerateTypes/utils/createTypeProvider.js';
 import { PlaydateSdkVersionIdentifier } from '../../../types.js';
 export const useGetVersion = (version)=>{
+    const [typeProvider, setTypeProvider] = useState(null);
     const [result, setResult] = useState(null);
     const fetchLastVersion = useCallback(async ()=>{
         const response = await fetch(PlaydateSdkUrl);
@@ -32,6 +34,7 @@ export const useGetVersion = (version)=>{
                     versionLiteral = await fetchLastVersion();
                 }
                 await validateVersion(versionLiteral);
+                setTypeProvider(createTypeProvider(versionLiteral));
                 return versionLiteral;
             },
             onFinish: (result)=>{
@@ -41,7 +44,8 @@ export const useGetVersion = (version)=>{
     }, []);
     return {
         fetchedVersion: result,
-        getVersion
+        getVersion,
+        typeProvider
     };
 };
 

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

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../../../libs/cli/src/commands/GenerateTypes/hooks/useGetVersion.ts"],"sourcesContent":["import { useCallback, useMemo, useState } from 'react';\nimport { PlaydateSdkUrl } from '@/cli/commands/GenerateTypes/constants.js';\nimport {\n    CheckListItem,\n    PlaydateSdkVersion,\n    PlaydateSdkVersionIdentifier,\n} from '@/cli/types.js';\n\nexport const useGetVersion = (version: PlaydateSdkVersion) => {\n    const [result, setResult] = useState<string | null>(null);\n    const fetchLastVersion = useCallback(async () => {\n        const response = await fetch(PlaydateSdkUrl);\n        const url = response.url;\n\n        const regex = /https:\\/\\/sdk.play.date\\/([0-9]+\\.[0-9]+\\.[0-9]+)\\//;\n        const match = url.match(regex);\n\n        if (!match || match.length < 2) {\n            throw new Error('Could not find version in URL');\n        }\n\n        return match[1];\n    }, []);\n    const validateVersion = useCallback(async (version: string) => {\n        const response = await fetch(`https://sdk.play.date/${version}/`);\n\n        if (!response.ok) {\n            throw new Error(`Failed to fetch version ${version}`);\n        }\n\n        return true;\n    }, []);\n\n    const getVersion = useMemo(() => {\n        return {\n            waitingDescription: `Waiting to fetch version`,\n            runningDescription: 'Fetching version...',\n            errorDescription: 'Failed to fetch version',\n            finishedDescription: (result) => `Fetched version ${result}`,\n            runner: async () => {\n                let versionLiteral = version;\n\n                if (version === PlaydateSdkVersionIdentifier.Latest) {\n                    versionLiteral = await fetchLastVersion();\n                }\n\n                await validateVersion(versionLiteral);\n\n                return versionLiteral;\n            },\n            onFinish: (result) => {\n                setResult(result);\n            },\n        } satisfies CheckListItem<string>;\n    }, []);\n\n    return {\n        fetchedVersion: result,\n        getVersion,\n    };\n};\n"],"names":["useCallback","useMemo","useState","PlaydateSdkUrl","PlaydateSdkVersionIdentifier","useGetVersion","version","result","setResult","fetchLastVersion","response","fetch","url","regex","match","length","Error","validateVersion","ok","getVersion","waitingDescription","runningDescription","errorDescription","finishedDescription","runner","versionLiteral","Latest","onFinish","fetchedVersion"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAAA,SAASA,WAAW,EAAEC,OAAO,EAAEC,QAAQ,QAAQ,QAAQ;AACvD,SAASC,cAAc,QAAQ,4CAA4C;AAC3E,SAGIC,4BAA4B,QACzB,iBAAiB;AAExB,OAAO,MAAMC,gBAAgB,CAACC;IAC1B,MAAM,CAACC,QAAQC,UAAU,GAAGN,SAAwB;IACpD,MAAMO,mBAAmBT,YAAY;QACjC,MAAMU,WAAW,MAAMC,MAAMR;QAC7B,MAAMS,MAAMF,SAASE,GAAG;QAExB,MAAMC,QAAQ;QACd,MAAMC,QAAQF,IAAIE,KAAK,CAACD;QAExB,IAAI,CAACC,SAASA,MAAMC,MAAM,GAAG,GAAG;YAC5B,MAAM,IAAIC,MAAM;QACpB;QAEA,OAAOF,KAAK,CAAC,EAAE;IACnB,GAAG,EAAE;IACL,MAAMG,kBAAkBjB,YAAY,OAAOM;QACvC,MAAMI,WAAW,MAAMC,MAAM,CAAC,sBAAsB,EAAEL,QAAQ,CAAC,CAAC;QAEhE,IAAI,CAACI,SAASQ,EAAE,EAAE;YACd,MAAM,IAAIF,MAAM,CAAC,wBAAwB,EAAEV,QAAQ,CAAC;QACxD;QAEA,OAAO;IACX,GAAG,EAAE;IAEL,MAAMa,aAAalB,QAAQ;QACvB,OAAO;YACHmB,oBAAoB,CAAC,wBAAwB,CAAC;YAC9CC,oBAAoB;YACpBC,kBAAkB;YAClBC,qBAAqB,CAAChB,SAAW,CAAC,gBAAgB,EAAEA,OAAO,CAAC;YAC5DiB,QAAQ;gBACJ,IAAIC,iBAAiBnB;gBAErB,IAAIA,YAAYF,6BAA6BsB,MAAM,EAAE;oBACjDD,iBAAiB,MAAMhB;gBAC3B;gBAEA,MAAMQ,gBAAgBQ;gBAEtB,OAAOA;YACX;YACAE,UAAU,CAACpB;gBACPC,UAAUD;YACd;QACJ;IACJ,GAAG,EAAE;IAEL,OAAO;QACHqB,gBAAgBrB;QAChBY;IACJ;AACJ,EAAE"}
+{"version":3,"sources":["../../../../../../../libs/cli/src/commands/GenerateTypes/hooks/useGetVersion.ts"],"sourcesContent":["import { useCallback, useMemo, useState } from 'react';\nimport { PlaydateSdkUrl } from '@/cli/commands/GenerateTypes/constants.js';\nimport { createTypeProvider } from '@/cli/commands/GenerateTypes/utils/createTypeProvider.js';\nimport {\n    CheckListItem,\n    PlaydateSdkVersion,\n    PlaydateSdkVersionIdentifier,\n} from '@/cli/types.js';\n\nexport const useGetVersion = (version: PlaydateSdkVersion) => {\n    const [typeProvider, setTypeProvider] = useState<ReturnType<\n        typeof createTypeProvider\n    > | null>(null);\n    const [result, setResult] = useState<string | null>(null);\n    const fetchLastVersion = useCallback(async () => {\n        const response = await fetch(PlaydateSdkUrl);\n        const url = response.url;\n\n        const regex = /https:\\/\\/sdk.play.date\\/([0-9]+\\.[0-9]+\\.[0-9]+)\\//;\n        const match = url.match(regex);\n\n        if (!match || match.length < 2) {\n            throw new Error('Could not find version in URL');\n        }\n\n        return match[1];\n    }, []);\n    const validateVersion = useCallback(async (version: string) => {\n        const response = await fetch(`https://sdk.play.date/${version}/`);\n\n        if (!response.ok) {\n            throw new Error(`Failed to fetch version ${version}`);\n        }\n\n        return true;\n    }, []);\n\n    const getVersion = useMemo(() => {\n        return {\n            waitingDescription: `Waiting to fetch version`,\n            runningDescription: 'Fetching version...',\n            errorDescription: 'Failed to fetch version',\n            finishedDescription: (result) => `Fetched version ${result}`,\n            runner: async () => {\n                let versionLiteral = version;\n\n                if (version === PlaydateSdkVersionIdentifier.Latest) {\n                    versionLiteral = await fetchLastVersion();\n                }\n\n                await validateVersion(versionLiteral);\n\n                setTypeProvider(createTypeProvider(versionLiteral));\n\n                return versionLiteral;\n            },\n            onFinish: (result) => {\n                setResult(result);\n            },\n        } satisfies CheckListItem<string>;\n    }, []);\n\n    return {\n        fetchedVersion: result,\n        getVersion,\n        typeProvider,\n    };\n};\n"],"names":["useCallback","useMemo","useState","PlaydateSdkUrl","createTypeProvider","PlaydateSdkVersionIdentifier","useGetVersion","version","typeProvider","setTypeProvider","result","setResult","fetchLastVersion","response","fetch","url","regex","match","length","Error","validateVersion","ok","getVersion","waitingDescription","runningDescription","errorDescription","finishedDescription","runner","versionLiteral","Latest","onFinish","fetchedVersion"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAAA,SAASA,WAAW,EAAEC,OAAO,EAAEC,QAAQ,QAAQ,QAAQ;AACvD,SAASC,cAAc,QAAQ,4CAA4C;AAC3E,SAASC,kBAAkB,QAAQ,2DAA2D;AAC9F,SAGIC,4BAA4B,QACzB,iBAAiB;AAExB,OAAO,MAAMC,gBAAgB,CAACC;IAC1B,MAAM,CAACC,cAAcC,gBAAgB,GAAGP,SAE9B;IACV,MAAM,CAACQ,QAAQC,UAAU,GAAGT,SAAwB;IACpD,MAAMU,mBAAmBZ,YAAY;QACjC,MAAMa,WAAW,MAAMC,MAAMX;QAC7B,MAAMY,MAAMF,SAASE,GAAG;QAExB,MAAMC,QAAQ;QACd,MAAMC,QAAQF,IAAIE,KAAK,CAACD;QAExB,IAAI,CAACC,SAASA,MAAMC,MAAM,GAAG,GAAG;YAC5B,MAAM,IAAIC,MAAM;QACpB;QAEA,OAAOF,KAAK,CAAC,EAAE;IACnB,GAAG,EAAE;IACL,MAAMG,kBAAkBpB,YAAY,OAAOO;QACvC,MAAMM,WAAW,MAAMC,MAAM,CAAC,sBAAsB,EAAEP,QAAQ,CAAC,CAAC;QAEhE,IAAI,CAACM,SAASQ,EAAE,EAAE;YACd,MAAM,IAAIF,MAAM,CAAC,wBAAwB,EAAEZ,QAAQ,CAAC;QACxD;QAEA,OAAO;IACX,GAAG,EAAE;IAEL,MAAMe,aAAarB,QAAQ;QACvB,OAAO;YACHsB,oBAAoB,CAAC,wBAAwB,CAAC;YAC9CC,oBAAoB;YACpBC,kBAAkB;YAClBC,qBAAqB,CAAChB,SAAW,CAAC,gBAAgB,EAAEA,OAAO,CAAC;YAC5DiB,QAAQ;gBACJ,IAAIC,iBAAiBrB;gBAErB,IAAIA,YAAYF,6BAA6BwB,MAAM,EAAE;oBACjDD,iBAAiB,MAAMhB;gBAC3B;gBAEA,MAAMQ,gBAAgBQ;gBAEtBnB,gBAAgBL,mBAAmBwB;gBAEnC,OAAOA;YACX;YACAE,UAAU,CAACpB;gBACPC,UAAUD;YACd;QACJ;IACJ,GAAG,EAAE;IAEL,OAAO;QACHqB,gBAAgBrB;QAChBY;QACAd;IACJ;AACJ,EAAE"}

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

@@ -9,15 +9,6 @@ export declare const useParseDocumentation: (html: string | null, version: strin
         runner: () => Promise<{
             namespaces: Record<string, import("../../../types.js").PlaydateNamespace>;
             types: Record<string, import("../../../types.js").PlaydateType>;
-            constants: {
-                name: string;
-                values: {
-                    name: string;
-                    value: number;
-                    docs: string;
-                }[];
-                docs: string;
-            }[];
         }>;
         onFinish: (result: ApiDefinitions) => void;
         ready: boolean;

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

@@ -1,6 +1,6 @@
 import { useMemo, useState } from 'react';
 import { getApiDefinitions } from '../../../commands/GenerateTypes/fn/getApiDefinitions.js';
-import { getFunctionDescriptionsFromHtml } from '../../../commands/GenerateTypes/fn/getFunctionDescriptionsFromHtml.js';
+import { getDescriptionsFromHtml } from '../../../commands/GenerateTypes/fn/getDescriptionsFromHtml.js';
 export const useParseDocumentation = (html, version)=>{
     const [result, setResult] = useState(null);
     const parseDocumentation = useMemo(()=>{
@@ -13,8 +13,8 @@ export const useParseDocumentation = (html, version)=>{
                 if (!html) {
                     throw new Error('HTML is not set');
                 }
-                const functions = getFunctionDescriptionsFromHtml(html, version);
-                return getApiDefinitions(functions);
+                const { functions, properties } = getDescriptionsFromHtml(html, version);
+                return getApiDefinitions(functions, properties);
             },
             onFinish: (result)=>{
                 setResult(result);

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

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../../../libs/cli/src/commands/GenerateTypes/hooks/useParseDocumentation.ts"],"sourcesContent":["import { useMemo, useState } from 'react';\nimport { getApiDefinitions } from '@/cli/commands/GenerateTypes/fn/getApiDefinitions.js';\nimport { getFunctionDescriptionsFromHtml } from '@/cli/commands/GenerateTypes/fn/getFunctionDescriptionsFromHtml.js';\nimport { CheckListItem, ApiDefinitions } from '@/cli/types.js';\n\nexport const useParseDocumentation = (html: string | null, version: string) => {\n    const [result, setResult] = useState<ApiDefinitions | null>(null);\n\n    const parseDocumentation = useMemo(() => {\n        return {\n            waitingDescription: 'Waiting to parse the documentation...',\n            errorDescription: 'Failed to parse the documentation',\n            finishedDescription: () => 'Documentation parsed',\n            runningDescription: 'Parsing the documentation...',\n            runner: async () => {\n                if (!html) {\n                    throw new Error('HTML is not set');\n                }\n\n                const functions = getFunctionDescriptionsFromHtml(\n                    html,\n                    version\n                );\n\n                return getApiDefinitions(functions);\n            },\n            onFinish: (result) => {\n                setResult(result);\n            },\n            ready: html !== null,\n        } satisfies CheckListItem<ApiDefinitions>;\n    }, [html]);\n\n    return {\n        definitions: result,\n        parseDocumentation,\n    };\n};\n"],"names":["useMemo","useState","getApiDefinitions","getFunctionDescriptionsFromHtml","useParseDocumentation","html","version","result","setResult","parseDocumentation","waitingDescription","errorDescription","finishedDescription","runningDescription","runner","Error","functions","onFinish","ready","definitions"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAAA,SAASA,OAAO,EAAEC,QAAQ,QAAQ,QAAQ;AAC1C,SAASC,iBAAiB,QAAQ,uDAAuD;AACzF,SAASC,+BAA+B,QAAQ,qEAAqE;AAGrH,OAAO,MAAMC,wBAAwB,CAACC,MAAqBC;IACvD,MAAM,CAACC,QAAQC,UAAU,GAAGP,SAAgC;IAE5D,MAAMQ,qBAAqBT,QAAQ;QAC/B,OAAO;YACHU,oBAAoB;YACpBC,kBAAkB;YAClBC,qBAAqB,IAAM;YAC3BC,oBAAoB;YACpBC,QAAQ;gBACJ,IAAI,CAACT,MAAM;oBACP,MAAM,IAAIU,MAAM;gBACpB;gBAEA,MAAMC,YAAYb,gCACdE,MACAC;gBAGJ,OAAOJ,kBAAkBc;YAC7B;YACAC,UAAU,CAACV;gBACPC,UAAUD;YACd;YACAW,OAAOb,SAAS;QACpB;IACJ,GAAG;QAACA;KAAK;IAET,OAAO;QACHc,aAAaZ;QACbE;IACJ;AACJ,EAAE"}
+{"version":3,"sources":["../../../../../../../libs/cli/src/commands/GenerateTypes/hooks/useParseDocumentation.ts"],"sourcesContent":["import { useMemo, useState } from 'react';\nimport { getApiDefinitions } from '@/cli/commands/GenerateTypes/fn/getApiDefinitions.js';\nimport { getDescriptionsFromHtml } from '@/cli/commands/GenerateTypes/fn/getDescriptionsFromHtml.js';\nimport { CheckListItem, ApiDefinitions } from '@/cli/types.js';\n\nexport const useParseDocumentation = (html: string | null, version: string) => {\n    const [result, setResult] = useState<ApiDefinitions | null>(null);\n\n    const parseDocumentation = useMemo(() => {\n        return {\n            waitingDescription: 'Waiting to parse the documentation...',\n            errorDescription: 'Failed to parse the documentation',\n            finishedDescription: () => 'Documentation parsed',\n            runningDescription: 'Parsing the documentation...',\n            runner: async () => {\n                if (!html) {\n                    throw new Error('HTML is not set');\n                }\n\n                const { functions, properties } = getDescriptionsFromHtml(\n                    html,\n                    version\n                );\n\n                return getApiDefinitions(functions, properties);\n            },\n            onFinish: (result) => {\n                setResult(result);\n            },\n            ready: html !== null,\n        } satisfies CheckListItem<ApiDefinitions>;\n    }, [html]);\n\n    return {\n        definitions: result,\n        parseDocumentation,\n    };\n};\n"],"names":["useMemo","useState","getApiDefinitions","getDescriptionsFromHtml","useParseDocumentation","html","version","result","setResult","parseDocumentation","waitingDescription","errorDescription","finishedDescription","runningDescription","runner","Error","functions","properties","onFinish","ready","definitions"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAAA,SAASA,OAAO,EAAEC,QAAQ,QAAQ,QAAQ;AAC1C,SAASC,iBAAiB,QAAQ,uDAAuD;AACzF,SAASC,uBAAuB,QAAQ,6DAA6D;AAGrG,OAAO,MAAMC,wBAAwB,CAACC,MAAqBC;IACvD,MAAM,CAACC,QAAQC,UAAU,GAAGP,SAAgC;IAE5D,MAAMQ,qBAAqBT,QAAQ;QAC/B,OAAO;YACHU,oBAAoB;YACpBC,kBAAkB;YAClBC,qBAAqB,IAAM;YAC3BC,oBAAoB;YACpBC,QAAQ;gBACJ,IAAI,CAACT,MAAM;oBACP,MAAM,IAAIU,MAAM;gBACpB;gBAEA,MAAM,EAAEC,SAAS,EAAEC,UAAU,EAAE,GAAGd,wBAC9BE,MACAC;gBAGJ,OAAOJ,kBAAkBc,WAAWC;YACxC;YACAC,UAAU,CAACX;gBACPC,UAAUD;YACd;YACAY,OAAOd,SAAS;QACpB;IACJ,GAAG;QAACA;KAAK;IAET,OAAO;QACHe,aAAab;QACbE;IACJ;AACJ,EAAE"}

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

@@ -0,0 +1,12 @@
+import { FunctionDeclarationStructure } from 'ts-morph';
+import { FunctionDescription, ParameterDetails, PropertyDescription, PropertyDetails } from '../../../types.js';
+export declare const createTypeProvider: (version: string) => {
+    getGlobalStatements: () => string[];
+    getStatements: () => string[];
+    getPropertyDetails: (property: PropertyDescription) => PropertyDetails;
+    getFunctionReturnType: (func: FunctionDescription) => string;
+    getParameterDetails: (func: FunctionDescription, parameter: string) => ParameterDetails;
+    getParameters: (func: FunctionDescription) => FunctionDeclarationStructure["parameters"];
+    getFunctionOverrideOptions: (func: FunctionDescription) => Partial<FunctionDeclarationStructure | import("ts-morph").MethodSignatureStructure>;
+    save: () => void;
+};