@threadlabs/looma 0.1.22 → 0.1.24

package/dist/esm/ui-tree.entry.js

@@ -1,4 +1,4 @@
-import { r as registerInstance, g as getElement, h, H as Host } from './index-CEeiinfk.js';
+import { r as registerInstance, g as getElement, h, H as Host } from './index-8BGiMGQ0.js';
 import { d as dispatchDetail } from './events-JwSoedEO.js';
 
 /**
@@ -53,7 +53,7 @@ function createHoverIntent(delay, onIntent) {
     };
 }
 
-const uiTreeCss = () => `:host{--ui-tree-indent:16px;display:block;min-inline-size:0;padding-inline-start:var(--ui-tree-gutter, 22px)}::slotted(ui-tree-item){--ui-tree-indent:inherit}`;
+const uiTreeCss = () => `:host{--ui-tree-indent:16px;--ui-tree-gutter:0px;display:block;min-inline-size:0;padding-inline-start:var(--ui-tree-gutter)}::slotted(ui-tree-item){--ui-tree-indent:inherit}`;
 
 const UITree = class {
     constructor(hostRef) {
@@ -62,10 +62,17 @@ const UITree = class {
     get host() { return getElement(this); }
     label = 'Tree';
     hoverExpandDelay = 700;
+    /** Maximum resulting item depth accepted by pointer reordering. Zero is unlimited. */
+    maxDepth = 0;
     source = null;
     target = null;
     position = null;
+    rejectedTarget = null;
+    rejectedPosition = null;
+    rejection = null;
     hoverIntent = null;
+    structureObserver = null;
+    tabStop = null;
     componentDidLoad() {
         this.hoverIntent = createHoverIntent(this.hoverExpandDelay, this.expandTarget);
         this.host.addEventListener('dragstart', this.onDragStart);
@@ -76,6 +83,11 @@ const UITree = class {
         this.host.addEventListener('drop', this.onDrop);
         this.host.addEventListener('dragend', this.onDragEnd);
         this.host.addEventListener('keydown', this.onKeyDown);
+        this.host.addEventListener('focusin', this.onFocusIn);
+        this.host.addEventListener('ui-tree-expansion-change', this.onExpansionChange);
+        this.syncStructuralLevels();
+        this.structureObserver = new MutationObserver(this.syncStructuralLevels);
+        this.structureObserver.observe(this.host, { childList: true, subtree: true });
     }
     disconnectedCallback() {
         this.hoverIntent?.destroy();
@@ -87,10 +99,44 @@ const UITree = class {
         this.host.removeEventListener('drop', this.onDrop);
         this.host.removeEventListener('dragend', this.onDragEnd);
         this.host.removeEventListener('keydown', this.onKeyDown);
+        this.host.removeEventListener('focusin', this.onFocusIn);
+        this.host.removeEventListener('ui-tree-expansion-change', this.onExpansionChange);
+        this.structureObserver?.disconnect();
+        this.structureObserver = null;
+    }
+    syncStructuralLevels = () => {
+        for (const item of Array.from(this.host.querySelectorAll('ui-tree-item'))) {
+            item.dispatchEvent(new CustomEvent('ui-tree-structure-sync'));
+        }
+        this.syncTabStop();
+    };
+    syncTabStop(preferred) {
+        const items = this.visibleItems();
+        const next = preferred && items.includes(preferred)
+            ? preferred
+            : this.tabStop && items.includes(this.tabStop)
+                ? this.tabStop
+                : items[0] ?? null;
+        this.tabStop = next;
+        for (const item of items) {
+            item.dispatchEvent(new CustomEvent('ui-tree-roving-tab-stop', {
+                detail: { active: item === next },
+            }));
+        }
     }
     itemFromEvent(event) {
         return event.composedPath().find(node => (node instanceof HTMLElement && node.localName === 'ui-tree-item')) ?? null;
     }
+    eventTargetsInteractiveContent(event) {
+        for (const node of event.composedPath()) {
+            if (node instanceof HTMLElement && node.localName === 'ui-tree-item')
+                break;
+            if (node instanceof HTMLElement && node.matches('a, button, input, select, textarea, [role="button"], [role="link"]')) {
+                return true;
+            }
+        }
+        return false;
+    }
     itemId(item) {
         return item.itemId || item.getAttribute('item-id') || '';
     }
@@ -132,19 +178,56 @@ const UITree = class {
                 .filter(Boolean),
         };
     }
-    permitsDrop(source, target, position) {
+    constraintDepth(item) {
+        if (item.dropDepth !== undefined)
+            return item.dropDepth;
+        const dropDepth = item.getAttribute('drop-depth');
+        if (dropDepth !== null)
+            return Number(dropDepth);
+        return Number(item.getAttribute('aria-level')) || 1;
+    }
+    subtreeDepth(item) {
+        if (item.subtreeDepth !== undefined)
+            return Math.max(0, Math.floor(item.subtreeDepth));
+        const override = item.getAttribute('subtree-depth');
+        if (override !== null)
+            return Math.max(0, Math.floor(Number(override)));
+        return Array.from(item.querySelectorAll('ui-tree-item')).reduce((deepest, descendant) => {
+            let nesting = 0;
+            let ancestor = descendant.parentElement?.closest('ui-tree-item') ?? null;
+            while (ancestor && ancestor !== item) {
+                nesting += 1;
+                ancestor = ancestor.parentElement?.closest('ui-tree-item') ?? null;
+            }
+            return ancestor === item ? Math.max(deepest, nesting + 1) : deepest;
+        }, 0);
+    }
+    dropRejection(source, target, position) {
         // A tree item can never move into (or beside) one of its own descendants.
         // Reject the target before showing any insertion affordance so the preview
         // stays truthful instead of promising a move the consumer must undo.
         if (source.contains(target))
-            return false;
+            return { reason: 'descendant' };
         const sourceMeta = this.itemMetadata(source);
         const targetMeta = this.itemMetadata(target);
         if (position === 'inside') {
-            return this.acceptsChildren(target)
-                && (targetMeta.accepts.length === 0 || targetMeta.accepts.includes(sourceMeta.type));
+            if (!this.acceptsChildren(target)
+                || (targetMeta.accepts.length > 0 && !targetMeta.accepts.includes(sourceMeta.type))) {
+                return { reason: 'incompatible' };
+            }
+        }
+        else if (sourceMeta.type !== targetMeta.type) {
+            return { reason: 'incompatible' };
         }
-        return sourceMeta.type === targetMeta.type;
+        const maxDepth = Math.max(0, Math.floor(this.maxDepth));
+        if (maxDepth > 0) {
+            const targetDepth = Math.max(0, Math.floor(this.constraintDepth(target)));
+            const subtreeDepth = this.subtreeDepth(source);
+            const resultingDepth = targetDepth + (position === 'inside' ? 1 : 0) + subtreeDepth;
+            if (resultingDepth > maxDepth)
+                return { reason: 'max-depth', maxDepth, resultingDepth };
+        }
+        return null;
     }
     clearTarget() {
         this.target?.removeAttribute('data-drop-position');
@@ -152,10 +235,16 @@ const UITree = class {
         this.position = null;
         this.hoverIntent?.cancel();
     }
+    clearRejection() {
+        this.rejectedTarget = null;
+        this.rejectedPosition = null;
+        this.rejection = null;
+    }
     finishDrag() {
         this.source?.removeAttribute('data-dragging');
         this.source = null;
         this.clearTarget();
+        this.clearRejection();
     }
     expandTarget = (itemId) => {
         const item = Array.from(this.host.querySelectorAll('ui-tree-item'))
@@ -193,18 +282,29 @@ const UITree = class {
             return false;
         if (!target || target === this.source) {
             this.clearTarget();
+            this.clearRejection();
             return false;
         }
         const row = this.rowFor(target);
         if (!row)
             return false;
         const position = classifyDropPosition(row.getBoundingClientRect(), clientY, this.acceptsChildren(target));
-        if (!this.permitsDrop(this.source, target, position)) {
+        const rejection = this.dropRejection(this.source, target, position);
+        if (rejection) {
             if (dataTransfer)
                 dataTransfer.dropEffect = 'none';
             this.clearTarget();
+            if (rejection.reason === 'max-depth') {
+                this.rejectedTarget = target;
+                this.rejectedPosition = position;
+                this.rejection = rejection;
+            }
+            else {
+                this.clearRejection();
+            }
             return false;
         }
+        this.clearRejection();
         if (dataTransfer)
             dataTransfer.dropEffect = 'move';
         if (this.target !== target || this.position !== position) {
@@ -246,12 +346,15 @@ const UITree = class {
         if (this.itemAtPoint(event.clientX, event.clientY))
             return;
         this.clearTarget();
+        this.clearRejection();
     };
     dispatchReorder(source, target, position) {
         const sourceId = this.itemId(source);
         const targetId = this.itemId(target);
         if (!sourceId || !targetId)
             return;
+        if (position === 'inside')
+            this.expandTarget(targetId);
         const sourceMeta = this.itemMetadata(source);
         const targetMeta = this.itemMetadata(target);
         dispatchDetail(this.host, 'reorder', {
@@ -265,6 +368,21 @@ const UITree = class {
             trigger: 'pointer',
         });
     }
+    dispatchReorderRejected(source, target, position, rejection) {
+        const sourceId = this.itemId(source);
+        const targetId = this.itemId(target);
+        if (!sourceId || !targetId)
+            return;
+        dispatchDetail(this.host, 'reorder-rejected', {
+            sourceId,
+            targetId,
+            position,
+            reason: 'max-depth',
+            maxDepth: rejection.maxDepth,
+            resultingDepth: rejection.resultingDepth,
+            trigger: 'pointer',
+        });
+    }
     onDrop = (event) => {
         if (!this.source || !this.target || !this.position)
             return;
@@ -274,14 +392,23 @@ const UITree = class {
     };
     onDragEnd = (event) => {
         if (this.source) {
+            if (this.rejectedTarget && this.rejectedPosition && this.rejection) {
+                this.dispatchReorderRejected(this.source, this.rejectedTarget, this.rejectedPosition, this.rejection);
+                this.finishDrag();
+                return;
+            }
             const target = this.itemAtPoint(event.clientX, event.clientY);
             if (target && target !== this.source) {
                 const row = this.rowFor(target);
                 if (row) {
                     const position = classifyDropPosition(row.getBoundingClientRect(), event.clientY, this.acceptsChildren(target));
-                    if (this.permitsDrop(this.source, target, position)) {
+                    const rejection = this.dropRejection(this.source, target, position);
+                    if (!rejection) {
                         this.dispatchReorder(this.source, target, position);
                     }
+                    else if (rejection.reason === 'max-depth') {
+                        this.dispatchReorderRejected(this.source, target, position, rejection);
+                    }
                 }
             }
         }
@@ -291,7 +418,35 @@ const UITree = class {
         return Array.from(this.host.querySelectorAll('ui-tree-item'))
             .filter(item => item.getClientRects().length > 0 && !item.hasAttribute('disabled'));
     }
+    parentItem(item) {
+        const parent = item.parentElement?.closest('ui-tree-item') ?? null;
+        return parent && this.host.contains(parent) ? parent : null;
+    }
+    firstVisibleChild(item, items) {
+        return items.find(candidate => this.parentItem(candidate) === item) ?? null;
+    }
+    focusItem(item) {
+        this.syncTabStop(item);
+        item.focus();
+    }
+    requestExpansion(item, expanded) {
+        item.dispatchEvent(new CustomEvent('ui-tree-request-expanded', {
+            detail: { expanded, trigger: 'keyboard' },
+        }));
+    }
+    onFocusIn = (event) => {
+        if (this.eventTargetsInteractiveContent(event))
+            return;
+        const item = this.itemFromEvent(event);
+        if (item)
+            this.syncTabStop(item);
+    };
+    onExpansionChange = () => {
+        requestAnimationFrame(() => this.syncTabStop());
+    };
     onKeyDown = (event) => {
+        if (this.eventTargetsInteractiveContent(event))
+            return;
         const current = this.itemFromEvent(event);
         if (!current)
             return;
@@ -299,14 +454,43 @@ const UITree = class {
         const index = items.indexOf(current);
         if (index < 0)
             return;
-        const next = event.key === 'ArrowDown' ? items[index + 1] : event.key === 'ArrowUp' ? items[index - 1] : null;
-        if (!next)
+        const next = event.key === 'ArrowDown' ? items[index + 1]
+            : event.key === 'ArrowUp' ? items[index - 1]
+                : event.key === 'Home' ? items[0]
+                    : event.key === 'End' ? items.at(-1)
+                        : null;
+        if (next) {
+            event.preventDefault();
+            this.focusItem(next);
             return;
-        event.preventDefault();
-        next.focus();
+        }
+        if (event.key === 'ArrowLeft') {
+            if (current.getAttribute('aria-expanded') === 'true') {
+                event.preventDefault();
+                this.requestExpansion(current, false);
+            }
+            else if (this.parentItem(current)) {
+                event.preventDefault();
+                this.focusItem(this.parentItem(current));
+            }
+            return;
+        }
+        if (event.key === 'ArrowRight') {
+            if (current.getAttribute('aria-expanded') === 'false') {
+                event.preventDefault();
+                this.requestExpansion(current, true);
+            }
+            else if (current.getAttribute('aria-expanded') === 'true') {
+                const child = this.firstVisibleChild(current, items);
+                if (child) {
+                    event.preventDefault();
+                    this.focusItem(child);
+                }
+            }
+        }
     };
     render() {
-        return (h(Host, { key: '7da064127eb199f5e2cfc59489a07204c9dac2f2', role: "tree", "aria-label": this.label || 'Tree' }, h("slot", { key: '31a98a6774ab35e565dab65f1dd8202494432b32' })));
+        return (h(Host, { key: '549c09abc67dc60b16bf2d6b7d6346f214e9d6ae', role: "tree", "aria-label": this.label || 'Tree' }, h("slot", { key: 'fea59bde97611bf384e32ce4fb2b3eec9aca784f' })));
     }
 };
 UITree.style = uiTreeCss();