@manta-eu/react 0.1.0

package/dist/components/tree-multi-select/tree-multi-select-rows.js

@@ -0,0 +1,118 @@
+import { isPresent } from "@manta-eu/lib/present";
+// Below this the search box is more clutter than help.
+export const treeSearchThreshold = 7;
+function nodeLabel(node) {
+    return node.name ?? node.id;
+}
+function compareNodes(a, b) {
+    const aNamed = a.name != null;
+    const bNamed = b.name != null;
+    if (aNamed !== bNamed)
+        return aNamed ? -1 : 1;
+    return nodeLabel(a).localeCompare(nodeLabel(b)) || a.id.localeCompare(b.id);
+}
+// Depth-first from the roots with label-sorted siblings; orphans and cycles still surface as roots.
+export function buildTreeRows(nodes) {
+    const ids = new Set(nodes.map(({ id }) => id));
+    const childrenByParent = new Map();
+    const roots = [];
+    for (const node of nodes) {
+        if (node.parent != null && ids.has(node.parent) && node.parent !== node.id) {
+            const siblings = childrenByParent.get(node.parent) ?? [];
+            siblings.push(node);
+            childrenByParent.set(node.parent, siblings);
+        }
+        else {
+            roots.push(node);
+        }
+    }
+    const rows = [];
+    const visited = new Set();
+    function visit(node, depth) {
+        if (visited.has(node.id))
+            return;
+        visited.add(node.id);
+        rows.push({ node, depth });
+        for (const child of [...(childrenByParent.get(node.id) ?? [])].sort(compareNodes)) {
+            visit(child, depth + 1);
+        }
+    }
+    for (const root of [...roots].sort(compareNodes)) {
+        visit(root, 0);
+    }
+    for (const node of nodes) {
+        visit(node, 0);
+    }
+    return rows;
+}
+export function isGroupHead(items, index) {
+    const head = items[index];
+    const next = items[index + 1];
+    return isPresent(head) && isPresent(next) && next.depth > head.depth;
+}
+export function subtreeIds(items, headId) {
+    const headIndex = items.findIndex((item) => item.id === headId);
+    const head = headIndex >= 0 ? items[headIndex] : undefined;
+    if (!isPresent(head))
+        return [];
+    const ids = [];
+    for (let next = headIndex + 1; next < items.length; next++) {
+        const descendant = items[next];
+        if (!isPresent(descendant) || descendant.depth <= head.depth)
+            break;
+        ids.push(descendant.id);
+    }
+    return ids;
+}
+function ancestorIndexes(items, index) {
+    const indexes = [];
+    const row = items[index];
+    if (!row)
+        return indexes;
+    let depth = row.depth;
+    for (let previous = index - 1; previous >= 0 && depth > 0; previous--) {
+        const candidate = items[previous];
+        if (candidate && candidate.depth < depth) {
+            indexes.push(previous);
+            depth = candidate.depth;
+        }
+    }
+    return indexes;
+}
+export function filterTreeItems(items, search) {
+    const term = search.trim().toLowerCase();
+    if (!isPresent(term))
+        return [...items];
+    const matches = (item) => item.label.toLowerCase().includes(term) ||
+        (item.caption ?? "").toLowerCase().includes(term) ||
+        item.id.toLowerCase().includes(term);
+    const kept = new Set();
+    items.forEach((item, index) => {
+        if (!matches(item))
+            return;
+        kept.add(index);
+        for (const ancestor of ancestorIndexes(items, index))
+            kept.add(ancestor);
+        const itemDepth = item.depth;
+        for (let next = index + 1; next < items.length; next++) {
+            const descendant = items[next];
+            if (!descendant || descendant.depth <= itemDepth)
+                break;
+            kept.add(next);
+        }
+    });
+    return items.filter((_, index) => kept.has(index));
+}
+export function visibleTreeItems(items, collapsedIds) {
+    const visible = [];
+    let collapsedDepth = null;
+    for (const item of items) {
+        if (collapsedDepth != null && item.depth > collapsedDepth)
+            continue;
+        collapsedDepth = null;
+        visible.push(item);
+        if (collapsedIds.has(item.id))
+            collapsedDepth = item.depth;
+    }
+    return visible;
+}

package/dist/components/tree-multi-select/tree-multi-select.d.ts

@@ -0,0 +1,9 @@
+import { type TreeSelectItem } from "./tree-multi-select-rows.js";
+export type TreeMultiSelectProps = {
+    items: TreeSelectItem[];
+    selectedIds: ReadonlySet<string>;
+    onToggle: (id: string, checked: boolean) => void;
+    searchPlaceholder: string;
+};
+export declare function TreeMultiSelect(props: TreeMultiSelectProps): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=tree-multi-select.d.ts.map

package/dist/components/tree-multi-select/tree-multi-select.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tree-multi-select.d.ts","sourceRoot":"","sources":["../../../src/components/tree-multi-select/tree-multi-select.tsx"],"names":[],"mappings":"AAOA,OAAO,EAML,KAAK,cAAc,EACpB,MAAM,0BAA0B,CAAC;AAIlC,MAAM,MAAM,oBAAoB,GAAG;IACjC,KAAK,EAAE,cAAc,EAAE,CAAC;IACxB,WAAW,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;IACjC,QAAQ,EAAE,CAAC,EAAE,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,KAAK,IAAI,CAAC;IACjD,iBAAiB,EAAE,MAAM,CAAC;CAC3B,CAAC;AAEF,wBAAgB,eAAe,CAAC,KAAK,EAAE,oBAAoB,2CA2E1D"}

package/dist/components/tree-multi-select/tree-multi-select.js

@@ -0,0 +1,45 @@
+"use client";
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { isPresent } from "@manta-eu/lib/present";
+import { ChevronDown, ChevronRight } from "lucide-react";
+import { useMemo, useState } from "react";
+import { Checkbox } from "../checkbox/index.js";
+import { SearchInput } from "../input/index.js";
+import { filterTreeItems, isGroupHead, subtreeIds, treeSearchThreshold, visibleTreeItems, } from "./tree-multi-select-rows.js";
+const treeIndentRem = 1.5;
+export function TreeMultiSelect(props) {
+    const { items, selectedIds, onToggle, searchPlaceholder } = props;
+    const [search, setSearch] = useState("");
+    const [collapsedIds, setCollapsedIds] = useState(new Set());
+    const isSearching = isPresent(search.trim());
+    const rows = useMemo(() => (isSearching ? filterTreeItems(items, search) : visibleTreeItems(items, collapsedIds)), [items, search, isSearching, collapsedIds]);
+    const groupHeadIds = useMemo(() => new Set(items.filter((_, index) => isGroupHead(items, index)).map((item) => item.id)), [items]);
+    function toggleCollapsed(id) {
+        setCollapsedIds((current) => {
+            const next = new Set(current);
+            if (next.has(id))
+                next.delete(id);
+            else
+                next.add(id);
+            return next;
+        });
+    }
+    return (_jsxs("div", { className: "grid gap-3", children: [items.length > treeSearchThreshold && (_jsx(SearchInput, { placeholder: searchPlaceholder, value: search, onChange: (e) => setSearch(e.target.value) })), !isPresent(rows) ? (_jsx("p", { className: "typography-caption text-muted-foreground", children: "No matches." })) : (_jsx("ul", { className: "grid gap-2 max-h-72 overflow-y-auto", children: rows.map((item) => {
+                    const isCollapsed = collapsedIds.has(item.id);
+                    const hiddenSelectedCount = isCollapsed
+                        ? subtreeIds(items, item.id).filter((id) => selectedIds.has(id)).length
+                        : 0;
+                    return (_jsxs("li", { className: "flex items-center gap-1", style: { paddingLeft: `${item.depth * treeIndentRem}rem` }, children: [!isSearching &&
+                                (groupHeadIds.has(item.id) ? (_jsx("button", { type: "button", "aria-expanded": !isCollapsed, "aria-label": isCollapsed ? `Expand ${item.label}` : `Collapse ${item.label}`, className: "text-muted-foreground", onClick: () => toggleCollapsed(item.id), children: isCollapsed ? (_jsx(ChevronRight, { className: "size-4", "aria-hidden": true })) : (_jsx(ChevronDown, { className: "size-4", "aria-hidden": true })) })) : (_jsx("span", { className: "size-4", "aria-hidden": true }))), _jsx(TreeSelectRow, { item: item, checked: selectedIds.has(item.id), hiddenSelectedCount: hiddenSelectedCount, onToggle: (checked) => onToggle(item.id, checked) })] }, item.id));
+                }) }))] }));
+}
+function TreeSelectRow(props) {
+    const { item, checked, hiddenSelectedCount, onToggle } = props;
+    const selectedBadge = hiddenSelectedCount > 0 ? `${hiddenSelectedCount} selected` : undefined;
+    const suffixes = [item.caption, item.hint, selectedBadge].filter((part) => part != null);
+    const text = [item.label, ...suffixes].join(" · ");
+    if (!item.selectable) {
+        return _jsx("span", { className: "typography-caption-semibold text-muted-foreground", children: text });
+    }
+    return (_jsx(Checkbox, { checked: checked, disabled: item.disabled, onCheckedChange: (value) => onToggle(value === true), label: text }));
+}

package/dist/datastore-picker/DatastorePicker.d.ts

@@ -0,0 +1,12 @@
+import { type Datastore, type DatastoreTreeNode } from "./datastore-picker-rows.js";
+export type DatastorePickerProps = {
+    currentDatastoreId?: string;
+    isOperator?: boolean;
+    isSwitching?: boolean;
+    datastores?: Datastore[];
+    datastoreTree?: readonly DatastoreTreeNode[];
+    isLoadingTree?: boolean;
+    onDatastoreSelected: (datastoreId: string) => void;
+};
+export declare function DatastorePicker(props: DatastorePickerProps): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=DatastorePicker.d.ts.map

package/dist/datastore-picker/DatastorePicker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DatastorePicker.d.ts","sourceRoot":"","sources":["../../src/datastore-picker/DatastorePicker.tsx"],"names":[],"mappings":"AAGA,OAAO,EAIL,KAAK,SAAS,EACd,KAAK,iBAAiB,EACvB,MAAM,yBAAyB,CAAC;AAOjC,MAAM,MAAM,oBAAoB,GAAG;IACjC,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,UAAU,CAAC,EAAE,SAAS,EAAE,CAAC;IAEzB,aAAa,CAAC,EAAE,SAAS,iBAAiB,EAAE,CAAC;IAC7C,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,mBAAmB,EAAE,CAAC,WAAW,EAAE,MAAM,KAAK,IAAI,CAAC;CACpD,CAAC;AAEF,wBAAgB,eAAe,CAAC,KAAK,EAAE,oBAAoB,2CAsF1D"}

package/dist/datastore-picker/DatastorePicker.js

@@ -0,0 +1,33 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { isPresent } from "@manta-eu/lib/present";
+import { LoaderCircle } from "lucide-react";
+import { useMemo, useState } from "react";
+import { datastorePickerRows, filterDatastoreRows, searchThreshold, } from "./datastore-picker-rows.js";
+import { DatastoreRowContent, datastoreRowIndent, datastoreRowTestIdPrefix } from "./DatastoreRow.js";
+import { DropdownGroup, DropdownItem, preventPointerFocus } from "#components/dropdown/index";
+import { SearchInput } from "#components/input/index";
+import { Tooltip, TooltipContent, TooltipProvider, TooltipTrigger } from "#components/tooltip/index";
+import { cn } from "#style";
+export function DatastorePicker(props) {
+    const { currentDatastoreId, isOperator, isSwitching, datastores: userDatastores, datastoreTree, isLoadingTree, onDatastoreSelected, } = props;
+    const [search, setSearch] = useState("");
+    const rows = useMemo(() => datastorePickerRows({ isOperator, currentDatastoreId, userDatastores, datastoreTree }), [datastoreTree, currentDatastoreId, isOperator, userDatastores]);
+    const visibleRows = useMemo(() => filterDatastoreRows(rows, search), [rows, search]);
+    const showSearch = !!isOperator || rows.length > searchThreshold;
+    const showLoading = !!isOperator && !!isLoadingTree;
+    const showEmptyState = !showLoading && !isSwitching && !isPresent(visibleRows);
+    return (_jsxs(TooltipProvider, { delayDuration: 300, children: [_jsxs(DropdownGroup, { className: "p-2 max-h-64 overflow-y-auto", children: [isSwitching && (_jsxs("div", { className: "p-1.5 flex items-center gap-2 typography-caption text-muted-foreground m-auto w-full", children: [_jsx(LoaderCircle, { className: "size-4 animate-spin" }), "Switching datastore..."] })), showLoading && !isSwitching && (_jsx("div", { className: "p-1.5 typography-caption text-muted-foreground", children: "Loading..." })), showEmptyState && _jsx("div", { className: "p-1.5 typography-caption text-muted-foreground", children: "No datastores found" }), visibleRows.map((datastore) => {
+                        const rowDisabled = isSwitching || datastore.active;
+                        // Not a destination, but still an ordinary row so its groups read as sitting under it.
+                        const heading = !!datastore.heading;
+                        const row = (_jsx(DropdownItem, { className: cn("p-1.5 flex", datastore.active && "bg-muted data-[disabled]:opacity-100", heading && "cursor-default hover:bg-transparent focus:bg-transparent"), "data-testid": `${datastoreRowTestIdPrefix}-${datastore.id}`, style: datastoreRowIndent(datastore), onSelect: heading ? (event) => event.preventDefault() : undefined, onClick: () => {
+                                if (!rowDisabled && !heading)
+                                    onDatastoreSelected(datastore.id);
+                            }, 
+                            // preventPointerFocus swallows the event a tooltip opens on, so headings keep theirs.
+                            onPointerMove: heading ? undefined : preventPointerFocus, onPointerLeave: heading ? undefined : preventPointerFocus, disabled: rowDisabled, children: _jsx(DatastoreRowContent, { row: datastore }) }, datastore.id));
+                        if (!datastore.note)
+                            return row;
+                        return (_jsxs(Tooltip, { children: [_jsx(TooltipTrigger, { asChild: true, children: row }), _jsx(TooltipContent, { side: "right", children: datastore.note })] }, datastore.id));
+                    })] }), showSearch && (_jsx(DropdownGroup, { className: "p-2", children: _jsx(SearchInput, { autoFocus: true, placeholder: "Search datastores...", value: search, onChange: (e) => setSearch(e.target.value), onKeyDown: (e) => e.stopPropagation() }) }))] }));
+}

package/dist/datastore-picker/DatastoreRow.d.ts

@@ -0,0 +1,9 @@
+import type { CSSProperties } from "react";
+import type { DatastorePickerRow } from "./datastore-picker-rows.js";
+export declare const datastoreRowTestIdPrefix = "datastore-picker-item";
+export declare function datastoreRowIndent(row: DatastorePickerRow): CSSProperties | undefined;
+export type DatastoreRowContentProps = {
+    row: DatastorePickerRow;
+};
+export declare function DatastoreRowContent(props: DatastoreRowContentProps): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=DatastoreRow.d.ts.map

package/dist/datastore-picker/DatastoreRow.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DatastoreRow.d.ts","sourceRoot":"","sources":["../../src/datastore-picker/DatastoreRow.tsx"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,OAAO,CAAC;AAE3C,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AAKlE,eAAO,MAAM,wBAAwB,0BAA0B,CAAC;AAEhE,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,kBAAkB,GAAG,aAAa,GAAG,SAAS,CAErF;AAED,MAAM,MAAM,wBAAwB,GAAG;IACrC,GAAG,EAAE,kBAAkB,CAAC;CACzB,CAAC;AAEF,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,wBAAwB,2CA4BlE"}

package/dist/datastore-picker/DatastoreRow.js

@@ -0,0 +1,15 @@
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import { Check, Minus } from "lucide-react";
+import { NestedMarker, nestedIndent } from "../nested-indent.js";
+import { Badge } from "#components/badge/index";
+import { Initials } from "#components/sidebar/index";
+import { cn } from "#style";
+export const datastoreRowTestIdPrefix = "datastore-picker-item";
+export function datastoreRowIndent(row) {
+    return nestedIndent((row.depth ?? 0) + 1);
+}
+export function DatastoreRowContent(props) {
+    const { row } = props;
+    const nested = (row.depth ?? 0) > 0;
+    return (_jsxs(_Fragment, { children: [!nested && (_jsx("div", { className: "shrink-0", children: _jsx(Initials, { name: row.name }) })), nested && _jsx(NestedMarker, {}), _jsx("span", { className: cn("min-w-0 truncate typography-caption", row.heading && "text-muted-foreground"), "data-testid": `${datastoreRowTestIdPrefix}-label-${row.id}`, children: row.name }), row.badge && (_jsx(Badge, { variant: "copy", size: "sm", children: row.badge })), _jsx("span", { className: "flex-1" }), row.active && _jsx(Check, { className: "ml-auto size-4" }), row.heading && _jsx(Minus, { className: "ml-auto size-4 text-muted-foreground", "aria-label": "No datastore" })] }));
+}

package/dist/datastore-picker/datastore-picker-rows.d.ts

@@ -0,0 +1,41 @@
+export declare const realmDatastoreId: string;
+export type Datastore = {
+    id: string;
+    name: string;
+    depth?: number;
+    selectable?: boolean;
+    badge?: string;
+};
+export type DatastoreTreeNode = {
+    id: string;
+    name: string;
+    depth?: number;
+    datastoreId?: string | null;
+    removed: boolean;
+};
+export type DatastorePickerRow = {
+    id: string;
+    name: string;
+    active: boolean;
+    badge?: string;
+    heading?: boolean;
+    note?: string;
+    depth?: number;
+    treeDepth?: number;
+};
+export declare function hasDatastoreChoice(datastores?: readonly Datastore[]): boolean;
+export declare function canPickDatastore(args: {
+    canSwitchDatastore?: boolean;
+    canSelect: boolean;
+    datastores?: readonly Datastore[];
+}): boolean;
+export type DatastorePickerRowsArgs = {
+    isOperator?: boolean;
+    currentDatastoreId?: string;
+    userDatastores?: Datastore[];
+    datastoreTree?: readonly DatastoreTreeNode[];
+};
+export declare const searchThreshold = 7;
+export declare function filterDatastoreRows(rows: readonly DatastorePickerRow[], search?: string): DatastorePickerRow[];
+export declare function datastorePickerRows(args: DatastorePickerRowsArgs): DatastorePickerRow[];
+//# sourceMappingURL=datastore-picker-rows.d.ts.map

package/dist/datastore-picker/datastore-picker-rows.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"datastore-picker-rows.d.ts","sourceRoot":"","sources":["../../src/datastore-picker/datastore-picker-rows.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,gBAAgB,QAAgB,CAAC;AAE9C,MAAM,MAAM,SAAS,GAAG;IACtB,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB,CAAC;AAGF,MAAM,MAAM,iBAAiB,GAAG;IAC9B,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,WAAW,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5B,OAAO,EAAE,OAAO,CAAC;CAClB,CAAC;AAEF,MAAM,MAAM,kBAAkB,GAAG;IAC/B,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,OAAO,CAAC;IAChB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB,CAAC;AAuHF,wBAAgB,kBAAkB,CAAC,UAAU,CAAC,EAAE,SAAS,SAAS,EAAE,GAAG,OAAO,CAO7E;AAED,wBAAgB,gBAAgB,CAAC,IAAI,EAAE;IACrC,kBAAkB,CAAC,EAAE,OAAO,CAAC;IAC7B,SAAS,EAAE,OAAO,CAAC;IACnB,UAAU,CAAC,EAAE,SAAS,SAAS,EAAE,CAAC;CACnC,GAAG,OAAO,CAIV;AAED,MAAM,MAAM,uBAAuB,GAAG;IACpC,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B,cAAc,CAAC,EAAE,SAAS,EAAE,CAAC;IAC7B,aAAa,CAAC,EAAE,SAAS,iBAAiB,EAAE,CAAC;CAC9C,CAAC;AAGF,eAAO,MAAM,eAAe,IAAI,CAAC;AAEjC,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,SAAS,kBAAkB,EAAE,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,kBAAkB,EAAE,CAU9G;AAED,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,uBAAuB,GAAG,kBAAkB,EAAE,CAsBvF"}

package/dist/datastore-picker/datastore-picker-rows.js

@@ -0,0 +1,143 @@
+import { activeRealm, realmVocabLabel } from "@manta-eu/ldo/realm";
+import { isPresent } from "@manta-eu/lib/present";
+// Not a Keycloak Organization, so it never appears in datastoreTree.
+export const realmDatastoreId = activeRealm();
+// Organizations, their groups, and one tier below - anything deeper flattens onto the last.
+const maxPickerDepth = 2;
+function pickerDepth(depth) {
+    return Math.min(depth ?? 0, maxPickerDepth);
+}
+// Only an operator can close the gap, so only theirs names it.
+const userUnprovisionedNote = "Your datastores are in the groups below.";
+const operatorUnprovisionedNote = "No datastore yet - add one from Datastores.";
+const removedDatastoreNote = "This datastore has been removed.";
+const aliasedDatastoreNote = "This datastore is already listed above.";
+function operatorCandidate(node, currentDatastoreId) {
+    const datastoreId = node.datastoreId ?? undefined;
+    const selectable = isPresent(datastoreId) && !node.removed;
+    const unprovisioned = !isPresent(datastoreId);
+    return {
+        selectable,
+        headingId: node.id,
+        item: {
+            id: datastoreId ?? node.id,
+            name: node.name,
+            depth: pickerDepth(node.depth),
+            treeDepth: node.depth ?? 0,
+            active: selectable && datastoreId === currentDatastoreId,
+            heading: !selectable,
+            ...(unprovisioned ? { note: operatorUnprovisionedNote } : {}),
+            ...(node.removed ? { note: removedDatastoreNote } : {}),
+        },
+    };
+}
+function userCandidate(datastore, currentDatastoreId) {
+    const selectable = datastore.selectable !== false;
+    return {
+        selectable,
+        item: {
+            id: datastore.id,
+            name: datastore.name,
+            depth: pickerDepth(datastore.depth),
+            treeDepth: datastore.depth ?? 0,
+            badge: datastore.badge,
+            active: selectable && datastore.id === currentDatastoreId,
+            heading: !selectable,
+            ...(selectable ? {} : { note: userUnprovisionedNote }),
+        },
+    };
+}
+function headsGroupWhere(entries, index, depthOf, predicate) {
+    const head = entries[index];
+    if (!head)
+        return false;
+    const headDepth = depthOf(head);
+    for (let next = index + 1; next < entries.length; next++) {
+        const entry = entries[next];
+        if (!entry || depthOf(entry) <= headDepth)
+            return false;
+        if (predicate(entry))
+            return true;
+    }
+    return false;
+}
+const candidateDepth = (candidate) => candidate.item.treeDepth ?? 0;
+const rowDepth = (row) => row.treeDepth ?? 0;
+function prunedToSelectable(candidates) {
+    return candidates
+        .filter((candidate, index) => candidate.selectable || headsGroupWhere(candidates, index, candidateDepth, (entry) => entry.selectable))
+        .map((candidate) => candidate.item);
+}
+function dedupedById(candidates) {
+    const seen = new Set();
+    return candidates.flatMap((candidate, index) => {
+        if (!seen.has(candidate.item.id)) {
+            seen.add(candidate.item.id);
+            return [candidate];
+        }
+        const { headingId } = candidate;
+        const headsGroups = headsGroupWhere(candidates, index, candidateDepth, () => true);
+        if (!headingId || seen.has(headingId) || !headsGroups)
+            return [];
+        seen.add(headingId);
+        return [
+            {
+                selectable: false,
+                item: {
+                    ...candidate.item,
+                    id: headingId,
+                    active: false,
+                    heading: true,
+                    note: aliasedDatastoreNote,
+                },
+            },
+        ];
+    });
+}
+function hasAncestorAbove(datastores, index) {
+    const depth = datastores[index]?.depth ?? 0;
+    return datastores.slice(0, index).some((entry) => (entry.depth ?? 0) < depth);
+}
+export function hasDatastoreChoice(datastores) {
+    const list = datastores ?? [];
+    const selectable = list.flatMap((datastore, index) => (datastore.selectable !== false ? [index] : []));
+    if (selectable.length > 1)
+        return true;
+    const only = selectable[0];
+    return only !== undefined && hasAncestorAbove(list, only);
+}
+export function canPickDatastore(args) {
+    const { canSwitchDatastore, canSelect, datastores } = args;
+    return !!canSwitchDatastore && canSelect && hasDatastoreChoice(datastores);
+}
+// Below this the search box is more clutter than help.
+export const searchThreshold = 7;
+export function filterDatastoreRows(rows, search) {
+    const term = (search ?? "").trim().toLowerCase();
+    if (!term)
+        return [...rows];
+    const matches = (row) => row.name.toLowerCase().includes(term) || row.id.toLowerCase().includes(term);
+    const matched = rows.filter((row, index) => matches(row) || headsGroupWhere(rows, index, rowDepth, matches));
+    return matched.filter((row, index) => !row.heading || headsGroupWhere(matched, index, rowDepth, () => true));
+}
+export function datastorePickerRows(args) {
+    const { isOperator, currentDatastoreId, userDatastores, datastoreTree } = args;
+    const candidates = isOperator
+        ? [
+            {
+                selectable: true,
+                item: {
+                    id: realmDatastoreId,
+                    name: realmVocabLabel(realmDatastoreId),
+                    badge: "Default",
+                    depth: 0,
+                    active: currentDatastoreId === realmDatastoreId,
+                    heading: false,
+                },
+            },
+            ...(datastoreTree ?? []).map((node) => operatorCandidate(node, currentDatastoreId)),
+        ]
+        : // A user's list already carries the realm default when they belong to no organization.
+            (userDatastores ?? []).map((datastore) => userCandidate(datastore, currentDatastoreId));
+    return prunedToSelectable(dedupedById(candidates));
+}

package/dist/datastore-picker/index.d.ts

@@ -0,0 +1,4 @@
+export { DatastorePicker, type DatastorePickerProps } from "./DatastorePicker.js";
+export { DatastoreRowContent, datastoreRowIndent, datastoreRowTestIdPrefix, type DatastoreRowContentProps, } from "./DatastoreRow.js";
+export { canPickDatastore, datastorePickerRows, filterDatastoreRows, hasDatastoreChoice, realmDatastoreId, searchThreshold, type Datastore, type DatastorePickerRow, type DatastorePickerRowsArgs, type DatastoreTreeNode, } from "./datastore-picker-rows.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/datastore-picker/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/datastore-picker/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,KAAK,oBAAoB,EAAE,MAAM,mBAAmB,CAAC;AAC/E,OAAO,EACL,mBAAmB,EACnB,kBAAkB,EAClB,wBAAwB,EACxB,KAAK,wBAAwB,GAC9B,MAAM,gBAAgB,CAAC;AACxB,OAAO,EACL,gBAAgB,EAChB,mBAAmB,EACnB,mBAAmB,EACnB,kBAAkB,EAClB,gBAAgB,EAChB,eAAe,EACf,KAAK,SAAS,EACd,KAAK,kBAAkB,EACvB,KAAK,uBAAuB,EAC5B,KAAK,iBAAiB,GACvB,MAAM,yBAAyB,CAAC"}

package/dist/datastore-picker/index.js

@@ -0,0 +1,3 @@
+export { DatastorePicker } from "./DatastorePicker.js";
+export { DatastoreRowContent, datastoreRowIndent, datastoreRowTestIdPrefix, } from "./DatastoreRow.js";
+export { canPickDatastore, datastorePickerRows, filterDatastoreRows, hasDatastoreChoice, realmDatastoreId, searchThreshold, } from "./datastore-picker-rows.js";

package/dist/easing.d.ts

@@ -0,0 +1,2 @@
+export declare const easeOutCubic: readonly [0.215, 0.61, 0.355, 1];
+//# sourceMappingURL=easing.d.ts.map

package/dist/easing.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"easing.d.ts","sourceRoot":"","sources":["../src/easing.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,YAAY,kCAAmC,CAAC"}

package/dist/easing.js

@@ -0,0 +1 @@
+export const easeOutCubic = [0.215, 0.61, 0.355, 1];

package/dist/engine.d.ts

@@ -0,0 +1,13 @@
+import type { Schema } from "ldkit";
+import { type Options, QueryEngine } from "ldkit";
+export type SparqlEngineConfig = {
+    sparqlEndpoint: string;
+    language?: string;
+    logQuery?: (query: string) => void;
+    headers?: Record<string, string>;
+};
+export declare function withAbortSignal(options: Options, signal: AbortSignal | undefined): Options;
+export declare function createSparqlOptions(config: SparqlEngineConfig): Options;
+export declare function createSparqlEngine(): QueryEngine;
+export declare function createTypedLens<S extends Schema>(schema: S, config: SparqlEngineConfig): import("ldkit").Lens<S>;
+//# sourceMappingURL=engine.d.ts.map

package/dist/engine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"engine.d.ts","sourceRoot":"","sources":["../src/engine.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,OAAO,CAAC;AACpC,OAAO,EAAE,KAAK,OAAO,EAAc,WAAW,EAAE,MAAM,OAAO,CAAC;AAE9D,MAAM,MAAM,kBAAkB,GAAG;IAC/B,cAAc,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,QAAQ,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;IACnC,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAClC,CAAC;AAeF,wBAAgB,eAAe,CAAC,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,WAAW,GAAG,SAAS,GAAG,OAAO,CAa1F;AAED,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,kBAAkB,GAAG,OAAO,CAOvE;AAED,wBAAgB,kBAAkB,IAAI,WAAW,CAEhD;AAED,wBAAgB,eAAe,CAAC,CAAC,SAAS,MAAM,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,kBAAkB,2BAGtF"}

package/dist/engine.js

@@ -0,0 +1,40 @@
+import { createLens, QueryEngine } from "ldkit";
+function createAuthenticatedFetch(headers) {
+    return (input, init) => {
+        const merged = new Headers(init?.headers);
+        for (const [name, value] of Object.entries(headers ?? {}))
+            merged.set(name, value);
+        return fetch(input, {
+            ...init,
+            headers: merged,
+            credentials: "include",
+        });
+    };
+}
+export function withAbortSignal(options, signal) {
+    if (!signal)
+        return options;
+    const baseFetch = options.fetch ?? fetch;
+    return {
+        ...options,
+        fetch: (input, init) => {
+            const merged = init?.signal ? AbortSignal.any([init.signal, signal]) : signal;
+            return baseFetch(input, { ...init, signal: merged });
+        },
+    };
+}
+export function createSparqlOptions(config) {
+    return {
+        sources: [config.sparqlEndpoint],
+        fetch: createAuthenticatedFetch(config.headers),
+        ...(config.language && { language: config.language }),
+        ...(config.logQuery && { logQuery: config.logQuery }),
+    };
+}
+export function createSparqlEngine() {
+    return new QueryEngine();
+}
+export function createTypedLens(schema, config) {
+    const options = createSparqlOptions(config);
+    return createLens(schema, options);
+}

package/dist/entity-tree/EntityRelationTree.d.ts

@@ -0,0 +1,23 @@
+import { type EntityTreeRowRenderer } from "./createEntityTreeRowRenderer.js";
+import { type EntityTreeNode } from "./entity-tree-model.js";
+export type EntityTreeTableProps = {
+    tree: EntityTreeNode[];
+    rowRenderer?: EntityTreeRowRenderer;
+    isLoading?: boolean;
+    loadingNodeIds?: ReadonlySet<string>;
+    emptyMessage?: string;
+    onRequestChildren?: (node: EntityTreeNode) => void;
+};
+export declare function EntityTreeTable(props: EntityTreeTableProps): import("react/jsx-runtime").JSX.Element;
+export type EntityRelationTreeProps = {
+    rootIri: string;
+    rootLabel?: string;
+    rootTypeIri?: string;
+    rowRenderer?: EntityTreeRowRenderer;
+};
+/**
+ * Recursive entity-relation tree for a root IRI. Top-level neighbor rows start collapsed;
+ * expanding a row loads that entity's neighbors on demand.
+ */
+export declare function EntityRelationTree(props: EntityRelationTreeProps): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=EntityRelationTree.d.ts.map

package/dist/entity-tree/EntityRelationTree.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"EntityRelationTree.d.ts","sourceRoot":"","sources":["../../src/entity-tree/EntityRelationTree.tsx"],"names":[],"mappings":"AAIA,OAAO,EAAgC,KAAK,qBAAqB,EAAE,MAAM,+BAA+B,CAAC;AACzG,OAAO,EAAgE,KAAK,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAOxH,MAAM,MAAM,oBAAoB,GAAG;IACjC,IAAI,EAAE,cAAc,EAAE,CAAC;IACvB,WAAW,CAAC,EAAE,qBAAqB,CAAC;IACpC,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,cAAc,CAAC,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;IACrC,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,iBAAiB,CAAC,EAAE,CAAC,IAAI,EAAE,cAAc,KAAK,IAAI,CAAC;CACpD,CAAC;AAEF,wBAAgB,eAAe,CAAC,KAAK,EAAE,oBAAoB,2CAwE1D;AA6CD,MAAM,MAAM,uBAAuB,GAAG;IACpC,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,WAAW,CAAC,EAAE,qBAAqB,CAAC;CACrC,CAAC;AAEF;;;GAGG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,uBAAuB,2CA0EhE"}