crankscript 0.1.2 → 0.1.5-beta

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

@@ -0,0 +1,78 @@
+import { _ as _extends } from "@swc/helpers/_/_extends";
+import { load } from 'cheerio';
+import Turndown from 'turndown';
+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 = [];
+    const turndown = new Turndown();
+    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) || /^-[a-zA-Z]/.test(titleText) || /[+*/]/.test(titleText) || titleText.indexOf(' - ') !== -1 || titleText.indexOf(' .. ') !== -1) {
+            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 + '#');
+        docsString = turndown.turndown(docsString);
+        const baseDocs = id ? `${docsString}\n\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 Turndown from 'turndown';\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    const turndown = new Turndown();\n\n    for (const element of functionSignatures) {\n        const id = $(element).attr('id') ?? '';\n        const isProperty = id.startsWith('v-');\n        const titleText = $(element).find('> .title').text();\n\n        if (\n            titleText.indexOf('#') !== -1 ||\n            /[a-zA-Z]\\[/.test(titleText) ||\n            /^-[a-zA-Z]/.test(titleText) ||\n            /[+*/]/.test(titleText) ||\n            titleText.indexOf(' - ') !== -1 ||\n            titleText.indexOf(' .. ') !== -1\n        ) {\n            continue;\n        }\n\n        const titles = isProperty\n            ? titleText.split('  ')\n            : extractFunctionCalls(titleText);\n\n        let docsString = ($(element).find('.content').html() ?? '').trim();\n\n        if (docsString.startsWith('<div class=\"paragraph\">')) {\n            docsString = docsString.slice('<div class=\"paragraph\">'.length);\n        }\n\n        if (docsString.endsWith('</div>')) {\n            docsString = docsString.slice(\n                0,\n                docsString.length - '</div>'.length\n            );\n        }\n\n        docsString = docsString.replace(\n            /<a href=\"#/g,\n            '<a href=\"' + PlaydateSdkUrl + version + '#'\n        );\n\n        docsString = turndown.turndown(docsString);\n\n        const baseDocs = id\n            ? `${docsString}\\n\\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","Turndown","PlaydateSdkUrl","parseFunctionSignature","extractFunctionCalls","input","functionCallRegex","matches","match","exec","push","trim","normalizeSignature","signature","closingParenIndex","indexOf","slice","getDescriptionsFromHtml","html","version","$","functionSignatures","toArray","functions","properties","visitedSignatures","turndown","element","id","attr","isProperty","startsWith","titleText","find","text","test","titles","split","docsString","length","endsWith","replace","baseDocs","title","includes","name","namespaces","docs","description","hasSelf","e"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"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"}

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

@@ -0,0 +1 @@
+export declare const getFunctionTypeOverride: (version: string) => import("../../../types.js").FunctionTypeOverrideMap;

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

@@ -0,0 +1,7 @@
+import { functionTypeOverrides } from '../../../commands/GenerateTypes/utils/functionTypeOverrides.js';
+export const getFunctionTypeOverride = (version)=>{
+    var _functionTypeOverrides_version;
+    return (_functionTypeOverrides_version = functionTypeOverrides[version]) != null ? _functionTypeOverrides_version : functionTypeOverrides['defaultVersion'];
+};
+
+//# sourceMappingURL=getFunctionTypeOverride.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../libs/cli/src/commands/GenerateTypes/fn/getFunctionTypeOverride.ts"],"sourcesContent":["import { functionTypeOverrides } from '@/cli/commands/GenerateTypes/utils/functionTypeOverrides.js';\n\nexport const getFunctionTypeOverride = (version: string) => {\n    return (\n        functionTypeOverrides[version] ??\n        functionTypeOverrides['defaultVersion']\n    );\n};\n"],"names":["functionTypeOverrides","getFunctionTypeOverride","version"],"rangeMappings":";;;;","mappings":"AAAA,SAASA,qBAAqB,QAAQ,8DAA8D;AAEpG,OAAO,MAAMC,0BAA0B,CAACC;QAEhCF;IADJ,OACIA,CAAAA,iCAAAA,qBAAqB,CAACE,QAAQ,YAA9BF,iCACAA,qBAAqB,CAAC,iBAAiB;AAE/C,EAAE"}

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

@@ -0,0 +1 @@
+export declare const getHtmlForVersion: (version: string) => Promise<string>;

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

@@ -0,0 +1,21 @@
+import { existsSync, readFileSync, writeFileSync } from 'node:fs';
+import { mkdirSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+export const getHtmlForVersion = async (version)=>{
+    const cacheDir = join(tmpdir(), 'crankscript', 'cache');
+    const path = join(cacheDir, `${version}.html`);
+    if (!existsSync(cacheDir)) {
+        mkdirSync(cacheDir, {
+            recursive: true
+        });
+    }
+    if (existsSync(path)) {
+        return readFileSync(path, 'utf8');
+    }
+    const html = await fetch(`https://sdk.play.date/${version}/`).then((res)=>res.text());
+    writeFileSync(path, html, 'utf8');
+    return html;
+};
+
+//# sourceMappingURL=getHtmlForVersion.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../libs/cli/src/commands/GenerateTypes/fn/getHtmlForVersion.ts"],"sourcesContent":["import { existsSync, readFileSync, writeFileSync } from 'node:fs';\nimport { mkdirSync } from 'node:fs';\nimport { tmpdir } from 'node:os';\nimport { join } from 'node:path';\n\nexport const getHtmlForVersion = async (version: string) => {\n    const cacheDir = join(tmpdir(), 'crankscript', 'cache');\n    const path = join(cacheDir, `${version}.html`);\n\n    if (!existsSync(cacheDir)) {\n        mkdirSync(cacheDir, { recursive: true });\n    }\n\n    if (existsSync(path)) {\n        return readFileSync(path, 'utf8');\n    }\n\n    const html = await fetch(`https://sdk.play.date/${version}/`).then((res) =>\n        res.text()\n    );\n\n    writeFileSync(path, html, 'utf8');\n\n    return html;\n};\n"],"names":["existsSync","readFileSync","writeFileSync","mkdirSync","tmpdir","join","getHtmlForVersion","version","cacheDir","path","recursive","html","fetch","then","res","text"],"rangeMappings":";;;;;;;;;;;;;;;;;;","mappings":"AAAA,SAASA,UAAU,EAAEC,YAAY,EAAEC,aAAa,QAAQ,UAAU;AAClE,SAASC,SAAS,QAAQ,UAAU;AACpC,SAASC,MAAM,QAAQ,UAAU;AACjC,SAASC,IAAI,QAAQ,YAAY;AAEjC,OAAO,MAAMC,oBAAoB,OAAOC;IACpC,MAAMC,WAAWH,KAAKD,UAAU,eAAe;IAC/C,MAAMK,OAAOJ,KAAKG,UAAU,CAAC,EAAED,QAAQ,KAAK,CAAC;IAE7C,IAAI,CAACP,WAAWQ,WAAW;QACvBL,UAAUK,UAAU;YAAEE,WAAW;QAAK;IAC1C;IAEA,IAAIV,WAAWS,OAAO;QAClB,OAAOR,aAAaQ,MAAM;IAC9B;IAEA,MAAME,OAAO,MAAMC,MAAM,CAAC,sBAAsB,EAAEL,QAAQ,CAAC,CAAC,EAAEM,IAAI,CAAC,CAACC,MAChEA,IAAIC,IAAI;IAGZb,cAAcO,MAAME,MAAM;IAE1B,OAAOA;AACX,EAAE"}

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

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

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

@@ -0,0 +1,22 @@
+export const parseFunctionSignature = (signature)=>{
+    const normalizedSignature = signature.includes('(') ? signature : signature + '()';
+    const [fullyQualifiedName, paramString] = normalizedSignature.split('(');
+    const hasSelf = fullyQualifiedName.includes(':');
+    const normalizedFullyQualifiedName = fullyQualifiedName.replace(':', '.');
+    const segments = normalizedFullyQualifiedName.split('.');
+    const functionName = segments[segments.length - 1];
+    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(),
+                required: !eachParam.includes('[') && !eachParam.includes(']')
+            })),
+        hasSelf
+    };
+};
+
+//# sourceMappingURL=parseFunctionSignature.js.map

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

@@ -0,0 +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,CAAC,CAACC,YAAe,CAAA;gBACnCH,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"}

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

@@ -0,0 +1,12 @@
+export declare const useFetchHtml: (version: string | null) => {
+    html: string | null;
+    fetchHtml: {
+        waitingDescription: string;
+        errorDescription: string;
+        finishedDescription: () => string;
+        runningDescription: string;
+        runner: () => Promise<string>;
+        onFinish: (result: string) => void;
+        ready: boolean;
+    };
+};

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

@@ -0,0 +1,31 @@
+import { useMemo, useState } from 'react';
+import { getHtmlForVersion } from '../../../commands/GenerateTypes/fn/getHtmlForVersion.js';
+export const useFetchHtml = (version)=>{
+    const [html, setHtml] = useState(null);
+    const fetchHtml = useMemo(()=>{
+        return {
+            waitingDescription: 'Waiting to fetch HTML contents',
+            errorDescription: 'Failed to fetch HTML contents',
+            finishedDescription: ()=>'HTML contents fetched',
+            runningDescription: 'Fetching HTML contents...',
+            runner: async ()=>{
+                if (!version) {
+                    throw new Error('Version is not set');
+                }
+                return getHtmlForVersion(version);
+            },
+            onFinish: (result)=>{
+                setHtml(result);
+            },
+            ready: version !== null
+        };
+    }, [
+        version
+    ]);
+    return {
+        html,
+        fetchHtml
+    };
+};
+
+//# sourceMappingURL=useFetchHtml.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../libs/cli/src/commands/GenerateTypes/hooks/useFetchHtml.ts"],"sourcesContent":["import { useMemo, useState } from 'react';\nimport { getHtmlForVersion } from '@/cli/commands/GenerateTypes/fn/getHtmlForVersion.js';\nimport { CheckListItem } from '@/cli/types.js';\n\nexport const useFetchHtml = (version: string | null) => {\n    const [html, setHtml] = useState<string | null>(null);\n\n    const fetchHtml = useMemo(() => {\n        return {\n            waitingDescription: 'Waiting to fetch HTML contents',\n            errorDescription: 'Failed to fetch HTML contents',\n            finishedDescription: () => 'HTML contents fetched',\n            runningDescription: 'Fetching HTML contents...',\n            runner: async () => {\n                if (!version) {\n                    throw new Error('Version is not set');\n                }\n\n                return getHtmlForVersion(version);\n            },\n            onFinish: (result) => {\n                setHtml(result);\n            },\n            ready: version !== null,\n        } satisfies CheckListItem<string>;\n    }, [version]);\n\n    return {\n        html,\n        fetchHtml,\n    };\n};\n"],"names":["useMemo","useState","getHtmlForVersion","useFetchHtml","version","html","setHtml","fetchHtml","waitingDescription","errorDescription","finishedDescription","runningDescription","runner","Error","onFinish","result","ready"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAAA,SAASA,OAAO,EAAEC,QAAQ,QAAQ,QAAQ;AAC1C,SAASC,iBAAiB,QAAQ,uDAAuD;AAGzF,OAAO,MAAMC,eAAe,CAACC;IACzB,MAAM,CAACC,MAAMC,QAAQ,GAAGL,SAAwB;IAEhD,MAAMM,YAAYP,QAAQ;QACtB,OAAO;YACHQ,oBAAoB;YACpBC,kBAAkB;YAClBC,qBAAqB,IAAM;YAC3BC,oBAAoB;YACpBC,QAAQ;gBACJ,IAAI,CAACR,SAAS;oBACV,MAAM,IAAIS,MAAM;gBACpB;gBAEA,OAAOX,kBAAkBE;YAC7B;YACAU,UAAU,CAACC;gBACPT,QAAQS;YACZ;YACAC,OAAOZ,YAAY;QACvB;IACJ,GAAG;QAACA;KAAQ;IAEZ,OAAO;QACHC;QACAE;IACJ;AACJ,EAAE"}

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

@@ -0,0 +1,12 @@
+import { createTypeProvider } from '../../../commands/GenerateTypes/utils/createTypeProvider.js';
+import { ApiDefinitions } from '../../../types.js';
+export declare const useGenerateTypeFile: (path: string, definitions: ApiDefinitions | null, typeProvider: ReturnType<typeof createTypeProvider> | null) => {
+    generateTypeFile: {
+        waitingDescription: string;
+        errorDescription: string;
+        finishedDescription: () => string;
+        runningDescription: string;
+        runner: () => Promise<void>;
+        ready: boolean;
+    };
+};

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

@@ -0,0 +1,126 @@
+import { _ as _extends } from "@swc/helpers/_/_extends";
+import { writeFileSync } from 'node:fs';
+import { useMemo } from 'react';
+import { Project } from 'ts-morph';
+import { TypescriptReservedNamed } from '../../../constants.js';
+export const useGenerateTypeFile = (path, definitions, typeProvider)=>{
+    const generateTypeFile = useMemo(()=>{
+        return {
+            waitingDescription: 'Waiting to generate the type file...',
+            errorDescription: 'Failed to generate the type file',
+            finishedDescription: ()=>'Type file generated',
+            runningDescription: 'Generating the type file...',
+            runner: async ()=>{
+                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
+                });
+                const globalNamespace = definitions.global;
+                typeFile.addStatements(typeProvider.getGlobalStatements());
+                generateNamespace(globalNamespace, typeFile, typeProvider, '');
+                writeFileSync(path, typeFile.getFullText().replace('*/', '*/\n'));
+            },
+            ready: definitions !== null && typeProvider !== null
+        };
+    }, [
+        definitions,
+        typeProvider
+    ]);
+    return {
+        generateTypeFile
+    };
+};
+const generateNamespace = (apiObject, incomingSubject, typeProvider, namespace, name)=>{
+    let subject = incomingSubject;
+    const fullNamespaceName = [
+        namespace,
+        name
+    ].filter(Boolean).join('.');
+    if (name) {
+        subject = incomingSubject.addModule({
+            name
+        });
+    }
+    if (name === 'playdate') {
+        subject.addStatements(typeProvider.getStatements());
+    }
+    for (const func of apiObject.functions){
+        const isFunctionNameReserved = TypescriptReservedNamed.includes(func.name);
+        const resolvedName = `_${func.name}`;
+        const parameters = typeProvider.getParameters(func);
+        subject.addFunction(_extends({
+            name: isFunctionNameReserved ? resolvedName : func.name,
+            docs: [
+                func.docs
+            ],
+            parameters,
+            returnType: typeProvider.getFunctionReturnType(func),
+            isExported: !!name
+        }, typeProvider.getFunctionOverrideOptions(func)));
+        if (isFunctionNameReserved) {
+            subject.addExportDeclaration({
+                namedExports: [
+                    {
+                        name: resolvedName,
+                        alias: func.name
+                    }
+                ]
+            });
+        }
+    }
+    let propertiesSubject = null;
+    if (name && apiObject.methods.length > 0) {
+        const typeClass = incomingSubject.addClass(_extends({
+            name
+        }, typeProvider.getClassOptions(fullNamespaceName)));
+        propertiesSubject = typeClass;
+        for (const method of apiObject.methods){
+            const parameters = typeProvider.getParameters(method);
+            typeClass.addMethod(_extends({
+                name: method.name,
+                docs: [
+                    method.docs
+                ],
+                parameters,
+                returnType: typeProvider.getFunctionReturnType(method)
+            }, typeProvider.getFunctionOverrideOptions(method)));
+        }
+    }
+    for (const property of apiObject.properties){
+        const propertyDetails = typeProvider.getPropertyDetails(property);
+        if (propertiesSubject) {
+            propertiesSubject.addProperty({
+                name: property.name,
+                docs: [
+                    property.docs
+                ],
+                type: propertyDetails.type,
+                isStatic: propertyDetails.isStatic,
+                isReadonly: propertyDetails.isReadOnly
+            });
+        } else {
+            subject.addVariableStatement({
+                docs: [
+                    property.docs
+                ],
+                declarations: [
+                    {
+                        name: property.name,
+                        type: propertyDetails.type
+                    }
+                ]
+            });
+        }
+    }
+    for (const eachNamespace of Object.entries(apiObject.namespaces)){
+        generateNamespace(eachNamespace[1], subject, typeProvider, fullNamespaceName, eachNamespace[0]);
+    }
+};
+
+//# sourceMappingURL=useGenerateTypeFile.js.map

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

@@ -0,0 +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} from 'ts-morph';\nimport { createTypeProvider } from '@/cli/commands/GenerateTypes/utils/createTypeProvider.js';\nimport { TypescriptReservedNamed } from '@/cli/constants.js';\nimport { ApiDefinitions, ApiObject, CheckListItem } from '@/cli/types.js';\n\nexport const useGenerateTypeFile = (\n    path: string,\n    definitions: ApiDefinitions | null,\n    typeProvider: ReturnType<typeof createTypeProvider> | null\n) => {\n    const generateTypeFile = useMemo(() => {\n        return {\n            waitingDescription: 'Waiting to generate the type file...',\n            errorDescription: 'Failed to generate the type file',\n            finishedDescription: () => 'Type file generated',\n            runningDescription: 'Generating the type file...',\n            runner: async () => {\n                if (!definitions) {\n                    throw new Error('Definitions are not set');\n                }\n\n                if (!typeProvider) {\n                    throw new Error('Type provider is not set');\n                }\n\n                const project = new Project();\n                const typeFile = project.createSourceFile(path, '', {\n                    overwrite: true,\n                });\n\n                const globalNamespace = definitions.global;\n\n                typeFile.addStatements(typeProvider.getGlobalStatements());\n\n                generateNamespace(globalNamespace, typeFile, typeProvider, '');\n\n                writeFileSync(\n                    path,\n                    typeFile.getFullText().replace('*/', '*/\\n')\n                );\n            },\n            ready: definitions !== null && typeProvider !== null,\n        } satisfies CheckListItem<void>;\n    }, [definitions, typeProvider]);\n\n    return {\n        generateTypeFile,\n    };\n};\n\nconst generateNamespace = (\n    apiObject: ApiObject,\n    incomingSubject: SourceFile | ModuleDeclaration,\n    typeProvider: ReturnType<typeof createTypeProvider>,\n    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 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    for (const property of apiObject.properties) {\n        const propertyDetails = typeProvider.getPropertyDetails(property);\n\n        if (propertiesSubject) {\n            propertiesSubject.addProperty({\n                name: property.name,\n                docs: [property.docs],\n                type: propertyDetails.type,\n                isStatic: propertyDetails.isStatic,\n                isReadonly: propertyDetails.isReadOnly,\n            });\n        } else {\n            subject.addVariableStatement({\n                docs: [property.docs],\n                declarations: [\n                    {\n                        name: property.name,\n                        type: propertyDetails.type,\n                    },\n                ],\n            });\n        }\n    }\n\n    for (const 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","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","func","functions","isFunctionNameReserved","includes","resolvedName","parameters","getParameters","addFunction","docs","returnType","getFunctionReturnType","isExported","getFunctionOverrideOptions","addExportDeclaration","namedExports","alias","propertiesSubject","methods","length","typeClass","addClass","getClassOptions","method","addMethod","property","properties","propertyDetails","getPropertyDetails","addProperty","type","isStatic","isReadonly","isReadOnly","addVariableStatement","declarations","eachNamespace","Object","entries","namespaces"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";AAAA,SAASA,aAAa,QAAQ,UAAU;AACxC,SAASC,OAAO,QAAQ,QAAQ;AAChC,SAKIC,OAAO,QAEJ,WAAW;AAElB,SAASC,uBAAuB,QAAQ,qBAAqB;AAG7D,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;gBAEA,MAAMC,kBAAkBb,YAAYc,MAAM;gBAE1CJ,SAASK,aAAa,CAACd,aAAae,mBAAmB;gBAEvDC,kBAAkBJ,iBAAiBH,UAAUT,cAAc;gBAE3DP,cACIK,MACAW,SAASQ,WAAW,GAAGC,OAAO,CAAC,MAAM;YAE7C;YACAC,OAAOpB,gBAAgB,QAAQC,iBAAiB;QACpD;IACJ,GAAG;QAACD;QAAaC;KAAa;IAE9B,OAAO;QACHC;IACJ;AACJ,EAAE;AAEF,MAAMe,oBAAoB,CACtBI,WACAC,iBACArB,cACAsB,WACAC;IAEA,IAAIC,UAAUH;IACd,MAAMI,oBAAoB;QAACH;QAAWC;KAAK,CAACG,MAAM,CAACC,SAASC,IAAI,CAAC;IAEjE,IAAIL,MAAM;QACNC,UAAUH,gBAAgBQ,SAAS,CAAC;YAChCN;QACJ;IACJ;IAEA,IAAIA,SAAS,YAAY;QACrBC,QAAQV,aAAa,CAACd,aAAa8B,aAAa;IACpD;IAEA,KAAK,MAAMC,QAAQX,UAAUY,SAAS,CAAE;QACpC,MAAMC,yBAAyBrC,wBAAwBsC,QAAQ,CAC3DH,KAAKR,IAAI;QAEb,MAAMY,eAAe,CAAC,CAAC,EAAEJ,KAAKR,IAAI,CAAC,CAAC;QACpC,MAAMa,aAAapC,aAAaqC,aAAa,CAACN;QAE9CP,QAAQc,WAAW,CAAC;YAChBf,MAAMU,yBAAyBE,eAAeJ,KAAKR,IAAI;YACvDgB,MAAM;gBAACR,KAAKQ,IAAI;aAAC;YACjBH;YACAI,YAAYxC,aAAayC,qBAAqB,CAACV;YAC/CW,YAAY,CAAC,CAACnB;WACVvB,aAAa2C,0BAA0B,CACvCZ;QAIR,IAAIE,wBAAwB;YACxBT,QAAQoB,oBAAoB,CAAC;gBACzBC,cAAc;oBACV;wBACItB,MAAMY;wBACNW,OAAOf,KAAKR,IAAI;oBACpB;iBACH;YACL;QACJ;IACJ;IAEA,IAAIwB,oBAA6C;IAEjD,IAAIxB,QAAQH,UAAU4B,OAAO,CAACC,MAAM,GAAG,GAAG;QACtC,MAAMC,YAAY7B,gBAAgB8B,QAAQ,CAAC;YACvC5B;WACGvB,aAAaoD,eAAe,CAAC3B;QAEpCsB,oBAAoBG;QAEpB,KAAK,MAAMG,UAAUjC,UAAU4B,OAAO,CAAE;YACpC,MAAMZ,aAAapC,aAAaqC,aAAa,CAACgB;YAE9CH,UAAUI,SAAS,CAAC;gBAChB/B,MAAM8B,OAAO9B,IAAI;gBACjBgB,MAAM;oBAACc,OAAOd,IAAI;iBAAC;gBACnBH;gBACAI,YAAYxC,aAAayC,qBAAqB,CAACY;eAC3CrD,aAAa2C,0BAA0B,CACvCU;QAGZ;IACJ;IAEA,KAAK,MAAME,YAAYnC,UAAUoC,UAAU,CAAE;QACzC,MAAMC,kBAAkBzD,aAAa0D,kBAAkB,CAACH;QAExD,IAAIR,mBAAmB;YACnBA,kBAAkBY,WAAW,CAAC;gBAC1BpC,MAAMgC,SAAShC,IAAI;gBACnBgB,MAAM;oBAACgB,SAAShB,IAAI;iBAAC;gBACrBqB,MAAMH,gBAAgBG,IAAI;gBAC1BC,UAAUJ,gBAAgBI,QAAQ;gBAClCC,YAAYL,gBAAgBM,UAAU;YAC1C;QACJ,OAAO;YACHvC,QAAQwC,oBAAoB,CAAC;gBACzBzB,MAAM;oBAACgB,SAAShB,IAAI;iBAAC;gBACrB0B,cAAc;oBACV;wBACI1C,MAAMgC,SAAShC,IAAI;wBACnBqC,MAAMH,gBAAgBG,IAAI;oBAC9B;iBACH;YACL;QACJ;IACJ;IAEA,KAAK,MAAMM,iBAAiBC,OAAOC,OAAO,CAAChD,UAAUiD,UAAU,EAAG;QAC9DrD,kBACIkD,aAAa,CAAC,EAAE,EAChB1C,SACAxB,cACAyB,mBACAyC,aAAa,CAAC,EAAE;IAExB;AACJ"}

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

@@ -0,0 +1,53 @@
+import { PlaydateSdkVersion } from '../../../types.js';
+export declare const useGetVersion: (version: PlaydateSdkVersion) => {
+    fetchedVersion: string | null;
+    getVersion: {
+        waitingDescription: string;
+        runningDescription: string;
+        errorDescription: string;
+        finishedDescription: (result: string) => string;
+        runner: () => Promise<string>;
+        onFinish: (result: string) => void;
+    };
+    typeProvider: {
+        getGlobalStatements: () => string[];
+        getStatements: () => string[];
+        getClassOptions: (className: string) => Partial<import("ts-morph").ClassDeclarationStructure>;
+        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> | 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;
+            })[];
+        };
+        save: () => void;
+    } | null;
+};

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

@@ -0,0 +1,52 @@
+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);
+        const url = response.url;
+        const regex = /https:\/\/sdk.play.date\/([0-9]+\.[0-9]+\.[0-9]+)\//;
+        const match = url.match(regex);
+        if (!match || match.length < 2) {
+            throw new Error('Could not find version in URL');
+        }
+        return match[1];
+    }, []);
+    const validateVersion = useCallback(async (version)=>{
+        const response = await fetch(`https://sdk.play.date/${version}/`);
+        if (!response.ok) {
+            throw new Error(`Failed to fetch version ${version}`);
+        }
+        return true;
+    }, []);
+    const getVersion = useMemo(()=>{
+        return {
+            waitingDescription: `Waiting to fetch version`,
+            runningDescription: 'Fetching version...',
+            errorDescription: 'Failed to fetch version',
+            finishedDescription: (result)=>`Fetched version ${result}`,
+            runner: async ()=>{
+                let versionLiteral = version;
+                if (version === PlaydateSdkVersionIdentifier.Latest) {
+                    versionLiteral = await fetchLastVersion();
+                }
+                await validateVersion(versionLiteral);
+                setTypeProvider(createTypeProvider(versionLiteral));
+                return versionLiteral;
+            },
+            onFinish: (result)=>{
+                setResult(result);
+            }
+        };
+    }, []);
+    return {
+        fetchedVersion: result,
+        getVersion,
+        typeProvider
+    };
+};
+
+//# sourceMappingURL=useGetVersion.js.map

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

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

@@ -0,0 +1,13 @@
+import { ApiDefinitions } from '../../../types.js';
+export declare const useParseDocumentation: (html: string | null, version: string) => {
+    definitions: ApiDefinitions | null;
+    parseDocumentation: {
+        waitingDescription: string;
+        errorDescription: string;
+        finishedDescription: () => string;
+        runningDescription: string;
+        runner: () => Promise<ApiDefinitions>;
+        onFinish: (result: ApiDefinitions) => void;
+        ready: boolean;
+    };
+};

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

@@ -0,0 +1,34 @@
+import { useMemo, useState } from 'react';
+import { getApiDefinitions } from '../../../commands/GenerateTypes/fn/getApiDefinitions.js';
+import { getDescriptionsFromHtml } from '../../../commands/GenerateTypes/fn/getDescriptionsFromHtml.js';
+import { getFunctionTypeOverride } from '../../../commands/GenerateTypes/fn/getFunctionTypeOverride.js';
+export const useParseDocumentation = (html, version)=>{
+    const [result, setResult] = useState(null);
+    const parseDocumentation = useMemo(()=>{
+        return {
+            waitingDescription: 'Waiting to parse the documentation...',
+            errorDescription: 'Failed to parse the documentation',
+            finishedDescription: ()=>'Documentation parsed',
+            runningDescription: 'Parsing the documentation...',
+            runner: async ()=>{
+                if (!html) {
+                    throw new Error('HTML is not set');
+                }
+                const { functions, properties } = getDescriptionsFromHtml(html, version);
+                return getApiDefinitions(functions, properties, getFunctionTypeOverride(version));
+            },
+            onFinish: (result)=>{
+                setResult(result);
+            },
+            ready: html !== null
+        };
+    }, [
+        html
+    ]);
+    return {
+        definitions: result,
+        parseDocumentation
+    };
+};
+
+//# sourceMappingURL=useParseDocumentation.js.map

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

@@ -0,0 +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 { getDescriptionsFromHtml } from '@/cli/commands/GenerateTypes/fn/getDescriptionsFromHtml.js';\nimport { getFunctionTypeOverride } from '@/cli/commands/GenerateTypes/fn/getFunctionTypeOverride.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(\n                    functions,\n                    properties,\n                    getFunctionTypeOverride(version)\n                );\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","getFunctionTypeOverride","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;AACrG,SAASC,uBAAuB,QAAQ,6DAA6D;AAGrG,OAAO,MAAMC,wBAAwB,CAACC,MAAqBC;IACvD,MAAM,CAACC,QAAQC,UAAU,GAAGR,SAAgC;IAE5D,MAAMS,qBAAqBV,QAAQ;QAC/B,OAAO;YACHW,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,GAAGf,wBAC9BG,MACAC;gBAGJ,OAAOL,kBACHe,WACAC,YACAd,wBAAwBG;YAEhC;YACAY,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/index.d.ts

@@ -0,0 +1 @@
+export * from './GenerateTypesCommand.js';

package/src/commands/GenerateTypes/index.js

@@ -0,0 +1,3 @@
+export * from './GenerateTypesCommand.js';
+
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../libs/cli/src/commands/GenerateTypes/index.ts"],"sourcesContent":["export * from './GenerateTypesCommand.js';\n"],"names":[],"rangeMappings":"","mappings":"AAAA,cAAc,4BAA4B"}