evolcore 0.0.9 → 0.0.11

package/dist/cli/init-cancel.js

@@ -0,0 +1,208 @@
+import { setupRawKeyListener } from './raw-key-input.js';
+const ESC = '\u001b';
+const ANSI_SEQUENCE_TIMEOUT_MS = 40;
+export const INIT_DOUBLE_ESCAPE_WINDOW_MS = 500;
+export class InitCancelledError extends Error {
+    constructor() {
+        super('EvolCore init cancelled');
+        this.name = 'InitCancelledError';
+    }
+}
+export function isInitCancelledError(error) {
+    return error instanceof InitCancelledError || (error instanceof Error && error.name === 'InitCancelledError');
+}
+export function printInitCancelHint() {
+    if (process.stdin.isTTY) {
+        console.log('提示：任意步骤连续按两次 Esc 退出（Ctrl+C 也可退出）\n');
+    }
+}
+function isAnsiFinalByte(char) {
+    const code = char.charCodeAt(0);
+    return code >= 0x40 && code <= 0x7e;
+}
+/**
+ * Detect two standalone Escape presses without treating arrow/function-key
+ * escape sequences as Escape presses.
+ */
+export function createDoubleEscapeDetector(onDoubleEscape, windowMs = INIT_DOUBLE_ESCAPE_WINDOW_MS) {
+    let pendingBareEscape = false;
+    let pendingTimer;
+    let lastBareEscapeAt = 0;
+    let ansiSequence = '';
+    let disposed = false;
+    let triggered = false;
+    const clearPending = () => {
+        if (pendingTimer)
+            clearTimeout(pendingTimer);
+        pendingTimer = undefined;
+        pendingBareEscape = false;
+    };
+    const registerBareEscape = () => {
+        if (disposed || triggered)
+            return;
+        const now = Date.now();
+        if (lastBareEscapeAt > 0 && now - lastBareEscapeAt <= windowMs) {
+            lastBareEscapeAt = 0;
+            triggered = true;
+            onDoubleEscape();
+            return;
+        }
+        lastBareEscapeAt = now;
+    };
+    const scheduleBareEscape = () => {
+        clearPending();
+        pendingBareEscape = true;
+        pendingTimer = setTimeout(() => {
+            pendingTimer = undefined;
+            pendingBareEscape = false;
+            registerBareEscape();
+        }, ANSI_SEQUENCE_TIMEOUT_MS);
+    };
+    const handle = (chunk) => {
+        if (disposed)
+            return;
+        const text = String(chunk);
+        for (let index = 0; index < text.length; index++) {
+            const char = text[index];
+            if (ansiSequence) {
+                lastBareEscapeAt = 0;
+                ansiSequence += char;
+                if (ansiSequence.length === 2 && ansiSequence[1] !== '[' && ansiSequence[1] !== 'O') {
+                    ansiSequence = '';
+                }
+                else if (ansiSequence.length >= 2 && isAnsiFinalByte(char)) {
+                    ansiSequence = '';
+                }
+                continue;
+            }
+            if (pendingBareEscape) {
+                clearPending();
+                if (char === ESC) {
+                    registerBareEscape();
+                    registerBareEscape();
+                }
+                else if (char === '[' || char === 'O') {
+                    lastBareEscapeAt = 0;
+                    ansiSequence = `${ESC}${char}`;
+                }
+                else {
+                    lastBareEscapeAt = 0;
+                }
+                continue;
+            }
+            if (char !== ESC) {
+                lastBareEscapeAt = 0;
+                continue;
+            }
+            const next = text[index + 1];
+            if (next === ESC) {
+                registerBareEscape();
+                registerBareEscape();
+                index++;
+            }
+            else if (next === '[' || next === 'O') {
+                lastBareEscapeAt = 0;
+                ansiSequence = `${ESC}${next}`;
+                index++;
+            }
+            else if (next !== undefined) {
+                lastBareEscapeAt = 0;
+                index++;
+            }
+            else {
+                scheduleBareEscape();
+            }
+        }
+    };
+    return {
+        handle,
+        dispose: () => {
+            disposed = true;
+            clearPending();
+            ansiSequence = '';
+        },
+    };
+}
+export function setupDoubleEscapeListener(onDoubleEscape, input = process.stdin) {
+    if (!input || typeof input.on !== 'function' || typeof input.removeListener !== 'function')
+        return () => { };
+    const detector = createDoubleEscapeDetector(onDoubleEscape);
+    const handler = (chunk) => detector.handle(chunk);
+    input.on('data', handler);
+    return () => {
+        input.removeListener('data', handler);
+        detector.dispose();
+    };
+}
+export function setupInitRawKeyListener(onKey, onDoubleEscape, input = process.stdin) {
+    const detector = createDoubleEscapeDetector(onDoubleEscape);
+    const cleanupRaw = setupRawKeyListener(key => {
+        detector.handle(key);
+        onKey(key);
+    }, input);
+    return () => {
+        cleanupRaw();
+        detector.dispose();
+    };
+}
+/** readline.question with the shared double-Escape cancellation behavior. */
+export function askInit(rl, question) {
+    return new Promise((resolve, reject) => {
+        let settled = false;
+        const input = rl.input;
+        let cleanupInput = () => { };
+        const cleanup = () => {
+            cleanupInput();
+            rl.removeListener('SIGINT', cancel);
+        };
+        const cancel = () => {
+            if (settled)
+                return;
+            settled = true;
+            cleanup();
+            try {
+                rl.close();
+            }
+            catch { /* ignore */ }
+            try {
+                input?.pause?.();
+            }
+            catch { /* ignore */ }
+            reject(new InitCancelledError());
+        };
+        cleanupInput = setupDoubleEscapeListener(cancel, input);
+        rl.once('SIGINT', cancel);
+        try {
+            rl.question(question, answer => {
+                if (settled)
+                    return;
+                settled = true;
+                cleanup();
+                resolve(answer);
+            });
+        }
+        catch (error) {
+            if (!settled) {
+                settled = true;
+                cleanup();
+                reject(error);
+            }
+        }
+    });
+}
+export function waitForInitDelay(ms, signal) {
+    if (signal?.aborted)
+        return Promise.reject(new InitCancelledError());
+    return new Promise((resolve, reject) => {
+        const onAbort = () => {
+            clearTimeout(timer);
+            signal?.removeEventListener('abort', onAbort);
+            reject(new InitCancelledError());
+        };
+        const timer = setTimeout(() => {
+            signal?.removeEventListener('abort', onAbort);
+            resolve();
+        }, ms);
+        signal?.addEventListener('abort', onAbort, { once: true });
+    });
+}