@simon_he/vue-tui 0.0.8 → 1.0.0

package/dist/path-suggest-BNqcuE3-.js

@@ -0,0 +1,274 @@
+import { dirname, isAbsolutePath, joinPath, normalizePath, resolvePath } from "./path-mnSgEpCm.js";
+
+//#region src/core/path-suggest.ts
+function lower(s) {
+	return s.toLowerCase();
+}
+function normalizePathInputSeparators(input) {
+	let out = "";
+	for (let i = 0; i < input.length; i++) {
+		const ch = input[i];
+		if (ch === "\r") continue;
+		out += ch === "\\" ? "/" : ch;
+	}
+	return out;
+}
+function stripCarriageReturns(input) {
+	let out = "";
+	for (let i = 0; i < input.length; i++) {
+		const ch = input[i];
+		if (ch !== "\r") out += ch;
+	}
+	return out;
+}
+function stripLeadingDotSlash(input) {
+	let i = 0;
+	while (i + 1 < input.length && input.charCodeAt(i) === 46 && input.charCodeAt(i + 1) === 47) i += 2;
+	return i === 0 ? input : input.slice(i);
+}
+function stripLeadingSlashes(input) {
+	let i = 0;
+	while (i < input.length && input.charCodeAt(i) === 47) i++;
+	return i === 0 ? input : input.slice(i);
+}
+function stripTrailingSlashes(input) {
+	let end = input.length;
+	while (end > 0 && input.charCodeAt(end - 1) === 47) end--;
+	return end === input.length ? input : input.slice(0, end);
+}
+function collapseSlashes(input) {
+	let out = "";
+	let previousWasSlash = false;
+	for (let i = 0; i < input.length; i++) {
+		const ch = input[i];
+		const isSlash = ch === "/";
+		if (isSlash) {
+			if (!previousWasSlash) out += "/";
+			previousWasSlash = true;
+			continue;
+		}
+		out += ch;
+		previousWasSlash = false;
+	}
+	return out;
+}
+function normalizeRelativePathForIgnore(input) {
+	return stripTrailingSlashes(collapseSlashes(stripLeadingSlashes(stripLeadingDotSlash(normalizePathInputSeparators(input)))));
+}
+function fuzzyScore(name, query) {
+	const n = lower(name);
+	const q = lower(query);
+	if (!q) return 0;
+	if (n === q) return 2e3;
+	if (n.startsWith(q)) return 1500 - (n.length - q.length);
+	const idx = n.indexOf(q);
+	if (idx >= 0) return 1200 - idx;
+	let ni = 0;
+	let qi = 0;
+	let gaps = 0;
+	let lastMatch = -1;
+	while (ni < n.length && qi < q.length) {
+		if (n[ni] === q[qi]) {
+			if (lastMatch >= 0) gaps += ni - lastMatch - 1;
+			lastMatch = ni;
+			qi++;
+		}
+		ni++;
+	}
+	if (qi !== q.length) return null;
+	const maxGaps = Math.max(4, q.length * 2);
+	if (gaps > maxGaps) return null;
+	return 800 - gaps;
+}
+function parsePathQuery(rawInput) {
+	const input = normalizePathInputSeparators(rawInput);
+	const lastSlash = input.lastIndexOf("/");
+	if (lastSlash < 0) return {
+		dirPrefix: "",
+		query: input
+	};
+	return {
+		dirPrefix: input.slice(0, lastSlash + 1),
+		query: input.slice(lastSlash + 1)
+	};
+}
+async function suggestPaths(options) {
+	const rawWorkspace = String(options.workspaceAbs ?? "");
+	const rawInput = String(options.input ?? "");
+	if (!rawWorkspace || rawWorkspace.includes("\0") || rawInput.includes("\0")) {
+		const safeWorkspaceAbs = normalizePath(rawWorkspace || ".");
+		return {
+			baseDirAbs: resolvePath(safeWorkspaceAbs, "."),
+			dirPrefix: "",
+			query: "",
+			suggestions: []
+		};
+	}
+	const workspaceAbs = normalizePath(rawWorkspace);
+	const input = normalizePathInputSeparators(rawInput);
+	const parsed = parsePathQuery(input);
+	let dirPrefix = parsed.dirPrefix;
+	let query = parsed.query;
+	let baseDirAbs = resolvePath(workspaceAbs, dirPrefix || ".");
+	let maxDepth = options.maxDepth ?? 0;
+	if (!query) maxDepth = 0;
+	const allowHidden = Boolean(options.showHidden);
+	const allowDir = options.mode === "directory" || options.mode === "any" || options.mode === "file";
+	const allowFile = options.mode === "file" || options.mode === "any";
+	const max = Math.max(0, Math.floor(options.max));
+	if (max <= 0) return {
+		baseDirAbs,
+		dirPrefix,
+		query,
+		suggestions: []
+	};
+	const maxDepthClamped = Math.max(0, Math.floor(maxDepth || 0));
+	const keepCapacity = Math.max(500, Math.min(8e3, max * 40));
+	const maxScannedDirs = Math.max(200, Math.min(6e3, 800 + maxDepthClamped * 600));
+	const maxScannedEntries = Math.max(2e3, Math.min(8e4, max * 2e3));
+	const scored = [];
+	let scannedDirs = 0;
+	let scannedEntries = 0;
+	let scanAborted = false;
+	function cmpScored(a, b) {
+		if (a.score !== b.score) return b.score - a.score;
+		if (a.depth !== b.depth) return a.depth - b.depth;
+		return a.name.localeCompare(b.name);
+	}
+	function pruneScored() {
+		if (scored.length <= keepCapacity) return;
+		scored.sort(cmpScored);
+		scored.length = keepCapacity;
+	}
+	function scoreItem(name, relPath, q) {
+		const byName = fuzzyScore(name, q);
+		const byPath = fuzzyScore(relPath, q);
+		if (byName == null && byPath == null) return null;
+		if (byName != null && byPath != null) return Math.max(byName + 50, byPath);
+		return byName ?? byPath;
+	}
+	async function searchDir(dirAbs, currentDepth, currentRelPath, preloadedEntries) {
+		if (scanAborted) return;
+		if (currentDepth > maxDepth) return;
+		if (dirAbs.includes("\0")) {
+			scanAborted = true;
+			return;
+		}
+		scannedDirs++;
+		if (scannedDirs > maxScannedDirs) {
+			scanAborted = true;
+			return;
+		}
+		let entries = [];
+		try {
+			entries = preloadedEntries ?? await options.listDir(dirAbs);
+		} catch {
+			return;
+		}
+		for (const e of entries) {
+			if (scanAborted) return;
+			scannedEntries++;
+			if (scannedEntries > maxScannedEntries) {
+				scanAborted = true;
+				return;
+			}
+			if (!allowHidden && !query && e.name.startsWith(".")) continue;
+			const itemRelPath = currentRelPath ? `${currentRelPath}/${e.name}` : e.name;
+			const normalizedRelPath = normalizeRelativePathForIgnore(`${dirPrefix}${itemRelPath}`);
+			const isDir = e.kind === "directory";
+			if (options.shouldIgnore?.({
+				normalizedRelPath,
+				isDir
+			})) continue;
+			if (e.kind === "directory") {
+				if (!allowDir) continue;
+				const score = scoreItem(e.name, itemRelPath, query);
+				if (score != null) {
+					scored.push({
+						score,
+						name: e.name,
+						kind: "directory",
+						depth: currentDepth,
+						relPath: itemRelPath
+					});
+					if (scored.length > keepCapacity * 2) pruneScored();
+				}
+				await searchDir(`${dirAbs}/${e.name}`, currentDepth + 1, itemRelPath);
+				continue;
+			}
+			if (e.kind === "file") {
+				if (!allowFile) continue;
+				const score = scoreItem(e.name, itemRelPath, query);
+				if (score != null) {
+					scored.push({
+						score,
+						name: e.name,
+						kind: "file",
+						depth: currentDepth,
+						relPath: itemRelPath
+					});
+					if (scored.length > keepCapacity * 2) pruneScored();
+				}
+			}
+		}
+	}
+	let ok = true;
+	let baseEntries = null;
+	try {
+		baseEntries = await options.listDir(baseDirAbs);
+	} catch {
+		ok = false;
+	}
+	if (!ok && dirPrefix) {
+		const fallbackQuery = stripTrailingSlashes(input);
+		dirPrefix = "";
+		query = fallbackQuery;
+		baseDirAbs = workspaceAbs;
+		maxDepth = options.maxDepth ?? 0;
+		if (!query) maxDepth = 0;
+		baseEntries = null;
+	}
+	await searchDir(baseDirAbs, 0, "", baseEntries ?? void 0);
+	pruneScored();
+	scored.sort(cmpScored);
+	const list = max ? scored.slice(0, max) : [];
+	const suggestions = list.map((s) => {
+		const suffix = s.kind === "directory" ? "/" : "";
+		const completion = `${dirPrefix}${s.relPath}${suffix}`;
+		const absPath = resolvePath(workspaceAbs, `${dirPrefix}${s.relPath}`);
+		return {
+			kind: s.kind,
+			display: completion,
+			completion,
+			absPath
+		};
+	});
+	return {
+		baseDirAbs,
+		dirPrefix,
+		query,
+		suggestions
+	};
+}
+function resolveUserPath(workspaceAbs, input, options) {
+	const raw = stripCarriageReturns(input ?? "").trim();
+	if (!raw) return resolvePath(normalizePath(workspaceAbs), ".");
+	if (raw === "~" || raw.startsWith("~/")) {
+		const home = String(options?.homeDir ?? "").trim();
+		if (home) {
+			const rest = raw === "~" ? "" : raw.slice(2);
+			return resolvePath(normalizePath(home), rest);
+		}
+	}
+	const normalized = normalizePathInputSeparators(raw);
+	if (isAbsolutePath(normalized)) return normalizePath(normalized);
+	return resolvePath(normalizePath(workspaceAbs), normalized);
+}
+function suggestParentHint(path) {
+	const p = normalizePath(path);
+	const d = dirname(p);
+	return d ? joinPath(d, "..") : "..";
+}
+
+//#endregion
+export { parsePathQuery, resolveUserPath, suggestParentHint, suggestPaths };

package/dist/path-suggest-Dk9TRLh5.js

@@ -0,0 +1,3 @@
+import { parsePathQuery, resolveUserPath, suggestPaths } from "./path-suggest-bvR9SY6Q.js";
+
+export { resolveUserPath, suggestPaths };

package/dist/{path-suggest-DmrmeueH.js → path-suggest-bvR9SY6Q.js}

@@ -1,19 +1,34 @@
-import process from "node:process";
+//#region src/cli/node-module.ts
+function isNodeRuntime() {
+	var _proc$versions;
+	const proc = globalThis.process;
+	return typeof (proc === null || proc === void 0 || (_proc$versions = proc.versions) === null || _proc$versions === void 0 ? void 0 : _proc$versions.node) === "string";
+}
+function importNodeModule(specifier) {
+	if (!isNodeRuntime()) return Promise.resolve(null);
+	try {
+		const dynamicImport = new Function("specifier", "return import(specifier)");
+		return dynamicImport(specifier).catch(() => null);
+	} catch {
+		return Promise.resolve(null);
+	}
+}
 
+//#endregion
 //#region src/utils/path.ts
 function normalizeSeparators(input) {
-	return input.replace(/\\/g, "/");
+	let out = "";
+	for (let i = 0; i < input.length; i++) {
+		const ch = input[i];
+		out += ch === "\\" ? "/" : ch;
+	}
+	return out;
 }
 function isAbsolutePath(path) {
 	const p = normalizeSeparators(path);
 	if (p.startsWith("/")) return true;
 	return /^[A-Z]:\//i.test(p);
 }
-function stripTrailingSlash(path) {
-	const p = normalizeSeparators(path);
-	if (p === "/") return p;
-	return p.replace(/\/+$/g, "");
-}
 function joinPath(base, next) {
 	const a = normalizeSeparators(base);
 	const b = normalizeSeparators(next);
@@ -57,10 +72,61 @@ function resolvePath(baseAbs, input) {
 }
 
 //#endregion
-//#region src/cli/path-suggest-core.ts
+//#region src/core/path-suggest.ts
 function lower(s) {
 	return s.toLowerCase();
 }
+function normalizePathInputSeparators(input) {
+	let out = "";
+	for (let i = 0; i < input.length; i++) {
+		const ch = input[i];
+		if (ch === "\r") continue;
+		out += ch === "\\" ? "/" : ch;
+	}
+	return out;
+}
+function stripCarriageReturns(input) {
+	let out = "";
+	for (let i = 0; i < input.length; i++) {
+		const ch = input[i];
+		if (ch !== "\r") out += ch;
+	}
+	return out;
+}
+function stripLeadingDotSlash(input) {
+	let i = 0;
+	while (i + 1 < input.length && input.charCodeAt(i) === 46 && input.charCodeAt(i + 1) === 47) i += 2;
+	return i === 0 ? input : input.slice(i);
+}
+function stripLeadingSlashes(input) {
+	let i = 0;
+	while (i < input.length && input.charCodeAt(i) === 47) i++;
+	return i === 0 ? input : input.slice(i);
+}
+function stripTrailingSlashes(input) {
+	let end = input.length;
+	while (end > 0 && input.charCodeAt(end - 1) === 47) end--;
+	return end === input.length ? input : input.slice(0, end);
+}
+function collapseSlashes(input) {
+	let out = "";
+	let previousWasSlash = false;
+	for (let i = 0; i < input.length; i++) {
+		const ch = input[i];
+		const isSlash = ch === "/";
+		if (isSlash) {
+			if (!previousWasSlash) out += "/";
+			previousWasSlash = true;
+			continue;
+		}
+		out += ch;
+		previousWasSlash = false;
+	}
+	return out;
+}
+function normalizeRelativePathForIgnore(input) {
+	return stripTrailingSlashes(collapseSlashes(stripLeadingSlashes(stripLeadingDotSlash(normalizePathInputSeparators(input)))));
+}
 function fuzzyScore(name, query) {
 	const n = lower(name);
 	const q = lower(query);
@@ -87,7 +153,7 @@ function fuzzyScore(name, query) {
 	return 800 - gaps;
 }
 function parsePathQuery(rawInput) {
-	const input = rawInput.replace(/\\/g, "/");
+	const input = normalizePathInputSeparators(rawInput);
 	const lastSlash = input.lastIndexOf("/");
 	if (lastSlash < 0) return {
 		dirPrefix: "",
@@ -111,7 +177,7 @@ async function suggestPaths$1(options) {
 		};
 	}
 	const workspaceAbs = normalizePath(rawWorkspace);
-	const input = rawInput.replace(/\r/g, "").replace(/\\/g, "/");
+	const input = normalizePathInputSeparators(rawInput);
 	const parsed = parsePathQuery(input);
 	let dirPrefix = parsed.dirPrefix;
 	let query = parsed.query;
@@ -181,7 +247,7 @@ async function suggestPaths$1(options) {
 			}
 			if (!allowHidden && !query && e.name.startsWith(".")) continue;
 			const itemRelPath = currentRelPath ? `${currentRelPath}/${e.name}` : e.name;
-			const normalizedRelPath = String(`${dirPrefix}${itemRelPath}`).replace(/\r/g, "").replace(/\\/g, "/").replace(/^(?:\.\/)+/g, "").replace(/^\/+/g, "").replace(/\/+/g, "/").replace(/\/+$/g, "");
+			const normalizedRelPath = normalizeRelativePathForIgnore(`${dirPrefix}${itemRelPath}`);
 			const isDir = e.kind === "directory";
 			if ((_options$shouldIgnore = options.shouldIgnore) === null || _options$shouldIgnore === void 0 ? void 0 : _options$shouldIgnore.call(options, {
 				normalizedRelPath,
@@ -227,7 +293,7 @@ async function suggestPaths$1(options) {
 		ok = false;
 	}
 	if (!ok && dirPrefix) {
-		const fallbackQuery = input.replace(/\/+$/g, "");
+		const fallbackQuery = stripTrailingSlashes(input);
 		dirPrefix = "";
 		query = fallbackQuery;
 		baseDirAbs = workspaceAbs;
@@ -258,7 +324,7 @@ async function suggestPaths$1(options) {
 	};
 }
 function resolveUserPath$1(workspaceAbs, input, options) {
-	const raw = (input ?? "").replace(/\r/g, "").trim();
+	const raw = stripCarriageReturns(input ?? "").trim();
 	if (!raw) return resolvePath(normalizePath(workspaceAbs), ".");
 	if (raw === "~" || raw.startsWith("~/")) {
 		const home = String((options === null || options === void 0 ? void 0 : options.homeDir) ?? "").trim();
@@ -267,7 +333,7 @@ function resolveUserPath$1(workspaceAbs, input, options) {
 			return resolvePath(normalizePath(home), rest);
 		}
 	}
-	const normalized = raw.replace(/\\/g, "/");
+	const normalized = normalizePathInputSeparators(raw);
 	if (isAbsolutePath(normalized)) return normalizePath(normalized);
 	return resolvePath(normalizePath(workspaceAbs), normalized);
 }
@@ -286,7 +352,7 @@ const gitignoreRulesCache = new Map();
 const gitignoreRulesLoading = new Map();
 function isNodeLike() {
 	var _proc$versions;
-	const proc = process;
+	const proc = globalThis.process;
 	return typeof (proc === null || proc === void 0 || (_proc$versions = proc.versions) === null || _proc$versions === void 0 ? void 0 : _proc$versions.node) === "string";
 }
 function loadGitignoreRulesAsync(workspaceAbs) {
@@ -294,7 +360,8 @@ function loadGitignoreRulesAsync(workspaceAbs) {
 	return (async () => {
 		if (!isNodeLike()) return EMPTY_GITIGNORE_RULES;
 		try {
-			const fs = await import("node:fs/promises");
+			const fs = await importNodeModule("node:fs/promises");
+			if (!fs) return EMPTY_GITIGNORE_RULES;
 			const gitignoreAbs = resolvePath(key, ".gitignore");
 			const content = await fs.readFile(gitignoreAbs, "utf8");
 			return compileGitignoreRules(content);
@@ -465,9 +532,10 @@ async function suggestPaths(options) {
 	});
 }
 function resolveUserPath(workspaceAbs, input) {
-	const env = (process === null || process === void 0 ? void 0 : process.env) ?? {};
+	var _process;
+	const env = ((_process = globalThis.process) === null || _process === void 0 ? void 0 : _process.env) ?? {};
 	return resolveUserPath$1(workspaceAbs, input, { homeDir: String(env.HOME || env.USERPROFILE || "") });
 }
 
 //#endregion
-export { isAbsolutePath, normalizePath, parsePathQuery, resolvePath, resolveUserPath, resolveUserPath$1, stripTrailingSlash, suggestPaths, suggestPaths$1 };
+export { importNodeModule, isAbsolutePath, normalizePath, parsePathQuery, resolvePath, resolveUserPath, suggestPaths };

package/dist/renderer/capabilities.d.ts

@@ -0,0 +1,13 @@
+export type RendererCapabilities = Readonly<{
+    syncFlush: boolean;
+    scrollOperations: boolean;
+    domRows: boolean;
+}>;
+export type TerminalRendererLike = Readonly<{
+    capabilities: RendererCapabilities;
+    container?: HTMLElement;
+    debugStats?: unknown;
+}>;
+export declare const DOM_RENDERER_CAPABILITIES: RendererCapabilities;
+export declare const HEADLESS_RENDERER_CAPABILITIES: RendererCapabilities;
+export declare const STDOUT_RENDERER_CAPABILITIES: RendererCapabilities;

package/dist/renderer/cli/index.d.ts

@@ -0,0 +1,2 @@
+export type { StdoutRenderer } from "./stdout-renderer.js";
+export { createStdoutRenderer } from "./stdout-renderer.js";

package/dist/renderer/cli/stdout-metrics.d.ts

@@ -0,0 +1,18 @@
+export type StdoutRendererWriteMode = "stream" | "sync" | "chunked";
+export interface StdoutRendererMetrics {
+    lastFrameAt: number;
+    lastFrameBytes: number;
+    lastWriteMs: number;
+    writeEmaMs: number;
+    writeMode: StdoutRendererWriteMode;
+    fps: number;
+    bytesPerSec: number;
+}
+export declare function getStdoutRendererMetrics(): StdoutRendererMetrics;
+export declare function recordStdoutFrame(info: Readonly<{
+    at: number;
+    bytes: number;
+    writeMs: number;
+    writeEmaMs: number;
+    writeMode: StdoutRendererWriteMode;
+}>): void;

package/dist/renderer/cli/stdout-renderer.d.ts

@@ -0,0 +1,48 @@
+import type { Terminal } from "../../core/types.js";
+import type { RendererCapabilities } from "../capabilities.js";
+import type { ThemePalette } from "../../core/ansi-palette.js";
+export type CliOutput = Readonly<{
+    write: (chunk: string) => unknown;
+    isTTY?: boolean;
+}>;
+export type StdoutRenderer = Readonly<{
+    capabilities: RendererCapabilities;
+    render: () => void;
+    dispose: () => void;
+    /** Move terminal cursor to specified cell position for IME input */
+    setCursor: (x: number, y: number) => void;
+    /** Show or hide the terminal cursor */
+    showCursor: (visible: boolean) => void;
+    /** Update default background without recreating the renderer. */
+    updateTheme?: (next: Readonly<{
+        defaultBg?: string | null;
+        palette?: ThemePalette | null;
+    }>) => void;
+}>;
+export type StdoutColorMode = "auto" | "truecolor" | "ansi256" | "ansi16" | "ansi8";
+export type { ThemePalette } from "../../core/ansi-palette.js";
+export declare function createStdoutRenderer(terminal: Terminal, options?: Readonly<{
+    output?: CliOutput;
+    clear?: boolean;
+    hideCursor?: boolean;
+    altScreen?: boolean;
+    /** Fallback background color when a cell has no explicit bg. `null` = transparent (terminal default). */
+    defaultBg?: string | null;
+    /** Optional ANSI-name palette used when emitting ansi256/truecolor sequences. */
+    palette?: ThemePalette | null;
+    /** Track TTY resize events (process.stdout 'resize') and call terminal.resize(). */
+    trackResize?: boolean;
+    /** Color mode for ANSI output (auto detects truecolor via env). */
+    colorMode?: StdoutColorMode;
+    /** Optional function to get IME cursor position, included in render output for atomic write */
+    getImeAnchor?: () => {
+        cellX: number;
+        cellY: number;
+    } | null;
+    /** Use DEC 2026 synchronized output mode (default: false for compatibility) */
+    useSyncOutput?: boolean;
+    allowFileUrls?: boolean;
+    profileFileWriter?: {
+        appendFileSync?: (path: string, data: string) => void;
+    };
+}>): StdoutRenderer;