@zaly/tui 0.0.4

package/dist/picker-ndVVt6qF.mjs

@@ -0,0 +1,621 @@
+import { S as unwrap, f as effect, h as memo, s as createProgressive, x as untrack } from "./reactive-f7NpAi69.mjs";
+import { widget } from "./widgets/widget.mjs";
+import { Input } from "./widgets/input.mjs";
+import { select } from "./widgets/select.mjs";
+import { tree } from "./widgets/tree.mjs";
+import { sliceAnsi, stripAnsi } from "@zaly/shared/ansi";
+import { TopK } from "@zaly/shared/minheap";
+//#region src/search/score.ts
+const SCORE_MATCH = 16;
+const SCORE_GAP_START = -3;
+const SCORE_GAP_EXTENSION = -1;
+const BONUS_BOUNDARY = SCORE_MATCH / 2;
+const BONUS_NONWORD = SCORE_MATCH / 2;
+const BONUS_CAMEL_123 = BONUS_BOUNDARY - 1;
+const BONUS_CONSECUTIVE = 4;
+const BONUS_FIRST_CHAR_MULTIPLIER = 2;
+const BONUS_NO_PATH_SEP = BONUS_BOUNDARY - 2;
+const CHAR_WHITE = 0;
+const CHAR_NONWORD = 1;
+const CHAR_DELIMITER = 2;
+const CHAR_LOWER = 3;
+const CHAR_UPPER = 4;
+const CHAR_LETTER = 5;
+const CHAR_NUMBER = 6;
+const PATH_SEPS = /* @__PURE__ */ new Set(["/", "\\"]);
+const CHAR_CLASS = Array.from({ length: 256 }, (_, b) => {
+	const ch = String.fromCharCode(b);
+	if (/\s/.test(ch)) return CHAR_WHITE;
+	if (String.raw`/\,:;|`.includes(ch)) return CHAR_DELIMITER;
+	if (b >= 48 && b <= 57) return CHAR_NUMBER;
+	if (b >= 65 && b <= 90) return CHAR_UPPER;
+	if (b >= 97 && b <= 122) return CHAR_LOWER;
+	return CHAR_NONWORD;
+});
+function charClass(str, pos) {
+	const code = str.charCodeAt(pos);
+	return code <= 255 ? CHAR_CLASS[code] ?? CHAR_NONWORD : CHAR_LETTER;
+}
+var Score = class {
+	#opts;
+	#bonusMatrix = [];
+	#bonusBoundaryWhite;
+	#bonusBoundaryDelimiter;
+	#consecutive = 0;
+	#firstBonus = 0;
+	#prev;
+	#prevClass = CHAR_WHITE;
+	#score = 0;
+	#str = "";
+	isFile = false;
+	constructor(opts = {}) {
+		this.#opts = opts;
+		this.#bonusBoundaryWhite = opts.historyBonus ? BONUS_BOUNDARY : 10;
+		this.#bonusBoundaryDelimiter = opts.historyBonus ? BONUS_BOUNDARY : 9;
+		for (let prev = 0; prev <= 6; prev++) {
+			this.#bonusMatrix[prev] = [];
+			for (let curr = 0; curr <= 6; curr++) this.#bonusMatrix[prev][curr] = this.#computeBonus(prev, curr);
+		}
+	}
+	get score() {
+		return this.#score;
+	}
+	isLeftBoundary(str, pos) {
+		return pos === 0 || charClass(str, pos - 1) < CHAR_LOWER;
+	}
+	isRightBoundary(str, pos) {
+		return pos === str.length - 1 || charClass(str, pos + 1) < CHAR_LOWER;
+	}
+	init(str, first) {
+		this.#str = str;
+		this.#score = 0;
+		this.#consecutive = 0;
+		this.#prevClass = first > 0 ? charClass(str, first - 1) : CHAR_WHITE;
+		this.#prev = void 0;
+		this.#firstBonus = 0;
+		if (this.isFile && this.#opts.filenameBonus && !hasPathSepAfter(str, first)) this.#score += BONUS_NO_PATH_SEP;
+		this.update(first);
+	}
+	update(pos) {
+		const cls = charClass(this.#str, pos);
+		const gap = this.#prev === void 0 ? 0 : pos - this.#prev - 1;
+		let bonus = 0;
+		if (gap > 0) {
+			this.#prevClass = charClass(this.#str, pos - 1);
+			bonus = this.#bonusMatrix[this.#prevClass]?.[cls] ?? 0;
+			this.#score += SCORE_GAP_START + (gap - 1) * SCORE_GAP_EXTENSION;
+			this.#consecutive = 0;
+			this.#firstBonus = 0;
+		} else {
+			bonus = this.#bonusMatrix[this.#prevClass]?.[cls] ?? 0;
+			if (this.#consecutive === 0) this.#firstBonus = bonus;
+			else {
+				if (bonus >= BONUS_BOUNDARY && bonus > this.#firstBonus) this.#firstBonus = bonus;
+				bonus = Math.max(bonus, this.#firstBonus, BONUS_CONSECUTIVE);
+			}
+			this.#consecutive++;
+		}
+		if (this.#prev === void 0) bonus *= BONUS_FIRST_CHAR_MULTIPLIER;
+		this.#score += SCORE_MATCH + bonus;
+		this.#prevClass = cls;
+		this.#prev = pos;
+	}
+	get(str, from, to) {
+		this.init(str, from);
+		for (let i = from + 1; i <= to; i++) this.update(i);
+		return this.#score;
+	}
+	#computeBonus(prev, curr) {
+		if (curr > CHAR_NONWORD) {
+			if (prev === CHAR_WHITE) return this.#bonusBoundaryWhite;
+			if (prev === CHAR_DELIMITER) return this.#bonusBoundaryDelimiter;
+			if (prev === CHAR_NONWORD) return BONUS_BOUNDARY;
+		}
+		if (prev === CHAR_LOWER && curr === CHAR_UPPER || prev !== CHAR_NUMBER && curr === CHAR_NUMBER) return BONUS_CAMEL_123;
+		if (curr === CHAR_NONWORD || curr === CHAR_DELIMITER) return BONUS_NONWORD;
+		if (curr === CHAR_WHITE) return 10;
+		return 0;
+	}
+};
+function hasPathSepAfter(str, first) {
+	for (let i = first + 1; i < str.length; i++) if (PATH_SEPS.has(str[i])) return true;
+	return false;
+}
+//#endregion
+//#region src/search/matcher.ts
+var Matcher = class {
+	opts;
+	score;
+	mods = [];
+	one;
+	pattern = "";
+	tick = 0;
+	constructor(opts = {}) {
+		this.opts = {
+			fuzzy: true,
+			ignorecase: true,
+			smartcase: true,
+			...opts
+		};
+		this.score = new Score(opts);
+	}
+	empty() {
+		return this.mods.length === 0;
+	}
+	init(pattern) {
+		pattern = pattern.trim();
+		if (pattern === this.pattern) return false;
+		this.pattern = pattern;
+		this.tick++;
+		this.mods = [];
+		this.one = void 0;
+		if (pattern === "") return true;
+		if (this.opts.regex) this.mods = [[this.#prepare(pattern)]];
+		else {
+			let isOr = false;
+			for (const part of pattern.split(/ +/)) {
+				if (part === "|") {
+					isOr = true;
+					continue;
+				}
+				const mod = this.#prepare(part);
+				if (mod.pattern === "") continue;
+				if (isOr && this.mods.length > 0) this.mods.at(-1)?.push(mod);
+				else this.mods.push([mod]);
+				isOr = false;
+			}
+		}
+		this.mods = this.mods.map((ors) => ors.toSorted((a, b) => a.entropy - b.entropy));
+		this.mods = this.mods.toSorted((a, b) => (b[0]?.entropy ?? 0) - (a[0]?.entropy ?? 0));
+		if (this.mods.length === 1 && this.mods[0]?.length === 1) this.one = this.mods[0][0];
+		return true;
+	}
+	match(input) {
+		if (this.empty()) return 1e3;
+		const item = typeof input === "string" ? { text: input } : input;
+		if (this.one) return this.#match(item, this.one)?.score ?? 0;
+		let score = 0;
+		for (const any of this.mods) {
+			let match;
+			for (const mod of any) {
+				match = this.#match(item, mod);
+				if (match) break;
+			}
+			if (!match) return 0;
+			score += match.score;
+		}
+		return score;
+	}
+	update(item) {
+		const score = this.match(item);
+		const it = item;
+		it.score = score;
+		return it;
+	}
+	positions(input) {
+		if (this.empty()) return [];
+		const item = typeof input === "string" ? { text: input } : input;
+		const ret = [];
+		const all = this.mods.flat();
+		for (const mod of all) {
+			const match = this.#match(item, mod);
+			if (!match) continue;
+			if (mod.fuzzy) ret.push(...this.#fuzzyPositions(match.search, mod.chars, match.from));
+			else for (let i = match.from; i <= match.to; i++) ret.push(i);
+		}
+		return [...new Set(ret)].toSorted((a, b) => a - b);
+	}
+	fields() {
+		const ret = /* @__PURE__ */ new Set();
+		for (const mod of this.mods.flat()) ret.add(mod.field ?? "text");
+		return [...ret];
+	}
+	#prepare(pattern) {
+		const mod = {
+			chars: [],
+			entropy: 0,
+			pattern
+		};
+		if (this.opts.regex) {
+			mod.regex = true;
+			const isLower = mod.pattern.toLowerCase() === mod.pattern;
+			mod.ignorecase = this.opts.smartcase ? isLower : this.opts.ignorecase;
+			try {
+				mod.re = new RegExp(mod.pattern, mod.ignorecase ? "i" : void 0);
+			} catch {
+				mod.re = void 0;
+			}
+		} else {
+			const file = parseFilePattern(pattern);
+			if (file) {
+				mod.field = "file";
+				mod.pattern = `${file}$`;
+			}
+			const field = mod.pattern.match(/^([\w_][\w_]+):(.*)$/);
+			if (field) {
+				mod.field = field[1];
+				mod.pattern = field[2];
+			}
+			mod.ignorecase = this.opts.ignorecase;
+			const isLower = mod.pattern.toLowerCase() === mod.pattern;
+			if (this.opts.smartcase) mod.ignorecase = isLower;
+			mod.fuzzy = this.opts.fuzzy;
+			if (!mod.fuzzy) mod.entropy += 10;
+			if (mod.pattern.startsWith("!")) {
+				mod.fuzzy = false;
+				mod.inverse = true;
+				mod.pattern = mod.pattern.slice(1);
+				mod.entropy -= 1;
+			}
+			if (mod.pattern.startsWith("'")) {
+				mod.fuzzy = false;
+				mod.pattern = mod.pattern.slice(1);
+				mod.entropy += 10;
+				if (mod.pattern.endsWith("'")) {
+					mod.word = true;
+					mod.pattern = mod.pattern.slice(0, -1);
+					mod.entropy += 10;
+				}
+			} else if (mod.pattern.startsWith("^")) {
+				mod.fuzzy = false;
+				mod.exactPrefix = true;
+				mod.pattern = mod.pattern.slice(1);
+				mod.entropy += 20;
+			}
+			if (mod.pattern.endsWith("$")) {
+				mod.fuzzy = false;
+				mod.exactSuffix = true;
+				mod.pattern = mod.pattern.slice(0, -1);
+				mod.entropy += 20;
+			}
+			const rareChars = (mod.pattern.match(/[^\w\s]/g) ?? []).length;
+			mod.entropy += Math.min(mod.pattern.length, 20) + rareChars * 2;
+			if (!mod.ignorecase && !isLower) mod.entropy *= 2;
+			if (mod.ignorecase) mod.pattern = mod.pattern.toLowerCase();
+		}
+		mod.chars = [...mod.pattern];
+		return mod;
+	}
+	#match(item, mod) {
+		this.score.isFile = itemField(item, "file") !== void 0;
+		let str = item.text;
+		if (mod.field) {
+			const value = itemField(item, mod.field);
+			if (value === void 0) return mod.inverse ? {
+				from: 0,
+				score: 1e3,
+				search: str,
+				str,
+				to: 0
+			} : void 0;
+			str = value;
+		}
+		const original = str;
+		if (mod.ignorecase) str = str.toLowerCase();
+		if (mod.regex) return this.#regex(original, mod);
+		if (mod.fuzzy) return this.#fuzzy(str, original, mod.chars);
+		let from = -1;
+		let to = -1;
+		if (mod.exactPrefix) {
+			if (str.startsWith(mod.pattern)) {
+				from = 0;
+				to = mod.pattern.length - 1;
+			}
+		} else if (mod.exactSuffix) {
+			if (str.endsWith(mod.pattern)) {
+				from = str.length - mod.pattern.length;
+				to = str.length - 1;
+			}
+		} else {
+			from = str.indexOf(mod.pattern);
+			to = from + mod.pattern.length - 1;
+			while (mod.word && from >= 0) {
+				if (this.score.isLeftBoundary(str, from) && this.score.isRightBoundary(str, to)) break;
+				from = str.indexOf(mod.pattern, to + 1);
+				to = from + mod.pattern.length - 1;
+			}
+		}
+		if (mod.inverse) return from === -1 ? {
+			from: 0,
+			score: 1e3,
+			search: str,
+			str: original,
+			to: 0
+		} : void 0;
+		if (from >= 0) return {
+			from,
+			score: this.score.get(original, from, to),
+			search: str,
+			str: original,
+			to
+		};
+	}
+	#regex(str, mod) {
+		const match = mod.re?.exec(str);
+		if (!match?.[0]) return void 0;
+		const from = match.index;
+		const to = from + match[0].length - 1;
+		return {
+			from,
+			score: this.score.get(str, from, to),
+			search: str,
+			str,
+			to
+		};
+	}
+	#fuzzyFind(str, original, pattern, init = 0) {
+		const from = str.indexOf(pattern[0] ?? "", init);
+		if (from === -1) return void 0;
+		this.score.init(original, from);
+		let last = from;
+		for (let i = 1; i < pattern.length; i++) {
+			last = str.indexOf(pattern[i], last + 1);
+			if (last === -1) return void 0;
+			this.score.update(last);
+		}
+		return {
+			from,
+			score: this.score.score,
+			to: last
+		};
+	}
+	#fuzzy(str, original, pattern) {
+		let best = this.#fuzzyFind(str, original, pattern);
+		if (!best) return void 0;
+		for (let next = this.#fuzzyFind(str, original, pattern, best.from + 1); next; next = this.#fuzzyFind(str, original, pattern, next.from + 1)) if (next.score > best.score) best = next;
+		return {
+			from: best.from,
+			score: best.score,
+			search: str,
+			str: original,
+			to: best.to
+		};
+	}
+	#fuzzyPositions(str, pattern, from) {
+		const ret = [from];
+		let last = from;
+		for (let i = 1; i < pattern.length; i++) {
+			last = str.indexOf(pattern[i], last + 1);
+			if (last === -1) break;
+			ret.push(last);
+		}
+		return ret;
+	}
+};
+function itemField(item, field) {
+	const value = item[field];
+	if (value === void 0 || value === null) return void 0;
+	if (typeof value === "string") return value;
+	if (typeof value === "number" || typeof value === "boolean" || typeof value === "bigint") return String(value);
+	if (Array.isArray(value)) return value.join(" ");
+}
+function parseFilePattern(pattern) {
+	return pattern.match(/^(.*[/\\].*):\d*:?:?\d*$/)?.[1] ?? pattern.match(/^(.+\.[a-z_]+):\d*:?:?\d*$/)?.[1];
+}
+//#endregion
+//#region src/search/sort.ts
+function parse(field) {
+	const len = field.startsWith("#");
+	return {
+		desc: field.endsWith(":desc"),
+		len,
+		name: field.replace(/^#/, "").replace(/:desc$/, "")
+	};
+}
+function sorter(fields = [
+	"score:desc",
+	"#text",
+	"idx"
+]) {
+	const parsed = fields.map(parse);
+	return (a, b) => {
+		for (const field of parsed) {
+			let av = a[field.name];
+			let bv = b[field.name];
+			if (av === void 0 || bv === void 0) continue;
+			if (field.len) {
+				av = typeof av === "string" || Array.isArray(av) ? av.length : 0;
+				bv = typeof bv === "string" || Array.isArray(bv) ? bv.length : 0;
+			}
+			if (av === bv) continue;
+			if (typeof av === "boolean" && typeof bv === "boolean") {
+				av = av ? 0 : 1;
+				bv = bv ? 0 : 1;
+			}
+			return compare(av, bv) * (field.desc ? -1 : 1);
+		}
+		return 0;
+	};
+}
+function compare(a, b) {
+	if (typeof a === "number" && typeof b === "number") return a - b;
+	if (typeof a === "string" && typeof b === "string") return a.localeCompare(b);
+	return String(a).localeCompare(String(b));
+}
+//#endregion
+//#region src/search/search.ts
+const BONUS_FRECENCY = 8;
+const SEARCH_LIMIT = 1e3;
+const aborted = Symbol("search.aborted");
+var Searcher = class {
+	#opts;
+	#sorter;
+	#matcher;
+	#ac;
+	constructor(opts) {
+		this.#opts = opts;
+		const sortOpts = opts.sort === true ? void 0 : opts.sort;
+		this.#sorter = sortOpts === false ? void 0 : sorter(sortOpts);
+		this.#matcher = new Matcher(opts);
+	}
+	/** Create a match function bound to the current pattern. If the
+	* matcher has been updated since the search started, match will
+	* return `0` to indicate no match, to prevent stale results */
+	createMatch(opts) {
+		const m = this.#matcher;
+		return (s) => opts.signal.aborted ? 0 : m.match(s);
+	}
+	async search(items, query = "", opts = {}) {
+		try {
+			return await this.#search(items, query, opts);
+		} catch (error) {
+			if (error === aborted) return [];
+			throw error;
+		}
+	}
+	get limit() {
+		return this.#opts.limit ?? (this.#sorter ? SEARCH_LIMIT : Infinity);
+	}
+	async #search(items, query = "", opts = {}) {
+		this.#ac?.abort(aborted);
+		const ac = this.#ac = new AbortController();
+		const m = this.#matcher;
+		m.init(query);
+		const f = this.#opts.frecency?.();
+		const s = this.#sorter;
+		const limit = this.limit;
+		const ret = [];
+		let match = (item) => this.#matcher.update(item);
+		const topk = s && (this.#opts.sortEmpty || !m.empty()) ? new TopK(limit, (a, b) => -s(a, b)) : void 0;
+		if (typeof items === "function") {
+			match = (item) => item;
+			items = await items(query, this.createMatch({ signal: ac.signal }));
+			ac.signal.throwIfAborted();
+		}
+		if (items.length === 0) return [];
+		const results = () => topk?.sorted() ?? ret;
+		const todo = [
+			[],
+			[],
+			[]
+		];
+		let idx = 0;
+		if (!topk) todo[0] = items;
+		else for (const item of items) {
+			item.idx = idx++;
+			const it = item;
+			if (it.topk) todo[0].push(item);
+			else if (it.score) todo[1].push(item);
+			else todo[2].push(item);
+		}
+		const doFilter = !m.empty() && (this.#opts.filter ?? true);
+		let lastYield = performance.now();
+		let dirty = false;
+		let count = 0;
+		loop: for (const todos of todo) for (const item of todos) {
+			ac.signal.throwIfAborted();
+			if (count++ % 256 === 0) {
+				const now = performance.now();
+				if (now - lastYield >= (this.#opts.throttle ?? 16)) {
+					lastYield = now;
+					await new Promise((r) => setImmediate(r));
+					if (opts.progress && dirty) {
+						dirty = false;
+						await opts.progress(results());
+					}
+				}
+			}
+			const si = match(item);
+			if (si.file && si.score && f) {
+				const frecency = f(si.file);
+				si.score += (1 - 1 / (1 + frecency)) * BONUS_FRECENCY;
+			}
+			if (doFilter && si.score === 0) continue;
+			if (topk) {
+				si.topk = false;
+				const ta = topk.add(si);
+				if (ta.added) {
+					si.topk = true;
+					dirty = true;
+					if (ta.evicted) ta.evicted.topk = false;
+				}
+			} else {
+				ret.push(si);
+				dirty = true;
+				if (ret.length >= limit) break loop;
+			}
+		}
+		return results();
+	}
+	positions(s) {
+		return this.#matcher.positions(s);
+	}
+};
+//#endregion
+//#region src/widgets/picker.ts
+function isTree(props) {
+	return "tree" in props;
+}
+const picker = widget((props) => {
+	const pattern = memo(() => {
+		if (props.pattern !== void 0) return unwrap(props.pattern);
+		return (props.input instanceof Input ? props.input : props.input?.())?.state.value ?? "";
+	});
+	let node;
+	let items;
+	if (isTree(props)) {
+		props = {
+			filter: false,
+			fuzzy: false,
+			sort: false,
+			...props
+		};
+		const t = tree(props);
+		node = t;
+		items = t.items;
+	} else {
+		node = select({
+			...props,
+			items: []
+		});
+		items = props.items;
+	}
+	const searcher = new Searcher(props);
+	node.extendRenderer((prev) => (item, ctx) => {
+		let row = prev(item, ctx);
+		if (!item.score) return row;
+		const stripped = stripAnsi(row);
+		const positions = searcher.positions(stripped).toSorted((a, b) => b - a);
+		while (positions.length > 0) {
+			const from = positions.pop();
+			let to = from;
+			while (positions.length && positions.at(-1) === to + 1) to = positions.pop();
+			row = sliceAnsi(row, 0, from) + ctx.style.accent(stripped.slice(from, to + 1)) + sliceAnsi(row, to + 1);
+		}
+		return row;
+	});
+	const results = createProgressive(async ({ set }) => await searcher.search(unwrap(items), pattern(), { progress: (r) => set(r) }), { initialValue: [] });
+	node.state.items = results;
+	if (props.input) node.bind(props.input);
+	const matches = () => unwrap(node.state.items).map((item, i) => [item, i]).filter(([item]) => item.score).map(([, i]) => i);
+	effect(() => {
+		const m = matches();
+		node.state.more = m.length >= searcher.limit;
+		if (m.length === 0 || pattern() === "") return;
+		untrack(() => {
+			if (props.filter === false) {
+				const active = node.active;
+				node.active = m.find((i) => i >= active) ?? m[0];
+			} else node.active = 0;
+		});
+	});
+	return node.withActions({
+		...props.actions,
+		"picker.next": () => {
+			const active = node.active;
+			const m = matches();
+			if (m.length === 0) return node.action("select.next");
+			node.active = node.state.reverse ? m.toReversed().find((i) => i < active) ?? m.at(-1) : m.find((i) => i > active) ?? m[0];
+		},
+		"picker.prev": () => {
+			const active = node.active;
+			const m = matches();
+			if (m.length === 0) return node.action("select.prev");
+			node.active = node.state.reverse ? m.find((i) => i > active) ?? m[0] : m.toReversed().find((i) => i < active) ?? m.at(-1);
+		}
+	});
+});
+//#endregion
+export { picker as t };
+
+//# sourceMappingURL=picker-ndVVt6qF.mjs.map