@dxos/react-ui-list 0.9.0 → 0.9.1-main.c7dcc2e112

package/src/components/OrderedList/OrderedListItem.tsx

@@ -0,0 +1,348 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import { createContext } from '@radix-ui/react-context';
+import React, {
+  type ComponentProps,
+  type CSSProperties,
+  type MouseEvent,
+  type PropsWithChildren,
+  type ReactNode,
+  type RefCallback,
+  useCallback,
+} from 'react';
+
+import {
+  IconBlock,
+  IconButton,
+  type IconButtonProps,
+  ListItem as NaturalListItem,
+  type ThemedClassName,
+  ToggleIconButton,
+  useTranslation,
+} from '@dxos/react-ui';
+import { mx, osTranslations } from '@dxos/ui-theme';
+
+import { useListGrid, useReorderItem } from '../../aspects';
+import { type ListItemRecord, useOrderedListContext } from './OrderedListRoot';
+
+const ORDERED_LIST_ITEM_NAME = 'OrderedListItem';
+
+type OrderedListItemContextValue = {
+  id: string;
+  expanded: boolean;
+  toggle: () => void;
+  canDrag: boolean;
+  handleRef: RefCallback<HTMLElement>;
+  /** ARIA wiring for the controlled disclosure panel. */
+  triggerProps: ReturnType<NonNullable<ReturnType<typeof useOrderedListContext>['disclosure']['bind']>>['triggerProps'];
+  panelProps: ReturnType<NonNullable<ReturnType<typeof useOrderedListContext>['disclosure']['bind']>>['panelProps'];
+};
+
+const [OrderedListItemProvider, useOrderedListItemContext] =
+  createContext<OrderedListItemContextValue>(ORDERED_LIST_ITEM_NAME);
+
+export type OrderedListItemProps<T extends ListItemRecord> = ThemedClassName<
+  PropsWithChildren<{
+    id: string;
+    /** The record handed to the underlying reorder hook (kept for back-compat with callers). */
+    item: T;
+    /** Defaults to true; false disables the drag handle. */
+    canDrag?: boolean;
+    /** Apply the row-hover affordance. Defaults to false. */
+    hover?: boolean;
+    /**
+     * Visually highlights the row as the "currently active" entry — sets `aria-current="true"`
+     * paired with `dx-current` styling. `aria-current` is the right grammar for an active row
+     * inside a `list`-mode container (listbox/option semantics live on `Listbox`); used for
+     * surfaces like the `Mixer` where the active layer needs visual highlight without
+     * adopting listbox role semantics.
+     */
+    selected?: boolean;
+    /** Optional click handler bound to the outer row element. */
+    onClick?: (event: MouseEvent<HTMLDivElement>) => void;
+    /** Inline style merged onto the outer element. Used for grid templates produced by `useListGrid`. */
+    style?: CSSProperties;
+  }>
+>;
+
+/**
+ * A single reorderable item. Calls `useReorderItem` to wire pragmatic-dnd refs + state,
+ * resolves disclosure state from the root context, and exposes both via item context for
+ * the sub-components (`OrderedListDragHandle`, `OrderedListTitle`, `OrderedListExpandCaret`).
+ *
+ * The outer element applies only structural concerns (`relative` + state classes); the
+ * layout (flex/grid) is controlled by the caller via `classNames` so master-detail rows
+ * and bare reorderable rows can share the same component.
+ */
+export const OrderedListItem = <T extends ListItemRecord>({
+  id,
+  canDrag = true,
+  hover = false,
+  selected,
+  onClick,
+  classNames,
+  style,
+  children,
+}: OrderedListItemProps<T>) => {
+  const { reorder, disclosure, navigation } = useOrderedListContext(ORDERED_LIST_ITEM_NAME);
+  const { rowRef, handleRef, closestEdge, state } = useReorderItem(reorder, id);
+  const { expanded, toggle, triggerProps, panelProps } = disclosure.bind(id);
+
+  return (
+    <OrderedListItemProvider
+      id={id}
+      expanded={expanded}
+      toggle={toggle}
+      canDrag={canDrag}
+      handleRef={handleRef}
+      triggerProps={triggerProps}
+      panelProps={panelProps}
+    >
+      <div
+        ref={rowRef as RefCallback<HTMLDivElement>}
+        {...navigation.itemProps()}
+        style={style}
+        aria-current={selected || undefined}
+        onClick={onClick}
+        className={mx(
+          'relative dx-current',
+          hover && 'dx-hover',
+          state.type === 'dragging' && 'opacity-50',
+          classNames,
+        )}
+      >
+        {children}
+        {closestEdge && <NaturalListItem.DropIndicator edge={closestEdge} />}
+      </div>
+    </OrderedListItemProvider>
+  );
+};
+
+/**
+ * Drag handle. Disabled when the list is readonly or the item opts out via `canDrag={false}`.
+ * The button is the only element that initiates drag — pragmatic-dnd's `dragHandle:` option
+ * scopes the source surface to this ref.
+ */
+export const OrderedListDragHandle = () => {
+  const { readonly } = useOrderedListContext('OrderedListDragHandle');
+  const { canDrag, handleRef } = useOrderedListItemContext('OrderedListDragHandle');
+  const { t } = useTranslation(osTranslations);
+  const disabled = readonly || !canDrag;
+  return (
+    <IconButton
+      variant='ghost'
+      disabled={disabled}
+      noTooltip
+      icon='ph--dots-six-vertical--regular'
+      iconOnly
+      label={t('drag-handle.label')}
+      ref={handleRef as RefCallback<HTMLButtonElement>}
+    />
+  );
+};
+
+/**
+ * Clickable title; clicking toggles the item's expanded state. Carries a stable id so the
+ * expanded panel can name itself via `aria-labelledby`.
+ */
+export const OrderedListTitle = ({
+  classNames,
+  children,
+  onClick,
+  ...props
+}: ThemedClassName<PropsWithChildren<ComponentProps<'div'>>>) => {
+  const { triggerProps } = useOrderedListItemContext('OrderedListTitle');
+  const handleClick = useCallback(
+    (event: MouseEvent<HTMLDivElement>) => {
+      onClick?.(event);
+      triggerProps.onClick(event);
+    },
+    [onClick, triggerProps],
+  );
+  return (
+    <div
+      {...props}
+      // The title row is also the disclosure trigger, so it carries the trigger's
+      // `id` + `aria-expanded` + `aria-controls` for assistive tech.
+      id={triggerProps.id}
+      aria-expanded={triggerProps['aria-expanded']}
+      aria-controls={triggerProps['aria-controls']}
+      className={mx('flex grow items-center truncate cursor-pointer', classNames)}
+      onClick={handleClick}
+    >
+      {children}
+    </div>
+  );
+};
+
+/**
+ * Generic action icon button. Anchored in a `var(--dx-rail-item)` IconBlock so it shares a
+ * centerline with the title row regardless of expand state. Use for inline row actions
+ * (mute, edit, copy, etc.); pair with `OrderedListDeleteButton` for the delete affordance.
+ */
+export const OrderedListIconButton = ({
+  autoHide = false,
+  disabled,
+  classNames,
+  ...props
+}: IconButtonProps & { autoHide?: boolean }) => (
+  <IconBlock>
+    <IconButton
+      {...props}
+      variant='ghost'
+      iconOnly
+      disabled={disabled}
+      classNames={[classNames, autoHide && disabled && 'hidden']}
+    />
+  </IconBlock>
+);
+
+/**
+ * Delete icon button. Anchored in a `var(--dx-rail-item)` IconBlock so it shares a centerline
+ * with the title row regardless of expand state. No `my-[1px]` nudge: the central column's
+ * outline is `ring-1` (see `OrderedListDetailItem`) so layout is exact.
+ */
+export const OrderedListDeleteButton = ({
+  autoHide = false,
+  icon = 'ph--x--regular',
+  label,
+  disabled,
+  classNames,
+  ...props
+}: Partial<Pick<IconButtonProps, 'icon'>> &
+  Omit<IconButtonProps, 'icon' | 'label'> & { autoHide?: boolean; label?: string }) => {
+  const { t } = useTranslation(osTranslations);
+  return (
+    <OrderedListIconButton
+      {...props}
+      autoHide={autoHide}
+      disabled={disabled}
+      icon={icon}
+      label={label ?? t('delete.label')}
+      classNames={classNames}
+    />
+  );
+};
+
+/**
+ * Expand/collapse caret; reflects and toggles the item's expanded state via the disclosure
+ * trigger's `aria-expanded` + `aria-controls`.
+ */
+export const OrderedListExpandCaret = ({ onClick, ...props }: Partial<IconButtonProps>) => {
+  const { t } = useTranslation(osTranslations);
+  const { expanded, toggle, triggerProps } = useOrderedListItemContext('OrderedListExpandCaret');
+  const handleClick = useCallback(
+    (event: MouseEvent<HTMLButtonElement>) => {
+      toggle();
+      onClick?.(event);
+    },
+    [toggle, onClick],
+  );
+  return (
+    <ToggleIconButton
+      iconOnly
+      variant='ghost'
+      active={expanded}
+      icon='ph--caret-right--regular'
+      label={t('toggle-expand.label')}
+      // Disclosure semantics are carried here for AT users that interact with the caret
+      // rather than the title.
+      aria-expanded={triggerProps['aria-expanded']}
+      aria-controls={triggerProps['aria-controls']}
+      onClick={handleClick}
+      {...props}
+    />
+  );
+};
+
+export type OrderedListDetailItemProps<T extends ListItemRecord> = ThemedClassName<
+  PropsWithChildren<{
+    id: string;
+    /** The record handed to the underlying reorder hook (kept for back-compat with callers). */
+    item: T;
+    /** Defaults to true; false disables the drag handle. */
+    canDrag?: boolean;
+    /** Title content shown in the clickable name row (clicking toggles expansion). */
+    title: ReactNode;
+    titleClassNames?: ThemedClassName<any>['classNames'];
+    /** Inline actions placed in the name row before the expand caret (e.g. a visibility toggle). */
+    actions?: ReactNode;
+    /** Action(s) placed outside the bordered column, flanking it (e.g. a delete button). */
+    trailing?: ReactNode;
+    /** When false, hides the expand caret and detail panel. Defaults to true. */
+    expandable?: boolean;
+  }>
+>;
+
+/**
+ * Master-detail row: a drag handle and trailing action flank a `ring-1`-outlined central
+ * column whose title row (title + inline actions + expand caret) toggles an inline detail
+ * panel (children).
+ *
+ * Outline uses `ring-1` (rendered as box-shadow) rather than `border` so the column's
+ * content area is the full `var(--dx-rail-item)` height — handles, title, caret, and
+ * trailing all sit on the same baseline without per-pixel nudges.
+ */
+export const OrderedListDetailItem = <T extends ListItemRecord>({
+  id,
+  item,
+  canDrag,
+  title,
+  titleClassNames,
+  actions,
+  trailing,
+  expandable = true,
+  classNames,
+  children,
+}: OrderedListDetailItemProps<T>) => {
+  const grid = useListGrid({ trailing: !!trailing });
+  return (
+    <OrderedListItem
+      id={id}
+      item={item}
+      canDrag={canDrag}
+      // The grid template is inline so the row's three slots (handle / card / trailing)
+      // land in fixed-width tracks that share a baseline with the title row inside the card.
+      // See useListGrid for the rationale.
+      style={grid.rowProps.style}
+      classNames={mx(grid.rowProps.className, 'pb-1', classNames)}
+    >
+      <OrderedListDragHandle />
+      <div className='flex flex-col ring-1 ring-subdued-separator rounded-sm overflow-hidden'>
+        <div className='flex items-center min-h-[var(--dx-rail-item)]'>
+          {expandable ? (
+            <OrderedListTitle classNames={mx('px-2', titleClassNames)}>{title}</OrderedListTitle>
+          ) : (
+            // When the row is not expandable, render a plain (non-toggling) title so a click
+            // doesn't mutate hidden disclosure state. Mirrors `OrderedListTitle`'s structure
+            // minus the trigger plumbing.
+            <div className={mx('flex grow items-center truncate px-2', titleClassNames)}>{title}</div>
+          )}
+          {actions}
+          {expandable && <OrderedListExpandCaret />}
+        </div>
+        {expandable && <DetailPanel>{children}</DetailPanel>}
+      </div>
+      {trailing}
+    </OrderedListItem>
+  );
+};
+
+/**
+ * Read-only panel renderer that consumes the item's disclosure state from context. Kept as
+ * a small sub-component so the panel's `id` + `role=region` + `aria-labelledby` come from a
+ * single source — and so a closed item doesn't pay for rendering an empty panel.
+ */
+const DetailPanel = ({ children }: PropsWithChildren) => {
+  const { expanded, panelProps } = useOrderedListItemContext('OrderedListDetailItem.Panel');
+  if (!expanded || !children) {
+    return null;
+  }
+  return (
+    <div {...panelProps} className='px-2 pb-2'>
+      {children}
+    </div>
+  );
+};

package/src/components/OrderedList/OrderedListRoot.tsx

@@ -0,0 +1,173 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import { createContext } from '@radix-ui/react-context';
+import React, { type PropsWithChildren, type ReactNode, useMemo } from 'react';
+
+import {
+  ScrollArea,
+  type ScrollAreaRootProps,
+  type ThemedClassName,
+  composable,
+  composableProps,
+} from '@dxos/react-ui';
+import { mx } from '@dxos/ui-theme';
+
+import {
+  type ReorderActive,
+  type ReorderListController,
+  type UseListNavigationReturn,
+  type UseListDisclosureReturn,
+  useListDisclosure,
+  useListNavigation,
+  useReorderAutoScroll,
+  useReorderList,
+} from '../../aspects';
+
+export type ListItemRecord = any;
+
+const ORDERED_LIST_NAME = 'OrderedList';
+
+type OrderedListContextValue<T extends ListItemRecord> = {
+  reorder: ReorderListController<T>;
+  disclosure: UseListDisclosureReturn;
+  navigation: UseListNavigationReturn;
+  readonly?: boolean;
+  active: ReorderActive<T>;
+  /**
+   * Stable id accessor reused by items that want to look up their record (e.g. the
+   * `OrderedListItem` <-> `useReorderItem` plumbing).
+   */
+  getId: (item: T) => string;
+};
+
+const [OrderedListProvider, useOrderedListContext] = createContext<OrderedListContextValue<any>>(ORDERED_LIST_NAME);
+
+export { useOrderedListContext };
+
+export type OrderedListRootProps<T extends ListItemRecord> = ThemedClassName<{
+  items: readonly T[];
+  /**
+   * Type guard reserved for backwards compatibility with the deprecated `List` API. The
+   * aspect layer doesn't need it (payloads are scoped via the list's internal id) — values
+   * passed here are currently ignored. Will be removed when call-sites migrate.
+   */
+  isItem?: (item: any) => boolean;
+  /**
+   * Stable id accessor. When omitted, the hook falls back to reference equality, which
+   * breaks after a pragmatic-dnd round-trip serialises the payload — supply a `getId` for
+   * any list whose items are plain values rather than ECHO refs.
+   */
+  getId?: (item: T) => string;
+  onMove?: (fromIndex: number, toIndex: number) => void;
+  readonly?: boolean;
+  /** Controlled expanded item id (single-expand). */
+  expandedId?: string;
+  defaultExpandedId?: string;
+  onExpandedChange?: (id: string | undefined) => void;
+  children: (props: { items: readonly T[] }) => ReactNode;
+}>;
+
+const defaultGetId = <T extends ListItemRecord>(item: T) => (item as any)?.id;
+const noopMove = () => {};
+
+/**
+ * Reorderable, single-expandable master-detail list. Wraps the aspect hooks:
+ *
+ * - `useReorderList` — drag-and-drop reorder via pragmatic-dnd.
+ * - `useListDisclosure` (single mode) — single-expand state machine.
+ * - `useListNavigation` (list mode) — Tabster keyboard nav across items.
+ *
+ * Owns the drag-handle / delete / expand-caret chrome plus expand state. Renders no DOM
+ * itself; `OrderedListContent` is the container.
+ */
+export const OrderedListRoot = <T extends ListItemRecord>({
+  items,
+  getId = defaultGetId,
+  onMove = noopMove,
+  readonly,
+  expandedId,
+  defaultExpandedId,
+  onExpandedChange,
+  children,
+}: OrderedListRootProps<T>) => {
+  const { controller, active } = useReorderList<T>({
+    items,
+    getId,
+    onMove,
+    readonly,
+  });
+
+  const disclosure = useListDisclosure({
+    mode: 'single',
+    value: expandedId,
+    defaultValue: defaultExpandedId,
+    onValueChange: (next) => onExpandedChange?.(next),
+  });
+
+  const navigation = useListNavigation({ mode: 'list' });
+
+  // Memoise the context value so identity-stable items don't re-render on aspect re-renders
+  // that don't affect their bindings (e.g. an unrelated drag-state change).
+  const context = useMemo(
+    () => ({
+      reorder: controller,
+      disclosure,
+      navigation,
+      readonly,
+      active,
+      getId,
+    }),
+    [controller, disclosure, navigation, readonly, active, getId],
+  );
+
+  return <OrderedListProvider {...context}>{children({ items })}</OrderedListProvider>;
+};
+
+/**
+ * Container for the list. Applies the navigation aspect's `containerProps` so role,
+ * aria-orientation, Tabster attributes, and focus-on-entry are wired in one place.
+ */
+export const OrderedListContent = ({ classNames, children }: ThemedClassName<PropsWithChildren>) => {
+  const { navigation } = useOrderedListContext('OrderedList.Content');
+  return (
+    <div {...navigation.containerProps} className={mx('flex flex-col', classNames)}>
+      {children}
+    </div>
+  );
+};
+
+/**
+ * Optional ScrollArea wrapper for the list. Mirrors `Listbox.Viewport`. Include when the
+ * list needs to fill a constrained pane and scroll independently; omit for static lists
+ * that flow with their parent.
+ *
+ * Wires `useReorderAutoScroll` on the inner viewport so pragmatic-dnd auto-scrolls the
+ * container when a drag hovers near its edges — long lists can be reordered without
+ * scrolling manually first.
+ */
+type OrderedListViewportProps = Pick<ScrollAreaRootProps, 'thin' | 'padding' | 'centered'>;
+
+export const OrderedListViewport = composable<HTMLDivElement, OrderedListViewportProps>((props, forwardedRef) => {
+  const { thin, padding, centered, children, ...rest } = props as PropsWithChildren<
+    OrderedListViewportProps & Record<string, unknown>
+  >;
+  // Callback ref so registration fires on attach and cleanup on detach — `useEffect` on a
+  // ref object would miss the element entirely (ref mutations don't re-run effects).
+  const autoScrollRef = useReorderAutoScroll();
+  return (
+    <ScrollArea.Root
+      {...composableProps<HTMLDivElement>(rest, { classNames: 'dx-container' })}
+      {...{ thin, padding, centered }}
+      orientation='vertical'
+      ref={forwardedRef}
+    >
+      <ScrollArea.Viewport ref={autoScrollRef}>{children}</ScrollArea.Viewport>
+    </ScrollArea.Root>
+  );
+});
+
+OrderedListViewport.displayName = 'OrderedList.Viewport';
+
+export type { OrderedListViewportProps };

package/src/components/OrderedList/index.ts

@@ -0,0 +1,5 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+export * from './OrderedList';

package/src/components/Tree/TreeItem.tsx

@@ -316,6 +316,8 @@ const RawTreeItem = <T extends { id: string } = any>({
         aria-current={current ? ('' as 'page') : undefined}
         classNames={mx(
           'grid grid-cols-subgrid col-[tree-row] mt-0.5 is-current:bg-current-surface',
+          // Highlight the row while a descendant marks an open popover anchor (e.g. inline rename).
+          'has-[[data-popover-anchor]]:bg-current-surface',
           hoverableControls,
           hoverableFocusedKeyboardControls,
           hoverableFocusedWithinControls,

package/src/components/Tree/TreeItemHeading.tsx

@@ -4,8 +4,7 @@
 
 import React, { type KeyboardEvent, type MouseEvent, forwardRef, memo, useCallback } from 'react';
 
-import { Button, Icon, type Label, Tag, toLocalizedString, useTranslation } from '@dxos/react-ui';
-import { TextTooltip } from '@dxos/react-ui-text-tooltip';
+import { Button, Icon, type Label, Tag, TextTooltip, toLocalizedString, useTranslation } from '@dxos/react-ui';
 import { getStyles } from '@dxos/ui-theme';
 
 // TODO(wittjosiah): Consider whether there should be a separate disabled prop which was visually distinct

package/src/components/index.ts

@@ -4,8 +4,7 @@
 
 export * from './Accordion';
 export * from './Combobox';
-export * from './List';
 export * from './Listbox';
+export * from './OrderedList';
 export * from './Picker';
-export * from './RowList';
 export * from './Tree';

package/src/index.ts

@@ -2,5 +2,6 @@
 // Copyright 2024 DXOS.org
 //
 
+export * from './aspects';
 export * from './components';
 export * from './util';

package/src/vitest-setup.ts

@@ -0,0 +1,11 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+// https://github.com/testing-library/jest-dom#with-vitest
+import '@testing-library/jest-dom/vitest';
+
+// https://github.com/jsdom/jsdom/issues/3368#issuecomment-1396749033
+import ResizeObserver from 'resize-observer-polyfill';
+
+global.ResizeObserver = ResizeObserver;

package/dist/types/src/components/List/List.d.ts

@@ -1,40 +0,0 @@
-import { ListItem, type ListItemProps, type ListItemRecord } from './ListItem';
-import { type ListRootProps } from './ListRoot';
-/**
- * Draggable list with per-row drag handles and delete buttons.
- * Ref: https://github.com/atlassian/pragmatic-drag-and-drop
- * Ref: https://github.com/alexreardon/pdnd-react-tailwind/blob/main/src/task.tsx
- *
- * @deprecated New code should use one of:
- *
- *   - `RowList` / `CardList` from this same package — for selectable
- *     pickers (master/detail). Correct ARIA + dx-* by construction.
- *   - `Mosaic.Stack` / `Mosaic.VirtualStack` from `@dxos/react-ui-mosaic`
- *     — for virtualized or drag-reorderable card stacks.
- *
- * This component is retained for the existing reorder-with-delete-button
- * use cases (plugin-meeting, plugin-automation, plugin-zen, etc.) until
- * each is migrated; see `AUDIT.md` Phase 6 for the migration plan.
- */
-export declare const List: {
-    Root: <T extends unknown>({ children, items, isItem, getId, onMove, ...props }: ListRootProps<T>) => import("react").JSX.Element;
-    Item: <T extends unknown>({ children, classNames, item, asChild, selected, ...props }: ListItemProps<T>) => import("react").JSX.Element;
-    ItemDragPreview: <T extends unknown>({ children, }: {
-        children: ({ item }: {
-            item: T;
-        }) => import("react").ReactNode;
-    }) => import("react").ReactPortal | null;
-    ItemWrapper: ({ classNames, children }: import("@dxos/ui-types").ThemedClassName<import("react").PropsWithChildren>) => import("react").JSX.Element;
-    ItemDragHandle: ({ disabled }: Pick<import("@dxos/react-ui").IconButtonProps, 'disabled'>) => import("react").JSX.Element;
-    ItemIconButton: ({ autoHide, iconOnly, variant, classNames, disabled, ...props }: import("@dxos/react-ui").IconButtonProps & {
-        autoHide?: boolean;
-    }) => import("react").JSX.Element;
-    ItemDeleteButton: ({ autoHide, classNames, disabled, icon, label, ...props }: Partial<Pick<import("@dxos/react-ui").IconButtonProps, 'icon'>> & Omit<import("@dxos/react-ui").IconButtonProps, 'icon' | 'label'> & {
-        autoHide?: boolean;
-        label?: string;
-    }) => import("react").JSX.Element;
-    ItemTitle: ({ classNames, children, ...props }: import("@dxos/ui-types").ThemedClassName<import("react").PropsWithChildren<import("react").ComponentProps<'div'>>>) => import("react").JSX.Element;
-};
-type ListItem = ListItemRecord;
-export type { ListRootProps, ListItemProps, ListItem, ListItemRecord };
-//# sourceMappingURL=List.d.ts.map

package/dist/types/src/components/List/List.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"List.d.ts","sourceRoot":"","sources":["../../../../../src/components/List/List.tsx"],"names":[],"mappings":"AAIA,OAAO,EACL,QAAQ,EAKR,KAAK,aAAa,EAClB,KAAK,cAAc,EAGpB,MAAM,YAAY,CAAC;AACpB,OAAO,EAAY,KAAK,aAAa,EAAE,MAAM,YAAY,CAAC;AAE1D;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,IAAI;IACf,IAAI;IACJ,IAAI;IACJ,eAAe;;;;;IACf,WAAW;IACX,cAAc;IACd,cAAc;;;IACd,gBAAgB;;;;IAChB,SAAS;CACV,CAAC;AAEF,KAAK,QAAQ,GAAG,cAAc,CAAC;AAE/B,YAAY,EAAE,aAAa,EAAE,aAAa,EAAE,QAAQ,EAAE,cAAc,EAAE,CAAC"}

package/dist/types/src/components/List/List.stories.d.ts

@@ -1,18 +0,0 @@
-import { type StoryObj } from '@storybook/react-vite';
-import React from 'react';
-import { type ListRootProps } from './List';
-import { type TestItemType } from './testing';
-declare const DefaultStory: (props: Omit<ListRootProps<TestItemType>, 'items'>) => React.JSX.Element;
-declare const SimpleStory: (props: Omit<ListRootProps<TestItemType>, 'items'>) => React.JSX.Element;
-declare const meta: {
-    title: string;
-    component: <T extends unknown>({ children, items, isItem, getId, onMove, ...props }: ListRootProps<T>) => React.JSX.Element;
-    decorators: import("@storybook/react").Decorator[];
-    parameters: {
-        layout: string;
-    };
-};
-export default meta;
-export declare const Default: StoryObj<typeof DefaultStory>;
-export declare const Simple: StoryObj<typeof SimpleStory>;
-//# sourceMappingURL=List.stories.d.ts.map

package/dist/types/src/components/List/List.stories.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"List.stories.d.ts","sourceRoot":"","sources":["../../../../../src/components/List/List.stories.tsx"],"names":[],"mappings":"AAKA,OAAO,EAAa,KAAK,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AAEjE,OAAO,KAA8B,MAAM,OAAO,CAAC;AAOnD,OAAO,EAAQ,KAAK,aAAa,EAAE,MAAM,QAAQ,CAAC;AAClD,OAAO,EAAkB,KAAK,YAAY,EAA6B,MAAM,WAAW,CAAC;AAKzF,QAAA,MAAM,YAAY,UAAW,IAAI,CAAC,aAAa,CAAC,YAAY,CAAC,EAAE,OAAO,CAAC,sBA6DtE,CAAC;AAEF,QAAA,MAAM,WAAW,UAAW,IAAI,CAAC,aAAa,CAAC,YAAY,CAAC,EAAE,OAAO,CAAC,sBAoBrE,CAAC;AAEF,QAAA,MAAM,IAAI;;;;;QAKN,MAAM;;CAEwB,CAAC;eAEpB,IAAI;AAEnB,eAAO,MAAM,OAAO,EAAE,QAAQ,CAAC,OAAO,YAAY,CAKjD,CAAC;AAEF,eAAO,MAAM,MAAM,EAAE,QAAQ,CAAC,OAAO,WAAW,CAK/C,CAAC"}