crankscript 0.11.14 → 0.12.0

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "crankscript",
-    "version": "0.11.14",
+    "version": "0.12.0",
     "scripts": {
         "dev": "tsx src/index.ts",
         "post-build": "tsc-alias --project tsconfig.json"
@@ -21,8 +21,8 @@
         "ts-morph": "^23.0.0",
         "turndown": "^7.2.0",
         "typanion": "^3.14.0",
-        "typescript-to-lua": "^1.27.0",
-        "typescript": "5.7.3"
+        "typescript": "5.7.3",
+        "typescript-to-lua": "^1.27.0"
     },
     "type": "module",
     "main": "./src/index.js",

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

@@ -1,5 +1,6 @@
 import React, { useMemo } from 'react';
 import { useFetchHtml } from '../../../commands/GenerateTypes/hooks/useFetchHtml.js';
+import { useFormatTypeFile } from '../../../commands/GenerateTypes/hooks/useFormatTypeFile.js';
 import { useGenerateTypeFile } from '../../../commands/GenerateTypes/hooks/useGenerateTypeFile.js';
 import { useGetVersion } from '../../../commands/GenerateTypes/hooks/useGetVersion.js';
 import { useParseDocumentation } from '../../../commands/GenerateTypes/hooks/useParseDocumentation.js';
@@ -9,18 +10,21 @@ export const GenerateTypes = ({ output, version, overwriteJson })=>{
     const { html, fetchHtml } = useFetchHtml(fetchedVersion);
     const { definitions, parseDocumentation } = useParseDocumentation(html, version);
     const { generateTypeFile } = useGenerateTypeFile(output, definitions, typeProvider);
+    const { formatTypeFile } = useFormatTypeFile(output);
     const items = useMemo(()=>{
         return [
             getVersion,
             fetchHtml,
             parseDocumentation,
-            generateTypeFile
+            generateTypeFile,
+            formatTypeFile
         ];
     }, [
         fetchedVersion,
         html,
         definitions,
-        typeProvider
+        typeProvider,
+        formatTypeFile
     ]);
     return /*#__PURE__*/ React.createElement(CheckList, {
         items: items,

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

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../../../libs/cli/src/commands/GenerateTypes/components/GenerateTypes.tsx"],"sourcesContent":["import React, { useMemo } from 'react';\nimport { useFetchHtml } from '@/cli/commands/GenerateTypes/hooks/useFetchHtml.js';\nimport { useGenerateTypeFile } from '@/cli/commands/GenerateTypes/hooks/useGenerateTypeFile.js';\nimport { useGetVersion } from '@/cli/commands/GenerateTypes/hooks/useGetVersion.js';\nimport { useParseDocumentation } from '@/cli/commands/GenerateTypes/hooks/useParseDocumentation.js';\nimport { CheckList } from '@/cli/components/CheckList/index.js';\nimport { CheckListItem, PlaydateSdkVersion } from '@/cli/types.js';\n\ninterface Props {\n    output: string;\n    version: PlaydateSdkVersion;\n    overwriteJson: boolean;\n}\n\nexport const GenerateTypes = ({ output, version, overwriteJson }: Props) => {\n    const { typeProvider, fetchedVersion, getVersion } = useGetVersion(version);\n    const { html, fetchHtml } = useFetchHtml(fetchedVersion);\n    const { definitions, parseDocumentation } = useParseDocumentation(\n        html,\n        version,\n    );\n    const { generateTypeFile } = useGenerateTypeFile(\n        output,\n        definitions,\n        typeProvider,\n    );\n\n    const items = useMemo(() => {\n        return [\n            getVersion,\n            fetchHtml,\n            parseDocumentation,\n            generateTypeFile,\n        ] as CheckListItem<unknown>[];\n    }, [fetchedVersion, html, definitions, typeProvider]);\n\n    return (\n        <CheckList\n            items={items}\n            onFinish={() => {\n                if (overwriteJson) {\n                    typeProvider?.save();\n                }\n\n                process.exit();\n            }}\n        />\n    );\n};\n"],"names":["React","useMemo","useFetchHtml","useGenerateTypeFile","useGetVersion","useParseDocumentation","CheckList","GenerateTypes","output","version","overwriteJson","typeProvider","fetchedVersion","getVersion","html","fetchHtml","definitions","parseDocumentation","generateTypeFile","items","onFinish","save","process","exit"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAAA,OAAOA,SAASC,OAAO,QAAQ,QAAQ;AACvC,SAASC,YAAY,QAAQ,qDAAqD;AAClF,SAASC,mBAAmB,QAAQ,4DAA4D;AAChG,SAASC,aAAa,QAAQ,sDAAsD;AACpF,SAASC,qBAAqB,QAAQ,8DAA8D;AACpG,SAASC,SAAS,QAAQ,sCAAsC;AAShE,OAAO,MAAMC,gBAAgB,CAAC,EAAEC,MAAM,EAAEC,OAAO,EAAEC,aAAa,EAAS;IACnE,MAAM,EAAEC,YAAY,EAAEC,cAAc,EAAEC,UAAU,EAAE,GAAGT,cAAcK;IACnE,MAAM,EAAEK,IAAI,EAAEC,SAAS,EAAE,GAAGb,aAAaU;IACzC,MAAM,EAAEI,WAAW,EAAEC,kBAAkB,EAAE,GAAGZ,sBACxCS,MACAL;IAEJ,MAAM,EAAES,gBAAgB,EAAE,GAAGf,oBACzBK,QACAQ,aACAL;IAGJ,MAAMQ,QAAQlB,QAAQ;QAClB,OAAO;YACHY;YACAE;YACAE;YACAC;SACH;IACL,GAAG;QAACN;QAAgBE;QAAME;QAAaL;KAAa;IAEpD,qBACI,oBAACL;QACGa,OAAOA;QACPC,UAAU;YACN,IAAIV,eAAe;gBACfC,gCAAAA,aAAcU,IAAI;YACtB;YAEAC,QAAQC,IAAI;QAChB;;AAGZ,EAAE"}
+{"version":3,"sources":["../../../../../../../libs/cli/src/commands/GenerateTypes/components/GenerateTypes.tsx"],"sourcesContent":["import React, { useMemo } from 'react';\nimport { useFetchHtml } from '@/cli/commands/GenerateTypes/hooks/useFetchHtml.js';\nimport { useFormatTypeFile } from '@/cli/commands/GenerateTypes/hooks/useFormatTypeFile.js';\nimport { useGenerateTypeFile } from '@/cli/commands/GenerateTypes/hooks/useGenerateTypeFile.js';\nimport { useGetVersion } from '@/cli/commands/GenerateTypes/hooks/useGetVersion.js';\nimport { useParseDocumentation } from '@/cli/commands/GenerateTypes/hooks/useParseDocumentation.js';\nimport { CheckList } from '@/cli/components/CheckList/index.js';\nimport { CheckListItem, PlaydateSdkVersion } from '@/cli/types.js';\n\ninterface Props {\n    output: string;\n    version: PlaydateSdkVersion;\n    overwriteJson: boolean;\n}\n\nexport const GenerateTypes = ({ output, version, overwriteJson }: Props) => {\n    const { typeProvider, fetchedVersion, getVersion } = useGetVersion(version);\n    const { html, fetchHtml } = useFetchHtml(fetchedVersion);\n    const { definitions, parseDocumentation } = useParseDocumentation(\n        html,\n        version,\n    );\n    const { generateTypeFile } = useGenerateTypeFile(\n        output,\n        definitions,\n        typeProvider,\n    );\n    const { formatTypeFile } = useFormatTypeFile(output);\n\n    const items = useMemo(() => {\n        return [\n            getVersion,\n            fetchHtml,\n            parseDocumentation,\n            generateTypeFile,\n            formatTypeFile,\n        ] as CheckListItem<unknown>[];\n    }, [fetchedVersion, html, definitions, typeProvider, formatTypeFile]);\n\n    return (\n        <CheckList\n            items={items}\n            onFinish={() => {\n                if (overwriteJson) {\n                    typeProvider?.save();\n                }\n\n                process.exit();\n            }}\n        />\n    );\n};\n"],"names":["React","useMemo","useFetchHtml","useFormatTypeFile","useGenerateTypeFile","useGetVersion","useParseDocumentation","CheckList","GenerateTypes","output","version","overwriteJson","typeProvider","fetchedVersion","getVersion","html","fetchHtml","definitions","parseDocumentation","generateTypeFile","formatTypeFile","items","onFinish","save","process","exit"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAAA,OAAOA,SAASC,OAAO,QAAQ,QAAQ;AACvC,SAASC,YAAY,QAAQ,qDAAqD;AAClF,SAASC,iBAAiB,QAAQ,0DAA0D;AAC5F,SAASC,mBAAmB,QAAQ,4DAA4D;AAChG,SAASC,aAAa,QAAQ,sDAAsD;AACpF,SAASC,qBAAqB,QAAQ,8DAA8D;AACpG,SAASC,SAAS,QAAQ,sCAAsC;AAShE,OAAO,MAAMC,gBAAgB,CAAC,EAAEC,MAAM,EAAEC,OAAO,EAAEC,aAAa,EAAS;IACnE,MAAM,EAAEC,YAAY,EAAEC,cAAc,EAAEC,UAAU,EAAE,GAAGT,cAAcK;IACnE,MAAM,EAAEK,IAAI,EAAEC,SAAS,EAAE,GAAGd,aAAaW;IACzC,MAAM,EAAEI,WAAW,EAAEC,kBAAkB,EAAE,GAAGZ,sBACxCS,MACAL;IAEJ,MAAM,EAAES,gBAAgB,EAAE,GAAGf,oBACzBK,QACAQ,aACAL;IAEJ,MAAM,EAAEQ,cAAc,EAAE,GAAGjB,kBAAkBM;IAE7C,MAAMY,QAAQpB,QAAQ;QAClB,OAAO;YACHa;YACAE;YACAE;YACAC;YACAC;SACH;IACL,GAAG;QAACP;QAAgBE;QAAME;QAAaL;QAAcQ;KAAe;IAEpE,qBACI,oBAACb;QACGc,OAAOA;QACPC,UAAU;YACN,IAAIX,eAAe;gBACfC,gCAAAA,aAAcW,IAAI;YACtB;YAEAC,QAAQC,IAAI;QAChB;;AAGZ,EAAE"}

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

@@ -7,13 +7,16 @@ export const parseFunctionSignature = (signature)=>{
     const functionName = segments[segments.length - 1];
     const namespaces = segments.slice(0, -1);
     const params = paramString.split(')')[0].split(',').filter(Boolean);
+    // Find if there's any optional parameter
+    const firstOptionalIndex = params.findIndex((param)=>param.includes('[') || param.includes(']'));
     return {
         signature,
         name: functionName,
         namespaces,
-        parameters: params.map((eachParam)=>({
+        parameters: params.map((eachParam, index)=>({
                 name: eachParam.replace(/\[/g, '').replace(/]/g, '').trim(),
-                required: !eachParam.includes('[') && !eachParam.includes(']')
+                // Parameter is not required if it has brackets or comes after an optional parameter
+                required: firstOptionalIndex === -1 ? !eachParam.includes('[') && !eachParam.includes(']') : index < firstOptionalIndex
             })),
         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    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('[') && !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,CAACC,CAAAA,YAAc,CAAA;gBACjCH,MAAMG,UAAUZ,OAAO,CAAC,OAAO,IAAIA,OAAO,CAAC,MAAM,IAAIa,IAAI;gBACzDC,UAAU,CAACF,UAAUlB,QAAQ,CAAC,QAAQ,CAACkB,UAAUlB,QAAQ,CAAC;YAC9D,CAAA;QACAI;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    // Find if there's any optional parameter\n    const firstOptionalIndex = params.findIndex(\n        param => param.includes('[') || param.includes(']'),\n    );\n\n    return {\n        signature,\n        name: functionName,\n        namespaces,\n        parameters: params.map((eachParam, index) => ({\n            name: eachParam.replace(/\\[/g, '').replace(/]/g, '').trim(),\n            // Parameter is not required if it has brackets or comes after an optional parameter\n            required:\n                firstOptionalIndex === -1\n                    ? !eachParam.includes('[') && !eachParam.includes(']')\n                    : index < firstOptionalIndex,\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","firstOptionalIndex","findIndex","param","name","parameters","map","eachParam","index","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,yCAAyC;IACzC,MAAMC,qBAAqBH,OAAOI,SAAS,CACvCC,CAAAA,QAASA,MAAMjB,QAAQ,CAAC,QAAQiB,MAAMjB,QAAQ,CAAC;IAGnD,OAAO;QACHF;QACAoB,MAAMV;QACNE;QACAS,YAAYP,OAAOQ,GAAG,CAAC,CAACC,WAAWC,QAAW,CAAA;gBAC1CJ,MAAMG,UAAUf,OAAO,CAAC,OAAO,IAAIA,OAAO,CAAC,MAAM,IAAIiB,IAAI;gBACzD,oFAAoF;gBACpFC,UACIT,uBAAuB,CAAC,IAClB,CAACM,UAAUrB,QAAQ,CAAC,QAAQ,CAACqB,UAAUrB,QAAQ,CAAC,OAChDsB,QAAQP;YACtB,CAAA;QACAX;IACJ;AACJ,EAAE"}

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

@@ -0,0 +1,11 @@
+export declare const useFormatTypeFile: (path: string) => {
+    formatTypeFile: {
+        waitingDescription: string;
+        errorDescription: string;
+        finishedDescription: () => string;
+        runningDescription: string;
+        runner: () => Promise<boolean>;
+        ready: true;
+        skip: boolean;
+    };
+};

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

@@ -0,0 +1,70 @@
+import { execSync } from 'node:child_process';
+import { useMemo } from 'react';
+export const useFormatTypeFile = (path)=>{
+    const formatTypeFile = useMemo(()=>{
+        // Check if prettier and eslint are available
+        const checkToolsAvailability = ()=>{
+            let hasPrettier = false;
+            let hasEslint = false;
+            try {
+                // Check if prettier is available
+                execSync('npx prettier --version', {
+                    stdio: 'ignore'
+                });
+                hasPrettier = true;
+            } catch (error) {
+            // Prettier not available
+            }
+            try {
+                // Check if eslint is available
+                execSync('npx eslint --version', {
+                    stdio: 'ignore'
+                });
+                hasEslint = true;
+            } catch (error) {
+            // ESLint not available
+            }
+            return {
+                hasPrettier,
+                hasEslint
+            };
+        };
+        const { hasPrettier, hasEslint } = checkToolsAvailability();
+        return {
+            waitingDescription: 'Waiting to format the type file...',
+            errorDescription: 'Failed to format the type file',
+            finishedDescription: ()=>'Type file formatted',
+            runningDescription: 'Formatting the type file...',
+            runner: async ()=>{
+                try {
+                    // Run prettier on the generated file if available
+                    if (hasPrettier) {
+                        execSync(`npx prettier --write "${path}"`, {
+                            stdio: 'ignore'
+                        });
+                    }
+                    // Run eslint if available
+                    if (hasEslint) {
+                        execSync(`npx eslint --fix "${path}"`, {
+                            stdio: 'ignore'
+                        });
+                    }
+                    return true;
+                } catch (error) {
+                    console.error('Error formatting file:', error);
+                    return false;
+                }
+            },
+            ready: true,
+            // Skip only if both tools are unavailable
+            skip: !hasPrettier && !hasEslint
+        };
+    }, [
+        path
+    ]);
+    return {
+        formatTypeFile
+    };
+};
+
+//# sourceMappingURL=useFormatTypeFile.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../libs/cli/src/commands/GenerateTypes/hooks/useFormatTypeFile.ts"],"sourcesContent":["import { execSync } from 'node:child_process';\nimport { useMemo } from 'react';\nimport { CheckListItem } from '@/cli/types.js';\n\nexport const useFormatTypeFile = (path: string) => {\n    const formatTypeFile = useMemo(() => {\n        // Check if prettier and eslint are available\n        const checkToolsAvailability = () => {\n            let hasPrettier = false;\n            let hasEslint = false;\n\n            try {\n                // Check if prettier is available\n                execSync('npx prettier --version', { stdio: 'ignore' });\n                hasPrettier = true;\n            } catch (error) {\n                // Prettier not available\n            }\n\n            try {\n                // Check if eslint is available\n                execSync('npx eslint --version', { stdio: 'ignore' });\n                hasEslint = true;\n            } catch (error) {\n                // ESLint not available\n            }\n\n            return { hasPrettier, hasEslint };\n        };\n\n        const { hasPrettier, hasEslint } = checkToolsAvailability();\n\n        return {\n            waitingDescription: 'Waiting to format the type file...',\n            errorDescription: 'Failed to format the type file',\n            finishedDescription: () => 'Type file formatted',\n            runningDescription: 'Formatting the type file...',\n            runner: async () => {\n                try {\n                    // Run prettier on the generated file if available\n                    if (hasPrettier) {\n                        execSync(`npx prettier --write \"${path}\"`, {\n                            stdio: 'ignore',\n                        });\n                    }\n\n                    // Run eslint if available\n                    if (hasEslint) {\n                        execSync(`npx eslint --fix \"${path}\"`, {\n                            stdio: 'ignore',\n                        });\n                    }\n\n                    return true;\n                } catch (error) {\n                    console.error('Error formatting file:', error);\n                    return false;\n                }\n            },\n            ready: true,\n            // Skip only if both tools are unavailable\n            skip: !hasPrettier && !hasEslint,\n        } satisfies CheckListItem<boolean>;\n    }, [path]);\n\n    return {\n        formatTypeFile,\n    };\n};\n"],"names":["execSync","useMemo","useFormatTypeFile","path","formatTypeFile","checkToolsAvailability","hasPrettier","hasEslint","stdio","error","waitingDescription","errorDescription","finishedDescription","runningDescription","runner","console","ready","skip"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAAA,SAASA,QAAQ,QAAQ,qBAAqB;AAC9C,SAASC,OAAO,QAAQ,QAAQ;AAGhC,OAAO,MAAMC,oBAAoB,CAACC;IAC9B,MAAMC,iBAAiBH,QAAQ;QAC3B,6CAA6C;QAC7C,MAAMI,yBAAyB;YAC3B,IAAIC,cAAc;YAClB,IAAIC,YAAY;YAEhB,IAAI;gBACA,iCAAiC;gBACjCP,SAAS,0BAA0B;oBAAEQ,OAAO;gBAAS;gBACrDF,cAAc;YAClB,EAAE,OAAOG,OAAO;YACZ,yBAAyB;YAC7B;YAEA,IAAI;gBACA,+BAA+B;gBAC/BT,SAAS,wBAAwB;oBAAEQ,OAAO;gBAAS;gBACnDD,YAAY;YAChB,EAAE,OAAOE,OAAO;YACZ,uBAAuB;YAC3B;YAEA,OAAO;gBAAEH;gBAAaC;YAAU;QACpC;QAEA,MAAM,EAAED,WAAW,EAAEC,SAAS,EAAE,GAAGF;QAEnC,OAAO;YACHK,oBAAoB;YACpBC,kBAAkB;YAClBC,qBAAqB,IAAM;YAC3BC,oBAAoB;YACpBC,QAAQ;gBACJ,IAAI;oBACA,kDAAkD;oBAClD,IAAIR,aAAa;wBACbN,SAAS,CAAC,sBAAsB,EAAEG,KAAK,CAAC,CAAC,EAAE;4BACvCK,OAAO;wBACX;oBACJ;oBAEA,0BAA0B;oBAC1B,IAAID,WAAW;wBACXP,SAAS,CAAC,kBAAkB,EAAEG,KAAK,CAAC,CAAC,EAAE;4BACnCK,OAAO;wBACX;oBACJ;oBAEA,OAAO;gBACX,EAAE,OAAOC,OAAO;oBACZM,QAAQN,KAAK,CAAC,0BAA0BA;oBACxC,OAAO;gBACX;YACJ;YACAO,OAAO;YACP,0CAA0C;YAC1CC,MAAM,CAACX,eAAe,CAACC;QAC3B;IACJ,GAAG;QAACJ;KAAK;IAET,OAAO;QACHC;IACJ;AACJ,EAAE"}

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

@@ -1,7 +1,7 @@
 import { _ as _extends } from "@swc/helpers/_/_extends";
 import { writeFileSync } from 'node:fs';
 import { useMemo } from 'react';
-import { Project, VariableDeclarationKind } from 'ts-morph';
+import { ModuleDeclarationKind, Project, VariableDeclarationKind } from 'ts-morph';
 import { TypescriptReservedNamed } from '../../../constants.js';
 export const useGenerateTypeFile = (path, definitions, typeProvider)=>{
     const generateTypeFile = useMemo(()=>{
@@ -23,7 +23,12 @@ export const useGenerateTypeFile = (path, definitions, typeProvider)=>{
                 });
                 const globalNamespace = definitions.global;
                 typeFile.addStatements(typeProvider.getGlobalStatements());
-                generateNamespace(globalNamespace, typeFile, typeProvider, '');
+                const globalModule = typeFile.addModule({
+                    name: 'global',
+                    hasDeclareKeyword: true,
+                    declarationKind: ModuleDeclarationKind.Global
+                });
+                generateNamespace(globalNamespace, globalModule, typeProvider, '');
                 writeFileSync(path, typeFile.getFullText().replace('*/', '*/\n'));
             },
             ready: definitions !== null && typeProvider !== null
@@ -74,6 +79,7 @@ const generateNamespace = (apiObject, incomingSubject, typeProvider, namespace,
         }, typeProvider.getFunctionOverrideOptions(func)));
         if (isFunctionNameReserved) {
             subject.addExportDeclaration({
+                leadingTrivia: '/** @ts-ignore */\n',
                 namedExports: [
                     {
                         name: resolvedName,
@@ -86,7 +92,8 @@ const generateNamespace = (apiObject, incomingSubject, typeProvider, namespace,
     let propertiesSubject = null;
     if (name && apiObject.methods.length > 0) {
         const typeClass = incomingSubject.addClass(_extends({
-            name
+            name,
+            isExported: true
         }, typeProvider.getClassOptions(fullNamespaceName)));
         propertiesSubject = typeClass;
         for (const method of apiObject.methods){
@@ -120,7 +127,7 @@ const generateNamespace = (apiObject, incomingSubject, typeProvider, namespace,
                 ],
                 type: propertyDetails.type,
                 isStatic: propertyDetails.isStatic,
-                isReadonly: propertyDetails.isReadOnly
+                isReadonly: propertyDetails.isReadonly
             });
         } else {
             subject.addVariableStatement({

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    FunctionDeclarationStructure,\n    MethodDeclarationStructure,\n    ModuleDeclaration,\n    Project,\n    SourceFile,\n    VariableDeclarationKind,\n} from 'ts-morph';\nimport { createTypeProvider } from '@/cli/commands/GenerateTypes/utils/createTypeProvider.js';\nimport { TypescriptReservedNamed } from '@/cli/constants.js';\nimport {\n    ApiDefinitions,\n    ApiObject,\n    CheckListItem,\n    PropertyDescription,\n} 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    namespace: string,\n    name?: string,\n) => {\n    let subject = incomingSubject;\n    const fullNamespaceName = [namespace, name].filter(Boolean).join('.');\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 constant of typeProvider.getConstants(fullNamespaceName)) {\n        subject.addVariableStatement({\n            declarations: [constant],\n            isExported: true,\n            declarationKind: VariableDeclarationKind.Const,\n        });\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            isExported: !!name,\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            ...typeProvider.getClassOptions(fullNamespaceName),\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    const dynamicProperties = typeProvider\n        .getDynamicProperties(`${namespace}.${name}`)\n        .map(\n            dynamicProperty =>\n                ({\n                    name: dynamicProperty.name,\n                    docs: dynamicProperty.docs,\n                    namespaces: namespace.split('.'),\n                    signature: `${namespace}.${name}.${dynamicProperty.name}`,\n                } satisfies PropertyDescription),\n        );\n\n    for (const property of [...apiObject.properties, ...dynamicProperties]) {\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 eachNamespace of Object.entries(apiObject.namespaces)) {\n        generateNamespace(\n            eachNamespace[1],\n            subject,\n            typeProvider,\n            fullNamespaceName,\n            eachNamespace[0],\n        );\n    }\n};\n"],"names":["writeFileSync","useMemo","Project","VariableDeclarationKind","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","namespace","name","subject","fullNamespaceName","filter","Boolean","join","addModule","getStatements","constant","getConstants","addVariableStatement","declarations","isExported","declarationKind","Const","func","functions","isFunctionNameReserved","includes","resolvedName","parameters","getParameters","addFunction","docs","returnType","getFunctionReturnType","getFunctionOverrideOptions","addExportDeclaration","namedExports","alias","propertiesSubject","methods","length","typeClass","addClass","getClassOptions","method","addMethod","dynamicProperties","getDynamicProperties","map","dynamicProperty","namespaces","split","signature","property","properties","propertyDetails","getPropertyDetails","addProperty","type","isStatic","isReadonly","isReadOnly","eachNamespace","Object","entries"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"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"}
+{"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    ModuleDeclarationKind,\n    Project,\n    SourceFile,\n    VariableDeclarationKind,\n} from 'ts-morph';\nimport { createTypeProvider } from '@/cli/commands/GenerateTypes/utils/createTypeProvider.js';\nimport { TypescriptReservedNamed } from '@/cli/constants.js';\nimport {\n    ApiDefinitions,\n    ApiObject,\n    CheckListItem,\n    PropertyDescription,\n} 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                const globalModule = typeFile.addModule({\n                    name: 'global',\n                    hasDeclareKeyword: true,\n                    declarationKind: ModuleDeclarationKind.Global,\n                });\n\n                generateNamespace(\n                    globalNamespace,\n                    globalModule,\n                    typeProvider,\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\nconst generateNamespace = (\n    apiObject: ApiObject,\n    incomingSubject: SourceFile | ModuleDeclaration,\n    typeProvider: ReturnType<typeof createTypeProvider>,\n    namespace: string,\n    name?: string,\n) => {\n    let subject = incomingSubject;\n    const fullNamespaceName = [namespace, name].filter(Boolean).join('.');\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 constant of typeProvider.getConstants(fullNamespaceName)) {\n        subject.addVariableStatement({\n            declarations: [constant],\n            isExported: true,\n            declarationKind: VariableDeclarationKind.Const,\n        });\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            isExported: !!name,\n            ...(typeProvider.getFunctionOverrideOptions(\n                func,\n            ) as FunctionDeclarationStructure),\n        });\n\n        if (isFunctionNameReserved) {\n            subject.addExportDeclaration({\n                leadingTrivia: '/** @ts-ignore */\\n',\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            isExported: true,\n            ...typeProvider.getClassOptions(fullNamespaceName),\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    const dynamicProperties = typeProvider\n        .getDynamicProperties(`${namespace}.${name}`)\n        .map(\n            dynamicProperty =>\n                ({\n                    name: dynamicProperty.name,\n                    docs: dynamicProperty.docs,\n                    namespaces: namespace.split('.'),\n                    signature: `${namespace}.${name}.${dynamicProperty.name}`,\n                } satisfies PropertyDescription),\n        );\n\n    for (const property of [...apiObject.properties, ...dynamicProperties]) {\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 eachNamespace of Object.entries(apiObject.namespaces)) {\n        generateNamespace(\n            eachNamespace[1],\n            subject,\n            typeProvider,\n            fullNamespaceName,\n            eachNamespace[0],\n        );\n    }\n};\n"],"names":["writeFileSync","useMemo","ModuleDeclarationKind","Project","VariableDeclarationKind","TypescriptReservedNamed","useGenerateTypeFile","path","definitions","typeProvider","generateTypeFile","waitingDescription","errorDescription","finishedDescription","runningDescription","runner","Error","project","typeFile","createSourceFile","overwrite","globalNamespace","global","addStatements","getGlobalStatements","globalModule","addModule","name","hasDeclareKeyword","declarationKind","Global","generateNamespace","getFullText","replace","ready","apiObject","incomingSubject","namespace","subject","fullNamespaceName","filter","Boolean","join","getStatements","constant","getConstants","addVariableStatement","declarations","isExported","Const","func","functions","isFunctionNameReserved","includes","resolvedName","parameters","getParameters","addFunction","docs","returnType","getFunctionReturnType","getFunctionOverrideOptions","addExportDeclaration","leadingTrivia","namedExports","alias","propertiesSubject","methods","length","typeClass","addClass","getClassOptions","method","addMethod","dynamicProperties","getDynamicProperties","map","dynamicProperty","namespaces","split","signature","property","properties","propertyDetails","getPropertyDetails","addProperty","type","isStatic","isReadonly","eachNamespace","Object","entries"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";AAAA,SAASA,aAAa,QAAQ,UAAU;AACxC,SAASC,OAAO,QAAQ,QAAQ;AAChC,SAKIC,qBAAqB,EACrBC,OAAO,EAEPC,uBAAuB,QACpB,WAAW;AAElB,SAASC,uBAAuB,QAAQ,qBAAqB;AAQ7D,OAAO,MAAMC,sBAAsB,CAC/BC,MACAC,aACAC;IAEA,MAAMC,mBAAmBT,QAAQ;QAC7B,OAAO;YACHU,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,IAAId;gBACpB,MAAMe,WAAWD,QAAQE,gBAAgB,CAACZ,MAAM,IAAI;oBAChDa,WAAW;gBACf;gBAEA,MAAMC,kBAAkBb,YAAYc,MAAM;gBAE1CJ,SAASK,aAAa,CAACd,aAAae,mBAAmB;gBACvD,MAAMC,eAAeP,SAASQ,SAAS,CAAC;oBACpCC,MAAM;oBACNC,mBAAmB;oBACnBC,iBAAiB3B,sBAAsB4B,MAAM;gBACjD;gBAEAC,kBACIV,iBACAI,cACAhB,cACA;gBAGJT,cACIO,MACAW,SAASc,WAAW,GAAGC,OAAO,CAAC,MAAM;YAE7C;YACAC,OAAO1B,gBAAgB,QAAQC,iBAAiB;QACpD;IACJ,GAAG;QAACD;QAAaC;KAAa;IAE9B,OAAO;QACHC;IACJ;AACJ,EAAE;AAEF,MAAMqB,oBAAoB,CACtBI,WACAC,iBACA3B,cACA4B,WACAV;IAEA,IAAIW,UAAUF;IACd,MAAMG,oBAAoB;QAACF;QAAWV;KAAK,CAACa,MAAM,CAACC,SAASC,IAAI,CAAC;IAEjE,IAAIf,MAAM;QACNW,UAAUF,gBAAgBV,SAAS,CAAC;YAChCC;QACJ;IACJ;IAEA,IAAIA,SAAS,YAAY;QACrBW,QAAQf,aAAa,CAACd,aAAakC,aAAa;IACpD;IAEA,KAAK,MAAMC,YAAYnC,aAAaoC,YAAY,CAACN,mBAAoB;QACjED,QAAQQ,oBAAoB,CAAC;YACzBC,cAAc;gBAACH;aAAS;YACxBI,YAAY;YACZnB,iBAAiBzB,wBAAwB6C,KAAK;QAClD;IACJ;IAEA,KAAK,MAAMC,QAAQf,UAAUgB,SAAS,CAAE;QACpC,MAAMC,yBAAyB/C,wBAAwBgD,QAAQ,CAC3DH,KAAKvB,IAAI;QAEb,MAAM2B,eAAe,CAAC,CAAC,EAAEJ,KAAKvB,IAAI,CAAC,CAAC;QACpC,MAAM4B,aAAa9C,aAAa+C,aAAa,CAACN;QAE9CZ,QAAQmB,WAAW,CAAC;YAChB9B,MAAMyB,yBAAyBE,eAAeJ,KAAKvB,IAAI;YACvD+B,MAAM;gBAACR,KAAKQ,IAAI;aAAC;YACjBH;YACAI,YAAYlD,aAAamD,qBAAqB,CAACV;YAC/CF,YAAY,CAAC,CAACrB;WACVlB,aAAaoD,0BAA0B,CACvCX;QAIR,IAAIE,wBAAwB;YACxBd,QAAQwB,oBAAoB,CAAC;gBACzBC,eAAe;gBACfC,cAAc;oBACV;wBACIrC,MAAM2B;wBACNW,OAAOf,KAAKvB,IAAI;oBACpB;iBACH;YACL;QACJ;IACJ;IAEA,IAAIuC,oBAA6C;IAEjD,IAAIvC,QAAQQ,UAAUgC,OAAO,CAACC,MAAM,GAAG,GAAG;QACtC,MAAMC,YAAYjC,gBAAgBkC,QAAQ,CAAC;YACvC3C;YACAqB,YAAY;WACTvC,aAAa8D,eAAe,CAAChC;QAEpC2B,oBAAoBG;QAEpB,KAAK,MAAMG,UAAUrC,UAAUgC,OAAO,CAAE;YACpC,MAAMZ,aAAa9C,aAAa+C,aAAa,CAACgB;YAE9CH,UAAUI,SAAS,CAAC;gBAChB9C,MAAM6C,OAAO7C,IAAI;gBACjB+B,MAAM;oBAACc,OAAOd,IAAI;iBAAC;gBACnBH;gBACAI,YAAYlD,aAAamD,qBAAqB,CAACY;eAC3C/D,aAAaoD,0BAA0B,CACvCW;QAGZ;IACJ;IAEA,MAAME,oBAAoBjE,aACrBkE,oBAAoB,CAAC,CAAC,EAAEtC,UAAU,CAAC,EAAEV,KAAK,CAAC,EAC3CiD,GAAG,CACAC,CAAAA,kBACK,CAAA;YACGlD,MAAMkD,gBAAgBlD,IAAI;YAC1B+B,MAAMmB,gBAAgBnB,IAAI;YAC1BoB,YAAYzC,UAAU0C,KAAK,CAAC;YAC5BC,WAAW,CAAC,EAAE3C,UAAU,CAAC,EAAEV,KAAK,CAAC,EAAEkD,gBAAgBlD,IAAI,CAAC,CAAC;QAC7D,CAAA;IAGZ,KAAK,MAAMsD,YAAY;WAAI9C,UAAU+C,UAAU;WAAKR;KAAkB,CAAE;QACpE,MAAMS,kBAAkB1E,aAAa2E,kBAAkB,CAACH;QAExD,IAAIf,mBAAmB;YACnBA,kBAAkBmB,WAAW,CAAC;gBAC1B1D,MAAMsD,SAAStD,IAAI;gBACnB+B,MAAM;oBAACuB,SAASvB,IAAI;iBAAC;gBACrB4B,MAAMH,gBAAgBG,IAAI;gBAC1BC,UAAUJ,gBAAgBI,QAAQ;gBAClCC,YAAYL,gBAAgBK,UAAU;YAC1C;QACJ,OAAO;YACHlD,QAAQQ,oBAAoB,CAAC;gBACzBY,MAAM;oBAACuB,SAASvB,IAAI;iBAAC;gBACrBX,cAAc;oBACV;wBACIpB,MAAMsD,SAAStD,IAAI;wBACnB2D,MAAMH,gBAAgBG,IAAI;oBAC9B;iBACH;YACL;QACJ;IACJ;IAEA,KAAK,MAAMG,iBAAiBC,OAAOC,OAAO,CAACxD,UAAU2C,UAAU,EAAG;QAC9D/C,kBACI0D,aAAa,CAAC,EAAE,EAChBnD,SACA7B,cACA8B,mBACAkD,aAAa,CAAC,EAAE;IAExB;AACJ"}

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

@@ -15,44 +15,14 @@ export declare const useGetVersion: (version: PlaydateSdkVersion) => {
         getClassOptions: (className: string) => Partial<import("ts-morph").ClassDeclarationStructure>;
         getPropertyDetails: (property: import("../../../types.js").PropertyDescription) => import("../../../types.js").PropertyDetails;
         getDynamicProperties: (namespace: string) => Pick<import("../../../types.js").PropertyDescription, "name" | "docs">[];
-        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> | Partial<import("ts-morph").MethodDeclarationStructure> | {
-            overloads: ({
-                docs: string[];
-                leadingTrivia?: (string | import("ts-morph").WriterFunction | (string | import("ts-morph").WriterFunction)[]) | undefined;
-                trailingTrivia?: (string | import("ts-morph").WriterFunction | (string | import("ts-morph").WriterFunction)[]) | undefined;
-                hasQuestionToken?: boolean | undefined;
-                scope?: import("ts-morph").Scope | undefined;
-                hasOverrideKeyword?: boolean | undefined;
-                parameters?: import("ts-morph").OptionalKind<import("ts-morph").ParameterDeclarationStructure>[] | undefined;
-                typeParameters?: (import("ts-morph").OptionalKind<import("ts-morph").TypeParameterDeclarationStructure> | string)[] | undefined;
-                isAbstract?: boolean | undefined;
-                returnType?: (string | import("ts-morph").WriterFunction) | undefined;
-                isAsync?: boolean | undefined;
-                isGenerator?: boolean | undefined;
-                isStatic?: boolean | undefined;
-                kind?: import("ts-morph").StructureKind.MethodOverload | undefined;
-            } | {
-                docs: string[];
-                leadingTrivia?: (string | import("ts-morph").WriterFunction | (string | import("ts-morph").WriterFunction)[]) | undefined;
-                trailingTrivia?: (string | import("ts-morph").WriterFunction | (string | import("ts-morph").WriterFunction)[]) | undefined;
-                parameters?: import("ts-morph").OptionalKind<import("ts-morph").ParameterDeclarationStructure>[] | undefined;
-                typeParameters?: (import("ts-morph").OptionalKind<import("ts-morph").TypeParameterDeclarationStructure> | string)[] | undefined;
-                hasDeclareKeyword?: boolean | undefined;
-                isExported?: boolean | undefined;
-                isDefaultExport?: boolean | undefined;
-                returnType?: (string | import("ts-morph").WriterFunction) | undefined;
-                isAsync?: boolean | undefined;
-                isGenerator?: boolean | undefined;
-                kind?: import("ts-morph").StructureKind.FunctionOverload | undefined;
-            })[];
-        };
+        getFunctionReturnType: (func: import("../../../types.js").FunctionDescription) => string | import("ts-morph").WriterFunction | undefined;
+        getParameterDetails: (func: import("../../../types.js").FunctionDescription, parameter: string) => import("ts-morph").ParameterDeclarationStructure;
+        getParameters: (func: import("../../../types.js").FunctionDescription) => import("ts-morph").ParameterDeclarationStructure[];
+        getFunctionOverrideOptions: (func: import("../../../types.js").FunctionDescription) => Partial<import("ts-morph").FunctionDeclarationStructure | import("ts-morph").MethodDeclarationStructure>;
         getConstants: (fullNamespace: string) => {
             kind: import("ts-morph").StructureKind.VariableDeclaration;
             name: string;
-            type: string;
+            type: string | import("ts-morph").WriterFunction | undefined;
         }[];
         save: () => void;
     } | null;

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

@@ -0,0 +1,12 @@
+import { ClassDeclarationStructure, PropertyDeclarationStructure } from 'ts-morph';
+export type ClassDefinition = Partial<ClassDeclarationStructure>;
+export type PropertyDefinition = {
+    signature: string;
+    definition: Partial<PropertyDeclarationStructure>;
+};
+export type VersionDefinition = {
+    globalStatements: string[];
+    constants: Record<string, string[]>;
+    statements: string[];
+    classes: Record<string, ClassDefinition>;
+};

package/src/commands/GenerateTypes/types.js

@@ -0,0 +1,3 @@
+export { };
+
+//# sourceMappingURL=types.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../libs/cli/src/commands/GenerateTypes/types.ts"],"sourcesContent":["import {\n    ClassDeclarationStructure,\n    PropertyDeclarationStructure,\n} from 'ts-morph';\n\nexport type ClassDefinition = Partial<ClassDeclarationStructure>;\n\nexport type PropertyDefinition = {\n    signature: string;\n    definition: Partial<PropertyDeclarationStructure>;\n};\n\nexport type VersionDefinition = {\n    globalStatements: string[];\n    constants: Record<string, string[]>;\n    statements: string[];\n    classes: Record<string, ClassDefinition>;\n};\n"],"names":[],"rangeMappings":"","mappings":"AAYA,WAKE"}

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

@@ -1,49 +1,19 @@
-import { FunctionDeclarationStructure, ParameterDeclarationStructure, StructureKind } from 'ts-morph';
-import { FunctionDescription, ParameterDetails, PropertyDescription, PropertyDetails } from '../../../types.js';
+import { ParameterDeclarationStructure, StructureKind, FunctionDeclarationStructure, MethodDeclarationStructure } from 'ts-morph';
+import { FunctionDescription, PropertyDescription, PropertyDetails } from '../../../types.js';
 export declare const createTypeProvider: (version: string) => {
     getGlobalStatements: () => string[];
     getStatements: () => string[];
     getClassOptions: (className: string) => Partial<import("ts-morph").ClassDeclarationStructure>;
     getPropertyDetails: (property: PropertyDescription) => PropertyDetails;
     getDynamicProperties: (namespace: string) => Pick<PropertyDescription, "name" | "docs">[];
-    getFunctionReturnType: (func: FunctionDescription) => string;
-    getParameterDetails: (func: FunctionDescription, parameter: string) => ParameterDetails;
-    getParameters: (func: FunctionDescription) => FunctionDeclarationStructure["parameters"];
-    getFunctionOverrideOptions: (func: FunctionDescription) => Partial<FunctionDeclarationStructure> | Partial<import("ts-morph").MethodDeclarationStructure> | {
-        overloads: ({
-            docs: string[];
-            leadingTrivia?: (string | import("ts-morph").WriterFunction | (string | import("ts-morph").WriterFunction)[]) | undefined;
-            trailingTrivia?: (string | import("ts-morph").WriterFunction | (string | import("ts-morph").WriterFunction)[]) | undefined;
-            hasQuestionToken?: boolean | undefined;
-            scope?: import("ts-morph").Scope | undefined;
-            hasOverrideKeyword?: boolean | undefined;
-            parameters?: import("ts-morph").OptionalKind<ParameterDeclarationStructure>[] | undefined;
-            typeParameters?: (import("ts-morph").OptionalKind<import("ts-morph").TypeParameterDeclarationStructure> | string)[] | undefined;
-            isAbstract?: boolean | undefined;
-            returnType?: (string | import("ts-morph").WriterFunction) | undefined;
-            isAsync?: boolean | undefined;
-            isGenerator?: boolean | undefined;
-            isStatic?: boolean | undefined;
-            kind?: StructureKind.MethodOverload | undefined;
-        } | {
-            docs: string[];
-            leadingTrivia?: (string | import("ts-morph").WriterFunction | (string | import("ts-morph").WriterFunction)[]) | undefined;
-            trailingTrivia?: (string | import("ts-morph").WriterFunction | (string | import("ts-morph").WriterFunction)[]) | undefined;
-            parameters?: import("ts-morph").OptionalKind<ParameterDeclarationStructure>[] | undefined;
-            typeParameters?: (import("ts-morph").OptionalKind<import("ts-morph").TypeParameterDeclarationStructure> | string)[] | undefined;
-            hasDeclareKeyword?: boolean | undefined;
-            isExported?: boolean | undefined;
-            isDefaultExport?: boolean | undefined;
-            returnType?: (string | import("ts-morph").WriterFunction) | undefined;
-            isAsync?: boolean | undefined;
-            isGenerator?: boolean | undefined;
-            kind?: StructureKind.FunctionOverload | undefined;
-        })[];
-    };
+    getFunctionReturnType: (func: FunctionDescription) => string | import("ts-morph").WriterFunction | undefined;
+    getParameterDetails: (func: FunctionDescription, parameter: string) => ParameterDeclarationStructure;
+    getParameters: (func: FunctionDescription) => ParameterDeclarationStructure[];
+    getFunctionOverrideOptions: (func: FunctionDescription) => Partial<FunctionDeclarationStructure | MethodDeclarationStructure>;
     getConstants: (fullNamespace: string) => {
         kind: StructureKind.VariableDeclaration;
         name: string;
-        type: string;
+        type: string | import("ts-morph").WriterFunction | undefined;
     }[];
     save: () => void;
 };

package/src/commands/GenerateTypes/utils/createTypeProvider.js

@@ -74,7 +74,8 @@ export const createTypeProvider = (version)=>{
             const details = {
                 signature: func.signature,
                 parameters: func.parameters.map((p)=>({
-                        name: p.name,
+                        kind: StructureKind.Parameter,
+                        name: kebabToCamelCase(p.name),
                         type: 'any'
                     })),
                 returnType: 'any'
@@ -99,49 +100,72 @@ export const createTypeProvider = (version)=>{
         return returnType;
     };
     const getParameterDetails = (func, parameter)=>{
-        const { parameters } = getFunctionDetails(func);
-        const param = parameters.find((p)=>p.name === parameter);
+        var _details_parameters;
+        const details = getFunctionDetails(func);
+        const param = (_details_parameters = details.parameters) == null ? void 0 : _details_parameters.find((p)=>p.name === parameter);
         if (!param) {
             return {
-                name: parameter,
+                kind: StructureKind.Parameter,
+                name: kebabToCamelCase(parameter),
                 type: 'any'
             };
         }
-        return param;
+        return _extends({}, param, {
+            name: kebabToCamelCase(param.name)
+        });
     };
     const getParameters = (func)=>{
-        const { overrideParameters = false, parameters } = getFunctionDetails(func);
-        const getParameterFromDetails = (parameter)=>{
-            var _parameter_overrideOptions;
-            return _extends({
-                kind: StructureKind.Parameter,
-                name: kebabToCamelCase(parameter.name),
-                type: parameter.type
-            }, (_parameter_overrideOptions = parameter.overrideOptions) != null ? _parameter_overrideOptions : {});
-        };
-        if (overrideParameters) {
-            return parameters.map((details)=>{
-                return getParameterFromDetails(details);
-            });
+        const details = getFunctionDetails(func);
+        if (details.overrideParameters && details.parameters) {
+            return details.parameters.map((param)=>_extends({}, param, {
+                    name: kebabToCamelCase(param.name)
+                }));
         }
         return func.parameters.map((parameter)=>{
             const details = getParameterDetails(func, parameter.name);
-            return _extends({
+            return _extends({}, details, {
+                name: kebabToCamelCase(details.name),
                 hasQuestionToken: !parameter.required
-            }, getParameterFromDetails(details));
+            });
         });
     };
     const getFunctionOverrideOptions = (func)=>{
-        var _getFunctionDetails_overrideOptions;
-        const options = (_getFunctionDetails_overrideOptions = getFunctionDetails(func).overrideOptions) != null ? _getFunctionDetails_overrideOptions : {};
-        if ('overloads' in options && Array.isArray(options.overloads)) {
-            return {
-                overloads: options.overloads.map((overload)=>_extends({}, overload, {
+        const details = getFunctionDetails(func);
+        const options = {};
+        if (details.kind) {
+            options.kind = details.kind;
+        }
+        if (details.typeParameters) {
+            options.typeParameters = details.typeParameters;
+        }
+        if ('overloads' in details && Array.isArray(details.overloads)) {
+            if (details.kind === StructureKind.Method) {
+                options.overloads = details.overloads.map((overload)=>{
+                    var _overload_parameters;
+                    return _extends({}, overload, {
+                        typeParameters: overload.typeParameters,
+                        parameters: (_overload_parameters = overload.parameters) == null ? void 0 : _overload_parameters.map((param)=>_extends({}, param, {
+                                name: kebabToCamelCase(param.name)
+                            })),
                         docs: [
                             func.docs
                         ]
-                    }))
-            };
+                    });
+                });
+            } else {
+                options.overloads = details.overloads.map((overload)=>{
+                    var _overload_parameters;
+                    return _extends({}, overload, {
+                        typeParameters: overload.typeParameters,
+                        parameters: (_overload_parameters = overload.parameters) == null ? void 0 : _overload_parameters.map((param)=>_extends({}, param, {
+                                name: kebabToCamelCase(param.name)
+                            })),
+                        docs: [
+                            func.docs
+                        ]
+                    });
+                });
+            }
         }
         return options;
     };