@densedash/core 0.1.1 → 0.2.0

package/dist/navigation/state.js

@@ -0,0 +1,265 @@
+import { reconcile } from "./reconcile.js";
+import { functionalUpdate, stateSlicesEqual } from "@tanstack/table-core";
+// src/navigation/state.ts
+function changeDetails({ reason = "programmatic", event } = {}) {
+	let canceled = false;
+	return {
+		reason,
+		event,
+		cancel() {
+			canceled = true;
+		},
+		get canceled() {
+			return canceled;
+		}
+	};
+}
+const keyState = (keys) => Object.fromEntries(Array.from(keys, (key) => [key, true]));
+const selectedKeys = (state) => new Set(Object.keys(state).filter((key) => state[key]));
+const controls = [
+	"expanded",
+	"sorting",
+	"highlighted",
+	"rowSelection"
+];
+/** Table atoms are the authority. The kernel store publishes one adapter snapshot per transaction. */
+function createNavigationModel(kernel, table, initial) {
+	let options = initial;
+	let disposed = false;
+	let publishing = false;
+	let staged;
+	let action = {};
+	const queued = [];
+	const subscriptions = /* @__PURE__ */ new Set();
+	function read() {
+		return table.store.state;
+	}
+	let validatedRows;
+	function rows() {
+		const core = table.getCoreRowModel();
+		if (validatedRows !== core.flatRows) {
+			const ids = /* @__PURE__ */ new Set();
+			for (const row of core.flatRows) {
+				if (ids.has(row.id)) throw new Error(`Duplicate row id "${row.id}".`);
+				ids.add(row.id);
+			}
+			validatedRows = core.flatRows;
+		}
+		return table.getRowModel().rows;
+	}
+	let projected;
+	function project() {
+		const state = read();
+		const visible = rows();
+		if (projected?.source !== visible || projected.expanded !== state.expanded || projected.disabled !== options.isDisabled || projected.text !== options.getTextValue) {
+			const siblings = /* @__PURE__ */ new Map();
+			for (const row of visible) {
+				const group = siblings.get(row.parentId) ?? [];
+				if (!siblings.has(row.parentId)) siblings.set(row.parentId, group);
+				group.push(row);
+			}
+			const positions = /* @__PURE__ */ new Map();
+			for (const group of siblings.values()) group.forEach((row, index) => positions.set(row.id, index + 1));
+			projected = {
+				source: visible,
+				expanded: state.expanded,
+				disabled: options.isDisabled,
+				text: options.getTextValue,
+				rows: visible.map((row, index) => ({
+					key: row.id,
+					item: row.original,
+					index,
+					depth: row.depth,
+					parentKey: row.parentId ?? null,
+					hasChildren: row.getCanExpand(),
+					expanded: row.getCanExpand() && row.getIsExpanded(),
+					posInSet: positions.get(row.id),
+					setSize: siblings.get(row.parentId).length,
+					disabled: options.isDisabled?.(row.original) ?? false,
+					textValue: options.getTextValue?.(row.original) ?? row.id
+				}))
+			};
+		}
+		return {
+			highlighted: state.highlighted,
+			anchor: state.anchor,
+			selected: selectedKeys(state.rowSelection),
+			expanded: state.expanded === true ? new Set(table.getCoreRowModel().flatRows.filter((row) => row.getCanExpand()).map((row) => row.id)) : selectedKeys(state.expanded),
+			rows: projected.rows
+		};
+	}
+	const store = kernel.ports.store.create({
+		snapshot: read(),
+		tree: project()
+	});
+	function write(patch) {
+		const atoms = table.baseAtoms;
+		for (const [key, value] of Object.entries(patch)) if (!stateSlicesEqual(atoms[key].get(), value)) atoms[key].set(value);
+	}
+	function configure(next) {
+		table.setOptions((previous) => ({
+			...previous,
+			data: next.data,
+			columns: next.columns ?? previous.columns,
+			getRowId: next.getRowId ?? ((_item, index, parent) => parent ? `${parent.id}.${index}` : `${index}`),
+			getSubRows: (item, index) => next.getSubRows?.(item, index),
+			enableRowSelection: (row) => !(next.isDisabled?.(row.original) ?? false),
+			enableMultiRowSelection: next.selectionMode === "multiple"
+		}));
+	}
+	function publish(patch, why, update) {
+		if (disposed) return;
+		if (publishing) {
+			queued.push(() => publish(patch, why, update));
+			return;
+		}
+		publishing = true;
+		const previous = read();
+		const previousOptions = options;
+		const previousTree = store.get().tree;
+		try {
+			table._reactivity.batch(() => {
+				try {
+					if (update !== void 0) {
+						const nextOptions = {
+							...options,
+							...update
+						};
+						configure(nextOptions);
+						options = nextOptions;
+						rows();
+					}
+					const baseline = { ...previous };
+					if (update !== void 0) for (const key of controls) {
+						const value = options[key]?.value;
+						if (value !== void 0) Object.assign(baseline, { [key]: value });
+					}
+					const requested = {
+						...baseline,
+						...patch
+					};
+					const effective = { ...requested };
+					for (const key of controls) if (options[key]?.value !== void 0) Object.assign(effective, { [key]: baseline[key] });
+					write(effective);
+					const visible = project();
+					const reconciled = reconcile(previousTree.rows, visible.rows, {
+						highlighted: requested.highlighted,
+						anchor: requested.anchor,
+						expanded: visible.expanded,
+						selected: selectedKeys(requested.rowSelection)
+					});
+					requested.highlighted = reconciled.highlighted;
+					requested.anchor = reconciled.anchor;
+					requested.rowSelection = keyState(reconciled.selected);
+					const details = changeDetails(why);
+					for (const key of controls) {
+						if (details.canceled || disposed) break;
+						if (stateSlicesEqual(baseline[key], requested[key])) continue;
+						switch (key) {
+							case "expanded":
+								options.expanded?.onChange?.(requested.expanded, details);
+								break;
+							case "sorting":
+								options.sorting?.onChange?.(requested.sorting, details);
+								break;
+							case "highlighted":
+								options.highlighted?.onChange?.(requested.highlighted, details);
+								break;
+							case "rowSelection": options.rowSelection?.onChange?.(requested.rowSelection, details);
+						}
+					}
+					const final = { ...details.canceled || disposed ? baseline : requested };
+					for (const key of controls) if (options[key]?.value !== void 0) Object.assign(final, { [key]: baseline[key] });
+					write(final);
+					if (!disposed) store.set({
+						snapshot: read(),
+						tree: project()
+					});
+				} catch (cause) {
+					options = previousOptions;
+					if (update !== void 0) configure(previousOptions);
+					write(previous);
+					throw cause;
+				}
+			});
+		} finally {
+			publishing = false;
+			while (!publishing && queued.length > 0 && !disposed) queued.shift()();
+		}
+	}
+	const subscription = table.store.subscribe(() => {
+		if (!publishing && !disposed) publish({}, { reason: "programmatic" });
+	});
+	function request(key, updater) {
+		if (disposed) return;
+		if (publishing) {
+			queued.push(() => request(key, updater));
+			return;
+		}
+		const current = staged?.[key] ?? read()[key];
+		const patch = { [key]: functionalUpdate(updater, current) };
+		if (staged) Object.assign(staged, patch);
+		else publish(patch, action);
+	}
+	function subscribe(listener) {
+		if (disposed) return () => {};
+		const unsubscribe = store.subscribe((value) => {
+			if (!disposed) listener(value.tree);
+		});
+		const release = () => {
+			if (subscriptions.delete(release)) unsubscribe();
+		};
+		subscriptions.add(release);
+		return release;
+	}
+	return {
+		table,
+		get: () => store.get().tree,
+		options: () => options,
+		active: () => !disposed,
+		request,
+		subscribe,
+		state: {
+			get: () => store.get().snapshot,
+			subscribe(listener) {
+				return subscribe(() => listener(store.get().snapshot));
+			}
+		},
+		run(why, run) {
+			if (disposed) return;
+			const previousAction = action;
+			action = why;
+			staged = {};
+			try {
+				run();
+				const patch = staged;
+				staged = void 0;
+				publish(patch, why);
+			} finally {
+				staged = void 0;
+				action = previousAction;
+			}
+		},
+		change(patch, why = {}) {
+			const next = {};
+			if (patch.highlighted !== void 0) next.highlighted = patch.highlighted;
+			if (patch.anchor !== void 0) next.anchor = patch.anchor;
+			if (patch.expanded !== void 0) next.expanded = keyState(patch.expanded);
+			if (patch.selected !== void 0) next.rowSelection = keyState(patch.selected);
+			if (staged) Object.assign(staged, next);
+			else publish(next, why);
+		},
+		update: (next) => publish({}, { reason: "items-changed" }, next),
+		dispose() {
+			if (disposed) return;
+			disposed = true;
+			queued.length = 0;
+			subscription.unsubscribe();
+			for (const release of subscriptions) release();
+			subscriptions.clear();
+		}
+	};
+}
+export { changeDetails, createNavigationModel, keyState };
+
+//# sourceMappingURL=state.js.map

package/dist/navigation/state.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"state.js","names":[],"sources":["../../src/navigation/state.ts"],"sourcesContent":["import type { RowData } from \"@tanstack/table-core\";\nimport { functionalUpdate, stateSlicesEqual } from \"@tanstack/table-core\";\nimport type { Updater } from \"@tanstack/table-core\";\nimport type { TreeState } from \"../collections/types.js\";\nimport type { ChangeDetails } from \"../controllable.js\";\nimport type { Kernel } from \"../kernel.js\";\nimport type { TreeAction, TreeChangeReason, TreeSnapshot } from \"../tree/types.js\";\nimport { reconcile } from \"./reconcile.js\";\nimport type { NavigationOptions, NavigationSnapshot, NavigationTable } from \"./types.js\";\n\nexport function changeDetails({\n  reason = \"programmatic\",\n  event,\n}: TreeAction = {}): ChangeDetails<TreeChangeReason> {\n  let canceled = false;\n  return {\n    reason,\n    event,\n    cancel() {\n      canceled = true;\n    },\n    get canceled() {\n      return canceled;\n    },\n  };\n}\n\nexport const keyState = (keys: ReadonlySet<string>) =>\n  Object.fromEntries(Array.from(keys, (key) => [key, true as const]));\nconst selectedKeys = (state: Record<string, boolean>) =>\n  new Set(Object.keys(state).filter((key) => state[key]));\nconst controls = [\"expanded\", \"sorting\", \"highlighted\", \"rowSelection\"] as const;\n\n/** Table atoms are the authority. The kernel store publishes one adapter snapshot per transaction. */\nexport function createNavigationModel<T extends RowData>(\n  kernel: Kernel,\n  table: NavigationTable<T>,\n  initial: NavigationOptions<T>,\n) {\n  let options = initial;\n  let disposed = false;\n  let publishing = false;\n  let staged: Partial<NavigationSnapshot> | undefined;\n  let action: TreeAction = {};\n  const queued: (() => void)[] = [];\n  const subscriptions = new Set<() => void>();\n\n  function read(): NavigationSnapshot {\n    return table.store.state;\n  }\n\n  let validatedRows: ReturnType<typeof table.getCoreRowModel>[\"flatRows\"] | undefined;\n\n  function rows() {\n    const core = table.getCoreRowModel();\n    if (validatedRows !== core.flatRows) {\n      const ids = new Set<string>();\n      for (const row of core.flatRows) {\n        if (ids.has(row.id)) throw new Error(`Duplicate row id \"${row.id}\".`);\n        ids.add(row.id);\n      }\n      validatedRows = core.flatRows;\n    }\n    return table.getRowModel().rows;\n  }\n\n  let projected:\n    | {\n        source: ReturnType<typeof rows>;\n        expanded: NavigationSnapshot[\"expanded\"];\n        disabled: NavigationOptions<T>[\"isDisabled\"];\n        text: NavigationOptions<T>[\"getTextValue\"];\n        rows: TreeSnapshot<T>[\"rows\"];\n      }\n    | undefined;\n\n  function project(): TreeSnapshot<T> {\n    const state = read();\n    const visible = rows();\n    if (\n      projected?.source !== visible ||\n      projected.expanded !== state.expanded ||\n      projected.disabled !== options.isDisabled ||\n      projected.text !== options.getTextValue\n    ) {\n      const siblings = new Map<string | undefined, typeof visible>();\n      for (const row of visible) {\n        const group = siblings.get(row.parentId) ?? [];\n        if (!siblings.has(row.parentId)) siblings.set(row.parentId, group);\n        group.push(row);\n      }\n      const positions = new Map<string, number>();\n      for (const group of siblings.values())\n        group.forEach((row, index) => positions.set(row.id, index + 1));\n      projected = {\n        source: visible,\n        expanded: state.expanded,\n        disabled: options.isDisabled,\n        text: options.getTextValue,\n        rows: visible.map((row, index) => ({\n          key: row.id,\n          item: row.original,\n          index,\n          depth: row.depth,\n          parentKey: row.parentId ?? null,\n          hasChildren: row.getCanExpand(),\n          expanded: row.getCanExpand() && row.getIsExpanded(),\n          posInSet: positions.get(row.id)!,\n          setSize: siblings.get(row.parentId)!.length,\n          disabled: options.isDisabled?.(row.original) ?? false,\n          textValue: options.getTextValue?.(row.original) ?? row.id,\n        })),\n      };\n    }\n    return {\n      highlighted: state.highlighted,\n      anchor: state.anchor,\n      selected: selectedKeys(state.rowSelection),\n      expanded:\n        state.expanded === true\n          ? new Set(\n              table\n                .getCoreRowModel()\n                .flatRows.filter((row) => row.getCanExpand())\n                .map((row) => row.id),\n            )\n          : selectedKeys(state.expanded),\n      rows: projected.rows,\n    };\n  }\n\n  const store = kernel.ports.store.create({ snapshot: read(), tree: project() });\n\n  function write(patch: Partial<NavigationSnapshot>): void {\n    // Every key is a registered state slice; the dynamic loop preserves its matching atom/value pair.\n    const atoms = table.baseAtoms as unknown as Record<\n      string,\n      { get(): unknown; set(value: unknown): void }\n    >;\n    for (const [key, value] of Object.entries(patch)) {\n      if (!stateSlicesEqual(atoms[key]!.get(), value)) atoms[key]!.set(value);\n    }\n  }\n\n  function configure(next: NavigationOptions<T>): void {\n    table.setOptions((previous) => ({\n      ...previous,\n      data: next.data,\n      columns: next.columns ?? previous.columns,\n      getRowId:\n        next.getRowId ??\n        ((_item, index, parent) => (parent ? `${parent.id}.${index}` : `${index}`)),\n      getSubRows: (item, index) => next.getSubRows?.(item, index),\n      enableRowSelection: (row) => !(next.isDisabled?.(row.original) ?? false),\n      enableMultiRowSelection: next.selectionMode === \"multiple\",\n    }));\n  }\n\n  function publish(\n    patch: Partial<NavigationSnapshot>,\n    why: TreeAction,\n    update?: Partial<NavigationOptions<T>>,\n  ): void {\n    if (disposed) return;\n    if (publishing) {\n      queued.push(() => publish(patch, why, update));\n      return;\n    }\n    publishing = true;\n    const previous = read();\n    const previousOptions = options;\n    const previousTree = store.get().tree;\n    try {\n      table._reactivity.batch(() => {\n        try {\n          if (update !== undefined) {\n            const nextOptions = { ...options, ...update };\n            configure(nextOptions);\n            options = nextOptions;\n            rows(); // Validate new IDs before any callback or publication.\n          }\n          const baseline = { ...previous };\n          if (update !== undefined) {\n            for (const key of controls) {\n              const value = options[key]?.value;\n              if (value !== undefined) Object.assign(baseline, { [key]: value });\n            }\n          }\n          const requested = { ...baseline, ...patch };\n          const effective = { ...requested };\n          for (const key of controls) {\n            if (options[key]?.value !== undefined)\n              Object.assign(effective, { [key]: baseline[key] });\n          }\n          write(effective);\n          const visible = project();\n          const reconciled = reconcile(previousTree.rows, visible.rows, {\n            highlighted: requested.highlighted,\n            anchor: requested.anchor,\n            expanded: visible.expanded,\n            selected: selectedKeys(requested.rowSelection),\n          });\n          requested.highlighted = reconciled.highlighted;\n          requested.anchor = reconciled.anchor;\n          requested.rowSelection = keyState(reconciled.selected);\n          const details = changeDetails(why);\n          for (const key of controls) {\n            if (details.canceled || disposed) break;\n            if (stateSlicesEqual(baseline[key], requested[key])) continue;\n            // The branch keeps each Controllable callback paired with its state type.\n            switch (key) {\n              case \"expanded\":\n                options.expanded?.onChange?.(requested.expanded, details);\n                break;\n              case \"sorting\":\n                options.sorting?.onChange?.(requested.sorting, details);\n                break;\n              case \"highlighted\":\n                options.highlighted?.onChange?.(requested.highlighted, details);\n                break;\n              case \"rowSelection\":\n                options.rowSelection?.onChange?.(requested.rowSelection, details);\n                break;\n            }\n          }\n          const accepted = details.canceled || disposed ? baseline : requested;\n          const final = { ...accepted };\n          for (const key of controls) {\n            if (options[key]?.value !== undefined) Object.assign(final, { [key]: baseline[key] });\n          }\n          write(final);\n          if (!disposed) store.set({ snapshot: read(), tree: project() });\n        } catch (cause) {\n          options = previousOptions;\n          if (update !== undefined) configure(previousOptions);\n          write(previous);\n          throw cause;\n        }\n      });\n    } finally {\n      publishing = false;\n      while (!publishing && queued.length > 0 && !disposed) queued.shift()!();\n    }\n  }\n\n  const subscription = table.store.subscribe(() => {\n    if (!publishing && !disposed) publish({}, { reason: \"programmatic\" });\n  });\n\n  function request<K extends keyof NavigationSnapshot>(\n    key: K,\n    updater: Updater<NavigationSnapshot[K]>,\n  ): void {\n    if (disposed) return;\n    if (publishing) {\n      queued.push(() => request(key, updater));\n      return;\n    }\n    const current = staged?.[key] ?? read()[key];\n    const patch = { [key]: functionalUpdate(updater, current) };\n    if (staged) Object.assign(staged, patch);\n    else publish(patch, action);\n  }\n\n  function subscribe(listener: (tree: TreeSnapshot<T>) => void): () => void {\n    if (disposed) return () => {};\n    const unsubscribe = store.subscribe((value) => {\n      if (!disposed) listener(value.tree);\n    });\n    const release = () => {\n      if (subscriptions.delete(release)) unsubscribe();\n    };\n    subscriptions.add(release);\n    return release;\n  }\n\n  return {\n    table,\n    get: () => store.get().tree,\n    options: () => options,\n    active: () => !disposed,\n    request,\n    subscribe,\n    state: {\n      get: () => store.get().snapshot,\n      subscribe(listener: (state: NavigationSnapshot) => void) {\n        return subscribe(() => listener(store.get().snapshot));\n      },\n    },\n    run(why: TreeAction, run: () => void) {\n      if (disposed) return;\n      const previousAction = action;\n      action = why;\n      staged = {};\n      try {\n        run();\n        const patch = staged;\n        staged = undefined;\n        publish(patch, why);\n      } finally {\n        staged = undefined;\n        action = previousAction;\n      }\n    },\n    change(patch: Partial<TreeState>, why: TreeAction = {}) {\n      const next: Partial<NavigationSnapshot> = {};\n      if (patch.highlighted !== undefined) next.highlighted = patch.highlighted;\n      if (patch.anchor !== undefined) next.anchor = patch.anchor;\n      if (patch.expanded !== undefined) next.expanded = keyState(patch.expanded);\n      if (patch.selected !== undefined) next.rowSelection = keyState(patch.selected);\n      if (staged) Object.assign(staged, next);\n      else publish(next, why);\n    },\n    update: (next: Partial<NavigationOptions<T>>) => publish({}, { reason: \"items-changed\" }, next),\n    dispose() {\n      if (disposed) return;\n      disposed = true;\n      queued.length = 0;\n      subscription.unsubscribe();\n      for (const release of subscriptions) release();\n      subscriptions.clear();\n    },\n  };\n}\n\nexport type NavigationModel<T extends RowData> = ReturnType<typeof createNavigationModel<T>>;\n"],"mappings":"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"}

package/dist/navigation/types.d.ts

@@ -0,0 +1,86 @@
+import { ChangeDetails, Controllable } from "../controllable.js";
+import { CommandScopeOptions, KeyLayer } from "../commands/types.js";
+import { Kernel } from "../kernel.js";
+import { Store } from "../ports/store.js";
+import { TreeAction, TreeChangeReason, TreeCommands, TreeFocusStrategy, TreeLabels, TreeMode, TreeRootProps, TreeRowProps, TreeToggleProps } from "../tree/types.js";
+import { navigationFeatures } from "./index.js";
+import { ColumnDef, ExpandedState, RowData, RowSelectionState, SortingState, Table, TableFeatures, TableState_ColumnFiltering, TableState_ColumnOrdering, TableState_ColumnSizing, TableState_ColumnVisibility, TableState_GlobalFiltering, Updater } from "@tanstack/table-core";
+export interface NavigationState {
+  highlighted: string | null;
+  anchor: string | null;
+  chosenColumn: string | null;
+}
+export interface NavigationSnapshot extends NavigationState, TableState_ColumnFiltering, TableState_GlobalFiltering, TableState_ColumnOrdering, TableState_ColumnSizing, TableState_ColumnVisibility {
+  expanded: ExpandedState;
+  rowSelection: RowSelectionState;
+  sorting: SortingState;
+}
+export interface NavigationOptions<T extends RowData> {
+  data: readonly T[];
+  getRowId?(item: NoInfer<T>, index: number, parent?: NavigationRow<T>): string;
+  getSubRows?(item: NoInfer<T>, index: number): readonly NoInfer<T>[] | undefined;
+  columns?: readonly ColumnDef<NavigationFeatures, NoInfer<T>>[];
+  isDisabled?(item: NoInfer<T>): boolean;
+  getTextValue?(item: NoInfer<T>): string;
+  id?: string;
+  mode?: TreeMode;
+  focusStrategy?: TreeFocusStrategy;
+  selectionMode?: "single" | "multiple";
+  highlighted?: Controllable<string | null, TreeChangeReason>;
+  expanded?: Controllable<ExpandedState, TreeChangeReason>;
+  rowSelection?: Controllable<RowSelectionState, TreeChangeReason>;
+  sorting?: Controllable<SortingState, TreeChangeReason>;
+  loop?: boolean;
+  pageSize?: number;
+  typeaheadMs?: number;
+  labels?: TreeLabels;
+  scope?: CommandScopeOptions;
+  /** Optional per-instance page-wide keys. Without it the root must have focus. */
+  keys?: KeyLayer | undefined;
+  onOpen?: ((item: NoInfer<T>, details: ChangeDetails<TreeChangeReason>) => void) | undefined;
+}
+export interface NavigationCommands extends TreeCommands {
+  sort(column?: string, action?: TreeAction): void;
+  chooseColumn(direction?: 1 | -1, action?: TreeAction): void;
+}
+export type NavigationFeatures = typeof navigationFeatures;
+export type NavigationRow<T extends RowData> = ReturnType<Table<NavigationFeatures, T>["getRow"]>;
+export type NavigationTable<T extends RowData> = Table<NavigationFeatures, T>;
+export interface NavigableTable<T extends RowData> {
+  readonly table: NavigationTable<T>;
+  readonly state: Pick<Store<NavigationSnapshot>, "get" | "subscribe">;
+  readonly commands: NavigationCommands;
+  readonly scope: string;
+  setHighlighted(updater: Updater<string | null>): void;
+  getRootProps(): TreeRootProps;
+  getRowProps(id: string): TreeRowProps;
+  getToggleProps(id: string): TreeToggleProps;
+  update(options: Partial<NavigationOptions<T>>): void;
+  dispose(): void;
+}
+export interface NavigationFeatureOptions<T extends RowData> {
+  navigation: {
+    kernel: Kernel;
+    options: NavigationOptions<T>;
+  };
+  onHighlightedChange?: (updater: Updater<string | null>) => void;
+}
+export interface NavigationTableAPI<T extends RowData> {
+  getNavigation(): NavigableTable<T>;
+  setHighlighted(updater: Updater<string | null>): void;
+}
+declare module "@tanstack/table-core" {
+  interface Plugins {
+    navigationFeature: import("@tanstack/table-core").TableFeature;
+  }
+  interface TableState_FeatureMap {
+    navigationFeature: NavigationState;
+  }
+  interface TableOptions_FeatureMap<TFeatures extends TableFeatures, TData extends RowData> {
+    navigationFeature: NavigationFeatureOptions<TData>;
+  }
+  interface Table_FeatureMap<TFeatures extends TableFeatures, TData extends RowData> {
+    navigationFeature: NavigationTableAPI<TData>;
+  }
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/ports/keyboard.d.ts

@@ -23,8 +23,8 @@ export interface KeyboardBindingOptions {
   readonly scope?: string;
   /** Defaults to document. Element targets require focus within the element. */
   readonly target?: KeyboardTarget;
-  /** Defaults to "auto": skip typing keys in controls, but allow Mod shortcuts. */
-  readonly ignoreInputs?: boolean | "auto";
+  /** Defaults to "auto". "editable" skips text fields while allowing keys owned by widgets. */
+  readonly ignoreInputs?: boolean | "auto" | "editable";
   readonly enabled?: boolean;
   /** Maximum milliseconds between sequence steps. Defaults to 1,000. */
   readonly timeout?: number;
@@ -51,6 +51,7 @@ export interface KeyboardPort {
   readonly platform: KeyboardPlatform;
   /** Validate saved strings or arrays. Malformed input returns a reason, never throws. */
   parse(input: unknown): KeyboardParseResult;
+  /** A label: `⇧J`, `⌘K` on macOS; `Shift+J`, `Ctrl+K` elsewhere; `g r` for a sequence. */
   format(hotkey: KeyboardHotkey): string;
   /** Descendants beat ancestors; otherwise the latest activation wins. Release is idempotent. */
   activateScope(scope: string, options?: KeyboardScopeOptions): () => void;

package/dist/ports/keyboard.js

@@ -0,0 +1,9 @@
+// src/ports/keyboard.ts
+/** Shared by editable-only dispatch and its command legend projection. */
+function isKeyboardEditable(element) {
+	while (element?.shadowRoot?.activeElement) element = element.shadowRoot.activeElement;
+	return element?.matches("input, textarea, select, [role=\"textbox\"], [role=\"searchbox\"]") === true || element !== null && element !== void 0 && "isContentEditable" in element && element.isContentEditable === true;
+}
+export { isKeyboardEditable };
+
+//# sourceMappingURL=keyboard.js.map

package/dist/ports/keyboard.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"keyboard.js","names":[],"sources":["../../src/ports/keyboard.ts"],"sourcesContent":["import type { Hotkey, HotkeyChord, HotkeyPlatform } from \"@tanstack/hotkeys\";\nimport type { Store } from \"./store.js\";\n\n/** TanStack's checked chord strings and readonly arrays of chord strings. */\nexport type KeyboardHotkey = Hotkey;\nexport type KeyboardPlatform = HotkeyPlatform;\nexport type KeyboardTarget = HTMLElement | Document | Window;\nexport type KeyboardHandler = (event: KeyboardEvent) => void;\n\n/** Shared by editable-only dispatch and its command legend projection. */\nexport function isKeyboardEditable(element: Element | null | undefined): boolean {\n  while (element?.shadowRoot?.activeElement) element = element.shadowRoot.activeElement;\n  return (\n    element?.matches('input, textarea, select, [role=\"textbox\"], [role=\"searchbox\"]') === true ||\n    (element !== null &&\n      element !== undefined &&\n      \"isContentEditable\" in element &&\n      element.isContentEditable === true)\n  );\n}\n\nexport type KeyboardParseResult =\n  | { readonly ok: true; readonly hotkey: KeyboardHotkey }\n  | { readonly ok: false; readonly reason: string };\n\nexport interface KeyboardScopeOptions {\n  readonly parent?: string;\n  readonly exclusive?: boolean | { readonly allow: readonly string[] };\n}\n\nexport interface KeyboardBindingOptions {\n  /** Defaults to the always-active \"global\" scope. */\n  readonly scope?: string;\n  /** Defaults to document. Element targets require focus within the element. */\n  readonly target?: KeyboardTarget;\n  /** Defaults to \"auto\". \"editable\" skips text fields while allowing keys owned by widgets. */\n  readonly ignoreInputs?: boolean | \"auto\" | \"editable\";\n  readonly enabled?: boolean;\n  /** Maximum milliseconds between sequence steps. Defaults to 1,000. */\n  readonly timeout?: number;\n}\n\nexport interface KeyboardBinding {\n  /** Merge options and optionally replace the handler. A new target resets progress. */\n  update(options: KeyboardBindingOptions & { readonly handler?: KeyboardHandler }): void;\n  /** Idempotent. Updates after disposal do nothing. */\n  dispose(): void;\n}\n\nexport interface PendingKeyboardSequence {\n  readonly id: string;\n  readonly hotkey: readonly KeyboardHotkeyChord[];\n  readonly matchedStepCount: number;\n  readonly scope: string;\n  readonly target: KeyboardTarget;\n}\n\nexport type KeyboardHotkeyChord = HotkeyChord;\n/** The read side of Store; consumers cannot write sequence progress. */\nexport type KeyboardPendingStore = Pick<\n  Store<readonly PendingKeyboardSequence[]>,\n  \"get\" | \"subscribe\"\n>;\n\nexport interface KeyboardPort {\n  readonly platform: KeyboardPlatform;\n  /** Validate saved strings or arrays. Malformed input returns a reason, never throws. */\n  parse(input: unknown): KeyboardParseResult;\n  /** A label: `⇧J`, `⌘K` on macOS; `Shift+J`, `Ctrl+K` elsewhere; `g r` for a sequence. */\n  format(hotkey: KeyboardHotkey): string;\n  /** Descendants beat ancestors; otherwise the latest activation wins. Release is idempotent. */\n  activateScope(scope: string, options?: KeyboardScopeOptions): () => void;\n  bind(\n    hotkey: KeyboardHotkey,\n    handler: KeyboardHandler,\n    options?: KeyboardBindingOptions,\n  ): KeyboardBinding;\n  readonly pending: KeyboardPendingStore;\n  /** Releases all bindings, scopes, subscriptions, timers and DOM listeners once. */\n  dispose(): void;\n}\n"],"mappings":";;AAUA,SAAgB,mBAAmB,SAA8C;CAC/E,OAAO,SAAS,YAAY,eAAe,UAAU,QAAQ,WAAW;CACxE,OACE,SAAS,QAAQ,mEAA+D,MAAM,QACrF,YAAY,QACX,YAAY,KAAA,KACZ,uBAAuB,WACvB,QAAQ,sBAAsB;AAEpC"}

package/dist/tree/types.d.ts

@@ -1,27 +1,13 @@
-import { Key, TreeRow, TreeSource, TreeState } from "../collections/types.js";
-import { ChangeDetails, Controllable } from "../controllable.js";
-import { CommandScopeOptions } from "../commands/types.js";
-import { Store } from "../ports/store.js";
+import { Key } from "../collections/types.js";
 export type TreeChangeReason = "keyboard" | "pointer" | "typeahead" | "programmatic" | "items-changed";
 export type TreeMode = "tree" | "listbox" | "treegrid" | "grid";
 export type TreeFocusStrategy = "active-descendant" | "roving";
-export interface TreeOptions<T> extends TreeSource<T> {
-  /** Supply a stable id for server rendering. Otherwise generated per instance. */
-  id?: string;
-  mode?: TreeMode;
-  focusStrategy?: TreeFocusStrategy;
-  selectionMode?: "single" | "multiple";
-  highlighted?: Controllable<Key | null, TreeChangeReason>;
-  selected?: Controllable<ReadonlySet<Key>, TreeChangeReason>;
-  expanded?: Controllable<ReadonlySet<Key>, TreeChangeReason>;
-  loop?: boolean;
-  /** Number of enabled rows per page. Defaults to 10. */
-  pageSize?: number;
-  /** Milliseconds between typed characters. Defaults to 500. */
-  typeaheadMs?: number;
-  /** Scope options, including the mounted root target for keyboard isolation. */
-  scope?: CommandScopeOptions;
-  onOpen?(item: NoInfer<T>, details: ChangeDetails<TreeChangeReason>): void;
+/** Accessible names of a row's expand/collapse toggle, for localization. */
+export interface TreeLabels {
+  /** Names a collapsed row's toggle. Defaults to "Expand". */
+  readonly expand?: string;
+  /** Names an expanded row's toggle. Defaults to "Collapse". */
+  readonly collapse?: string;
 }
 export interface TreeAction {
   /** Defaults to the highlighted row. */
@@ -43,9 +29,6 @@ export interface TreeCommands {
   extendSelection(action?: TreeAction): void;
   open(action?: TreeAction): void;
 }
-export interface TreeSnapshot<T> extends Readonly<TreeState> {
-  readonly rows: readonly TreeRow<T>[];
-}
 export interface TreePartProps {
   /** Grid and treegrid modes use the `table-*` slots. */
   "data-slot": "tree-root" | "tree-row" | "tree-toggle" | "table-root" | "table-row" | "table-toggle";
@@ -92,16 +75,4 @@ export interface TreeToggleProps extends TreePartProps {
   "aria-expanded": boolean | undefined;
   onClick(event: MouseEvent): void;
 }
-export interface Tree<T> {
-  readonly rows: readonly TreeRow<T>[];
-  readonly state: Pick<Store<TreeSnapshot<T>>, "get" | "subscribe">;
-  readonly commands: TreeCommands;
-  readonly scope: string;
-  /** Merge live data, control values and presentation options. Defaults apply only at creation. */
-  update(options: Partial<TreeOptions<T>>): void;
-  getRootProps(): TreeRootProps;
-  getRowProps(key: Key): TreeRowProps;
-  getToggleProps(key: Key): TreeToggleProps;
-  dispose(): void;
-}
 //# sourceMappingURL=types.d.ts.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@densedash/core",
-  "version": "0.1.1",
+  "version": "0.2.0",
   "description": "Framework-agnostic densedash kernel, ports and plugin contracts.",
   "license": "MIT",
   "repository": {
@@ -33,7 +33,8 @@
   },
   "dependencies": {
     "@tanstack/hotkeys": "0.24.0",
-    "@tanstack/store": "0.11.2"
+    "@tanstack/store": "0.11.2",
+    "@tanstack/table-core": "9.3.1"
   },
   "scripts": {
     "build": "tsdown",

package/dist/collections/flatten.d.ts

@@ -1,8 +0,0 @@
-import { Key, TreeRow, TreeSource } from "./types.js";
-/**
- * Visible preorder rows. Index/depth are zero-based; sibling positions are one-based.
- * Validate the entire source, including collapsed branches, in O(total items).
- * Duplicate keys and ancestor cycles throw in every environment, naming the key.
- */
-export declare function flatten<T>(source: TreeSource<T>, expanded: ReadonlySet<Key>): TreeRow<T>[];
-//# sourceMappingURL=flatten.d.ts.map

package/dist/collections/flatten.js

@@ -1,59 +0,0 @@
-// src/collections/flatten.ts
-/**
-* Visible preorder rows. Index/depth are zero-based; sibling positions are one-based.
-* Validate the entire source, including collapsed branches, in O(total items).
-* Duplicate keys and ancestor cycles throw in every environment, naming the key.
-*/
-function flatten(source, expanded) {
-	const rows = [];
-	const seen = /* @__PURE__ */ new Set();
-	const ancestors = /* @__PURE__ */ new Set();
-	const stack = [{
-		items: source.roots,
-		offset: 0,
-		parentKey: null,
-		visible: true
-	}];
-	while (stack.length > 0) {
-		const frame = stack[stack.length - 1];
-		if (frame.offset === frame.items.length) {
-			if (frame.parentKey !== null) ancestors.delete(frame.parentKey);
-			stack.pop();
-			continue;
-		}
-		const item = frame.items[frame.offset++];
-		const key = source.getKey(item);
-		if (ancestors.has(key)) throw new Error(`Collection cycle at key "${key}".`);
-		if (seen.has(key)) throw new Error(`Duplicate collection key "${key}".`);
-		seen.add(key);
-		const children = source.getChildren?.(item);
-		const hasChildren = children !== void 0 && children.length > 0;
-		const isExpanded = hasChildren && expanded.has(key);
-		if (frame.visible) rows.push({
-			key,
-			item,
-			index: rows.length,
-			depth: stack.length - 1,
-			parentKey: frame.parentKey,
-			hasChildren,
-			expanded: isExpanded,
-			posInSet: frame.offset,
-			setSize: frame.items.length,
-			disabled: source.isDisabled?.(item) ?? false,
-			textValue: source.getTextValue?.(item) ?? key
-		});
-		if (children !== void 0 && hasChildren) {
-			ancestors.add(key);
-			stack.push({
-				items: children,
-				offset: 0,
-				parentKey: key,
-				visible: frame.visible && isExpanded
-			});
-		}
-	}
-	return rows;
-}
-export { flatten };
-
-//# sourceMappingURL=flatten.js.map

package/dist/collections/flatten.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"flatten.js","names":[],"sources":["../../src/collections/flatten.ts"],"sourcesContent":["import type { Key, TreeRow, TreeSource } from \"./types.js\";\n\ninterface Frame<T> {\n  items: readonly T[];\n  offset: number;\n  parentKey: Key | null;\n  visible: boolean;\n}\n\n/**\n * Visible preorder rows. Index/depth are zero-based; sibling positions are one-based.\n * Validate the entire source, including collapsed branches, in O(total items).\n * Duplicate keys and ancestor cycles throw in every environment, naming the key.\n */\nexport function flatten<T>(source: TreeSource<T>, expanded: ReadonlySet<Key>): TreeRow<T>[] {\n  const rows: TreeRow<T>[] = [];\n  const seen = new Set<Key>();\n  const ancestors = new Set<Key>();\n  const stack: Frame<T>[] = [{ items: source.roots, offset: 0, parentKey: null, visible: true }];\n\n  while (stack.length > 0) {\n    const frame = stack[stack.length - 1]!;\n    if (frame.offset === frame.items.length) {\n      if (frame.parentKey !== null) ancestors.delete(frame.parentKey);\n      stack.pop();\n      continue;\n    }\n\n    const item = frame.items[frame.offset++]!;\n    const key = source.getKey(item);\n    if (ancestors.has(key)) throw new Error(`Collection cycle at key \"${key}\".`);\n    if (seen.has(key)) throw new Error(`Duplicate collection key \"${key}\".`);\n    seen.add(key);\n\n    const children = source.getChildren?.(item);\n    const hasChildren = children !== undefined && children.length > 0;\n    const isExpanded = hasChildren && expanded.has(key);\n    if (frame.visible) {\n      rows.push({\n        key,\n        item,\n        index: rows.length,\n        depth: stack.length - 1,\n        parentKey: frame.parentKey,\n        hasChildren,\n        expanded: isExpanded,\n        posInSet: frame.offset,\n        setSize: frame.items.length,\n        disabled: source.isDisabled?.(item) ?? false,\n        textValue: source.getTextValue?.(item) ?? key,\n      });\n    }\n\n    if (children !== undefined && hasChildren) {\n      ancestors.add(key);\n      stack.push({\n        items: children,\n        offset: 0,\n        parentKey: key,\n        visible: frame.visible && isExpanded,\n      });\n    }\n  }\n\n  return rows;\n}\n"],"mappings":";;;;;;AAcA,SAAgB,QAAW,QAAuB,UAA0C;CAC1F,MAAM,OAAqB,CAAC;CAC5B,MAAM,uBAAO,IAAI,IAAS;CAC1B,MAAM,4BAAY,IAAI,IAAS;CAC/B,MAAM,QAAoB,CAAC;EAAE,OAAO,OAAO;EAAO,QAAQ;EAAG,WAAW;EAAM,SAAS;CAAK,CAAC;CAE7F,OAAO,MAAM,SAAS,GAAG;EACvB,MAAM,QAAQ,MAAM,MAAM,SAAS;EACnC,IAAI,MAAM,WAAW,MAAM,MAAM,QAAQ;GACvC,IAAI,MAAM,cAAc,MAAM,UAAU,OAAO,MAAM,SAAS;GAC9D,MAAM,IAAI;GACV;EACF;EAEA,MAAM,OAAO,MAAM,MAAM,MAAM;EAC/B,MAAM,MAAM,OAAO,OAAO,IAAI;EAC9B,IAAI,UAAU,IAAI,GAAG,GAAG,MAAM,IAAI,MAAM,4BAA4B,IAAI,GAAG;EAC3E,IAAI,KAAK,IAAI,GAAG,GAAG,MAAM,IAAI,MAAM,6BAA6B,IAAI,GAAG;EACvE,KAAK,IAAI,GAAG;EAEZ,MAAM,WAAW,OAAO,cAAc,IAAI;EAC1C,MAAM,cAAc,aAAa,KAAA,KAAa,SAAS,SAAS;EAChE,MAAM,aAAa,eAAe,SAAS,IAAI,GAAG;EAClD,IAAI,MAAM,SACR,KAAK,KAAK;GACR;GACA;GACA,OAAO,KAAK;GACZ,OAAO,MAAM,SAAS;GACtB,WAAW,MAAM;GACjB;GACA,UAAU;GACV,UAAU,MAAM;GAChB,SAAS,MAAM,MAAM;GACrB,UAAU,OAAO,aAAa,IAAI,KAAK;GACvC,WAAW,OAAO,eAAe,IAAI,KAAK;EAC5C,CAAC;EAGH,IAAI,aAAa,KAAA,KAAa,aAAa;GACzC,UAAU,IAAI,GAAG;GACjB,MAAM,KAAK;IACT,OAAO;IACP,QAAQ;IACR,WAAW;IACX,SAAS,MAAM,WAAW;GAC5B,CAAC;EACH;CACF;CAEA,OAAO;AACT"}

package/dist/collections/move.d.ts

@@ -1,7 +0,0 @@
-import { Key, Move, MoveOptions, TreeRow } from "./types.js";
-/**
- * Return a key; never mutate rows or state. No target leaves the current enabled
- * key in place (or null). Counts and pages count enabled rows. Empty rows return null.
- */
-export declare function move<T>(rows: readonly TreeRow<T>[], from: Key | null, movement: Move, { loop }?: MoveOptions): Key | null;
-//# sourceMappingURL=move.d.ts.map

package/dist/collections/move.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"move.js","names":[],"sources":["../../src/collections/move.ts"],"sourcesContent":["import type { Key, Move, MoveOptions, TreeRow } from \"./types.js\";\n\n/** Move by enabled rows without iterating count times, even for huge counts. */\nfunction step<T>(\n  rows: readonly TreeRow<T>[],\n  fromIndex: number,\n  count: number,\n  direction: 1 | -1,\n  loop: boolean,\n): Key | null {\n  if (!Number.isSafeInteger(count) || count < 0) {\n    throw new RangeError(\"Collection move count/size must be a non-negative safe integer.\");\n  }\n\n  const keys: Key[] = [];\n  let before = 0;\n  let current = -1;\n  for (let index = 0; index < rows.length; index++) {\n    const row = rows[index]!;\n    if (row.disabled) continue;\n    if (index < fromIndex) before++;\n    if (index === fromIndex) current = keys.length;\n    keys.push(row.key);\n  }\n  if (keys.length === 0) return null;\n  if (count === 0) return current < 0 ? null : keys[current]!;\n\n  let start = current;\n  if (current < 0) {\n    start =\n      fromIndex < 0 ? (direction === 1 ? -1 : keys.length) : direction === 1 ? before - 1 : before;\n  }\n  // Reduce before addition so even MAX_SAFE_INTEGER stays arithmetically exact.\n  const distance = loop ? count % keys.length : Math.min(count, keys.length);\n  const target = start + direction * distance;\n  const bounded = loop\n    ? ((target % keys.length) + keys.length) % keys.length\n    : Math.max(0, Math.min(keys.length - 1, target));\n  return keys[bounded]!;\n}\n\n/**\n * Return a key; never mutate rows or state. No target leaves the current enabled\n * key in place (or null). Counts and pages count enabled rows. Empty rows return null.\n */\nexport function move<T>(\n  rows: readonly TreeRow<T>[],\n  from: Key | null,\n  movement: Move,\n  { loop = false }: MoveOptions = {},\n): Key | null {\n  const fromIndex = from === null ? -1 : rows.findIndex((row) => row.key === from);\n  const current = rows[fromIndex];\n  const unchanged = current && !current.disabled ? current.key : null;\n\n  switch (movement.type) {\n    case \"next\":\n    case \"prev\":\n      return step(rows, fromIndex, movement.count ?? 1, movement.type === \"next\" ? 1 : -1, loop);\n    case \"page\":\n      return step(rows, fromIndex, movement.size, movement.direction, loop);\n    case \"first\":\n      return rows.find((row) => !row.disabled)?.key ?? null;\n    case \"last\":\n      for (let index = rows.length - 1; index >= 0; index--) {\n        const row = rows[index]!;\n        if (!row.disabled) return row.key;\n      }\n      return null;\n    case \"parent\": {\n      let parentKey = current?.parentKey;\n      for (let index = fromIndex - 1; index >= 0 && parentKey != null; index--) {\n        const row = rows[index]!;\n        if (row.key !== parentKey) continue;\n        if (!row.disabled) return row.key;\n        parentKey = row.parentKey;\n      }\n      return unchanged;\n    }\n    case \"firstChild\":\n      if (!current) return null;\n      for (let index = fromIndex + 1; index < rows.length; index++) {\n        const row = rows[index]!;\n        if (row.depth <= current.depth) break;\n        if (row.parentKey === current.key && !row.disabled) return row.key;\n      }\n      return unchanged;\n    case \"typeahead\": {\n      const text = movement.text.toLowerCase();\n      if (text.length === 0) return unchanged;\n      const end = loop ? rows.length + fromIndex + 1 : rows.length;\n      for (let index = fromIndex + 1; index < end; index++) {\n        const row = rows[index % rows.length]!;\n        if (!row.disabled && row.textValue.toLowerCase().startsWith(text)) return row.key;\n      }\n      return unchanged;\n    }\n  }\n}\n"],"mappings":";;AAGA,SAAS,KACP,MACA,WACA,OACA,WACA,MACY;CACZ,IAAI,CAAC,OAAO,cAAc,KAAK,KAAK,QAAQ,GAC1C,MAAM,IAAI,WAAW,iEAAiE;CAGxF,MAAM,OAAc,CAAC;CACrB,IAAI,SAAS;CACb,IAAI,UAAU;CACd,KAAK,IAAI,QAAQ,GAAG,QAAQ,KAAK,QAAQ,SAAS;EAChD,MAAM,MAAM,KAAK;EACjB,IAAI,IAAI,UAAU;EAClB,IAAI,QAAQ,WAAW;EACvB,IAAI,UAAU,WAAW,UAAU,KAAK;EACxC,KAAK,KAAK,IAAI,GAAG;CACnB;CACA,IAAI,KAAK,WAAW,GAAG,OAAO;CAC9B,IAAI,UAAU,GAAG,OAAO,UAAU,IAAI,OAAO,KAAK;CAElD,IAAI,QAAQ;CACZ,IAAI,UAAU,GACZ,QACE,YAAY,IAAK,cAAc,IAAI,KAAK,KAAK,SAAU,cAAc,IAAI,SAAS,IAAI;CAG1F,MAAM,WAAW,OAAO,QAAQ,KAAK,SAAS,KAAK,IAAI,OAAO,KAAK,MAAM;CACzE,MAAM,SAAS,QAAQ,YAAY;CAInC,OAAO,KAHS,QACV,SAAS,KAAK,SAAU,KAAK,UAAU,KAAK,SAC9C,KAAK,IAAI,GAAG,KAAK,IAAI,KAAK,SAAS,GAAG,MAAM,CAAC;AAEnD;;;;;AAMA,SAAgB,KACd,MACA,MACA,UACA,EAAE,OAAO,UAAuB,CAAC,GACrB;CACZ,MAAM,YAAY,SAAS,OAAO,KAAK,KAAK,WAAW,QAAQ,IAAI,QAAQ,IAAI;CAC/E,MAAM,UAAU,KAAK;CACrB,MAAM,YAAY,WAAW,CAAC,QAAQ,WAAW,QAAQ,MAAM;CAE/D,QAAQ,SAAS,MAAjB;EACE,KAAK;EACL,KAAK,QACH,OAAO,KAAK,MAAM,WAAW,SAAS,SAAS,GAAG,SAAS,SAAS,SAAS,IAAI,IAAI,IAAI;EAC3F,KAAK,QACH,OAAO,KAAK,MAAM,WAAW,SAAS,MAAM,SAAS,WAAW,IAAI;EACtE,KAAK,SACH,OAAO,KAAK,MAAM,QAAQ,CAAC,IAAI,QAAQ,CAAC,EAAE,OAAO;EACnD,KAAK;GACH,KAAK,IAAI,QAAQ,KAAK,SAAS,GAAG,SAAS,GAAG,SAAS;IACrD,MAAM,MAAM,KAAK;IACjB,IAAI,CAAC,IAAI,UAAU,OAAO,IAAI;GAChC;GACA,OAAO;EACT,KAAK,UAAU;GACb,IAAI,YAAY,SAAS;GACzB,KAAK,IAAI,QAAQ,YAAY,GAAG,SAAS,KAAK,aAAa,MAAM,SAAS;IACxE,MAAM,MAAM,KAAK;IACjB,IAAI,IAAI,QAAQ,WAAW;IAC3B,IAAI,CAAC,IAAI,UAAU,OAAO,IAAI;IAC9B,YAAY,IAAI;GAClB;GACA,OAAO;EACT;EACA,KAAK;GACH,IAAI,CAAC,SAAS,OAAO;GACrB,KAAK,IAAI,QAAQ,YAAY,GAAG,QAAQ,KAAK,QAAQ,SAAS;IAC5D,MAAM,MAAM,KAAK;IACjB,IAAI,IAAI,SAAS,QAAQ,OAAO;IAChC,IAAI,IAAI,cAAc,QAAQ,OAAO,CAAC,IAAI,UAAU,OAAO,IAAI;GACjE;GACA,OAAO;EACT,KAAK,aAAa;GAChB,MAAM,OAAO,SAAS,KAAK,YAAY;GACvC,IAAI,KAAK,WAAW,GAAG,OAAO;GAC9B,MAAM,MAAM,OAAO,KAAK,SAAS,YAAY,IAAI,KAAK;GACtD,KAAK,IAAI,QAAQ,YAAY,GAAG,QAAQ,KAAK,SAAS;IACpD,MAAM,MAAM,KAAK,QAAQ,KAAK;IAC9B,IAAI,CAAC,IAAI,YAAY,IAAI,UAAU,YAAY,CAAC,CAAC,WAAW,IAAI,GAAG,OAAO,IAAI;GAChF;GACA,OAAO;EACT;CACF;AACF"}

package/dist/collections/reconcile.d.ts

@@ -1,9 +0,0 @@
-import { TreeRow, TreeState } from "./types.js";
-/**
- * Reconcile against supplied visible rows in O(prev + next + selected).
- * Keep a live enabled cursor by key. Otherwise prefer the nearest enabled survivor
- * in the old order (following wins ties), then the first enabled new row.
- * Prune invisible selection/anchor; retain expansion for hidden descendants.
- */
-export declare function reconcile<T>(prev: readonly TreeRow<T>[], next: readonly TreeRow<T>[], state: TreeState): TreeState;
-//# sourceMappingURL=reconcile.d.ts.map

package/dist/collections/reconcile.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"reconcile.js","names":[],"sources":["../../src/collections/reconcile.ts"],"sourcesContent":["import type { Key, TreeRow, TreeState } from \"./types.js\";\n\n/**\n * Reconcile against supplied visible rows in O(prev + next + selected).\n * Keep a live enabled cursor by key. Otherwise prefer the nearest enabled survivor\n * in the old order (following wins ties), then the first enabled new row.\n * Prune invisible selection/anchor; retain expansion for hidden descendants.\n */\nexport function reconcile<T>(\n  prev: readonly TreeRow<T>[],\n  next: readonly TreeRow<T>[],\n  state: TreeState,\n): TreeState {\n  const existing = new Set<Key>();\n  const enabled = new Set<Key>();\n  for (const row of next) {\n    existing.add(row.key);\n    if (!row.disabled) enabled.add(row.key);\n  }\n\n  let highlighted = state.highlighted;\n  if (highlighted !== null && !enabled.has(highlighted)) {\n    const previousIndex = prev.findIndex((row) => row.key === highlighted);\n    highlighted = null;\n    if (previousIndex >= 0) {\n      for (let distance = 1; distance < prev.length; distance++) {\n        const following = prev[previousIndex + distance];\n        const preceding = prev[previousIndex - distance];\n        if (following && enabled.has(following.key)) {\n          highlighted = following.key;\n          break;\n        }\n        if (preceding && enabled.has(preceding.key)) {\n          highlighted = preceding.key;\n          break;\n        }\n      }\n    }\n    highlighted ??= next.find((row) => !row.disabled)?.key ?? null;\n  }\n\n  const selected = new Set<Key>();\n  for (const key of state.selected) {\n    if (existing.has(key)) selected.add(key);\n  }\n\n  return {\n    highlighted,\n    selected,\n    anchor: state.anchor !== null && existing.has(state.anchor) ? state.anchor : null,\n    expanded: state.expanded,\n  };\n}\n"],"mappings":";;;;;;;AAQA,SAAgB,UACd,MACA,MACA,OACW;CACX,MAAM,2BAAW,IAAI,IAAS;CAC9B,MAAM,0BAAU,IAAI,IAAS;CAC7B,KAAK,MAAM,OAAO,MAAM;EACtB,SAAS,IAAI,IAAI,GAAG;EACpB,IAAI,CAAC,IAAI,UAAU,QAAQ,IAAI,IAAI,GAAG;CACxC;CAEA,IAAI,cAAc,MAAM;CACxB,IAAI,gBAAgB,QAAQ,CAAC,QAAQ,IAAI,WAAW,GAAG;EACrD,MAAM,gBAAgB,KAAK,WAAW,QAAQ,IAAI,QAAQ,WAAW;EACrE,cAAc;EACd,IAAI,iBAAiB,GACnB,KAAK,IAAI,WAAW,GAAG,WAAW,KAAK,QAAQ,YAAY;GACzD,MAAM,YAAY,KAAK,gBAAgB;GACvC,MAAM,YAAY,KAAK,gBAAgB;GACvC,IAAI,aAAa,QAAQ,IAAI,UAAU,GAAG,GAAG;IAC3C,cAAc,UAAU;IACxB;GACF;GACA,IAAI,aAAa,QAAQ,IAAI,UAAU,GAAG,GAAG;IAC3C,cAAc,UAAU;IACxB;GACF;EACF;EAEF,gBAAgB,KAAK,MAAM,QAAQ,CAAC,IAAI,QAAQ,CAAC,EAAE,OAAO;CAC5D;CAEA,MAAM,2BAAW,IAAI,IAAS;CAC9B,KAAK,MAAM,OAAO,MAAM,UACtB,IAAI,SAAS,IAAI,GAAG,GAAG,SAAS,IAAI,GAAG;CAGzC,OAAO;EACL;EACA;EACA,QAAQ,MAAM,WAAW,QAAQ,SAAS,IAAI,MAAM,MAAM,IAAI,MAAM,SAAS;EAC7E,UAAU,MAAM;CAClB;AACF"}

package/dist/collections/selection.d.ts

@@ -1,12 +0,0 @@
-import { Key, TreeRow } from "./types.js";
-/** Toggle a visible enabled key, preserving the caller's selected set. */
-export declare function toggleSelection<T>(rows: readonly TreeRow<T>[], selected: ReadonlySet<Key>, key: Key): ReadonlySet<Key>;
-/**
- * Replace selection with an inclusive visible range, excluding disabled rows.
- * A missing anchor selects only the target; a missing target yields an empty set.
- */
-export declare function selectRange<T>(rows: readonly TreeRow<T>[], anchor: Key | null, to: Key): ReadonlySet<Key>;
-/** Select every visible enabled row. */
-export declare function selectAll<T>(rows: readonly TreeRow<T>[]): ReadonlySet<Key>;
-export declare function clearSelection(): ReadonlySet<Key>;
-//# sourceMappingURL=selection.d.ts.map