@embedpdf/core-ui 3.0.0-next.0

package/dist/index.js

@@ -0,0 +1,630 @@
+//#region src/schema.ts
+const PINNED = 5;
+function item(command, opts) {
+	return {
+		command,
+		...opts
+	};
+}
+function custom(slot, opts) {
+	return {
+		slot,
+		...opts
+	};
+}
+function group(id, optsOrItems, items) {
+	if (Array.isArray(optsOrItems)) return {
+		id,
+		items: optsOrItems
+	};
+	const { items: optItems, ...opts } = optsOrItems;
+	return {
+		id,
+		...opts,
+		items: items ?? optItems ?? []
+	};
+}
+const DEFAULT_IMPORTANCE = 3;
+const DEFAULT_COMMAND_VARIANTS = ["icon"];
+const DEFAULT_CUSTOM_VARIANTS = ["default"];
+function normalizeChild(groupId, child, seen) {
+	const asItem = typeof child === "string" ? { command: child } : child;
+	const unit = "slot" in asItem ? {
+		kind: "custom",
+		key: `${groupId}:${asItem.slot}`,
+		slot: asItem.slot,
+		variants: asItem.variants ?? DEFAULT_CUSTOM_VARIANTS,
+		terminal: asItem.terminal,
+		importance: asItem.importance ?? 3
+	} : {
+		kind: "command",
+		key: `${groupId}:${asItem.command}`,
+		command: asItem.command,
+		variants: asItem.variants ?? DEFAULT_COMMAND_VARIANTS,
+		importance: asItem.importance ?? 3
+	};
+	if (unit.variants.length === 0) throw new Error(`[ui-core] empty variant ladder: ${unit.key}`);
+	if (seen.has(unit.key)) throw new Error(`[ui-core] duplicate unit in bar: ${unit.key}`);
+	seen.add(unit.key);
+	return unit;
+}
+/** Resolve shorthands + defaults; validate uniqueness. Solver/projection input. */
+function normalizeBar(bar) {
+	const seen = /* @__PURE__ */ new Set();
+	const groupIds = /* @__PURE__ */ new Set();
+	const sections = [];
+	for (const name of [
+		"start",
+		"center",
+		"end"
+	]) {
+		const groups = bar.sections[name];
+		if (!groups || groups.length === 0) continue;
+		sections.push({
+			name,
+			groups: groups.map((g) => {
+				if (groupIds.has(g.id)) throw new Error(`[ui-core] duplicate group in bar: ${g.id}`);
+				groupIds.add(g.id);
+				return {
+					id: g.id,
+					labelKey: g.labelKey,
+					role: g.role ?? "buttons",
+					shed: g.shed ?? false,
+					collapse: g.collapse,
+					importance: g.importance ?? 3,
+					units: g.items.map((c) => normalizeChild(g.id, c, seen))
+				};
+			})
+		});
+	}
+	return {
+		id: bar.id,
+		sections
+	};
+}
+/**
+* Drop units whose command is currently invisible (permissions, disabled
+* categories, contextual visibility) BEFORE solving — an invisible unit must
+* not consume budget or appear in the overflow. Groups that empty out vanish
+* naturally in the solver's separator math and in the projection.
+*/
+function filterBar(bar, keep) {
+	return {
+		id: bar.id,
+		sections: bar.sections.map((s) => ({
+			name: s.name,
+			groups: s.groups.map((g) => ({
+				...g,
+				units: g.units.filter(keep)
+			}))
+		}))
+	};
+}
+/**
+* Identity + validation. Checks what is checkable without a command registry:
+* bars normalize cleanly, and every `menu` a strip/bar could reference exists
+* is left to `validateChrome` (which also takes the known command ids).
+*/
+function defineChrome(chrome) {
+	for (const bar of Object.values(chrome.bars)) normalizeBar(bar);
+	for (const bar of Object.values(chrome.modeBars ?? {})) normalizeBar(bar);
+	for (const strip of Object.values(chrome.strips ?? {})) normalizeBar(strip);
+	return chrome;
+}
+/** Dev-time cross-check: every command referenced by the chrome exists. */
+function validateChrome(chrome, knownCommands) {
+	const problems = [];
+	const checkBar = (bar, where) => {
+		for (const section of normalizeBar(bar).sections) for (const g of section.groups) for (const u of g.units) {
+			const refs = u.kind === "command" ? [u.command] : [u.terminal];
+			for (const c of refs) if (!knownCommands.has(c)) problems.push(`${where}: unknown command "${c}"`);
+		}
+	};
+	for (const [id, bar] of Object.entries(chrome.bars)) checkBar(bar, `bars.${id}`);
+	for (const [id, bar] of Object.entries(chrome.modeBars ?? {})) checkBar(bar, `modeBars.${id}`);
+	for (const [id, strip] of Object.entries(chrome.strips ?? {})) checkBar(strip, `strips.${id}`);
+	for (const [id, menu] of Object.entries(chrome.menus ?? {})) for (const section of menu.sections) for (const c of section.items) if (!knownCommands.has(c)) problems.push(`menus.${id}: unknown command "${c}"`);
+	return problems;
+}
+//#endregion
+//#region src/transforms.ts
+/**
+* Pure transforms over ChromeSchema — the "surgical edit" tier of the
+* customization ladder, between "pass nothing" and "own the whole value".
+* They are ordinary functions over data: no registry, no merge grammar, no
+* order sensitivity beyond function composition. Anything they can't express
+* is a sign the caller should write the schema value instead.
+*
+* Addressing is by BAR ID across all three bar collections (bars, modeBars,
+* strips). Mode bars may also be addressed by their surface key
+* ('mode:annotate') since that is what appears in `chrome.modeBars`.
+*/
+const SECTION_NAMES = [
+	"start",
+	"center",
+	"end"
+];
+const isCustom = (child) => typeof child !== "string" && "slot" in child;
+const commandOf = (child) => typeof child === "string" ? child : isCustom(child) ? null : child.command;
+/** Every (collection, key) location whose bar matches `id`. */
+function locate(schema, id) {
+	const hits = [];
+	for (const coll of [
+		"bars",
+		"modeBars",
+		"strips"
+	]) for (const [key, bar] of Object.entries(schema[coll] ?? {})) if (bar.id === id || key === id) hits.push([coll, key]);
+	return hits;
+}
+function withBar(schema, coll, key, bar) {
+	return {
+		...schema,
+		[coll]: {
+			...schema[coll],
+			[key]: bar
+		}
+	};
+}
+/** Insert `spec.item` into a group of one bar. See AddItemSpec for semantics. */
+function addItem(schema, spec) {
+	const hits = locate(schema, spec.bar);
+	if (hits.length === 0) throw new Error(`[ui-core] addItem: no bar "${spec.bar}" in bars/modeBars/strips`);
+	if (hits.length > 1) throw new Error(`[ui-core] addItem: bar id "${spec.bar}" is ambiguous (${hits.map(([c]) => c).join(", ")})`);
+	const [coll, key] = hits[0];
+	const bar = schema[coll][key];
+	for (const name of SECTION_NAMES) {
+		if (name === spec.section) continue;
+		if (bar.sections[name]?.some((g) => g.id === spec.group)) throw new Error(`[ui-core] addItem: group "${spec.group}" lives in section "${name}", not "${spec.section}"`);
+	}
+	const groups = bar.sections[spec.section] ?? [];
+	const idx = groups.findIndex((g) => g.id === spec.group);
+	const nextGroups = idx === -1 ? [...groups, group(spec.group, [spec.item])] : groups.map((g, i) => {
+		if (i !== idx) return g;
+		const items = [...g.items];
+		items.splice(spec.at ?? items.length, 0, spec.item);
+		return {
+			...g,
+			items
+		};
+	});
+	return withBar(schema, coll, key, {
+		...bar,
+		sections: {
+			...bar.sections,
+			[spec.section]: nextGroups
+		}
+	});
+}
+/**
+* Purge commands (or custom slots, by slot name) from every bar, mode bar,
+* strip, and menu. Groups and menu sections that empty out are dropped;
+* emptied menus keep their key (commands may still target them) with no rows.
+*/
+function removeItems(schema, ids) {
+	const gone = new Set(ids);
+	const keep = (child) => {
+		const cmd = commandOf(child);
+		return cmd !== null ? !gone.has(cmd) : !gone.has(child.slot);
+	};
+	const filterGroups = (groups) => groups?.map((g) => ({
+		...g,
+		items: g.items.filter(keep)
+	})).filter((g) => g.items.length > 0);
+	const filterBarSchema = (bar) => ({
+		...bar,
+		sections: Object.fromEntries(SECTION_NAMES.flatMap((name) => {
+			const groups = filterGroups(bar.sections[name]);
+			return groups && groups.length > 0 ? [[name, groups]] : [];
+		}))
+	});
+	const filterColl = (coll) => coll && Object.fromEntries(Object.entries(coll).map(([k, b]) => [k, filterBarSchema(b)]));
+	return {
+		...schema,
+		bars: filterColl(schema.bars),
+		modeBars: filterColl(schema.modeBars),
+		strips: filterColl(schema.strips),
+		menus: schema.menus && Object.fromEntries(Object.entries(schema.menus).map(([k, menu]) => [k, {
+			...menu,
+			sections: menu.sections.map((s) => ({
+				...s,
+				items: s.items.filter((c) => !gone.has(c))
+			})).filter((s) => s.items.length > 0)
+		}]))
+	};
+}
+/**
+* Swap a command in place everywhere it appears — bars, mode bars, strips,
+* and (when the replacement is itself a plain command) menu rows.
+*/
+function replaceItem(schema, id, item) {
+	const replacementCommand = commandOf(item);
+	const swap = (child) => commandOf(child) === id ? item : child;
+	const mapBar = (bar) => ({
+		...bar,
+		sections: Object.fromEntries(SECTION_NAMES.flatMap((name) => {
+			const groups = bar.sections[name];
+			return groups ? [[name, groups.map((g) => ({
+				...g,
+				items: g.items.map(swap)
+			}))]] : [];
+		}))
+	});
+	const mapColl = (coll) => coll && Object.fromEntries(Object.entries(coll).map(([k, b]) => [k, mapBar(b)]));
+	return {
+		...schema,
+		bars: mapColl(schema.bars),
+		modeBars: mapColl(schema.modeBars),
+		strips: mapColl(schema.strips),
+		menus: replacementCommand === null ? schema.menus : schema.menus && Object.fromEntries(Object.entries(schema.menus).map(([k, menu]) => [k, {
+			...menu,
+			sections: menu.sections.map((s) => ({
+				...s,
+				items: s.items.map((c) => c === id ? replacementCommand : c)
+			}))
+		}]))
+	};
+}
+//#endregion
+//#region src/helpers.ts
+/**
+* The helpers bundle handed to `chrome: (base, h) => …` transforms — the
+* surgical edits plus the authoring sugar, so simple customizations need no
+* imports at all. One object, frozen shape: it IS public API (the vanilla
+* snippet passes it across the config boundary), so additions are features
+* and removals are breaking.
+*/
+const chromeHelpers = {
+	addItem,
+	removeItems,
+	replaceItem,
+	item,
+	group,
+	custom,
+	defineChrome
+};
+//#endregion
+//#region src/solver.ts
+/** variant < shed < collapse < overflow when importance ties. */
+const STEP_RANK = {
+	variant: 0,
+	shed: 1,
+	collapse: 2,
+	"overflow-unit": 3,
+	"overflow-group": 3
+};
+function buildState(bar) {
+	const groups = [];
+	let position = 0;
+	for (const section of bar.sections) for (const g of section.groups) {
+		const gs = {
+			group: g,
+			section: section.name,
+			collapsed: false,
+			overflowed: false,
+			units: []
+		};
+		for (const u of g.units) {
+			gs.units.push({
+				unit: u,
+				group: gs,
+				variantIndex: 0,
+				shed: false,
+				overflowed: false,
+				position
+			});
+			position += 1;
+		}
+		groups.push(gs);
+	}
+	return groups;
+}
+function nextStep(groups) {
+	let best = null;
+	const consider = (step) => {
+		if (!best || step.importance < best.importance || step.importance === best.importance && (STEP_RANK[step.type] < STEP_RANK[best.type] || STEP_RANK[step.type] === STEP_RANK[best.type] && step.position > best.position)) best = step;
+	};
+	for (const gs of groups) {
+		if (gs.overflowed) continue;
+		const groupPosition = gs.units.length ? gs.units[gs.units.length - 1].position : 0;
+		if (gs.collapsed) {
+			if (gs.group.importance < 5) consider({
+				type: "overflow-group",
+				importance: gs.group.importance,
+				position: groupPosition,
+				group: gs
+			});
+			continue;
+		}
+		let childrenExhausted = true;
+		const visibleCount = gs.units.filter((u) => !u.overflowed && !u.shed).length;
+		for (const us of gs.units) {
+			if (us.overflowed || us.shed) continue;
+			if (us.variantIndex < us.unit.variants.length - 1) {
+				childrenExhausted = false;
+				consider({
+					type: "variant",
+					importance: us.unit.importance,
+					position: us.position,
+					unit: us
+				});
+			} else if (us.unit.importance < 5) {
+				if (gs.group.shed && visibleCount > 1) consider({
+					type: "shed",
+					importance: us.unit.importance,
+					position: us.position,
+					unit: us
+				});
+				else if (!gs.group.shed && !gs.group.collapse) consider({
+					type: "overflow-unit",
+					importance: us.unit.importance,
+					position: us.position,
+					unit: us
+				});
+			}
+		}
+		const shedExhausted = !gs.group.shed || visibleCount <= 1;
+		if (childrenExhausted && shedExhausted && gs.group.importance < 5) {
+			if (gs.group.collapse) consider({
+				type: "collapse",
+				importance: gs.group.importance,
+				position: groupPosition,
+				group: gs
+			});
+			else if (gs.group.shed) consider({
+				type: "overflow-group",
+				importance: gs.group.importance,
+				position: groupPosition,
+				group: gs
+			});
+		}
+	}
+	return best;
+}
+function applyStep(step) {
+	switch (step.type) {
+		case "variant":
+			step.unit.variantIndex += 1;
+			return;
+		case "shed":
+			step.unit.shed = true;
+			return;
+		case "collapse":
+			step.group.collapsed = true;
+			return;
+		case "overflow-unit":
+			step.unit.overflowed = true;
+			if (step.unit.group.units.every((u) => u.overflowed)) step.unit.group.overflowed = true;
+			return;
+		case "overflow-group":
+			step.group.overflowed = true;
+			for (const u of step.group.units) u.overflowed = true;
+			return;
+	}
+}
+/**
+* Visible width of the current assignment: unit widths + gaps + derived
+* separators. Gaps are counted between ALL adjacent visible units, including
+* across section boundaries — deliberately conservative: the adapter's layout
+* spaces sections with collapsing auto margins, so the cross-section gap
+* allowance (≤ 2×gap) is slack those margins absorb, never an overlap risk.
+*/
+function measure(groups, metrics, hasTrigger) {
+	let width = 0;
+	let complete = true;
+	let visibleUnits = 0;
+	const visibleBySection = /* @__PURE__ */ new Map();
+	for (const gs of groups) {
+		if (gs.overflowed) continue;
+		if (gs.collapsed) {
+			const w = metrics.groupCollapsed(gs.group.id);
+			if (w === void 0) complete = false;
+			width += w ?? 0;
+			visibleUnits += 1;
+			visibleBySection.set(gs.section, (visibleBySection.get(gs.section) ?? 0) + 1);
+			continue;
+		}
+		let groupVisible = false;
+		let shedCount = 0;
+		for (const us of gs.units) {
+			if (us.overflowed) continue;
+			if (us.shed) {
+				shedCount += 1;
+				continue;
+			}
+			const w = metrics.unit(us.unit.key, us.unit.variants[us.variantIndex]);
+			if (w === void 0) complete = false;
+			width += w ?? 0;
+			visibleUnits += 1;
+			groupVisible = true;
+		}
+		if (shedCount > 0) {
+			const w = metrics.groupTrigger(gs.group.id);
+			if (w === void 0) complete = false;
+			width += w ?? 0;
+			visibleUnits += 1;
+			groupVisible = true;
+		}
+		if (groupVisible) visibleBySection.set(gs.section, (visibleBySection.get(gs.section) ?? 0) + 1);
+	}
+	if (hasTrigger) {
+		width += metrics.overflowTrigger;
+		visibleUnits += 1;
+	}
+	if (visibleUnits > 1) width += metrics.gap * (visibleUnits - 1);
+	for (const count of visibleBySection.values()) if (count > 1) width += metrics.separator * (count - 1);
+	return {
+		width,
+		complete
+	};
+}
+function anyOverflow(groups) {
+	return groups.some((gs) => gs.units.some((u) => u.overflowed));
+}
+function solvePass(bar, metrics, budget, hasTrigger) {
+	const groups = buildState(bar);
+	let measured = measure(groups, metrics, hasTrigger);
+	while (measured.width > budget) {
+		const step = nextStep(groups);
+		if (!step) break;
+		applyStep(step);
+		measured = measure(groups, metrics, hasTrigger);
+	}
+	return {
+		groups,
+		measured
+	};
+}
+function solve(bar, metrics, containerWidth) {
+	let pass = solvePass(bar, metrics, containerWidth, false);
+	if (anyOverflow(pass.groups)) pass = solvePass(bar, metrics, containerWidth, true);
+	const units = /* @__PURE__ */ new Map();
+	const groupAssignments = /* @__PURE__ */ new Map();
+	for (const gs of pass.groups) {
+		const shedCount = gs.units.filter((u) => u.shed && !u.overflowed && !gs.collapsed).length;
+		groupAssignments.set(gs.group.id, {
+			shedCount,
+			collapsed: gs.collapsed,
+			overflowed: gs.overflowed
+		});
+		for (const us of gs.units) units.set(us.unit.key, us.overflowed ? { kind: "overflow" } : gs.collapsed ? { kind: "collapsed" } : us.shed ? { kind: "shed" } : {
+			kind: "variant",
+			variant: us.unit.variants[us.variantIndex]
+		});
+	}
+	return {
+		units,
+		groups: groupAssignments,
+		hasOverflow: anyOverflow(pass.groups),
+		width: pass.measured.width,
+		complete: pass.measured.complete
+	};
+}
+//#endregion
+//#region src/projection.ts
+function projectUnit(unit, resolve) {
+	const command = unit.kind === "custom" ? unit.terminal : unit.command;
+	const menu = resolve(command)?.menu;
+	return menu ? {
+		type: "submenu",
+		command,
+		menu
+	} : {
+		type: "command",
+		command
+	};
+}
+function projectOverflow(bar, fit, resolve) {
+	const sections = [];
+	for (const section of bar.sections) for (const group of section.groups) {
+		const rows = group.units.filter((u) => fit.units.get(u.key)?.kind === "overflow").map((u) => projectUnit(u, resolve));
+		if (rows.length === 0) continue;
+		sections.push({
+			labelKey: group.labelKey,
+			role: group.role === "tabs" ? "radio" : void 0,
+			rows
+		});
+	}
+	return sections;
+}
+/**
+* The content of a group's disclosure trigger: its shed units, in bar order,
+* in menu form — same totality rules as the global overflow. This is v2's
+* hand-written `mode-tabs-overflow-menu`, derived.
+*/
+function projectShed(group, fit, resolve) {
+	return group.units.filter((u) => fit.units.get(u.key)?.kind === "shed").map((u) => projectUnit(u, resolve));
+}
+/**
+* Strip projection — a bar projected for UN-measured rendering (a contextual
+* strip anchored to a selection has no fit pressure to solve). The schema
+* declares what COULD appear; `visible` (the command registry's runtime truth)
+* decides what DOES: hidden commands drop out, groups that empty out vanish,
+* and an all-hidden bar projects to [] — "render nothing" falls out. Custom
+* units project through their `terminal` command, same totality rule as the
+* overflow. Upgrading a strip to measured/overflowing rendering later is a
+* renderer swap (<Toolbar>), never a schema change.
+*/
+function projectStrip(bar, visible) {
+	const groups = [];
+	for (const section of bar.sections) for (const group of section.groups) {
+		const commands = group.units.map((u) => u.kind === "custom" ? u.terminal : u.command).filter(visible);
+		if (commands.length === 0) continue;
+		groups.push({
+			id: group.id,
+			labelKey: group.labelKey,
+			commands
+		});
+	}
+	return groups;
+}
+//#endregion
+//#region src/shortcuts.ts
+const MODIFIERS = /* @__PURE__ */ new Set([
+	"mod",
+	"ctrl",
+	"control",
+	"meta",
+	"cmd",
+	"command",
+	"alt",
+	"option",
+	"shift"
+]);
+function parseShortcut(shortcut) {
+	const tokens = shortcut.split("+").map((t) => t.trim());
+	const parsed = {
+		key: (tokens[tokens.length - 1] === "" ? "+" : tokens[tokens.length - 1]).toLowerCase(),
+		mod: false,
+		ctrl: false,
+		meta: false,
+		alt: false,
+		shift: false
+	};
+	for (const token of tokens.slice(0, -1)) {
+		const t = token.toLowerCase();
+		if (t === "") continue;
+		if (!MODIFIERS.has(t)) throw new Error(`[ui-core] unknown modifier "${token}" in "${shortcut}"`);
+		if (t === "mod") parsed.mod = true;
+		else if (t === "ctrl" || t === "control") parsed.ctrl = true;
+		else if (t === "meta" || t === "cmd" || t === "command") parsed.meta = true;
+		else if (t === "alt" || t === "option") parsed.alt = true;
+		else parsed.shift = true;
+	}
+	if (parsed.key === "") throw new Error(`[ui-core] empty key in shortcut "${shortcut}"`);
+	return parsed;
+}
+function matchShortcut(parsed, stroke, opts) {
+	const wantCtrl = parsed.ctrl || parsed.mod && !opts.isMac;
+	const wantMeta = parsed.meta || parsed.mod && opts.isMac;
+	if (stroke.ctrlKey !== wantCtrl) return false;
+	if (stroke.metaKey !== wantMeta) return false;
+	if (stroke.altKey !== parsed.alt) return false;
+	if (parsed.shift && !stroke.shiftKey) return false;
+	if (!parsed.shift && stroke.shiftKey && parsed.key.length > 1) return false;
+	if (stroke.key.toLowerCase() === parsed.key) return true;
+	return parsed.key.length > 1 && stroke.code !== void 0 && stroke.code.toLowerCase() === parsed.key;
+}
+/** Display form for menu rows: '⌘K' on mac, 'Ctrl+K' elsewhere. */
+function formatShortcut(shortcut, opts) {
+	const parsed = parseShortcut(shortcut);
+	const key = parsed.key.length === 1 ? parsed.key.toUpperCase() : capitalize(parsed.key);
+	if (opts.isMac) return `${[
+		parsed.ctrl ? "⌃" : "",
+		parsed.alt ? "⌥" : "",
+		parsed.shift ? "⇧" : "",
+		parsed.meta || parsed.mod ? "⌘" : ""
+	].join("")}${key}`;
+	return [...[
+		parsed.ctrl || parsed.mod ? "Ctrl" : "",
+		parsed.meta ? "Meta" : "",
+		parsed.alt ? "Alt" : "",
+		parsed.shift ? "Shift" : ""
+	].filter(Boolean), key].join("+");
+}
+function capitalize(s) {
+	return s.charAt(0).toUpperCase() + s.slice(1);
+}
+//#endregion
+export { DEFAULT_IMPORTANCE, PINNED, addItem, chromeHelpers, custom, defineChrome, filterBar, formatShortcut, group, item, matchShortcut, normalizeBar, parseShortcut, projectOverflow, projectShed, projectStrip, removeItems, replaceItem, solve, validateChrome };
+
+//# sourceMappingURL=index.js.map