uni-run 0.0.0

package/dist/arg.d.ts

@@ -0,0 +1,142 @@
+import NoArg from 'noarg';
+export declare const app: NoArg<"uni-run", {
+    readonly allowEqualAssign: true;
+    readonly booleanNotSyntaxEnding: "\\";
+    readonly allowDuplicateFlagForList: true;
+    readonly splitListByComma: true;
+}, {
+    readonly help: true;
+}, {
+    readonly optionalArguments: [];
+    readonly globalFlags: {};
+    readonly arguments: [{
+        readonly name: "script";
+        readonly description: "Run a script";
+        readonly type: import("noarg/dist/schema/TypeString.cjs").TypeString<{}>;
+    }];
+    readonly listArgument: {
+        readonly name: "args";
+        readonly description: "The arguments to pass to the script";
+        readonly type: import("noarg/dist/schema/TypeString.cjs").TypeString<{}>;
+    };
+    readonly trailingArguments: "--";
+    readonly flags: {
+        readonly cwd: import("noarg/dist/schema/TypeString.cjs").TypeString<{
+            required: true;
+            default: string;
+            description: "The current working directory";
+        }>;
+        readonly clear: import("noarg/dist/schema/TypeBoolean.cjs").TypeBoolean<{
+            description: "Clear the console before running the script";
+            required: true;
+            default: true;
+            aliases: [string];
+        }>;
+        readonly reload: import("noarg/dist/schema/TypeBoolean.cjs").TypeBoolean<{
+            description: "Reload the page when pressing \"Ctrl+R\" or \"Meta+R\"";
+            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];
+        }>;
+        readonly watchDelay: import("noarg/dist/schema/TypeNumber.cjs").TypeNumber<{
+            description: "The delay to wait for the watcher to trigger";
+            required: true;
+            default: 100;
+            aliases: [string];
+        }>;
+        readonly ext: import("noarg/dist/schema/TypeArray.cjs").TypeArray<{
+            description: "Looks for changes only of the given extensions";
+            required: true;
+            default: never[];
+            schema: import("noarg/dist/schema/TypeString.cjs").TypeString<{}>;
+            aliases: [string];
+        }>;
+        readonly ignore: import("noarg/dist/schema/TypeArray.cjs").TypeArray<{
+            required: true;
+            default: never[];
+            schema: import("noarg/dist/schema/TypeString.cjs").TypeString<{}>;
+            description: "Ignore the given targets";
+        }>;
+        readonly env: import("noarg/dist/schema/TypeArray.cjs").TypeArray<{
+            required: true;
+            default: never[];
+            schema: import("noarg/dist/schema/TypeString.cjs").TypeString<{}>;
+            description: "Environment variables";
+        }>;
+    };
+}>;
+export declare const exec: import("noarg/dist/NoArg/NoArgProgram.cjs").NoArgProgram<"exec", {
+    readonly allowEqualAssign: true;
+    readonly booleanNotSyntaxEnding: "\\";
+    readonly allowDuplicateFlagForList: true;
+    readonly splitListByComma: true;
+}, {
+    readonly help: true;
+}, {
+    readonly description: "Execute a script with the given binary";
+    readonly arguments: [];
+    readonly optionalArguments: [];
+    readonly listArgument: {
+        readonly name: "args";
+        readonly description: "The arguments to pass to the script";
+        readonly type: import("noarg/dist/schema/TypeString.cjs").TypeString<{}>;
+    };
+    readonly trailingArguments: "--";
+    readonly flags: {
+        readonly cwd: import("noarg/dist/schema/TypeString.cjs").TypeString<{
+            required: true;
+            default: string;
+            description: "The current working directory";
+        }>;
+        readonly clear: import("noarg/dist/schema/TypeBoolean.cjs").TypeBoolean<{
+            description: "Clear the console before running the script";
+            required: true;
+            default: true;
+            aliases: [string];
+        }>;
+        readonly reload: import("noarg/dist/schema/TypeBoolean.cjs").TypeBoolean<{
+            description: "Reload the page when pressing \"Ctrl+R\" or \"Meta+R\"";
+            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];
+        }>;
+        readonly watchDelay: import("noarg/dist/schema/TypeNumber.cjs").TypeNumber<{
+            description: "The delay to wait for the watcher to trigger";
+            required: true;
+            default: 100;
+            aliases: [string];
+        }>;
+        readonly ext: import("noarg/dist/schema/TypeArray.cjs").TypeArray<{
+            description: "Looks for changes only of the given extensions";
+            required: true;
+            default: never[];
+            schema: import("noarg/dist/schema/TypeString.cjs").TypeString<{}>;
+            aliases: [string];
+        }>;
+        readonly ignore: import("noarg/dist/schema/TypeArray.cjs").TypeArray<{
+            required: true;
+            default: never[];
+            schema: import("noarg/dist/schema/TypeString.cjs").TypeString<{}>;
+            description: "Ignore the given targets";
+        }>;
+        readonly env: import("noarg/dist/schema/TypeArray.cjs").TypeArray<{
+            required: true;
+            default: never[];
+            schema: import("noarg/dist/schema/TypeString.cjs").TypeString<{}>;
+            description: "Environment variables";
+        }>;
+    };
+    globalFlags: {};
+}>;

package/dist/arg.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.exec = exports.app = void 0;
+const noarg_1 = require("noarg");
+const executionConfig = noarg_1.default.defineConfig({
+    flags: {
+        cwd: noarg_1.default.string()
+            .default(process.cwd())
+            .description('The current working directory'),
+        clear: noarg_1.default.boolean()
+            .default(true)
+            .description('Clear the console before running the script')
+            .aliases('c'),
+        reload: noarg_1.default.boolean()
+            .default(true)
+            .description('Reload the page when pressing "Ctrl+R" or "Meta+R"')
+            .aliases('r'),
+        watch: noarg_1.default.boolean()
+            .default(true)
+            .description('Watch for changes')
+            .aliases('w'),
+        watchDelay: noarg_1.default.number()
+            .default(100)
+            .description('The delay to wait for the watcher to trigger')
+            .aliases('wd'),
+        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 targets'),
+        env: noarg_1.default.array(noarg_1.default.string())
+            .default([])
+            .description('Environment variables'),
+    },
+    listArgument: {
+        name: 'args',
+        description: 'The arguments to pass to the script',
+        type: noarg_1.default.string(),
+    },
+    trailingArguments: '--',
+});
+exports.app = noarg_1.default.create('uni-run', Object.assign(Object.assign({}, executionConfig), { arguments: [
+        {
+            name: 'script',
+            description: 'Run a script',
+            type: noarg_1.default.string(),
+        },
+    ], system: {
+        splitListByComma: true,
+    } }));
+exports.exec = exports.app.create('exec', Object.assign(Object.assign({}, executionConfig), { description: 'Execute a script with the given binary' }));

package/dist/bin.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+import './index';

package/dist/bin.js

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

package/dist/builtin-bin/ExecutionBin.d.ts

@@ -0,0 +1,18 @@
+export default class ExecutionBin {
+    displayName: string;
+    command: string;
+    run: (...args: string[]) => [command: string, ...args: string[]];
+    extensions: Set<string>;
+    checkInstallationArgs?: string[];
+    howToInstall?: () => void;
+    constructor(config: {
+        name: string;
+        command: string;
+        extensions: string[];
+        run: (...args: string[]) => [command: string, ...args: string[]];
+        checkInstallationArgs?: string[];
+        howToInstall?: () => void;
+    });
+    isSupported(script: string): boolean;
+    isInstalled(): boolean;
+}

package/dist/builtin-bin/ExecutionBin.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const cross_spawn_1 = require("cross-spawn");
+class ExecutionBin {
+    constructor(config) {
+        this.displayName = config.name;
+        this.command = config.command;
+        this.extensions = new Set(config.extensions);
+        this.run = config.run;
+        this.checkInstallationArgs = config.checkInstallationArgs;
+        this.howToInstall = config.howToInstall;
+    }
+    isSupported(script) {
+        return this.extensions.has(script.split('.').pop() || '');
+    }
+    isInstalled() {
+        const result = (0, cross_spawn_1.sync)(this.command, this.checkInstallationArgs ? this.checkInstallationArgs : []);
+        if (result.status === 1)
+            return false;
+        return true;
+    }
+}
+exports.default = ExecutionBin;

package/dist/builtin-bin/index.d.ts

@@ -0,0 +1,3 @@
+import ExecutionBin from './ExecutionBin';
+declare const _default: ExecutionBin[];
+export default _default;

package/dist/builtin-bin/index.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const ExecutionBin_1 = require("./ExecutionBin");
+exports.default = [
+    new ExecutionBin_1.default({
+        name: 'Node.js',
+        command: 'node',
+        extensions: ['js', 'javascript', 'jsx', 'cjs', 'cjsx', 'mjs', 'mjsx'],
+        run(...args) {
+            return [this.command, ...args];
+        },
+        checkInstallationArgs: ['--version'],
+        howToInstall: () => {
+            console.log('Please install Node.js from https://nodejs.org/');
+        },
+    }),
+    new ExecutionBin_1.default({
+        name: 'TypeScript',
+        command: 'ts-node',
+        extensions: ['ts', 'tsx', 'cts', 'ctsx', 'mts', 'mtsx'],
+        run(...args) {
+            return [this.command, ...args];
+        },
+        checkInstallationArgs: ['--version'],
+        howToInstall: () => {
+            console.log('Please install ts-node from https://www.npmjs.com/package/ts-node');
+        },
+    }),
+    new ExecutionBin_1.default({
+        name: 'python',
+        command: 'python',
+        extensions: ['py'],
+        run(...args) {
+            return [this.command, ...args];
+        },
+        checkInstallationArgs: ['--version'],
+        howToInstall: () => {
+            console.log('Please install Python from https://www.python.org/');
+        },
+    }),
+    new ExecutionBin_1.default({
+        name: 'java',
+        command: 'java',
+        extensions: ['java'],
+        run(...args) {
+            return [this.command, ...args];
+        },
+        checkInstallationArgs: ['--version'],
+        howToInstall: () => {
+            console.log('Please install Java from https://www.oracle.com/java/');
+        },
+    }),
+];

package/dist/execute.d.ts

@@ -0,0 +1,11 @@
+export type ExecuteOptions = {
+    cwd: string;
+    clearOnReload: boolean;
+    readlineReload: boolean;
+    watch: boolean;
+    watchDelay: number;
+    watchIgnore: string[];
+    watchExtensions: string[];
+    env?: Record<string, string>;
+};
+export default function ([command, ...args]: string[], options: ExecuteOptions): void;

package/dist/execute.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = default_1;
+const readline = require("readline");
+const cross_spawn_1 = require("cross-spawn");
+const colors_1 = require("./utils/colors");
+const watcher_1 = require("./watcher");
+function default_1([command, ...args], options) {
+    var _a, _b;
+    if (options.readlineReload) {
+        readline.emitKeypressEvents(process.stdin);
+        (_b = (_a = process.stdin).setRawMode) === null || _b === void 0 ? void 0 : _b.call(_a, true);
+        process.stdin.on('keypress', (_, key) => {
+            if (key.name === 'f5')
+                return exec();
+            if ((key.ctrl || key.meta) && key.name === 'r')
+                return exec();
+            if (key.ctrl && key.name === 'c') {
+                console.log('^C...');
+                process.exit(0);
+            }
+        });
+    }
+    if (options.watch) {
+        (0, watcher_1.default)(options.cwd, {
+            ignore: options.watchIgnore,
+            debounceDelay: options.watchDelay,
+            extensions: new Set(options.watchExtensions),
+        }, () => exec());
+    }
+    let child = null;
+    function exec() {
+        if (options.clearOnReload) {
+            process.stdout.write('\x1Bc');
+            console.clear();
+        }
+        if (child) {
+            child.removeAllListeners();
+            child.kill();
+        }
+        child = (0, cross_spawn_1.spawn)(command, args, {
+            argv0: command,
+            cwd: options.cwd,
+            stdio: 'inherit',
+            env: Object.assign({}, options.env),
+        });
+        child.on('error', console.error);
+        child.on('exit', (code) => {
+            if (code && code > 0) {
+                console.log('');
+                console.log(colors_1.default.red(`Process exited with code: ${colors_1.default.yellow(String(code))}`));
+            }
+            if (options.readlineReload) {
+                console.log(colors_1.default.blue.dim(`⟳ Press ${colors_1.default.yellow('F5')} or ${colors_1.default.yellow('^R')} to reload...`));
+            }
+        });
+    }
+    exec();
+}

package/dist/index.d.ts

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

package/dist/index.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const arg = require("./arg");
+const builtin_bin_1 = require("./builtin-bin");
+const execute_1 = require("./execute");
+function mapFlagsToOptions(flags) {
+    return {
+        cwd: flags.cwd,
+        clearOnReload: flags.clear,
+        readlineReload: flags.reload,
+        env: flags.env.reduce((acc, env) => {
+            const [key, value] = env.split('=');
+            acc[key] = value;
+            return acc;
+        }, {}),
+        watch: flags.watch,
+        watchDelay: flags.watchDelay,
+        watchExtensions: flags.ext,
+        watchIgnore: flags.ignore,
+    };
+}
+arg.app.on(([script, listArs, trailingArgs], flags) => {
+    if (script) {
+        const bin = builtin_bin_1.default.find((bin) => bin.isSupported(script));
+        if (!bin) {
+            console.log('Unsupported script:', script);
+            console.log('You may try "ur exec bin script.ext - --flags"');
+            process.exit(1);
+        }
+        if (!bin.isInstalled()) {
+            console.error(`${bin.displayName} is not installed.`);
+            if (bin.howToInstall) {
+                console.log('How to install:');
+                bin.howToInstall();
+            }
+            process.exit(1);
+        }
+        return (0, execute_1.default)(bin.run(script, ...listArs, ...trailingArgs), mapFlagsToOptions(flags));
+    }
+    arg.app.renderHelp();
+});
+arg.exec.on(([listArs, trailingArgs], flags) => {
+    (0, execute_1.default)([...listArs, ...trailingArgs], mapFlagsToOptions(flags));
+});

package/dist/utils/colors.d.ts

@@ -0,0 +1,2 @@
+import * as colors from 'ansi-colors';
+export default colors;

package/dist/utils/colors.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const colors = require("ansi-colors");
+exports.default = colors;

package/dist/utils/debounce.d.ts

@@ -0,0 +1 @@
+export declare function createDebounce(delay: number): (fn: Function) => void;

package/dist/utils/debounce.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createDebounce = createDebounce;
+function createDebounce(delay) {
+    let debounceTimeout;
+    return function (fn) {
+        clearTimeout(debounceTimeout);
+        debounceTimeout = setTimeout(() => fn(), delay);
+    };
+}

package/dist/watcher/gitignore.d.ts

@@ -0,0 +1 @@
+export default function (baseDir: string, extraIgnore?: string[]): import("ignore").Ignore;

package/dist/watcher/gitignore.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = default_1;
+const fs = require("fs");
+const path = require("path");
+const ignore_1 = require("ignore");
+function default_1(baseDir, extraIgnore = []) {
+    const gitignorePath = path.resolve(path.join(baseDir, '.gitignore'));
+    const ig = (0, ignore_1.default)({ ignorecase: true }).add(extraIgnore);
+    if (fs.existsSync(gitignorePath)) {
+        return ig.add(fs.readFileSync(gitignorePath).toString());
+    }
+    return ig;
+}

package/dist/watcher/index.d.ts

@@ -0,0 +1,6 @@
+export type WatcherOptions = {
+    ignore: string[];
+    extensions: Set<string>;
+    debounceDelay: number;
+};
+export default function (dir: string, options: WatcherOptions, callback: () => void): void;

package/dist/watcher/index.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = default_1;
+const path = require("path");
+const chokidar = require("chokidar");
+const gitignore_1 = require("./gitignore");
+const debounce_1 = require("../utils/debounce");
+function default_1(dir, options, callback) {
+    const ig = (0, gitignore_1.default)(dir, options.ignore);
+    const debounce = (0, debounce_1.createDebounce)(options.debounceDelay);
+    const watcher = chokidar.watch(dir, {
+        ignored: (filePath) => {
+            const relativePath = path.relative(dir, filePath);
+            if (!relativePath)
+                return false;
+            if (ig.ignores(relativePath))
+                return true;
+            if (options.extensions.size) {
+                const ext = path.extname(relativePath).slice(1);
+                if (ext && !options.extensions.has(ext))
+                    return true;
+            }
+            return false;
+        },
+        interval: options.debounceDelay / 2,
+        persistent: true,
+        ignoreInitial: true,
+    });
+    watcher.on('add', (event) => {
+        debounce(() => callback());
+    });
+    watcher.on('change', (event) => {
+        debounce(() => callback());
+    });
+    watcher.on('unlink', () => {
+        debounce(() => callback());
+    });
+}

package/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "uni-run",
+  "description": "Universal Runner for many language",
+  "version": "0.0.0",
+  "type": "commonjs",
+  "scripts": {
+    "ts": "w ./src/__lab__/index.ts",
+    "js": "n ./dist/__lab__/index.js",
+    "dev": "tsc --watch",
+    "build": "node ./build.cjs"
+  },
+  "bin": {
+    "ur": "./dist/bin.js",
+    "uni-run": "./dist/bin.js"
+  },
+  "dependencies": {
+    "ansi-colors": "^4.1.3",
+    "chokidar": "^3.6.0",
+    "cross-spawn": "^7.0.3",
+    "ignore": "^5.3.2",
+    "noarg": "^3.0.21"
+  },
+  "devDependencies": {
+    "@types/cross-spawn": "^6.0.6",
+    "typescript": "^5.5.4"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/NazmusSayad/uni-run"
+  }
+}