crankscript 0.4.0 → 0.5.0

package/package.json

@@ -1,28 +1,27 @@
 {
-    "name": "crankscript",
-    "version": "0.4.0",
-    "scripts": {
-        "dev": "tsx src/index.ts",
-        "post-build": "tsc-alias --project 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",
-        "react": "^18.3.1",
-        "ts-morph": "^23.0.0",
-        "typanion": "^3.14.0",
-        "zod": "^3.23.8"
-    },
-    "type": "module",
-    "main": "./src/index.js",
-    "typings": "./src/index.d.ts",
-    "module": "./src/index.js",
-    "types": "./src/index.d.ts"
+  "name": "crankscript",
+  "version": "0.5.0",
+  "scripts": {
+    "dev": "tsx src/index.ts",
+    "post-build": "tsc-alias --project 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",
+    "react": "^18.3.1",
+    "ts-morph": "^23.0.0",
+    "typanion": "^3.14.0"
+  },
+  "type": "module",
+  "main": "./src/index.js",
+  "typings": "./src/index.d.ts",
+  "module": "./src/index.js",
+  "types": "./src/index.d.ts"
 }

package/src/commands/DoctorCommand.js

@@ -1,7 +1,7 @@
 import { Command } from 'clipanion';
 import { Text } from 'ink';
 import React from 'react';
-import { createEnvironment } from '../environment/createEnvironment.js';
+import { createEnvironment } from '@/cli/environment/createEnvironment.js';
 import { HealthReport } from './EnvironmentAwareCommand/components/HealthReport.js';
 import { RenderableCommand } from './RenderableCommand.js';
 export class DoctorCommand extends RenderableCommand {
@@ -10,7 +10,7 @@ export class DoctorCommand extends RenderableCommand {
         return /*#__PURE__*/ React.createElement(React.Fragment, null, /*#__PURE__*/ React.createElement(Text, {
             color: "gray"
         }, "Checking the environment..."), /*#__PURE__*/ React.createElement(HealthReport, {
-            health: environment.health
+            environment: environment
         }));
     }
 }

package/src/commands/DoctorCommand.js.map

@@ -1 +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 health={environment.health} />\n            </>\n        );\n    }\n}\n"],"names":["Command","Text","React","createEnvironment","HealthReport","RenderableCommand","DoctorCommand","render","environment","color","health","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;YAAaM,QAAQF,YAAYE,MAAM;;IAGpD;AACJ;AAjBaJ,cACOK,QAAQ;IAAC;QAAC;KAAS;CAAC;AAD3BL,cAGOM,QAAQZ,QAAQa,KAAK,CAAC;IAClCC,aAAa;AACjB"}
+{"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

@@ -1,6 +1,6 @@
 import { JSX } from 'react';
-import { RenderableCommand } from '../../commands/RenderableCommand.js';
-import { Environment } from '../../environment/dto/Environment.js';
+import { RenderableCommand } from '@/cli/commands/RenderableCommand.js';
+import { Environment } from '@/cli/environment/dto/Environment.js';
 export declare abstract class EnvironmentAwareCommand extends RenderableCommand {
     private environment;
     protected abstract renderWithEnvironment(environment: Environment): JSX.Element;

package/src/commands/EnvironmentAwareCommand/EnvironmentAwareCommand.js

@@ -1,7 +1,7 @@
 import React from 'react';
-import { HealthReport } from '../../commands/EnvironmentAwareCommand/components/HealthReport.js';
-import { RenderableCommand } from '../../commands/RenderableCommand.js';
-import { createEnvironment } from '../../environment/createEnvironment.js';
+import { HealthReport } from '@/cli/commands/EnvironmentAwareCommand/components/HealthReport.js';
+import { RenderableCommand } from '@/cli/commands/RenderableCommand.js';
+import { createEnvironment } from '@/cli/environment/createEnvironment.js';
 export class EnvironmentAwareCommand extends RenderableCommand {
     render() {
         if (!this.environment) {
@@ -13,7 +13,7 @@ export class EnvironmentAwareCommand extends RenderableCommand {
         const environmentHealth = createEnvironment();
         if (!environmentHealth.isHealthy) {
             this.renderElement(/*#__PURE__*/ React.createElement(HealthReport, {
-                health: environmentHealth.health
+                environment: environmentHealth
             }));
             return;
         }

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

@@ -1 +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 health={environmentHealth.health} />\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","health"],"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;gBAAaY,QAAQH,kBAAkBG,MAAM;;YAGlD;QACJ;QAEA,IAAI,CAACP,WAAW,GAAGI,kBAAkBJ,WAAW;QAEhD,IAAI,CAACM,aAAa,CAAC,IAAI,CAACP,MAAM;IAClC;AACJ"}
+{"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

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

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

@@ -1,46 +1,40 @@
 import { StatusMessage } from '@inkjs/ui';
 import { Text } from 'ink';
 import React from 'react';
-import { HealthCheckStatus } from '../../../types.js';
+import { HealthCheckStatusType } from '@/cli/types.js';
 const SuccessMessages = {
-    configurationFilePresent: {
-        [HealthCheckStatus.Unknown]: 'Configuration file status unknown',
-        [HealthCheckStatus.Healthy]: 'Configuration file found',
-        [HealthCheckStatus.Unhealthy]: 'Configuration file not found'
-    },
-    configurationFileValid: {
-        [HealthCheckStatus.Unknown]: 'Configuration file validity unknown',
-        [HealthCheckStatus.Healthy]: 'Configuration file is valid',
-        [HealthCheckStatus.Unhealthy]: 'Configuration file is invalid'
-    },
     sdkPathKnown: {
-        [HealthCheckStatus.Unknown]: 'SDK path status unknown',
-        [HealthCheckStatus.Healthy]: 'SDK path found',
-        [HealthCheckStatus.Unhealthy]: 'SDK path not found'
+        [HealthCheckStatusType.Unknown]: 'SDK path status unknown',
+        [HealthCheckStatusType.Healthy]: (sdkPath)=>`SDK path found ("${sdkPath.path}")`,
+        [HealthCheckStatusType.Unhealthy]: 'SDK path not found'
     }
 };
 const ColorMap = {
-    [HealthCheckStatus.Healthy]: 'green',
-    [HealthCheckStatus.Unhealthy]: 'red',
-    [HealthCheckStatus.Unknown]: 'gray'
+    [HealthCheckStatusType.Healthy]: 'green',
+    [HealthCheckStatusType.Unhealthy]: 'red',
+    [HealthCheckStatusType.Unknown]: 'gray'
 };
-export const HealthReport = ({ health })=>{
+export const HealthReport = ({ environment })=>{
+    const { health } = environment;
     return Object.keys(health).map((eachKey)=>{
         const healthKey = eachKey;
         const keyHealth = health[healthKey];
         let variant = 'info';
-        if (health[healthKey] === HealthCheckStatus.Unhealthy) {
+        let message = SuccessMessages[healthKey][HealthCheckStatusType.Unknown];
+        if (health[healthKey].healthStatus === HealthCheckStatusType.Unhealthy) {
+            message = SuccessMessages[healthKey][HealthCheckStatusType.Unhealthy];
             variant = 'error';
         }
-        if (health[healthKey] === HealthCheckStatus.Healthy) {
+        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]
-        }, keyHealth === HealthCheckStatus.Unhealthy && ' ', SuccessMessages[healthKey][keyHealth]));
+            color: ColorMap[keyHealth.healthStatus]
+        }, keyHealth.healthStatus === HealthCheckStatusType.Unhealthy && ' ', message));
     });
 };
 

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

@@ -1 +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 { EnvironmentHealth, HealthCheckStatus } from '@/cli/types.js';\n\ninterface Props {\n    health: EnvironmentHealth;\n}\n\nconst SuccessMessages = {\n    configurationFilePresent: {\n        [HealthCheckStatus.Unknown]: 'Configuration file status unknown',\n        [HealthCheckStatus.Healthy]: 'Configuration file found',\n        [HealthCheckStatus.Unhealthy]: 'Configuration file not found',\n    },\n    configurationFileValid: {\n        [HealthCheckStatus.Unknown]: 'Configuration file validity unknown',\n        [HealthCheckStatus.Healthy]: 'Configuration file is valid',\n        [HealthCheckStatus.Unhealthy]: 'Configuration file is invalid',\n    },\n    sdkPathKnown: {\n        [HealthCheckStatus.Unknown]: 'SDK path status unknown',\n        [HealthCheckStatus.Healthy]: 'SDK path found',\n        [HealthCheckStatus.Unhealthy]: 'SDK path not found',\n    },\n} satisfies {\n    [key in keyof EnvironmentHealth]: {\n        [HealthCheckStatus.Unknown]: string;\n        [HealthCheckStatus.Healthy]: string;\n        [HealthCheckStatus.Unhealthy]: string;\n    };\n};\n\nconst ColorMap = {\n    [HealthCheckStatus.Healthy]: 'green',\n    [HealthCheckStatus.Unhealthy]: 'red',\n    [HealthCheckStatus.Unknown]: 'gray',\n} satisfies {\n    [key in HealthCheckStatus]: TextProps['color'];\n};\n\nexport const HealthReport = ({ health }: Props) => {\n    return Object.keys(health).map((eachKey) => {\n        const healthKey = eachKey as keyof EnvironmentHealth;\n        const keyHealth = health[healthKey];\n        let variant: StatusMessageProps['variant'] = 'info';\n\n        if (health[healthKey] === HealthCheckStatus.Unhealthy) {\n            variant = 'error';\n        }\n\n        if (health[healthKey] === HealthCheckStatus.Healthy) {\n            variant = 'success';\n        }\n\n        return (\n            <StatusMessage key={healthKey} variant={variant}>\n                <Text color={ColorMap[keyHealth]}>\n                    {keyHealth === HealthCheckStatus.Unhealthy && ' '}\n                    {SuccessMessages[healthKey][keyHealth]}\n                </Text>\n            </StatusMessage>\n        );\n    });\n};\n"],"names":["StatusMessage","Text","React","HealthCheckStatus","SuccessMessages","configurationFilePresent","Unknown","Healthy","Unhealthy","configurationFileValid","sdkPathKnown","ColorMap","HealthReport","health","Object","keys","map","eachKey","healthKey","keyHealth","variant","key","color"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAAA,SAASA,aAAa,QAA4B,YAAY;AAC9D,SAASC,IAAI,QAAmB,MAAM;AACtC,OAAOC,WAAW,QAAQ;AAC1B,SAA4BC,iBAAiB,QAAQ,iBAAiB;AAMtE,MAAMC,kBAAkB;IACpBC,0BAA0B;QACtB,CAACF,kBAAkBG,OAAO,CAAC,EAAE;QAC7B,CAACH,kBAAkBI,OAAO,CAAC,EAAE;QAC7B,CAACJ,kBAAkBK,SAAS,CAAC,EAAE;IACnC;IACAC,wBAAwB;QACpB,CAACN,kBAAkBG,OAAO,CAAC,EAAE;QAC7B,CAACH,kBAAkBI,OAAO,CAAC,EAAE;QAC7B,CAACJ,kBAAkBK,SAAS,CAAC,EAAE;IACnC;IACAE,cAAc;QACV,CAACP,kBAAkBG,OAAO,CAAC,EAAE;QAC7B,CAACH,kBAAkBI,OAAO,CAAC,EAAE;QAC7B,CAACJ,kBAAkBK,SAAS,CAAC,EAAE;IACnC;AACJ;AAQA,MAAMG,WAAW;IACb,CAACR,kBAAkBI,OAAO,CAAC,EAAE;IAC7B,CAACJ,kBAAkBK,SAAS,CAAC,EAAE;IAC/B,CAACL,kBAAkBG,OAAO,CAAC,EAAE;AACjC;AAIA,OAAO,MAAMM,eAAe,CAAC,EAAEC,MAAM,EAAS;IAC1C,OAAOC,OAAOC,IAAI,CAACF,QAAQG,GAAG,CAAC,CAACC;QAC5B,MAAMC,YAAYD;QAClB,MAAME,YAAYN,MAAM,CAACK,UAAU;QACnC,IAAIE,UAAyC;QAE7C,IAAIP,MAAM,CAACK,UAAU,KAAKf,kBAAkBK,SAAS,EAAE;YACnDY,UAAU;QACd;QAEA,IAAIP,MAAM,CAACK,UAAU,KAAKf,kBAAkBI,OAAO,EAAE;YACjDa,UAAU;QACd;QAEA,qBACI,oBAACpB;YAAcqB,KAAKH;YAAWE,SAASA;yBACpC,oBAACnB;YAAKqB,OAAOX,QAAQ,CAACQ,UAAU;WAC3BA,cAAchB,kBAAkBK,SAAS,IAAI,KAC7CJ,eAAe,CAACc,UAAU,CAACC,UAAU;IAItD;AACJ,EAAE"}
+{"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/GenerateTypes/GenerateTypesCommand.d.ts

@@ -1,9 +1,9 @@
 import React from 'react';
-import { EnvironmentAwareCommand } from '../../commands/EnvironmentAwareCommand/index.js';
-import { Environment } from '../../environment/dto/Environment.js';
-export declare class GenerateTypesCommand extends EnvironmentAwareCommand {
+import { RenderableCommand } from '@/cli/commands/RenderableCommand.js';
+export declare class GenerateTypesCommand extends RenderableCommand {
     static paths: string[][];
     static usage: import("clipanion").Usage;
+    output: string;
     version: any;
-    renderWithEnvironment(environment: Environment): React.JSX.Element;
+    render(): React.JSX.Element;
 }

package/src/commands/GenerateTypes/GenerateTypesCommand.js

@@ -1,22 +1,28 @@
+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 { EnvironmentAwareCommand } from '../../commands/EnvironmentAwareCommand/index.js';
-import { PlaydateSdkVersionIdentifier } from '../../types.js';
+import { RenderableCommand } from '@/cli/commands/RenderableCommand.js';
+import { PlaydateSdkVersionIdentifier } from '@/cli/types.js';
 import { GenerateTypes } from './components/GenerateTypes.js';
-export class GenerateTypesCommand extends EnvironmentAwareCommand {
-    renderWithEnvironment(environment) {
+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, {
-            version: this.version === PlaydateSdkVersionIdentifier.FromConfig ? environment.configuration.version : this.version
+            output: output,
+            version: this.version
         });
     }
     constructor(...args){
         super(...args);
-        this.version = Option.String('-s,--sdk-version', PlaydateSdkVersionIdentifier.FromConfig, {
-            tolerateBoolean: false,
-            description: 'The version',
+        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.version = Option.String({
+            name: 'version',
             validator: t.isOneOf([
-                t.isLiteral(PlaydateSdkVersionIdentifier.FromConfig),
                 t.isLiteral(PlaydateSdkVersionIdentifier.Latest),
                 t.matchesRegExp(/^[0-9]+\.[0-9]+\.[0-9]+$/)
             ])

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

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../../libs/cli/src/commands/GenerateTypes/GenerateTypesCommand.tsx"],"sourcesContent":["import { Command, Option } from 'clipanion';\nimport React from 'react';\nimport * as t from 'typanion';\nimport { AnyStrictValidator } from 'typanion';\nimport { EnvironmentAwareCommand } from '@/cli/commands/EnvironmentAwareCommand/index.js';\nimport { Environment } from '@/cli/environment/dto/Environment.js';\nimport { PlaydateSdkVersionIdentifier } from '@/cli/types.js';\nimport { GenerateTypes } from './components/GenerateTypes.js';\n\nexport class GenerateTypesCommand extends EnvironmentAwareCommand {\n    static override paths = [['generate-types']];\n    static override usage = Command.Usage({\n        description: 'Generate types from the Playdate SDK documentation',\n    });\n\n    version = Option.String(\n        '-s,--sdk-version',\n        PlaydateSdkVersionIdentifier.FromConfig,\n        {\n            tolerateBoolean: false,\n            description: 'The version',\n            validator: t.isOneOf([\n                t.isLiteral(PlaydateSdkVersionIdentifier.FromConfig),\n                t.isLiteral(PlaydateSdkVersionIdentifier.Latest),\n                t.matchesRegExp(\n                    /^[0-9]+\\.[0-9]+\\.[0-9]+$/\n                ) as AnyStrictValidator,\n            ]),\n        }\n    );\n\n    override renderWithEnvironment(environment: Environment) {\n        return (\n            <GenerateTypes\n                version={\n                    this.version === PlaydateSdkVersionIdentifier.FromConfig\n                        ? environment.configuration.version\n                        : this.version\n                }\n            />\n        );\n    }\n}\n"],"names":["Command","Option","React","t","EnvironmentAwareCommand","PlaydateSdkVersionIdentifier","GenerateTypes","GenerateTypesCommand","renderWithEnvironment","environment","version","FromConfig","configuration","String","tolerateBoolean","description","validator","isOneOf","isLiteral","Latest","matchesRegExp","paths","usage","Usage"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAAA,SAASA,OAAO,EAAEC,MAAM,QAAQ,YAAY;AAC5C,OAAOC,WAAW,QAAQ;AAC1B,YAAYC,OAAO,WAAW;AAE9B,SAASC,uBAAuB,QAAQ,kDAAkD;AAE1F,SAASC,4BAA4B,QAAQ,iBAAiB;AAC9D,SAASC,aAAa,QAAQ,gCAAgC;AAE9D,OAAO,MAAMC,6BAA6BH;IAsB7BI,sBAAsBC,WAAwB,EAAE;QACrD,qBACI,oBAACH;YACGI,SACI,IAAI,CAACA,OAAO,KAAKL,6BAA6BM,UAAU,GAClDF,YAAYG,aAAa,CAACF,OAAO,GACjC,IAAI,CAACA,OAAO;;IAIlC;;;aA1BAA,UAAUT,OAAOY,MAAM,CACnB,oBACAR,6BAA6BM,UAAU,EACvC;YACIG,iBAAiB;YACjBC,aAAa;YACbC,WAAWb,EAAEc,OAAO,CAAC;gBACjBd,EAAEe,SAAS,CAACb,6BAA6BM,UAAU;gBACnDR,EAAEe,SAAS,CAACb,6BAA6Bc,MAAM;gBAC/ChB,EAAEiB,aAAa,CACX;aAEP;QACL;;AAcR;AAjCab,qBACOc,QAAQ;IAAC;QAAC;KAAiB;CAAC;AADnCd,qBAEOe,QAAQtB,QAAQuB,KAAK,CAAC;IAClCR,aAAa;AACjB"}
+{"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    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 <GenerateTypes output={output} version={this.version} />;\n    }\n}\n"],"names":["join","process","Command","Option","React","t","RenderableCommand","PlaydateSdkVersionIdentifier","GenerateTypes","GenerateTypesCommand","render","output","endsWith","version","String","cwd","description","validator","isString","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;IAmB7BI,SAAS;QACd,MAAMC,SAAS,IAAI,CAACA,MAAM,CAACC,QAAQ,CAAC,WAC9B,IAAI,CAACD,MAAM,GACXX,KAAK,IAAI,CAACW,MAAM,EAAE;QAExB,qBAAO,oBAACH;YAAcG,QAAQA;YAAQE,SAAS,IAAI,CAACA,OAAO;;IAC/D;;;aAnBAF,SAASR,OAAOW,MAAM,CAAC,eAAeb,QAAQc,GAAG,IAAI;YACjDC,aAAa,CAAC,sFAAsF,EAAEf,QAAQc,GAAG,GAAG,EAAE,CAAC;YACvHE,WAAWZ,EAAEa,QAAQ;QACzB;aAEAL,UAAUV,OAAOW,MAAM,CAAC;YACpBK,MAAM;YACNF,WAAWZ,EAAEe,OAAO,CAAC;gBACjBf,EAAEgB,SAAS,CAACd,6BAA6Be,MAAM;gBAC/CjB,EAAEkB,aAAa,CAAC;aACnB;QACL;;AASJ;AA1Bad,qBACOe,QAAQ;IAAC;QAAC;KAAiB;CAAC;AADnCf,qBAEOgB,QAAQvB,QAAQwB,KAAK,CAAC;IAClCV,aAAa;AACjB"}

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

@@ -1,7 +1,8 @@
 import React from 'react';
-import { ConfigurationType } from '../../../environment/configuration/ConfigurationSchema.js';
+import { PlaydateSdkVersion } from '@/cli/types.js';
 interface Props {
-    version: ConfigurationType['version'];
+    output: string;
+    version: PlaydateSdkVersion;
 }
-export declare const GenerateTypes: ({ version }: Props) => React.JSX.Element;
+export declare const GenerateTypes: ({ output, version }: Props) => React.JSX.Element;
 export {};

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

@@ -1,23 +1,27 @@
 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 { CheckList } from '../../../components/CheckList/index.js';
-import { useQuitOnCtrlC } from '../../../hooks/useQuitOnCtrlC.js';
-export const GenerateTypes = ({ version })=>{
+import { useFetchHtml } from '@/cli/commands/GenerateTypes/hooks/useFetchHtml.js';
+import { useGenerateTypeFile } from '@/cli/commands/GenerateTypes/hooks/useGenerateTypeFile.js';
+import { useGetVersion } from '@/cli/commands/GenerateTypes/hooks/useGetVersion.js';
+import { useParseDocumentation } from '@/cli/commands/GenerateTypes/hooks/useParseDocumentation.js';
+import { CheckList } from '@/cli/components/CheckList/index.js';
+import { useQuitOnCtrlC } from '@/cli/hooks/useQuitOnCtrlC.js';
+export const GenerateTypes = ({ output, version })=>{
     useQuitOnCtrlC();
     const { fetchedVersion, getVersion } = useGetVersion(version);
     const { html, fetchHtml } = useFetchHtml(fetchedVersion);
-    const { generateTypeFile } = useGenerateTypeFile(process.cwd(), html);
+    const { definitions, parseDocumentation } = useParseDocumentation(html, version);
+    const { generateTypeFile } = useGenerateTypeFile(output, definitions);
     const items = useMemo(()=>{
         return [
             getVersion,
             fetchHtml,
+            parseDocumentation,
             generateTypeFile
         ];
     }, [
         fetchedVersion,
-        html
+        html,
+        definitions
     ]);
     return /*#__PURE__*/ React.createElement(CheckList, {
         items: items,

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

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../../../libs/cli/src/commands/GenerateTypes/components/GenerateTypes.tsx"],"sourcesContent":["import React, { useMemo } from 'react';\nimport { useFetchHtml } from '@/cli/commands/GenerateTypes/hooks/useFetchHtml.js';\nimport { useGenerateTypeFile } from '@/cli/commands/GenerateTypes/hooks/useGenerateTypeFile.js';\nimport { useGetVersion } from '@/cli/commands/GenerateTypes/hooks/useGetVersion.js';\nimport { CheckList } from '@/cli/components/CheckList/index.js';\nimport { ConfigurationType } from '@/cli/environment/configuration/ConfigurationSchema.js';\nimport { useQuitOnCtrlC } from '@/cli/hooks/useQuitOnCtrlC.js';\nimport { CheckListItem } from '@/cli/types.js';\n\ninterface Props {\n    version: ConfigurationType['version'];\n}\n\nexport const GenerateTypes = ({ version }: Props) => {\n    useQuitOnCtrlC();\n\n    const { fetchedVersion, getVersion } = useGetVersion(version);\n    const { html, fetchHtml } = useFetchHtml(fetchedVersion);\n    const { generateTypeFile } = useGenerateTypeFile(process.cwd(), html);\n\n    const items = useMemo(() => {\n        return [\n            getVersion,\n            fetchHtml,\n            generateTypeFile,\n        ] as CheckListItem<unknown>[];\n    }, [fetchedVersion, html]);\n\n    return <CheckList items={items} onFinish={process.exit} />;\n};\n"],"names":["React","useMemo","useFetchHtml","useGenerateTypeFile","useGetVersion","CheckList","useQuitOnCtrlC","GenerateTypes","version","fetchedVersion","getVersion","html","fetchHtml","generateTypeFile","process","cwd","items","onFinish","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,SAAS,QAAQ,sCAAsC;AAEhE,SAASC,cAAc,QAAQ,gCAAgC;AAO/D,OAAO,MAAMC,gBAAgB,CAAC,EAAEC,OAAO,EAAS;IAC5CF;IAEA,MAAM,EAAEG,cAAc,EAAEC,UAAU,EAAE,GAAGN,cAAcI;IACrD,MAAM,EAAEG,IAAI,EAAEC,SAAS,EAAE,GAAGV,aAAaO;IACzC,MAAM,EAAEI,gBAAgB,EAAE,GAAGV,oBAAoBW,QAAQC,GAAG,IAAIJ;IAEhE,MAAMK,QAAQf,QAAQ;QAClB,OAAO;YACHS;YACAE;YACAC;SACH;IACL,GAAG;QAACJ;QAAgBE;KAAK;IAEzB,qBAAO,oBAACN;QAAUW,OAAOA;QAAOC,UAAUH,QAAQI,IAAI;;AAC1D,EAAE"}
+{"version":3,"sources":["../../../../../../../libs/cli/src/commands/GenerateTypes/components/GenerateTypes.tsx"],"sourcesContent":["import React, { useMemo } from 'react';\nimport { useFetchHtml } from '@/cli/commands/GenerateTypes/hooks/useFetchHtml.js';\nimport { 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 { useQuitOnCtrlC } from '@/cli/hooks/useQuitOnCtrlC.js';\nimport { CheckListItem, PlaydateSdkVersion } from '@/cli/types.js';\n\ninterface Props {\n    output: string;\n    version: PlaydateSdkVersion;\n}\n\nexport const GenerateTypes = ({ output, version }: Props) => {\n    useQuitOnCtrlC();\n\n    const { fetchedVersion, getVersion } = useGetVersion(version);\n    const { html, fetchHtml } = useFetchHtml(fetchedVersion);\n    const { definitions, parseDocumentation } = useParseDocumentation(\n        html,\n        version\n    );\n    const { generateTypeFile } = useGenerateTypeFile(output, definitions);\n\n    const items = useMemo(() => {\n        return [\n            getVersion,\n            fetchHtml,\n            parseDocumentation,\n            generateTypeFile,\n        ] as CheckListItem<unknown>[];\n    }, [fetchedVersion, html, definitions]);\n\n    return <CheckList items={items} onFinish={process.exit} />;\n};\n"],"names":["React","useMemo","useFetchHtml","useGenerateTypeFile","useGetVersion","useParseDocumentation","CheckList","useQuitOnCtrlC","GenerateTypes","output","version","fetchedVersion","getVersion","html","fetchHtml","definitions","parseDocumentation","generateTypeFile","items","onFinish","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;AAChE,SAASC,cAAc,QAAQ,gCAAgC;AAQ/D,OAAO,MAAMC,gBAAgB,CAAC,EAAEC,MAAM,EAAEC,OAAO,EAAS;IACpDH;IAEA,MAAM,EAAEI,cAAc,EAAEC,UAAU,EAAE,GAAGR,cAAcM;IACrD,MAAM,EAAEG,IAAI,EAAEC,SAAS,EAAE,GAAGZ,aAAaS;IACzC,MAAM,EAAEI,WAAW,EAAEC,kBAAkB,EAAE,GAAGX,sBACxCQ,MACAH;IAEJ,MAAM,EAAEO,gBAAgB,EAAE,GAAGd,oBAAoBM,QAAQM;IAEzD,MAAMG,QAAQjB,QAAQ;QAClB,OAAO;YACHW;YACAE;YACAE;YACAC;SACH;IACL,GAAG;QAACN;QAAgBE;QAAME;KAAY;IAEtC,qBAAO,oBAACT;QAAUY,OAAOA;QAAOC,UAAUC,QAAQC,IAAI;;AAC1D,EAAE"}

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

@@ -0,0 +1,3 @@
+import { ModuleDeclaration, SourceFile } from 'ts-morph';
+import { PlaydateNamespace } from '@/cli/types.js';
+export declare const generateNamespace: (subject: SourceFile | ModuleDeclaration, namespace: string, namespaceDescription: PlaydateNamespace, nextNamespaces: string[]) => void;

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

@@ -0,0 +1,33 @@
+import { TypescriptReservedNamed } from '@/cli/constants.js';
+export const generateNamespace = (subject, namespace, namespaceDescription, nextNamespaces)=>{
+    const module = subject.addModule({
+        name: namespace.trim()
+    });
+    if (nextNamespaces.length) {
+        generateNamespace(module, nextNamespaces[0], namespaceDescription, nextNamespaces.slice(1));
+    } else {
+        for (const func of namespaceDescription.functions){
+            const isReserved = TypescriptReservedNamed.includes(func.name);
+            const name = isReserved ? `_${func.name}` : func.name;
+            module.addFunction({
+                name,
+                docs: [
+                    func.docs
+                ],
+                isExported: !isReserved
+            });
+            if (isReserved) {
+                module.addExportDeclaration({
+                    namedExports: [
+                        {
+                            name,
+                            alias: func.name
+                        }
+                    ]
+                });
+            }
+        }
+    }
+};
+
+//# sourceMappingURL=generateNamespace.js.map

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

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

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

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

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

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

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

@@ -0,0 +1,2 @@
+import { FunctionDescription } from '@/cli/types.js';
+export declare const getFunctionDescriptionsFromHtml: (html: string, version: string) => FunctionDescription[];

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

@@ -0,0 +1,37 @@
+import { _ as _extends } from "@swc/helpers/_/_extends";
+import { load } from 'cheerio';
+import { PlaydateSdkUrl } from '@/cli/commands/GenerateTypes/constants.js';
+import { parseFunctionSignature } from '@/cli/commands/GenerateTypes/fn/parseFunctionSignature.js';
+export const getFunctionDescriptionsFromHtml = (html, version)=>{
+    const $ = load(html);
+    const allSignatures = $('[id^="m-"], [id^="f-"], [id^="c-"]').toArray();
+    const result = [];
+    for (const element of allSignatures){
+        var _$_attr;
+        const id = (_$_attr = $(element).attr('id')) != null ? _$_attr : '';
+        var _$_find_text;
+        const titles = ((_$_find_text = $(element).find('.title').text()) != null ? _$_find_text : '').split('  ');
+        var _$_find_html;
+        let docsString = ((_$_find_html = $(element).find('.content').html()) != null ? _$_find_html : '').trim();
+        if (docsString.startsWith('<div class="paragraph">')) {
+            docsString = docsString.slice('<div class="paragraph">'.length);
+        }
+        if (docsString.endsWith('</div>')) {
+            docsString = docsString.slice(0, docsString.length - '</div>'.length);
+        }
+        docsString = docsString.replace(/<a href="#/g, '<a href="' + PlaydateSdkUrl + version + '#');
+        const docs = id ? `${docsString}\n[Read more](${PlaydateSdkUrl}${version}#${id})` : docsString;
+        for (const title of titles){
+            try {
+                result.push(_extends({}, parseFunctionSignature(title), {
+                    docs
+                }));
+            } catch (e) {
+            // skip
+            }
+        }
+    }
+    return result;
+};
+
+//# sourceMappingURL=getFunctionDescriptionsFromHtml.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../libs/cli/src/commands/GenerateTypes/fn/getFunctionDescriptionsFromHtml.ts"],"sourcesContent":["import { load } from 'cheerio';\nimport { PlaydateSdkUrl } from '@/cli/commands/GenerateTypes/constants.js';\nimport { parseFunctionSignature } from '@/cli/commands/GenerateTypes/fn/parseFunctionSignature.js';\nimport { FunctionDescription } from '@/cli/types.js';\n\nexport const getFunctionDescriptionsFromHtml = (\n    html: string,\n    version: string\n) => {\n    const $ = load(html);\n\n    const allSignatures = $('[id^=\"m-\"], [id^=\"f-\"], [id^=\"c-\"]').toArray();\n    const result: FunctionDescription[] = [];\n\n    for (const element of allSignatures) {\n        const id = $(element).attr('id') ?? '';\n        const titles = ($(element).find('.title').text() ?? '').split('  ');\n        let docsString = ($(element).find('.content').html() ?? '').trim();\n\n        if (docsString.startsWith('<div class=\"paragraph\">')) {\n            docsString = docsString.slice('<div class=\"paragraph\">'.length);\n        }\n\n        if (docsString.endsWith('</div>')) {\n            docsString = docsString.slice(\n                0,\n                docsString.length - '</div>'.length\n            );\n        }\n\n        docsString = docsString.replace(\n            /<a href=\"#/g,\n            '<a href=\"' + PlaydateSdkUrl + version + '#'\n        );\n\n        const docs = id\n            ? `${docsString}\\n[Read more](${PlaydateSdkUrl}${version}#${id})`\n            : docsString;\n\n        for (const title of titles) {\n            try {\n                result.push({ ...parseFunctionSignature(title), docs });\n            } catch (e) {\n                // skip\n            }\n        }\n    }\n\n    return result;\n};\n"],"names":["load","PlaydateSdkUrl","parseFunctionSignature","getFunctionDescriptionsFromHtml","html","version","$","allSignatures","toArray","result","element","id","attr","titles","find","text","split","docsString","trim","startsWith","slice","length","endsWith","replace","docs","title","push","e"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";AAAA,SAASA,IAAI,QAAQ,UAAU;AAC/B,SAASC,cAAc,QAAQ,4CAA4C;AAC3E,SAASC,sBAAsB,QAAQ,4DAA4D;AAGnG,OAAO,MAAMC,kCAAkC,CAC3CC,MACAC;IAEA,MAAMC,IAAIN,KAAKI;IAEf,MAAMG,gBAAgBD,EAAE,sCAAsCE,OAAO;IACrE,MAAMC,SAAgC,EAAE;IAExC,KAAK,MAAMC,WAAWH,cAAe;YACtBD;QAAX,MAAMK,KAAKL,CAAAA,UAAAA,EAAEI,SAASE,IAAI,CAAC,iBAAhBN,UAAyB;YACpBA;QAAhB,MAAMO,SAAS,AAACP,CAAAA,CAAAA,eAAAA,EAAEI,SAASI,IAAI,CAAC,UAAUC,IAAI,cAA9BT,eAAoC,EAAC,EAAGU,KAAK,CAAC;YAC5CV;QAAlB,IAAIW,aAAa,AAACX,CAAAA,CAAAA,eAAAA,EAAEI,SAASI,IAAI,CAAC,YAAYV,IAAI,cAAhCE,eAAsC,EAAC,EAAGY,IAAI;QAEhE,IAAID,WAAWE,UAAU,CAAC,4BAA4B;YAClDF,aAAaA,WAAWG,KAAK,CAAC,0BAA0BC,MAAM;QAClE;QAEA,IAAIJ,WAAWK,QAAQ,CAAC,WAAW;YAC/BL,aAAaA,WAAWG,KAAK,CACzB,GACAH,WAAWI,MAAM,GAAG,SAASA,MAAM;QAE3C;QAEAJ,aAAaA,WAAWM,OAAO,CAC3B,eACA,cAActB,iBAAiBI,UAAU;QAG7C,MAAMmB,OAAOb,KACP,CAAC,EAAEM,WAAW,cAAc,EAAEhB,eAAe,EAAEI,QAAQ,CAAC,EAAEM,GAAG,CAAC,CAAC,GAC/DM;QAEN,KAAK,MAAMQ,SAASZ,OAAQ;YACxB,IAAI;gBACAJ,OAAOiB,IAAI,CAAC,aAAKxB,uBAAuBuB;oBAAQD;;YACpD,EAAE,OAAOG,GAAG;YACR,OAAO;YACX;QACJ;IACJ;IAEA,OAAOlB;AACX,EAAE"}

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

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

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

@@ -0,0 +1,24 @@
+export const parseFunctionSignature = (signature)=>{
+    if (!signature.includes('(')) {
+        throw new Error('Invalid signature');
+    }
+    const [fullyQualifiedName, paramString] = signature.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 {
+        name: functionName,
+        namespaces,
+        parameters: params.map((eachParam)=>({
+                name: eachParam.replace(/\[/g, '').replace(/\]/g, '').trim(),
+                type: 'unknown',
+                required: !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    if (!signature.includes('(')) {\n        throw new Error('Invalid signature');\n    }\n\n    const [fullyQualifiedName, paramString] = signature.split('(');\n    const hasSelf = fullyQualifiedName.includes(':');\n    const normalizedFullyQualifiedName = fullyQualifiedName.replace(':', '.');\n    const segments = normalizedFullyQualifiedName.split('.');\n    const functionName = segments[segments.length - 1];\n    const namespaces = segments.slice(0, -1);\n    const params = paramString.split(')')[0].split(',').filter(Boolean);\n\n    return {\n        name: functionName,\n        namespaces,\n        parameters: params.map((eachParam) => ({\n            name: eachParam.replace(/\\[/g, '').replace(/\\]/g, '').trim(),\n            type: 'unknown',\n            required: !eachParam.includes('['),\n        })),\n        hasSelf,\n    } satisfies Omit<FunctionDescription, 'docs'>;\n};\n"],"names":["parseFunctionSignature","signature","includes","Error","fullyQualifiedName","paramString","split","hasSelf","normalizedFullyQualifiedName","replace","segments","functionName","length","namespaces","slice","params","filter","Boolean","name","parameters","map","eachParam","trim","type","required"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;","mappings":"AAEA,OAAO,MAAMA,yBAAyB,CAACC;IACnC,IAAI,CAACA,UAAUC,QAAQ,CAAC,MAAM;QAC1B,MAAM,IAAIC,MAAM;IACpB;IAEA,MAAM,CAACC,oBAAoBC,YAAY,GAAGJ,UAAUK,KAAK,CAAC;IAC1D,MAAMC,UAAUH,mBAAmBF,QAAQ,CAAC;IAC5C,MAAMM,+BAA+BJ,mBAAmBK,OAAO,CAAC,KAAK;IACrE,MAAMC,WAAWF,6BAA6BF,KAAK,CAAC;IACpD,MAAMK,eAAeD,QAAQ,CAACA,SAASE,MAAM,GAAG,EAAE;IAClD,MAAMC,aAAaH,SAASI,KAAK,CAAC,GAAG,CAAC;IACtC,MAAMC,SAASV,YAAYC,KAAK,CAAC,IAAI,CAAC,EAAE,CAACA,KAAK,CAAC,KAAKU,MAAM,CAACC;IAE3D,OAAO;QACHC,MAAMP;QACNE;QACAM,YAAYJ,OAAOK,GAAG,CAAC,CAACC,YAAe,CAAA;gBACnCH,MAAMG,UAAUZ,OAAO,CAAC,OAAO,IAAIA,OAAO,CAAC,OAAO,IAAIa,IAAI;gBAC1DC,MAAM;gBACNC,UAAU,CAACH,UAAUnB,QAAQ,CAAC;YAClC,CAAA;QACAK;IACJ;AACJ,EAAE"}