crankscript 0.1.2 → 0.1.5-beta

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

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

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

@@ -0,0 +1,156 @@
+import { _ as _extends } from "@swc/helpers/_/_extends";
+import { readFileSync } from 'fs';
+import { existsSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { StructureKind } from 'ts-morph';
+import { DataFolder } from '../../../constants.js';
+function kebabToCamelCase(str) {
+    return str.replace(/-([a-z])/g, (_, letter)=>letter.toUpperCase());
+}
+export const createTypeProvider = (version)=>{
+    const path = join(DataFolder, `${version}.json`);
+    const fallbackProvider = existsSync(path) ? JSON.parse(readFileSync(path, 'utf-8')) : {
+        globalStatements: [],
+        statements: [],
+        classes: {},
+        properties: {},
+        functions: {}
+    };
+    const provider = {
+        globalStatements: fallbackProvider.globalStatements,
+        statements: fallbackProvider.statements,
+        classes: fallbackProvider.classes,
+        properties: {},
+        functions: {}
+    };
+    const visitedProperties = new Map();
+    const visitedFunctions = new Map();
+    const getClassOptions = (className)=>{
+        var _provider_classes_className;
+        return (_provider_classes_className = provider.classes[className]) != null ? _provider_classes_className : {};
+    };
+    const getPropertyDetails = (property)=>{
+        if (visitedProperties.has(property.signature)) {
+            return visitedProperties.get(property.signature);
+        }
+        let result;
+        let prop = provider.properties[property.signature];
+        if (!prop) {
+            prop = fallbackProvider.properties[property.signature];
+        }
+        if (!prop) {
+            const details = {
+                signature: property.signature,
+                type: 'any'
+            };
+            provider.properties[property.signature] = details;
+            result = details;
+        } else {
+            provider.properties[property.signature] = prop;
+            result = prop;
+        }
+        visitedProperties.set(property.signature, result);
+        return result;
+    };
+    const getFunctionDetails = (func)=>{
+        if (visitedFunctions.has(func.signature)) {
+            return visitedFunctions.get(func.signature);
+        }
+        let result;
+        let fn = provider.functions[func.signature];
+        if (!fn) {
+            fn = fallbackProvider.functions[func.signature];
+        }
+        if (!fn) {
+            const details = {
+                signature: func.signature,
+                parameters: func.parameters.map((p)=>({
+                        name: p.name,
+                        type: 'any'
+                    })),
+                returnType: 'any'
+            };
+            provider.functions[func.signature] = details;
+            result = details;
+        } else {
+            provider.functions[func.signature] = fn;
+            result = fn;
+        }
+        visitedFunctions.set(func.signature, result);
+        return result;
+    };
+    const getGlobalStatements = ()=>{
+        return provider.globalStatements;
+    };
+    const getStatements = ()=>{
+        return provider.statements;
+    };
+    const getFunctionReturnType = (func)=>{
+        const { returnType } = getFunctionDetails(func);
+        return returnType;
+    };
+    const getParameterDetails = (func, parameter)=>{
+        const { parameters } = getFunctionDetails(func);
+        const param = parameters.find((p)=>p.name === parameter);
+        if (!param) {
+            return {
+                name: parameter,
+                type: 'any'
+            };
+        }
+        return param;
+    };
+    const getParameters = (func)=>{
+        const { overrideParameters = false, parameters } = getFunctionDetails(func);
+        const getParameterFromDetails = (parameter)=>{
+            var _parameter_overrideOptions;
+            return _extends({
+                kind: StructureKind.Parameter,
+                name: kebabToCamelCase(parameter.name),
+                type: parameter.type
+            }, (_parameter_overrideOptions = parameter.overrideOptions) != null ? _parameter_overrideOptions : {});
+        };
+        if (overrideParameters) {
+            return parameters.map((details)=>{
+                return getParameterFromDetails(details);
+            });
+        }
+        return func.parameters.map((parameter)=>{
+            const details = getParameterDetails(func, parameter.name);
+            return _extends({
+                hasQuestionToken: !parameter.required
+            }, getParameterFromDetails(details));
+        });
+    };
+    const getFunctionOverrideOptions = (func)=>{
+        var _getFunctionDetails_overrideOptions;
+        const options = (_getFunctionDetails_overrideOptions = getFunctionDetails(func).overrideOptions) != null ? _getFunctionDetails_overrideOptions : {};
+        if ('overloads' in options && Array.isArray(options.overloads)) {
+            return {
+                overloads: options.overloads.map((overload)=>_extends({}, overload, {
+                        docs: [
+                            func.docs
+                        ]
+                    }))
+            };
+        }
+        return options;
+    };
+    const save = ()=>{
+        const contents = JSON.stringify(provider, null, 4) + '\n';
+        writeFileSync(path, contents, 'utf-8');
+    };
+    return {
+        getGlobalStatements,
+        getStatements,
+        getClassOptions,
+        getPropertyDetails,
+        getFunctionReturnType,
+        getParameterDetails,
+        getParameters,
+        getFunctionOverrideOptions,
+        save
+    };
+};
+
+//# sourceMappingURL=createTypeProvider.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../libs/cli/src/commands/GenerateTypes/utils/createTypeProvider.ts"],"sourcesContent":["import { readFileSync } from 'fs';\nimport { existsSync, writeFileSync } from 'node:fs';\nimport { join } from 'node:path';\nimport {\n    FunctionDeclarationStructure,\n    ParameterDeclarationStructure,\n    StructureKind,\n} from 'ts-morph';\nimport { DataFolder } from '@/cli/constants.js';\nimport {\n    FunctionDescription,\n    FunctionDetails,\n    ParameterDetails,\n    PropertyDescription,\n    PropertyDetails,\n    TypeProviderData,\n} from '@/cli/types.js';\n\nfunction kebabToCamelCase(str: string): string {\n    return str.replace(/-([a-z])/g, (_, letter) => letter.toUpperCase());\n}\n\nexport const createTypeProvider = (version: string) => {\n    const path = join(DataFolder, `${version}.json`);\n    const fallbackProvider = existsSync(path)\n        ? (JSON.parse(readFileSync(path, 'utf-8')) as TypeProviderData)\n        : ({\n              globalStatements: [],\n              statements: [],\n              classes: {},\n              properties: {},\n              functions: {},\n          } satisfies TypeProviderData);\n    const provider = {\n        globalStatements: fallbackProvider.globalStatements,\n        statements: fallbackProvider.statements,\n        classes: fallbackProvider.classes,\n        properties: {},\n        functions: {},\n    } as TypeProviderData;\n    const visitedProperties = new Map<string, PropertyDetails>();\n    const visitedFunctions = new Map<string, FunctionDetails>();\n\n    const getClassOptions = (className: string) => {\n        return provider.classes[className] ?? {};\n    };\n\n    const getPropertyDetails = (property: PropertyDescription) => {\n        if (visitedProperties.has(property.signature)) {\n            return visitedProperties.get(property.signature) as PropertyDetails;\n        }\n\n        let result: PropertyDetails;\n        let prop = provider.properties[property.signature];\n\n        if (!prop) {\n            prop = fallbackProvider.properties[property.signature];\n        }\n\n        if (!prop) {\n            const details = {\n                signature: property.signature,\n                type: 'any',\n            } satisfies PropertyDetails;\n\n            provider.properties[property.signature] = details;\n\n            result = details;\n        } else {\n            provider.properties[property.signature] = prop;\n\n            result = prop;\n        }\n\n        visitedProperties.set(property.signature, result);\n\n        return result;\n    };\n\n    const getFunctionDetails = (func: FunctionDescription): FunctionDetails => {\n        if (visitedFunctions.has(func.signature)) {\n            return visitedFunctions.get(func.signature) as FunctionDetails;\n        }\n\n        let result: FunctionDetails;\n        let fn = provider.functions[func.signature];\n\n        if (!fn) {\n            fn = fallbackProvider.functions[func.signature];\n        }\n\n        if (!fn) {\n            const details = {\n                signature: func.signature,\n                parameters: func.parameters.map((p) => ({\n                    name: p.name,\n                    type: 'any',\n                })),\n                returnType: 'any',\n            } satisfies FunctionDetails;\n\n            provider.functions[func.signature] = details;\n\n            result = details;\n        } else {\n            provider.functions[func.signature] = fn;\n\n            result = fn;\n        }\n\n        visitedFunctions.set(func.signature, result);\n\n        return result;\n    };\n\n    const getGlobalStatements = () => {\n        return provider.globalStatements;\n    };\n\n    const getStatements = () => {\n        return provider.statements;\n    };\n\n    const getFunctionReturnType = (func: FunctionDescription) => {\n        const { returnType } = getFunctionDetails(func);\n\n        return returnType;\n    };\n\n    const getParameterDetails = (\n        func: FunctionDescription,\n        parameter: string\n    ) => {\n        const { parameters } = getFunctionDetails(func);\n        const param = parameters.find((p) => p.name === parameter);\n\n        if (!param) {\n            return {\n                name: parameter,\n                type: 'any',\n            } satisfies ParameterDetails;\n        }\n\n        return param;\n    };\n\n    const getParameters = (\n        func: FunctionDescription\n    ): FunctionDeclarationStructure['parameters'] => {\n        const { overrideParameters = false, parameters } =\n            getFunctionDetails(func);\n        const getParameterFromDetails = (parameter: ParameterDetails) => {\n            return {\n                kind: StructureKind.Parameter,\n                name: kebabToCamelCase(parameter.name),\n                type: parameter.type,\n                ...(parameter.overrideOptions ?? {}),\n            } satisfies ParameterDeclarationStructure;\n        };\n\n        if (overrideParameters) {\n            return parameters.map((details) => {\n                return getParameterFromDetails(details);\n            });\n        }\n\n        return func.parameters.map((parameter) => {\n            const details = getParameterDetails(func, parameter.name);\n\n            return {\n                hasQuestionToken: !parameter.required,\n                ...getParameterFromDetails(details),\n            } satisfies ParameterDeclarationStructure;\n        });\n    };\n\n    const getFunctionOverrideOptions = (func: FunctionDescription) => {\n        const options = getFunctionDetails(func).overrideOptions ?? {};\n\n        if ('overloads' in options && Array.isArray(options.overloads)) {\n            return {\n                overloads: options.overloads.map((overload) => ({\n                    ...overload,\n                    docs: [func.docs],\n                })),\n            };\n        }\n\n        return options;\n    };\n\n    const save = () => {\n        const contents = JSON.stringify(provider, null, 4) + '\\n';\n\n        writeFileSync(path, contents, 'utf-8');\n    };\n\n    return {\n        getGlobalStatements,\n        getStatements,\n        getClassOptions,\n        getPropertyDetails,\n        getFunctionReturnType,\n        getParameterDetails,\n        getParameters,\n        getFunctionOverrideOptions,\n        save,\n    };\n};\n"],"names":["readFileSync","existsSync","writeFileSync","join","StructureKind","DataFolder","kebabToCamelCase","str","replace","_","letter","toUpperCase","createTypeProvider","version","path","fallbackProvider","JSON","parse","globalStatements","statements","classes","properties","functions","provider","visitedProperties","Map","visitedFunctions","getClassOptions","className","getPropertyDetails","property","has","signature","get","result","prop","details","type","set","getFunctionDetails","func","fn","parameters","map","p","name","returnType","getGlobalStatements","getStatements","getFunctionReturnType","getParameterDetails","parameter","param","find","getParameters","overrideParameters","getParameterFromDetails","kind","Parameter","overrideOptions","hasQuestionToken","required","getFunctionOverrideOptions","options","Array","isArray","overloads","overload","docs","save","contents","stringify"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"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"}

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

@@ -0,0 +1,2 @@
+import { FunctionTypeOverrideMap } from '../../../types.js';
+export declare const functionTypeOverrides: Record<string, FunctionTypeOverrideMap>;

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

@@ -0,0 +1,18 @@
+export const functionTypeOverrides = {
+    defaultVersion: {
+        'playdate.timer.timerEndedCallback': {
+            isMethod: true
+        },
+        'playdate.timer.updateCallback': {
+            isMethod: true
+        },
+        'playdate.frameTimer.timerEndedCallback': {
+            isMethod: true
+        },
+        'playdate.frameTimer.updateCallback': {
+            isMethod: true
+        }
+    }
+};
+
+//# sourceMappingURL=functionTypeOverrides.js.map

package/src/commands/GenerateTypes/utils/functionTypeOverrides.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../libs/cli/src/commands/GenerateTypes/utils/functionTypeOverrides.ts"],"sourcesContent":["import { FunctionTypeOverrideMap } from '@/cli/types.js';\n\nexport const functionTypeOverrides: Record<string, FunctionTypeOverrideMap> = {\n    defaultVersion: {\n        'playdate.timer.timerEndedCallback': {\n            isMethod: true,\n        },\n        'playdate.timer.updateCallback': {\n            isMethod: true,\n        },\n        'playdate.frameTimer.timerEndedCallback': {\n            isMethod: true,\n        },\n        'playdate.frameTimer.updateCallback': {\n            isMethod: true,\n        },\n    },\n};\n"],"names":["functionTypeOverrides","defaultVersion","isMethod"],"rangeMappings":";;;;;;;;;;;;;;;","mappings":"AAEA,OAAO,MAAMA,wBAAiE;IAC1EC,gBAAgB;QACZ,qCAAqC;YACjCC,UAAU;QACd;QACA,iCAAiC;YAC7BA,UAAU;QACd;QACA,0CAA0C;YACtCA,UAAU;QACd;QACA,sCAAsC;YAClCA,UAAU;QACd;IACJ;AACJ,EAAE"}

package/src/commands/NewCommand/NewCommand.d.ts

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

package/src/commands/NewCommand/NewCommand.js

@@ -0,0 +1,35 @@
+import { Command, Option } from 'clipanion';
+import React from 'react';
+import * as t from 'typanion';
+import { RenderableCommand } from '../../commands/RenderableCommand.js';
+import { TemplateName } from '../../types.js';
+import { New } from './components/New.js';
+const defaultTemplate = TemplateName.Blank;
+export class NewCommand extends RenderableCommand {
+    render() {
+        return /*#__PURE__*/ React.createElement(New, {
+            name: this.name,
+            template: this.template
+        });
+    }
+    constructor(...args){
+        super(...args);
+        this.name = Option.String({
+            name: 'name'
+        });
+        this.template = Option.String('-t,--template', defaultTemplate, {
+            description: `The template to use, defaults to "${defaultTemplate}"`,
+            validator: t.isEnum(TemplateName)
+        });
+    }
+}
+NewCommand.paths = [
+    [
+        'new'
+    ]
+];
+NewCommand.usage = Command.Usage({
+    description: 'Create a new crankscript project'
+});
+
+//# sourceMappingURL=NewCommand.js.map

package/src/commands/NewCommand/NewCommand.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../libs/cli/src/commands/NewCommand/NewCommand.tsx"],"sourcesContent":["import { Command, Option } from 'clipanion';\nimport React from 'react';\nimport * as t from 'typanion';\nimport { RenderableCommand } from '@/cli/commands/RenderableCommand.js';\nimport { TemplateName } from '@/cli/types.js';\nimport { New } from './components/New.js';\n\nconst defaultTemplate = TemplateName.Blank;\n\nexport class NewCommand extends RenderableCommand {\n    static override paths = [['new']];\n\n    static override usage = Command.Usage({\n        description: 'Create a new crankscript project',\n    });\n\n    name = Option.String({\n        name: 'name',\n    });\n\n    template = Option.String('-t,--template', defaultTemplate, {\n        description: `The template to use, defaults to \"${defaultTemplate}\"`,\n        validator: t.isEnum(TemplateName),\n    });\n\n    override render() {\n        return <New name={this.name} template={this.template} />;\n    }\n}\n"],"names":["Command","Option","React","t","RenderableCommand","TemplateName","New","defaultTemplate","Blank","NewCommand","render","name","template","String","description","validator","isEnum","paths","usage","Usage"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAAA,SAASA,OAAO,EAAEC,MAAM,QAAQ,YAAY;AAC5C,OAAOC,WAAW,QAAQ;AAC1B,YAAYC,OAAO,WAAW;AAC9B,SAASC,iBAAiB,QAAQ,sCAAsC;AACxE,SAASC,YAAY,QAAQ,iBAAiB;AAC9C,SAASC,GAAG,QAAQ,sBAAsB;AAE1C,MAAMC,kBAAkBF,aAAaG,KAAK;AAE1C,OAAO,MAAMC,mBAAmBL;IAgBnBM,SAAS;QACd,qBAAO,oBAACJ;YAAIK,MAAM,IAAI,CAACA,IAAI;YAAEC,UAAU,IAAI,CAACA,QAAQ;;IACxD;;;aAXAD,OAAOV,OAAOY,MAAM,CAAC;YACjBF,MAAM;QACV;aAEAC,WAAWX,OAAOY,MAAM,CAAC,iBAAiBN,iBAAiB;YACvDO,aAAa,CAAC,kCAAkC,EAAEP,gBAAgB,CAAC,CAAC;YACpEQ,WAAWZ,EAAEa,MAAM,CAACX;QACxB;;AAKJ;AAnBaI,WACOQ,QAAQ;IAAC;QAAC;KAAM;CAAC;AADxBR,WAGOS,QAAQlB,QAAQmB,KAAK,CAAC;IAClCL,aAAa;AACjB"}

package/src/commands/NewCommand/components/New.d.ts

@@ -0,0 +1,8 @@
+import React from 'react';
+import { TemplateName } from '../../../types.js';
+interface Props {
+    name: string;
+    template: TemplateName;
+}
+export declare const New: ({ name, template }: Props) => React.JSX.Element;
+export {};

package/src/commands/NewCommand/components/New.js

@@ -0,0 +1,26 @@
+import React, { useMemo } from 'react';
+import tiged from 'tiged';
+import { CheckList } from '../../../components/CheckList/index.js';
+export const New = ({ name, template })=>{
+    const items = useMemo(()=>{
+        return [
+            {
+                ready: true,
+                runner: async ()=>{
+                    const task = tiged(`crankscript/template-${template}`);
+                    await task.clone(name);
+                },
+                waitingDescription: `About to create a new project named "${name}" using the "${template}" template`,
+                runningDescription: `Creating a new project named "${name}" using the "${template}" template`,
+                finishedDescription: ()=>`Created a new project named "${name}" using the "${template}" template`,
+                errorDescription: `Failed to create project named "${name}" using the "${template}" template`
+            }
+        ];
+    }, []);
+    return /*#__PURE__*/ React.createElement(CheckList, {
+        items: items,
+        onFinish: process.exit
+    });
+};
+
+//# sourceMappingURL=New.js.map

package/src/commands/NewCommand/components/New.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../libs/cli/src/commands/NewCommand/components/New.tsx"],"sourcesContent":["import React, { useMemo } from 'react';\nimport tiged from 'tiged';\nimport { CheckList } from '@/cli/components/CheckList/index.js';\nimport { CheckListItem, TemplateName } from '@/cli/types.js';\n\ninterface Props {\n    name: string;\n    template: TemplateName;\n}\n\nexport const New = ({ name, template }: Props) => {\n    const items = useMemo(() => {\n        return [\n            {\n                ready: true,\n                runner: async () => {\n                    const task = tiged(`crankscript/template-${template}`);\n\n                    await task.clone(name);\n                },\n                waitingDescription: `About to create a new project named \"${name}\" using the \"${template}\" template`,\n                runningDescription: `Creating a new project named \"${name}\" using the \"${template}\" template`,\n                finishedDescription: () =>\n                    `Created a new project named \"${name}\" using the \"${template}\" template`,\n                errorDescription: `Failed to create project named \"${name}\" using the \"${template}\" template`,\n            },\n        ];\n    }, []) satisfies CheckListItem<unknown>[];\n\n    return <CheckList items={items} onFinish={process.exit} />;\n};\n"],"names":["React","useMemo","tiged","CheckList","New","name","template","items","ready","runner","task","clone","waitingDescription","runningDescription","finishedDescription","errorDescription","onFinish","process","exit"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAAA,OAAOA,SAASC,OAAO,QAAQ,QAAQ;AACvC,OAAOC,WAAW,QAAQ;AAC1B,SAASC,SAAS,QAAQ,sCAAsC;AAQhE,OAAO,MAAMC,MAAM,CAAC,EAAEC,IAAI,EAAEC,QAAQ,EAAS;IACzC,MAAMC,QAAQN,QAAQ;QAClB,OAAO;YACH;gBACIO,OAAO;gBACPC,QAAQ;oBACJ,MAAMC,OAAOR,MAAM,CAAC,qBAAqB,EAAEI,SAAS,CAAC;oBAErD,MAAMI,KAAKC,KAAK,CAACN;gBACrB;gBACAO,oBAAoB,CAAC,qCAAqC,EAAEP,KAAK,aAAa,EAAEC,SAAS,UAAU,CAAC;gBACpGO,oBAAoB,CAAC,8BAA8B,EAAER,KAAK,aAAa,EAAEC,SAAS,UAAU,CAAC;gBAC7FQ,qBAAqB,IACjB,CAAC,6BAA6B,EAAET,KAAK,aAAa,EAAEC,SAAS,UAAU,CAAC;gBAC5ES,kBAAkB,CAAC,gCAAgC,EAAEV,KAAK,aAAa,EAAEC,SAAS,UAAU,CAAC;YACjG;SACH;IACL,GAAG,EAAE;IAEL,qBAAO,oBAACH;QAAUI,OAAOA;QAAOS,UAAUC,QAAQC,IAAI;;AAC1D,EAAE"}

package/src/commands/RenderableCommand.d.ts

@@ -0,0 +1,7 @@
+import { Command } from 'clipanion';
+import { JSX } from 'react';
+export declare abstract class RenderableCommand extends Command {
+    protected abstract render(): JSX.Element;
+    protected renderElement(element: JSX.Element): void;
+    execute(): Promise<void>;
+}

package/src/commands/RenderableCommand.js

@@ -0,0 +1,12 @@
+import { Command } from 'clipanion';
+import { render } from 'ink';
+export class RenderableCommand extends Command {
+    renderElement(element) {
+        render(element);
+    }
+    async execute() {
+        this.renderElement(this.render());
+    }
+}
+
+//# sourceMappingURL=RenderableCommand.js.map

package/src/commands/RenderableCommand.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../libs/cli/src/commands/RenderableCommand.ts"],"sourcesContent":["import { Command } from 'clipanion';\nimport { render } from 'ink';\nimport { JSX } from 'react';\n\nexport abstract class RenderableCommand extends Command {\n    protected abstract render(): JSX.Element;\n\n    protected renderElement(element: JSX.Element) {\n        render(element);\n    }\n\n    override async execute() {\n        this.renderElement(this.render());\n    }\n}\n"],"names":["Command","render","RenderableCommand","renderElement","element","execute"],"rangeMappings":";;;;;;;;;","mappings":"AAAA,SAASA,OAAO,QAAQ,YAAY;AACpC,SAASC,MAAM,QAAQ,MAAM;AAG7B,OAAO,MAAeC,0BAA0BF;IAGlCG,cAAcC,OAAoB,EAAE;QAC1CH,OAAOG;IACX;IAEA,MAAeC,UAAU;QACrB,IAAI,CAACF,aAAa,CAAC,IAAI,CAACF,MAAM;IAClC;AACJ"}

package/src/commands/SimulatorCommand/SimulatorCommand.d.ts

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

package/src/commands/SimulatorCommand/SimulatorCommand.js

@@ -0,0 +1,39 @@
+import { Command, Option } from 'clipanion';
+import React from 'react';
+import { EnvironmentAwareCommand } from '../../commands/EnvironmentAwareCommand/index.js';
+import { Simulator } from '../../commands/SimulatorCommand/components/Simulator.js';
+import { projectPathOption } from '../../commands/TranspileCommand/index.js';
+export class SimulatorCommand extends EnvironmentAwareCommand {
+    renderWithEnvironment(environment) {
+        return /*#__PURE__*/ React.createElement(Simulator, {
+            environment: environment,
+            path: this.projectPath,
+            watch: this.watch,
+            recompileOnly: this.compileOnly,
+            background: this.background
+        });
+    }
+    constructor(...args){
+        super(...args);
+        this.watch = Option.Boolean('-w,--watch', false, {
+            description: 'Watch for changes'
+        });
+        this.compileOnly = Option.Boolean('-c,--compile-only', false, {
+            description: 'Use with --watch to only recompile without launching the simulator'
+        });
+        this.background = Option.Boolean('-b,--background', false, {
+            description: 'Do not bring simulator to foreground'
+        });
+        this.projectPath = projectPathOption;
+    }
+}
+SimulatorCommand.paths = [
+    [
+        'simulator'
+    ]
+];
+SimulatorCommand.usage = Command.Usage({
+    description: 'Transpile, compile, and run the simulator'
+});
+
+//# sourceMappingURL=SimulatorCommand.js.map

package/src/commands/SimulatorCommand/SimulatorCommand.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../libs/cli/src/commands/SimulatorCommand/SimulatorCommand.tsx"],"sourcesContent":["import { Command, Option } from 'clipanion';\nimport React from 'react';\nimport { EnvironmentAwareCommand } from '@/cli/commands/EnvironmentAwareCommand/index.js';\nimport { Simulator } from '@/cli/commands/SimulatorCommand/components/Simulator.js';\nimport { projectPathOption } from '@/cli/commands/TranspileCommand/index.js';\nimport { Environment } from '@/cli/environment/dto/Environment.js';\n\nexport class SimulatorCommand extends EnvironmentAwareCommand {\n    static override paths = [['simulator']];\n\n    static override usage = Command.Usage({\n        description: 'Transpile, compile, and run the simulator',\n    });\n\n    watch = Option.Boolean('-w,--watch', false, {\n        description: 'Watch for changes',\n    });\n\n    compileOnly = Option.Boolean('-c,--compile-only', false, {\n        description:\n            'Use with --watch to only recompile without launching the simulator',\n    });\n\n    background = Option.Boolean('-b,--background', false, {\n        description: 'Do not bring simulator to foreground',\n    });\n\n    projectPath = projectPathOption;\n\n    override renderWithEnvironment(environment: Environment) {\n        return (\n            <Simulator\n                environment={environment}\n                path={this.projectPath}\n                watch={this.watch}\n                recompileOnly={this.compileOnly}\n                background={this.background}\n            />\n        );\n    }\n}\n"],"names":["Command","Option","React","EnvironmentAwareCommand","Simulator","projectPathOption","SimulatorCommand","renderWithEnvironment","environment","path","projectPath","watch","recompileOnly","compileOnly","background","Boolean","description","paths","usage","Usage"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAAA,SAASA,OAAO,EAAEC,MAAM,QAAQ,YAAY;AAC5C,OAAOC,WAAW,QAAQ;AAC1B,SAASC,uBAAuB,QAAQ,kDAAkD;AAC1F,SAASC,SAAS,QAAQ,0DAA0D;AACpF,SAASC,iBAAiB,QAAQ,2CAA2C;AAG7E,OAAO,MAAMC,yBAAyBH;IAsBzBI,sBAAsBC,WAAwB,EAAE;QACrD,qBACI,oBAACJ;YACGI,aAAaA;YACbC,MAAM,IAAI,CAACC,WAAW;YACtBC,OAAO,IAAI,CAACA,KAAK;YACjBC,eAAe,IAAI,CAACC,WAAW;YAC/BC,YAAY,IAAI,CAACA,UAAU;;IAGvC;;;aAzBAH,QAAQV,OAAOc,OAAO,CAAC,cAAc,OAAO;YACxCC,aAAa;QACjB;aAEAH,cAAcZ,OAAOc,OAAO,CAAC,qBAAqB,OAAO;YACrDC,aACI;QACR;aAEAF,aAAab,OAAOc,OAAO,CAAC,mBAAmB,OAAO;YAClDC,aAAa;QACjB;aAEAN,cAAcL;;AAalB;AAjCaC,iBACOW,QAAQ;IAAC;QAAC;KAAY;CAAC;AAD9BX,iBAGOY,QAAQlB,QAAQmB,KAAK,CAAC;IAClCH,aAAa;AACjB"}

package/src/commands/SimulatorCommand/components/Simulator.d.ts

@@ -0,0 +1,11 @@
+import React from 'react';
+import { Environment } from '../../../environment/dto/Environment.js';
+interface Props {
+    environment: Environment;
+    path: string;
+    watch?: boolean;
+    recompileOnly?: boolean;
+    background?: boolean;
+}
+export declare const Simulator: ({ environment, path, watch, recompileOnly, background, }: Props) => React.JSX.Element;
+export {};

package/src/commands/SimulatorCommand/components/Simulator.js

@@ -0,0 +1,80 @@
+import { watch as watchDir } from 'node:fs';
+import { platform } from 'node:os';
+import { join } from 'node:path';
+import { StatusMessage } from '@inkjs/ui';
+import open from 'open';
+import React, { useCallback, useEffect, useMemo, useRef, useState } from 'react';
+import { getPdcPathFromEnvironment } from '../../../commands/CompileCommand/fn/getPdcPathFromEnvironment.js';
+import { getSimulatorPathFromEnvironment } from '../../../commands/CompileCommand/fn/getSimulatorPathFromEnvironment.js';
+import { useCompileTasks } from '../../../commands/CompileCommand/hooks/useCompileTasks.js';
+import { useTranspileTasks } from '../../../commands/TranspileCommand/hooks/useTranspileTasks.js';
+import { CheckList } from '../../../components/CheckList/index.js';
+const platformName = platform();
+export const Simulator = ({ environment, path, watch = false, recompileOnly = false, background = false })=>{
+    const watcher = useRef(null);
+    const [isWatching, setIsWatching] = useState(false);
+    const [hasChanged, setHasChanged] = useState(false);
+    const [hasChangedMessage, setHasChangedMessage] = useState(false);
+    const transpileTasks = useTranspileTasks(path);
+    const compileTasks = useCompileTasks(getPdcPathFromEnvironment(environment));
+    const hasRun = useRef(false);
+    useEffect(()=>{
+        if (hasChanged) {
+            setHasChanged(false);
+        }
+    }, [
+        hasChanged,
+        setHasChanged
+    ]);
+    const handleFinish = useCallback(()=>{
+        if (hasRun.current && recompileOnly) {
+            return;
+        }
+        hasRun.current = true;
+        open('Game.pdx', {
+            background,
+            app: platformName === 'linux' ? {
+                name: getSimulatorPathFromEnvironment(environment)
+            } : undefined
+        }).then(()=>{
+            if (!watch) {
+                process.exit();
+            }
+            setHasChangedMessage(false);
+            if (watcher.current) {
+                watcher.current.close();
+            }
+            setIsWatching(true);
+            watcher.current = watchDir(join(path, 'src'), {
+                recursive: true
+            }, ()=>{
+                setHasChanged(true);
+                setHasChangedMessage(true);
+                setIsWatching(false);
+            });
+        });
+    }, [
+        watch,
+        setHasChanged,
+        setIsWatching
+    ]);
+    const tasks = useMemo(()=>{
+        return [
+            ...transpileTasks,
+            ...compileTasks
+        ];
+    }, [
+        transpileTasks,
+        compileTasks
+    ]);
+    return /*#__PURE__*/ React.createElement(React.Fragment, null, !hasChanged && /*#__PURE__*/ React.createElement(CheckList, {
+        items: tasks,
+        onFinish: handleFinish
+    }), isWatching && !hasChangedMessage && /*#__PURE__*/ React.createElement(StatusMessage, {
+        variant: "info"
+    }, "Watching for changes..."), hasChangedMessage && /*#__PURE__*/ React.createElement(StatusMessage, {
+        variant: "info"
+    }, "Change detected"));
+};
+
+//# sourceMappingURL=Simulator.js.map

package/src/commands/SimulatorCommand/components/Simulator.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../libs/cli/src/commands/SimulatorCommand/components/Simulator.tsx"],"sourcesContent":["import { FSWatcher, watch as watchDir } from 'node:fs';\nimport { platform } from 'node:os';\nimport { join } from 'node:path';\nimport { StatusMessage } from '@inkjs/ui';\nimport open from 'open';\nimport React, {\n    useCallback,\n    useEffect,\n    useMemo,\n    useRef,\n    useState,\n} from 'react';\nimport { getPdcPathFromEnvironment } from '@/cli/commands/CompileCommand/fn/getPdcPathFromEnvironment.js';\nimport { getSimulatorPathFromEnvironment } from '@/cli/commands/CompileCommand/fn/getSimulatorPathFromEnvironment.js';\nimport { useCompileTasks } from '@/cli/commands/CompileCommand/hooks/useCompileTasks.js';\nimport { useTranspileTasks } from '@/cli/commands/TranspileCommand/hooks/useTranspileTasks.js';\nimport { CheckList } from '@/cli/components/CheckList/index.js';\nimport { Environment } from '@/cli/environment/dto/Environment.js';\n\ninterface Props {\n    environment: Environment;\n    path: string;\n    watch?: boolean;\n    recompileOnly?: boolean;\n    background?: boolean;\n}\n\nconst platformName = platform();\n\nexport const Simulator = ({\n    environment,\n    path,\n    watch = false,\n    recompileOnly = false,\n    background = false,\n}: Props) => {\n    const watcher = useRef<FSWatcher | null>(null);\n    const [isWatching, setIsWatching] = useState(false);\n    const [hasChanged, setHasChanged] = useState(false);\n    const [hasChangedMessage, setHasChangedMessage] = useState(false);\n    const transpileTasks = useTranspileTasks(path);\n    const compileTasks = useCompileTasks(\n        getPdcPathFromEnvironment(environment)\n    );\n    const hasRun = useRef(false);\n\n    useEffect(() => {\n        if (hasChanged) {\n            setHasChanged(false);\n        }\n    }, [hasChanged, setHasChanged]);\n\n    const handleFinish = useCallback(() => {\n        if (hasRun.current && recompileOnly) {\n            return;\n        }\n\n        hasRun.current = true;\n\n        open('Game.pdx', {\n            background,\n            app:\n                platformName === 'linux'\n                    ? {\n                          name: getSimulatorPathFromEnvironment(environment),\n                      }\n                    : undefined,\n        }).then(() => {\n            if (!watch) {\n                process.exit();\n            }\n\n            setHasChangedMessage(false);\n\n            if (watcher.current) {\n                watcher.current.close();\n            }\n\n            setIsWatching(true);\n\n            watcher.current = watchDir(\n                join(path, 'src'),\n                { recursive: true },\n                () => {\n                    setHasChanged(true);\n                    setHasChangedMessage(true);\n                    setIsWatching(false);\n                }\n            );\n        });\n    }, [watch, setHasChanged, setIsWatching]);\n\n    const tasks = useMemo(() => {\n        return [...transpileTasks, ...compileTasks];\n    }, [transpileTasks, compileTasks]);\n\n    return (\n        <>\n            {!hasChanged && <CheckList items={tasks} onFinish={handleFinish} />}\n            {isWatching && !hasChangedMessage && (\n                <StatusMessage variant=\"info\">\n                    Watching for changes...\n                </StatusMessage>\n            )}\n            {hasChangedMessage && (\n                <StatusMessage variant=\"info\">Change detected</StatusMessage>\n            )}\n        </>\n    );\n};\n"],"names":["watch","watchDir","platform","join","StatusMessage","open","React","useCallback","useEffect","useMemo","useRef","useState","getPdcPathFromEnvironment","getSimulatorPathFromEnvironment","useCompileTasks","useTranspileTasks","CheckList","platformName","Simulator","environment","path","recompileOnly","background","watcher","isWatching","setIsWatching","hasChanged","setHasChanged","hasChangedMessage","setHasChangedMessage","transpileTasks","compileTasks","hasRun","handleFinish","current","app","name","undefined","then","process","exit","close","recursive","tasks","items","onFinish","variant"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAAA,SAAoBA,SAASC,QAAQ,QAAQ,UAAU;AACvD,SAASC,QAAQ,QAAQ,UAAU;AACnC,SAASC,IAAI,QAAQ,YAAY;AACjC,SAASC,aAAa,QAAQ,YAAY;AAC1C,OAAOC,UAAU,OAAO;AACxB,OAAOC,SACHC,WAAW,EACXC,SAAS,EACTC,OAAO,EACPC,MAAM,EACNC,QAAQ,QACL,QAAQ;AACf,SAASC,yBAAyB,QAAQ,gEAAgE;AAC1G,SAASC,+BAA+B,QAAQ,sEAAsE;AACtH,SAASC,eAAe,QAAQ,yDAAyD;AACzF,SAASC,iBAAiB,QAAQ,6DAA6D;AAC/F,SAASC,SAAS,QAAQ,sCAAsC;AAWhE,MAAMC,eAAef;AAErB,OAAO,MAAMgB,YAAY,CAAC,EACtBC,WAAW,EACXC,IAAI,EACJpB,QAAQ,KAAK,EACbqB,gBAAgB,KAAK,EACrBC,aAAa,KAAK,EACd;IACJ,MAAMC,UAAUb,OAAyB;IACzC,MAAM,CAACc,YAAYC,cAAc,GAAGd,SAAS;IAC7C,MAAM,CAACe,YAAYC,cAAc,GAAGhB,SAAS;IAC7C,MAAM,CAACiB,mBAAmBC,qBAAqB,GAAGlB,SAAS;IAC3D,MAAMmB,iBAAiBf,kBAAkBK;IACzC,MAAMW,eAAejB,gBACjBF,0BAA0BO;IAE9B,MAAMa,SAAStB,OAAO;IAEtBF,UAAU;QACN,IAAIkB,YAAY;YACZC,cAAc;QAClB;IACJ,GAAG;QAACD;QAAYC;KAAc;IAE9B,MAAMM,eAAe1B,YAAY;QAC7B,IAAIyB,OAAOE,OAAO,IAAIb,eAAe;YACjC;QACJ;QAEAW,OAAOE,OAAO,GAAG;QAEjB7B,KAAK,YAAY;YACbiB;YACAa,KACIlB,iBAAiB,UACX;gBACImB,MAAMvB,gCAAgCM;YAC1C,IACAkB;QACd,GAAGC,IAAI,CAAC;YACJ,IAAI,CAACtC,OAAO;gBACRuC,QAAQC,IAAI;YAChB;YAEAX,qBAAqB;YAErB,IAAIN,QAAQW,OAAO,EAAE;gBACjBX,QAAQW,OAAO,CAACO,KAAK;YACzB;YAEAhB,cAAc;YAEdF,QAAQW,OAAO,GAAGjC,SACdE,KAAKiB,MAAM,QACX;gBAAEsB,WAAW;YAAK,GAClB;gBACIf,cAAc;gBACdE,qBAAqB;gBACrBJ,cAAc;YAClB;QAER;IACJ,GAAG;QAACzB;QAAO2B;QAAeF;KAAc;IAExC,MAAMkB,QAAQlC,QAAQ;QAClB,OAAO;eAAIqB;eAAmBC;SAAa;IAC/C,GAAG;QAACD;QAAgBC;KAAa;IAEjC,qBACI,0CACK,CAACL,4BAAc,oBAACV;QAAU4B,OAAOD;QAAOE,UAAUZ;QAClDT,cAAc,CAACI,mCACZ,oBAACxB;QAAc0C,SAAQ;OAAO,4BAIjClB,mCACG,oBAACxB;QAAc0C,SAAQ;OAAO;AAI9C,EAAE"}

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

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

package/src/commands/SimulatorCommand/index.js

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

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

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

package/src/commands/TranspileCommand/TranspileCommand.d.ts

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

package/src/commands/TranspileCommand/TranspileCommand.js

@@ -0,0 +1,31 @@
+import 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 { Transpile } from '../../commands/TranspileCommand/components/Transpile.js';
+export const projectPathOption = Option.String('-p,--path', process.cwd(), {
+    description: `Where to find the project. Defaults to the current working directory ("${process.cwd()}")`,
+    validator: t.isString()
+});
+export class TranspileCommand extends RenderableCommand {
+    render() {
+        return /*#__PURE__*/ React.createElement(Transpile, {
+            path: this.projectPath
+        });
+    }
+    constructor(...args){
+        super(...args);
+        this.projectPath = projectPathOption;
+    }
+}
+TranspileCommand.paths = [
+    [
+        'transpile'
+    ]
+];
+TranspileCommand.usage = Command.Usage({
+    description: 'Transpile TypeScript files to Lua'
+});
+
+//# sourceMappingURL=TranspileCommand.js.map

package/src/commands/TranspileCommand/TranspileCommand.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../libs/cli/src/commands/TranspileCommand/TranspileCommand.tsx"],"sourcesContent":["import process from 'node:process';\nimport { Command, Option } from 'clipanion';\nimport React from 'react';\nimport * as t from 'typanion';\nimport { RenderableCommand } from '@/cli/commands/RenderableCommand.js';\nimport { Transpile } from '@/cli/commands/TranspileCommand/components/Transpile.js';\n\nexport const projectPathOption = Option.String('-p,--path', process.cwd(), {\n    description: `Where to find the project. Defaults to the current working directory (\"${process.cwd()}\")`,\n    validator: t.isString(),\n});\n\nexport class TranspileCommand extends RenderableCommand {\n    static override paths = [['transpile']];\n\n    static override usage = Command.Usage({\n        description: 'Transpile TypeScript files to Lua',\n    });\n\n    projectPath = projectPathOption;\n\n    override render() {\n        return <Transpile path={this.projectPath} />;\n    }\n}\n"],"names":["process","Command","Option","React","t","RenderableCommand","Transpile","projectPathOption","String","cwd","description","validator","isString","TranspileCommand","render","path","projectPath","paths","usage","Usage"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAAA,OAAOA,aAAa,eAAe;AACnC,SAASC,OAAO,EAAEC,MAAM,QAAQ,YAAY;AAC5C,OAAOC,WAAW,QAAQ;AAC1B,YAAYC,OAAO,WAAW;AAC9B,SAASC,iBAAiB,QAAQ,sCAAsC;AACxE,SAASC,SAAS,QAAQ,0DAA0D;AAEpF,OAAO,MAAMC,oBAAoBL,OAAOM,MAAM,CAAC,aAAaR,QAAQS,GAAG,IAAI;IACvEC,aAAa,CAAC,uEAAuE,EAAEV,QAAQS,GAAG,GAAG,EAAE,CAAC;IACxGE,WAAWP,EAAEQ,QAAQ;AACzB,GAAG;AAEH,OAAO,MAAMC,yBAAyBR;IASzBS,SAAS;QACd,qBAAO,oBAACR;YAAUS,MAAM,IAAI,CAACC,WAAW;;IAC5C;;;aAJAA,cAAcT;;AAKlB;AAZaM,iBACOI,QAAQ;IAAC;QAAC;KAAY;CAAC;AAD9BJ,iBAGOK,QAAQjB,QAAQkB,KAAK,CAAC;IAClCT,aAAa;AACjB"}

package/src/commands/TranspileCommand/components/Transpile.d.ts

@@ -0,0 +1,6 @@
+import React from 'react';
+interface Props {
+    path: string;
+}
+export declare const Transpile: ({ path }: Props) => React.JSX.Element;
+export {};

package/src/commands/TranspileCommand/components/Transpile.js

@@ -0,0 +1,12 @@
+import React from 'react';
+import { useTranspileTasks } from '../../../commands/TranspileCommand/hooks/useTranspileTasks.js';
+import { CheckList } from '../../../components/CheckList/index.js';
+export const Transpile = ({ path })=>{
+    const items = useTranspileTasks(path);
+    return /*#__PURE__*/ React.createElement(CheckList, {
+        items: items,
+        onFinish: process.exit
+    });
+};
+
+//# sourceMappingURL=Transpile.js.map