@spinjs/components 0.0.0-stage → 0.1.0-preview.1

package/dist/tree-view/tree-view.presentation.js

@@ -0,0 +1,515 @@
+import { nodesOf } from "./tree-view.state.js";
+import { treeView as treeView$1 } from "./tree-view.machine.js";
+import { ariaControls, ariaHidden, ariaLabelledBy, defineComponent, disclosureTrigger, isRecord, optionRow } from "@spinjs/runtime";
+// src/tree-view/tree-view.presentation.ts
+const isLoadChildren = (value) => typeof value === "function";
+const inputValue = (target) => {
+	if (!isRecord(target)) return "";
+	const value = target["value"];
+	return typeof value === "string" ? value : "";
+};
+const setRootNodes = (scope, json) => {
+	const root = scope.root();
+	if (root === null || typeof root !== "object") return;
+	root["nodes"] = json;
+};
+/** The TreeCollection replacement: the visible-row list. */
+const flatten = (nodes, expanded) => {
+	const rows = [];
+	const walk = (list, depth, indexPath) => {
+		for (let i = 0; i < list.length; i++) {
+			const node = list[i];
+			if (node === void 0) continue;
+			const path = [...indexPath, i];
+			rows.push({
+				node,
+				depth,
+				indexPath: path
+			});
+			const kids = node.children;
+			if (kids !== void 0 && kids.length > 0 && expanded.includes(node.value)) walk(kids, depth + 1, path);
+		}
+	};
+	walk(nodes, 0, []);
+	return rows;
+};
+/** Visible rows memoized on the nodes' identity and the expansion: fresh
+* rows per move would re-stamp every node and orphan gestures in flight. */
+const rowsCache = /* @__PURE__ */ new WeakMap();
+const rowsOf = (nodes, expanded) => {
+	const key = expanded.join(" ");
+	let byKey = rowsCache.get(nodes);
+	if (byKey === void 0) {
+		byKey = /* @__PURE__ */ new Map();
+		rowsCache.set(nodes, byKey);
+	}
+	const hit = byKey.get(key);
+	if (hit !== void 0) return hit;
+	const rows = flatten(nodes, expanded);
+	byKey.set(key, rows);
+	return rows;
+};
+const isBranchRow = (row, loadable) => {
+	const children = row.node.children;
+	if (children === void 0) return loadable;
+	return children.length > 0;
+};
+const itemStateOf = (scope, row) => {
+	const ctx = scope.context;
+	return {
+		expanded: ctx.expandedValue.includes(row.node.value),
+		selected: ctx.selectedValue.includes(row.node.value),
+		focused: ctx.focusedValue === row.node.value,
+		checked: ctx.checkedValue.includes(row.node.value),
+		loading: ctx.loadingStatus[row.node.value] === "loading",
+		branch: isBranchRow(row, isLoadChildren(scope.context.loadChildren)),
+		renaming: ctx.renamingValue === row.node.value
+	};
+};
+const iconKind = (scope, row) => {
+	const state = itemStateOf(scope, row);
+	if (!state.branch) return "leaf";
+	return state.expanded ? "branch-open" : "branch-closed";
+};
+const stateAttrs = (state) => {
+	const attrs = { "data-state": state.expanded ? "open" : "closed" };
+	if (state.selected) attrs["data-selected"] = "";
+	if (state.focused) attrs["data-focus"] = "";
+	if (state.checked) attrs["data-checked"] = "";
+	if (state.loading) attrs["data-loading"] = "";
+	if (state.renaming) attrs["data-renaming"] = "";
+	return attrs;
+};
+/**
+* Lazy branches: expanding a row with no children asks the host to load
+* them. The host owns the data (it rewrites the `nodes` property); the
+* machine owns the loading marker. LOAD_DONE is sent even on a rejected
+* load, so the spinner clears rather than sticking.
+*/
+const ensureChildren = (scope, value) => {
+	const ctx = scope.context;
+	const nodes = scope.context.nodes;
+	const node = rowsOf(nodes, ctx.expandedValue).find((row) => row.node.value === value)?.node;
+	if (node === void 0 || node.children !== void 0 && node.children.length > 0) return;
+	const load = scope.context.loadChildren;
+	if (!isLoadChildren(load)) return;
+	scope.send({
+		type: "NODE.LOAD_START",
+		value
+	});
+	(async () => {
+		let grafted;
+		try {
+			const loaded = await load(value);
+			if (Array.isArray(loaded)) {
+				const added = nodesOf(loaded);
+				grafted = added;
+				const graft = (list) => list.map((item) => item.value === value ? {
+					...item,
+					children: [...item.children ?? [], ...added]
+				} : item.children !== void 0 ? {
+					...item,
+					children: graft(item.children)
+				} : item);
+				setRootNodes(scope, JSON.stringify(graft(nodes)));
+			}
+		} catch {} finally {
+			scope.send(grafted !== void 0 ? {
+				type: "NODE.LOAD_DONE",
+				value,
+				children: grafted
+			} : {
+				type: "NODE.LOAD_DONE",
+				value
+			});
+		}
+	})();
+};
+/** Typeahead buffers, keyed per bridge: printable keys accumulate within
+* 500ms, and the first visible label match wins. */
+const typeaheadByBridge = /* @__PURE__ */ new WeakMap();
+const typeaheadOf = (scope) => {
+	let buffer = typeaheadByBridge.get(scope.id);
+	if (buffer === void 0) {
+		buffer = {
+			keys: "",
+			at: 0
+		};
+		typeaheadByBridge.set(scope.id, buffer);
+	}
+	return buffer;
+};
+const rowKeydown = (scope, row, event) => {
+	if (event.defaultPrevented) return;
+	const ctx = scope.context;
+	const nodes = scope.context.nodes;
+	const rows = rowsOf(nodes, ctx.expandedValue);
+	const at = rows.findIndex((r) => r.node.value === row.node.value);
+	const loadable = isLoadChildren(scope.context.loadChildren);
+	const branch = isBranchRow(row, loadable);
+	const expanded = ctx.expandedValue.includes(row.node.value);
+	const multiple = ctx.selectionMode === "multiple";
+	const shift = event.shiftKey && multiple;
+	const valueAt = (index) => index >= 0 && index < rows.length ? rows[index]?.node.value ?? null : null;
+	const move = (index, extend) => {
+		const value = valueAt(index);
+		if (value !== null) {
+			scope.send({
+				type: "NODE.FOCUS",
+				value
+			});
+			if (extend) scope.send({
+				type: "NODE.CLICK",
+				value,
+				shiftKey: true
+			});
+		}
+	};
+	switch (event.key) {
+		case "ArrowDown":
+			move(at + 1, shift);
+			break;
+		case "ArrowUp":
+			move(at - 1, shift);
+			break;
+		case "ArrowRight":
+			if (branch && !expanded) {
+				scope.send({
+					type: "BRANCH.TOGGLE",
+					value: row.node.value
+				});
+				ensureChildren(scope, row.node.value);
+			} else if (branch) move(at + 1, false);
+			break;
+		case "ArrowLeft":
+			if (branch && expanded) scope.send({
+				type: "BRANCH.TOGGLE",
+				value: row.node.value
+			});
+			else if (row.depth > 0) {
+				const parent = [...rows.slice(0, at)].reverse().find((r) => r.depth === row.depth - 1);
+				const parentValue = parent !== void 0 ? parent.node.value : null;
+				if (parentValue !== null) scope.send({
+					type: "NODE.FOCUS",
+					value: parentValue
+				});
+			}
+			break;
+		case "Home":
+			move(0, shift);
+			break;
+		case "End":
+			move(rows.length - 1, shift);
+			break;
+		case "Enter":
+			scope.send(branch && ctx.expandOnClick ? {
+				type: "BRANCH_NODE.CLICK",
+				value: row.node.value
+			} : {
+				type: "NODE.CLICK",
+				value: row.node.value
+			});
+			if (branch && !expanded) ensureChildren(scope, row.node.value);
+			break;
+		case " ":
+			scope.send({
+				type: "NODE.CLICK",
+				value: row.node.value
+			});
+			break;
+		case "*":
+			scope.send({
+				type: "EXPANDED.SET",
+				value: rows.filter((r) => isBranchRow(r, loadable)).map((r) => r.node.value)
+			});
+			break;
+		case "F2":
+			if (ctx.rename) scope.send({
+				type: "NODE.RENAME",
+				value: row.node.value
+			});
+			break;
+		default:
+			if (scope.context.typeaheadEnabled && event.key.length === 1 && !event.ctrlKey && !event.metaKey) {
+				const buffer = typeaheadOf(scope);
+				const now = Date.now();
+				buffer.keys = now - buffer.at < 500 ? buffer.keys + event.key : event.key;
+				buffer.at = now;
+				const match = rows.find((r) => r.node.label.toLowerCase().startsWith(buffer.keys.toLowerCase()));
+				if (match !== void 0) scope.send({
+					type: "NODE.FOCUS",
+					value: match.node.value
+				});
+				return;
+			}
+			return;
+	}
+	event.preventDefault();
+};
+const rowClick = (scope, row, event) => {
+	const wasExpanded = scope.context.expandedValue.includes(row.node.value);
+	const branch = isBranchRow(row, isLoadChildren(scope.context.loadChildren));
+	scope.send(branch ? {
+		type: "BRANCH_NODE.CLICK",
+		value: row.node.value,
+		shiftKey: event.shiftKey,
+		ctrlKey: event.ctrlKey
+	} : {
+		type: "NODE.CLICK",
+		value: row.node.value,
+		shiftKey: event.shiftKey,
+		ctrlKey: event.ctrlKey
+	});
+	if (branch && !wasExpanded) ensureChildren(scope, row.node.value);
+};
+const def = {
+	name: "tree",
+	machine: (args, authored) => treeView$1(args, authored),
+	start: "idle",
+	settled: ({ before, after, focus }) => {
+		if (after.context.focusedValue !== before.context.focusedValue && after.context.focusedValue !== null) focus("item", after.context.focusedValue);
+		if (after.context.renamingValue !== before.context.renamingValue && after.context.renamingValue !== null) focus("rename", after.context.renamingValue);
+	},
+	parts: {
+		root: { attrs: (scope) => ({
+			role: "tree",
+			tabindex: -1,
+			...ariaLabelledBy(scope, { part: "label" })
+		}) },
+		tree: { attrs: () => ({ role: "group" }) },
+		label: {},
+		valueText: {}
+	},
+	slots: {
+		item: {
+			indexes: (context) => rowsOf(context.nodes, context.expandedValue),
+			attrs: (scope) => {
+				const row = scope.slot;
+				const state = itemStateOf(scope, row);
+				const ctx = scope.context;
+				return {
+					role: "treeitem",
+					...optionRow({
+						level: row.depth + 1,
+						selected: state.selected
+					}),
+					...disclosureTrigger(scope, { expanded: state.branch ? state.expanded : void 0 }),
+					"data-path": row.indexPath.join("-"),
+					"data-checkable": state.checked || ctx.selectionMode === "multiple" ? "" : void 0,
+					...stateAttrs(state)
+				};
+			}
+		},
+		branchControl: {
+			id: "item",
+			indexes: (context) => rowsOf(context.nodes, context.expandedValue),
+			attrs: (scope) => {
+				const row = scope.slot;
+				const state = itemStateOf(scope, row);
+				return {
+					id: scope.id("item", row.node.value),
+					type: "button",
+					tabindex: state.focused ? 0 : -1,
+					...ariaControls(scope, state.branch ? {
+						part: "content",
+						slot: row.node.value
+					} : void 0),
+					style: {
+						width: `calc(100% - ${row.depth * 14}px)`,
+						marginInlineStart: `${row.depth * .875}rem`
+					},
+					...stateAttrs(state),
+					onClick: (event) => rowClick(scope, row, event),
+					onDblclick: () => {
+						if (scope.context.rename) scope.send({
+							type: "NODE.RENAME",
+							value: row.node.value
+						});
+					},
+					onKeydown: (event) => rowKeydown(scope, row, event),
+					onFocus: () => scope.send({
+						type: "NODE.FOCUS",
+						value: row.node.value
+					})
+				};
+			}
+		},
+		branchIndicator: {
+			indexes: (context) => rowsOf(context.nodes, context.expandedValue),
+			attrs: (scope) => {
+				const row = scope.slot;
+				const state = itemStateOf(scope, row);
+				return {
+					...ariaHidden(true),
+					"data-branch": state.branch ? "" : void 0,
+					...stateAttrs(state)
+				};
+			}
+		},
+		itemIcon: {
+			indexes: (context) => rowsOf(context.nodes, context.expandedValue),
+			attrs: (scope) => ({
+				...ariaHidden(true),
+				"data-kind": iconKind(scope, scope.slot)
+			})
+		},
+		rail: {
+			indexes: (context) => rowsOf(context.nodes, context.expandedValue),
+			attrs: (scope) => {
+				const row = scope.slot;
+				return {
+					...ariaHidden(true),
+					hidden: row.depth === 0,
+					style: { left: `${Math.max(0, row.depth - 1) * .875}rem` }
+				};
+			}
+		},
+		branchText: {
+			indexes: (context) => rowsOf(context.nodes, context.expandedValue),
+			attrs: () => ({})
+		},
+		branchContent: {
+			id: "content",
+			indexes: (context) => rowsOf(context.nodes, context.expandedValue),
+			attrs: (scope) => {
+				const row = scope.slot;
+				return {
+					role: "group",
+					hidden: !scope.context.expandedValue.includes(row.node.value)
+				};
+			}
+		},
+		checkbox: {
+			indexes: (context) => rowsOf(context.nodes, context.expandedValue),
+			attrs: (scope) => {
+				const row = scope.slot;
+				const state = itemStateOf(scope, row);
+				const ctx = scope.context;
+				return {
+					role: "checkbox",
+					tabindex: -1,
+					...optionRow({ checked: state.checked }),
+					"data-checked": state.checked ? "" : void 0,
+					"data-mode": ctx.selectionMode,
+					hidden: ctx.selectionMode !== "multiple",
+					onClick: (event) => {
+						if (event.defaultPrevented) return;
+						scope.send({
+							type: "CHECKED.TOGGLE",
+							value: row.node.value
+						});
+					}
+				};
+			}
+		},
+		loading: {
+			indexes: (context) => rowsOf(context.nodes, context.expandedValue),
+			attrs: (scope) => {
+				const row = scope.slot;
+				return {
+					hidden: scope.context.loadingStatus[row.node.value] !== "loading",
+					...ariaHidden(true)
+				};
+			}
+		},
+		renameInput: {
+			id: "rename",
+			indexes: (context) => rowsOf(context.nodes, context.expandedValue),
+			attrs: (scope) => {
+				const row = scope.slot;
+				const state = itemStateOf(scope, row);
+				return {
+					type: "text",
+					value: row.node.label,
+					hidden: !state.renaming,
+					"aria-label": "Rename tree item",
+					onKeydown: (event) => {
+						if (event.key === "Escape") {
+							scope.send({ type: "RENAME.CANCEL" });
+							event.preventDefault();
+						} else if (event.key === "Enter") {
+							scope.send({
+								type: "RENAME.SUBMIT",
+								value: row.node.value,
+								label: inputValue(event.target)
+							});
+							event.preventDefault();
+						}
+						event.stopPropagation();
+					},
+					onBlur: (event) => {
+						scope.send({
+							type: "RENAME.SUBMIT",
+							value: row.node.value,
+							label: inputValue(event.target)
+						});
+					}
+				};
+			}
+		}
+	},
+	commands: { startRenaming: { event: ([value]) => ({
+		type: "NODE.RENAME",
+		value
+	}) } },
+	readers: {
+		focusedValue: { read: (context) => context.focusedValue },
+		expandedValue: { read: (context) => [...context.expandedValue] },
+		selectedValue: { read: (context) => [...context.selectedValue] },
+		checkedValue: { read: (context) => [...context.checkedValue] },
+		renamingValue: { read: (context) => context.renamingValue },
+		loadingStatus: { read: (context) => ({ ...context.loadingStatus }) },
+		nodes: { read: (context) => [...context.nodes] }
+	},
+	methods: {
+		getVisibleRows: { call: (context) => rowsOf(context.nodes, context.expandedValue) },
+		isBranch: { call: (context, _state, [row]) => isBranchRow(row, isLoadChildren(context.loadChildren)) },
+		getItemState: { call: (context, _state, [row]) => {
+			const ctx = context;
+			return {
+				expanded: ctx.expandedValue.includes(row.node.value),
+				selected: ctx.selectedValue.includes(row.node.value),
+				focused: ctx.focusedValue === row.node.value,
+				checked: ctx.checkedValue.includes(row.node.value),
+				loading: ctx.loadingStatus[row.node.value] === "loading",
+				branch: isBranchRow(row, isLoadChildren(ctx.loadChildren)),
+				renaming: ctx.renamingValue === row.node.value
+			};
+		} }
+	},
+	events: {
+		"expanded-change": {
+			prop: "onExpandedChange",
+			watch: (context) => [...context.expandedValue],
+			detail: (watched) => ({ expandedValue: watched.filter((v) => typeof v === "string") })
+		},
+		"selection-change": {
+			prop: "onSelectionChange",
+			watch: (context) => [...context.selectedValue],
+			detail: (watched) => ({ selectedValue: watched.filter((v) => typeof v === "string") })
+		},
+		"focus-change": {
+			prop: "onFocusChange",
+			watch: (context) => [context.focusedValue],
+			detail: (watched) => {
+				const focused = watched[0];
+				return { focusedValue: typeof focused === "string" ? focused : null };
+			}
+		},
+		"checked-change": {
+			prop: "onCheckedChange",
+			watch: (context) => [...context.checkedValue],
+			detail: (watched) => ({ checkedValue: watched.filter((v) => typeof v === "string") })
+		},
+		"load-complete": {
+			prop: "onLoadComplete",
+			watch: (context) => [context.loadingStatus],
+			detail: () => ({ value: "" }),
+			select: (event) => event.type === "NODE.LOAD_DONE" && typeof event["value"] === "string" ? { value: event["value"] } : null
+		}
+	}
+};
+const treeView = defineComponent(def);
+export { def, treeView };
+
+//# sourceMappingURL=tree-view.presentation.js.map

package/dist/tree-view/tree-view.state.d.ts

@@ -0,0 +1,54 @@
+export interface TreeExpandedChange {
+  readonly expandedValue: readonly string[];
+}
+export interface TreeSelectionChange {
+  readonly selectedValue: readonly string[];
+}
+export interface TreeFocusChange {
+  readonly focusedValue: string | null;
+}
+export interface TreeCheckedChange {
+  readonly checkedValue: readonly string[];
+}
+export interface TreeLoadComplete {
+  readonly value: string;
+}
+export interface TreeArgs {
+  readonly nodes?: unknown;
+  readonly expandedValue?: readonly string[];
+  readonly selectedValue?: readonly string[];
+  readonly checkedValue?: readonly string[];
+  readonly selectionMode?: string;
+  readonly expandOnClick?: boolean;
+  readonly rename?: boolean;
+  readonly typeahead?: boolean;
+  readonly loadChildren?: unknown;
+}
+export interface TreeNodeShape {
+  readonly value: string;
+  readonly label: string;
+  readonly children?: readonly TreeNodeShape[] | undefined;
+}
+/** The scope grammar has no recursive shape, so the collection parses here. */
+export declare function nodesOf(raw: unknown): TreeNodeShape[];
+declare const keysOf: (value: unknown) => string[];
+export type TreeState = "idle" | "renaming";
+export interface TreeContext {
+  nodes: TreeNodeShape[];
+  expandedValue: string[];
+  selectedValue: string[];
+  checkedValue: string[];
+  focusedValue: string | null;
+  renamingValue: string | null;
+  loadingStatus: Record<string, "loading" | "loaded" | "error">;
+  typeahead: string;
+  typeaheadEnabled: boolean;
+  selectionMode: "single" | "multiple";
+  expandOnClick: boolean;
+  rename: boolean;
+  loadChildren: unknown;
+}
+export declare function initial(args?: TreeArgs, authored?: (name: string) => boolean): TreeContext;
+export declare const sameSet: (a: readonly string[], b: readonly string[]) => boolean;
+export { keysOf };
+//# sourceMappingURL=tree-view.state.d.ts.map

package/dist/tree-view/tree-view.state.js

@@ -0,0 +1,61 @@
+import { coerceJsonArray, defaultTwin, isRecord } from "@spinjs/runtime";
+// src/tree-view/tree-view.state.ts
+/** Malformed entries drop. */
+const shapeNode = (entry) => {
+	if (!isRecord(entry)) return null;
+	const value = entry["value"];
+	if (typeof value !== "string") return null;
+	const label = entry["label"];
+	const node = {
+		value,
+		label: typeof label === "string" ? label : ""
+	};
+	const kids = entry["children"];
+	if (kids !== void 0) {
+		if (!Array.isArray(kids)) return null;
+		const shaped = [];
+		for (const kid of kids) {
+			const child = shapeNode(kid);
+			if (child === null) return null;
+			shaped.push(child);
+		}
+		node.children = shaped;
+	}
+	return node;
+};
+/** The scope grammar has no recursive shape, so the collection parses here. */
+function nodesOf(raw) {
+	const list = typeof raw === "string" ? coerceJsonArray(raw, []) : Array.isArray(raw) ? raw : [];
+	const out = [];
+	for (const entry of list) {
+		const shaped = shapeNode(entry);
+		if (shaped !== null) out.push(shaped);
+	}
+	return out;
+}
+const keysOf = (value) => {
+	if (!Array.isArray(value)) return [];
+	return value.filter((v) => typeof v === "string");
+};
+function initial(args = {}, authored = () => true) {
+	const written = (field) => authored(field) || authored(defaultTwin(field)) || args[defaultTwin(field)] !== void 0;
+	return {
+		nodes: nodesOf(args.nodes),
+		expandedValue: written("expandedValue") ? keysOf(args.expandedValue) : [],
+		selectedValue: written("selectedValue") ? keysOf(args.selectedValue) : [],
+		checkedValue: written("checkedValue") ? keysOf(args.checkedValue) : [],
+		focusedValue: null,
+		renamingValue: null,
+		loadingStatus: {},
+		typeahead: "",
+		typeaheadEnabled: written("typeahead") ? args.typeahead !== false : true,
+		selectionMode: written("selectionMode") ? args.selectionMode === "multiple" ? "multiple" : "single" : "single",
+		expandOnClick: written("expandOnClick") ? args.expandOnClick !== false : true,
+		rename: written("rename") ? args.rename !== false : true,
+		loadChildren: args.loadChildren
+	};
+}
+const sameSet = (a, b) => a.length === b.length && a.every((v) => b.includes(v));
+export { initial, keysOf, nodesOf, sameSet };
+
+//# sourceMappingURL=tree-view.state.js.map

package/dist/tree-view/tree-view.transitions.d.ts

@@ -0,0 +1,30 @@
+import { TreeContext } from "./tree-view.state.js";
+import { TreeEvents } from "./tree-view.events.js";
+import { AssignFor, GuardFor } from "@spinjs/runtime/fsm";
+type TreeAssign<K extends keyof TreeEvents = keyof TreeEvents> = AssignFor<TreeContext, TreeEvents, K>;
+type TreeGuard<K extends keyof TreeEvents = keyof TreeEvents> = GuardFor<TreeContext, TreeEvents, K>;
+export declare const toggleBranch: TreeAssign<"BRANCH.TOGGLE" | "BRANCH_NODE.CLICK">;
+export declare const selectNode: TreeAssign<"NODE.SELECT" | "NODE.CLICK" | "BRANCH_NODE.CLICK">;
+export declare const toggleNodeSelection: TreeAssign<"NODE.CLICK" | "BRANCH_NODE.CLICK">;
+export declare const extendSelectionToNode: TreeAssign<"NODE.CLICK" | "BRANCH_NODE.CLICK">;
+export declare const isMultiToggle: TreeGuard<"NODE.CLICK" | "BRANCH_NODE.CLICK">;
+export declare const isRangeExtend: TreeGuard<"NODE.CLICK" | "BRANCH_NODE.CLICK">;
+export declare const expandedSet: TreeAssign<"EXPANDED.SET">;
+export declare const expandedClear: TreeAssign<"EXPANDED.CLEAR">;
+export declare const selectedSet: TreeAssign<"SELECTED.SET">;
+export declare const selectedClear: TreeAssign<"SELECTED.CLEAR">;
+export declare const checkedSet: TreeAssign<"CHECKED.SET">;
+export declare const checkedClear: TreeAssign<"CHECKED.CLEAR">;
+export declare const checkedToggle: TreeAssign<"CHECKED.TOGGLE">;
+export declare const nodeFocus: TreeAssign<"NODE.FOCUS">;
+export declare const branchExpand: TreeAssign<"BRANCH.EXPAND">;
+export declare const branchCollapse: TreeAssign<"BRANCH.COLLAPSE">;
+export declare const loadStart: TreeAssign<"NODE.LOAD_START">;
+export declare const loadDone: TreeAssign<"NODE.LOAD_DONE">;
+export declare const nodeDeselect: TreeAssign<"NODE.DESELECT">;
+export declare const nodeRename: TreeAssign<"NODE.RENAME">;
+export declare const renameSubmit: TreeAssign<"RENAME.SUBMIT">;
+export declare const renameCancel: TreeAssign<"RENAME.CANCEL">;
+export declare const expandOnClickGuard: TreeGuard<"BRANCH_NODE.CLICK">;
+export {};
+//# sourceMappingURL=tree-view.transitions.d.ts.map