bitboss-ui 3.0.0-beta.21 → 3.0.0-beta.22

package/dist/icon-scan.js

@@ -0,0 +1,485 @@
+import * as e from "node:fs";
+import { existsSync as t, readFileSync as n } from "node:fs";
+import { dirname as r, isAbsolute as i, join as a, relative as o, resolve as s, sep as c } from "node:path";
+import l from "ignore";
+import * as u from "node:crypto";
+import { mkdir as d, readdir as f, stat as p, writeFile as m } from "node:fs/promises";
+import { availableParallelism as h } from "node:os";
+import { Worker as g } from "node:worker_threads";
+//#region src/icon-scan.ts
+var _ = /* @__PURE__ */ new Set([
+	"node_modules",
+	"vendor",
+	"storage"
+]), v = 256 * 1024 * 1024, y = 8192, b = 48, x = 1500, S = 64, C = (e) => e.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+function w(e) {
+	let t = [...e].sort((e, t) => t.length - e.length).map(C).join("|");
+	return RegExp(`(?<![A-Za-z0-9_-])(${t}):([a-z0-9][a-z0-9-]*)`, "g");
+}
+function T(e, t) {
+	let n = e.toString("latin1"), r = /* @__PURE__ */ new Set();
+	t.lastIndex = 0;
+	for (let e of n.matchAll(t)) {
+		let t = e[2].replace(/-+$/, "");
+		t && r.add(`${e[1]}:${t}`);
+	}
+	return [...r];
+}
+var E = /[*?[{]/, D = (e) => E.test(e);
+function O(e) {
+	let t = "^";
+	for (let n = 0; n < e.length; n++) {
+		let r = e[n];
+		if (r === "*") e[n + 1] === "*" ? e[n + 2] === "/" ? (t += "(?:.*/)?", n += 2) : (t += ".*", n += 1) : t += "[^/]*";
+		else if (r === "?") t += "[^/]";
+		else if (r === "[") {
+			let r = e.indexOf("]", n + 1);
+			r === -1 ? t += "\\[" : (t += `[${e.slice(n + 1, r).replace(/\\/g, "\\\\")}]`, n = r);
+		} else if (r === "{") {
+			let r = e.indexOf("}", n + 1);
+			r === -1 ? t += "\\{" : (t += `(?:${e.slice(n + 1, r).split(",").map(C).join("|")})`, n = r);
+		} else t += C(r);
+	}
+	return RegExp(t + "$");
+}
+var k = (e) => c === "/" ? e : e.split(c).join("/");
+function A(e, t) {
+	let n = o(e, t);
+	return n === "" || !n.startsWith("..") && !i(n);
+}
+function j(e) {
+	let n = [], i = r(e), o = -1;
+	for (;;) {
+		if (n.push(i), t(a(i, ".git"))) {
+			o = n.length;
+			break;
+		}
+		let e = r(i);
+		if (e === i) break;
+		i = e;
+	}
+	return o === -1 ? [] : n.slice(0, o).reverse().flatMap((e) => {
+		let t = M(e);
+		return t ? [{
+			dir: e,
+			ig: t
+		}] : [];
+	});
+}
+function M(e) {
+	let r = a(e, ".gitignore");
+	try {
+		return t(r) ? l().add(n(r, "utf-8")) : null;
+	} catch {
+		return null;
+	}
+}
+function N(e, t, n) {
+	let r = n.needles.map((e) => Buffer.from(e, "latin1")), i = new RegExp(n.regexSource, "g"), a = t.hash ? (e) => t.hash("sha1", e, "hex") : (e) => t.createHash("sha1").update(e).digest("hex"), o = (t, r) => {
+		let i = Math.min(r, n.probeBytes), a = Buffer.allocUnsafe(i), o = e.readSync(t, a, 0, i, 0);
+		if (a.subarray(0, o).indexOf(0) !== -1) return null;
+		if (o >= r) return a.subarray(0, o);
+		let s = Buffer.allocUnsafe(r);
+		a.copy(s, 0, 0, o);
+		let c = o;
+		for (; c < r;) {
+			let n = e.readSync(t, s, c, r - c, c);
+			if (n === 0) break;
+			c += n;
+		}
+		return s.subarray(0, c);
+	};
+	return (t) => {
+		let { path: s, prev: c } = t, l = -1, u;
+		try {
+			c ? u = e.statSync(s) : (l = e.openSync(s, "r"), u = e.fstatSync(l));
+		} catch {
+			return l !== -1 && e.closeSync(l), {
+				path: s,
+				outcome: "skip",
+				read: !1
+			};
+		}
+		try {
+			if (!u.isFile() || u.size > n.maxFileSize) return {
+				path: s,
+				outcome: "skip",
+				read: !1
+			};
+			if (c && c.size === u.size && c.mtime === u.mtimeMs) return {
+				path: s,
+				outcome: "fresh",
+				size: u.size,
+				mtime: u.mtimeMs
+			};
+			let t;
+			try {
+				l === -1 && (l = e.openSync(s, "r")), t = o(l, u.size);
+			} catch {
+				return {
+					path: s,
+					outcome: "skip",
+					read: !1
+				};
+			}
+			if (t === null) return {
+				path: s,
+				outcome: "skip",
+				read: !0
+			};
+			let d = a(t);
+			if (c && c.hash === d) return {
+				path: s,
+				outcome: "same",
+				size: u.size,
+				mtime: u.mtimeMs,
+				hash: d
+			};
+			let f = [];
+			if (r.some((e) => t.indexOf(e) !== -1)) {
+				let e = t.toString("latin1"), n = /* @__PURE__ */ new Set();
+				i.lastIndex = 0;
+				for (let t of e.matchAll(i)) {
+					let e = t[2].replace(/-+$/, "");
+					e && n.add(`${t[1]}:${e}`);
+				}
+				f = [...n];
+			}
+			return {
+				path: s,
+				outcome: "new",
+				size: u.size,
+				mtime: u.mtimeMs,
+				hash: d,
+				candidates: f
+			};
+		} finally {
+			l !== -1 && e.closeSync(l);
+		}
+	};
+}
+var P = `
+const { parentPort, workerData } = require('node:worker_threads');
+const scan = (${N.toString()})(require('node:fs'), require('node:crypto'), workerData);
+parentPort.on('message', (jobs) => parentPort.postMessage(jobs.map(scan)));
+`;
+function F(e) {
+	return Math.max(2, Math.min(4, e - 1));
+}
+function I(e, t) {
+	return Array.from({ length: e }, () => new g(P, {
+		eval: !0,
+		workerData: t
+	}));
+}
+async function L(e, t) {
+	let n = [], r = [];
+	for (let t = 0; t < e.length; t += S) r.push(e.slice(t, t + S));
+	let i = 0;
+	try {
+		await Promise.all(t.map((e) => new Promise((t, a) => {
+			let o = () => {
+				let n = r[i++];
+				if (!n) return t();
+				e.postMessage(n);
+			};
+			e.on("message", (e) => {
+				n.push(...e), o();
+			}), e.on("error", a), e.on("exit", (e) => {
+				e !== 0 && a(/* @__PURE__ */ Error(`icon-scan worker exited with ${e}`));
+			}), o();
+		})));
+	} finally {
+		await Promise.all(t.map((e) => e.terminate()));
+	}
+	return n;
+}
+async function R(e, t, n) {
+	let r = Array(e.length), i = 0;
+	return await Promise.all(Array.from({ length: Math.min(t, e.length) }, async () => {
+		for (;;) {
+			let t = i++;
+			if (t >= e.length) return;
+			r[t] = await n(e[t]);
+		}
+	})), r;
+}
+var z = class {
+	constructor(t) {
+		this.resolveMemo = /* @__PURE__ */ new Map(), this.gitignoreMemo = /* @__PURE__ */ new Map(), this.entries = /* @__PURE__ */ new Map(), this.cold = !0, this.dirty = !1, this.lastWorkers = 0, this.cfg = t, this.fileOptions = t.prefixes.length ? {
+			needles: t.prefixes.map((e) => `${e}:`),
+			regexSource: w(t.prefixes).source,
+			maxFileSize: t.scanner.maxFileSize ?? 268435456,
+			probeBytes: y
+		} : null, this.scanOne = this.fileOptions ? N(e, u, this.fileOptions) : null, this.workerThreshold = t.workerThreshold ?? 1500;
+		let n = t.scanner.exclude ?? [];
+		this.excludes = n.length ? l().add(n) : null, this.bases = [{
+			dir: t.root,
+			match: null,
+			ancestors: j(t.root)
+		}, ...(t.scanner.include ?? []).map((e) => this.includeBase(e))];
+	}
+	get includeDirs() {
+		return this.bases.slice(1).map((e) => e.dir).filter((e) => !A(this.cfg.root, e));
+	}
+	get icons() {
+		let e = /* @__PURE__ */ new Set();
+		for (let t of this.entries.values()) for (let n of t.icons) e.add(n);
+		return e;
+	}
+	includeBase(e) {
+		let t = k(e).split("/"), n = t.findIndex((e) => D(e));
+		if (n === -1) return {
+			dir: s(this.cfg.root, e),
+			match: null,
+			ancestors: []
+		};
+		let r = t.slice(0, n).join("/"), i = t.slice(n).join("/");
+		return {
+			dir: s(this.cfg.root, r || "."),
+			match: O(i),
+			ancestors: []
+		};
+	}
+	gitignoreFor(e) {
+		let t = this.gitignoreMemo.get(e);
+		return t === void 0 && (t = M(e), this.gitignoreMemo.set(e, t)), t;
+	}
+	resetGitignores() {
+		this.gitignoreMemo.clear(), this.bases[0].ancestors = j(this.cfg.root);
+	}
+	isGitignored(e, t, n) {
+		let r = !1;
+		for (let { dir: i, ig: a } of e) {
+			let e = k(o(i, t));
+			if (!e || e.startsWith("..")) continue;
+			n && (e += "/");
+			let s = a.test(e);
+			s.ignored ? r = !0 : s.unignored && (r = !1);
+		}
+		return r;
+	}
+	isExcluded(e, t, n) {
+		if (!this.excludes) return !1;
+		let r = k(o(A(this.cfg.root, t) ? this.cfg.root : e.dir, t));
+		return !r || r.startsWith("..") ? !1 : (n && (r += "/"), this.excludes.ignores(r));
+	}
+	admits(e, t, n, r, i) {
+		if (n.startsWith(".") || r && (_.has(n) || t === this.cfg.outDir) || this.isGitignored(i, t, r) || this.isExcluded(e, t, r)) return !1;
+		if (!r && e.match) {
+			let n = k(o(e.dir, t));
+			if (!e.match.test(n)) return !1;
+		}
+		return !0;
+	}
+	isCandidate(e) {
+		e = s(e);
+		let t = this.bases.find((t) => A(t.dir, e));
+		if (!t) return !1;
+		if (e === t.dir) return t.match === null;
+		let n = [...t.ancestors], r = this.gitignoreFor(t.dir);
+		r && n.push({
+			dir: t.dir,
+			ig: r
+		});
+		let i = k(o(t.dir, e)).split("/"), c = t.dir;
+		for (let e = 0; e < i.length; e++) {
+			let r = i[e], o = a(c, r), s = e < i.length - 1;
+			if (!this.admits(t, o, r, s, n)) return !1;
+			if (s) {
+				let e = this.gitignoreFor(o);
+				e && n.push({
+					dir: o,
+					ig: e
+				}), c = o;
+			}
+		}
+		return !0;
+	}
+	async walk(e, t, n, r) {
+		let i;
+		try {
+			i = await f(t, { withFileTypes: !0 });
+		} catch {
+			return;
+		}
+		let o = this.gitignoreFor(t), s = o ? [...n, {
+			dir: t,
+			ig: o
+		}] : n, c = [];
+		for (let n of i) {
+			if (n.isSymbolicLink()) continue;
+			let i = a(t, n.name), o = n.isDirectory();
+			!o && !n.isFile() || this.admits(e, i, n.name, o, s) && (o ? c.push(i) : r.add(i));
+		}
+		await Promise.all(c.map((t) => this.walk(e, t, s, r)));
+	}
+	async collectFiles() {
+		let e = /* @__PURE__ */ new Set();
+		for (let t of this.bases) {
+			let n;
+			try {
+				n = await p(t.dir);
+			} catch {
+				continue;
+			}
+			if (n.isFile()) {
+				t.match || e.add(t.dir);
+				continue;
+			}
+			await this.walk(t, t.dir, [...t.ancestors], e);
+		}
+		return [...e];
+	}
+	resolvesMemo(e) {
+		let t = this.resolveMemo.get(e);
+		if (t === void 0) {
+			let n = e.indexOf(":");
+			t = this.cfg.resolves(e.slice(0, n), e.slice(n + 1)), this.resolveMemo.set(e, t);
+		}
+		return t;
+	}
+	fold(e, t) {
+		switch (e.outcome) {
+			case "skip": return {
+				entry: null,
+				read: e.read,
+				extracted: !1
+			};
+			case "fresh": return {
+				entry: t,
+				read: !1,
+				extracted: !1
+			};
+			case "same": return {
+				entry: {
+					...t,
+					size: e.size,
+					mtime: e.mtime
+				},
+				read: !0,
+				extracted: !1
+			};
+			case "new": return {
+				entry: {
+					size: e.size,
+					mtime: e.mtime,
+					hash: e.hash,
+					icons: e.candidates.filter((e) => this.resolvesMemo(e))
+				},
+				read: !0,
+				extracted: !0
+			};
+		}
+	}
+	async statOnly(e) {
+		try {
+			let t = await p(e);
+			return t.isFile() ? {
+				size: t.size,
+				mtime: t.mtimeMs,
+				hash: "",
+				icons: []
+			} : null;
+		} catch {
+			return null;
+		}
+	}
+	async scanFile(e, t) {
+		return this.scanOne ? this.fold(await this.scanOne({
+			path: e,
+			prev: t ?? null
+		}), t) : {
+			entry: await this.statOnly(e),
+			read: !1,
+			extracted: !1
+		};
+	}
+	useWorkers(e) {
+		return this.fileOptions !== null && e >= this.workerThreshold;
+	}
+	async scanAll(e, t, n) {
+		let r = e.map((e) => ({
+			path: e,
+			prev: t.get(e) ?? null
+		}));
+		if (n && this.useWorkers(r.length)) try {
+			let e = await L(r, n);
+			return this.lastWorkers = n.length, e;
+		} catch {}
+		else n && Promise.all(n.map((e) => e.terminate()));
+		this.lastWorkers = 0;
+		let i = [];
+		for (let e = 0; e < r.length; e += S) {
+			for (let t of r.slice(e, e + S)) i.push(this.scanOne(t));
+			e + S < r.length && await new Promise((e) => setImmediate(e));
+		}
+		return i;
+	}
+	loadCache() {
+		try {
+			let e = JSON.parse(n(this.cfg.cacheFile, "utf-8"));
+			if (e.version === 4 && e.key === this.cfg.cacheKey && e.entries && typeof e.entries == "object") return this.cold = !1, new Map(Object.entries(e.entries));
+		} catch {}
+		return this.cold = !0, /* @__PURE__ */ new Map();
+	}
+	async scan() {
+		let e = performance.now(), t = this.loadCache(), n = this.cold ? 2 ** 53 - 1 : t.size, r = this.fileOptions && this.useWorkers(n) ? I(F(h()), this.fileOptions) : null, i = await this.collectFiles(), a = /* @__PURE__ */ new Map(), o = 0, s = 0, c = 0;
+		if (this.scanOne) for (let e of await this.scanAll(i, t, r)) {
+			let n = this.fold(e, t.get(e.path));
+			n.read && o++, n.extracted && s++, n.entry ? a.set(e.path, n.entry) : c++;
+		}
+		else await R(i, b, async (e) => {
+			let t = await this.statOnly(e);
+			t ? a.set(e, t) : c++;
+		});
+		return this.entries = a, this.dirty = this.cold || o > 0 || a.size !== t.size || [...a.keys()].some((e) => !t.has(e)), await this.persist(), {
+			files: i.length,
+			read: o,
+			extracted: s,
+			skipped: c,
+			elapsed: Math.round(performance.now() - e),
+			cold: this.cold,
+			workers: this.lastWorkers
+		};
+	}
+	async updateFile(e) {
+		if (e = s(e), !this.isCandidate(e)) return this.removeFile(e);
+		let t = this.icons, n = await this.scanFile(e, this.entries.get(e));
+		return n.entry ? this.entries.set(e, n.entry) : this.entries.delete(e), this.dirty = !0, !B(t, this.icons);
+	}
+	removeFile(e) {
+		if (e = s(e), !this.entries.has(e)) return !1;
+		let t = this.icons;
+		return this.entries.delete(e), this.dirty = !0, !B(t, this.icons);
+	}
+	async persist() {
+		if (!this.dirty) return;
+		this.dirty = !1;
+		let e = {
+			version: 4,
+			key: this.cfg.cacheKey,
+			entries: Object.fromEntries(this.entries)
+		};
+		try {
+			await d(r(this.cfg.cacheFile), { recursive: !0 }), await m(this.cfg.cacheFile, JSON.stringify(e), "utf-8");
+		} catch {}
+	}
+};
+function B(e, t) {
+	if (e.size !== t.size) return !1;
+	for (let n of e) if (!t.has(n)) return !1;
+	return !0;
+}
+function V(e) {
+	let n = s(e);
+	for (;;) {
+		if (t(a(n, "node_modules"))) return a(n, "node_modules", ".cache", "bitboss-ui", "icon-scan.json");
+		let e = r(n);
+		if (e === n) break;
+		n = e;
+	}
+	return a(e, "node_modules", ".cache", "bitboss-ui", "icon-scan.json");
+}
+//#endregion
+export { _ as ALWAYS_SKIPPED_DIRS, v as DEFAULT_MAX_FILE_SIZE, x as DEFAULT_WORKER_THRESHOLD, z as IconScanner, N as createFileScanner, T as extractIconCandidates, O as globToRegExp, D as hasGlobMagic, w as iconLiteralRegExp, V as iconScanCacheFile, F as workerCountFor };

package/dist/icons-whitelist.d.ts

@@ -1,8 +1,9 @@
 /**
- * Storybook icon whitelist.
+ * Storybook icon control options.
  *
- * Keep provider icon names as string literals in this source file so the
- * `bitbossUi` build scanner can discover and include them for static docs
- * builds (it does not scan `*.stories.*` files).
+ * Historically this list existed so the `bitbossUi` build scanner — which
+ * once read only `.vue/.ts/.js` source and skipped `*.stories.*` — would see
+ * these names as literals. The scanner now reads every file in the project,
+ * stories included, so the list is purely the control's option set.
  */
 export declare const STORYBOOK_ICON_WHITELIST: readonly ["lucide:plus", "lucide:download", "lucide:arrow-right", "lucide:settings", "lucide:trash-2", "lucide:bell"];