@vobs/ui 0.1.0

package/dist/tree.d.ts

@@ -0,0 +1,144 @@
+/** @license MIT
+ * Copyright (c) 2026 vobsjs
+ * @vobs/ui
+ */
+import { type UiAttributes, type UiDomPlan } from './primitives.js';
+export type TreeNodeKind = 'branch' | 'leaf';
+export type TreeLazyLoadState = 'empty' | 'error' | 'loading' | 'partial' | 'ready';
+export type TreeNodeLazyState = 'error' | 'idle' | 'loaded' | 'loading';
+export type TreeNodeActionAvailability = 'available' | 'disabled';
+export type TreePermission = 'allowed' | 'denied';
+export type TreePermissionState = 'empty' | 'permission-limited' | 'ready';
+export type TreeNodeTone = 'css' | 'default' | 'folder' | 'json' | 'ts';
+export interface TreeNodeItem {
+    readonly id: string;
+    readonly label: string;
+    readonly depth?: number;
+    readonly kind?: TreeNodeKind;
+    readonly expanded?: boolean;
+    readonly disabled?: boolean;
+    readonly value?: string;
+    readonly tone?: TreeNodeTone;
+    readonly lazy?: boolean;
+    readonly loading?: boolean;
+    readonly loaded?: boolean;
+    readonly loadError?: string;
+    readonly retryable?: boolean;
+    readonly permission?: TreePermission;
+    readonly disabledReason?: string;
+    readonly actionable?: boolean;
+    readonly actionDisabled?: boolean;
+    readonly actionDisabledReason?: string;
+}
+export interface TreePlanOptions {
+    readonly id: string;
+    readonly nodes: readonly TreeNodeItem[];
+    readonly activeId?: string;
+    readonly selectedId?: string;
+    readonly multiselect?: boolean;
+    readonly disabled?: boolean;
+    readonly labelId?: string;
+    readonly describedBy?: string;
+    readonly className?: string;
+    readonly attrs?: UiAttributes;
+}
+export interface TreePlans {
+    readonly root: UiDomPlan<'div'>;
+    readonly rows: readonly UiDomPlan<'div'>[];
+    readonly chevrons: readonly UiDomPlan<'span'>[];
+    readonly icons: readonly UiDomPlan<'span'>[];
+    readonly labels: readonly UiDomPlan<'span'>[];
+}
+export interface TreeSelectPlanOptions extends TreePlanOptions {
+    readonly open?: boolean;
+    readonly placeholder?: string;
+}
+export interface TreeSelectPlans {
+    readonly root: UiDomPlan<'div'>;
+    readonly trigger: UiDomPlan<'button'>;
+    readonly popup: UiDomPlan<'div'>;
+    readonly tree: TreePlans;
+}
+export interface TreeLazyLoadStateContractOptions {
+    readonly nodes: readonly TreeNodeItem[];
+    readonly loadingIds?: ReadonlySet<string> | readonly string[];
+    readonly loadedIds?: ReadonlySet<string> | readonly string[];
+    readonly errorIds?: ReadonlySet<string> | readonly string[];
+    readonly errors?: Readonly<Record<string, string | undefined>>;
+    readonly retryableIds?: ReadonlySet<string> | readonly string[];
+    readonly disabled?: boolean;
+}
+export interface TreeLazyLoadNodeContract {
+    readonly id: string;
+    readonly state: TreeNodeLazyState;
+    readonly lazy: boolean;
+    readonly loading: boolean;
+    readonly loaded: boolean;
+    readonly error: string;
+    readonly retryable: boolean;
+    readonly canRetry: boolean;
+    readonly attrs: UiAttributes;
+}
+export interface TreeLazyLoadStateContract {
+    readonly state: TreeLazyLoadState;
+    readonly disabled: boolean;
+    readonly nodeCount: number;
+    readonly loadableCount: number;
+    readonly loadingCount: number;
+    readonly loadedCount: number;
+    readonly errorCount: number;
+    readonly retryableCount: number;
+    readonly loadingIds: readonly string[];
+    readonly loadedIds: readonly string[];
+    readonly errorIds: readonly string[];
+    readonly retryableIds: readonly string[];
+    readonly nodes: readonly TreeNodeItem[];
+    readonly nodeContracts: readonly TreeLazyLoadNodeContract[];
+    readonly attrs: UiAttributes;
+}
+export interface TreePermissionStateContractOptions {
+    readonly nodes: readonly TreeNodeItem[];
+    readonly allowedIds?: ReadonlySet<string> | readonly string[];
+    readonly deniedIds?: ReadonlySet<string> | readonly string[];
+    readonly disabledReasons?: Readonly<Record<string, string | undefined>>;
+    readonly actionableIds?: ReadonlySet<string> | readonly string[];
+    readonly actionDisabledIds?: ReadonlySet<string> | readonly string[];
+    readonly actionDisabledReasons?: Readonly<Record<string, string | undefined>>;
+    readonly disabled?: boolean;
+}
+export interface TreePermissionNodeContract {
+    readonly id: string;
+    readonly permission: TreePermission;
+    readonly disabled: boolean;
+    readonly disabledReason: string;
+    readonly actionable: boolean;
+    readonly actionAvailability: TreeNodeActionAvailability;
+    readonly actionDisabled: boolean;
+    readonly actionDisabledReason: string;
+    readonly attrs: UiAttributes;
+}
+export interface TreePermissionStateContract {
+    readonly state: TreePermissionState;
+    readonly disabled: boolean;
+    readonly nodeCount: number;
+    readonly allowedCount: number;
+    readonly deniedCount: number;
+    readonly disabledReasonCount: number;
+    readonly actionableCount: number;
+    readonly actionDisabledCount: number;
+    readonly actionDisabledReasonCount: number;
+    readonly allowedIds: readonly string[];
+    readonly deniedIds: readonly string[];
+    readonly actionableIds: readonly string[];
+    readonly actionDisabledIds: readonly string[];
+    readonly nodes: readonly TreeNodeItem[];
+    readonly nodeContracts: readonly TreePermissionNodeContract[];
+    readonly attrs: UiAttributes;
+}
+export declare function createTreePlans(options: TreePlanOptions): TreePlans;
+export declare function createTreeLazyLoadStateContract(options: TreeLazyLoadStateContractOptions): TreeLazyLoadStateContract;
+export declare function createTreePermissionStateContract(options: TreePermissionStateContractOptions): TreePermissionStateContract;
+export declare function createTreeSelectPlans(options: TreeSelectPlanOptions): TreeSelectPlans;
+export declare function getVisibleTreeNodeIds(nodes: readonly TreeNodeItem[]): readonly string[];
+export declare function getNextTreeNodeId(nodes: readonly TreeNodeItem[], activeId: string | undefined, key: string): string | undefined;
+export declare function shouldToggleTreeNodeForKey(key: string): boolean;

package/dist/tree.js

@@ -0,0 +1,469 @@
+/** @license MIT
+ * Copyright (c) 2026 vobsjs
+ * @vobs/ui
+ */
+import { createUiDomPlan } from './primitives.js';
+export function createTreePlans(options) {
+    const visibleNodes = visibleTreeNodes(options.nodes);
+    const activeId = visibleNodes.some((node) => node.id === options.activeId)
+        ? options.activeId
+        : undefined;
+    const disabled = options.disabled === true;
+    return {
+        root: createUiDomPlan('div', 'tree', {
+            ...(options.className === undefined ? {} : { className: options.className }),
+            disabled,
+            state: disabled ? 'disabled' : visibleNodes.length === 0 ? 'empty' : 'idle',
+            attrs: {
+                id: options.id,
+                role: 'tree',
+                'aria-labelledby': options.labelId,
+                'aria-describedby': options.describedBy,
+                'aria-multiselectable': options.multiselect === true ? 'true' : undefined,
+                ...options.attrs,
+            },
+        }),
+        rows: visibleNodes.map((node, index) => {
+            const nodeDisabled = disabled || node.disabled === true;
+            const selected = node.id === options.selectedId;
+            const active = node.id === activeId || (activeId === undefined && index === 0);
+            const branch = treeNodeKind(node) === 'branch';
+            return createUiDomPlan('div', 'tree-row', {
+                disabled: nodeDisabled,
+                state: nodeDisabled ? 'disabled' : active ? 'active' : selected ? 'selected' : 'idle',
+                ...(selected ? { className: 'is-active' } : {}),
+                attrs: {
+                    id: treeNodeDomId(options.id, node.id),
+                    role: 'treeitem',
+                    tabindex: active && !nodeDisabled ? 0 : -1,
+                    'aria-level': treeNodeDepth(node) + 1,
+                    'aria-expanded': branch ? (node.expanded === true ? 'true' : 'false') : undefined,
+                    'aria-selected': selected ? 'true' : 'false',
+                    'data-node-id': node.id,
+                    'data-value': node.value,
+                    'data-depth': treeNodeDepth(node),
+                    'data-kind': treeNodeKind(node),
+                    'data-lazy-state': treeNodeLazyStateFromItem(node),
+                    'data-lazy': node.lazy === true ? 'true' : undefined,
+                    'data-loading': node.loading === true ? 'true' : undefined,
+                    'data-loaded': node.loaded === true ? 'true' : undefined,
+                    'data-load-error': node.loadError,
+                    'data-retryable': node.retryable === true ? 'true' : undefined,
+                    'data-can-retry': node.loadError !== undefined && node.retryable === true && !nodeDisabled
+                        ? 'true'
+                        : undefined,
+                    'data-permission': node.permission,
+                    'data-disabled-reason': node.disabledReason,
+                    'data-actionable': node.actionable === true ? 'true' : undefined,
+                    'data-action-availability': node.actionable === true
+                        ? node.actionDisabled === true || nodeDisabled
+                            ? 'disabled'
+                            : 'available'
+                        : undefined,
+                    'data-action-disabled': node.actionable === true && (node.actionDisabled === true || nodeDisabled)
+                        ? 'true'
+                        : undefined,
+                    'data-action-disabled-reason': node.actionDisabledReason,
+                    'aria-disabled': nodeDisabled ? 'true' : undefined,
+                    'aria-busy': node.loading === true ? 'true' : undefined,
+                },
+            });
+        }),
+        chevrons: visibleNodes.map((node) => {
+            const branch = treeNodeKind(node) === 'branch';
+            return createUiDomPlan('span', 'tree-chevron', {
+                state: branch ? (node.expanded === true ? 'expanded' : 'collapsed') : 'leaf',
+                ...(branch ? {} : { className: 'kui-tree-chevron--leaf' }),
+                attrs: {
+                    'aria-hidden': 'true',
+                    'data-expanded': branch ? (node.expanded === true ? 'true' : 'false') : undefined,
+                },
+            });
+        }),
+        icons: visibleNodes.map((node) => createUiDomPlan('span', 'tree-icon', {
+            state: treeNodeKind(node),
+            className: `kui-tree-icon--${node.tone ?? (treeNodeKind(node) === 'branch' ? 'folder' : 'default')}`,
+            attrs: {
+                'aria-hidden': 'true',
+                'data-tone': node.tone ?? (treeNodeKind(node) === 'branch' ? 'folder' : 'default'),
+            },
+        })),
+        labels: visibleNodes.map((node) => createUiDomPlan('span', 'tree-label', {
+            attrs: {
+                'data-label': node.label,
+            },
+        })),
+    };
+}
+export function createTreeLazyLoadStateContract(options) {
+    const disabled = options.disabled === true;
+    const knownIds = new Set(options.nodes.map((node) => node.id));
+    const loadingIds = normalizeTreeIds(options.loadingIds, knownIds);
+    const loadedIds = normalizeTreeIds(options.loadedIds, knownIds);
+    const errorIds = normalizeTreeIds(options.errorIds, knownIds);
+    const retryableIds = normalizeTreeIds(options.retryableIds, knownIds);
+    const nodeContracts = options.nodes.map((node) => treeLazyLoadNodeContract(node, {
+        disabled,
+        error: options.errors?.[node.id],
+        loading: loadingIds.includes(node.id),
+        loaded: loadedIds.includes(node.id),
+        errored: errorIds.includes(node.id),
+        retryable: retryableIds.includes(node.id),
+    }));
+    const nodes = options.nodes.map((node, index) => treeNodeWithLazyContract(node, nodeContracts[index]));
+    const loadableCount = nodeContracts.filter((node) => node.lazy).length;
+    const loadingCount = nodeContracts.filter((node) => node.loading).length;
+    const loadedCount = nodeContracts.filter((node) => node.loaded).length;
+    const errorCount = nodeContracts.filter((node) => node.state === 'error').length;
+    const retryableCount = nodeContracts.filter((node) => node.canRetry).length;
+    const state = treeLazyLoadState({
+        errorCount,
+        loadableCount,
+        loadedCount,
+        loadingCount,
+        nodeCount: options.nodes.length,
+    });
+    return {
+        state,
+        disabled,
+        nodeCount: options.nodes.length,
+        loadableCount,
+        loadingCount,
+        loadedCount,
+        errorCount,
+        retryableCount,
+        loadingIds,
+        loadedIds,
+        errorIds,
+        retryableIds,
+        nodes,
+        nodeContracts,
+        attrs: {
+            'data-tree-lazy-load-contract': 'true',
+            'data-state': state,
+            'data-disabled': disabled ? 'true' : undefined,
+            'data-node-count': options.nodes.length,
+            'data-loadable-count': loadableCount,
+            'data-loading-count': loadingCount,
+            'data-loaded-count': loadedCount,
+            'data-error-count': errorCount,
+            'data-retryable-count': retryableCount,
+            'data-loading-ids': loadingIds.join(','),
+            'data-loaded-ids': loadedIds.join(','),
+            'data-error-ids': errorIds.join(','),
+            'data-retryable-ids': retryableIds.join(','),
+            'aria-busy': loadingCount > 0 ? 'true' : undefined,
+        },
+    };
+}
+export function createTreePermissionStateContract(options) {
+    const disabled = options.disabled === true;
+    const knownIds = new Set(options.nodes.map((node) => node.id));
+    const allowedIds = normalizeTreeIds(options.allowedIds, knownIds);
+    const deniedIds = normalizeTreeIds(options.deniedIds, knownIds);
+    const actionableIds = normalizeTreeIds(options.actionableIds, knownIds);
+    const actionDisabledIds = normalizeTreeIds(options.actionDisabledIds, knownIds);
+    const allowedSet = new Set(allowedIds);
+    const deniedSet = new Set(deniedIds);
+    const actionableSet = new Set(actionableIds);
+    const actionDisabledSet = new Set(actionDisabledIds);
+    const hasAllowedIds = options.allowedIds !== undefined;
+    const nodeContracts = options.nodes.map((node) => treePermissionNodeContract(node, {
+        actionDisabled: actionDisabledSet.has(node.id),
+        actionDisabledReason: normalizedTreeReason(options.actionDisabledReasons?.[node.id]),
+        actionable: actionableSet.has(node.id),
+        allowed: allowedSet.has(node.id),
+        denied: deniedSet.has(node.id),
+        disabled,
+        disabledReason: normalizedTreeReason(options.disabledReasons?.[node.id]),
+        hasAllowedIds,
+    }));
+    const nodes = options.nodes.map((node, index) => treeNodeWithPermissionContract(node, nodeContracts[index]));
+    const allowedNodeIds = nodeContracts
+        .filter((node) => node.permission === 'allowed')
+        .map((node) => node.id);
+    const deniedNodeIds = nodeContracts
+        .filter((node) => node.permission === 'denied')
+        .map((node) => node.id);
+    const actionableNodeIds = nodeContracts.filter((node) => node.actionable).map((node) => node.id);
+    const actionDisabledNodeIds = nodeContracts
+        .filter((node) => node.actionDisabled)
+        .map((node) => node.id);
+    const disabledReasonCount = nodeContracts.filter((node) => node.disabledReason !== '').length;
+    const actionDisabledReasonCount = nodeContracts.filter((node) => node.actionDisabledReason !== '').length;
+    const state = treePermissionState({
+        actionDisabledCount: actionDisabledNodeIds.length,
+        deniedCount: deniedNodeIds.length,
+        nodeCount: options.nodes.length,
+    });
+    return {
+        state,
+        disabled,
+        nodeCount: options.nodes.length,
+        allowedCount: allowedNodeIds.length,
+        deniedCount: deniedNodeIds.length,
+        disabledReasonCount,
+        actionableCount: actionableNodeIds.length,
+        actionDisabledCount: actionDisabledNodeIds.length,
+        actionDisabledReasonCount,
+        allowedIds: allowedNodeIds,
+        deniedIds: deniedNodeIds,
+        actionableIds: actionableNodeIds,
+        actionDisabledIds: actionDisabledNodeIds,
+        nodes,
+        nodeContracts,
+        attrs: {
+            'data-tree-permission-contract': 'true',
+            'data-state': state,
+            'data-disabled': disabled ? 'true' : undefined,
+            'data-node-count': options.nodes.length,
+            'data-allowed-count': allowedNodeIds.length,
+            'data-denied-count': deniedNodeIds.length,
+            'data-disabled-reason-count': disabledReasonCount,
+            'data-actionable-count': actionableNodeIds.length,
+            'data-action-disabled-count': actionDisabledNodeIds.length,
+            'data-action-disabled-reason-count': actionDisabledReasonCount,
+            'data-allowed-ids': allowedNodeIds.join(','),
+            'data-denied-ids': deniedNodeIds.join(','),
+            'data-actionable-ids': actionableNodeIds.join(','),
+            'data-action-disabled-ids': actionDisabledNodeIds.join(','),
+        },
+    };
+}
+export function createTreeSelectPlans(options) {
+    const open = options.open === true;
+    const selected = options.nodes.find((node) => node.id === options.selectedId);
+    const tree = createTreePlans({
+        id: `${options.id}-tree`,
+        nodes: options.nodes,
+        ...(options.activeId === undefined ? {} : { activeId: options.activeId }),
+        ...(options.selectedId === undefined ? {} : { selectedId: options.selectedId }),
+        ...(options.multiselect === undefined ? {} : { multiselect: options.multiselect }),
+        ...(options.disabled === undefined ? {} : { disabled: options.disabled }),
+        ...(options.labelId === undefined ? {} : { labelId: options.labelId }),
+        ...(options.describedBy === undefined ? {} : { describedBy: options.describedBy }),
+    });
+    return {
+        root: createUiDomPlan('div', 'tree-select', {
+            ...(options.className === undefined ? {} : { className: options.className }),
+            ...(options.disabled === undefined ? {} : { disabled: options.disabled }),
+            state: options.disabled === true ? 'disabled' : open ? 'open' : 'closed',
+            attrs: {
+                id: options.id,
+            },
+        }),
+        trigger: createUiDomPlan('button', 'tree-select-trigger', {
+            ...(options.disabled === undefined ? {} : { disabled: options.disabled }),
+            state: options.disabled === true ? 'disabled' : open ? 'open' : 'closed',
+            attrs: {
+                id: `${options.id}-trigger`,
+                type: 'button',
+                role: 'combobox',
+                'aria-haspopup': 'tree',
+                'aria-expanded': open ? 'true' : 'false',
+                'aria-controls': `${options.id}-popup`,
+                'aria-labelledby': options.labelId,
+                'aria-describedby': options.describedBy,
+                'data-value': selected?.value ?? selected?.id,
+                'data-label': selected?.label ?? options.placeholder,
+            },
+        }),
+        popup: createUiDomPlan('div', 'tree-select-popup', {
+            state: open ? 'open' : 'closed',
+            attrs: {
+                id: `${options.id}-popup`,
+                hidden: open ? undefined : true,
+            },
+        }),
+        tree,
+    };
+}
+export function getVisibleTreeNodeIds(nodes) {
+    return visibleTreeNodes(nodes).map((node) => node.id);
+}
+export function getNextTreeNodeId(nodes, activeId, key) {
+    const enabled = visibleTreeNodes(nodes).filter((node) => node.disabled !== true);
+    if (enabled.length === 0)
+        return activeId;
+    const currentIndex = Math.max(-1, enabled.findIndex((node) => node.id === activeId));
+    if (key === 'Home')
+        return enabled[0]?.id;
+    if (key === 'End')
+        return enabled.at(-1)?.id;
+    if (key === 'ArrowUp')
+        return enabled.at(currentIndex - 1)?.id ?? enabled.at(-1)?.id;
+    if (key === 'ArrowDown')
+        return enabled[(currentIndex + 1) % enabled.length]?.id;
+    return activeId;
+}
+export function shouldToggleTreeNodeForKey(key) {
+    return key === 'Enter' || key === ' ' || key === 'ArrowLeft' || key === 'ArrowRight';
+}
+function treeNodeDomId(treeId, nodeId) {
+    return `${treeId}-${nodeId}-treeitem`;
+}
+function treeLazyLoadNodeContract(node, options) {
+    const lazy = node.lazy === true || treeNodeKind(node) === 'branch';
+    const error = (options.error ?? node.loadError ?? '').trim();
+    const loading = options.loading || node.loading === true;
+    const loaded = !loading && (options.loaded || node.loaded === true);
+    const errored = !loading && (options.errored || error !== '');
+    const state = loading
+        ? 'loading'
+        : errored
+            ? 'error'
+            : loaded
+                ? 'loaded'
+                : 'idle';
+    const retryable = options.retryable || node.retryable === true;
+    const canRetry = !options.disabled && state === 'error' && retryable;
+    return {
+        id: node.id,
+        state,
+        lazy,
+        loading,
+        loaded,
+        error,
+        retryable,
+        canRetry,
+        attrs: {
+            'data-node-id': node.id,
+            'data-lazy-state': state,
+            'data-lazy': lazy ? 'true' : undefined,
+            'data-loading': loading ? 'true' : undefined,
+            'data-loaded': loaded ? 'true' : undefined,
+            'data-load-error': error === '' ? undefined : error,
+            'data-retryable': retryable ? 'true' : undefined,
+            'data-can-retry': canRetry ? 'true' : 'false',
+            'aria-busy': loading ? 'true' : undefined,
+        },
+    };
+}
+function treeNodeWithLazyContract(node, contract) {
+    if (contract === undefined)
+        return node;
+    return {
+        ...node,
+        lazy: contract.lazy,
+        loading: contract.loading,
+        loaded: contract.loaded,
+        ...(contract.error === '' ? {} : { loadError: contract.error }),
+        retryable: contract.retryable,
+    };
+}
+function treePermissionNodeContract(node, options) {
+    const permission = options.denied || (options.hasAllowedIds && !options.allowed) ? 'denied' : 'allowed';
+    const disabled = options.disabled || node.disabled === true || permission === 'denied';
+    const nodeDisabledReason = options.disabledReason || normalizedTreeReason(node.disabledReason);
+    const disabledReason = permission === 'denied' && nodeDisabledReason === ''
+        ? 'Permission required'
+        : nodeDisabledReason;
+    const actionable = options.actionable || node.actionable === true || options.actionDisabled;
+    const actionDisabled = actionable && (options.actionDisabled || node.actionDisabled === true);
+    const nodeActionDisabledReason = options.actionDisabledReason || normalizedTreeReason(node.actionDisabledReason);
+    const actionDisabledReason = actionDisabled && nodeActionDisabledReason === ''
+        ? 'Action unavailable'
+        : nodeActionDisabledReason;
+    const actionAvailability = actionDisabled || disabled ? 'disabled' : 'available';
+    return {
+        id: node.id,
+        permission,
+        disabled,
+        disabledReason,
+        actionable,
+        actionAvailability,
+        actionDisabled,
+        actionDisabledReason,
+        attrs: {
+            'data-node-id': node.id,
+            'data-permission': permission,
+            'data-disabled-reason': disabledReason,
+            'data-actionable': actionable ? 'true' : undefined,
+            'data-action-availability': actionable ? actionAvailability : undefined,
+            'data-action-disabled': actionable && actionAvailability === 'disabled' ? 'true' : undefined,
+            'data-action-disabled-reason': actionDisabledReason,
+            'aria-disabled': disabled ? 'true' : undefined,
+        },
+    };
+}
+function treeNodeWithPermissionContract(node, contract) {
+    if (contract === undefined)
+        return node;
+    return {
+        ...node,
+        disabled: contract.disabled,
+        permission: contract.permission,
+        ...(contract.disabledReason === '' ? {} : { disabledReason: contract.disabledReason }),
+        ...(contract.actionable ? { actionable: true } : {}),
+        ...(contract.actionDisabled ? { actionDisabled: true } : {}),
+        ...(contract.actionDisabledReason === ''
+            ? {}
+            : { actionDisabledReason: contract.actionDisabledReason }),
+    };
+}
+function normalizeTreeIds(ids, knownIds) {
+    if (ids === undefined)
+        return [];
+    const result = [];
+    for (const id of ids) {
+        if (!knownIds.has(id) || result.includes(id))
+            continue;
+        result.push(id);
+    }
+    return result;
+}
+function treeLazyLoadState(options) {
+    if (options.nodeCount === 0)
+        return 'empty';
+    if (options.loadingCount > 0)
+        return 'loading';
+    if (options.errorCount > 0)
+        return 'error';
+    if (options.loadableCount > 0 && options.loadedCount >= options.loadableCount)
+        return 'ready';
+    if (options.loadedCount > 0)
+        return 'partial';
+    return 'ready';
+}
+function treePermissionState(options) {
+    if (options.nodeCount === 0)
+        return 'empty';
+    if (options.deniedCount > 0 || options.actionDisabledCount > 0)
+        return 'permission-limited';
+    return 'ready';
+}
+function normalizedTreeReason(reason) {
+    return reason?.trim() ?? '';
+}
+function visibleTreeNodes(nodes) {
+    const visible = [];
+    let collapsedDepth;
+    for (const node of nodes) {
+        const depth = treeNodeDepth(node);
+        if (collapsedDepth !== undefined) {
+            if (depth > collapsedDepth)
+                continue;
+            collapsedDepth = undefined;
+        }
+        visible.push(node);
+        if (treeNodeKind(node) === 'branch' && node.expanded !== true) {
+            collapsedDepth = depth;
+        }
+    }
+    return visible;
+}
+function treeNodeDepth(node) {
+    return Math.max(0, Math.trunc(node.depth ?? 0));
+}
+function treeNodeKind(node) {
+    return node.kind ?? 'leaf';
+}
+function treeNodeLazyStateFromItem(node) {
+    if (node.loading === true)
+        return 'loading';
+    if (node.loadError !== undefined && node.loadError.trim() !== '')
+        return 'error';
+    if (node.loaded === true)
+        return 'loaded';
+    return node.lazy === true ? 'idle' : undefined;
+}