@dxos/react-ui-list 0.8.4-main.84f28bd → 0.8.4-main.937b3ca

package/src/components/Tree/Tree.stories.tsx

@@ -2,115 +2,132 @@
 // Copyright 2024 DXOS.org
 //
 
-import '@dxos-theme';
-
 import { monitorForElements } from '@atlaskit/pragmatic-drag-and-drop/element/adapter';
-import { extractInstruction, type Instruction } from '@atlaskit/pragmatic-drag-and-drop-hitbox/tree-item';
+import { type Instruction, extractInstruction } from '@atlaskit/pragmatic-drag-and-drop-hitbox/tree-item';
+import { Atom, RegistryContext, useAtomValue } from '@effect-atom/atom-react';
 import { type Meta, type StoryObj } from '@storybook/react-vite';
-import React, { useEffect } from 'react';
+import React, { useCallback, useContext, useEffect, useMemo, useRef } from 'react';
 
-import { live, type Live } from '@dxos/live-object';
 import { faker } from '@dxos/random';
 import { Icon } from '@dxos/react-ui';
-import { withLayout, withTheme } from '@dxos/storybook-utils';
+import { withTheme } from '@dxos/react-ui/testing';
+import { withRegistry } from '@dxos/storybook-utils';
+
+import { Path } from '../../util';
 
+import { type TestItem, createTree, updateState } from './testing';
 import { Tree } from './Tree';
 import { type TreeData } from './TreeItem';
-import { createTree, updateState, type TestItem } from './testing';
-import { Path } from '../../util';
 
 faker.seed(1234);
 
-const tree = live<TestItem>(createTree());
-const state = new Map<string, Live<{ open: boolean; current: boolean }>>();
+const tree = createTree() as TestItem;
 
-const meta: Meta<typeof Tree<TestItem>> = {
-  title: 'ui/react-ui-list/Tree',
-  component: Tree,
-  decorators: [withTheme, withLayout()],
-  render: (args) => {
-    useEffect(() => {
-      return monitorForElements({
-        canMonitor: ({ source }) => typeof source.data.id === 'string' && Array.isArray(source.data.path),
-        onDrop: ({ location, source }) => {
-          // Didn't drop on anything.
-          if (!location.current.dropTargets.length) {
-            return;
-          }
-
-          const target = location.current.dropTargets[0];
-
-          const instruction: Instruction | null = extractInstruction(target.data);
-          if (instruction !== null) {
-            updateState({
-              state: tree,
-              instruction,
-              source: source.data as TreeData,
-              target: target.data as TreeData,
-            });
-          }
-        },
-      });
-    }, []);
-
-    return <Tree {...args} />;
-  },
-  args: {
-    id: tree.id,
-    useItems: (testItem?: TestItem) => {
-      return testItem?.items ?? tree.items;
-    },
-    getProps: (testItem: TestItem) => ({
-      id: testItem.id,
-      label: testItem.name,
-      icon: testItem.icon,
-      ...((testItem.items?.length ?? 0) > 0 && {
-        parentOf: testItem.items!.map(({ id }) => id),
-      }),
-    }),
-    isOpen: (_path: string[]) => {
-      const path = Path.create(..._path);
-      const object = state.get(path) ?? live({ open: false, current: false });
-      if (!state.has(path)) {
-        state.set(path, object);
-      }
+const DefaultStory = ({ draggable }: { draggable?: boolean }) => {
+  const registry = useContext(RegistryContext);
+  const stateAtomsRef = useRef(new Map<string, Atom.Writable<{ open: boolean; current: boolean }>>());
+
+  const getOrCreateStateAtom = useCallback((path: string) => {
+    let atom = stateAtomsRef.current.get(path);
+    if (!atom) {
+      atom = Atom.make({ open: false, current: false }).pipe(Atom.keepAlive);
+      stateAtomsRef.current.set(path, atom);
+    }
+    return atom;
+  }, []);
 
-      return object.open;
+  const useItemState = useCallback(
+    (_path: string[]) => {
+      const path = useMemo(() => Path.create(..._path), [_path.join('~')]);
+      const atom = getOrCreateStateAtom(path);
+      return useAtomValue(atom);
     },
-    isCurrent: (_path: string[]) => {
+    [getOrCreateStateAtom],
+  );
+
+  const handleOpenChange = useCallback(
+    ({ path: _path, open }: { path: string[]; open: boolean }) => {
       const path = Path.create(..._path);
-      const object = state.get(path) ?? live({ open: false, current: false });
-      if (!state.has(path)) {
-        state.set(path, object);
-      }
+      const atom = getOrCreateStateAtom(path);
+      const prev = registry.get(atom);
+      registry.set(atom, { ...prev, open });
+    },
+    [getOrCreateStateAtom, registry],
+  );
 
-      return object.current;
+  const handleSelect = useCallback(
+    ({ path: _path, current }: { path: string[]; current: boolean }) => {
+      const path = Path.create(..._path);
+      const atom = getOrCreateStateAtom(path);
+      const prev = registry.get(atom);
+      registry.set(atom, { ...prev, current });
     },
-    renderColumns: () => {
-      return (
+    [getOrCreateStateAtom, registry],
+  );
+
+  useEffect(() => {
+    return monitorForElements({
+      canMonitor: ({ source }) => typeof source.data.id === 'string' && Array.isArray(source.data.path),
+      onDrop: ({ location, source }) => {
+        if (!location.current.dropTargets.length) {
+          return;
+        }
+
+        const target = location.current.dropTargets[0];
+        const instruction: Instruction | null = extractInstruction(target.data);
+        if (instruction !== null) {
+          updateState({
+            state: tree,
+            instruction,
+            source: source.data as TreeData,
+            target: target.data as TreeData,
+          });
+        }
+      },
+    });
+  }, []);
+
+  return (
+    <Tree
+      id={tree.id}
+      draggable={draggable}
+      useItems={(parent?: TestItem) => parent?.items ?? tree.items}
+      getProps={(parent: TestItem) => ({
+        id: parent.id,
+        label: parent.name,
+        icon: parent.icon,
+        ...((parent.items?.length ?? 0) > 0 && {
+          parentOf: parent.items!.map(({ id }) => id),
+        }),
+      })}
+      useIsOpen={(_path: string[]) => useItemState(_path).open}
+      useIsCurrent={(_path: string[]) => useItemState(_path).current}
+      renderColumns={() => (
         <div className='flex items-center'>
           <Icon icon='ph--placeholder--regular' size={5} />
         </div>
-      );
-    },
-    onOpenChange: ({ path: _path, open }) => {
-      const path = Path.create(..._path);
-      const object = state.get(path);
-      object!.open = open;
-    },
-    onSelect: ({ path: _path, current }) => {
-      const path = Path.create(..._path);
-      const object = state.get(path);
-      object!.current = current;
-    },
-  },
+      )}
+      onOpenChange={handleOpenChange}
+      onSelect={handleSelect}
+    />
+  );
 };
 
+const meta = {
+  title: 'ui/react-ui-list/Tree',
+
+  decorators: [withTheme, withRegistry],
+  component: Tree,
+  render: DefaultStory,
+} satisfies Meta<typeof Tree<TestItem>>;
+
 export default meta;
 
-export const Default = {};
+type Story = StoryObj<typeof DefaultStory>;
+
+export const Default: Story = {};
 
-export const Draggable: StoryObj<typeof Tree> = {
+export const Draggable: Story = {
   args: {
     draggable: true,
   },

package/src/components/Tree/Tree.tsx

@@ -4,34 +4,45 @@
 
 import React, { useMemo } from 'react';
 
-import { type HasId } from '@dxos/echo-schema';
 import { Treegrid, type TreegridRootProps } from '@dxos/react-ui';
 
 import { type TreeContextType, TreeProvider } from './TreeContext';
 import { TreeItem, type TreeItemProps } from './TreeItem';
 
-export type TreeProps<T extends HasId = any, O = any> = {
+export type TreeProps<T extends { id: string } = any, O = any> = {
   root?: T;
   path?: string[];
   id: string;
 } & TreeContextType<T, O> &
   Partial<Pick<TreegridRootProps, 'gridTemplateColumns' | 'classNames'>> &
-  Pick<TreeItemProps<T>, 'draggable' | 'renderColumns' | 'canDrop' | 'onOpenChange' | 'onSelect' | 'levelOffset'>;
+  Pick<
+    TreeItemProps<T>,
+    | 'draggable'
+    | 'renderColumns'
+    | 'blockInstruction'
+    | 'canDrop'
+    | 'canSelect'
+    | 'onOpenChange'
+    | 'onSelect'
+    | 'levelOffset'
+  >;
 
-export const Tree = <T extends HasId = any, O = any>({
+export const Tree = <T extends { id: string } = any, O = any>({
   root,
   path,
   id,
   useItems,
   getProps,
-  isOpen,
-  isCurrent,
+  useIsOpen,
+  useIsCurrent,
   draggable = false,
   gridTemplateColumns = '[tree-row-start] 1fr min-content [tree-row-end]',
   classNames,
   levelOffset,
   renderColumns,
+  blockInstruction,
   canDrop,
+  canSelect,
   onOpenChange,
   onSelect,
 }: TreeProps<T, O>) => {
@@ -39,10 +50,10 @@ export const Tree = <T extends HasId = any, O = any>({
     () => ({
       useItems,
       getProps,
-      isOpen,
-      isCurrent,
+      useIsOpen,
+      useIsCurrent,
     }),
-    [useItems, getProps, isOpen, isCurrent],
+    [useItems, getProps, useIsOpen, useIsCurrent],
   );
   const items = useItems(root);
   const treePath = useMemo(() => (path ? [...path, id] : [id]), [id, path]);
@@ -59,7 +70,9 @@ export const Tree = <T extends HasId = any, O = any>({
             levelOffset={levelOffset}
             draggable={draggable}
             renderColumns={renderColumns}
+            blockInstruction={blockInstruction}
             canDrop={canDrop}
+            canSelect={canSelect}
             onOpenChange={onOpenChange}
             onSelect={onSelect}
           />

package/src/components/Tree/TreeContext.tsx

@@ -11,18 +11,21 @@ export type TreeItemDataProps = {
   id: string;
   label: Label;
   parentOf?: string[];
-  icon?: string;
-  disabled?: boolean;
   className?: string;
   headingClassName?: string;
+  icon?: string;
+  iconHue?: string;
+  disabled?: boolean;
   testId?: string;
 };
 
 export type TreeContextType<T = any, O = any> = {
   useItems: (parent?: T, options?: O) => T[];
   getProps: (item: T, parent: string[]) => TreeItemDataProps;
-  isOpen: (path: string[], item: T) => boolean;
-  isCurrent: (path: string[], item: T) => boolean;
+  /** Hook that subscribes to and returns the open state for a tree item. */
+  useIsOpen: (path: string[], item: T) => boolean;
+  /** Hook that subscribes to and returns the current state for a tree item. */
+  useIsCurrent: (path: string[], item: T) => boolean;
 };
 
 const TreeContext = createContext<null | TreeContextType>(null);

package/src/components/Tree/TreeItem.tsx

@@ -5,35 +5,34 @@
 import { combine } from '@atlaskit/pragmatic-drag-and-drop/combine';
 import { draggable, dropTargetForElements } from '@atlaskit/pragmatic-drag-and-drop/element/adapter';
 import {
-  attachInstruction,
-  extractInstruction,
   type Instruction,
   type ItemMode,
+  attachInstruction,
+  extractInstruction,
 } from '@atlaskit/pragmatic-drag-and-drop-hitbox/tree-item';
-import { Schema } from 'effect';
-import React, { memo, useCallback, useEffect, useMemo, useRef, useState, type FC, type KeyboardEvent } from 'react';
+import * as Schema from 'effect/Schema';
+import React, { type FC, type KeyboardEvent, memo, useCallback, useEffect, useMemo, useRef, useState } from 'react';
 
-import { type HasId } from '@dxos/echo-schema';
 import { invariant } from '@dxos/invariant';
-import { Treegrid, TreeItem as NaturalTreeItem } from '@dxos/react-ui';
+import { TreeItem as NaturalTreeItem, Treegrid } from '@dxos/react-ui';
 import {
+  ghostFocusWithin,
   ghostHover,
   hoverableControls,
   hoverableFocusedKeyboardControls,
   hoverableFocusedWithinControls,
-  mx,
-} from '@dxos/react-ui-theme';
+} from '@dxos/ui-theme';
 
+import { DEFAULT_INDENTATION, paddingIndentation } from './helpers';
 import { useTree } from './TreeContext';
 import { TreeItemHeading } from './TreeItemHeading';
 import { TreeItemToggle } from './TreeItemToggle';
-import { DEFAULT_INDENTATION, paddingIndentation } from './helpers';
-
-type TreeItemState = 'idle' | 'dragging' | 'preview' | 'parent-of-instruction';
 
 const hoverableDescriptionIcons =
   '[--icons-color:inherit] hover-hover:[--icons-color:var(--description-text)] hover-hover:hover:[--icons-color:inherit] focus-within:[--icons-color:inherit]';
 
+type TreeItemState = 'idle' | 'dragging' | 'preview' | 'parent-of-instruction';
+
 export const TreeDataSchema = Schema.Struct({
   id: Schema.String,
   path: Schema.Array(Schema.String),
@@ -41,37 +40,42 @@ export const TreeDataSchema = Schema.Struct({
 });
 
 export type TreeData = Schema.Schema.Type<typeof TreeDataSchema>;
-
 export const isTreeData = (data: unknown): data is TreeData => Schema.is(TreeDataSchema)(data);
 
-export type TreeItemProps<T extends HasId = any> = {
+export type ColumnRenderer<T extends { id: string } = any> = FC<{
+  item: T;
+  path: string[];
+  open: boolean;
+  menuOpen: boolean;
+  setMenuOpen: (open: boolean) => void;
+}>;
+
+export type TreeItemProps<T extends { id: string } = any> = {
   item: T;
   path: string[];
   levelOffset?: number;
   last: boolean;
   draggable?: boolean;
-  renderColumns?: FC<{
-    item: T;
-    path: string[];
-    open: boolean;
-    menuOpen: boolean;
-    setMenuOpen: (open: boolean) => void;
-  }>;
+  renderColumns?: ColumnRenderer<T>;
+  blockInstruction?: (params: { instruction: Instruction; source: TreeData; target: TreeData }) => boolean;
   canDrop?: (params: { source: TreeData; target: TreeData }) => boolean;
+  canSelect?: (params: { item: T; path: string[] }) => boolean;
   onOpenChange?: (params: { item: T; path: string[]; open: boolean }) => void;
   onSelect?: (params: { item: T; path: string[]; current: boolean; option: boolean }) => void;
 };
 
-const RawTreeItem = <T extends HasId = any>({
+const RawTreeItem = <T extends { id: string } = any>({
   item,
   path: _path,
+  levelOffset = 2,
   last,
   draggable: _draggable,
   renderColumns: Columns,
+  blockInstruction,
   canDrop,
+  canSelect,
   onOpenChange,
   onSelect,
-  levelOffset = 2,
 }: TreeItemProps<T>) => {
   const rowRef = useRef<HTMLDivElement | null>(null);
   const buttonRef = useRef<HTMLButtonElement | null>(null);
@@ -81,15 +85,16 @@ const RawTreeItem = <T extends HasId = any>({
   const [instruction, setInstruction] = useState<Instruction | null>(null);
   const [menuOpen, setMenuOpen] = useState(false);
 
-  const { useItems, getProps, isOpen, isCurrent } = useTree();
+  const { useItems, getProps, useIsOpen, useIsCurrent } = useTree();
   const items = useItems(item);
-  const { id, label, parentOf, icon, disabled, className, headingClassName, testId } = getProps(item, _path);
+  const { id, parentOf, label, className, headingClassName, icon, iconHue, disabled, testId } = getProps(item, _path);
   const path = useMemo(() => [..._path, id], [_path, id]);
-  const open = isOpen(path, item);
-  const current = isCurrent(path, item);
+  const open = useIsOpen(path, item);
+  const current = useIsCurrent(path, item);
   const level = path.length - levelOffset;
   const isBranch = !!parentOf;
   const mode: ItemMode = last ? 'last-in-group' : open ? 'expanded' : 'standard';
+  const canSelectItem = canSelect?.({ item, path }) ?? true;
 
   const cancelExpand = useCallback(() => {
     if (cancelExpandRef.current) {
@@ -145,7 +150,11 @@ const RawTreeItem = <T extends HasId = any>({
         },
         getIsSticky: () => true,
         onDrag: ({ self, source }) => {
-          const instruction = extractInstruction(self.data);
+          const desired = extractInstruction(self.data);
+          const block =
+            desired && blockInstruction?.({ instruction: desired, source: source.data as TreeData, target: data });
+          const instruction: Instruction | null =
+            block && desired.type !== 'instruction-blocked' ? { type: 'instruction-blocked', desired } : desired;
 
           if (source.data.id !== id) {
             if (instruction?.type === 'make-child' && isBranch && !open && !cancelExpandRef.current) {
@@ -176,43 +185,42 @@ const RawTreeItem = <T extends HasId = any>({
         },
       }),
     );
-  }, [_draggable, item, id, mode, path, open, canDrop]);
+  }, [_draggable, item, id, mode, path, open, blockInstruction, canDrop]);
 
   // Cancel expand on unmount.
   useEffect(() => () => cancelExpand(), [cancelExpand]);
 
-  const handleOpenChange = useCallback(
+  const handleOpenToggle = useCallback(
     () => onOpenChange?.({ item, path, open: !open }),
     [onOpenChange, item, path, open],
   );
 
   const handleSelect = useCallback(
     (option = false) => {
-      if (isBranch) {
-        handleOpenChange();
-      } else {
+      // If the item is a branch, toggle it if:
+      //   - also holding down the option key
+      //   - or the item is currently selected
+      if (isBranch && (option || current)) {
+        handleOpenToggle();
+      } else if (canSelectItem) {
+        canSelect?.({ item, path });
         rowRef.current?.focus();
         onSelect?.({ item, path, current: !current, option });
       }
     },
-    [item, path, current, isBranch, handleOpenChange, onSelect],
+    [item, path, current, isBranch, canSelectItem, handleOpenToggle, onSelect],
   );
 
   const handleKeyDown = useCallback(
     (event: KeyboardEvent) => {
       switch (event.key) {
         case 'ArrowRight':
-          isBranch && !open && handleOpenChange();
-          break;
         case 'ArrowLeft':
-          isBranch && open && handleOpenChange();
-          break;
-        case ' ':
-          handleSelect(event.altKey);
+          isBranch && handleOpenToggle();
           break;
       }
     },
-    [isBranch, open, handleOpenChange, handleSelect],
+    [isBranch, open, handleOpenToggle, handleSelect],
   );
 
   return (
@@ -223,16 +231,17 @@ const RawTreeItem = <T extends HasId = any>({
         id={id}
         aria-labelledby={`${id}__label`}
         parentOf={parentOf?.join(Treegrid.PARENT_OF_SEPARATOR)}
-        classNames={mx(
+        classNames={[
           'grid grid-cols-subgrid col-[tree-row] mbs-0.5 aria-[current]:bg-activeSurface',
           hoverableControls,
           hoverableFocusedKeyboardControls,
           hoverableFocusedWithinControls,
           hoverableDescriptionIcons,
           ghostHover,
+          ghostFocusWithin,
           className,
-        )}
-        data-itemid={id}
+        ]}
+        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:
@@ -244,26 +253,27 @@ const RawTreeItem = <T extends HasId = any>({
           setMenuOpen(true);
         }}
       >
-        <Treegrid.Cell
-          indent
-          classNames='relative grid grid-cols-subgrid col-[tree-row]'
+        <div
+          role='none'
+          className='indent relative grid grid-cols-subgrid col-[tree-row]'
           style={paddingIndentation(level)}
         >
-          <div role='none' className='flex items-center'>
-            <TreeItemToggle isBranch={isBranch} open={open} onToggle={handleOpenChange} />
+          <Treegrid.Cell classNames='flex items-center'>
+            <TreeItemToggle isBranch={isBranch} open={open} onClick={handleOpenToggle} />
             <TreeItemHeading
-              ref={buttonRef}
-              label={label}
-              icon={icon}
-              className={headingClassName}
               disabled={disabled}
               current={current}
+              label={label}
+              className={headingClassName}
+              icon={icon}
+              iconHue={iconHue}
               onSelect={handleSelect}
+              ref={buttonRef}
             />
-          </div>
+          </Treegrid.Cell>
           {Columns && <Columns item={item} path={path} open={open} menuOpen={menuOpen} setMenuOpen={setMenuOpen} />}
           {instruction && <NaturalTreeItem.DropIndicator instruction={instruction} gap={2} />}
-        </Treegrid.Cell>
+        </div>
       </Treegrid.Row>
       {open &&
         items.map((item, index) => (
@@ -274,7 +284,9 @@ const RawTreeItem = <T extends HasId = any>({
             last={index === items.length - 1}
             draggable={_draggable}
             renderColumns={Columns}
+            blockInstruction={blockInstruction}
             canDrop={canDrop}
+            canSelect={canSelect}
             onOpenChange={onOpenChange}
             onSelect={onSelect}
           />

package/src/components/Tree/TreeItemHeading.tsx

@@ -4,25 +4,27 @@
 
 import React, { type KeyboardEvent, type MouseEvent, forwardRef, memo, useCallback } from 'react';
 
-import { Button, Icon, toLocalizedString, useTranslation, type Label } from '@dxos/react-ui';
+import { Button, Icon, type Label, toLocalizedString, useTranslation } from '@dxos/react-ui';
 import { TextTooltip } from '@dxos/react-ui-text-tooltip';
-import { mx } from '@dxos/react-ui-theme';
+import { getStyles } from '@dxos/ui-theme';
 
 // TODO(wittjosiah): Consider whether there should be a separate disabled prop which was visually distinct
 //   rather than just making the item unselectable.
-export type NavTreeItemHeadingProps = {
+export type TreeItemHeadingProps = {
   label: Label;
-  icon?: string;
   className?: string;
+  icon?: string;
+  iconHue?: string;
   disabled?: boolean;
   current?: boolean;
   onSelect?: (option: boolean) => void;
 };
 
 export const TreeItemHeading = memo(
-  forwardRef<HTMLButtonElement, NavTreeItemHeadingProps>(
-    ({ label, icon, className, disabled, current, onSelect }, forwardedRef) => {
+  forwardRef<HTMLButtonElement, TreeItemHeadingProps>(
+    ({ label, className, icon, iconHue, disabled, current, onSelect }, forwardedRef) => {
       const { t } = useTranslation();
+      const styles = iconHue ? getStyles(iconHue) : undefined;
 
       const handleSelect = useCallback(
         (event: MouseEvent) => {
@@ -55,17 +57,17 @@ export const TreeItemHeading = memo(
             data-testid='treeItem.heading'
             variant='ghost'
             density='fine'
-            classNames={mx(
+            classNames={[
               'grow gap-2 pis-0.5 hover:bg-transparent dark:hover:bg-transparent',
               'disabled:cursor-default disabled:opacity-100',
               className,
-            )}
+            ]}
             disabled={disabled}
             onClick={handleSelect}
             onKeyDown={handleButtonKeydown}
             {...(current && { 'aria-current': 'location' })}
           >
-            {icon && <Icon icon={icon ?? 'ph--placeholder--regular'} size={5} classNames='mlb-1' />}
+            {icon && <Icon icon={icon ?? 'ph--placeholder--regular'} size={5} classNames={['mlb-1', styles?.icon]} />}
             <span className='flex-1 is-0 truncate text-start text-sm font-normal' data-tooltip>
               {toLocalizedString(label, t)}
             </span>