uni-run 1.0.5 → 1.0.7

package/README.md

@@ -0,0 +1,122 @@
+# 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.
+
+## 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.
+- **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.
+- **Information Display**: Show detailed information about the script execution.
+
+## Installation
+
+To install `uni-run`, use npm:
+
+```sh
+npm install -g uni-run
+```
+
+## CLI Usage
+
+### Basic Command
+
+To run a script, use the following command:
+
+```sh
+run script.ext [options] -- [args for internal bin]
+uni-run script.ext [options] -- [args for internal bin]
+```
+
+### Examples
+
+#### Running a JavaScript File
+
+```sh
+run ./scripts/main.js
+```
+
+#### Running a TypeScript File
+
+```sh
+run ./scripts/main.ts
+```
+
+#### Running a Python File
+
+```sh
+run ./scripts/main.py
+```
+
+#### Running a Java File
+
+```sh
+run ./scripts/Main.java
+```
+
+#### Running with script argv
+
+```sh
+run ./scripts/main.js -- --some someValue
+```
+
+Here `--some someValue` will be passed to `node` and will be ignored by uni-run.
+
+## 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.
+
+```typescript
+import uniRun, { Executor } from 'uni-run'
+
+const executor = new Executor('Name', {
+  extensions: ['something'],
+  run(args, options) {
+    return ['something-binary', ...args]
+  },
+})
+
+uniRun.addBin(executor)
+```
+
+#### `start(args?: string[])`:
+
+Starts the application with the provided arguments.
+
+```typescript
+import uniRun from 'uni-run'
+
+uniRun.start(['arg1', 'arg2'])
+```
+
+### Example Usage
+
+```typescript
+import uniRun, { Executor } from 'uni-run'
+
+// Create a new Executor instance
+const executor = new Executor('Name', {
+  extensions: ['some'],
+  run(args, options) {
+    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.

package/dist/app.cjs

@@ -0,0 +1,60 @@
+"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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const arg = __importStar(require("./arg.cjs"));
+const execution_1 = __importDefault(require("./execution/index.cjs"));
+const builtin_bin_1 = __importDefault(require("./builtin-bin/index.cjs"));
+const arg_helper_1 = require("./arg-helper.cjs");
+arg.app.on(([script, listArs, trailingArgs], flags) => {
+    const bin = builtin_bin_1.default.find((bin) => bin.isSupported(script));
+    if (!bin) {
+        console.log('Unsupported script:', script);
+        return console.log('You may try "ur exec bin script.ext - --flags"');
+    }
+    const executionOptions = (0, arg_helper_1.mapFlagsToOptions)(flags, bin);
+    bin.start(executionOptions, [script, ...listArs, ...trailingArgs]);
+});
+arg.exec.on(([listArs, trailingArgs], flags) => {
+    execution_1.default.start([...listArs, ...trailingArgs], (0, arg_helper_1.mapFlagsToOptions)(flags));
+});
+arg.list.on(() => {
+    console.log('Supported scripts:');
+    builtin_bin_1.default
+        .sort((a, b) => {
+        const aName = a.getName();
+        const bName = b.getName();
+        if (aName < bName)
+            return -1;
+        if (aName > bName)
+            return 1;
+        return 0;
+    })
+        .forEach((bin) => {
+        console.log(`- ${bin.getName()}`);
+    });
+});

package/dist/app.d.mts

@@ -0,0 +1 @@
+export {};

package/dist/{index.js → app.mjs}

@@ -1,24 +1,22 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const arg = require("./arg");
-const execution_1 = require("./execution");
-const builtin_bin_1 = require("./builtin-bin");
-const arg_helper_1 = require("./arg-helper");
+import * as arg from "./arg.mjs";
+import Execution from "./execution/index.mjs";
+import builtinBin from "./builtin-bin/index.mjs";
+import { mapFlagsToOptions } from "./arg-helper.mjs";
 arg.app.on(([script, listArs, trailingArgs], flags) => {
-    const bin = builtin_bin_1.default.find((bin) => bin.isSupported(script));
+    const bin = builtinBin.find((bin) => bin.isSupported(script));
     if (!bin) {
         console.log('Unsupported script:', script);
         return console.log('You may try "ur exec bin script.ext - --flags"');
     }
-    const executionOptions = (0, arg_helper_1.mapFlagsToOptions)(flags, bin);
+    const executionOptions = mapFlagsToOptions(flags, bin);
     bin.start(executionOptions, [script, ...listArs, ...trailingArgs]);
 });
 arg.exec.on(([listArs, trailingArgs], flags) => {
-    execution_1.default.start([...listArs, ...trailingArgs], (0, arg_helper_1.mapFlagsToOptions)(flags));
+    Execution.start([...listArs, ...trailingArgs], mapFlagsToOptions(flags));
 });
 arg.list.on(() => {
     console.log('Supported scripts:');
-    builtin_bin_1.default
+    builtinBin
         .sort((a, b) => {
         const aName = a.getName();
         const bName = b.getName();

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

@@ -1,10 +1,51 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.executionConfig = void 0;
 exports.mapFlagsToOptions = mapFlagsToOptions;
-const noarg_1 = require("noarg");
+const noarg_1 = __importDefault(require("noarg"));
 exports.executionConfig = noarg_1.default.defineConfig({
     flags: {
+        reloadKey: noarg_1.default.boolean()
+            .aliases('rk')
+            .default(true)
+            .description("Reload the page when pressing 'Ctrl+R' or 'F5'"),
+        watch: noarg_1.default.boolean()
+            .aliases('w')
+            .default(true)
+            .description('Watch for changes'),
+        exit: noarg_1.default.boolean()
+            .default(false)
+            .description('Exit after code execution, disabling `watch` and `reloadKey`'),
+        clear: noarg_1.default.boolean()
+            .aliases('c')
+            .default(true)
+            .description('Clear the console before running the script'),
+        delay: noarg_1.default.number()
+            .aliases('d')
+            .default(100)
+            .description('The delay to wait for the watcher to trigger'),
+        ext: noarg_1.default.array(noarg_1.default.string())
+            .aliases('e')
+            .default([])
+            .description('Looks for changes only of the given extensions'),
+        include: noarg_1.default.array(noarg_1.default.string())
+            .aliases('in')
+            .default([])
+            .description('Only watch the given folders/files'),
+        exclude: noarg_1.default.array(noarg_1.default.string())
+            .aliases('ex')
+            .default([])
+            .description('Exclude the given folders/files'),
+        bench: noarg_1.default.boolean()
+            .aliases('b')
+            .description('Calculate the execution time'),
+        benchPrefix: noarg_1.default.string()
+            .aliases('bp')
+            .minLength(1)
+            .description('The prefix to show before the execution time'),
         cwd: noarg_1.default.string()
             .default(process.cwd())
             .description('Current working directory'),
@@ -17,37 +58,10 @@ exports.executionConfig = noarg_1.default.defineConfig({
         time: noarg_1.default.boolean()
             .default(false)
             .description('Show the execution time at the start'),
-        bench: noarg_1.default.boolean()
-            .default(false)
-            .description('Show the execution time'),
-        benchPrefix: noarg_1.default.string().description('The prefix for the benchmark to show at the start of the line'),
-        clear: noarg_1.default.boolean()
-            .default(true)
-            .description('Clear the console before running the script')
-            .aliases('c'),
-        reloadKey: noarg_1.default.boolean()
-            .default(true)
-            .description("Reload the page when pressing 'Ctrl+R' or 'F5'")
-            .aliases('rk'),
-        watch: noarg_1.default.boolean()
-            .default(true)
-            .description('Watch for changes')
-            .aliases('w'),
-        delay: noarg_1.default.number()
-            .default(100)
-            .description('The delay to wait for the watcher to trigger')
-            .aliases('d'),
-        ext: noarg_1.default.array(noarg_1.default.string())
-            .default([])
-            .description('Looks for changes only of the given extensions')
-            .aliases('e'),
-        ignore: noarg_1.default.array(noarg_1.default.string())
-            .default([])
-            .description('Ignore the given folders/files')
-            .aliases('ig'),
         env: noarg_1.default.array(noarg_1.default.string())
             .default([])
             .description('Environment variables'),
+        // Extra flags
         nodeDev: noarg_1.default.boolean()
             .default(false)
             .description('Set NODE_ENV to "development"'),
@@ -66,18 +80,20 @@ exports.executionConfig = noarg_1.default.defineConfig({
     },
 });
 function mapFlagsToOptions(flags, bin) {
+    var _a;
     return {
         cwd: flags.cwd,
         shell: flags.shell,
         showInfo: flags.info,
         showTime: flags.time,
-        benchmark: flags.bench,
+        benchmark: (_a = flags.bench) !== null && _a !== void 0 ? _a : Boolean(flags.benchPrefix),
         benchmarkPrefix: flags.benchPrefix,
         clearOnReload: flags.clear,
-        readlineReload: flags.reloadKey,
-        watch: flags.watch,
+        keystrokeReload: flags.exit ? false : flags.reloadKey,
+        watch: flags.exit ? false : flags.watch,
         watchDelay: flags.delay,
-        watchIgnore: flags.ignore,
+        watchInclude: flags.include,
+        watchExclude: flags.exclude,
         watchExtensions: (flags.ext.length ? flags.ext : bin === null || bin === void 0 ? void 0 : bin.getRelatedExts()) || [],
         tsNode: flags['tsn'],
         env: Object.assign(Object.assign({}, flags.env.reduce((acc, env) => {

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

@@ -1,73 +1,86 @@
-import NoArg from 'noarg';
-import type { app } from './arg';
-import Executor from './builtin-bin/Executor';
+import NoArg from "noarg";
+import type { app } from "./arg.cjs";
+import Executor from "./builtin-bin/Executor.cjs";
 export declare const executionConfig: {
     readonly flags: {
-        readonly cwd: import("noarg/dist/schema/TypeString.cjs").TypeString<{
-            required: true;
-            default: string;
-            description: "Current working directory";
-        }>;
-        readonly shell: import("noarg/dist/schema/TypeBoolean.cjs").TypeBoolean<{
-            required: true;
-            default: false;
-            description: "Run the script in a shell for more low-level control";
-        }>;
-        readonly info: import("noarg/dist/schema/TypeBoolean.cjs").TypeBoolean<{
+        readonly reloadKey: import("noarg/dist/schema/TypeBoolean.cjs").TypeBoolean<{
+            aliases: ["rk"];
             required: true;
-            default: false;
-            description: "Show information about the script";
+            default: true;
+            description: "Reload the page when pressing 'Ctrl+R' or 'F5'";
         }>;
-        readonly time: import("noarg/dist/schema/TypeBoolean.cjs").TypeBoolean<{
+        readonly watch: import("noarg/dist/schema/TypeBoolean.cjs").TypeBoolean<{
+            aliases: ["w"];
             required: true;
-            default: false;
-            description: "Show the execution time at the start";
+            default: true;
+            description: "Watch for changes";
         }>;
-        readonly bench: import("noarg/dist/schema/TypeBoolean.cjs").TypeBoolean<{
+        readonly exit: import("noarg/dist/schema/TypeBoolean.cjs").TypeBoolean<{
             required: true;
             default: false;
-            description: "Show the execution time";
-        }>;
-        readonly benchPrefix: import("noarg/dist/schema/TypeString.cjs").TypeString<{
-            description: "The prefix for the benchmark to show at the start of the line";
+            description: "Exit after code execution, disabling `watch` and `reloadKey`";
         }>;
         readonly clear: import("noarg/dist/schema/TypeBoolean.cjs").TypeBoolean<{
-            description: "Clear the console before running the script";
+            aliases: ["c"];
             required: true;
             default: true;
-            aliases: [string];
-        }>;
-        readonly reloadKey: import("noarg/dist/schema/TypeBoolean.cjs").TypeBoolean<{
-            description: "Reload the page when pressing 'Ctrl+R' or 'F5'";
-            required: true;
-            default: true;
-            aliases: [string];
-        }>;
-        readonly watch: import("noarg/dist/schema/TypeBoolean.cjs").TypeBoolean<{
-            description: "Watch for changes";
-            required: true;
-            default: true;
-            aliases: [string];
+            description: "Clear the console before running the script";
         }>;
         readonly delay: import("noarg/dist/schema/TypeNumber.cjs").TypeNumber<{
-            description: "The delay to wait for the watcher to trigger";
+            aliases: ["d"];
             required: true;
             default: 100;
-            aliases: [string];
+            description: "The delay to wait for the watcher to trigger";
         }>;
         readonly ext: import("noarg/dist/schema/TypeArray.cjs").TypeArray<{
+            aliases: ["e"];
+            required: true;
+            default: never[];
+            schema: import("noarg/dist/schema/TypeString.cjs").TypeString<{}>;
             description: "Looks for changes only of the given extensions";
+        }>;
+        readonly include: import("noarg/dist/schema/TypeArray.cjs").TypeArray<{
+            aliases: ["in"];
             required: true;
             default: never[];
             schema: import("noarg/dist/schema/TypeString.cjs").TypeString<{}>;
-            aliases: [string];
+            description: "Only watch the given folders/files";
         }>;
-        readonly ignore: import("noarg/dist/schema/TypeArray.cjs").TypeArray<{
-            description: "Ignore the given folders/files";
+        readonly exclude: import("noarg/dist/schema/TypeArray.cjs").TypeArray<{
+            aliases: ["ex"];
             required: true;
             default: never[];
             schema: import("noarg/dist/schema/TypeString.cjs").TypeString<{}>;
-            aliases: [string];
+            description: "Exclude the given folders/files";
+        }>;
+        readonly bench: import("noarg/dist/schema/TypeBoolean.cjs").TypeBoolean<{
+            aliases: ["b"];
+            description: "Calculate the execution time";
+        }>;
+        readonly benchPrefix: import("noarg/dist/schema/TypeString.cjs").TypeString<{
+            aliases: ["bp"];
+            minLength: 1;
+            description: "The prefix to show before the execution time";
+        }>;
+        readonly cwd: import("noarg/dist/schema/TypeString.cjs").TypeString<{
+            required: true;
+            default: string;
+            description: "Current working directory";
+        }>;
+        readonly shell: import("noarg/dist/schema/TypeBoolean.cjs").TypeBoolean<{
+            required: true;
+            default: false;
+            description: "Run the script in a shell for more low-level control";
+        }>;
+        readonly info: import("noarg/dist/schema/TypeBoolean.cjs").TypeBoolean<{
+            required: true;
+            default: false;
+            description: "Show information about the script";
+        }>;
+        readonly time: import("noarg/dist/schema/TypeBoolean.cjs").TypeBoolean<{
+            required: true;
+            default: false;
+            description: "Show the execution time at the start";
         }>;
         readonly env: import("noarg/dist/schema/TypeArray.cjs").TypeArray<{
             required: true;
@@ -105,10 +118,11 @@ export declare function mapFlagsToOptions(flags: NoArg.InferFlags<typeof app>, b
     benchmark: boolean;
     benchmarkPrefix: string | undefined;
     clearOnReload: boolean;
-    readlineReload: boolean;
+    keystrokeReload: boolean;
     watch: boolean;
     watchDelay: number;
-    watchIgnore: string[];
+    watchInclude: string[];
+    watchExclude: string[];
     watchExtensions: string[];
     tsNode: boolean;
     env: NodeJS.ProcessEnv;

package/dist/arg-helper.d.mts

@@ -0,0 +1,129 @@
+import NoArg from "noarg";
+import type { app } from "./arg.mjs";
+import Executor from "./builtin-bin/Executor.mjs";
+export declare const executionConfig: {
+    readonly flags: {
+        readonly reloadKey: import("noarg/dist/schema/TypeBoolean.cjs").TypeBoolean<{
+            aliases: ["rk"];
+            required: true;
+            default: true;
+            description: "Reload the page when pressing 'Ctrl+R' or 'F5'";
+        }>;
+        readonly watch: import("noarg/dist/schema/TypeBoolean.cjs").TypeBoolean<{
+            aliases: ["w"];
+            required: true;
+            default: true;
+            description: "Watch for changes";
+        }>;
+        readonly exit: import("noarg/dist/schema/TypeBoolean.cjs").TypeBoolean<{
+            required: true;
+            default: false;
+            description: "Exit after code execution, disabling `watch` and `reloadKey`";
+        }>;
+        readonly clear: import("noarg/dist/schema/TypeBoolean.cjs").TypeBoolean<{
+            aliases: ["c"];
+            required: true;
+            default: true;
+            description: "Clear the console before running the script";
+        }>;
+        readonly delay: import("noarg/dist/schema/TypeNumber.cjs").TypeNumber<{
+            aliases: ["d"];
+            required: true;
+            default: 100;
+            description: "The delay to wait for the watcher to trigger";
+        }>;
+        readonly ext: import("noarg/dist/schema/TypeArray.cjs").TypeArray<{
+            aliases: ["e"];
+            required: true;
+            default: never[];
+            schema: import("noarg/dist/schema/TypeString.cjs").TypeString<{}>;
+            description: "Looks for changes only of the given extensions";
+        }>;
+        readonly include: import("noarg/dist/schema/TypeArray.cjs").TypeArray<{
+            aliases: ["in"];
+            required: true;
+            default: never[];
+            schema: import("noarg/dist/schema/TypeString.cjs").TypeString<{}>;
+            description: "Only watch the given folders/files";
+        }>;
+        readonly exclude: import("noarg/dist/schema/TypeArray.cjs").TypeArray<{
+            aliases: ["ex"];
+            required: true;
+            default: never[];
+            schema: import("noarg/dist/schema/TypeString.cjs").TypeString<{}>;
+            description: "Exclude the given folders/files";
+        }>;
+        readonly bench: import("noarg/dist/schema/TypeBoolean.cjs").TypeBoolean<{
+            aliases: ["b"];
+            description: "Calculate the execution time";
+        }>;
+        readonly benchPrefix: import("noarg/dist/schema/TypeString.cjs").TypeString<{
+            aliases: ["bp"];
+            minLength: 1;
+            description: "The prefix to show before the execution time";
+        }>;
+        readonly cwd: import("noarg/dist/schema/TypeString.cjs").TypeString<{
+            required: true;
+            default: string;
+            description: "Current working directory";
+        }>;
+        readonly shell: import("noarg/dist/schema/TypeBoolean.cjs").TypeBoolean<{
+            required: true;
+            default: false;
+            description: "Run the script in a shell for more low-level control";
+        }>;
+        readonly info: import("noarg/dist/schema/TypeBoolean.cjs").TypeBoolean<{
+            required: true;
+            default: false;
+            description: "Show information about the script";
+        }>;
+        readonly time: import("noarg/dist/schema/TypeBoolean.cjs").TypeBoolean<{
+            required: true;
+            default: false;
+            description: "Show the execution time at the start";
+        }>;
+        readonly env: import("noarg/dist/schema/TypeArray.cjs").TypeArray<{
+            required: true;
+            default: never[];
+            schema: import("noarg/dist/schema/TypeString.cjs").TypeString<{}>;
+            description: "Environment variables";
+        }>;
+        readonly nodeDev: import("noarg/dist/schema/TypeBoolean.cjs").TypeBoolean<{
+            required: true;
+            default: false;
+            description: "Set NODE_ENV to \"development\"";
+        }>;
+        readonly tsn: import("noarg/dist/schema/TypeBoolean.cjs").TypeBoolean<{
+            required: true;
+            default: false;
+            description: "Run the script with ts-node";
+        }>;
+    };
+    readonly listArgument: {
+        readonly name: "args for script";
+        readonly description: "The arguments to pass to the script";
+        readonly type: import("noarg/dist/schema/TypeString.cjs").TypeString<{}>;
+    };
+    readonly trailingArguments: "--";
+    readonly customRenderHelp: {
+        readonly helpUsageTrailingArgsLabel: "...[args/flags for script]";
+    };
+};
+export type ExecuteOptions = ReturnType<typeof mapFlagsToOptions>;
+export declare function mapFlagsToOptions(flags: NoArg.InferFlags<typeof app>, bin?: Executor): {
+    cwd: string;
+    shell: boolean;
+    showInfo: boolean;
+    showTime: boolean;
+    benchmark: boolean;
+    benchmarkPrefix: string | undefined;
+    clearOnReload: boolean;
+    keystrokeReload: boolean;
+    watch: boolean;
+    watchDelay: number;
+    watchInclude: string[];
+    watchExclude: string[];
+    watchExtensions: string[];
+    tsNode: boolean;
+    env: NodeJS.ProcessEnv;
+};