@dxos/react-ui-list 0.8.4-main.8342792842 → 0.8.4-main.8360d9e660

package/dist/lib/browser/index.mjs

@@ -44,7 +44,7 @@ var AccordionItemHeader = ({ classNames, children, ...props }) => {
     ...props,
     className: mx2(classNames)
   }, /* @__PURE__ */ React2.createElement(AccordionPrimitive2.Trigger, {
-    className: "group flex items-center p-2 dx-focus-ring-inset is-full text-start"
+    className: "group flex items-center p-2 dx-focus-ring-inset w-full text-start"
   }, children, /* @__PURE__ */ React2.createElement(Icon, {
     icon: "ph--caret-right--regular",
     size: 4,
@@ -74,6 +74,7 @@ import { draggable, dropTargetForElements } from "@atlaskit/pragmatic-drag-and-d
 import { setCustomNativeDragPreview } from "@atlaskit/pragmatic-drag-and-drop/element/set-custom-native-drag-preview";
 import { attachClosestEdge, extractClosestEdge as extractClosestEdge2 } from "@atlaskit/pragmatic-drag-and-drop-hitbox/closest-edge";
 import { createContext as createContext4 } from "@radix-ui/react-context";
+import { Slot } from "@radix-ui/react-slot";
 import React4, { useEffect as useEffect2, useRef, useState as useState2 } from "react";
 import { createPortal } from "react-dom";
 import { invariant } from "@dxos/invariant";
@@ -160,16 +161,17 @@ var stateStyles = {
 var defaultContext = {};
 var LIST_ITEM_NAME = "ListItem";
 var [ListItemProvider, useListItemContext] = createContext4(LIST_ITEM_NAME, defaultContext);
-var ListItem = ({ children, classNames, item, ...props }) => {
+var ListItem = ({ children, classNames, item, asChild, selected, ...props }) => {
+  const Comp = asChild ? Slot : "div";
   const { isItem, readonly, dragPreview, setState: setRootState } = useListContext(LIST_ITEM_NAME);
-  const ref = useRef(null);
+  const rootRef = useRef(null);
   const dragHandleRef = useRef(null);
   const [state, setState] = useState2(idle);
   useEffect2(() => {
-    const element = ref.current;
+    const element = rootRef.current;
     invariant(element, void 0, {
       F: __dxlog_file,
-      L: 98,
+      L: 109,
       S: void 0,
       A: [
         "element",
@@ -278,40 +280,41 @@ var ListItem = ({ children, classNames, item, ...props }) => {
   return /* @__PURE__ */ React4.createElement(ListItemProvider, {
     item,
     dragHandleRef
-  }, /* @__PURE__ */ React4.createElement("div", {
-    ref,
+  }, /* @__PURE__ */ React4.createElement(Comp, {
+    ...props,
     role: "listitem",
-    className: mx3("flex relative", classNames, stateStyles[state.type]),
-    ...props
-  }, children, state.type === "is-dragging-over" && state.closestEdge && /* @__PURE__ */ React4.createElement(NaturalListItem.DropIndicator, {
+    "aria-selected": selected,
+    className: mx3("relative p-1 dx-selected dx-hover", classNames, stateStyles[state.type]),
+    ref: rootRef
+  }, children), state.type === "is-dragging-over" && state.closestEdge && /* @__PURE__ */ React4.createElement(NaturalListItem.DropIndicator, {
     edge: state.closestEdge
-  })));
+  }));
 };
-var ListItemDeleteButton = ({ autoHide = true, classNames, disabled, icon = "ph--x--regular", label, ...props }) => {
-  const { state } = useListContext("DELETE_BUTTON");
+var ListItemIconButton = ({ autoHide = true, iconOnly = true, variant = "ghost", classNames, disabled, ...props }) => {
+  const { state } = useListContext("ITEM_BUTTON");
   const isDisabled = state.type !== "idle" || disabled;
-  const { t } = useTranslation(osTranslations);
   return /* @__PURE__ */ React4.createElement(IconButton, {
-    iconOnly: true,
-    variant: "ghost",
     ...props,
-    icon,
     disabled: isDisabled,
-    label: label ?? t("delete label"),
+    iconOnly,
+    variant,
     classNames: [
       classNames,
       autoHide && disabled && "hidden"
     ]
   });
 };
-var ListItemButton = ({ autoHide = true, iconOnly = true, variant = "ghost", classNames, disabled, ...props }) => {
-  const { state } = useListContext("ITEM_BUTTON");
+var ListItemDeleteButton = ({ autoHide = true, classNames, disabled, icon = "ph--x--regular", label, ...props }) => {
+  const { state } = useListContext("DELETE_BUTTON");
   const isDisabled = state.type !== "idle" || disabled;
+  const { t } = useTranslation(osTranslations);
   return /* @__PURE__ */ React4.createElement(IconButton, {
     ...props,
+    variant: "ghost",
     disabled: isDisabled,
-    iconOnly,
-    variant,
+    icon,
+    iconOnly: true,
+    label: label ?? t("delete label"),
     classNames: [
       classNames,
       autoHide && disabled && "hidden"
@@ -322,12 +325,12 @@ var ListItemDragHandle = ({ disabled }) => {
   const { dragHandleRef } = useListItemContext("DRAG_HANDLE");
   const { t } = useTranslation(osTranslations);
   return /* @__PURE__ */ React4.createElement(IconButton, {
-    iconOnly: true,
     variant: "ghost",
-    label: t("drag handle label"),
-    ref: dragHandleRef,
+    disabled,
     icon: "ph--dots-six-vertical--regular",
-    disabled
+    iconOnly: true,
+    label: t("drag handle label"),
+    ref: dragHandleRef
   });
 };
 var ListItemDragPreview = ({ children }) => {
@@ -337,9 +340,11 @@ var ListItemDragPreview = ({ children }) => {
   }), state.container) : null;
 };
 var ListItemWrapper = ({ classNames, children }) => /* @__PURE__ */ React4.createElement("div", {
-  className: mx3("flex is-full gap-2", classNames)
+  role: "none",
+  className: mx3("flex w-full gap-2", classNames)
 }, children);
 var ListItemTitle = ({ classNames, children, ...props }) => /* @__PURE__ */ React4.createElement("div", {
+  role: "none",
   className: mx3("flex grow items-center truncate", classNames),
   ...props
 }, children);
@@ -351,12 +356,13 @@ var List = {
   ItemDragPreview: ListItemDragPreview,
   ItemWrapper: ListItemWrapper,
   ItemDragHandle: ListItemDragHandle,
+  ItemIconButton: ListItemIconButton,
   ItemDeleteButton: ListItemDeleteButton,
-  ItemButton: ListItemButton,
   ItemTitle: ListItemTitle
 };
 
 // src/components/Tree/Tree.tsx
+import { useAtomValue as useAtomValue2 } from "@effect-atom/atom-react";
 import React8, { useMemo as useMemo2 } from "react";
 import { Treegrid as Treegrid2 } from "@dxos/react-ui";
 
@@ -371,11 +377,12 @@ var useTree = () => useContext(TreeContext) ?? raise(new Error("TreeContext not
 import { combine as combine2 } from "@atlaskit/pragmatic-drag-and-drop/combine";
 import { draggable as draggable2, dropTargetForElements as dropTargetForElements2 } from "@atlaskit/pragmatic-drag-and-drop/element/adapter";
 import { attachInstruction, extractInstruction } from "@atlaskit/pragmatic-drag-and-drop-hitbox/tree-item";
+import { useAtomValue } from "@effect-atom/atom-react";
 import * as Schema from "effect/Schema";
 import React7, { memo as memo3, useCallback as useCallback3, useEffect as useEffect3, useMemo, useRef as useRef2, useState as useState3 } from "react";
 import { invariant as invariant2 } from "@dxos/invariant";
 import { TreeItem as NaturalTreeItem, Treegrid } from "@dxos/react-ui";
-import { ghostFocusWithin, ghostHover, hoverableControls, hoverableFocusedKeyboardControls, hoverableFocusedWithinControls } from "@dxos/ui-theme";
+import { ghostFocusWithin, ghostHover, hoverableControls, hoverableFocusedKeyboardControls, hoverableFocusedWithinControls, mx as mx4 } from "@dxos/ui-theme";
 
 // src/components/Tree/helpers.ts
 var DEFAULT_INDENTATION = 8;
@@ -417,7 +424,7 @@ var TreeItemHeading = /* @__PURE__ */ memo(/* @__PURE__ */ forwardRef(({ label,
     variant: "ghost",
     density: "fine",
     classNames: [
-      "grow gap-2 pis-0.5 hover:bg-transparent dark:hover:bg-transparent",
+      "grow gap-2 ps-0.5 hover:bg-transparent dark:hover:bg-transparent",
       "disabled:cursor-default disabled:opacity-100",
       className
     ],
@@ -431,11 +438,11 @@ var TreeItemHeading = /* @__PURE__ */ memo(/* @__PURE__ */ forwardRef(({ label,
     icon: icon ?? "ph--placeholder--regular",
     size: 5,
     classNames: [
-      "mlb-1",
-      styles?.icon
+      "my-1",
+      styles?.surfaceText
     ]
   }), /* @__PURE__ */ React5.createElement("span", {
-    className: "flex-1 is-0 truncate text-start text-sm font-normal",
+    className: "flex-1 w-0 truncate text-start font-normal",
     "data-tooltip": true
   }, toLocalizedString(label, t))));
 }));
@@ -451,7 +458,7 @@ var TreeItemToggle = /* @__PURE__ */ memo2(/* @__PURE__ */ forwardRef2(({ open,
     variant: "ghost",
     density: "fine",
     classNames: [
-      "bs-full is-6 pli-0",
+      "h-full w-6 px-0",
       "[&_svg]:transition-[transform] [&_svg]:duration-200",
       open && "[&_svg]:rotate-90",
       hidden ? "hidden" : !isBranch && "invisible",
@@ -476,7 +483,7 @@ var TreeDataSchema = Schema.Struct({
   item: Schema.Any
 });
 var isTreeData = (data) => Schema.is(TreeDataSchema)(data);
-var RawTreeItem = ({ item, path: _path, levelOffset = 2, last, draggable: _draggable, renderColumns: Columns, blockInstruction, canDrop, canSelect, onOpenChange, onSelect }) => {
+var RawTreeItem = ({ item, path: pathProp, levelOffset = 2, last, draggable: draggableProp, renderColumns: Columns, blockInstruction, canDrop, canSelect, onOpenChange, onSelect, onItemHover }) => {
   const rowRef = useRef2(null);
   const buttonRef = useRef2(null);
   const openRef = useRef2(false);
@@ -484,18 +491,18 @@ var RawTreeItem = ({ item, path: _path, levelOffset = 2, last, draggable: _dragg
   const [_state, setState] = useState3("idle");
   const [instruction, setInstruction] = useState3(null);
   const [menuOpen, setMenuOpen] = useState3(false);
-  const { useItems, getProps, useIsOpen, useIsCurrent } = useTree();
-  const items = useItems(item);
-  const { id, parentOf, label, className, headingClassName, icon, iconHue, disabled, testId } = getProps(item, _path);
+  const { itemProps: itemPropsAtom, childIds: childIdsAtom, itemOpen: itemOpenAtom, itemCurrent: itemCurrentAtom } = useTree();
   const path = useMemo(() => [
-    ..._path,
-    id
+    ...pathProp,
+    item.id
   ], [
-    _path,
-    id
+    pathProp,
+    item.id
   ]);
-  const open = useIsOpen(path, item);
-  const current = useIsCurrent(path, item);
+  const { id, parentOf, draggable: itemDraggable, droppable: itemDroppable, label, className, headingClassName, icon, iconHue, disabled, testId } = useAtomValue(itemPropsAtom(path));
+  const childIds = useAtomValue(childIdsAtom(item.id));
+  const open = useAtomValue(itemOpenAtom(path));
+  const current = useAtomValue(itemCurrentAtom(path));
   const level = path.length - levelOffset;
   const isBranch = !!parentOf;
   const mode = last ? "last-in-group" : open ? "expanded" : "standard";
@@ -503,122 +510,130 @@ var RawTreeItem = ({ item, path: _path, levelOffset = 2, last, draggable: _dragg
     item,
     path
   }) ?? true;
+  const data = {
+    id,
+    path,
+    item
+  };
   const cancelExpand = useCallback3(() => {
     if (cancelExpandRef.current) {
       clearTimeout(cancelExpandRef.current);
       cancelExpandRef.current = null;
     }
   }, []);
+  const isItemDraggable = draggableProp && itemDraggable !== false;
+  const isItemDroppable = itemDroppable !== false;
   useEffect3(() => {
-    if (!_draggable) {
+    if (!draggableProp) {
       return;
     }
     invariant2(buttonRef.current, void 0, {
       F: __dxlog_file2,
-      L: 111,
+      L: 148,
       S: void 0,
       A: [
         "buttonRef.current",
         ""
       ]
     });
-    const data = {
-      id,
-      path,
-      item
-    };
-    return combine2(
-      draggable2({
-        element: buttonRef.current,
-        getInitialData: () => data,
-        onDragStart: () => {
-          setState("dragging");
-          if (open) {
-            openRef.current = true;
-            onOpenChange?.({
-              item,
-              path,
-              open: false
-            });
-          }
-        },
-        onDrop: () => {
-          setState("idle");
-          if (openRef.current) {
-            onOpenChange?.({
-              item,
-              path,
-              open: true
-            });
-          }
-        }
-      }),
-      // https://github.com/atlassian/pragmatic-drag-and-drop/blob/main/packages/hitbox/constellation/index/about.mdx
-      dropTargetForElements2({
-        element: buttonRef.current,
-        getData: ({ input, element }) => {
-          return attachInstruction(data, {
-            input,
-            element,
-            indentPerLevel: DEFAULT_INDENTATION,
-            currentLevel: level,
-            mode,
-            block: isBranch ? [] : [
-              "make-child"
-            ]
+    const makeDraggable = () => draggable2({
+      element: buttonRef.current,
+      getInitialData: () => data,
+      onDragStart: () => {
+        setState("dragging");
+        if (open) {
+          openRef.current = true;
+          onOpenChange?.({
+            item,
+            path,
+            open: false
           });
-        },
-        canDrop: ({ source }) => {
-          const _canDrop = canDrop ?? (() => true);
-          return source.element !== buttonRef.current && _canDrop({
-            source: source.data,
-            target: data
-          });
-        },
-        getIsSticky: () => true,
-        onDrag: ({ self, source }) => {
-          const desired = extractInstruction(self.data);
-          const block = desired && blockInstruction?.({
-            instruction: desired,
-            source: source.data,
-            target: data
+        }
+      },
+      onDrop: () => {
+        setState("idle");
+        if (openRef.current) {
+          onOpenChange?.({
+            item,
+            path,
+            open: true
           });
-          const instruction2 = block && desired.type !== "instruction-blocked" ? {
-            type: "instruction-blocked",
-            desired
-          } : desired;
-          if (source.data.id !== id) {
-            if (instruction2?.type === "make-child" && isBranch && !open && !cancelExpandRef.current) {
-              cancelExpandRef.current = setTimeout(() => {
-                onOpenChange?.({
-                  item,
-                  path,
-                  open: true
-                });
-              }, 500);
-            }
-            if (instruction2?.type !== "make-child") {
-              cancelExpand();
-            }
-            setInstruction(instruction2);
-          } else if (instruction2?.type === "reparent") {
-            setInstruction(instruction2);
-          } else {
-            setInstruction(null);
+        }
+      }
+    });
+    if (!isItemDroppable) {
+      return isItemDraggable ? makeDraggable() : void 0;
+    }
+    const dropTarget = dropTargetForElements2({
+      element: buttonRef.current,
+      getData: ({ input, element }) => {
+        return attachInstruction(data, {
+          input,
+          element,
+          indentPerLevel: DEFAULT_INDENTATION,
+          currentLevel: level,
+          mode,
+          block: isBranch ? [] : [
+            "make-child"
+          ]
+        });
+      },
+      canDrop: ({ source }) => {
+        const _canDrop = canDrop ?? (() => true);
+        return source.element !== buttonRef.current && _canDrop({
+          source: source.data,
+          target: data
+        });
+      },
+      getIsSticky: () => true,
+      onDrag: ({ self, source }) => {
+        const desired = extractInstruction(self.data);
+        const block = desired && blockInstruction?.({
+          instruction: desired,
+          source: source.data,
+          target: data
+        });
+        const instruction2 = block && desired.type !== "instruction-blocked" ? {
+          type: "instruction-blocked",
+          desired
+        } : desired;
+        if (source.data.id !== id) {
+          if (instruction2?.type === "make-child" && isBranch && !open && !cancelExpandRef.current) {
+            cancelExpandRef.current = setTimeout(() => {
+              onOpenChange?.({
+                item,
+                path,
+                open: true
+              });
+            }, 500);
           }
-        },
-        onDragLeave: () => {
-          cancelExpand();
-          setInstruction(null);
-        },
-        onDrop: () => {
-          cancelExpand();
+          if (instruction2?.type !== "make-child") {
+            cancelExpand();
+          }
+          setInstruction(instruction2);
+        } else if (instruction2?.type === "reparent") {
+          setInstruction(instruction2);
+        } else {
           setInstruction(null);
         }
-      })
-    );
+      },
+      onDragLeave: () => {
+        cancelExpand();
+        setInstruction(null);
+      },
+      onDrop: () => {
+        cancelExpand();
+        setInstruction(null);
+      }
+    });
+    if (!isItemDraggable) {
+      return dropTarget;
+    }
+    return combine2(makeDraggable(), dropTarget);
   }, [
-    _draggable,
+    draggableProp,
+    isItemDraggable,
+    isItemDroppable,
     item,
     id,
     mode,
@@ -678,33 +693,46 @@ var RawTreeItem = ({ item, path: _path, levelOffset = 2, last, draggable: _dragg
     handleOpenToggle,
     handleSelect
   ]);
+  const handleItemHover = useCallback3(() => {
+    onItemHover?.({
+      item
+    });
+  }, [
+    onItemHover,
+    item
+  ]);
+  const handleContextMenu = useCallback3((event) => {
+    event.preventDefault();
+    setMenuOpen(true);
+  }, [
+    setMenuOpen
+  ]);
+  const childProps = {
+    draggable: draggableProp,
+    renderColumns: Columns,
+    blockInstruction,
+    canDrop,
+    canSelect,
+    onItemHover,
+    onOpenChange,
+    onSelect
+  };
   return /* @__PURE__ */ React7.createElement(React7.Fragment, null, /* @__PURE__ */ React7.createElement(Treegrid.Row, {
     ref: rowRef,
     key: id,
     id,
     "aria-labelledby": `${id}__label`,
     parentOf: parentOf?.join(Treegrid.PARENT_OF_SEPARATOR),
-    classNames: [
-      "grid grid-cols-subgrid col-[tree-row] mbs-0.5 aria-[current]:bg-activeSurface",
-      hoverableControls,
-      hoverableFocusedKeyboardControls,
-      hoverableFocusedWithinControls,
-      hoverableDescriptionIcons,
-      ghostHover,
-      ghostFocusWithin,
-      className
-    ],
     "data-object-id": id,
     "data-testid": testId,
     // NOTE(thure): This is intentionally an empty string to for descendents to select by in the CSS
     //   without alerting the user (except for in the correct link element). See also:
     //   https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/Attributes/aria-current#description
     "aria-current": current ? "" : void 0,
+    classNames: mx4("grid grid-cols-subgrid col-[tree-row] mt-0.5 is-current:bg-active-surface", hoverableControls, hoverableFocusedKeyboardControls, hoverableFocusedWithinControls, hoverableDescriptionIcons, ghostFocusWithin, ghostHover, className),
     onKeyDown: handleKeyDown,
-    onContextMenu: (event) => {
-      event.preventDefault();
-      setMenuOpen(true);
-    }
+    onMouseEnter: handleItemHover,
+    onContextMenu: handleContextMenu
   }, /* @__PURE__ */ React7.createElement("div", {
     role: "none",
     className: "indent relative grid grid-cols-subgrid col-[tree-row]",
@@ -733,36 +761,31 @@ var RawTreeItem = ({ item, path: _path, levelOffset = 2, last, draggable: _dragg
   }), instruction && /* @__PURE__ */ React7.createElement(NaturalTreeItem.DropIndicator, {
     instruction,
     gap: 2
-  }))), open && items.map((item2, index) => /* @__PURE__ */ React7.createElement(TreeItem, {
-    key: item2.id,
-    item: item2,
+  }))), open && childIds.map((childId, index) => /* @__PURE__ */ React7.createElement(TreeItemById, {
+    key: childId,
+    id: childId,
     path,
-    last: index === items.length - 1,
-    draggable: _draggable,
-    renderColumns: Columns,
-    blockInstruction,
-    canDrop,
-    canSelect,
-    onOpenChange,
-    onSelect
+    last: index === childIds.length - 1,
+    ...childProps
   })));
 };
 var TreeItem = /* @__PURE__ */ memo3(RawTreeItem);
+var RawTreeItemById = ({ id, ...props }) => {
+  const { item: itemAtom } = useTree();
+  const item = useAtomValue(itemAtom(id));
+  if (!item) {
+    return null;
+  }
+  return /* @__PURE__ */ React7.createElement(TreeItem, {
+    item,
+    ...props
+  });
+};
+var TreeItemById = /* @__PURE__ */ memo3(RawTreeItemById);
 
 // src/components/Tree/Tree.tsx
-var Tree = ({ root, path, id, useItems, getProps, useIsOpen, useIsCurrent, draggable: draggable3 = false, gridTemplateColumns = "[tree-row-start] 1fr min-content [tree-row-end]", classNames, levelOffset, renderColumns, blockInstruction, canDrop, canSelect, onOpenChange, onSelect }) => {
-  const context = useMemo2(() => ({
-    useItems,
-    getProps,
-    useIsOpen,
-    useIsCurrent
-  }), [
-    useItems,
-    getProps,
-    useIsOpen,
-    useIsCurrent
-  ]);
-  const items = useItems(root);
+var Tree = ({ model, rootId, path, id, draggable: draggable3 = false, gridTemplateColumns = "[tree-row-start] 1fr min-content [tree-row-end]", classNames, levelOffset, renderColumns, blockInstruction, canDrop, canSelect, onOpenChange, onSelect, onItemHover }) => {
+  const childIds = useAtomValue2(model.childIds(rootId));
   const treePath = useMemo2(() => path ? [
     ...path,
     id
@@ -772,15 +795,7 @@ var Tree = ({ root, path, id, useItems, getProps, useIsOpen, useIsCurrent, dragg
     id,
     path
   ]);
-  return /* @__PURE__ */ React8.createElement(Treegrid2.Root, {
-    gridTemplateColumns,
-    classNames
-  }, /* @__PURE__ */ React8.createElement(TreeProvider, {
-    value: context
-  }, items.map((item, index) => /* @__PURE__ */ React8.createElement(TreeItem, {
-    key: item.id,
-    item,
-    last: index === items.length - 1,
+  const childProps = {
     path: treePath,
     levelOffset,
     draggable: draggable3,
@@ -789,7 +804,19 @@ var Tree = ({ root, path, id, useItems, getProps, useIsOpen, useIsCurrent, dragg
     canDrop,
     canSelect,
     onOpenChange,
-    onSelect
+    onSelect,
+    onItemHover
+  };
+  return /* @__PURE__ */ React8.createElement(Treegrid2.Root, {
+    gridTemplateColumns,
+    classNames
+  }, /* @__PURE__ */ React8.createElement(TreeProvider, {
+    value: model
+  }, childIds.map((childId, index) => /* @__PURE__ */ React8.createElement(TreeItemById, {
+    key: childId,
+    id: childId,
+    last: index === childIds.length - 1,
+    ...childProps
   }))));
 };
 
@@ -810,13 +837,17 @@ var Path = {
 };
 export {
   Accordion,
+  DEFAULT_INDENTATION,
   List,
   Path,
   Tree,
   TreeDataSchema,
   TreeItem,
+  TreeItemById,
+  TreeItemToggle,
   TreeProvider,
   isTreeData,
+  paddingIndentation,
   useTree
 };
 //# sourceMappingURL=index.mjs.map