@dxos/react-ui-attention 0.8.2-staging.7ac8446 → 0.8.2

package/src/components/SelectionProvider.tsx

@@ -3,11 +3,12 @@
 //
 
 import { createContext } from '@radix-ui/react-context';
+import { Match } from 'effect';
 import React, { useCallback, useMemo, type PropsWithChildren } from 'react';
 
 import { useDefaultValue } from '@dxos/react-ui';
 
-import { SelectionManager } from '../selection';
+import { defaultSelection, SelectionManager, type Selection, type SelectionMode } from '../selection';
 
 const SELECTION_NAME = 'Selection';
 
@@ -22,7 +23,6 @@ const [SelectionContextProvider, useSelectionContext] = createContext<SelectionC
 /**
  * Manages selection state across the app for multiple contexts.
  */
-// TODO(burdon): Review/remove this.
 // TODO(burdon): When is the selection removed?
 export const SelectionProvider = ({
   children,
@@ -32,25 +32,61 @@ export const SelectionProvider = ({
   return <SelectionContextProvider selection={selection}>{children}</SelectionContextProvider>;
 };
 
-const emptySet = new Set<string>();
-
-// TODO(burdon): Return array?
-export const useSelectedItems = (contextId?: string): Set<string> => {
+export const useSelected = <T extends SelectionMode>(
+  contextId?: string,
+  mode: T = 'multi' as T,
+): T extends 'single'
+  ? string | undefined
+  : T extends 'multi'
+    ? string[]
+    : T extends 'range'
+      ? { from: string; to: string } | undefined
+      : T extends 'multi-range'
+        ? { from: string; to: string }[]
+        : never => {
   const { selection } = useSelectionContext(SELECTION_NAME);
-  return contextId ? selection.getSelection(contextId) : emptySet;
+  if (contextId) {
+    return selection.getSelected(contextId, mode);
+  }
+
+  return Match.type<Selection>().pipe(
+    Match.when({ mode: 'single' }, (s) => s.id),
+    Match.when({ mode: 'multi' }, (s) => s.ids),
+    Match.when({ mode: 'range' }, (s) => (s.from && s.to ? { from: s.from, to: s.to } : undefined)),
+    Match.when({ mode: 'multi-range' }, (s) => s.ranges),
+    Match.exhaustive,
+  )(defaultSelection(mode)) as any;
 };
 
 /**
  * Provides functions to manage the selection state for multiple contexts.
  */
-export const useSelectionActions = (contextIds: string[]) => {
-  const stableContextIds = useMemo(() => contextIds, [JSON.stringify(contextIds)]);
+export const useSelectionActions = (contextIds: string[], mode: SelectionMode = 'multi') => {
+  const stableContextIds = useMemo(() => contextIds, [JSON.stringify(contextIds)]); // TODO(burdon): Avoid stringify.
   const { selection } = useSelectionContext(SELECTION_NAME);
 
-  const select = useCallback(
+  const singleSelect = useCallback(
+    (id: string) => {
+      for (const contextId of stableContextIds) {
+        selection.updateSingle(contextId, id);
+      }
+    },
+    [selection, stableContextIds],
+  );
+
+  const multiSelect = useCallback(
     (ids: string[]) => {
       for (const contextId of stableContextIds) {
-        selection.updateSelection(contextId, ids);
+        selection.updateMulti(contextId, ids);
+      }
+    },
+    [selection, stableContextIds],
+  );
+
+  const rangeSelect = useCallback(
+    (from: string, to: string) => {
+      for (const contextId of stableContextIds) {
+        selection.updateRange(contextId, from, to);
       }
     },
     [selection, stableContextIds],
@@ -71,5 +107,5 @@ export const useSelectionActions = (contextIds: string[]) => {
     }
   }, [selection, stableContextIds]);
 
-  return { select, toggle, clear };
+  return { singleSelect, multiSelect, rangeSelect, toggle, clear };
 };

package/src/selection.ts

@@ -3,18 +3,35 @@
 //
 
 import { untracked } from '@preact/signals-core';
+import { Match } from 'effect';
 
-import { create, type ReactiveObject } from '@dxos/live-object';
+import { invariant } from '@dxos/invariant';
+import { live, type Live } from '@dxos/live-object';
+
+export type SelectionMode = 'single' | 'multi' | 'range' | 'multi-range';
+
+export type Selection =
+  | { mode: 'single'; id?: string }
+  | { mode: 'multi'; ids: string[] }
+  | { mode: 'range'; from?: string; to?: string }
+  | { mode: 'multi-range'; ranges: { from: string; to: string }[] };
+
+export const defaultSelection = Match.type<SelectionMode>().pipe(
+  Match.when('single', () => ({ mode: 'single' }) as Selection),
+  Match.when('multi', () => ({ mode: 'multi', ids: [] }) as Selection),
+  Match.when('range', () => ({ mode: 'range' }) as Selection),
+  Match.when('multi-range', () => ({ mode: 'multi-range', ranges: [] }) as Selection),
+  Match.exhaustive,
+);
 
 /**
  * Manages selection state for different contexts.
- * Each context maintains its own list of selected IDs.
+ * Each context maintains its own selection mode and state.
  */
-// TODO(burdon): Review/remove this abstraction. Selection should be managed by specific components.
 export class SelectionManager {
-  private readonly _state = create<{ selections: Record<string, Set<string>> }>({ selections: {} });
+  private readonly _state = live<{ selections: Record<string, Selection> }>({ selections: {} });
 
-  constructor(initial: Record<string, Set<string>> = {}) {
+  constructor(initial: Record<string, Selection> = {}) {
     if (Object.keys(initial).length > 0) {
       untracked(() => {
         this._state.selections = initial;
@@ -22,38 +39,96 @@ export class SelectionManager {
     }
   }
 
-  get selections(): ReactiveObject<Record<string, Set<string>>> {
-    return this._state.selections;
+  getSelection<T extends SelectionMode | undefined>(
+    contextId: string,
+    mode: T = undefined as T,
+  ): T extends undefined ? Live<Selection> | undefined : Live<Selection> {
+    const selection = untracked(() => this._state.selections[contextId]);
+    if (!mode || selection) {
+      return selection;
+    }
+
+    return untracked(() => {
+      this._state.selections[contextId] = defaultSelection(mode);
+      return this._state.selections[contextId];
+    });
   }
 
-  getSelection(contextId: string): Set<string> {
-    if (!this.selections[contextId]) {
-      untracked(() => {
-        this._state.selections[contextId] = new Set();
-      });
-    }
-    return this.selections[contextId];
+  getSelected<T extends SelectionMode>(
+    contextId: string,
+    mode: T = 'multi' as T,
+  ): T extends 'single'
+    ? string | undefined
+    : T extends 'multi'
+      ? string[]
+      : T extends 'range'
+        ? { from: string; to: string } | undefined
+        : T extends 'multi-range'
+          ? { from: string; to: string }[]
+          : never {
+    const selection = this.getSelection(contextId, mode);
+    invariant(selection?.mode === mode, 'Selection mode mismatch');
+    return Match.type<Selection>().pipe(
+      Match.when({ mode: 'single' }, (s) => s.id),
+      Match.when({ mode: 'multi' }, (s) => s.ids),
+      Match.when({ mode: 'range' }, (s) => (s.from && s.to ? { from: s.from, to: s.to } : undefined)),
+      Match.when({ mode: 'multi-range' }, (s) => s.ranges),
+      Match.exhaustive,
+    )(selection) as any;
   }
 
-  updateSelection(contextId: string, selectedIds: Set<string> | string[]) {
+  updateSingle(contextId: string, id: string): void {
     untracked(() => {
-      this._state.selections[contextId] = selectedIds instanceof Set ? selectedIds : new Set(selectedIds);
+      const selection = this.getSelection(contextId, 'single');
+      invariant(selection?.mode === 'single', 'Selection mode is not single');
+      selection.id = id;
     });
   }
 
-  clearSelection(contextId: string) {
+  updateMulti(contextId: string, ids: string[]) {
     untracked(() => {
-      this._state.selections[contextId] = new Set();
+      const selection = this.getSelection(contextId, 'multi');
+      invariant(selection?.mode === 'multi', 'Selection mode is not multi');
+      selection.ids = ids;
     });
   }
 
-  toggleSelection(contextId: string, id: string) {
+  updateRange(contextId: string, from: string, to: string) {
     untracked(() => {
-      const current = this.getSelection(contextId);
-      if (current.has(id)) {
-        current.delete(id);
+      const selection = this.getSelection(contextId, 'range');
+      invariant(selection?.mode === 'range', 'Selection mode is not range');
+      selection.from = from;
+      selection.to = to;
+    });
+  }
+
+  updateMultiRange(contextId: string, ranges: { from: string; to: string }[]) {
+    untracked(() => {
+      const selection = this.getSelection(contextId, 'multi-range');
+      invariant(selection?.mode === 'multi-range', 'Selection mode is not multi-range');
+      selection.ranges = ranges;
+    });
+  }
+
+  clearSelection(contextId: string): void {
+    untracked(() => {
+      const selection = this.getSelection(contextId);
+      if (selection) {
+        this._state.selections[contextId] = defaultSelection(selection.mode);
+      }
+    });
+  }
+
+  toggleSelection(contextId: string, id: string): void {
+    untracked(() => {
+      const selection = this.getSelection(contextId, 'multi');
+      invariant(selection?.mode === 'multi', 'Selection mode is not multi');
+
+      if (selection.ids.includes(id)) {
+        const index = selection.ids.indexOf(id);
+        selection.ids.splice(index, 1);
       } else {
-        current.add(id);
+        selection.ids.push(id);
       }
     });
   }

package/dist/lib/browser/chunk-DX37PZNT.mjs

@@ -1,410 +0,0 @@
-// packages/ui/react-ui-attention/src/attention.ts
-import { untracked } from "@preact/signals-core";
-import { S } from "@dxos/echo-schema";
-import { create } from "@dxos/live-object";
-import { ComplexMap } from "@dxos/util";
-var ATTENDABLE_PATH_SEPARATOR = "~";
-var AttentionSchema = S.mutable(S.Struct({
-  hasAttention: S.Boolean,
-  isAncestor: S.Boolean,
-  isRelated: S.Boolean
-}));
-var stringKey = (key) => key.join(",");
-var AttentionManager = class {
-  constructor(initial = []) {
-    // Each attention path is associated with an attention object.
-    // The lookup is not a reactive object to ensure that attention for each path is subscribable independently.
-    this._map = new ComplexMap(stringKey);
-    this._state = create({
-      current: []
-    });
-    if (initial.length > 0) {
-      this.update(initial);
-    }
-  }
-  /**
-  * Currently attended element.
-  *
-  * @reactive
-  */
-  get current() {
-    return this._state.current;
-  }
-  /**
-  * All attention paths.
-  */
-  keys() {
-    return Array.from(this._map.keys());
-  }
-  /**
-  * Get the attention state for a given path.
-  */
-  get(key) {
-    const object = this._map.get(key);
-    if (object) {
-      return object;
-    }
-    const newObject = create(AttentionSchema, {
-      hasAttention: false,
-      isAncestor: false,
-      isRelated: false
-    });
-    this._map.set(key, newObject);
-    return newObject;
-  }
-  /**
-  * Update the currently attended element.
-  *
-  * @internal
-  */
-  update(nextKey) {
-    const currentKey = untracked(() => this.current);
-    const currentRelatedTo = currentKey[0];
-    const nextRelatedTo = nextKey[0];
-    this.get([
-      nextRelatedTo
-    ]);
-    const currentRelatedKeys = this.keys().filter((key) => key[0] === currentRelatedTo);
-    const nextRelatedKeys = this.keys().filter((key) => key[0] === nextRelatedTo && stringKey(key) !== stringKey(nextKey));
-    const prevRelatedKeys = currentRelatedKeys.filter((curr) => !nextRelatedKeys.find((next) => stringKey(curr) === stringKey(next)));
-    const currentAncestorKeys = currentKey.slice(1).map((_, i) => currentKey.slice(i + 1, currentKey.length));
-    const nextAncestorKeys = nextKey.slice(1).map((_, i) => nextKey.slice(i + 1, nextKey.length));
-    const prevAncestorKeys = currentAncestorKeys.filter((curr) => !nextAncestorKeys.find((next) => stringKey(curr) === stringKey(next)));
-    this._state.current = nextKey;
-    prevRelatedKeys.forEach((key) => this._set(key, {}));
-    prevAncestorKeys.forEach((key) => this._set(key, {}));
-    nextRelatedKeys.forEach((key) => this._set(key, {
-      isRelated: true
-    }));
-    nextAncestorKeys.forEach((key) => this._set(key, {
-      isAncestor: true
-    }));
-    this._set(nextKey, {
-      hasAttention: true
-    });
-  }
-  _set(key, attention) {
-    const object = this.get(key);
-    object.hasAttention = attention.hasAttention ?? false;
-    object.isAncestor = attention.isAncestor ?? false;
-    object.isRelated = attention.isRelated ?? false;
-  }
-};
-var getAttendables = (selector, cursor, acc = []) => {
-  const closestAttendable = cursor.closest(selector);
-  if (closestAttendable) {
-    const attendableId = closestAttendable.getAttribute("data-attendable-id");
-    if (!attendableId) {
-      const trigger = document.querySelector(`[aria-controls="${closestAttendable.getAttribute("id")}"]`);
-      if (!trigger) {
-        return acc;
-      } else {
-        return getAttendables(selector, trigger, acc);
-      }
-    } else {
-      acc.push(...attendableId.split(ATTENDABLE_PATH_SEPARATOR));
-      return !closestAttendable.parentElement ? acc : getAttendables(selector, closestAttendable.parentElement, acc);
-    }
-  }
-  return [
-    ...new Set(acc)
-  ];
-};
-
-// packages/ui/react-ui-attention/src/components/AttentionGlyph.tsx
-import React, { forwardRef, useMemo } from "react";
-import { Icon } from "@dxos/react-ui";
-import { mx } from "@dxos/react-ui-theme";
-var attentionGlyphStyles = "inline-block rounded-sm is-3 bs-3 bg-transparent text-accentText transition-colors [[data-contains-attended=true]_&]:bg-attentionRelated [[data-attention=true]_&]:bg-accentSurface [[data-attention=true]_&]:text-inverse [[aria-current][data-attention=true]_&]:bg-accentSurface [[aria-current][data-attention=true]_&]:text-inverse";
-var presenceIconStyles = "is-3 bs-3 group-[[aria-current]_&:hover]/attentionGlyphButton:hidden group-[[aria-current]_&:focus]/attentionGlyphButton:hidden group-[[data-attention=true]_&:hover]/attentionGlyphButton:hidden group-[[data-attention=true]_&:focus]/attentionGlyphButton:hidden group-[[aria-current][data-attention=true]_&:hover]/attentionGlyphButton:hidden group-[[aria-current][data-attention=true]_&:focus]/attentionGlyphButton:hidden";
-var PresenceOne = () => {
-  return /* @__PURE__ */ React.createElement("svg", {
-    width: "12",
-    height: "12",
-    viewBox: "0 0 12 12",
-    className: presenceIconStyles,
-    fill: "none",
-    xmlns: "http://www.w3.org/2000/svg"
-  }, /* @__PURE__ */ React.createElement("circle", {
-    cx: "6",
-    cy: "6",
-    r: "2.5",
-    fill: "currentColor"
-  }));
-};
-var PresenceMany = () => {
-  return /* @__PURE__ */ React.createElement("svg", {
-    width: "12",
-    height: "12",
-    viewBox: "0 0 12 12",
-    className: presenceIconStyles,
-    fill: "none",
-    xmlns: "http://www.w3.org/2000/svg"
-  }, /* @__PURE__ */ React.createElement("path", {
-    d: "M6.75 8.27311C7.38815 7.72296 7.79212 6.90866 7.79212 6C7.79212 5.09134 7.38815 4.27704 6.75 3.72689C7.06722 3.58122 7.42019 3.5 7.79212 3.5C9.17283 3.5 10.2921 4.61929 10.2921 6C10.2921 7.38071 9.17283 8.5 7.79212 8.5C7.42019 8.5 7.06723 8.41878 6.75 8.27311Z",
-    fill: "currentColor"
-  }), /* @__PURE__ */ React.createElement("circle", {
-    cx: "4.25",
-    cy: "6",
-    r: "2.5",
-    fill: "currentColor"
-  }));
-};
-var Syncing = () => {
-  const animationProps = useMemo(() => ({
-    // Synchronize animations.
-    animationDelay: `-${Date.now() % 2e3}ms`
-  }), []);
-  return /* @__PURE__ */ React.createElement("div", {
-    role: "status",
-    className: "flex items-center"
-  }, /* @__PURE__ */ React.createElement(Icon, {
-    icon: "ph--circle-notch--regular",
-    size: 3,
-    style: animationProps,
-    classNames: "text-subdued animate-[spin_2s_linear_infinite]"
-  }));
-};
-var AttentionGlyph = /* @__PURE__ */ forwardRef(({ presence, attended, syncing, containsAttended, classNames, ...props }, forwardedRef) => {
-  const icon = syncing ? /* @__PURE__ */ React.createElement(Syncing, null) : presence === "many" ? /* @__PURE__ */ React.createElement(PresenceMany, null) : presence === "one" ? /* @__PURE__ */ React.createElement(PresenceOne, null) : null;
-  return /* @__PURE__ */ React.createElement("div", {
-    role: "none",
-    className: "flex",
-    "data-attention": attended,
-    "data-contains-attended": containsAttended
-  }, /* @__PURE__ */ React.createElement("span", {
-    role: "none",
-    ...props,
-    className: mx(attentionGlyphStyles, classNames),
-    ref: forwardedRef
-  }, icon));
-});
-
-// packages/ui/react-ui-attention/src/components/AttentionProvider.tsx
-import { createContext } from "@radix-ui/react-context";
-import { Primitive } from "@radix-ui/react-primitive";
-import { Slot } from "@radix-ui/react-slot";
-import React2, { useMemo as useMemo2, forwardRef as forwardRef2 } from "react";
-import { useDefaultValue } from "@dxos/react-ui";
-import { mx as mx2 } from "@dxos/react-ui-theme";
-var ATTENTION_NAME = "Attention";
-var ATTENABLE_ATTRIBUTE = "data-attendable-id";
-var ATTENTION_SOURCE_ATTRIBUTE = "data-is-attention-source";
-var [AttentionContextProvider, useAttentionContext] = createContext(ATTENTION_NAME, {
-  attention: new AttentionManager(),
-  path: []
-});
-var UNKNOWN_ATTENDABLE = {
-  hasAttention: false,
-  isAncestor: false,
-  isRelated: false
-};
-var useAttention = (attendableId) => {
-  const { attention, path } = useAttentionContext(ATTENTION_NAME);
-  if (!attendableId) {
-    return UNKNOWN_ATTENDABLE;
-  }
-  const current = [
-    ...attendableId.split(ATTENDABLE_PATH_SEPARATOR),
-    ...path
-  ];
-  return attention.get(current);
-};
-var useAttended = () => {
-  const { attention } = useAttentionContext(ATTENTION_NAME);
-  return attention.current;
-};
-var useAttendableAttributes = (attendableId) => {
-  const { hasAttention } = useAttention(attendableId);
-  return useMemo2(() => {
-    const attributes = {
-      [ATTENABLE_ATTRIBUTE]: attendableId
-    };
-    if (hasAttention) {
-      attributes[ATTENTION_SOURCE_ATTRIBUTE] = "true";
-    }
-    return attributes;
-  }, [
-    attendableId,
-    hasAttention
-  ]);
-};
-var useAttentionPath = () => {
-  const { path } = useAttentionContext(ATTENTION_NAME);
-  return path;
-};
-var RootAttentionProvider = ({ children, attention: propsAttention, onChange }) => {
-  const attention = useDefaultValue(propsAttention, () => new AttentionManager());
-  const handleFocus = (event) => {
-    const selector = [
-      "[data-attendable-id]",
-      ...Array.from(document.querySelectorAll("[aria-controls]")).map((el) => `[id="${el.getAttribute("aria-controls")}"]`)
-    ].join(",");
-    const prev = attention.current;
-    const next = getAttendables(selector, event.target);
-    if (next.length > 0 && (prev.length !== next.length || !!prev.find((id, index) => next[index] !== id))) {
-      attention.update(next);
-      onChange?.(next);
-    }
-  };
-  return /* @__PURE__ */ React2.createElement(AttentionContextProvider, {
-    attention,
-    path: []
-  }, /* @__PURE__ */ React2.createElement("div", {
-    role: "none",
-    className: "contents",
-    onFocusCapture: handleFocus
-  }, children));
-};
-var AttentionProvider = ({ id, children }) => {
-  const { attention, path } = useAttentionContext(ATTENTION_NAME);
-  const nextPath = useMemo2(() => [
-    id,
-    ...path
-  ], [
-    id,
-    path
-  ]);
-  return /* @__PURE__ */ React2.createElement(AttentionContextProvider, {
-    attention,
-    path: nextPath
-  }, children);
-};
-var AttendableContainer = /* @__PURE__ */ forwardRef2(({ id, classNames, children, asChild, ...props }, forwardedRef) => {
-  const attendableAttrs = useAttendableAttributes(id);
-  const Root = asChild ? Slot : Primitive.div;
-  return /* @__PURE__ */ React2.createElement(Root, {
-    role: "none",
-    ...attendableAttrs,
-    ...props,
-    className: mx2("attention-surface", props.tabIndex === 0 && "dx-focus-ring-inset-over-all", classNames),
-    ref: forwardedRef
-  }, children);
-});
-
-// packages/ui/react-ui-attention/src/selection.ts
-import { untracked as untracked2 } from "@preact/signals-core";
-import { create as create2 } from "@dxos/live-object";
-var SelectionManager = class {
-  constructor(initial = {}) {
-    this._state = create2({
-      selections: {}
-    });
-    if (Object.keys(initial).length > 0) {
-      untracked2(() => {
-        this._state.selections = initial;
-      });
-    }
-  }
-  get selections() {
-    return this._state.selections;
-  }
-  getSelection(contextId) {
-    if (!this.selections[contextId]) {
-      untracked2(() => {
-        this._state.selections[contextId] = /* @__PURE__ */ new Set();
-      });
-    }
-    return this.selections[contextId];
-  }
-  updateSelection(contextId, selectedIds) {
-    untracked2(() => {
-      this._state.selections[contextId] = selectedIds instanceof Set ? selectedIds : new Set(selectedIds);
-    });
-  }
-  clearSelection(contextId) {
-    untracked2(() => {
-      this._state.selections[contextId] = /* @__PURE__ */ new Set();
-    });
-  }
-  toggleSelection(contextId, id) {
-    untracked2(() => {
-      const current = this.getSelection(contextId);
-      if (current.has(id)) {
-        current.delete(id);
-      } else {
-        current.add(id);
-      }
-    });
-  }
-};
-
-// packages/ui/react-ui-attention/src/components/SelectionProvider.tsx
-import { createContext as createContext2 } from "@radix-ui/react-context";
-import React3, { useCallback, useMemo as useMemo3 } from "react";
-import { useDefaultValue as useDefaultValue2 } from "@dxos/react-ui";
-var SELECTION_NAME = "Selection";
-var [SelectionContextProvider, useSelectionContext] = createContext2(SELECTION_NAME, {
-  selection: new SelectionManager()
-});
-var SelectionProvider = ({ children, selection: propsSelection }) => {
-  const selection = useDefaultValue2(propsSelection, () => new SelectionManager());
-  return /* @__PURE__ */ React3.createElement(SelectionContextProvider, {
-    selection
-  }, children);
-};
-var emptySet = /* @__PURE__ */ new Set();
-var useSelectedItems = (contextId) => {
-  const { selection } = useSelectionContext(SELECTION_NAME);
-  return contextId ? selection.getSelection(contextId) : emptySet;
-};
-var useSelectionActions = (contextIds) => {
-  const stableContextIds = useMemo3(() => contextIds, [
-    JSON.stringify(contextIds)
-  ]);
-  const { selection } = useSelectionContext(SELECTION_NAME);
-  const select = useCallback((ids) => {
-    for (const contextId of stableContextIds) {
-      selection.updateSelection(contextId, ids);
-    }
-  }, [
-    selection,
-    stableContextIds
-  ]);
-  const toggle = useCallback((id) => {
-    for (const contextId of stableContextIds) {
-      selection.toggleSelection(contextId, id);
-    }
-  }, [
-    selection,
-    stableContextIds
-  ]);
-  const clear = useCallback(() => {
-    for (const contextId of stableContextIds) {
-      selection.clearSelection(contextId);
-    }
-  }, [
-    selection,
-    stableContextIds
-  ]);
-  return {
-    select,
-    toggle,
-    clear
-  };
-};
-
-export {
-  ATTENDABLE_PATH_SEPARATOR,
-  AttentionSchema,
-  AttentionManager,
-  getAttendables,
-  Syncing,
-  AttentionGlyph,
-  ATTENTION_NAME,
-  ATTENABLE_ATTRIBUTE,
-  ATTENTION_SOURCE_ATTRIBUTE,
-  useAttentionContext,
-  useAttention,
-  useAttended,
-  useAttendableAttributes,
-  useAttentionPath,
-  RootAttentionProvider,
-  AttentionProvider,
-  AttendableContainer,
-  SelectionManager,
-  SelectionProvider,
-  useSelectedItems,
-  useSelectionActions
-};
-//# sourceMappingURL=chunk-DX37PZNT.mjs.map