uni-run 1.0.13 → 1.1.0

package/README.md

@@ -1,12 +1,14 @@
+Here is the corrected grammar for your document:
+
 # uni-run
 
-`uni-run` is a versatile CLI tool designed to run various types of scripts, including but not limited to JavaScript, TypeScript, Python, Java, HTML, SASS, Lua and more. It provides a unified interface to execute scripts with additional features like watching for file changes, benchmarking execution time, and more.
+`uni-run` is a versatile CLI tool designed to run various types of scripts, including but not limited to JavaScript, TypeScript, Python, Java, HTML, SASS, Lua, and more. It provides a unified interface to execute scripts with additional features like watching for file changes, benchmarking execution time, and more.
 
 ## Features
 
 - **Watch Mode**: Automatically re-run scripts when files change.
 - **Benchmarking**: Measure and display the execution time of scripts.
-- **Environment Variables**: Set environment variables for the script execution.
+- **Environment Variables**: Set environment variables for script execution.
 - **Shell Execution**: Run scripts in a shell for more control.
 - **Console Clearing**: Clear the console before running the script.
 - **Reload Key**: Enable reloading the script with a specific key combination.
@@ -63,28 +65,57 @@ run ./scripts/Main.java
 run ./scripts/main.js -- --some someValue
 ```
 
-Here `--some someValue` will be passed to `node` and will be ignored by uni-run.
+Here `--some someValue` will be passed to `node` and will be ignored by `uni-run`.
+
+## Define Custom Configuration
+
+Create `.uni-run.json` file in your user home directory.
+
+```json
+{
+  "javascript-runtime": "bun",
+  "typescript-runtime": "deno"
+}
+```
+
+Now you can run your script with `run script.js` or `run script.ts` with your own runtime.
+
+## Setup Custom Executors
+
+Create `.uni-run.cjs` file in your user home directory.
+
+```js
+module.exports = [
+  {
+    name: 'Something',
+    exts: ['ext'],
+    getRuntime(args, options, config) {
+      return {
+        run: ['YOUR_BIN', ...args],
+      }
+    },
+  },
+]
+```
+
+Now you can run your script with `run script.ext`.
 
 ## API
 
 The `uni-run` package provides a simple API to manage and execute scripts.
 
-#### `addBin(bin: Executor)`:
-
-The `Executor` class is imported from `uni-run` and is used to manage script execution.
-Adds a new `Executor` instance to the list of built-in binaries.
+#### `addExecutor(options: ExecutorOptions)`:
 
 ```typescript
-import uniRun, { Executor } from 'uni-run'
+import uniRun from 'uni-run'
 
-const executor = new Executor('Name', {
-  extensions: ['something'],
-  run(args, options) {
+uniRun.addExecutor({
+  name: 'Name',
+  exts: ['something'],
+  getRuntime(args, options, config) {
     return ['something-binary', ...args]
   },
 })
-
-uniRun.addBin(executor)
 ```
 
 #### `start(args?: string[])`:
@@ -100,23 +131,20 @@ uniRun.start(['arg1', 'arg2'])
 ### Example Usage
 
 ```typescript
-import uniRun, { Executor } from 'uni-run'
+import uniRun from 'uni-run'
 
-// Create a new Executor instance
-const executor = new Executor('Name', {
-  extensions: ['some'],
-  run(args, options) {
+// Add the Executor to uni-run
+uniRun.addExecutor({
+  name: 'Name',
+  exts: ['something'],
+  getRuntime(args, options, config) {
     return ['something-binary', ...args]
   },
 })
 
-// Add the Executor to uni-run
-uniRun.addBin(executor)
-
 // Start the application with arguments
 uniRun.start(['arg1.some'])
-```
 
-## License
-
-This project is licensed under the MIT License.
+// Or inherit from CLI
+uniRun.start()
+```

package/dist/app.js

@@ -0,0 +1,79 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const arg = __importStar(require("./arg"));
+const execution_1 = __importDefault(require("./execution"));
+const getConfig_1 = __importDefault(require("./helpers/getConfig"));
+const argHelper_1 = require("./argHelper");
+const scriptExecutors_1 = __importDefault(require("./scriptExecutors"));
+const checkRuntime_1 = __importDefault(require("./scriptExecutors/checkRuntime"));
+const getUserExecutors_1 = __importDefault(require("./helpers/getUserExecutors"));
+arg.app.on((_a, flags_1) => __awaiter(void 0, [_a, flags_1], void 0, function* ([script, listArs, trailingArgs], flags) {
+    var _b;
+    const userExecutors = (0, getUserExecutors_1.default)(flags.cwd);
+    const executionConfig = (0, getConfig_1.default)(flags.cwd);
+    const totalExecutors = [
+        ...(Array.isArray(userExecutors) ? userExecutors : []),
+        ...scriptExecutors_1.default,
+    ];
+    const scriptExecutor = totalExecutors.find((executor) => executor.exts.includes(script.split('.').pop()));
+    if (!scriptExecutor) {
+        console.log('Unsupported script:', script);
+        return console.log('You may try "run exec YOUR_BIN script.ext -- --flags"');
+    }
+    const executionOptions = (0, argHelper_1.mapFlagsToOptions)(flags);
+    const runtime = scriptExecutor.getRuntime([script, ...listArs, ...trailingArgs], executionOptions, executionConfig);
+    (0, checkRuntime_1.default)(runtime);
+    execution_1.default.start(runtime.run, Object.assign(Object.assign({}, executionOptions), { watchExtensions: executionOptions.watchExtensions.length
+            ? executionOptions.watchExtensions
+            : [...scriptExecutor.exts, ...((_b = runtime.watchExts) !== null && _b !== void 0 ? _b : [])] }));
+}));
+arg.exec.on(([listArs, trailingArgs], flags) => {
+    execution_1.default.start([...listArs, ...trailingArgs], (0, argHelper_1.mapFlagsToOptions)(flags));
+});
+arg.list.on(() => {
+    console.log('Supported scripts:');
+    scriptExecutors_1.default
+        .sort((a, b) => {
+        if (a.name < b.name)
+            return -1;
+        if (a.name > b.name)
+            return 1;
+        return 0;
+    })
+        .forEach(({ name }) => console.log(`- ${name}`));
+});

package/dist/{arg.d.cts → arg.d.ts}

@@ -1,4 +1,4 @@
-import NoArg from "noarg";
+import NoArg from 'noarg';
 export declare const app: NoArg<"uni-run", {
     readonly allowEqualAssign: true;
     readonly booleanNotSyntaxEnding: "\\";

package/dist/{arg.cjs → arg.js}

@@ -5,11 +5,11 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.list = exports.exec = exports.app = void 0;
 const noarg_1 = __importDefault(require("noarg"));
-const arg_helper_1 = require("./arg-helper.cjs");
-exports.app = noarg_1.default.create('uni-run', Object.assign(Object.assign({}, arg_helper_1.executionConfig), { description: 'A universal runner for scripts', system: { splitListByComma: true }, arguments: [
+const argHelper_1 = require("./argHelper");
+exports.app = noarg_1.default.create('uni-run', Object.assign(Object.assign({}, argHelper_1.executionConfig), { description: 'A universal runner for scripts', system: { splitListByComma: true }, arguments: [
         { name: 'script', type: noarg_1.default.string(), description: 'Run a script' },
     ] }));
-exports.exec = exports.app.create('exec', Object.assign(Object.assign({}, arg_helper_1.executionConfig), { description: 'Execute a script with the given binary' }));
+exports.exec = exports.app.create('exec', Object.assign(Object.assign({}, argHelper_1.executionConfig), { description: 'Execute a script with the given binary' }));
 exports.list = exports.app.create('list', {
     description: 'List supported scripts',
 });

package/dist/{arg-helper.d.cts → argHelper.d.ts}

@@ -1,6 +1,5 @@
-import NoArg from "noarg";
-import type { app } from "./arg.cjs";
-import Executor from "./builtin-bin/Executor.cjs";
+import NoArg from 'noarg';
+import type { app } from './arg';
 export declare const executionConfig: {
     readonly flags: {
         readonly 'key-reload': import("noarg/dist/schema/TypeBoolean.cjs").TypeBoolean<{
@@ -120,7 +119,7 @@ export declare const executionConfig: {
     };
 };
 export type ExecuteOptions = ReturnType<typeof mapFlagsToOptions>;
-export declare function mapFlagsToOptions(flags: NoArg.InferFlags<typeof app>, bin?: Executor): {
+export declare function mapFlagsToOptions(flags: NoArg.InferFlags<typeof app>): {
     cwd: string;
     shell: boolean;
     silent: boolean;

package/dist/{arg-helper.cjs → argHelper.js}

@@ -87,7 +87,7 @@ exports.executionConfig = noarg_1.default.defineConfig({
         helpUsageTrailingArgsLabel: '...[args/flags for script]',
     },
 });
-function mapFlagsToOptions(flags, bin) {
+function mapFlagsToOptions(flags) {
     var _a;
     return {
         cwd: flags.cwd,
@@ -104,7 +104,7 @@ function mapFlagsToOptions(flags, bin) {
         watchDelay: flags.delay,
         watchFocus: flags.focus.length ? flags.focus : [flags.cwd],
         watchIgnore: flags.ignore,
-        watchExtensions: (flags.ext.length ? flags.ext : bin === null || bin === void 0 ? void 0 : bin.getRelatedExts()) || [],
+        watchExtensions: flags.ext,
         tsNode: flags['tsn'],
         env: Object.assign(Object.assign({}, flags.env.reduce((acc, env) => {
             const [key, value] = env.split('=');

package/dist/{bin.d.cts → bin.d.ts}

@@ -1,2 +1,2 @@
 #!/usr/bin/env node
-import "./app.cjs";
+import './app';

package/dist/{bin.cjs → bin.js}

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-require("./app.cjs");
-const arg_1 = require("./arg.cjs");
+require("./app");
+const arg_1 = require("./arg");
 arg_1.app.start();

package/dist/execution/{index.d.mts → index.d.ts}

@@ -1,4 +1,4 @@
-import { ExecuteOptions } from "../arg-helper.mjs";
+import { ExecuteOptions } from '../argHelper';
 export default class Execution {
     private command;
     private args;

package/dist/execution/{index.cjs → index.js}

@@ -28,9 +28,9 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 const cross_spawn_1 = require("cross-spawn");
 const readline = __importStar(require("readline"));
-const watcher_1 = __importDefault(require("./watcher.cjs"));
-const colors_1 = __importDefault(require("../lib/colors.cjs"));
-const kill_process_1 = __importDefault(require("./kill-process.cjs"));
+const watcher_1 = __importDefault(require("./watcher"));
+const colors_1 = __importDefault(require("../lib/colors"));
+const kill_process_1 = __importDefault(require("./kill-process"));
 class Execution {
     static start([command, ...args], options) {
         return new Execution(command, args, options);

package/dist/execution/{kill-process.d.cts → kill-process.d.ts}

@@ -1,2 +1,2 @@
-import { ChildProcess } from "child_process";
+import { ChildProcess } from 'child_process';
 export default function (child: ChildProcess): boolean;

package/dist/execution/{watcher.cjs → watcher.js}

@@ -28,9 +28,9 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.default = default_1;
 const path = __importStar(require("path"));
-const gitignore_1 = __importDefault(require("./gitignore.cjs"));
+const gitignore_1 = __importDefault(require("./gitignore"));
 const chokidar = __importStar(require("chokidar"));
-const debounce_1 = require("../utils/debounce.cjs");
+const debounce_1 = require("../helpers/debounce");
 function default_1(cwd, targets, callback, options) {
     const ig = (0, gitignore_1.default)(cwd, options.ignore);
     const debounce = (0, debounce_1.createDebounce)(options.debounceDelay);

package/dist/helpers/as.d.ts

@@ -0,0 +1 @@
+export default function <const T>(arg: T): T;

package/dist/helpers/as.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = default_1;
+function default_1(arg) {
+    return arg;
+}

package/dist/helpers/get-config.d.ts

@@ -0,0 +1 @@
+export default function (...extraDirs: string[]): any;

package/dist/helpers/get-config.js

@@ -0,0 +1,30 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = default_1;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+function getExistedFile(...files) {
+    for (const file of files) {
+        if (node_fs_1.default.existsSync(file))
+            return file;
+    }
+}
+function default_1(...extraDirs) {
+    var _a;
+    const userPath = (_a = process.env.HOME) !== null && _a !== void 0 ? _a : process.env.USERPROFILE;
+    if (!userPath)
+        return;
+    const configFile = getExistedFile(...extraDirs.map((dir) => node_path_1.default.join(dir, '/.uni-run.json')), node_path_1.default.join(process.cwd(), '/.uni-run.json'), node_path_1.default.join(userPath, '/.uni-run.json'));
+    if (!configFile)
+        return;
+    try {
+        const config = node_fs_1.default.readFileSync(configFile, 'utf-8');
+        return JSON.parse(config);
+    }
+    catch (_b) {
+        return {};
+    }
+}

package/dist/helpers/getConfig.d.ts

@@ -0,0 +1 @@
+export default function (...extraDirs: string[]): any;

package/dist/helpers/getConfig.js

@@ -0,0 +1,24 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = default_1;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const utils_1 = require("./utils");
+function default_1(...extraDirs) {
+    const userPath = (0, utils_1.getUserPath)();
+    if (!userPath)
+        return;
+    const configFile = (0, utils_1.getExistedFile)(...extraDirs.map((dir) => path_1.default.join(dir, '/.uni-run.json')), path_1.default.join(process.cwd(), '/.uni-run.json'), path_1.default.join(userPath, '/.uni-run.json'));
+    if (!configFile)
+        return;
+    try {
+        const config = fs_1.default.readFileSync(configFile, 'utf-8');
+        return JSON.parse(config);
+    }
+    catch (_a) {
+        return {};
+    }
+}

package/dist/helpers/getUserExecutors.d.ts

@@ -0,0 +1,2 @@
+import { ScriptExecutorOptions } from '../scriptExecutors/types.t';
+export default function (...extraDirs: string[]): ScriptExecutorOptions[] | undefined;

package/dist/helpers/getUserExecutors.js

@@ -0,0 +1,18 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = default_1;
+const path_1 = __importDefault(require("path"));
+const utils_1 = require("./utils");
+const EXECUTOR_CONFIG_FILE = '.uni-run.cjs';
+function default_1(...extraDirs) {
+    const userPath = (0, utils_1.getUserPath)();
+    if (!userPath)
+        return;
+    const configFile = (0, utils_1.getExistedFile)(...extraDirs.map((dir) => path_1.default.join(dir, EXECUTOR_CONFIG_FILE)), path_1.default.join(process.cwd(), EXECUTOR_CONFIG_FILE), path_1.default.join(userPath, EXECUTOR_CONFIG_FILE));
+    if (!configFile)
+        return;
+    return require(configFile);
+}

package/dist/helpers/utils.d.ts

@@ -0,0 +1,2 @@
+export declare function getExistedFile(...files: string[]): string | undefined;
+export declare function getUserPath(): string | undefined;

package/dist/helpers/utils.js

@@ -0,0 +1,18 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getExistedFile = getExistedFile;
+exports.getUserPath = getUserPath;
+const fs_1 = __importDefault(require("fs"));
+function getExistedFile(...files) {
+    for (const file of files) {
+        if (fs_1.default.existsSync(file))
+            return file;
+    }
+}
+function getUserPath() {
+    var _a;
+    return (_a = process.env.HOME) !== null && _a !== void 0 ? _a : process.env.USERPROFILE;
+}

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+import './app';
+import { ScriptExecutorOptions } from './scriptExecutors/types.t';
+declare const _default: {
+    addExecutor(executor: ScriptExecutorOptions): void;
+    start(args?: string[]): void;
+};
+export default _default;

package/dist/index.js

@@ -0,0 +1,16 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+require("./app");
+const arg_1 = require("./arg");
+const scriptExecutors_1 = __importDefault(require("./scriptExecutors"));
+exports.default = {
+    addExecutor(executor) {
+        scriptExecutors_1.default.unshift(executor);
+    },
+    start(args) {
+        arg_1.app.start(args);
+    },
+};

package/dist/lib/{colors.d.cts → colors.d.ts}

@@ -1,3 +1,3 @@
-import mjs from "ansi-colors";
+import mjs from 'ansi-colors';
 declare const _default: typeof mjs;
 export default _default;

package/dist/lib/{colors.cjs → colors.js}

@@ -28,5 +28,5 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 const ansi_colors_1 = __importDefault(require("ansi-colors"));
 const cjs = __importStar(require("ansi-colors"));
-const currentModule_1 = __importDefault(require("./currentModule.cjs"));
+const currentModule_1 = __importDefault(require("./currentModule"));
 exports.default = currentModule_1.default.isCJS ? cjs : ansi_colors_1.default;

package/dist/scriptExecutors/checkRuntime.d.ts

@@ -0,0 +1,2 @@
+import { RuntimeOptions } from './types.t';
+export default function (runtime: RuntimeOptions): false | undefined;

package/dist/scriptExecutors/checkRuntime.js

@@ -0,0 +1,42 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = default_1;
+const confirm_1 = __importDefault(require("@inquirer/confirm"));
+const cross_spawn_1 = require("cross-spawn");
+function default_1(runtime) {
+    if (!isInstalled(runtime.isInstalled)) {
+        renderHowToInstall(runtime.run[0], runtime.installHints);
+        return canBeInstalled(runtime.install);
+    }
+}
+function isInstalled(commands) {
+    if (!(commands === null || commands === void 0 ? void 0 : commands.length))
+        return true;
+    const [command, ...args] = commands;
+    const result = (0, cross_spawn_1.sync)(command, args, {
+        stdio: 'ignore',
+    });
+    if (result.status === 1)
+        return false;
+    return true;
+}
+function renderHowToInstall(name, hints) {
+    if (!(hints === null || hints === void 0 ? void 0 : hints.length))
+        return;
+    console.error(`${name} is not installed.`);
+    console.log('How to install:');
+    hints.forEach((hint) => console.log(hint));
+}
+function canBeInstalled(installCommands) {
+    if (!(installCommands === null || installCommands === void 0 ? void 0 : installCommands.length))
+        return false;
+    (0, confirm_1.default)({ message: 'Do you want to install it?' }).then((ans) => {
+        if (!ans)
+            return;
+        const [command, ...args] = installCommands;
+        (0, cross_spawn_1.sync)(command, args, { stdio: 'inherit' });
+    });
+}

package/dist/scriptExecutors/index.d.ts

@@ -0,0 +1,3 @@
+import { ScriptExecutorOptions } from './types.t';
+declare const _default: ScriptExecutorOptions[];
+export default _default;