@adea-ai/ui 0.140.0 → 0.142.0

package/dist/components/composites/file-tree/build-file-tree.js

@@ -0,0 +1,325 @@
+//#region src/components/composites/file-tree/build-file-tree.ts
+/** Deeper paths are rejected: no real repository nests this far, and a row's indent would be unusable. */
+var FILE_TREE_MAX_DEPTH = 256;
+var MAX_SEGMENT_LENGTH = 1024;
+function hasForbiddenCharacter(value) {
+	for (let i = 0; i < value.length; i += 1) {
+		const code = value.charCodeAt(i);
+		if (code < 32 || code >= 127 && code <= 159 || code >= 8234 && code <= 8238 || code >= 8294 && code <= 8297 || code === 8232 || code === 8233) return true;
+	}
+	return false;
+}
+/**
+* A path as its segments, or `null` when it is not acceptable. Both separators
+* are accepted, empty and `.` segments are dropped (`a//b`, `./a`, trailing `/`),
+* and a leading separator is dropped, so an absolute path becomes relative to
+* the tree's root rather than escaping it.
+*/
+function normalizePath(path) {
+	if (typeof path !== "string" || hasForbiddenCharacter(path)) return null;
+	const segments = [];
+	let start = 0;
+	for (let i = 0; i <= path.length; i += 1) {
+		if (i !== path.length && path[i] !== "/" && path[i] !== "\\") continue;
+		const segment = path.slice(start, i);
+		start = i + 1;
+		if (segment === "" || segment === ".") continue;
+		if (segment === ".." || segment.length > MAX_SEGMENT_LENGTH) return null;
+		segments.push(segment);
+		if (segments.length > 256) return null;
+	}
+	return segments.length === 0 ? null : segments;
+}
+function newDraft(id, name) {
+	return {
+		id,
+		name,
+		children: /* @__PURE__ */ new Map(),
+		explicit: false
+	};
+}
+function compareNodes(a, b) {
+	if (a.kind !== b.kind) return a.kind === "directory" ? -1 : 1;
+	const left = a.name.toLowerCase();
+	const right = b.name.toLowerCase();
+	if (left !== right) return left < right ? -1 : 1;
+	return a.name < b.name ? -1 : a.name > b.name ? 1 : 0;
+}
+function safeCount(value) {
+	return typeof value === "number" && Number.isFinite(value) && value >= 0 ? Math.floor(value) : void 0;
+}
+var CHANGE_KINDS = /* @__PURE__ */ new Set([
+	"added",
+	"modified",
+	"deleted",
+	"renamed"
+]);
+/**
+* Build the tree. Folders sort before files, then by name without regard to
+* case. A path that is both a file and the parent of another path is a folder
+* that keeps the file entry's change (a file replaced by a directory is a real
+* thing to report).
+*/
+function buildFileTree(paths, options = {}) {
+	const root = newDraft("", "");
+	const rejected = [];
+	let duplicates = 0;
+	for (const input of paths) {
+		const entry = typeof input === "string" ? { path: input } : input && typeof input === "object" ? input : void 0;
+		const segments = normalizePath(entry?.path);
+		if (!entry || !segments) {
+			rejected.push(typeof input === "string" ? input : String(input?.path ?? ""));
+			continue;
+		}
+		let node = root;
+		let id = "";
+		for (const segment of segments) {
+			id = id === "" ? segment : `${id}/${segment}`;
+			let child = node.children.get(segment);
+			if (!child) {
+				child = newDraft(id, segment);
+				node.children.set(segment, child);
+			}
+			node = child;
+		}
+		if (node.explicit) {
+			duplicates += 1;
+			continue;
+		}
+		node.explicit = true;
+		if (entry.change && CHANGE_KINDS.has(entry.change)) node.change = entry.change;
+		if (typeof entry.renamedFrom === "string" && !hasForbiddenCharacter(entry.renamedFrom)) node.renamedFrom = entry.renamedFrom;
+		node.additions = safeCount(entry.additions);
+		node.deletions = safeCount(entry.deletions);
+	}
+	const order = [];
+	const parentOf = [];
+	const stack = [...root.children.values()].map((draft) => [draft, -1]);
+	while (stack.length > 0) {
+		const [draft, parent] = stack.pop();
+		const index = order.length;
+		order.push(draft);
+		parentOf.push(parent);
+		for (const child of draft.children.values()) stack.push([child, index]);
+	}
+	const built = order.map(() => []);
+	const roots = [];
+	const compact = options.compact !== false;
+	let fileCount = 0;
+	for (let index = order.length - 1; index >= 0; index -= 1) {
+		const draft = order[index];
+		const children = built[index].toSorted(compareNodes);
+		let node;
+		const only = children.length === 1 ? children[0] : void 0;
+		if (compact && only?.kind === "directory" && draft.change === void 0) node = {
+			...only,
+			name: `${draft.name}/${only.name}`
+		};
+		else if (children.length > 0) node = {
+			id: draft.id,
+			name: draft.name,
+			kind: "directory",
+			...draft.change && { change: draft.change },
+			...draft.renamedFrom !== void 0 && { renamedFrom: draft.renamedFrom },
+			children,
+			fileCount: children.reduce((sum, child) => sum + child.fileCount, 0)
+		};
+		else {
+			fileCount += 1;
+			node = {
+				id: draft.id,
+				name: draft.name,
+				kind: "file",
+				...draft.change && { change: draft.change },
+				...draft.renamedFrom !== void 0 && { renamedFrom: draft.renamedFrom },
+				...draft.additions !== void 0 && { additions: draft.additions },
+				...draft.deletions !== void 0 && { deletions: draft.deletions },
+				children: [],
+				fileCount: 1
+			};
+		}
+		const parent = parentOf[index];
+		if (parent === -1) roots.push(node);
+		else built[parent].push(node);
+	}
+	roots.sort(compareNodes);
+	return {
+		roots,
+		rejected,
+		duplicates,
+		fileCount
+	};
+}
+/**
+* The rows that are on screen, in reading order. A collapsed folder's subtree
+* is never visited, so toggling a folder in a 5 000-file tree costs the size of
+* what is visible, not of what exists.
+*/
+function flattenFileTree(roots, expanded) {
+	const rows = [];
+	const stack = [];
+	for (let i = roots.length - 1; i >= 0; i -= 1) stack.push([
+		roots[i],
+		1,
+		null
+	]);
+	while (stack.length > 0) {
+		const [node, level, parentId] = stack.pop();
+		const open = node.kind === "directory" && expanded.has(node.id);
+		rows.push({
+			node,
+			level,
+			parentId,
+			expanded: open
+		});
+		if (open) for (let i = node.children.length - 1; i >= 0; i -= 1) stack.push([
+			node.children[i],
+			level + 1,
+			node.id
+		]);
+	}
+	return rows;
+}
+/** Every node by id, for turning a row id back into its node. */
+function indexFileTree(roots) {
+	const index = /* @__PURE__ */ new Map();
+	const stack = [...roots];
+	while (stack.length > 0) {
+		const node = stack.pop();
+		index.set(node.id, node);
+		for (const child of node.children) stack.push(child);
+	}
+	return index;
+}
+/** Tree this small opens fully by default; a larger one opens only its top level. */
+var FILE_TREE_AUTO_EXPAND_LIMIT = 100;
+/**
+* Which folders start open. `true` opens every folder, a number opens folders up
+* to that depth (1 is the top level), a list opens exactly those ids, `false`
+* none. Unset is "auto": everything for a small tree, the top level for a large
+* one, because a tree that opens 5 000 rows is the freeze this exists to avoid.
+*/
+function initialExpanded(roots, spec, fileCount) {
+	const open = /* @__PURE__ */ new Set();
+	if (Array.isArray(spec)) {
+		for (const id of spec) open.add(id);
+		return open;
+	}
+	const depth = spec === true ? Infinity : spec === false ? 0 : typeof spec === "number" ? Math.max(0, Math.floor(spec)) : fileCount <= 100 ? Infinity : 1;
+	const stack = roots.map((node) => [node, 1]);
+	while (stack.length > 0) {
+		const [node, level] = stack.pop();
+		if (node.kind !== "directory" || level > depth) continue;
+		open.add(node.id);
+		for (const child of node.children) stack.push([child, level + 1]);
+	}
+	return open;
+}
+/**
+* A window clamped to what exists, and never narrower than one page when that
+* many rows are there. Rows collapse and files are removed while a window is
+* held, so every read goes through this.
+*/
+function clampWindow(window, total, page) {
+	if (total <= 0) return {
+		start: 0,
+		end: 0
+	};
+	const start = Math.min(Math.max(0, window.start), total - 1);
+	return {
+		start,
+		end: Math.min(total, Math.max(window.end, start + Math.max(1, page)))
+	};
+}
+/**
+* The window after the keyboard (or typeahead) asks for a row. A row inside the
+* window changes nothing. A row just outside it — an arrow key at the edge — grows
+* the window by one page, so walking the tree costs a page at a time. Anything
+* further is a jump (End, Home, a typed letter): the window moves to the page that
+* holds the row instead of mounting every row between, which is what keeps End on
+* a 5 000-row tree from being a multi-second freeze.
+*/
+function revealInWindow(window, index, total, page) {
+	const current = clampWindow(window, total, page);
+	if (index < 0 || index >= total) return current;
+	if (index >= current.start && index < current.end) return current;
+	if (index === current.start - 1) return {
+		start: Math.max(0, current.start - page),
+		end: current.end
+	};
+	if (index === current.end) return {
+		start: current.start,
+		end: Math.min(total, current.end + page)
+	};
+	const start = Math.floor(index / page) * page;
+	return {
+		start,
+		end: Math.min(total, start + page)
+	};
+}
+function countChanges(roots) {
+	const counts = {
+		total: 0,
+		added: 0,
+		modified: 0,
+		deleted: 0,
+		renamed: 0,
+		unspecified: 0
+	};
+	const stack = [...roots];
+	while (stack.length > 0) {
+		const node = stack.pop();
+		for (const child of node.children) stack.push(child);
+		if (node.kind !== "file") continue;
+		counts.total += 1;
+		if (node.change) counts[node.change] += 1;
+		else counts.unspecified += 1;
+	}
+	return counts;
+}
+/**
+* The summary in words: "12 files changed: 3 added, 8 modified, 1 deleted". Only
+* kinds that occur are named, and files with no kind are not folded into any of
+* them. Empty is empty, not "0 files changed".
+*/
+function describeChanges(counts) {
+	if (counts.total === 0) return "No changed files";
+	const parts = [];
+	for (const kind of [
+		"added",
+		"modified",
+		"deleted",
+		"renamed"
+	]) if (counts[kind] > 0) parts.push(`${counts[kind].toLocaleString()} ${kind}`);
+	const noun = counts.total === 1 ? "file" : "files";
+	const head = `${counts.total.toLocaleString()} ${noun} changed`;
+	return parts.length > 0 ? `${head}: ${parts.join(", ")}` : head;
+}
+/** The words for a change, which are drawn on the row and so also spoken. */
+var FILE_CHANGE_LABELS = {
+	added: "Added",
+	modified: "Modified",
+	deleted: "Deleted",
+	renamed: "Renamed"
+};
+/**
+* The row a typed prefix jumps to. One typed letter searches from the row after
+* the active one, so pressing it again cycles; a longer string searches from the
+* active row, so refining a match does not skip past it. Matching ignores case.
+*/
+function typeaheadIndex(labels, activeIndex, query) {
+	const needle = query.toLowerCase();
+	if (needle === "" || labels.length === 0) return -1;
+	const repeated = needle.length > 1 && [...needle].every((char) => char === needle[0]);
+	const prefix = repeated ? needle[0] : needle;
+	const first = needle.length === 1 || repeated ? activeIndex + 1 : Math.max(0, activeIndex);
+	for (let offset = 0; offset < labels.length; offset += 1) {
+		const index = (first + offset) % labels.length;
+		if (labels[index].toLowerCase().startsWith(prefix)) return index;
+	}
+	return -1;
+}
+//#endregion
+export { FILE_CHANGE_LABELS, FILE_TREE_AUTO_EXPAND_LIMIT, FILE_TREE_MAX_DEPTH, buildFileTree, clampWindow, countChanges, describeChanges, flattenFileTree, indexFileTree, initialExpanded, normalizePath, revealInWindow, typeaheadIndex };
+
+//# sourceMappingURL=build-file-tree.js.map

package/dist/components/composites/file-tree/build-file-tree.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"build-file-tree.js","names":[],"sources":["../../../../src/components/composites/file-tree/build-file-tree.ts"],"sourcesContent":["/**\n * The model behind the changed-files tree: paths in, a folder tree out, and the\n * small pure rules the view needs (what is visible, what to say about the\n * changes, what a typed letter jumps to).\n *\n * Paths come from an agent, which means from a model, which means they are\n * untrusted text. They are used here as labels and as ids, never as places to\n * read or write, and the builder is strict about what counts as a path at all:\n * a `..` segment, a control character or a bidirectional override rejects the\n * path rather than being cleaned up, because a cleaned-up path is a different\n * path and the tree would be making a claim the input did not. Rejected paths\n * are returned, not dropped silently, so the view can say how many it ignored.\n *\n * Everything is iterative. A path with ten thousand segments, or a tree five\n * thousand files wide, must not be able to overflow the stack or stall the page.\n */\n\nexport type FileChangeKind = 'added' | 'modified' | 'deleted' | 'renamed'\n\nexport type FileChangeInput = Readonly<{\n  path: string\n  /** Absent means the host did not say; the tree makes no statement about the file. */\n  change?: FileChangeKind\n  /** For a rename, where the file was. Shown as text only. */\n  renamedFrom?: string\n  additions?: number\n  deletions?: number\n}>\n\nexport type FileTreeNode = Readonly<{\n  /** The normalised path, `/`-separated. Unique within a tree. */\n  id: string\n  /** The label. For a compacted folder chain this is `a/b/c`. */\n  name: string\n  kind: 'file' | 'directory'\n  change?: FileChangeKind\n  renamedFrom?: string\n  additions?: number\n  deletions?: number\n  children: readonly FileTreeNode[]\n  /** Files at or below this node. A file counts itself. */\n  fileCount: number\n}>\n\nexport type FileTreeBuild = Readonly<{\n  roots: readonly FileTreeNode[]\n  /** Inputs that were not accepted as paths, exactly as given. */\n  rejected: readonly string[]\n  /** Inputs that named a path already present. The first one wins. */\n  duplicates: number\n  fileCount: number\n}>\n\nexport type BuildFileTreeOptions = {\n  /** Merge a folder with a single folder child into one row (`src/lib`). Default true. */\n  compact?: boolean\n}\n\n/** Deeper paths are rejected: no real repository nests this far, and a row's indent would be unusable. */\nexport const FILE_TREE_MAX_DEPTH = 256\nconst MAX_SEGMENT_LENGTH = 1024\n\nfunction hasForbiddenCharacter(value: string): boolean {\n  for (let i = 0; i < value.length; i += 1) {\n    const code = value.charCodeAt(i)\n    if (\n      code < 0x20 ||\n      (code >= 0x7f && code <= 0x9f) ||\n      (code >= 0x202a && code <= 0x202e) ||\n      (code >= 0x2066 && code <= 0x2069) ||\n      code === 0x2028 ||\n      code === 0x2029\n    ) {\n      return true\n    }\n  }\n  return false\n}\n\n/**\n * A path as its segments, or `null` when it is not acceptable. Both separators\n * are accepted, empty and `.` segments are dropped (`a//b`, `./a`, trailing `/`),\n * and a leading separator is dropped, so an absolute path becomes relative to\n * the tree's root rather than escaping it.\n */\nexport function normalizePath(path: unknown): string[] | null {\n  if (typeof path !== 'string' || hasForbiddenCharacter(path)) return null\n  const segments: string[] = []\n  let start = 0\n  for (let i = 0; i <= path.length; i += 1) {\n    if (i !== path.length && path[i] !== '/' && path[i] !== '\\\\') continue\n    const segment = path.slice(start, i)\n    start = i + 1\n    if (segment === '' || segment === '.') continue\n    if (segment === '..' || segment.length > MAX_SEGMENT_LENGTH) return null\n    segments.push(segment)\n    if (segments.length > FILE_TREE_MAX_DEPTH) return null\n  }\n  return segments.length === 0 ? null : segments\n}\n\ntype Draft = {\n  id: string\n  name: string\n  children: Map<string, Draft>\n  change?: FileChangeKind\n  renamedFrom?: string\n  additions?: number\n  deletions?: number\n  explicit: boolean\n}\n\nfunction newDraft(id: string, name: string): Draft {\n  return { id, name, children: new Map(), explicit: false }\n}\n\nfunction compareNodes(a: FileTreeNode, b: FileTreeNode): number {\n  if (a.kind !== b.kind) return a.kind === 'directory' ? -1 : 1\n  const left = a.name.toLowerCase()\n  const right = b.name.toLowerCase()\n  if (left !== right) return left < right ? -1 : 1\n  return a.name < b.name ? -1 : a.name > b.name ? 1 : 0\n}\n\nfunction safeCount(value: unknown): number | undefined {\n  return typeof value === 'number' && Number.isFinite(value) && value >= 0\n    ? Math.floor(value)\n    : undefined\n}\n\nconst CHANGE_KINDS: ReadonlySet<string> = new Set(['added', 'modified', 'deleted', 'renamed'])\n\n/**\n * Build the tree. Folders sort before files, then by name without regard to\n * case. A path that is both a file and the parent of another path is a folder\n * that keeps the file entry's change (a file replaced by a directory is a real\n * thing to report).\n */\nexport function buildFileTree(\n  paths: readonly (string | FileChangeInput)[],\n  options: BuildFileTreeOptions = {}\n): FileTreeBuild {\n  const root = newDraft('', '')\n  const rejected: string[] = []\n  let duplicates = 0\n\n  for (const input of paths) {\n    const entry: FileChangeInput | undefined =\n      typeof input === 'string'\n        ? { path: input }\n        : input && typeof input === 'object'\n          ? input\n          : undefined\n    const segments = normalizePath(entry?.path)\n    if (!entry || !segments) {\n      rejected.push(\n        typeof input === 'string' ? input : String((input as { path?: unknown })?.path ?? '')\n      )\n      continue\n    }\n\n    let node = root\n    let id = ''\n    for (const segment of segments) {\n      id = id === '' ? segment : `${id}/${segment}`\n      let child = node.children.get(segment)\n      if (!child) {\n        child = newDraft(id, segment)\n        node.children.set(segment, child)\n      }\n      node = child\n    }\n    if (node.explicit) {\n      duplicates += 1\n      continue\n    }\n    node.explicit = true\n    if (entry.change && CHANGE_KINDS.has(entry.change)) node.change = entry.change\n    if (typeof entry.renamedFrom === 'string' && !hasForbiddenCharacter(entry.renamedFrom)) {\n      node.renamedFrom = entry.renamedFrom\n    }\n    node.additions = safeCount(entry.additions)\n    node.deletions = safeCount(entry.deletions)\n  }\n\n  // Pre-order flatten, then fold back in reverse: a child always has a larger\n  // index than its parent, so one backwards pass builds every node after its\n  // children without recursion.\n  const order: Draft[] = []\n  const parentOf: number[] = []\n  const stack: [Draft, number][] = [...root.children.values()].map((draft) => [draft, -1])\n  while (stack.length > 0) {\n    const [draft, parent] = stack.pop()!\n    const index = order.length\n    order.push(draft)\n    parentOf.push(parent)\n    for (const child of draft.children.values()) stack.push([child, index])\n  }\n\n  const built: FileTreeNode[][] = order.map(() => [])\n  const roots: FileTreeNode[] = []\n  const compact = options.compact !== false\n  let fileCount = 0\n\n  for (let index = order.length - 1; index >= 0; index -= 1) {\n    const draft = order[index]!\n    const children = built[index]!.toSorted(compareNodes)\n    let node: FileTreeNode\n    const only = children.length === 1 ? children[0]! : undefined\n    if (compact && only?.kind === 'directory' && draft.change === undefined) {\n      // A folder holding only another folder reads as one row: `src/lib`, not two.\n      node = { ...only, name: `${draft.name}/${only.name}` }\n    } else if (children.length > 0) {\n      node = {\n        id: draft.id,\n        name: draft.name,\n        kind: 'directory',\n        ...(draft.change && { change: draft.change }),\n        ...(draft.renamedFrom !== undefined && { renamedFrom: draft.renamedFrom }),\n        children,\n        fileCount: children.reduce((sum, child) => sum + child.fileCount, 0),\n      }\n    } else {\n      fileCount += 1\n      node = {\n        id: draft.id,\n        name: draft.name,\n        kind: 'file',\n        ...(draft.change && { change: draft.change }),\n        ...(draft.renamedFrom !== undefined && { renamedFrom: draft.renamedFrom }),\n        ...(draft.additions !== undefined && { additions: draft.additions }),\n        ...(draft.deletions !== undefined && { deletions: draft.deletions }),\n        children: [],\n        fileCount: 1,\n      }\n    }\n    const parent = parentOf[index]!\n    if (parent === -1) roots.push(node)\n    else built[parent]!.push(node)\n  }\n\n  roots.sort(compareNodes)\n  return { roots, rejected, duplicates, fileCount }\n}\n\n// ---------------------------------------------------------------------------\n// Projection\n// ---------------------------------------------------------------------------\n\nexport type FileTreeRow = Readonly<{\n  node: FileTreeNode\n  /** One-based depth. */\n  level: number\n  parentId: string | null\n  expanded: boolean\n}>\n\n/**\n * The rows that are on screen, in reading order. A collapsed folder's subtree\n * is never visited, so toggling a folder in a 5 000-file tree costs the size of\n * what is visible, not of what exists.\n */\nexport function flattenFileTree(\n  roots: readonly FileTreeNode[],\n  expanded: ReadonlySet<string>\n): FileTreeRow[] {\n  const rows: FileTreeRow[] = []\n  const stack: [FileTreeNode, number, string | null][] = []\n  for (let i = roots.length - 1; i >= 0; i -= 1) stack.push([roots[i]!, 1, null])\n  while (stack.length > 0) {\n    const [node, level, parentId] = stack.pop()!\n    const open = node.kind === 'directory' && expanded.has(node.id)\n    rows.push({ node, level, parentId, expanded: open })\n    if (open) {\n      for (let i = node.children.length - 1; i >= 0; i -= 1) {\n        stack.push([node.children[i]!, level + 1, node.id])\n      }\n    }\n  }\n  return rows\n}\n\n/** Every node by id, for turning a row id back into its node. */\nexport function indexFileTree(roots: readonly FileTreeNode[]): Map<string, FileTreeNode> {\n  const index = new Map<string, FileTreeNode>()\n  const stack = [...roots]\n  while (stack.length > 0) {\n    const node = stack.pop()!\n    index.set(node.id, node)\n    for (const child of node.children) stack.push(child)\n  }\n  return index\n}\n\nexport type FileTreeExpansion = boolean | number | readonly string[] | undefined\n\n/** Tree this small opens fully by default; a larger one opens only its top level. */\nexport const FILE_TREE_AUTO_EXPAND_LIMIT = 100\n\n/**\n * Which folders start open. `true` opens every folder, a number opens folders up\n * to that depth (1 is the top level), a list opens exactly those ids, `false`\n * none. Unset is \"auto\": everything for a small tree, the top level for a large\n * one, because a tree that opens 5 000 rows is the freeze this exists to avoid.\n */\nexport function initialExpanded(\n  roots: readonly FileTreeNode[],\n  spec: FileTreeExpansion,\n  fileCount: number\n): Set<string> {\n  const open = new Set<string>()\n  if (Array.isArray(spec)) {\n    for (const id of spec) open.add(id)\n    return open\n  }\n  const depth =\n    spec === true\n      ? Infinity\n      : spec === false\n        ? 0\n        : typeof spec === 'number'\n          ? Math.max(0, Math.floor(spec))\n          : fileCount <= FILE_TREE_AUTO_EXPAND_LIMIT\n            ? Infinity\n            : 1\n  const stack: [FileTreeNode, number][] = roots.map((node) => [node, 1])\n  while (stack.length > 0) {\n    const [node, level] = stack.pop()!\n    if (node.kind !== 'directory' || level > depth) continue\n    open.add(node.id)\n    for (const child of node.children) stack.push([child, level + 1])\n  }\n  return open\n}\n\n// ---------------------------------------------------------------------------\n// Mounted window\n// ---------------------------------------------------------------------------\n\n/** The slice of visible rows that is mounted: `start` inclusive, `end` exclusive. */\nexport type RowWindow = Readonly<{ start: number; end: number }>\n\n/**\n * A window clamped to what exists, and never narrower than one page when that\n * many rows are there. Rows collapse and files are removed while a window is\n * held, so every read goes through this.\n */\nexport function clampWindow(window: RowWindow, total: number, page: number): RowWindow {\n  if (total <= 0) return { start: 0, end: 0 }\n  const start = Math.min(Math.max(0, window.start), total - 1)\n  return { start, end: Math.min(total, Math.max(window.end, start + Math.max(1, page))) }\n}\n\n/**\n * The window after the keyboard (or typeahead) asks for a row. A row inside the\n * window changes nothing. A row just outside it — an arrow key at the edge — grows\n * the window by one page, so walking the tree costs a page at a time. Anything\n * further is a jump (End, Home, a typed letter): the window moves to the page that\n * holds the row instead of mounting every row between, which is what keeps End on\n * a 5 000-row tree from being a multi-second freeze.\n */\nexport function revealInWindow(\n  window: RowWindow,\n  index: number,\n  total: number,\n  page: number\n): RowWindow {\n  const current = clampWindow(window, total, page)\n  if (index < 0 || index >= total) return current\n  if (index >= current.start && index < current.end) return current\n  if (index === current.start - 1) {\n    return { start: Math.max(0, current.start - page), end: current.end }\n  }\n  if (index === current.end)\n    return { start: current.start, end: Math.min(total, current.end + page) }\n  const start = Math.floor(index / page) * page\n  return { start, end: Math.min(total, start + page) }\n}\n\n// ---------------------------------------------------------------------------\n// Words\n// ---------------------------------------------------------------------------\n\nexport type ChangeCounts = Readonly<{\n  total: number\n  added: number\n  modified: number\n  deleted: number\n  renamed: number\n  /** Files with no change kind supplied. */\n  unspecified: number\n}>\n\nexport function countChanges(roots: readonly FileTreeNode[]): ChangeCounts {\n  const counts = { total: 0, added: 0, modified: 0, deleted: 0, renamed: 0, unspecified: 0 }\n  const stack = [...roots]\n  while (stack.length > 0) {\n    const node = stack.pop()!\n    for (const child of node.children) stack.push(child)\n    if (node.kind !== 'file') continue\n    counts.total += 1\n    if (node.change) counts[node.change] += 1\n    else counts.unspecified += 1\n  }\n  return counts\n}\n\n/**\n * The summary in words: \"12 files changed: 3 added, 8 modified, 1 deleted\". Only\n * kinds that occur are named, and files with no kind are not folded into any of\n * them. Empty is empty, not \"0 files changed\".\n */\nexport function describeChanges(counts: ChangeCounts): string {\n  if (counts.total === 0) return 'No changed files'\n  const parts: string[] = []\n  for (const kind of ['added', 'modified', 'deleted', 'renamed'] as const) {\n    if (counts[kind] > 0) parts.push(`${counts[kind].toLocaleString()} ${kind}`)\n  }\n  const noun = counts.total === 1 ? 'file' : 'files'\n  const head = `${counts.total.toLocaleString()} ${noun} changed`\n  return parts.length > 0 ? `${head}: ${parts.join(', ')}` : head\n}\n\n/** The words for a change, which are drawn on the row and so also spoken. */\nexport const FILE_CHANGE_LABELS: Readonly<Record<FileChangeKind, string>> = {\n  added: 'Added',\n  modified: 'Modified',\n  deleted: 'Deleted',\n  renamed: 'Renamed',\n}\n\n// ---------------------------------------------------------------------------\n// Typeahead\n// ---------------------------------------------------------------------------\n\n/**\n * The row a typed prefix jumps to. One typed letter searches from the row after\n * the active one, so pressing it again cycles; a longer string searches from the\n * active row, so refining a match does not skip past it. Matching ignores case.\n */\nexport function typeaheadIndex(\n  labels: readonly string[],\n  activeIndex: number,\n  query: string\n): number {\n  const needle = query.toLowerCase()\n  if (needle === '' || labels.length === 0) return -1\n  const repeated = needle.length > 1 && [...needle].every((char) => char === needle[0])\n  const prefix = repeated ? needle[0]! : needle\n  const first = needle.length === 1 || repeated ? activeIndex + 1 : Math.max(0, activeIndex)\n  for (let offset = 0; offset < labels.length; offset += 1) {\n    const index = (first + offset) % labels.length\n    if (labels[index]!.toLowerCase().startsWith(prefix)) return index\n  }\n  return -1\n}\n"],"mappings":"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"}

package/dist/components/composites/file-tree/file-tree.d.ts

@@ -0,0 +1,74 @@
+import { type ComponentProps } from 'solid-js';
+import { type FileChangeInput, type FileTreeExpansion, type FileTreeNode } from './build-file-tree';
+/**
+ * FileTree.
+ *
+ * The files an agent changed, as a folder tree. It is for a change set — dozens
+ * to thousands of paths with an optional change kind each — and not for browsing
+ * a workspace: it has no rename, drag, or filesystem action, and it never opens
+ * anything. Reach for `Trace` lines when the agent touched two or three files, and
+ * for the shared `Tree` directly when the host owns a real file explorer.
+ *
+ * ## Built on `Tree`, and why that fits
+ *
+ * `Tree` supplies the treeitem semantics and the WAI-ARIA keyboard model (arrows,
+ * Home/End, roving tab stop) and leaves the projection to the host. A changed-file
+ * tree is small enough that the whole projection can live in memory, and the
+ * `Tree` contract for a mounted window — a complete `visibleItems` list with only
+ * some rows rendered, `onRequestReveal` to mount a row the keyboard moved to — is
+ * exactly the seam a bounded render needs, so this adds no navigation code of
+ * its own. What it adds is typeahead, which `Tree` does not provide: a typed
+ * prefix jumps to the next row whose name starts with it.
+ *
+ * ## Large trees
+ *
+ * A collapsed folder's subtree is never visited or rendered, so a 5 000-file tree
+ * costs what is visible. A tree of more than 100 files starts with only its top
+ * level open (`defaultExpanded` overrides). Past `maxRows` visible rows only a
+ * window of them is mounted, with a control above and below to move it a page at
+ * a time. The full list is what keyboard navigation walks: an arrow key at the
+ * window's edge grows it by a page, and a jump (End, Home, a typed letter) moves
+ * it to the page holding the target instead of mounting every row between, so End
+ * on a tree of thousands of open rows stays one page of work.
+ *
+ * ## Changes are claims
+ *
+ * A change kind is drawn — as a word on the row, so it is also spoken — only for a
+ * file the host gave one. A file without one is listed and nothing more is said.
+ * The summary counts what was supplied, and is silent about files with no kind.
+ * Paths that are not acceptable (`..` segments, control characters) are not drawn;
+ * their number is stated, so the list is never quietly shorter than the input.
+ *
+ * ## Selection is the host's
+ *
+ * Rows select only when `onSelect` is supplied; without it no row is selectable
+ * and `aria-selected` is not set. Enter or a click on a folder expands it; on a
+ * file it selects. Space selects either. The tree never opens a file itself — the
+ * path is untrusted text, and what it means on this machine is the host's call.
+ */
+export type FileTreeProps = Omit<ComponentProps<'div'>, 'children' | 'onSelect'> & {
+    /** Paths, or paths with a change kind. Both `/` and `\` separate segments. */
+    files: readonly (string | FileChangeInput)[];
+    /** The tree's accessible name. Default "Changed files". */
+    label?: string;
+    /**
+     * Which folders start open: `true` all, `false` none, a number to that depth,
+     * or a list of ids. Unset opens a small tree fully and a large one at its top level.
+     */
+    defaultExpanded?: FileTreeExpansion;
+    /** Merge a folder with a single folder child into one row. Default true. */
+    compact?: boolean;
+    /** The selected node's id. Meaningful only with `onSelect`. */
+    selected?: string;
+    /** Make rows selectable. Omit and nothing is selectable. */
+    onSelect?: (path: string, node: FileTreeNode) => void;
+    /** Height of the tree box, which scrolls past it. A number is pixels. Default `20rem`. */
+    maxHeight?: number | string;
+    /** Visible rows mounted at once; more are added a page at a time. Default 500. */
+    maxRows?: number;
+    /** Show the count of changes above the tree. Default true. */
+    showSummary?: boolean;
+};
+export declare const FILE_TREE_MAX_ROWS = 500;
+export declare function FileTree(props: FileTreeProps): import("solid-js").JSX.Element;
+//# sourceMappingURL=file-tree.d.ts.map

package/dist/components/composites/file-tree/file-tree.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"file-tree.d.ts","sourceRoot":"","sources":["../../../../src/components/composites/file-tree/file-tree.tsx"],"names":[],"mappings":"AACA,OAAO,EASL,KAAK,cAAc,EACpB,MAAM,UAAU,CAAA;AAMjB,OAAO,EAYL,KAAK,eAAe,EAEpB,KAAK,iBAAiB,EACtB,KAAK,YAAY,EAElB,MAAM,mBAAmB,CAAA;AAE1B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AACH,MAAM,MAAM,aAAa,GAAG,IAAI,CAAC,cAAc,CAAC,KAAK,CAAC,EAAE,UAAU,GAAG,UAAU,CAAC,GAAG;IACjF,8EAA8E;IAC9E,KAAK,EAAE,SAAS,CAAC,MAAM,GAAG,eAAe,CAAC,EAAE,CAAA;IAC5C,2DAA2D;IAC3D,KAAK,CAAC,EAAE,MAAM,CAAA;IACd;;;OAGG;IACH,eAAe,CAAC,EAAE,iBAAiB,CAAA;IACnC,4EAA4E;IAC5E,OAAO,CAAC,EAAE,OAAO,CAAA;IACjB,+DAA+D;IAC/D,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,4DAA4D;IAC5D,QAAQ,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,YAAY,KAAK,IAAI,CAAA;IACrD,0FAA0F;IAC1F,SAAS,CAAC,EAAE,MAAM,GAAG,MAAM,CAAA;IAC3B,kFAAkF;IAClF,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,8DAA8D;IAC9D,WAAW,CAAC,EAAE,OAAO,CAAA;CACtB,CAAA;AAED,eAAO,MAAM,kBAAkB,MAAM,CAAA;AAuErC,wBAAgB,QAAQ,CAAC,KAAK,EAAE,aAAa,kCAmO5C"}