crankscript 0.0.6 → 0.1.5-beta

package/package.json

@@ -1,19 +1,32 @@
 {
-    "name": "crankscript",
-    "version": "0.0.6",
-    "scripts": {
-        "dev": "tsx src/index.ts"
-    },
-    "bin": {
-        "crankscript": "./src/index.js"
-    },
-    "dependencies": {
-        "@swc/helpers": "~0.5.11",
-        "yargs": "^17.7.2"
-    },
-    "type": "module",
-    "main": "./src/index.js",
-    "typings": "./src/index.d.ts",
-    "module": "./src/index.js",
-    "types": "./src/index.d.ts"
+  "name": "crankscript",
+  "version": "0.1.5-beta",
+  "scripts": {
+    "dev": "tsx src/index.ts",
+    "post-build": "tsc-alias --project tsconfig.json",
+    "prepare-assets": "npx tsc -p assets/tsconfig.json"
+  },
+  "bin": {
+    "crankscript": "./src/index.js"
+  },
+  "license": "MIT",
+  "dependencies": {
+    "@inkjs/ui": "^2.0.0",
+    "@swc/helpers": "~0.5.11",
+    "cheerio": "^1.0.0",
+    "clipanion": "^4.0.0-rc.4",
+    "ink": "^5.0.1",
+    "open": "^10.1.0",
+    "react": "^18.3.1",
+    "tiged": "^3.0.0-rc.0",
+    "ts-morph": "^23.0.0",
+    "turndown": "^7.2.0",
+    "typanion": "^3.14.0",
+    "typescript-to-lua": "^1.27.0"
+  },
+  "type": "module",
+  "main": "./src/index.js",
+  "typings": "./src/index.d.ts",
+  "module": "./src/index.js",
+  "types": "./src/index.d.ts"
 }

package/src/commands/CompileCommand/CompileCommand.d.ts

@@ -0,0 +1,8 @@
+import React from 'react';
+import { EnvironmentAwareCommand } from '../../commands/EnvironmentAwareCommand/index.js';
+import { Environment } from '../../environment/dto/Environment.js';
+export declare class CompileCommand extends EnvironmentAwareCommand {
+    static paths: string[][];
+    static usage: import("clipanion").Usage;
+    renderWithEnvironment(environment: Environment): React.JSX.Element;
+}

package/src/commands/CompileCommand/CompileCommand.js

@@ -0,0 +1,21 @@
+import { Command } from 'clipanion';
+import React from 'react';
+import { Compile } from '../../commands/CompileCommand/components/Compile.js';
+import { EnvironmentAwareCommand } from '../../commands/EnvironmentAwareCommand/index.js';
+export class CompileCommand extends EnvironmentAwareCommand {
+    renderWithEnvironment(environment) {
+        return /*#__PURE__*/ React.createElement(Compile, {
+            environment: environment
+        });
+    }
+}
+CompileCommand.paths = [
+    [
+        'compile'
+    ]
+];
+CompileCommand.usage = Command.Usage({
+    description: 'Compiles the code and runs the simulator'
+});
+
+//# sourceMappingURL=CompileCommand.js.map

package/src/commands/CompileCommand/CompileCommand.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../libs/cli/src/commands/CompileCommand/CompileCommand.tsx"],"sourcesContent":["import { Command } from 'clipanion';\nimport React from 'react';\nimport { Compile } from '@/cli/commands/CompileCommand/components/Compile.js';\nimport { EnvironmentAwareCommand } from '@/cli/commands/EnvironmentAwareCommand/index.js';\nimport { Environment } from '@/cli/environment/dto/Environment.js';\n\nexport class CompileCommand extends EnvironmentAwareCommand {\n    static override paths = [['compile']];\n\n    static override usage = Command.Usage({\n        description: 'Compiles the code and runs the simulator',\n    });\n\n    override renderWithEnvironment(environment: Environment) {\n        return <Compile environment={environment} />;\n    }\n}\n"],"names":["Command","React","Compile","EnvironmentAwareCommand","CompileCommand","renderWithEnvironment","environment","paths","usage","Usage","description"],"rangeMappings":";;;;;;;;;;;;;;;;;;","mappings":"AAAA,SAASA,OAAO,QAAQ,YAAY;AACpC,OAAOC,WAAW,QAAQ;AAC1B,SAASC,OAAO,QAAQ,sDAAsD;AAC9E,SAASC,uBAAuB,QAAQ,kDAAkD;AAG1F,OAAO,MAAMC,uBAAuBD;IAOvBE,sBAAsBC,WAAwB,EAAE;QACrD,qBAAO,oBAACJ;YAAQI,aAAaA;;IACjC;AACJ;AAVaF,eACOG,QAAQ;IAAC;QAAC;KAAU;CAAC;AAD5BH,eAGOI,QAAQR,QAAQS,KAAK,CAAC;IAClCC,aAAa;AACjB"}

package/src/commands/CompileCommand/components/Compile.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+import { Environment } from '../../../environment/dto/Environment.js';
+interface Props {
+    environment: Environment;
+}
+export declare const Compile: ({ environment }: Props) => React.JSX.Element;
+export {};

package/src/commands/CompileCommand/components/Compile.js

@@ -0,0 +1,14 @@
+import process from 'node:process';
+import React from 'react';
+import { getPdcPathFromEnvironment } from '../../../commands/CompileCommand/fn/getPdcPathFromEnvironment.js';
+import { useCompileTasks } from '../../../commands/CompileCommand/hooks/useCompileTasks.js';
+import { CheckList } from '../../../components/CheckList/index.js';
+export const Compile = ({ environment })=>{
+    const items = useCompileTasks(getPdcPathFromEnvironment(environment));
+    return /*#__PURE__*/ React.createElement(CheckList, {
+        items: items,
+        onFinish: process.exit
+    });
+};
+
+//# sourceMappingURL=Compile.js.map

package/src/commands/CompileCommand/components/Compile.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../libs/cli/src/commands/CompileCommand/components/Compile.tsx"],"sourcesContent":["import process from 'node:process';\nimport React from 'react';\nimport { getPdcPathFromEnvironment } from '@/cli/commands/CompileCommand/fn/getPdcPathFromEnvironment.js';\nimport { useCompileTasks } from '@/cli/commands/CompileCommand/hooks/useCompileTasks.js';\nimport { CheckList } from '@/cli/components/CheckList/index.js';\nimport { Environment } from '@/cli/environment/dto/Environment.js';\n\ninterface Props {\n    environment: Environment;\n}\n\nexport const Compile = ({ environment }: Props) => {\n    const items = useCompileTasks(getPdcPathFromEnvironment(environment));\n\n    return <CheckList items={items} onFinish={process.exit} />;\n};\n"],"names":["process","React","getPdcPathFromEnvironment","useCompileTasks","CheckList","Compile","environment","items","onFinish","exit"],"rangeMappings":";;;;;;;;;;;","mappings":"AAAA,OAAOA,aAAa,eAAe;AACnC,OAAOC,WAAW,QAAQ;AAC1B,SAASC,yBAAyB,QAAQ,gEAAgE;AAC1G,SAASC,eAAe,QAAQ,yDAAyD;AACzF,SAASC,SAAS,QAAQ,sCAAsC;AAOhE,OAAO,MAAMC,UAAU,CAAC,EAAEC,WAAW,EAAS;IAC1C,MAAMC,QAAQJ,gBAAgBD,0BAA0BI;IAExD,qBAAO,oBAACF;QAAUG,OAAOA;QAAOC,UAAUR,QAAQS,IAAI;;AAC1D,EAAE"}

package/src/commands/CompileCommand/fn/getPdcPathFromEnvironment.d.ts

@@ -0,0 +1,2 @@
+import { Environment } from '../../../environment/dto/Environment.js';
+export declare const getPdcPathFromEnvironment: (environment: Environment) => string;

package/src/commands/CompileCommand/fn/getPdcPathFromEnvironment.js

@@ -0,0 +1,6 @@
+import { join } from 'node:path';
+export const getPdcPathFromEnvironment = (environment)=>{
+    return join(environment.sdkPath.path, 'bin', 'pdc');
+};
+
+//# sourceMappingURL=getPdcPathFromEnvironment.js.map

package/src/commands/CompileCommand/fn/getPdcPathFromEnvironment.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../libs/cli/src/commands/CompileCommand/fn/getPdcPathFromEnvironment.ts"],"sourcesContent":["import { join } from 'node:path';\nimport { Environment } from '@/cli/environment/dto/Environment.js';\n\nexport const getPdcPathFromEnvironment = (environment: Environment) => {\n    return join(environment.sdkPath.path, 'bin', 'pdc');\n};\n"],"names":["join","getPdcPathFromEnvironment","environment","sdkPath","path"],"rangeMappings":";;;","mappings":"AAAA,SAASA,IAAI,QAAQ,YAAY;AAGjC,OAAO,MAAMC,4BAA4B,CAACC;IACtC,OAAOF,KAAKE,YAAYC,OAAO,CAACC,IAAI,EAAE,OAAO;AACjD,EAAE"}

package/src/commands/CompileCommand/fn/getSimulatorPathFromEnvironment.d.ts

@@ -0,0 +1,2 @@
+import { Environment } from '../../../environment/dto/Environment.js';
+export declare const getSimulatorPathFromEnvironment: (environment: Environment) => string;

package/src/commands/CompileCommand/fn/getSimulatorPathFromEnvironment.js

@@ -0,0 +1,6 @@
+import { join } from 'node:path';
+export const getSimulatorPathFromEnvironment = (environment)=>{
+    return join(environment.sdkPath.path, 'bin', 'PlaydateSimulator');
+};
+
+//# sourceMappingURL=getSimulatorPathFromEnvironment.js.map

package/src/commands/CompileCommand/fn/getSimulatorPathFromEnvironment.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../libs/cli/src/commands/CompileCommand/fn/getSimulatorPathFromEnvironment.ts"],"sourcesContent":["import { join } from 'node:path';\nimport { Environment } from '@/cli/environment/dto/Environment.js';\n\nexport const getSimulatorPathFromEnvironment = (environment: Environment) => {\n    return join(environment.sdkPath.path, 'bin', 'PlaydateSimulator');\n};\n"],"names":["join","getSimulatorPathFromEnvironment","environment","sdkPath","path"],"rangeMappings":";;;","mappings":"AAAA,SAASA,IAAI,QAAQ,YAAY;AAGjC,OAAO,MAAMC,kCAAkC,CAACC;IAC5C,OAAOF,KAAKE,YAAYC,OAAO,CAACC,IAAI,EAAE,OAAO;AACjD,EAAE"}

package/src/commands/CompileCommand/hooks/useCompileTasks.d.ts

@@ -0,0 +1,2 @@
+import { CheckListItem } from '../../../types.js';
+export declare const useCompileTasks: (pdcPath: string) => CheckListItem<unknown>[];

package/src/commands/CompileCommand/hooks/useCompileTasks.js

@@ -0,0 +1,60 @@
+import { spawn } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import { useMemo } from 'react';
+export const useCompileTasks = (pdcPath)=>{
+    return useMemo(()=>[
+            {
+                waitingDescription: 'Waiting to check for pdc binary...',
+                errorDescription: 'Could not find pdc binary',
+                runningDescription: 'Checking for pdc binary...',
+                finishedDescription: (result)=>`Found pdc binary at "${result}"`,
+                runner: async ()=>{
+                    if (!existsSync(pdcPath)) {
+                        throw new Error('Could not find pdc binary');
+                    }
+                    return pdcPath;
+                },
+                ready: true
+            },
+            {
+                waitingDescription: 'Waiting for pdc binary path...',
+                errorDescription: 'Could not compile lua code',
+                runningDescription: 'Compiling lua code...',
+                finishedDescription: ()=>'Lua code compiled',
+                runner: async ()=>{
+                    return new Promise((resolve, reject)=>{
+                        const pdc = spawn(pdcPath, [
+                            'Source',
+                            'Game.pdx'
+                        ]);
+                        // Collect any standard output or errors
+                        let stdout = '';
+                        let stderr = '';
+                        // Handle stdout (standard output)
+                        pdc.stdout.on('data', (data)=>{
+                            stdout += data.toString();
+                        });
+                        // Handle stderr (standard error)
+                        pdc.stderr.on('data', (data)=>{
+                            stderr += data.toString();
+                        });
+                        // Handle the process closing
+                        pdc.on('close', (code)=>{
+                            if (code === 0) {
+                                resolve(stdout); // Resolve the promise with the output
+                            } else {
+                                reject(new Error(`pdc exited with code ${code}: ${stderr}`));
+                            }
+                        });
+                        // Handle any errors that occur while starting the process
+                        pdc.on('error', (err)=>{
+                            reject(new Error(`Failed to start pdc process: ${err.message}`));
+                        });
+                    });
+                },
+                ready: true
+            }
+        ], []);
+};
+
+//# sourceMappingURL=useCompileTasks.js.map

package/src/commands/CompileCommand/hooks/useCompileTasks.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../libs/cli/src/commands/CompileCommand/hooks/useCompileTasks.ts"],"sourcesContent":["import { spawn } from 'node:child_process';\nimport { existsSync } from 'node:fs';\nimport { useMemo } from 'react';\nimport { CheckListItem } from '@/cli/types.js';\n\nexport const useCompileTasks = (pdcPath: string) => {\n    return useMemo(\n        () => [\n            {\n                waitingDescription: 'Waiting to check for pdc binary...',\n                errorDescription: 'Could not find pdc binary',\n                runningDescription: 'Checking for pdc binary...',\n                finishedDescription: (result) =>\n                    `Found pdc binary at \"${result}\"`,\n                runner: async () => {\n                    if (!existsSync(pdcPath)) {\n                        throw new Error('Could not find pdc binary');\n                    }\n\n                    return pdcPath;\n                },\n                ready: true,\n            } satisfies CheckListItem<string>,\n            {\n                waitingDescription: 'Waiting for pdc binary path...',\n                errorDescription: 'Could not compile lua code',\n                runningDescription: 'Compiling lua code...',\n                finishedDescription: () => 'Lua code compiled',\n                runner: async () => {\n                    return new Promise((resolve, reject) => {\n                        const pdc = spawn(pdcPath, ['Source', 'Game.pdx']);\n\n                        // Collect any standard output or errors\n                        let stdout = '';\n                        let stderr = '';\n\n                        // Handle stdout (standard output)\n                        pdc.stdout.on('data', (data) => {\n                            stdout += data.toString();\n                        });\n\n                        // Handle stderr (standard error)\n                        pdc.stderr.on('data', (data) => {\n                            stderr += data.toString();\n                        });\n\n                        // Handle the process closing\n                        pdc.on('close', (code) => {\n                            if (code === 0) {\n                                resolve(stdout); // Resolve the promise with the output\n                            } else {\n                                reject(\n                                    new Error(\n                                        `pdc exited with code ${code}: ${stderr}`\n                                    )\n                                );\n                            }\n                        });\n\n                        // Handle any errors that occur while starting the process\n                        pdc.on('error', (err) => {\n                            reject(\n                                new Error(\n                                    `Failed to start pdc process: ${err.message}`\n                                )\n                            );\n                        });\n                    });\n                },\n                ready: true,\n            },\n        ],\n        []\n    ) as CheckListItem<unknown>[];\n};\n"],"names":["spawn","existsSync","useMemo","useCompileTasks","pdcPath","waitingDescription","errorDescription","runningDescription","finishedDescription","result","runner","Error","ready","Promise","resolve","reject","pdc","stdout","stderr","on","data","toString","code","err","message"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAAA,SAASA,KAAK,QAAQ,qBAAqB;AAC3C,SAASC,UAAU,QAAQ,UAAU;AACrC,SAASC,OAAO,QAAQ,QAAQ;AAGhC,OAAO,MAAMC,kBAAkB,CAACC;IAC5B,OAAOF,QACH,IAAM;YACF;gBACIG,oBAAoB;gBACpBC,kBAAkB;gBAClBC,oBAAoB;gBACpBC,qBAAqB,CAACC,SAClB,CAAC,qBAAqB,EAAEA,OAAO,CAAC,CAAC;gBACrCC,QAAQ;oBACJ,IAAI,CAACT,WAAWG,UAAU;wBACtB,MAAM,IAAIO,MAAM;oBACpB;oBAEA,OAAOP;gBACX;gBACAQ,OAAO;YACX;YACA;gBACIP,oBAAoB;gBACpBC,kBAAkB;gBAClBC,oBAAoB;gBACpBC,qBAAqB,IAAM;gBAC3BE,QAAQ;oBACJ,OAAO,IAAIG,QAAQ,CAACC,SAASC;wBACzB,MAAMC,MAAMhB,MAAMI,SAAS;4BAAC;4BAAU;yBAAW;wBAEjD,wCAAwC;wBACxC,IAAIa,SAAS;wBACb,IAAIC,SAAS;wBAEb,kCAAkC;wBAClCF,IAAIC,MAAM,CAACE,EAAE,CAAC,QAAQ,CAACC;4BACnBH,UAAUG,KAAKC,QAAQ;wBAC3B;wBAEA,iCAAiC;wBACjCL,IAAIE,MAAM,CAACC,EAAE,CAAC,QAAQ,CAACC;4BACnBF,UAAUE,KAAKC,QAAQ;wBAC3B;wBAEA,6BAA6B;wBAC7BL,IAAIG,EAAE,CAAC,SAAS,CAACG;4BACb,IAAIA,SAAS,GAAG;gCACZR,QAAQG,SAAS,sCAAsC;4BAC3D,OAAO;gCACHF,OACI,IAAIJ,MACA,CAAC,qBAAqB,EAAEW,KAAK,EAAE,EAAEJ,OAAO,CAAC;4BAGrD;wBACJ;wBAEA,0DAA0D;wBAC1DF,IAAIG,EAAE,CAAC,SAAS,CAACI;4BACbR,OACI,IAAIJ,MACA,CAAC,6BAA6B,EAAEY,IAAIC,OAAO,CAAC,CAAC;wBAGzD;oBACJ;gBACJ;gBACAZ,OAAO;YACX;SACH,EACD,EAAE;AAEV,EAAE"}

package/src/commands/CompileCommand/index.d.ts

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

package/src/commands/CompileCommand/index.js

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

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

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

package/src/commands/DoctorCommand.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+import { RenderableCommand } from './RenderableCommand.js';
+export declare class DoctorCommand extends RenderableCommand {
+    static paths: string[][];
+    static usage: import("clipanion").Usage;
+    render(): React.JSX.Element;
+}

package/src/commands/DoctorCommand.js

@@ -0,0 +1,26 @@
+import { Command } from 'clipanion';
+import { Text } from 'ink';
+import React from 'react';
+import { createEnvironment } from '../environment/createEnvironment.js';
+import { HealthReport } from './EnvironmentAwareCommand/components/HealthReport.js';
+import { RenderableCommand } from './RenderableCommand.js';
+export class DoctorCommand extends RenderableCommand {
+    render() {
+        const environment = createEnvironment();
+        return /*#__PURE__*/ React.createElement(React.Fragment, null, /*#__PURE__*/ React.createElement(Text, {
+            color: "gray"
+        }, "Checking the environment..."), /*#__PURE__*/ React.createElement(HealthReport, {
+            environment: environment
+        }));
+    }
+}
+DoctorCommand.paths = [
+    [
+        'doctor'
+    ]
+];
+DoctorCommand.usage = Command.Usage({
+    description: 'Check the health of the environment'
+});
+
+//# sourceMappingURL=DoctorCommand.js.map

package/src/commands/DoctorCommand.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../libs/cli/src/commands/DoctorCommand.tsx"],"sourcesContent":["import { Command } from 'clipanion';\nimport { Text } from 'ink';\nimport React from 'react';\nimport { createEnvironment } from '@/cli/environment/createEnvironment.js';\nimport { HealthReport } from './EnvironmentAwareCommand/components/HealthReport.js';\nimport { RenderableCommand } from './RenderableCommand.js';\n\nexport class DoctorCommand extends RenderableCommand {\n    static override paths = [['doctor']];\n\n    static override usage = Command.Usage({\n        description: 'Check the health of the environment',\n    });\n\n    override render() {\n        const environment = createEnvironment();\n\n        return (\n            <>\n                <Text color=\"gray\">Checking the environment...</Text>\n                <HealthReport environment={environment} />\n            </>\n        );\n    }\n}\n"],"names":["Command","Text","React","createEnvironment","HealthReport","RenderableCommand","DoctorCommand","render","environment","color","paths","usage","Usage","description"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAAA,SAASA,OAAO,QAAQ,YAAY;AACpC,SAASC,IAAI,QAAQ,MAAM;AAC3B,OAAOC,WAAW,QAAQ;AAC1B,SAASC,iBAAiB,QAAQ,yCAAyC;AAC3E,SAASC,YAAY,QAAQ,uDAAuD;AACpF,SAASC,iBAAiB,QAAQ,yBAAyB;AAE3D,OAAO,MAAMC,sBAAsBD;IAOtBE,SAAS;QACd,MAAMC,cAAcL;QAEpB,qBACI,wDACI,oBAACF;YAAKQ,OAAM;WAAO,8CACnB,oBAACL;YAAaI,aAAaA;;IAGvC;AACJ;AAjBaF,cACOI,QAAQ;IAAC;QAAC;KAAS;CAAC;AAD3BJ,cAGOK,QAAQX,QAAQY,KAAK,CAAC;IAClCC,aAAa;AACjB"}

package/src/commands/EnvironmentAwareCommand/EnvironmentAwareCommand.d.ts

@@ -0,0 +1,9 @@
+import { JSX } from 'react';
+import { RenderableCommand } from '../../commands/RenderableCommand.js';
+import { Environment } from '../../environment/dto/Environment.js';
+export declare abstract class EnvironmentAwareCommand extends RenderableCommand {
+    private environment;
+    protected abstract renderWithEnvironment(environment: Environment): JSX.Element;
+    render(): JSX.Element;
+    execute(): Promise<void>;
+}

package/src/commands/EnvironmentAwareCommand/EnvironmentAwareCommand.js

@@ -0,0 +1,25 @@
+import React from 'react';
+import { HealthReport } from '../../commands/EnvironmentAwareCommand/components/HealthReport.js';
+import { RenderableCommand } from '../../commands/RenderableCommand.js';
+import { createEnvironment } from '../../environment/createEnvironment.js';
+export class EnvironmentAwareCommand extends RenderableCommand {
+    render() {
+        if (!this.environment) {
+            throw new Error('Environment is not set');
+        }
+        return this.renderWithEnvironment(this.environment);
+    }
+    async execute() {
+        const environmentHealth = createEnvironment();
+        if (!environmentHealth.isHealthy) {
+            this.renderElement(/*#__PURE__*/ React.createElement(HealthReport, {
+                environment: environmentHealth
+            }));
+            return;
+        }
+        this.environment = environmentHealth.environment;
+        this.renderElement(this.render());
+    }
+}
+
+//# sourceMappingURL=EnvironmentAwareCommand.js.map

package/src/commands/EnvironmentAwareCommand/EnvironmentAwareCommand.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../libs/cli/src/commands/EnvironmentAwareCommand/EnvironmentAwareCommand.tsx"],"sourcesContent":["import React, { JSX } from 'react';\nimport { HealthReport } from '@/cli/commands/EnvironmentAwareCommand/components/HealthReport.js';\nimport { RenderableCommand } from '@/cli/commands/RenderableCommand.js';\nimport { createEnvironment } from '@/cli/environment/createEnvironment.js';\nimport { Environment } from '@/cli/environment/dto/Environment.js';\n\nexport abstract class EnvironmentAwareCommand extends RenderableCommand {\n    private environment: Environment | undefined;\n\n    protected abstract renderWithEnvironment(\n        environment: Environment\n    ): JSX.Element;\n\n    override render() {\n        if (!this.environment) {\n            throw new Error('Environment is not set');\n        }\n\n        return this.renderWithEnvironment(this.environment);\n    }\n\n    override async execute() {\n        const environmentHealth = createEnvironment();\n\n        if (!environmentHealth.isHealthy) {\n            this.renderElement(\n                <HealthReport environment={environmentHealth} />\n            );\n\n            return;\n        }\n\n        this.environment = environmentHealth.environment;\n\n        this.renderElement(this.render());\n    }\n}\n"],"names":["React","HealthReport","RenderableCommand","createEnvironment","EnvironmentAwareCommand","render","environment","Error","renderWithEnvironment","execute","environmentHealth","isHealthy","renderElement"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;","mappings":"AAAA,OAAOA,WAAoB,QAAQ;AACnC,SAASC,YAAY,QAAQ,oEAAoE;AACjG,SAASC,iBAAiB,QAAQ,sCAAsC;AACxE,SAASC,iBAAiB,QAAQ,yCAAyC;AAG3E,OAAO,MAAeC,gCAAgCF;IAOzCG,SAAS;QACd,IAAI,CAAC,IAAI,CAACC,WAAW,EAAE;YACnB,MAAM,IAAIC,MAAM;QACpB;QAEA,OAAO,IAAI,CAACC,qBAAqB,CAAC,IAAI,CAACF,WAAW;IACtD;IAEA,MAAeG,UAAU;QACrB,MAAMC,oBAAoBP;QAE1B,IAAI,CAACO,kBAAkBC,SAAS,EAAE;YAC9B,IAAI,CAACC,aAAa,eACd,oBAACX;gBAAaK,aAAaI;;YAG/B;QACJ;QAEA,IAAI,CAACJ,WAAW,GAAGI,kBAAkBJ,WAAW;QAEhD,IAAI,CAACM,aAAa,CAAC,IAAI,CAACP,MAAM;IAClC;AACJ"}

package/src/commands/EnvironmentAwareCommand/components/HealthReport.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+import { EnvironmentHealthResult } from '../../../types.js';
+interface Props {
+    environment: EnvironmentHealthResult;
+}
+export declare const HealthReport: ({ environment }: Props) => React.JSX.Element[];
+export {};

package/src/commands/EnvironmentAwareCommand/components/HealthReport.js

@@ -0,0 +1,41 @@
+import { StatusMessage } from '@inkjs/ui';
+import { Text } from 'ink';
+import React from 'react';
+import { HealthCheckStatusType } from '../../../types.js';
+const SuccessMessages = {
+    sdkPathKnown: {
+        [HealthCheckStatusType.Unknown]: 'SDK path status unknown',
+        [HealthCheckStatusType.Healthy]: (sdkPath)=>`SDK path found ("${sdkPath.path}")`,
+        [HealthCheckStatusType.Unhealthy]: 'SDK path not found'
+    }
+};
+const ColorMap = {
+    [HealthCheckStatusType.Healthy]: 'green',
+    [HealthCheckStatusType.Unhealthy]: 'red',
+    [HealthCheckStatusType.Unknown]: 'gray'
+};
+export const HealthReport = ({ environment })=>{
+    const { health } = environment;
+    return Object.keys(health).map((eachKey)=>{
+        const healthKey = eachKey;
+        const keyHealth = health[healthKey];
+        let variant = 'info';
+        let message = SuccessMessages[healthKey][HealthCheckStatusType.Unknown];
+        if (health[healthKey].healthStatus === HealthCheckStatusType.Unhealthy) {
+            message = SuccessMessages[healthKey][HealthCheckStatusType.Unhealthy];
+            variant = 'error';
+        }
+        if (health[healthKey].healthStatus === HealthCheckStatusType.Healthy) {
+            message = SuccessMessages[healthKey][HealthCheckStatusType.Healthy](health[healthKey].argument);
+            variant = 'success';
+        }
+        return /*#__PURE__*/ React.createElement(StatusMessage, {
+            key: healthKey,
+            variant: variant
+        }, /*#__PURE__*/ React.createElement(Text, {
+            color: ColorMap[keyHealth.healthStatus]
+        }, keyHealth.healthStatus === HealthCheckStatusType.Unhealthy && ' ', message));
+    });
+};
+
+//# sourceMappingURL=HealthReport.js.map

package/src/commands/EnvironmentAwareCommand/components/HealthReport.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../libs/cli/src/commands/EnvironmentAwareCommand/components/HealthReport.tsx"],"sourcesContent":["import { StatusMessage, StatusMessageProps } from '@inkjs/ui';\nimport { Text, TextProps } from 'ink';\nimport React from 'react';\nimport { PlaydateSdkPath } from '@/cli/environment/path/dto/PlaydateSdkPath.js';\nimport {\n    EnvironmentHealth,\n    EnvironmentHealthResult,\n    HealthCheckStatusType,\n} from '@/cli/types.js';\n\ninterface Props {\n    environment: EnvironmentHealthResult;\n}\n\nconst SuccessMessages = {\n    sdkPathKnown: {\n        [HealthCheckStatusType.Unknown]: 'SDK path status unknown',\n        [HealthCheckStatusType.Healthy]: (sdkPath: PlaydateSdkPath) =>\n            `SDK path found (\"${sdkPath.path}\")`,\n        [HealthCheckStatusType.Unhealthy]: 'SDK path not found',\n    },\n} as const;\n\nconst ColorMap = {\n    [HealthCheckStatusType.Healthy]: 'green',\n    [HealthCheckStatusType.Unhealthy]: 'red',\n    [HealthCheckStatusType.Unknown]: 'gray',\n} satisfies {\n    [key in HealthCheckStatusType]: TextProps['color'];\n};\n\nexport const HealthReport = ({ environment }: Props) => {\n    const { health } = environment;\n    return Object.keys(health).map((eachKey) => {\n        const healthKey = eachKey as keyof EnvironmentHealth;\n        const keyHealth = health[healthKey];\n\n        let variant: StatusMessageProps['variant'] = 'info';\n        let message: string =\n            SuccessMessages[healthKey][HealthCheckStatusType.Unknown];\n\n        if (\n            health[healthKey].healthStatus === HealthCheckStatusType.Unhealthy\n        ) {\n            message =\n                SuccessMessages[healthKey][HealthCheckStatusType.Unhealthy];\n            variant = 'error';\n        }\n\n        if (health[healthKey].healthStatus === HealthCheckStatusType.Healthy) {\n            message = SuccessMessages[healthKey][HealthCheckStatusType.Healthy](\n                health[healthKey].argument\n            );\n            variant = 'success';\n        }\n\n        return (\n            <StatusMessage key={healthKey} variant={variant}>\n                <Text color={ColorMap[keyHealth.healthStatus]}>\n                    {keyHealth.healthStatus ===\n                        HealthCheckStatusType.Unhealthy && ' '}\n                    {message}\n                </Text>\n            </StatusMessage>\n        );\n    });\n};\n"],"names":["StatusMessage","Text","React","HealthCheckStatusType","SuccessMessages","sdkPathKnown","Unknown","Healthy","sdkPath","path","Unhealthy","ColorMap","HealthReport","environment","health","Object","keys","map","eachKey","healthKey","keyHealth","variant","message","healthStatus","argument","key","color"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAAA,SAASA,aAAa,QAA4B,YAAY;AAC9D,SAASC,IAAI,QAAmB,MAAM;AACtC,OAAOC,WAAW,QAAQ;AAE1B,SAGIC,qBAAqB,QAClB,iBAAiB;AAMxB,MAAMC,kBAAkB;IACpBC,cAAc;QACV,CAACF,sBAAsBG,OAAO,CAAC,EAAE;QACjC,CAACH,sBAAsBI,OAAO,CAAC,EAAE,CAACC,UAC9B,CAAC,iBAAiB,EAAEA,QAAQC,IAAI,CAAC,EAAE,CAAC;QACxC,CAACN,sBAAsBO,SAAS,CAAC,EAAE;IACvC;AACJ;AAEA,MAAMC,WAAW;IACb,CAACR,sBAAsBI,OAAO,CAAC,EAAE;IACjC,CAACJ,sBAAsBO,SAAS,CAAC,EAAE;IACnC,CAACP,sBAAsBG,OAAO,CAAC,EAAE;AACrC;AAIA,OAAO,MAAMM,eAAe,CAAC,EAAEC,WAAW,EAAS;IAC/C,MAAM,EAAEC,MAAM,EAAE,GAAGD;IACnB,OAAOE,OAAOC,IAAI,CAACF,QAAQG,GAAG,CAAC,CAACC;QAC5B,MAAMC,YAAYD;QAClB,MAAME,YAAYN,MAAM,CAACK,UAAU;QAEnC,IAAIE,UAAyC;QAC7C,IAAIC,UACAlB,eAAe,CAACe,UAAU,CAAChB,sBAAsBG,OAAO,CAAC;QAE7D,IACIQ,MAAM,CAACK,UAAU,CAACI,YAAY,KAAKpB,sBAAsBO,SAAS,EACpE;YACEY,UACIlB,eAAe,CAACe,UAAU,CAAChB,sBAAsBO,SAAS,CAAC;YAC/DW,UAAU;QACd;QAEA,IAAIP,MAAM,CAACK,UAAU,CAACI,YAAY,KAAKpB,sBAAsBI,OAAO,EAAE;YAClEe,UAAUlB,eAAe,CAACe,UAAU,CAAChB,sBAAsBI,OAAO,CAAC,CAC/DO,MAAM,CAACK,UAAU,CAACK,QAAQ;YAE9BH,UAAU;QACd;QAEA,qBACI,oBAACrB;YAAcyB,KAAKN;YAAWE,SAASA;yBACpC,oBAACpB;YAAKyB,OAAOf,QAAQ,CAACS,UAAUG,YAAY,CAAC;WACxCH,UAAUG,YAAY,KACnBpB,sBAAsBO,SAAS,IAAI,KACtCY;IAIjB;AACJ,EAAE"}

package/src/commands/EnvironmentAwareCommand/index.d.ts

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

package/src/commands/EnvironmentAwareCommand/index.js

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

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

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

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

@@ -0,0 +1,10 @@
+import React from 'react';
+import { RenderableCommand } from '../../commands/RenderableCommand.js';
+export declare class GenerateTypesCommand extends RenderableCommand {
+    static paths: string[][];
+    static usage: import("clipanion").Usage;
+    output: string;
+    overwriteJson: boolean;
+    version: any;
+    render(): React.JSX.Element;
+}

package/src/commands/GenerateTypes/GenerateTypesCommand.js

@@ -0,0 +1,45 @@
+import { join } from 'node:path';
+import * as process from 'node:process';
+import { Command, Option } from 'clipanion';
+import React from 'react';
+import * as t from 'typanion';
+import { RenderableCommand } from '../../commands/RenderableCommand.js';
+import { PlaydateSdkVersionIdentifier } from '../../types.js';
+import { GenerateTypes } from './components/GenerateTypes.js';
+export class GenerateTypesCommand extends RenderableCommand {
+    render() {
+        const output = this.output.endsWith('.d.ts') ? this.output : join(this.output, 'playdate.d.ts');
+        return /*#__PURE__*/ React.createElement(GenerateTypes, {
+            output: output,
+            version: this.version,
+            overwriteJson: this.overwriteJson
+        });
+    }
+    constructor(...args){
+        super(...args);
+        this.output = Option.String('-o,--output', process.cwd(), {
+            description: `Where to generate the playdate.d.ts file. Defaults to the current working directory ("${process.cwd()}")`,
+            validator: t.isString()
+        });
+        this.overwriteJson = Option.Boolean('-j,--overwrite-json', false, {
+            description: 'Overwrite the JSON data file with the new data'
+        });
+        this.version = Option.String({
+            name: 'version',
+            validator: t.isOneOf([
+                t.isLiteral(PlaydateSdkVersionIdentifier.Latest),
+                t.matchesRegExp(/^[0-9]+\.[0-9]+\.[0-9]+$/)
+            ])
+        });
+    }
+}
+GenerateTypesCommand.paths = [
+    [
+        'generate-types'
+    ]
+];
+GenerateTypesCommand.usage = Command.Usage({
+    description: 'Generate types from the Playdate SDK documentation'
+});
+
+//# sourceMappingURL=GenerateTypesCommand.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../libs/cli/src/commands/GenerateTypes/GenerateTypesCommand.tsx"],"sourcesContent":["import { join } from 'node:path';\nimport * as process from 'node:process';\nimport { Command, Option } from 'clipanion';\nimport React from 'react';\nimport * as t from 'typanion';\nimport { AnyStrictValidator } from 'typanion';\nimport { RenderableCommand } from '@/cli/commands/RenderableCommand.js';\nimport { PlaydateSdkVersionIdentifier } from '@/cli/types.js';\nimport { GenerateTypes } from './components/GenerateTypes.js';\n\nexport class GenerateTypesCommand extends RenderableCommand {\n    static override paths = [['generate-types']];\n    static override usage = Command.Usage({\n        description: 'Generate types from the Playdate SDK documentation',\n    });\n\n    output = Option.String('-o,--output', process.cwd(), {\n        description: `Where to generate the playdate.d.ts file. Defaults to the current working directory (\"${process.cwd()}\")`,\n        validator: t.isString(),\n    });\n\n    overwriteJson = Option.Boolean('-j,--overwrite-json', false, {\n        description: 'Overwrite the JSON data file with the new data',\n    });\n\n    version = Option.String({\n        name: 'version',\n        validator: t.isOneOf([\n            t.isLiteral(PlaydateSdkVersionIdentifier.Latest),\n            t.matchesRegExp(/^[0-9]+\\.[0-9]+\\.[0-9]+$/) as AnyStrictValidator,\n        ]),\n    });\n\n    override render() {\n        const output = this.output.endsWith('.d.ts')\n            ? this.output\n            : join(this.output, 'playdate.d.ts');\n\n        return (\n            <GenerateTypes\n                output={output}\n                version={this.version}\n                overwriteJson={this.overwriteJson}\n            />\n        );\n    }\n}\n"],"names":["join","process","Command","Option","React","t","RenderableCommand","PlaydateSdkVersionIdentifier","GenerateTypes","GenerateTypesCommand","render","output","endsWith","version","overwriteJson","String","cwd","description","validator","isString","Boolean","name","isOneOf","isLiteral","Latest","matchesRegExp","paths","usage","Usage"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAAA,SAASA,IAAI,QAAQ,YAAY;AACjC,YAAYC,aAAa,eAAe;AACxC,SAASC,OAAO,EAAEC,MAAM,QAAQ,YAAY;AAC5C,OAAOC,WAAW,QAAQ;AAC1B,YAAYC,OAAO,WAAW;AAE9B,SAASC,iBAAiB,QAAQ,sCAAsC;AACxE,SAASC,4BAA4B,QAAQ,iBAAiB;AAC9D,SAASC,aAAa,QAAQ,gCAAgC;AAE9D,OAAO,MAAMC,6BAA6BH;IAuB7BI,SAAS;QACd,MAAMC,SAAS,IAAI,CAACA,MAAM,CAACC,QAAQ,CAAC,WAC9B,IAAI,CAACD,MAAM,GACXX,KAAK,IAAI,CAACW,MAAM,EAAE;QAExB,qBACI,oBAACH;YACGG,QAAQA;YACRE,SAAS,IAAI,CAACA,OAAO;YACrBC,eAAe,IAAI,CAACA,aAAa;;IAG7C;;;aA7BAH,SAASR,OAAOY,MAAM,CAAC,eAAed,QAAQe,GAAG,IAAI;YACjDC,aAAa,CAAC,sFAAsF,EAAEhB,QAAQe,GAAG,GAAG,EAAE,CAAC;YACvHE,WAAWb,EAAEc,QAAQ;QACzB;aAEAL,gBAAgBX,OAAOiB,OAAO,CAAC,uBAAuB,OAAO;YACzDH,aAAa;QACjB;aAEAJ,UAAUV,OAAOY,MAAM,CAAC;YACpBM,MAAM;YACNH,WAAWb,EAAEiB,OAAO,CAAC;gBACjBjB,EAAEkB,SAAS,CAAChB,6BAA6BiB,MAAM;gBAC/CnB,EAAEoB,aAAa,CAAC;aACnB;QACL;;AAeJ;AApCahB,qBACOiB,QAAQ;IAAC;QAAC;KAAiB;CAAC;AADnCjB,qBAEOkB,QAAQzB,QAAQ0B,KAAK,CAAC;IAClCX,aAAa;AACjB"}

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

@@ -0,0 +1,9 @@
+import React from 'react';
+import { PlaydateSdkVersion } from '../../../types.js';
+interface Props {
+    output: string;
+    version: PlaydateSdkVersion;
+    overwriteJson: boolean;
+}
+export declare const GenerateTypes: ({ output, version, overwriteJson }: Props) => React.JSX.Element;
+export {};

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

@@ -0,0 +1,36 @@
+import React, { useMemo } from 'react';
+import { useFetchHtml } from '../../../commands/GenerateTypes/hooks/useFetchHtml.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';
+import { CheckList } from '../../../components/CheckList/index.js';
+export const GenerateTypes = ({ output, version, overwriteJson })=>{
+    const { typeProvider, fetchedVersion, getVersion } = useGetVersion(version);
+    const { html, fetchHtml } = useFetchHtml(fetchedVersion);
+    const { definitions, parseDocumentation } = useParseDocumentation(html, version);
+    const { generateTypeFile } = useGenerateTypeFile(output, definitions, typeProvider);
+    const items = useMemo(()=>{
+        return [
+            getVersion,
+            fetchHtml,
+            parseDocumentation,
+            generateTypeFile
+        ];
+    }, [
+        fetchedVersion,
+        html,
+        definitions,
+        typeProvider
+    ]);
+    return /*#__PURE__*/ React.createElement(CheckList, {
+        items: items,
+        onFinish: ()=>{
+            if (overwriteJson) {
+                typeProvider == null ? void 0 : typeProvider.save();
+            }
+            process.exit();
+        }
+    });
+};
+
+//# sourceMappingURL=GenerateTypes.js.map

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

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

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

@@ -0,0 +1 @@
+export declare const PlaydateSdkUrl = "https://sdk.play.date/";

package/src/commands/GenerateTypes/constants.js

@@ -0,0 +1,3 @@
+export const PlaydateSdkUrl = 'https://sdk.play.date/';
+
+//# sourceMappingURL=constants.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../libs/cli/src/commands/GenerateTypes/constants.ts"],"sourcesContent":["export const PlaydateSdkUrl = 'https://sdk.play.date/';\n"],"names":["PlaydateSdkUrl"],"rangeMappings":"","mappings":"AAAA,OAAO,MAAMA,iBAAiB,yBAAyB"}

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

@@ -0,0 +1,2 @@
+import { ApiDefinitions, FunctionDescription, PropertyDescription, FunctionTypeOverrideMap } from '../../../types.js';
+export declare const getApiDefinitions: (functions: FunctionDescription[], properties: PropertyDescription[], functionTypeOverride: FunctionTypeOverrideMap) => ApiDefinitions;

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

@@ -0,0 +1,39 @@
+export const getApiDefinitions = (functions, properties, functionTypeOverride)=>{
+    const global = {
+        functions: [],
+        methods: [],
+        properties: [],
+        namespaces: {}
+    };
+    const getOrCreateNamespace = (path, root)=>{
+        return path.reduce((currentNamespace, ns)=>{
+            if (!currentNamespace.namespaces[ns]) {
+                currentNamespace.namespaces[ns] = {
+                    functions: [],
+                    methods: [],
+                    properties: [],
+                    namespaces: {}
+                };
+            }
+            return currentNamespace.namespaces[ns];
+        }, root);
+    };
+    functions.forEach((func)=>{
+        var _functionTypeOverride_func_signature;
+        const targetNamespace = getOrCreateNamespace(func.namespaces, global);
+        if (func.hasSelf || ((_functionTypeOverride_func_signature = functionTypeOverride[func.signature]) == null ? void 0 : _functionTypeOverride_func_signature.isMethod)) {
+            targetNamespace.methods.push(func);
+        } else {
+            targetNamespace.functions.push(func);
+        }
+    });
+    properties.forEach((prop)=>{
+        const targetNamespace = getOrCreateNamespace(prop.namespaces, global);
+        targetNamespace.properties.push(prop);
+    });
+    return {
+        global
+    };
+};
+
+//# sourceMappingURL=getApiDefinitions.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../libs/cli/src/commands/GenerateTypes/fn/getApiDefinitions.ts"],"sourcesContent":["import {\n    ApiDefinitions,\n    FunctionDescription,\n    ApiObject,\n    PropertyDescription,\n    FunctionTypeOverrideMap,\n} from '@/cli/types.js';\n\nexport const getApiDefinitions = (\n    functions: FunctionDescription[],\n    properties: PropertyDescription[],\n    functionTypeOverride: FunctionTypeOverrideMap\n): ApiDefinitions => {\n    const global: ApiObject = {\n        functions: [],\n        methods: [],\n        properties: [],\n        namespaces: {},\n    };\n\n    const getOrCreateNamespace = (\n        path: string[],\n        root: ApiObject\n    ): ApiObject => {\n        return path.reduce((currentNamespace, ns) => {\n            if (!currentNamespace.namespaces[ns]) {\n                currentNamespace.namespaces[ns] = {\n                    functions: [],\n                    methods: [],\n                    properties: [],\n                    namespaces: {},\n                };\n            }\n            return currentNamespace.namespaces[ns];\n        }, root);\n    };\n\n    functions.forEach((func) => {\n        const targetNamespace = getOrCreateNamespace(func.namespaces, global);\n        if (func.hasSelf || functionTypeOverride[func.signature]?.isMethod) {\n            targetNamespace.methods.push(func);\n        } else {\n            targetNamespace.functions.push(func);\n        }\n    });\n\n    properties.forEach((prop) => {\n        const targetNamespace = getOrCreateNamespace(prop.namespaces, global);\n        targetNamespace.properties.push(prop);\n    });\n\n    return { global };\n};\n"],"names":["getApiDefinitions","functions","properties","functionTypeOverride","global","methods","namespaces","getOrCreateNamespace","path","root","reduce","currentNamespace","ns","forEach","func","targetNamespace","hasSelf","signature","isMethod","push","prop"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAQA,OAAO,MAAMA,oBAAoB,CAC7BC,WACAC,YACAC;IAEA,MAAMC,SAAoB;QACtBH,WAAW,EAAE;QACbI,SAAS,EAAE;QACXH,YAAY,EAAE;QACdI,YAAY,CAAC;IACjB;IAEA,MAAMC,uBAAuB,CACzBC,MACAC;QAEA,OAAOD,KAAKE,MAAM,CAAC,CAACC,kBAAkBC;YAClC,IAAI,CAACD,iBAAiBL,UAAU,CAACM,GAAG,EAAE;gBAClCD,iBAAiBL,UAAU,CAACM,GAAG,GAAG;oBAC9BX,WAAW,EAAE;oBACbI,SAAS,EAAE;oBACXH,YAAY,EAAE;oBACdI,YAAY,CAAC;gBACjB;YACJ;YACA,OAAOK,iBAAiBL,UAAU,CAACM,GAAG;QAC1C,GAAGH;IACP;IAEAR,UAAUY,OAAO,CAAC,CAACC;YAEKX;QADpB,MAAMY,kBAAkBR,qBAAqBO,KAAKR,UAAU,EAAEF;QAC9D,IAAIU,KAAKE,OAAO,MAAIb,uCAAAA,oBAAoB,CAACW,KAAKG,SAAS,CAAC,qBAApCd,qCAAsCe,QAAQ,GAAE;YAChEH,gBAAgBV,OAAO,CAACc,IAAI,CAACL;QACjC,OAAO;YACHC,gBAAgBd,SAAS,CAACkB,IAAI,CAACL;QACnC;IACJ;IAEAZ,WAAWW,OAAO,CAAC,CAACO;QAChB,MAAML,kBAAkBR,qBAAqBa,KAAKd,UAAU,EAAEF;QAC9DW,gBAAgBb,UAAU,CAACiB,IAAI,CAACC;IACpC;IAEA,OAAO;QAAEhB;IAAO;AACpB,EAAE"}

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

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