genomic 0.0.1 → 4.0.1

package/commander.d.ts

@@ -0,0 +1,21 @@
+import { Opts, ParsedArgs } from 'minimist';
+import { Readable, Writable } from 'stream';
+import { Prompter } from './prompt';
+export type CommandHandler = (argv: ParsedArgs, prompter: Prompter, options: CLIOptions) => void;
+export interface CLIOptions {
+    noTty: boolean;
+    input: Readable;
+    output: Writable;
+    minimistOpts: Opts;
+    version: string;
+}
+export declare const defaultCLIOptions: CLIOptions;
+export declare class CLI {
+    private argv;
+    private prompter;
+    private commandHandler;
+    private options;
+    constructor(commandHandler: CommandHandler, options: Partial<CLIOptions>, argv?: any);
+    run(): Promise<void>;
+}
+export default CLI;

package/commander.js

@@ -0,0 +1,57 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CLI = exports.defaultCLIOptions = void 0;
+const deepmerge_1 = __importDefault(require("deepmerge"));
+const minimist_1 = __importDefault(require("minimist"));
+const prompt_1 = require("./prompt");
+const utils_1 = require("./utils");
+exports.defaultCLIOptions = {
+    version: `genomic@${(0, utils_1.getVersion)()}`,
+    noTty: false,
+    input: process.stdin,
+    output: process.stdout,
+    minimistOpts: {
+        alias: {
+            v: 'version'
+        }
+    }
+};
+class CLI {
+    argv;
+    prompter;
+    commandHandler;
+    options;
+    constructor(commandHandler, options, argv) {
+        const { input, output, ...optionsWithoutIO } = options;
+        const { input: defaultInput, output: defaultOutput, ...defaultOptionsWithoutIO } = exports.defaultCLIOptions;
+        const mergedOptions = (0, deepmerge_1.default)(defaultOptionsWithoutIO, optionsWithoutIO);
+        mergedOptions.input = input || defaultInput;
+        mergedOptions.output = output || defaultOutput;
+        this.options = mergedOptions;
+        this.argv = argv ? argv : (0, minimist_1.default)(process.argv.slice(2), this.options.minimistOpts);
+        this.prompter = new prompt_1.Prompter({
+            noTty: this.options.noTty,
+            input: this.options.input,
+            output: this.options.output
+        });
+        this.commandHandler = commandHandler;
+    }
+    async run() {
+        if (!('tty' in this.argv)) {
+            this.argv.tty = true;
+        }
+        if (this.argv.version) {
+            console.log(this.options.version);
+            process.exit(0);
+        }
+        const args = await this.commandHandler(this.argv, this.prompter, this.options);
+        // this.prompter.exit();
+        this.prompter.close();
+        return args;
+    }
+}
+exports.CLI = CLI;
+exports.default = CLI;

package/esm/commander.js

@@ -0,0 +1,50 @@
+import deepmerge from 'deepmerge';
+import minimist from 'minimist';
+import { Prompter } from './prompt';
+import { getVersion } from './utils';
+export const defaultCLIOptions = {
+    version: `genomic@${getVersion()}`,
+    noTty: false,
+    input: process.stdin,
+    output: process.stdout,
+    minimistOpts: {
+        alias: {
+            v: 'version'
+        }
+    }
+};
+export class CLI {
+    argv;
+    prompter;
+    commandHandler;
+    options;
+    constructor(commandHandler, options, argv) {
+        const { input, output, ...optionsWithoutIO } = options;
+        const { input: defaultInput, output: defaultOutput, ...defaultOptionsWithoutIO } = defaultCLIOptions;
+        const mergedOptions = deepmerge(defaultOptionsWithoutIO, optionsWithoutIO);
+        mergedOptions.input = input || defaultInput;
+        mergedOptions.output = output || defaultOutput;
+        this.options = mergedOptions;
+        this.argv = argv ? argv : minimist(process.argv.slice(2), this.options.minimistOpts);
+        this.prompter = new Prompter({
+            noTty: this.options.noTty,
+            input: this.options.input,
+            output: this.options.output
+        });
+        this.commandHandler = commandHandler;
+    }
+    async run() {
+        if (!('tty' in this.argv)) {
+            this.argv.tty = true;
+        }
+        if (this.argv.version) {
+            console.log(this.options.version);
+            process.exit(0);
+        }
+        const args = await this.commandHandler(this.argv, this.prompter, this.options);
+        // this.prompter.exit();
+        this.prompter.close();
+        return args;
+    }
+}
+export default CLI;

package/esm/index.js

@@ -0,0 +1,4 @@
+export * from './commander';
+export * from './prompt';
+export * from './question';
+export * from './resolvers';

package/esm/keypress.js

@@ -0,0 +1,95 @@
+const defaultProcessWrapper = {
+    exit: (code) => process.exit(code)
+};
+export const KEY_CODES = {
+    UP_ARROW: '\u001b[A',
+    DOWN_ARROW: '\u001b[B',
+    RIGHT_ARROW: '\u001b[C',
+    LEFT_ARROW: '\u001b[D',
+    ENTER: '\r',
+    SPACE: ' ',
+    CTRL_C: '\u0003',
+    BACKSPACE: '\x7f', // Commonly used BACKSPACE key in Unix-like systems
+    BACKSPACE_LEGACY: '\x08' // For compatibility with some systems
+};
+/**
+ * Handles keyboard input for interactive prompts.
+ *
+ * **Important**: Only one TerminalKeypress instance should be actively listening
+ * on a given input stream at a time. If you need multiple Prompter instances,
+ * call `close()` on the first instance before using the second, or reuse a single
+ * instance for all prompts.
+ *
+ * Multiple instances sharing the same input stream (e.g., process.stdin) will
+ * each receive all keypresses, which can cause duplicate or unexpected behavior.
+ */
+export class TerminalKeypress {
+    listeners = {};
+    active = true;
+    noTty;
+    input;
+    proc;
+    dataHandler = null;
+    constructor(noTty = false, input = process.stdin, proc = defaultProcessWrapper) {
+        this.noTty = noTty;
+        this.input = input;
+        this.proc = proc;
+        if (this.isTTY()) {
+            this.input.resume();
+            this.input.setEncoding('utf8');
+        }
+        this.setupListeners();
+    }
+    isTTY() {
+        return !this.noTty;
+    }
+    setupListeners() {
+        this.dataHandler = (key) => {
+            if (!this.active)
+                return;
+            const handlers = this.listeners[key];
+            handlers?.forEach(handler => handler());
+            if (key === KEY_CODES.CTRL_C) {
+                this.proc.exit(0);
+            }
+        };
+        this.input.on('data', this.dataHandler);
+    }
+    on(key, callback) {
+        if (!this.listeners[key]) {
+            this.listeners[key] = [];
+        }
+        this.listeners[key].push(callback);
+    }
+    off(key, callback) {
+        if (this.listeners[key]) {
+            const index = this.listeners[key].indexOf(callback);
+            if (index !== -1) {
+                this.listeners[key].splice(index, 1);
+            }
+        }
+    }
+    clearHandlers() {
+        this.listeners = {};
+    }
+    pause() {
+        this.active = false;
+        this.clearHandlers();
+    }
+    resume() {
+        this.active = true;
+        if (this.isTTY() && typeof this.input.setRawMode === 'function') {
+            this.input.setRawMode(true);
+        }
+    }
+    destroy() {
+        if (typeof this.input.setRawMode === 'function') {
+            this.input.setRawMode(false);
+        }
+        this.input.pause();
+        if (this.dataHandler) {
+            this.input.removeListener('data', this.dataHandler);
+            this.dataHandler = null;
+        }
+    }
+}