crankscript 0.13.1 → 0.15.1

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

@@ -0,0 +1,43 @@
+import { mkdirSync } from 'node:fs';
+import React, { useMemo, useState } from 'react';
+import { CheckList } from '../../../components/CheckList/index.js';
+import { useCrankScriptContext } from '../../EnvironmentAwareCommand/contexts/CrankScriptContext.js';
+import { createTemporaryFolderPathFromEntryFile } from '../fn/createTemporaryFolderPathFromEntryFile.js';
+export const TemporaryFolderCreator = ({ entryFile, children })=>{
+    const [created, setCreated] = useState(false);
+    const { verbose } = useCrankScriptContext();
+    const temporaryFolder = useMemo(()=>{
+        return createTemporaryFolderPathFromEntryFile(entryFile);
+    }, [
+        entryFile
+    ]);
+    const items = useMemo(()=>{
+        return [
+            {
+                waitingDescription: 'Waiting to create temporary directory...',
+                runningDescription: 'Creating temporary directory...',
+                errorDescription: 'Failed to create temporary directory',
+                runner: async ()=>{
+                    if (!temporaryFolder) {
+                        return false;
+                    }
+                    mkdirSync(temporaryFolder, {
+                        recursive: true
+                    });
+                    return true;
+                },
+                finishedDescription: ()=>{
+                    return `Temporary directory ${verbose ? `"${temporaryFolder}" ` : ''}created`;
+                }
+            }
+        ];
+    }, [
+        created
+    ]);
+    return /*#__PURE__*/ React.createElement(React.Fragment, null, /*#__PURE__*/ React.createElement(CheckList, {
+        items: items,
+        onFinish: ()=>setCreated(true)
+    }), created && children);
+};
+
+//# sourceMappingURL=TemporaryFolderCreator.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../libs/cli/src/commands/SimulatorCommand/components/TemporaryFolderCreator.tsx"],"sourcesContent":["import { mkdirSync } from 'node:fs';\nimport React, { useMemo, ReactNode, useState } from 'react';\nimport { CheckList } from '@/cli/components/CheckList/index.js';\nimport { CheckListItem } from '@/cli/types.js';\nimport { useCrankScriptContext } from '../../EnvironmentAwareCommand/contexts/CrankScriptContext.js';\nimport { createTemporaryFolderPathFromEntryFile } from '../fn/createTemporaryFolderPathFromEntryFile.js';\n\ninterface Props {\n    entryFile: string;\n    children: ReactNode;\n}\n\nexport const TemporaryFolderCreator = ({ entryFile, children }: Props) => {\n    const [created, setCreated] = useState(false);\n    const { verbose } = useCrankScriptContext();\n    const temporaryFolder = useMemo(() => {\n        return createTemporaryFolderPathFromEntryFile(entryFile);\n    }, [entryFile]);\n\n    const items = useMemo(() => {\n        return [\n            {\n                waitingDescription: 'Waiting to create temporary directory...',\n                runningDescription: 'Creating temporary directory...',\n                errorDescription: 'Failed to create temporary directory',\n                runner: async () => {\n                    if (!temporaryFolder) {\n                        return false;\n                    }\n\n                    mkdirSync(temporaryFolder, { recursive: true });\n\n                    return true;\n                },\n                finishedDescription: () => {\n                    return `Temporary directory ${\n                        verbose ? `\"${temporaryFolder}\" ` : ''\n                    }created`;\n                },\n            },\n        ] satisfies CheckListItem<unknown>[];\n    }, [created]);\n\n    return (\n        <>\n            <CheckList items={items} onFinish={() => setCreated(true)} />\n            {created && children}\n        </>\n    );\n};\n"],"names":["mkdirSync","React","useMemo","useState","CheckList","useCrankScriptContext","createTemporaryFolderPathFromEntryFile","TemporaryFolderCreator","entryFile","children","created","setCreated","verbose","temporaryFolder","items","waitingDescription","runningDescription","errorDescription","runner","recursive","finishedDescription","onFinish"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAAA,SAASA,SAAS,QAAQ,UAAU;AACpC,OAAOC,SAASC,OAAO,EAAaC,QAAQ,QAAQ,QAAQ;AAC5D,SAASC,SAAS,QAAQ,sCAAsC;AAEhE,SAASC,qBAAqB,QAAQ,+DAA+D;AACrG,SAASC,sCAAsC,QAAQ,kDAAkD;AAOzG,OAAO,MAAMC,yBAAyB,CAAC,EAAEC,SAAS,EAAEC,QAAQ,EAAS;IACjE,MAAM,CAACC,SAASC,WAAW,GAAGR,SAAS;IACvC,MAAM,EAAES,OAAO,EAAE,GAAGP;IACpB,MAAMQ,kBAAkBX,QAAQ;QAC5B,OAAOI,uCAAuCE;IAClD,GAAG;QAACA;KAAU;IAEd,MAAMM,QAAQZ,QAAQ;QAClB,OAAO;YACH;gBACIa,oBAAoB;gBACpBC,oBAAoB;gBACpBC,kBAAkB;gBAClBC,QAAQ;oBACJ,IAAI,CAACL,iBAAiB;wBAClB,OAAO;oBACX;oBAEAb,UAAUa,iBAAiB;wBAAEM,WAAW;oBAAK;oBAE7C,OAAO;gBACX;gBACAC,qBAAqB;oBACjB,OAAO,CAAC,oBAAoB,EACxBR,UAAU,CAAC,CAAC,EAAEC,gBAAgB,EAAE,CAAC,GAAG,GACvC,OAAO,CAAC;gBACb;YACJ;SACH;IACL,GAAG;QAACH;KAAQ;IAEZ,qBACI,wDACI,oBAACN;QAAUU,OAAOA;QAAOO,UAAU,IAAMV,WAAW;QACnDD,WAAWD;AAGxB,EAAE"}

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

@@ -0,0 +1 @@
+export declare const createTemporaryFolderPathFromEntryFile: (entryFilePath: string) => string;

package/src/commands/SimulatorCommand/fn/createTemporaryFolderPathFromEntryFile.js

@@ -0,0 +1,9 @@
+import { createHash } from 'crypto';
+import { tmpdir } from 'os';
+import { join } from 'path';
+export const createTemporaryFolderPathFromEntryFile = (entryFilePath)=>{
+    const hash = createHash('sha256').update(entryFilePath).digest('hex').slice(0, 8);
+    return join(tmpdir(), 'crankscript', `run-${hash}`);
+};
+
+//# sourceMappingURL=createTemporaryFolderPathFromEntryFile.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../libs/cli/src/commands/SimulatorCommand/fn/createTemporaryFolderPathFromEntryFile.ts"],"sourcesContent":["import { createHash } from 'crypto';\nimport { tmpdir } from 'os';\nimport { join } from 'path';\n\nexport const createTemporaryFolderPathFromEntryFile = (\n    entryFilePath: string,\n) => {\n    const hash = createHash('sha256')\n        .update(entryFilePath)\n        .digest('hex')\n        .slice(0, 8);\n\n    return join(tmpdir(), 'crankscript', `run-${hash}`);\n};\n"],"names":["createHash","tmpdir","join","createTemporaryFolderPathFromEntryFile","entryFilePath","hash","update","digest","slice"],"rangeMappings":";;;;;;","mappings":"AAAA,SAASA,UAAU,QAAQ,SAAS;AACpC,SAASC,MAAM,QAAQ,KAAK;AAC5B,SAASC,IAAI,QAAQ,OAAO;AAE5B,OAAO,MAAMC,yCAAyC,CAClDC;IAEA,MAAMC,OAAOL,WAAW,UACnBM,MAAM,CAACF,eACPG,MAAM,CAAC,OACPC,KAAK,CAAC,GAAG;IAEd,OAAON,KAAKD,UAAU,eAAe,CAAC,IAAI,EAAEI,KAAK,CAAC;AACtD,EAAE"}

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

@@ -0,0 +1,6 @@
+export declare const useFileWatcher: (options: {
+    watchPath: string;
+    additionalGlobs?: string[];
+    onChange: () => void;
+    enabled: boolean;
+}) => void;

package/src/commands/SimulatorCommand/hooks/useFileWatcher.js

@@ -0,0 +1,37 @@
+import { watch } from 'chokidar';
+import { useEffect, useRef } from 'react';
+export const useFileWatcher = (options)=>{
+    const watcher = useRef(null);
+    const started = useRef(false);
+    useEffect(()=>{
+        if (!options.enabled || started.current) {
+            return;
+        }
+        watcher.current = watch(options.watchPath, {
+            ignoreInitial: true,
+            awaitWriteFinish: {
+                stabilityThreshold: 200,
+                pollInterval: 100
+            }
+        });
+        if (options.additionalGlobs) {
+            watcher.current.add(options.additionalGlobs);
+        }
+        watcher.current.on('change', ()=>{
+            options.onChange();
+        });
+        started.current = true;
+        return ()=>{
+            var _watcher_current;
+            (_watcher_current = watcher.current) == null ? void 0 : _watcher_current.close();
+            watcher.current = null;
+            started.current = false;
+        };
+    }, [
+        options.enabled,
+        options.watchPath,
+        options.onChange
+    ]);
+};
+
+//# sourceMappingURL=useFileWatcher.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../libs/cli/src/commands/SimulatorCommand/hooks/useFileWatcher.ts"],"sourcesContent":["import { FSWatcher, watch } from 'chokidar';\nimport { useEffect, useRef } from 'react';\n\nexport const useFileWatcher = (options: {\n    watchPath: string;\n    additionalGlobs?: string[];\n    onChange: () => void;\n    enabled: boolean;\n}) => {\n    const watcher = useRef<FSWatcher | null>(null);\n    const started = useRef(false);\n\n    useEffect(() => {\n        if (!options.enabled || started.current) {\n            return;\n        }\n\n        watcher.current = watch(options.watchPath, {\n            ignoreInitial: true,\n            awaitWriteFinish: {\n                stabilityThreshold: 200,\n                pollInterval: 100,\n            },\n        });\n\n        if (options.additionalGlobs) {\n            watcher.current.add(options.additionalGlobs);\n        }\n\n        watcher.current.on('change', () => {\n            options.onChange();\n        });\n\n        started.current = true;\n\n        return () => {\n            watcher.current?.close();\n            watcher.current = null;\n            started.current = false;\n        };\n    }, [options.enabled, options.watchPath, options.onChange]);\n};\n"],"names":["watch","useEffect","useRef","useFileWatcher","options","watcher","started","enabled","current","watchPath","ignoreInitial","awaitWriteFinish","stabilityThreshold","pollInterval","additionalGlobs","add","on","onChange","close"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAAA,SAAoBA,KAAK,QAAQ,WAAW;AAC5C,SAASC,SAAS,EAAEC,MAAM,QAAQ,QAAQ;AAE1C,OAAO,MAAMC,iBAAiB,CAACC;IAM3B,MAAMC,UAAUH,OAAyB;IACzC,MAAMI,UAAUJ,OAAO;IAEvBD,UAAU;QACN,IAAI,CAACG,QAAQG,OAAO,IAAID,QAAQE,OAAO,EAAE;YACrC;QACJ;QAEAH,QAAQG,OAAO,GAAGR,MAAMI,QAAQK,SAAS,EAAE;YACvCC,eAAe;YACfC,kBAAkB;gBACdC,oBAAoB;gBACpBC,cAAc;YAClB;QACJ;QAEA,IAAIT,QAAQU,eAAe,EAAE;YACzBT,QAAQG,OAAO,CAACO,GAAG,CAACX,QAAQU,eAAe;QAC/C;QAEAT,QAAQG,OAAO,CAACQ,EAAE,CAAC,UAAU;YACzBZ,QAAQa,QAAQ;QACpB;QAEAX,QAAQE,OAAO,GAAG;QAElB,OAAO;gBACHH;aAAAA,mBAAAA,QAAQG,OAAO,qBAAfH,iBAAiBa,KAAK;YACtBb,QAAQG,OAAO,GAAG;YAClBF,QAAQE,OAAO,GAAG;QACtB;IACJ,GAAG;QAACJ,QAAQG,OAAO;QAAEH,QAAQK,SAAS;QAAEL,QAAQa,QAAQ;KAAC;AAC7D,EAAE"}

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

@@ -0,0 +1,22 @@
+import { Environment } from '../../../environment/dto/Environment.js';
+interface Props {
+    path: string;
+    environment: Environment;
+    watchForChanges: boolean;
+    recompileOnly: boolean;
+    background: boolean;
+    entryFile?: string;
+    luaOutputPath?: string;
+    gameOutputPath?: string;
+    requireWithinProjectPath?: boolean;
+    additionalGlobs?: string[];
+}
+export declare const useSimulatorTasks: ({ path, environment, watchForChanges, recompileOnly, background, entryFile, luaOutputPath, gameOutputPath, requireWithinProjectPath, additionalGlobs, }: Props) => {
+    tasks: import("../../../types.js").CheckListItem<unknown>[];
+    handleFinish: (hasFailure: boolean) => void;
+    hasChanged: boolean;
+    isWatching: boolean;
+    hasChangedMessage: boolean;
+    hasFailure: boolean;
+};
+export {};

package/src/commands/SimulatorCommand/hooks/useSimulatorTasks.js

@@ -0,0 +1,109 @@
+import { join } from 'node:path';
+import open from 'open';
+import { useCallback, useEffect, useMemo } from 'react';
+import { useState } from 'react';
+import { useRef } from 'react';
+import { isWindows } from '../../../utils/platform.js';
+import { isMac } from '../../../utils/platform.js';
+import { useFileWatcher } from './useFileWatcher.js';
+import { getPdcPathFromEnvironment } from '../../CompileCommand/fn/getPdcPathFromEnvironment.js';
+import { useCompileTasks } from '../../CompileCommand/hooks/useCompileTasks.js';
+import { validateEntryPoint } from '../../TranspileCommand/fn/validateEntryPoint.js';
+import { validateExitPoint } from '../../TranspileCommand/fn/validateExitPoint.js';
+import { useTranspileTasks } from '../../TranspileCommand/hooks/useTranspileTasks.js';
+import { TranspileMode } from '../../TranspileCommand/types.js';
+import { getSimulatorPathFromEnvironment } from '../fn/getSimulatorPathFromEnvironment.js';
+export const useSimulatorTasks = ({ path, environment, watchForChanges, recompileOnly, background, entryFile, luaOutputPath, gameOutputPath, requireWithinProjectPath = true, additionalGlobs = [] })=>{
+    const [isWatching, setIsWatching] = useState(false);
+    const [hasChanged, setHasChanged] = useState(false);
+    const [hasChangedMessage, setHasChangedMessage] = useState(false);
+    const [hasFailure, setHasFailure] = useState(false);
+    const didRun = useRef(false);
+    useEffect(()=>{
+        if (hasChanged) {
+            setHasChanged(false);
+        }
+    }, [
+        hasChanged,
+        setHasChanged
+    ]);
+    const transpileTasks = useTranspileTasks({
+        entryPoint: validateEntryPoint({
+            projectPath: path,
+            entryFile: entryFile != null ? entryFile : join(path, 'src', 'index.ts'),
+            requireWithinProjectPath
+        }),
+        exitPoint: validateExitPoint({
+            projectPath: path,
+            exitFile: join(...luaOutputPath ? [
+                luaOutputPath
+            ] : [
+                path,
+                'Source'
+            ], 'main.lua'),
+            requireWithinProjectPath
+        }),
+        transpileMode: entryFile ? TranspileMode.File : TranspileMode.Project
+    });
+    const compileTasks = useCompileTasks({
+        pdcPath: getPdcPathFromEnvironment(environment),
+        outputPath: gameOutputPath
+    });
+    const handleFinish = useCallback((hasFailure)=>{
+        setHasFailure(hasFailure);
+        if (didRun.current && recompileOnly) {
+            return;
+        }
+        didRun.current = true;
+        open(join(gameOutputPath != null ? gameOutputPath : process.cwd(), 'Game.pdx'), {
+            background,
+            app: isMac ? undefined : {
+                name: getSimulatorPathFromEnvironment(environment)
+            }
+        }).then(()=>{
+            if (!watchForChanges) {
+                if (!isWindows) {
+                    process.exit();
+                }
+                setTimeout(process.exit, 1000);
+            } else {
+                setHasChangedMessage(false);
+                setIsWatching(true);
+            }
+        });
+    }, [
+        watchForChanges,
+        recompileOnly,
+        gameOutputPath,
+        environment,
+        background
+    ]);
+    useFileWatcher({
+        watchPath: entryFile ? entryFile : join(path, 'src'),
+        enabled: isWatching,
+        onChange: ()=>{
+            setHasChanged(true);
+            setHasChangedMessage(true);
+        },
+        additionalGlobs
+    });
+    const tasks = useMemo(()=>{
+        return [
+            ...transpileTasks,
+            ...compileTasks
+        ];
+    }, [
+        transpileTasks,
+        compileTasks
+    ]);
+    return {
+        tasks,
+        handleFinish,
+        hasChanged,
+        isWatching,
+        hasChangedMessage,
+        hasFailure
+    };
+};
+
+//# sourceMappingURL=useSimulatorTasks.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../libs/cli/src/commands/SimulatorCommand/hooks/useSimulatorTasks.ts"],"sourcesContent":["import { join } from 'node:path';\nimport open from 'open';\nimport { useCallback, useEffect, useMemo } from 'react';\nimport { useState } from 'react';\nimport { useRef } from 'react';\nimport { CheckListProps } from '@/cli/components/CheckList/CheckList.js';\nimport { Environment } from '@/cli/environment/dto/Environment.js';\nimport { isWindows } from '@/cli/utils/platform.js';\nimport { isMac } from '@/cli/utils/platform.js';\nimport { useFileWatcher } from './useFileWatcher.js';\nimport { getPdcPathFromEnvironment } from '../../CompileCommand/fn/getPdcPathFromEnvironment.js';\nimport { useCompileTasks } from '../../CompileCommand/hooks/useCompileTasks.js';\nimport { validateEntryPoint } from '../../TranspileCommand/fn/validateEntryPoint.js';\nimport { validateExitPoint } from '../../TranspileCommand/fn/validateExitPoint.js';\nimport { useTranspileTasks } from '../../TranspileCommand/hooks/useTranspileTasks.js';\nimport { TranspileMode } from '../../TranspileCommand/types.js';\nimport { getSimulatorPathFromEnvironment } from '../fn/getSimulatorPathFromEnvironment.js';\n\ninterface Props {\n    path: string;\n    environment: Environment;\n    watchForChanges: boolean;\n    recompileOnly: boolean;\n    background: boolean;\n    entryFile?: string;\n    luaOutputPath?: string;\n    gameOutputPath?: string;\n    requireWithinProjectPath?: boolean;\n    additionalGlobs?: string[];\n}\n\nexport const useSimulatorTasks = ({\n    path,\n    environment,\n    watchForChanges,\n    recompileOnly,\n    background,\n    entryFile,\n    luaOutputPath,\n    gameOutputPath,\n    requireWithinProjectPath = true,\n    additionalGlobs = [],\n}: Props) => {\n    const [isWatching, setIsWatching] = useState(false);\n    const [hasChanged, setHasChanged] = useState(false);\n    const [hasChangedMessage, setHasChangedMessage] = useState(false);\n    const [hasFailure, setHasFailure] = useState(false);\n    const didRun = useRef(false);\n\n    useEffect(() => {\n        if (hasChanged) {\n            setHasChanged(false);\n        }\n    }, [hasChanged, setHasChanged]);\n\n    const transpileTasks = useTranspileTasks({\n        entryPoint: validateEntryPoint({\n            projectPath: path,\n            entryFile: entryFile ?? join(path, 'src', 'index.ts'),\n            requireWithinProjectPath,\n        }),\n        exitPoint: validateExitPoint({\n            projectPath: path,\n            exitFile: join(\n                ...(luaOutputPath ? [luaOutputPath] : [path, 'Source']),\n                'main.lua',\n            ),\n            requireWithinProjectPath,\n        }),\n        transpileMode: entryFile ? TranspileMode.File : TranspileMode.Project,\n    });\n\n    const compileTasks = useCompileTasks({\n        pdcPath: getPdcPathFromEnvironment(environment),\n        outputPath: gameOutputPath,\n    });\n\n    const handleFinish = useCallback(\n        (hasFailure => {\n            setHasFailure(hasFailure);\n\n            if (didRun.current && recompileOnly) {\n                return;\n            }\n\n            didRun.current = true;\n\n            open(join(gameOutputPath ?? process.cwd(), 'Game.pdx'), {\n                background,\n                app: isMac\n                    ? undefined\n                    : {\n                          name: getSimulatorPathFromEnvironment(environment),\n                      },\n            }).then(() => {\n                if (!watchForChanges) {\n                    if (!isWindows) {\n                        process.exit();\n                    }\n                    setTimeout(process.exit, 1000);\n                } else {\n                    setHasChangedMessage(false);\n                    setIsWatching(true);\n                }\n            });\n        }) satisfies CheckListProps['onFinish'],\n        [\n            watchForChanges,\n            recompileOnly,\n            gameOutputPath,\n            environment,\n            background,\n        ],\n    );\n\n    useFileWatcher({\n        watchPath: entryFile ? entryFile : join(path, 'src'),\n        enabled: isWatching,\n        onChange: () => {\n            setHasChanged(true);\n            setHasChangedMessage(true);\n        },\n        additionalGlobs,\n    });\n\n    const tasks = useMemo(() => {\n        return [...transpileTasks, ...compileTasks];\n    }, [transpileTasks, compileTasks]);\n\n    return {\n        tasks,\n        handleFinish,\n        hasChanged,\n        isWatching,\n        hasChangedMessage,\n        hasFailure,\n    };\n};\n"],"names":["join","open","useCallback","useEffect","useMemo","useState","useRef","isWindows","isMac","useFileWatcher","getPdcPathFromEnvironment","useCompileTasks","validateEntryPoint","validateExitPoint","useTranspileTasks","TranspileMode","getSimulatorPathFromEnvironment","useSimulatorTasks","path","environment","watchForChanges","recompileOnly","background","entryFile","luaOutputPath","gameOutputPath","requireWithinProjectPath","additionalGlobs","isWatching","setIsWatching","hasChanged","setHasChanged","hasChangedMessage","setHasChangedMessage","hasFailure","setHasFailure","didRun","transpileTasks","entryPoint","projectPath","exitPoint","exitFile","transpileMode","File","Project","compileTasks","pdcPath","outputPath","handleFinish","current","process","cwd","app","undefined","name","then","exit","setTimeout","watchPath","enabled","onChange","tasks"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAAA,SAASA,IAAI,QAAQ,YAAY;AACjC,OAAOC,UAAU,OAAO;AACxB,SAASC,WAAW,EAAEC,SAAS,EAAEC,OAAO,QAAQ,QAAQ;AACxD,SAASC,QAAQ,QAAQ,QAAQ;AACjC,SAASC,MAAM,QAAQ,QAAQ;AAG/B,SAASC,SAAS,QAAQ,0BAA0B;AACpD,SAASC,KAAK,QAAQ,0BAA0B;AAChD,SAASC,cAAc,QAAQ,sBAAsB;AACrD,SAASC,yBAAyB,QAAQ,uDAAuD;AACjG,SAASC,eAAe,QAAQ,gDAAgD;AAChF,SAASC,kBAAkB,QAAQ,kDAAkD;AACrF,SAASC,iBAAiB,QAAQ,iDAAiD;AACnF,SAASC,iBAAiB,QAAQ,oDAAoD;AACtF,SAASC,aAAa,QAAQ,kCAAkC;AAChE,SAASC,+BAA+B,QAAQ,2CAA2C;AAe3F,OAAO,MAAMC,oBAAoB,CAAC,EAC9BC,IAAI,EACJC,WAAW,EACXC,eAAe,EACfC,aAAa,EACbC,UAAU,EACVC,SAAS,EACTC,aAAa,EACbC,cAAc,EACdC,2BAA2B,IAAI,EAC/BC,kBAAkB,EAAE,EAChB;IACJ,MAAM,CAACC,YAAYC,cAAc,GAAGxB,SAAS;IAC7C,MAAM,CAACyB,YAAYC,cAAc,GAAG1B,SAAS;IAC7C,MAAM,CAAC2B,mBAAmBC,qBAAqB,GAAG5B,SAAS;IAC3D,MAAM,CAAC6B,YAAYC,cAAc,GAAG9B,SAAS;IAC7C,MAAM+B,SAAS9B,OAAO;IAEtBH,UAAU;QACN,IAAI2B,YAAY;YACZC,cAAc;QAClB;IACJ,GAAG;QAACD;QAAYC;KAAc;IAE9B,MAAMM,iBAAiBvB,kBAAkB;QACrCwB,YAAY1B,mBAAmB;YAC3B2B,aAAarB;YACbK,WAAWA,oBAAAA,YAAavB,KAAKkB,MAAM,OAAO;YAC1CQ;QACJ;QACAc,WAAW3B,kBAAkB;YACzB0B,aAAarB;YACbuB,UAAUzC,QACFwB,gBAAgB;gBAACA;aAAc,GAAG;gBAACN;gBAAM;aAAS,EACtD;YAEJQ;QACJ;QACAgB,eAAenB,YAAYR,cAAc4B,IAAI,GAAG5B,cAAc6B,OAAO;IACzE;IAEA,MAAMC,eAAelC,gBAAgB;QACjCmC,SAASpC,0BAA0BS;QACnC4B,YAAYtB;IAChB;IAEA,MAAMuB,eAAe9C,YAChBgC,CAAAA;QACGC,cAAcD;QAEd,IAAIE,OAAOa,OAAO,IAAI5B,eAAe;YACjC;QACJ;QAEAe,OAAOa,OAAO,GAAG;QAEjBhD,KAAKD,KAAKyB,yBAAAA,iBAAkByB,QAAQC,GAAG,IAAI,aAAa;YACpD7B;YACA8B,KAAK5C,QACC6C,YACA;gBACIC,MAAMtC,gCAAgCG;YAC1C;QACV,GAAGoC,IAAI,CAAC;YACJ,IAAI,CAACnC,iBAAiB;gBAClB,IAAI,CAACb,WAAW;oBACZ2C,QAAQM,IAAI;gBAChB;gBACAC,WAAWP,QAAQM,IAAI,EAAE;YAC7B,OAAO;gBACHvB,qBAAqB;gBACrBJ,cAAc;YAClB;QACJ;IACJ,GACA;QACIT;QACAC;QACAI;QACAN;QACAG;KACH;IAGLb,eAAe;QACXiD,WAAWnC,YAAYA,YAAYvB,KAAKkB,MAAM;QAC9CyC,SAAS/B;QACTgC,UAAU;YACN7B,cAAc;YACdE,qBAAqB;QACzB;QACAN;IACJ;IAEA,MAAMkC,QAAQzD,QAAQ;QAClB,OAAO;eAAIiC;eAAmBQ;SAAa;IAC/C,GAAG;QAACR;QAAgBQ;KAAa;IAEjC,OAAO;QACHgB;QACAb;QACAlB;QACAF;QACAI;QACAE;IACJ;AACJ,EAAE"}

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

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

package/src/commands/TranspileCommand/TranspileCommand.js

@@ -6,8 +6,9 @@ import { RenderableCommand } from '../../commands/RenderableCommand.js';
 import { Transpile } from '../../commands/TranspileCommand/components/Transpile.js';
 import { validateEntryPoint } from '../../commands/TranspileCommand/fn/validateEntryPoint.js';
 import { validateExitPoint } from './fn/validateExitPoint.js';
-export const projectPathOption = Option.String('-p,--path', process.cwd(), {
-    description: `Where to find the project. Defaults to the current working directory ("${process.cwd()}")`,
+export const defaultProjectPath = process.cwd();
+export const projectPathOption = Option.String('-p,--path', defaultProjectPath, {
+    description: `Where to find the project. Defaults to the current working directory ("${defaultProjectPath}")`,
     validator: t.isString()
 });
 export class TranspileCommand extends RenderableCommand {
@@ -22,7 +23,8 @@ export class TranspileCommand extends RenderableCommand {
         });
         return /*#__PURE__*/ React.createElement(Transpile, {
             entryPoint: validatedEntryPoint,
-            exitPoint: validatedExitPoint
+            exitPoint: validatedExitPoint,
+            toybox: this.toybox
         });
     }
     constructor(...args){
@@ -31,10 +33,14 @@ export class TranspileCommand extends RenderableCommand {
             description: 'The entry point to transpile',
             validator: t.isString()
         });
-        this.exitFile = Option.String('-o,--output', 'Source/main.lua', {
+        this.exitFile = Option.String('-o,--output', 'Source/index.lua', {
             description: 'The output bundle',
             validator: t.isString()
         });
+        this.toybox = Option.String('--toybox', {
+            description: 'Output a toybox compatible bundle which exports to this namespace',
+            validator: t.isString()
+        });
         this.projectPath = projectPathOption;
     }
 }

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

@@ -1 +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';\nimport { validateEntryPoint } from '@/cli/commands/TranspileCommand/fn/validateEntryPoint.js';\nimport { validateExitPoint } from './fn/validateExitPoint.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    entryFile = Option.String('-i,--input', 'src/index.ts', {\n        description: 'The entry point to transpile',\n        validator: t.isString(),\n    });\n\n    exitFile = Option.String('-o,--output', 'Source/main.lua', {\n        description: 'The output bundle',\n        validator: t.isString(),\n    });\n\n    projectPath = projectPathOption;\n\n    override render() {\n        const validatedEntryPoint = validateEntryPoint({\n            projectPath: this.projectPath,\n            entryFile: this.entryFile,\n        });\n\n        const validatedExitPoint = validateExitPoint({\n            projectPath: this.projectPath,\n            exitFile: this.exitFile,\n        });\n\n        return (\n            <Transpile\n                entryPoint={validatedEntryPoint}\n                exitPoint={validatedExitPoint}\n            />\n        );\n    }\n}\n"],"names":["process","Command","Option","React","t","RenderableCommand","Transpile","validateEntryPoint","validateExitPoint","projectPathOption","String","cwd","description","validator","isString","TranspileCommand","render","validatedEntryPoint","projectPath","entryFile","validatedExitPoint","exitFile","entryPoint","exitPoint","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;AACpF,SAASC,kBAAkB,QAAQ,2DAA2D;AAC9F,SAASC,iBAAiB,QAAQ,4BAA4B;AAE9D,OAAO,MAAMC,oBAAoBP,OAAOQ,MAAM,CAAC,aAAaV,QAAQW,GAAG,IAAI;IACvEC,aAAa,CAAC,uEAAuE,EAAEZ,QAAQW,GAAG,GAAG,EAAE,CAAC;IACxGE,WAAWT,EAAEU,QAAQ;AACzB,GAAG;AAEH,OAAO,MAAMC,yBAAyBV;IAmBzBW,SAAS;QACd,MAAMC,sBAAsBV,mBAAmB;YAC3CW,aAAa,IAAI,CAACA,WAAW;YAC7BC,WAAW,IAAI,CAACA,SAAS;QAC7B;QAEA,MAAMC,qBAAqBZ,kBAAkB;YACzCU,aAAa,IAAI,CAACA,WAAW;YAC7BG,UAAU,IAAI,CAACA,QAAQ;QAC3B;QAEA,qBACI,oBAACf;YACGgB,YAAYL;YACZM,WAAWH;;IAGvB;;;aA7BAD,YAAYjB,OAAOQ,MAAM,CAAC,cAAc,gBAAgB;YACpDE,aAAa;YACbC,WAAWT,EAAEU,QAAQ;QACzB;aAEAO,WAAWnB,OAAOQ,MAAM,CAAC,eAAe,mBAAmB;YACvDE,aAAa;YACbC,WAAWT,EAAEU,QAAQ;QACzB;aAEAI,cAAcT;;AAoBlB;AArCaM,iBACOS,QAAQ;IAAC;QAAC;KAAY;CAAC;AAD9BT,iBAGOU,QAAQxB,QAAQyB,KAAK,CAAC;IAClCd,aAAa;AACjB"}
+{"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';\nimport { validateEntryPoint } from '@/cli/commands/TranspileCommand/fn/validateEntryPoint.js';\nimport { validateExitPoint } from './fn/validateExitPoint.js';\n\nexport const defaultProjectPath = process.cwd();\nexport const projectPathOption = Option.String(\n    '-p,--path',\n    defaultProjectPath,\n    {\n        description: `Where to find the project. Defaults to the current working directory (\"${defaultProjectPath}\")`,\n        validator: t.isString(),\n    },\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    entryFile = Option.String('-i,--input', 'src/index.ts', {\n        description: 'The entry point to transpile',\n        validator: t.isString(),\n    });\n\n    exitFile = Option.String('-o,--output', 'Source/index.lua', {\n        description: 'The output bundle',\n        validator: t.isString(),\n    });\n\n    toybox = Option.String('--toybox', {\n        description:\n            'Output a toybox compatible bundle which exports to this namespace',\n        validator: t.isString(),\n    });\n\n    projectPath = projectPathOption;\n\n    override render() {\n        const validatedEntryPoint = validateEntryPoint({\n            projectPath: this.projectPath,\n            entryFile: this.entryFile,\n        });\n\n        const validatedExitPoint = validateExitPoint({\n            projectPath: this.projectPath,\n            exitFile: this.exitFile,\n        });\n\n        return (\n            <Transpile\n                entryPoint={validatedEntryPoint}\n                exitPoint={validatedExitPoint}\n                toybox={this.toybox}\n            />\n        );\n    }\n}\n"],"names":["process","Command","Option","React","t","RenderableCommand","Transpile","validateEntryPoint","validateExitPoint","defaultProjectPath","cwd","projectPathOption","String","description","validator","isString","TranspileCommand","render","validatedEntryPoint","projectPath","entryFile","validatedExitPoint","exitFile","entryPoint","exitPoint","toybox","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;AACpF,SAASC,kBAAkB,QAAQ,2DAA2D;AAC9F,SAASC,iBAAiB,QAAQ,4BAA4B;AAE9D,OAAO,MAAMC,qBAAqBT,QAAQU,GAAG,GAAG;AAChD,OAAO,MAAMC,oBAAoBT,OAAOU,MAAM,CAC1C,aACAH,oBACA;IACII,aAAa,CAAC,uEAAuE,EAAEJ,mBAAmB,EAAE,CAAC;IAC7GK,WAAWV,EAAEW,QAAQ;AACzB,GACF;AAEF,OAAO,MAAMC,yBAAyBX;IAyBzBY,SAAS;QACd,MAAMC,sBAAsBX,mBAAmB;YAC3CY,aAAa,IAAI,CAACA,WAAW;YAC7BC,WAAW,IAAI,CAACA,SAAS;QAC7B;QAEA,MAAMC,qBAAqBb,kBAAkB;YACzCW,aAAa,IAAI,CAACA,WAAW;YAC7BG,UAAU,IAAI,CAACA,QAAQ;QAC3B;QAEA,qBACI,oBAAChB;YACGiB,YAAYL;YACZM,WAAWH;YACXI,QAAQ,IAAI,CAACA,MAAM;;IAG/B;;;aApCAL,YAAYlB,OAAOU,MAAM,CAAC,cAAc,gBAAgB;YACpDC,aAAa;YACbC,WAAWV,EAAEW,QAAQ;QACzB;aAEAO,WAAWpB,OAAOU,MAAM,CAAC,eAAe,oBAAoB;YACxDC,aAAa;YACbC,WAAWV,EAAEW,QAAQ;QACzB;aAEAU,SAASvB,OAAOU,MAAM,CAAC,YAAY;YAC/BC,aACI;YACJC,WAAWV,EAAEW,QAAQ;QACzB;aAEAI,cAAcR;;AAqBlB;AA5CaK,iBACOU,QAAQ;IAAC;QAAC;KAAY;CAAC;AAD9BV,iBAGOW,QAAQ1B,QAAQ2B,KAAK,CAAC;IAClCf,aAAa;AACjB"}

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

@@ -4,6 +4,7 @@ import { ValidatedExitPoint } from '../model/ValidatedExitPoint.js';
 interface Props {
     entryPoint: ValidatedEntryPoint;
     exitPoint: ValidatedExitPoint;
+    toybox?: string;
 }
-export declare const Transpile: ({ entryPoint, exitPoint }: Props) => React.JSX.Element;
+export declare const Transpile: ({ entryPoint, exitPoint, toybox }: Props) => React.JSX.Element;
 export {};

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

@@ -1,10 +1,11 @@
 import React from 'react';
 import { useTranspileTasks } from '../../../commands/TranspileCommand/hooks/useTranspileTasks.js';
 import { CheckList } from '../../../components/CheckList/index.js';
-export const Transpile = ({ entryPoint, exitPoint })=>{
+export const Transpile = ({ entryPoint, exitPoint, toybox })=>{
     const items = useTranspileTasks({
         entryPoint,
-        exitPoint
+        exitPoint,
+        toybox
     });
     return /*#__PURE__*/ React.createElement(CheckList, {
         items: items,

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

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../../../libs/cli/src/commands/TranspileCommand/components/Transpile.tsx"],"sourcesContent":["import React from 'react';\nimport { useTranspileTasks } from '@/cli/commands/TranspileCommand/hooks/useTranspileTasks.js';\nimport { ValidatedEntryPoint } from '@/cli/commands/TranspileCommand/model/ValidatedEntryPoint.js';\nimport { CheckList } from '@/cli/components/CheckList/index.js';\nimport { ValidatedExitPoint } from '../model/ValidatedExitPoint.js';\n\ninterface Props {\n    entryPoint: ValidatedEntryPoint;\n    exitPoint: ValidatedExitPoint;\n}\n\nexport const Transpile = ({ entryPoint, exitPoint }: Props) => {\n    const items = useTranspileTasks({\n        entryPoint,\n        exitPoint,\n    });\n\n    return <CheckList items={items} onFinish={() => process.exit} />;\n};\n"],"names":["React","useTranspileTasks","CheckList","Transpile","entryPoint","exitPoint","items","onFinish","process","exit"],"rangeMappings":";;;;;;;;;;;;","mappings":"AAAA,OAAOA,WAAW,QAAQ;AAC1B,SAASC,iBAAiB,QAAQ,6DAA6D;AAE/F,SAASC,SAAS,QAAQ,sCAAsC;AAQhE,OAAO,MAAMC,YAAY,CAAC,EAAEC,UAAU,EAAEC,SAAS,EAAS;IACtD,MAAMC,QAAQL,kBAAkB;QAC5BG;QACAC;IACJ;IAEA,qBAAO,oBAACH;QAAUI,OAAOA;QAAOC,UAAU,IAAMC,QAAQC,IAAI;;AAChE,EAAE"}
+{"version":3,"sources":["../../../../../../../libs/cli/src/commands/TranspileCommand/components/Transpile.tsx"],"sourcesContent":["import React from 'react';\nimport { useTranspileTasks } from '@/cli/commands/TranspileCommand/hooks/useTranspileTasks.js';\nimport { ValidatedEntryPoint } from '@/cli/commands/TranspileCommand/model/ValidatedEntryPoint.js';\nimport { CheckList } from '@/cli/components/CheckList/index.js';\nimport { ValidatedExitPoint } from '../model/ValidatedExitPoint.js';\n\ninterface Props {\n    entryPoint: ValidatedEntryPoint;\n    exitPoint: ValidatedExitPoint;\n    toybox?: string;\n}\n\nexport const Transpile = ({ entryPoint, exitPoint, toybox }: Props) => {\n    const items = useTranspileTasks({\n        entryPoint,\n        exitPoint,\n        toybox,\n    });\n\n    return <CheckList items={items} onFinish={() => process.exit} />;\n};\n"],"names":["React","useTranspileTasks","CheckList","Transpile","entryPoint","exitPoint","toybox","items","onFinish","process","exit"],"rangeMappings":";;;;;;;;;;;;;","mappings":"AAAA,OAAOA,WAAW,QAAQ;AAC1B,SAASC,iBAAiB,QAAQ,6DAA6D;AAE/F,SAASC,SAAS,QAAQ,sCAAsC;AAShE,OAAO,MAAMC,YAAY,CAAC,EAAEC,UAAU,EAAEC,SAAS,EAAEC,MAAM,EAAS;IAC9D,MAAMC,QAAQN,kBAAkB;QAC5BG;QACAC;QACAC;IACJ;IAEA,qBAAO,oBAACJ;QAAUK,OAAOA;QAAOC,UAAU,IAAMC,QAAQC,IAAI;;AAChE,EAAE"}

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

@@ -1,8 +1,9 @@
 import * as tstl from 'typescript-to-lua';
 import { ValidatedEntryPoint } from '../model/ValidatedEntryPoint.js';
 import { ValidatedExitPoint } from '../model/ValidatedExitPoint.js';
-export declare const transpile: ({ entryPoint, exitPoint, buildMode, }: {
+import { TranspileMode } from '../types.js';
+export declare const transpile: ({ entryPoint, exitPoint, transpileMode, }: {
     entryPoint: ValidatedEntryPoint;
     exitPoint: ValidatedExitPoint;
-    buildMode?: tstl.BuildMode;
+    transpileMode?: TranspileMode;
 }) => tstl.EmitResult;

package/src/commands/TranspileCommand/fn/transpile.js

@@ -4,15 +4,31 @@ import { basename, dirname, join } from 'node:path';
 import * as tstl from 'typescript-to-lua';
 import { LuaTarget } from 'typescript-to-lua';
 import { RootFolder } from '../../../constants.js';
-export const transpile = ({ entryPoint, exitPoint, buildMode = tstl.BuildMode.Default })=>{
+import { TranspileMode } from '../types.js';
+export const transpile = ({ entryPoint, exitPoint, transpileMode = TranspileMode.Project })=>{
     const exitDir = dirname(exitPoint.exitPath);
     if (!existsSync(exitDir)) {
         mkdirSync(exitDir, {
             recursive: true
         });
     }
+    if (transpileMode === TranspileMode.File) {
+        return tstl.transpileFiles([
+            entryPoint.entryFile
+        ], {
+            luaTarget: LuaTarget.Lua54,
+            outDir: dirname(exitPoint.exitPath),
+            luaBundle: basename(exitPoint.exitPath),
+            luaBundleEntry: join(entryPoint.entryFile),
+            skipLibCheck: true,
+            luaPlugins: [
+                {
+                    name: join(RootFolder, 'assets', 'index.js')
+                }
+            ]
+        });
+    }
     return tstl.transpileProject(join(entryPoint.projectPath, 'tsconfig.json'), {
-        buildMode,
         luaTarget: LuaTarget.Lua54,
         outDir: dirname(exitPoint.exitPath),
         luaBundle: basename(exitPoint.exitPath),

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

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../../../libs/cli/src/commands/TranspileCommand/fn/transpile.ts"],"sourcesContent":["import { existsSync } from 'node:fs';\nimport { mkdirSync } from 'node:fs';\nimport { basename, dirname, join } from 'node:path';\nimport * as tstl from 'typescript-to-lua';\nimport { LuaTarget } from 'typescript-to-lua';\nimport { RootFolder } from '@/cli/constants.js';\nimport { ValidatedEntryPoint } from '../model/ValidatedEntryPoint.js';\nimport { ValidatedExitPoint } from '../model/ValidatedExitPoint.js';\n\nexport const transpile = ({\n    entryPoint,\n    exitPoint,\n    buildMode = tstl.BuildMode.Default,\n}: {\n    entryPoint: ValidatedEntryPoint;\n    exitPoint: ValidatedExitPoint;\n    buildMode?: tstl.BuildMode;\n}) => {\n    const exitDir = dirname(exitPoint.exitPath);\n\n    if (!existsSync(exitDir)) {\n        mkdirSync(exitDir, { recursive: true });\n    }\n\n    return tstl.transpileProject(\n        join(entryPoint.projectPath, 'tsconfig.json'),\n        {\n            buildMode,\n            luaTarget: LuaTarget.Lua54,\n            outDir: dirname(exitPoint.exitPath),\n            luaBundle: basename(exitPoint.exitPath),\n            luaBundleEntry: join(entryPoint.entryFile),\n            luaPlugins: [\n                {\n                    name: join(RootFolder, 'assets', 'index.js'),\n                },\n            ],\n        },\n    );\n};\n"],"names":["existsSync","mkdirSync","basename","dirname","join","tstl","LuaTarget","RootFolder","transpile","entryPoint","exitPoint","buildMode","BuildMode","Default","exitDir","exitPath","recursive","transpileProject","projectPath","luaTarget","Lua54","outDir","luaBundle","luaBundleEntry","entryFile","luaPlugins","name"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAAA,SAASA,UAAU,QAAQ,UAAU;AACrC,SAASC,SAAS,QAAQ,UAAU;AACpC,SAASC,QAAQ,EAAEC,OAAO,EAAEC,IAAI,QAAQ,YAAY;AACpD,YAAYC,UAAU,oBAAoB;AAC1C,SAASC,SAAS,QAAQ,oBAAoB;AAC9C,SAASC,UAAU,QAAQ,qBAAqB;AAIhD,OAAO,MAAMC,YAAY,CAAC,EACtBC,UAAU,EACVC,SAAS,EACTC,YAAYN,KAAKO,SAAS,CAACC,OAAO,EAKrC;IACG,MAAMC,UAAUX,QAAQO,UAAUK,QAAQ;IAE1C,IAAI,CAACf,WAAWc,UAAU;QACtBb,UAAUa,SAAS;YAAEE,WAAW;QAAK;IACzC;IAEA,OAAOX,KAAKY,gBAAgB,CACxBb,KAAKK,WAAWS,WAAW,EAAE,kBAC7B;QACIP;QACAQ,WAAWb,UAAUc,KAAK;QAC1BC,QAAQlB,QAAQO,UAAUK,QAAQ;QAClCO,WAAWpB,SAASQ,UAAUK,QAAQ;QACtCQ,gBAAgBnB,KAAKK,WAAWe,SAAS;QACzCC,YAAY;YACR;gBACIC,MAAMtB,KAAKG,YAAY,UAAU;YACrC;SACH;IACL;AAER,EAAE"}
+{"version":3,"sources":["../../../../../../../libs/cli/src/commands/TranspileCommand/fn/transpile.ts"],"sourcesContent":["import { existsSync } from 'node:fs';\nimport { mkdirSync } from 'node:fs';\nimport { basename, dirname, join } from 'node:path';\nimport * as tstl from 'typescript-to-lua';\nimport { LuaTarget } from 'typescript-to-lua';\nimport { RootFolder } from '@/cli/constants.js';\nimport { ValidatedEntryPoint } from '../model/ValidatedEntryPoint.js';\nimport { ValidatedExitPoint } from '../model/ValidatedExitPoint.js';\nimport { TranspileMode } from '../types.js';\n\nexport const transpile = ({\n    entryPoint,\n    exitPoint,\n    transpileMode = TranspileMode.Project,\n}: {\n    entryPoint: ValidatedEntryPoint;\n    exitPoint: ValidatedExitPoint;\n    transpileMode?: TranspileMode;\n}) => {\n    const exitDir = dirname(exitPoint.exitPath);\n\n    if (!existsSync(exitDir)) {\n        mkdirSync(exitDir, { recursive: true });\n    }\n\n    if (transpileMode === TranspileMode.File) {\n        return tstl.transpileFiles([entryPoint.entryFile], {\n            luaTarget: LuaTarget.Lua54,\n            outDir: dirname(exitPoint.exitPath),\n            luaBundle: basename(exitPoint.exitPath),\n            luaBundleEntry: join(entryPoint.entryFile),\n            skipLibCheck: true,\n            luaPlugins: [\n                {\n                    name: join(RootFolder, 'assets', 'index.js'),\n                },\n            ],\n        });\n    }\n\n    return tstl.transpileProject(\n        join(entryPoint.projectPath, 'tsconfig.json'),\n        {\n            luaTarget: LuaTarget.Lua54,\n            outDir: dirname(exitPoint.exitPath),\n            luaBundle: basename(exitPoint.exitPath),\n            luaBundleEntry: join(entryPoint.entryFile),\n            luaPlugins: [\n                {\n                    name: join(RootFolder, 'assets', 'index.js'),\n                },\n            ],\n        },\n    );\n};\n"],"names":["existsSync","mkdirSync","basename","dirname","join","tstl","LuaTarget","RootFolder","TranspileMode","transpile","entryPoint","exitPoint","transpileMode","Project","exitDir","exitPath","recursive","File","transpileFiles","entryFile","luaTarget","Lua54","outDir","luaBundle","luaBundleEntry","skipLibCheck","luaPlugins","name","transpileProject","projectPath"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAAA,SAASA,UAAU,QAAQ,UAAU;AACrC,SAASC,SAAS,QAAQ,UAAU;AACpC,SAASC,QAAQ,EAAEC,OAAO,EAAEC,IAAI,QAAQ,YAAY;AACpD,YAAYC,UAAU,oBAAoB;AAC1C,SAASC,SAAS,QAAQ,oBAAoB;AAC9C,SAASC,UAAU,QAAQ,qBAAqB;AAGhD,SAASC,aAAa,QAAQ,cAAc;AAE5C,OAAO,MAAMC,YAAY,CAAC,EACtBC,UAAU,EACVC,SAAS,EACTC,gBAAgBJ,cAAcK,OAAO,EAKxC;IACG,MAAMC,UAAUX,QAAQQ,UAAUI,QAAQ;IAE1C,IAAI,CAACf,WAAWc,UAAU;QACtBb,UAAUa,SAAS;YAAEE,WAAW;QAAK;IACzC;IAEA,IAAIJ,kBAAkBJ,cAAcS,IAAI,EAAE;QACtC,OAAOZ,KAAKa,cAAc,CAAC;YAACR,WAAWS,SAAS;SAAC,EAAE;YAC/CC,WAAWd,UAAUe,KAAK;YAC1BC,QAAQnB,QAAQQ,UAAUI,QAAQ;YAClCQ,WAAWrB,SAASS,UAAUI,QAAQ;YACtCS,gBAAgBpB,KAAKM,WAAWS,SAAS;YACzCM,cAAc;YACdC,YAAY;gBACR;oBACIC,MAAMvB,KAAKG,YAAY,UAAU;gBACrC;aACH;QACL;IACJ;IAEA,OAAOF,KAAKuB,gBAAgB,CACxBxB,KAAKM,WAAWmB,WAAW,EAAE,kBAC7B;QACIT,WAAWd,UAAUe,KAAK;QAC1BC,QAAQnB,QAAQQ,UAAUI,QAAQ;QAClCQ,WAAWrB,SAASS,UAAUI,QAAQ;QACtCS,gBAAgBpB,KAAKM,WAAWS,SAAS;QACzCO,YAAY;YACR;gBACIC,MAAMvB,KAAKG,YAAY,UAAU;YACrC;SACH;IACL;AAER,EAAE"}

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

@@ -1,5 +1,6 @@
 import { ValidatedEntryPoint } from '../model/ValidatedEntryPoint.js';
-export declare const validateEntryPoint: (input: {
+export declare const validateEntryPoint: ({ projectPath, entryFile, requireWithinProjectPath, }: {
     projectPath: string;
     entryFile: string;
+    requireWithinProjectPath?: boolean;
 }) => ValidatedEntryPoint;

package/src/commands/TranspileCommand/fn/validateEntryPoint.js

@@ -1,16 +1,26 @@
 import { existsSync, statSync } from 'node:fs';
 import { resolve } from 'node:path';
-export const validateEntryPoint = (input)=>{
-    const resolvedPath = resolve(input.projectPath);
-    const resolvedEntry = resolve(input.entryFile);
-    if (!existsSync(resolvedPath) || !statSync(resolvedPath).isDirectory()) {
-        throw new Error(`"${resolvedPath}" is not a valid project path`);
+export const validateEntryPoint = ({ projectPath, entryFile, requireWithinProjectPath = true })=>{
+    const resolvedPath = resolve(projectPath);
+    const resolvedEntry = resolve(entryFile);
+    const projectPathExists = existsSync(resolvedPath);
+    const projectPathIsDirectory = projectPathExists && statSync(resolvedPath).isDirectory();
+    const entryFileExists = existsSync(resolvedEntry);
+    const entryFileIsFile = entryFileExists && statSync(resolvedEntry).isFile();
+    if (!projectPathExists) {
+        throw new Error(`Path "${resolvedPath}" does not exist`);
     }
-    if (!existsSync(resolvedEntry) || !statSync(resolvedEntry).isFile()) {
-        throw new Error(`"${resolvedEntry}" is not a valid entry file`);
+    if (!projectPathIsDirectory) {
+        throw new Error(`Path "${resolvedPath}" is not a directory`);
     }
-    if (!resolvedEntry.startsWith(resolvedPath)) {
-        throw new Error(`Entry must be inside project path`);
+    if (!entryFileExists) {
+        throw new Error(`Path "${resolvedEntry}" does not exist`);
+    }
+    if (!entryFileIsFile) {
+        throw new Error(`Path "${resolvedEntry}" is not a file`);
+    }
+    if (requireWithinProjectPath && !resolvedEntry.startsWith(resolvedPath)) {
+        throw new Error(`Entry "${resolvedEntry}" must be inside project path "${resolvedPath}"`);
     }
     return {
         __validated: true,

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

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../../../libs/cli/src/commands/TranspileCommand/fn/validateEntryPoint.ts"],"sourcesContent":["import { existsSync, statSync } from 'node:fs';\nimport { resolve } from 'node:path';\nimport { ValidatedEntryPoint } from '../model/ValidatedEntryPoint.js';\n\nexport const validateEntryPoint = (input: {\n    projectPath: string;\n    entryFile: string;\n}): ValidatedEntryPoint => {\n    const resolvedPath = resolve(input.projectPath);\n    const resolvedEntry = resolve(input.entryFile);\n\n    if (!existsSync(resolvedPath) || !statSync(resolvedPath).isDirectory()) {\n        throw new Error(`\"${resolvedPath}\" is not a valid project path`);\n    }\n\n    if (!existsSync(resolvedEntry) || !statSync(resolvedEntry).isFile()) {\n        throw new Error(`\"${resolvedEntry}\" is not a valid entry file`);\n    }\n\n    if (!resolvedEntry.startsWith(resolvedPath)) {\n        throw new Error(`Entry must be inside project path`);\n    }\n\n    return {\n        __validated: true,\n        projectPath: resolvedPath,\n        entryFile: resolvedEntry,\n    } satisfies ValidatedEntryPoint;\n};\n"],"names":["existsSync","statSync","resolve","validateEntryPoint","input","resolvedPath","projectPath","resolvedEntry","entryFile","isDirectory","Error","isFile","startsWith","__validated"],"rangeMappings":";;;;;;;;;;;;;;;;;;;","mappings":"AAAA,SAASA,UAAU,EAAEC,QAAQ,QAAQ,UAAU;AAC/C,SAASC,OAAO,QAAQ,YAAY;AAGpC,OAAO,MAAMC,qBAAqB,CAACC;IAI/B,MAAMC,eAAeH,QAAQE,MAAME,WAAW;IAC9C,MAAMC,gBAAgBL,QAAQE,MAAMI,SAAS;IAE7C,IAAI,CAACR,WAAWK,iBAAiB,CAACJ,SAASI,cAAcI,WAAW,IAAI;QACpE,MAAM,IAAIC,MAAM,CAAC,CAAC,EAAEL,aAAa,6BAA6B,CAAC;IACnE;IAEA,IAAI,CAACL,WAAWO,kBAAkB,CAACN,SAASM,eAAeI,MAAM,IAAI;QACjE,MAAM,IAAID,MAAM,CAAC,CAAC,EAAEH,cAAc,2BAA2B,CAAC;IAClE;IAEA,IAAI,CAACA,cAAcK,UAAU,CAACP,eAAe;QACzC,MAAM,IAAIK,MAAM,CAAC,iCAAiC,CAAC;IACvD;IAEA,OAAO;QACHG,aAAa;QACbP,aAAaD;QACbG,WAAWD;IACf;AACJ,EAAE"}
+{"version":3,"sources":["../../../../../../../libs/cli/src/commands/TranspileCommand/fn/validateEntryPoint.ts"],"sourcesContent":["import { existsSync, statSync } from 'node:fs';\nimport { resolve } from 'node:path';\nimport { ValidatedEntryPoint } from '../model/ValidatedEntryPoint.js';\n\nexport const validateEntryPoint = ({\n    projectPath,\n    entryFile,\n    requireWithinProjectPath = true,\n}: {\n    projectPath: string;\n    entryFile: string;\n    requireWithinProjectPath?: boolean;\n}): ValidatedEntryPoint => {\n    const resolvedPath = resolve(projectPath);\n    const resolvedEntry = resolve(entryFile);\n    const projectPathExists = existsSync(resolvedPath);\n    const projectPathIsDirectory =\n        projectPathExists && statSync(resolvedPath).isDirectory();\n    const entryFileExists = existsSync(resolvedEntry);\n    const entryFileIsFile = entryFileExists && statSync(resolvedEntry).isFile();\n\n    if (!projectPathExists) {\n        throw new Error(`Path \"${resolvedPath}\" does not exist`);\n    }\n\n    if (!projectPathIsDirectory) {\n        throw new Error(`Path \"${resolvedPath}\" is not a directory`);\n    }\n\n    if (!entryFileExists) {\n        throw new Error(`Path \"${resolvedEntry}\" does not exist`);\n    }\n\n    if (!entryFileIsFile) {\n        throw new Error(`Path \"${resolvedEntry}\" is not a file`);\n    }\n\n    if (requireWithinProjectPath && !resolvedEntry.startsWith(resolvedPath)) {\n        throw new Error(\n            `Entry \"${resolvedEntry}\" must be inside project path \"${resolvedPath}\"`,\n        );\n    }\n\n    return {\n        __validated: true,\n        projectPath: resolvedPath,\n        entryFile: resolvedEntry,\n    } satisfies ValidatedEntryPoint;\n};\n"],"names":["existsSync","statSync","resolve","validateEntryPoint","projectPath","entryFile","requireWithinProjectPath","resolvedPath","resolvedEntry","projectPathExists","projectPathIsDirectory","isDirectory","entryFileExists","entryFileIsFile","isFile","Error","startsWith","__validated"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAAA,SAASA,UAAU,EAAEC,QAAQ,QAAQ,UAAU;AAC/C,SAASC,OAAO,QAAQ,YAAY;AAGpC,OAAO,MAAMC,qBAAqB,CAAC,EAC/BC,WAAW,EACXC,SAAS,EACTC,2BAA2B,IAAI,EAKlC;IACG,MAAMC,eAAeL,QAAQE;IAC7B,MAAMI,gBAAgBN,QAAQG;IAC9B,MAAMI,oBAAoBT,WAAWO;IACrC,MAAMG,yBACFD,qBAAqBR,SAASM,cAAcI,WAAW;IAC3D,MAAMC,kBAAkBZ,WAAWQ;IACnC,MAAMK,kBAAkBD,mBAAmBX,SAASO,eAAeM,MAAM;IAEzE,IAAI,CAACL,mBAAmB;QACpB,MAAM,IAAIM,MAAM,CAAC,MAAM,EAAER,aAAa,gBAAgB,CAAC;IAC3D;IAEA,IAAI,CAACG,wBAAwB;QACzB,MAAM,IAAIK,MAAM,CAAC,MAAM,EAAER,aAAa,oBAAoB,CAAC;IAC/D;IAEA,IAAI,CAACK,iBAAiB;QAClB,MAAM,IAAIG,MAAM,CAAC,MAAM,EAAEP,cAAc,gBAAgB,CAAC;IAC5D;IAEA,IAAI,CAACK,iBAAiB;QAClB,MAAM,IAAIE,MAAM,CAAC,MAAM,EAAEP,cAAc,eAAe,CAAC;IAC3D;IAEA,IAAIF,4BAA4B,CAACE,cAAcQ,UAAU,CAACT,eAAe;QACrE,MAAM,IAAIQ,MACN,CAAC,OAAO,EAAEP,cAAc,+BAA+B,EAAED,aAAa,CAAC,CAAC;IAEhF;IAEA,OAAO;QACHU,aAAa;QACbb,aAAaG;QACbF,WAAWG;IACf;AACJ,EAAE"}

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

@@ -1,5 +1,6 @@
 import { ValidatedExitPoint } from '../model/ValidatedExitPoint.js';
-export declare const validateExitPoint: (input: {
+export declare const validateExitPoint: ({ projectPath, exitFile, requireWithinProjectPath, }: {
     projectPath: string;
     exitFile: string;
+    requireWithinProjectPath?: boolean;
 }) => ValidatedExitPoint;

package/src/commands/TranspileCommand/fn/validateExitPoint.js

@@ -1,19 +1,25 @@
 import { existsSync, statSync } from 'node:fs';
 import { resolve, dirname } from 'node:path';
-export const validateExitPoint = (input)=>{
-    const resolvedPath = resolve(input.projectPath);
-    const resolvedExit = resolve(input.exitFile);
+export const validateExitPoint = ({ projectPath, exitFile, requireWithinProjectPath = true })=>{
+    const resolvedPath = resolve(projectPath);
+    const resolvedExit = resolve(exitFile);
     const exitDir = dirname(resolvedExit);
-    if (!existsSync(resolvedPath) || !statSync(resolvedPath).isDirectory()) {
-        throw new Error(`"${resolvedPath}" is not a valid project path`);
+    const projectPathExists = existsSync(resolvedPath);
+    const projectPathIsDirectory = projectPathExists && statSync(resolvedPath).isDirectory();
+    const exitDirExists = existsSync(exitDir);
+    const exitDirIsDirectory = exitDirExists && statSync(exitDir).isDirectory();
+    if (!projectPathExists) {
+        throw new Error(`Path "${resolvedPath}" does not exist`);
     }
-    if (!existsSync(exitDir)) {
+    if (!projectPathIsDirectory) {
+        throw new Error(`Path "${resolvedPath}" is not a directory`);
+    }
+    if (!exitDirExists) {
     // Will be created
-    } else if (!statSync(exitDir).isDirectory()) {
-        throw new Error(`"${exitDir}" exists but is not a directory`);
+    } else if (!exitDirIsDirectory) {
+        throw new Error(`Path "${exitDir}" exists but is not a directory`);
     }
-    // Check if the parent directory is inside the project path
-    if (!exitDir.startsWith(resolvedPath)) {
+    if (requireWithinProjectPath && !exitDir.startsWith(resolvedPath)) {
         throw new Error(`Exit path must be inside project path`);
     }
     return {

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

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../../../libs/cli/src/commands/TranspileCommand/fn/validateExitPoint.ts"],"sourcesContent":["import { existsSync, statSync } from 'node:fs';\nimport { resolve, dirname } from 'node:path';\nimport { ValidatedExitPoint } from '../model/ValidatedExitPoint.js';\n\nexport const validateExitPoint = (input: {\n    projectPath: string;\n    exitFile: string;\n}): ValidatedExitPoint => {\n    const resolvedPath = resolve(input.projectPath);\n    const resolvedExit = resolve(input.exitFile);\n    const exitDir = dirname(resolvedExit);\n\n    if (!existsSync(resolvedPath) || !statSync(resolvedPath).isDirectory()) {\n        throw new Error(`\"${resolvedPath}\" is not a valid project path`);\n    }\n\n    if (!existsSync(exitDir)) {\n        // Will be created\n    } else if (!statSync(exitDir).isDirectory()) {\n        throw new Error(`\"${exitDir}\" exists but is not a directory`);\n    }\n\n    // Check if the parent directory is inside the project path\n    if (!exitDir.startsWith(resolvedPath)) {\n        throw new Error(`Exit path must be inside project path`);\n    }\n\n    return {\n        __validated: true,\n        projectPath: resolvedPath,\n        exitPath: resolvedExit,\n    } satisfies ValidatedExitPoint;\n};\n"],"names":["existsSync","statSync","resolve","dirname","validateExitPoint","input","resolvedPath","projectPath","resolvedExit","exitFile","exitDir","isDirectory","Error","startsWith","__validated","exitPath"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAAA,SAASA,UAAU,EAAEC,QAAQ,QAAQ,UAAU;AAC/C,SAASC,OAAO,EAAEC,OAAO,QAAQ,YAAY;AAG7C,OAAO,MAAMC,oBAAoB,CAACC;IAI9B,MAAMC,eAAeJ,QAAQG,MAAME,WAAW;IAC9C,MAAMC,eAAeN,QAAQG,MAAMI,QAAQ;IAC3C,MAAMC,UAAUP,QAAQK;IAExB,IAAI,CAACR,WAAWM,iBAAiB,CAACL,SAASK,cAAcK,WAAW,IAAI;QACpE,MAAM,IAAIC,MAAM,CAAC,CAAC,EAAEN,aAAa,6BAA6B,CAAC;IACnE;IAEA,IAAI,CAACN,WAAWU,UAAU;IACtB,kBAAkB;IACtB,OAAO,IAAI,CAACT,SAASS,SAASC,WAAW,IAAI;QACzC,MAAM,IAAIC,MAAM,CAAC,CAAC,EAAEF,QAAQ,+BAA+B,CAAC;IAChE;IAEA,2DAA2D;IAC3D,IAAI,CAACA,QAAQG,UAAU,CAACP,eAAe;QACnC,MAAM,IAAIM,MAAM,CAAC,qCAAqC,CAAC;IAC3D;IAEA,OAAO;QACHE,aAAa;QACbP,aAAaD;QACbS,UAAUP;IACd;AACJ,EAAE"}
+{"version":3,"sources":["../../../../../../../libs/cli/src/commands/TranspileCommand/fn/validateExitPoint.ts"],"sourcesContent":["import { existsSync, statSync } from 'node:fs';\nimport { resolve, dirname } from 'node:path';\nimport { ValidatedExitPoint } from '../model/ValidatedExitPoint.js';\n\nexport const validateExitPoint = ({\n    projectPath,\n    exitFile,\n    requireWithinProjectPath = true,\n}: {\n    projectPath: string;\n    exitFile: string;\n    requireWithinProjectPath?: boolean;\n}): ValidatedExitPoint => {\n    const resolvedPath = resolve(projectPath);\n    const resolvedExit = resolve(exitFile);\n    const exitDir = dirname(resolvedExit);\n    const projectPathExists = existsSync(resolvedPath);\n    const projectPathIsDirectory =\n        projectPathExists && statSync(resolvedPath).isDirectory();\n    const exitDirExists = existsSync(exitDir);\n    const exitDirIsDirectory = exitDirExists && statSync(exitDir).isDirectory();\n\n    if (!projectPathExists) {\n        throw new Error(`Path \"${resolvedPath}\" does not exist`);\n    }\n\n    if (!projectPathIsDirectory) {\n        throw new Error(`Path \"${resolvedPath}\" is not a directory`);\n    }\n\n    if (!exitDirExists) {\n        // Will be created\n    } else if (!exitDirIsDirectory) {\n        throw new Error(`Path \"${exitDir}\" exists but is not a directory`);\n    }\n\n    if (requireWithinProjectPath && !exitDir.startsWith(resolvedPath)) {\n        throw new Error(`Exit path must be inside project path`);\n    }\n\n    return {\n        __validated: true,\n        projectPath: resolvedPath,\n        exitPath: resolvedExit,\n    } satisfies ValidatedExitPoint;\n};\n"],"names":["existsSync","statSync","resolve","dirname","validateExitPoint","projectPath","exitFile","requireWithinProjectPath","resolvedPath","resolvedExit","exitDir","projectPathExists","projectPathIsDirectory","isDirectory","exitDirExists","exitDirIsDirectory","Error","startsWith","__validated","exitPath"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAAA,SAASA,UAAU,EAAEC,QAAQ,QAAQ,UAAU;AAC/C,SAASC,OAAO,EAAEC,OAAO,QAAQ,YAAY;AAG7C,OAAO,MAAMC,oBAAoB,CAAC,EAC9BC,WAAW,EACXC,QAAQ,EACRC,2BAA2B,IAAI,EAKlC;IACG,MAAMC,eAAeN,QAAQG;IAC7B,MAAMI,eAAeP,QAAQI;IAC7B,MAAMI,UAAUP,QAAQM;IACxB,MAAME,oBAAoBX,WAAWQ;IACrC,MAAMI,yBACFD,qBAAqBV,SAASO,cAAcK,WAAW;IAC3D,MAAMC,gBAAgBd,WAAWU;IACjC,MAAMK,qBAAqBD,iBAAiBb,SAASS,SAASG,WAAW;IAEzE,IAAI,CAACF,mBAAmB;QACpB,MAAM,IAAIK,MAAM,CAAC,MAAM,EAAER,aAAa,gBAAgB,CAAC;IAC3D;IAEA,IAAI,CAACI,wBAAwB;QACzB,MAAM,IAAII,MAAM,CAAC,MAAM,EAAER,aAAa,oBAAoB,CAAC;IAC/D;IAEA,IAAI,CAACM,eAAe;IAChB,kBAAkB;IACtB,OAAO,IAAI,CAACC,oBAAoB;QAC5B,MAAM,IAAIC,MAAM,CAAC,MAAM,EAAEN,QAAQ,+BAA+B,CAAC;IACrE;IAEA,IAAIH,4BAA4B,CAACG,QAAQO,UAAU,CAACT,eAAe;QAC/D,MAAM,IAAIQ,MAAM,CAAC,qCAAqC,CAAC;IAC3D;IAEA,OAAO;QACHE,aAAa;QACbb,aAAaG;QACbW,UAAUV;IACd;AACJ,EAAE"}

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

@@ -1,7 +1,10 @@
 import { ValidatedEntryPoint } from '../../../commands/TranspileCommand/model/ValidatedEntryPoint.js';
 import { ValidatedExitPoint } from '../../../commands/TranspileCommand/model/ValidatedExitPoint.js';
 import { CheckListItem } from '../../../types.js';
-export declare const useTranspileTasks: ({ entryPoint, exitPoint, }: {
+import { TranspileMode } from '../types.js';
+export declare const useTranspileTasks: ({ entryPoint, exitPoint, toybox, transpileMode, }: {
     entryPoint: ValidatedEntryPoint;
     exitPoint: ValidatedExitPoint;
+    toybox?: string;
+    transpileMode?: TranspileMode;
 }) => CheckListItem<unknown>[];