@cloud-ru/ds-list 1.0.0

package/dist/esm/components/Items/utils.d.ts

@@ -0,0 +1,52 @@
+import { ItemContentProps } from '../../helperComponents/index.js';
+import { AccordionItem, BaseItem, FlattenItem, FlattenSimpleItem, FocusFlattenItem, GroupItem, GroupSelectItem, Item, ItemId, NextListItem, ReorderItem, SimpleGroupItem, SimpleItem } from './types.js';
+type FlattenableItem = Item | SimpleItem;
+export declare function isBaseItem<ReturnType = BaseItem>(item: unknown): item is ReturnType;
+export declare function isAccordionItem<ReturnType = AccordionItem>(item: unknown): item is ReturnType;
+export declare function isNextListItem<ReturnType = NextListItem>(item: unknown): item is ReturnType;
+export declare function isGroupItem<ReturnType = GroupItem>(item: unknown): item is ReturnType;
+export declare function isGroupSelectItem<ReturnType = GroupSelectItem>(item: unknown): item is ReturnType;
+export declare function isSimpleItem<ReturnType = FlattenSimpleItem>(item: unknown): item is ReturnType;
+export declare function isReorderGroup(item: ReorderItem): item is SimpleGroupItem;
+export declare function isReorderBaseItem(item: ReorderItem): item is SimpleItem;
+export declare function isContentItem(item: unknown): item is ItemContentProps;
+/**
+ * Примитивный `content` (строка/число) — это шорткат для `{ label: content }`:
+ * такой айтем рендерится через `ItemContent` и получает размерную высоту строки
+ * (`min-height` по `size`), а не схлопывается до высоты текста, как произвольный ReactNode.
+ */
+export declare function isPrimitiveContent(item: unknown): item is string | number;
+export declare const isBaseItemProps: typeof isBaseItem;
+export declare const isAccordionItemProps: typeof isAccordionItem;
+export declare const isNextListItemProps: typeof isNextListItem;
+export declare const isGroupItemProps: typeof isGroupItem;
+export declare const isGroupSelectItemProps: typeof isGroupSelectItem;
+type KindFlattenItemsProps = {
+    items: FlattenableItem[];
+    prefix?: ItemId;
+    parentId?: ItemId;
+    /**
+     * Дерево — `SimpleItem[]` в режиме drag&drop-переупорядочивания (`onItemsReorder`): каждый
+     * узел (лист и контейнер) размечается `type: ITEM_TYPE.Simple`, чтобы `getRenderItems` рендерил
+     * его через сортируемую обёртку, а `extractActiveItems` — считал всегда «развёрнутым».
+     */
+    sortable?: boolean;
+};
+export declare function kindFlattenItems({ items, prefix, parentId, sortable }: KindFlattenItemsProps): {
+    focusCloseChildIds: ItemId[];
+    allChildIds: ItemId[];
+    flattenItems: Record<string, FlattenItem>;
+    focusFlattenItems: Record<string, FocusFlattenItem>;
+};
+type ExtractActiveItemsProps = {
+    focusFlattenItems: Record<string, FocusFlattenItem>;
+    focusCloseChildIds: ItemId[];
+    openCollapseItems: ItemId[];
+    isSelectionMultiple?: boolean;
+};
+type ExtractActiveItemsReturnType = {
+    ids: ItemId[];
+    expandedIds: ItemId[];
+};
+export declare function extractActiveItems({ focusFlattenItems, focusCloseChildIds, openCollapseItems, isSelectionMultiple, }: ExtractActiveItemsProps): ExtractActiveItemsReturnType;
+export {};

package/dist/esm/components/Items/utils.js

@@ -0,0 +1,203 @@
+import { createRef } from 'react';
+import { ITEM_PREFIXES, ITEM_TYPE } from '../../constants.js';
+import { getItemAutoId } from '../../utils.js';
+function isRecord(item) {
+    return typeof item === 'object' && item !== null;
+}
+export function isBaseItem(item) {
+    return isRecord(item) && !('items' in item);
+}
+export function isAccordionItem(item) {
+    return isRecord(item) && 'items' in item && item['type'] === ITEM_TYPE.Collapse;
+}
+export function isNextListItem(item) {
+    return isRecord(item) && 'items' in item && item['type'] === ITEM_TYPE.NextList;
+}
+export function isGroupItem(item) {
+    return isRecord(item) && 'items' in item && item['type'] === ITEM_TYPE.Group;
+}
+export function isGroupSelectItem(item) {
+    return isRecord(item) && 'items' in item && item['type'] === ITEM_TYPE.GroupSelect;
+}
+// В отличие от остальных `is<Kind>Item`, не требует `'items' in item` — `Simple`-айтемы без
+// вложенности (листья) тоже размечаются `type: ITEM_TYPE.Simple` в `kindFlattenItems`.
+export function isSimpleItem(item) {
+    return isRecord(item) && item['type'] === ITEM_TYPE.Simple;
+}
+// Гарды для «сырого» дерева reorder-режима (payload `onItemsReorder`): группа `SimpleGroupItem`
+// несёт `type: Group`, строка `SimpleItem` — без `type`. Отличаются от `isSimpleItem` (он смотрит
+// `type: Simple`, проставляемый только при уплощении через `kindFlattenItems`), поэтому на payload'е
+// `onItemsReorder` использовать нужно именно эти.
+export function isReorderGroup(item) {
+    return 'type' in item && item.type === ITEM_TYPE.Group;
+}
+export function isReorderBaseItem(item) {
+    return !isReorderGroup(item);
+}
+export function isContentItem(item) {
+    return isRecord(item) && item['label'] !== undefined;
+}
+/**
+ * Примитивный `content` (строка/число) — это шорткат для `{ label: content }`:
+ * такой айтем рендерится через `ItemContent` и получает размерную высоту строки
+ * (`min-height` по `size`), а не схлопывается до высоты текста, как произвольный ReactNode.
+ */
+export function isPrimitiveContent(item) {
+    return typeof item === 'string' || typeof item === 'number';
+}
+// Публичные дискриминаторы пропсов айтемов (документированы в README, потребитель
+// сужает union `Item` по типу). Внутри пакета используются короткие формы `isBaseItem`
+// и т.д.; наружу отдаём `is<Kind>Props`, как в публичном API типов (`<Kind>Props`).
+export const isBaseItemProps = isBaseItem;
+export const isAccordionItemProps = isAccordionItem;
+export const isNextListItemProps = isNextListItem;
+export const isGroupItemProps = isGroupItem;
+export const isGroupSelectItemProps = isGroupSelectItem;
+export function kindFlattenItems({ items, prefix, parentId, sortable }) {
+    const flattenItems = {};
+    const focusFlattenItems = {};
+    function flatten({ item, idx, prefix, parentId = ITEM_PREFIXES.default }) {
+        const autoId = prefix !== undefined ? getItemAutoId(prefix, idx) : String(idx);
+        // В reorder-режиме (`sortable`) группа несёт собственный `id` (нужен `@dnd-kit` как identity
+        // для перестановки групп) — используется он. Обычная (не сортируемая) группа `id` не имеет — `autoId`.
+        const itemId = (isGroupItem(item) && !sortable ? undefined : item.id) ?? autoId;
+        if (isBaseItem(item)) {
+            // `type` добавляется в `flattenItems` только в `sortable`-режиме: другой код (например,
+            // `useGroupItemSelection`) отличает базовые айтемы от контейнерных через `!('type' in item)`,
+            // а не по значению — присутствие ключа `type: undefined` уже сломало бы эту проверку.
+            flattenItems[itemId] = {
+                ...item,
+                items: [],
+                allChildIds: [],
+                id: itemId,
+                ...(sortable ? { type: ITEM_TYPE.Simple } : {}),
+            };
+            focusFlattenItems[autoId] = {
+                // React key = `itemId`, не `autoId`. `autoId` — позиционный путь в focus-дереве
+                // (`default-0`, `default-1`, …): при `onItemsReorder` путь остаётся на месте, а данные
+                // под ним меняются. Ключ по позиции оставляет тот же инстанс (`Switch` и т.п.) в слоте
+                // и проигрывает transition на смене `checked` — `Switch` визуально «переезжает».
+                key: itemId,
+                originalId: itemId,
+                id: autoId,
+                // `inactive` элемент выпадает из клавиатурной навигации наравне с `disabled`
+                // (см. JSDoc `BaseItem.inactive`). Гейтит только nav/bulk-select через
+                // `extractActiveItems`; рендерный `disabled` в `flattenItems` остаётся исходным.
+                disabled: item.disabled || item.inactive,
+                parentId,
+                items: [],
+                allChildIds: [],
+                itemRef: item.itemRef || createRef(),
+                type: sortable ? ITEM_TYPE.Simple : undefined,
+            };
+            return { id: itemId, children: [itemId], autoId, focusChildren: [autoId] };
+        }
+        let allChildIds = [];
+        let allFocusChildIds = [];
+        const closeChildIds = [];
+        const autoChildIds = [];
+        const { items, ...rest } = item;
+        const childActiveParent = isGroupItem(item) ? (parentId ?? ITEM_PREFIXES.default) : autoId;
+        const filteredItems = items.filter(item => !item.hidden);
+        for (let idx = 0; idx < filteredItems.length; idx++) {
+            const { id, children, autoId, focusChildren } = flatten({
+                item: filteredItems[idx],
+                idx,
+                prefix: itemId,
+                parentId: childActiveParent,
+            });
+            autoChildIds.push(autoId);
+            closeChildIds.push(id);
+            allChildIds = allChildIds.concat(children);
+            allFocusChildIds = allFocusChildIds.concat(focusChildren);
+        }
+        const children = [...new Set(allChildIds.concat(closeChildIds))];
+        const focusChildren = [...new Set(allFocusChildIds.concat(autoChildIds))];
+        flattenItems[itemId] = {
+            ...rest,
+            id: itemId,
+            items: [],
+            allChildIds: children,
+        };
+        // При `sortable` дерево в рантайме целиком `SimpleItem[]`, но статический тип этого не выражает
+        // (структурно совпадает с `BaseItem`) — отсюда каст к `SimpleItem` за `disabled`.
+        const containerDisabled = sortable
+            ? item.disabled
+            : (item.type === ITEM_TYPE.Collapse || item.type === ITEM_TYPE.NextList) && item.disabled;
+        focusFlattenItems[autoId] = {
+            // См. комментарий у листового `key` выше — стабильная identity, не позиционный autoId.
+            key: autoId + '_' + itemId,
+            originalId: itemId,
+            id: autoId,
+            parentId,
+            items: autoChildIds,
+            allChildIds: focusChildren,
+            disabled: containerDisabled,
+            type: item.type,
+            itemRef: !isGroupItem(item) ? (item.itemRef ?? createRef()) : undefined,
+        };
+        return { id: itemId, children, autoId, focusChildren };
+    }
+    const closeChildIds = [];
+    const autoChildIds = [];
+    let allChildIds = [];
+    const filteredItems = items.filter(item => !item.hidden);
+    for (let idx = 0; idx < filteredItems.length; idx++) {
+        const { id, children, autoId } = flatten({ item: filteredItems[idx], idx, prefix, parentId });
+        autoChildIds.push(autoId);
+        closeChildIds.push(id);
+        allChildIds.push(id);
+        allChildIds = allChildIds.concat(children);
+    }
+    const children = [...new Set(allChildIds)];
+    return {
+        focusCloseChildIds: autoChildIds,
+        allChildIds: children,
+        flattenItems,
+        focusFlattenItems,
+    };
+}
+export function extractActiveItems({ focusFlattenItems, focusCloseChildIds, openCollapseItems, isSelectionMultiple, }) {
+    const ids = [];
+    const expandedIds = [];
+    function internalFn(focusCloseChildIds) {
+        focusCloseChildIds.forEach(id => {
+            const child = focusFlattenItems[id];
+            if (child.type === ITEM_TYPE.Group) {
+                internalFn(child.items);
+                return;
+            }
+            // `Simple` (drag&drop-переупорядочивание, `onItemsReorder`) не имеет collapse-состояния —
+            // строка всегда «развёрнута»: сама участвует в навигации (если не disabled) и рекурсия в
+            // детей идёт безусловно, в отличие от `Collapse`/`NextList` ниже (гейт `openCollapseItems`).
+            if (child.type === ITEM_TYPE.Simple) {
+                if (!child.disabled) {
+                    ids.push(child.id);
+                    internalFn(child.items);
+                }
+                return;
+            }
+            if (!child.disabled) {
+                if (child.type === ITEM_TYPE.GroupSelect) {
+                    if (isSelectionMultiple) {
+                        ids.push(child.id);
+                    }
+                    internalFn(child.items);
+                    return;
+                }
+                ids.push(child.id);
+                if (child.type) {
+                    expandedIds.push(id);
+                    if (openCollapseItems.includes(child.originalId)) {
+                        internalFn(child.items);
+                    }
+                }
+            }
+        });
+    }
+    internalFn(focusCloseChildIds);
+    return {
+        ids,
+        expandedIds,
+    };
+}

package/dist/esm/components/Lists/Droplist/DropList.d.ts

@@ -0,0 +1,21 @@
+import { DroplistProps, ReorderableDroplistProps } from '../types.js';
+/**
+ * Адаптивный `Droplist`: раскладку берёт из `AdaptiveProvider` (контекст). На `mobile` рендерит
+ * список (size `l`) в `BottomSheet` (`MobileDroplist`), иначе — анкорный popover (`DesktopDroplist`).
+ * Слоты `label` / `actionButton` / `slotAfterTitle` / `onBackButtonClick` применяются только на mobile.
+ * Чтобы всегда был popover — `withLayoutType(Droplist, 'desktop')` либо вложенный
+ * `<AdaptiveProvider layoutType='desktop'>`. Пропа `layoutType` у компонента нет.
+ */
+export declare function Droplist(props: DroplistProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace Droplist {
+    var displayName: string;
+}
+/**
+ * Адаптивный `Droplist` с drag&drop-переупорядочиванием строк (см. `ReorderableList`): управляемый
+ * порядок через `onItemsReorder`, модель айтемов — `ReorderItem`, виртуализации нет. Раскладку и
+ * mobile-слоты берёт из `Droplist`.
+ */
+export declare function ReorderableDroplist(props: ReorderableDroplistProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace ReorderableDroplist {
+    var displayName: string;
+}

package/dist/esm/components/Lists/Droplist/DropList.js

@@ -0,0 +1,32 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { isMobileLayout, useAdaptiveLayout } from '@cloud-ru/ds-adaptive';
+import { DesktopDroplist } from '../../../helperComponents/DesktopDroplist/index.js';
+import { MobileDroplist } from '../../../helperComponents/MobileDroplist/index.js';
+/** @internal Общая реализация `Droplist`/`ReorderableDroplist`: свап поверхности по раскладке. */
+function DroplistImpl({ children, size = 'm', label, actionButton, slotAfterTitle, onBackButtonClick, ...rest }) {
+    const { layoutType } = useAdaptiveLayout();
+    if (isMobileLayout(layoutType)) {
+        return (_jsx(MobileDroplist, { ...rest, label: label, actionButton: actionButton, slotAfterTitle: slotAfterTitle, onBackButtonClick: onBackButtonClick, children: children }));
+    }
+    return (_jsx(DesktopDroplist, { ...rest, size: size, children: children }));
+}
+/**
+ * Адаптивный `Droplist`: раскладку берёт из `AdaptiveProvider` (контекст). На `mobile` рендерит
+ * список (size `l`) в `BottomSheet` (`MobileDroplist`), иначе — анкорный popover (`DesktopDroplist`).
+ * Слоты `label` / `actionButton` / `slotAfterTitle` / `onBackButtonClick` применяются только на mobile.
+ * Чтобы всегда был popover — `withLayoutType(Droplist, 'desktop')` либо вложенный
+ * `<AdaptiveProvider layoutType='desktop'>`. Пропа `layoutType` у компонента нет.
+ */
+export function Droplist(props) {
+    return _jsx(DroplistImpl, { ...props });
+}
+Droplist.displayName = 'Droplist';
+/**
+ * Адаптивный `Droplist` с drag&drop-переупорядочиванием строк (см. `ReorderableList`): управляемый
+ * порядок через `onItemsReorder`, модель айтемов — `ReorderItem`, виртуализации нет. Раскладку и
+ * mobile-слоты берёт из `Droplist`.
+ */
+export function ReorderableDroplist(props) {
+    return _jsx(DroplistImpl, { ...props });
+}
+ReorderableDroplist.displayName = 'ReorderableDroplist';

package/dist/esm/components/Lists/Droplist/constants.d.ts

@@ -0,0 +1,8 @@
+import { DropdownProps } from '@cloud-ru/ds-dropdown';
+export declare const DEFAULT_FALLBACK_PLACEMENTS: DropdownProps['fallbackPlacements'];
+/**
+ * Возврат фокуса/фокусировка списка откладывается на следующий тик (0ms),
+ * чтобы дождаться размонтирования/монтирования портала дроплиста.
+ */
+export declare const FOCUS_DEFERRAL_TIMEOUT = 0;
+export declare const DEFAULT_SIZE = "m";

package/dist/esm/components/Lists/Droplist/constants.js

@@ -0,0 +1,7 @@
+export const DEFAULT_FALLBACK_PLACEMENTS = ['top', 'right', 'bottom', 'left'];
+/**
+ * Возврат фокуса/фокусировка списка откладывается на следующий тик (0ms),
+ * чтобы дождаться размонтирования/монтирования портала дроплиста.
+ */
+export const FOCUS_DEFERRAL_TIMEOUT = 0;
+export const DEFAULT_SIZE = 'm';

package/dist/esm/components/Lists/Droplist/index.d.ts

@@ -0,0 +1 @@
+export * from './DropList.js';

package/dist/esm/components/Lists/Droplist/index.js

@@ -0,0 +1 @@
+export * from './DropList.js';

package/dist/esm/components/Lists/List/List.d.ts

@@ -0,0 +1,61 @@
+import { KeyboardEvent } from 'react';
+/** Список айтемов: base / collapse / group / next-list, с опциональной виртуализацией. */
+export declare const List: import("react").ForwardRefExoticComponent<{
+    'data-test-id'?: string;
+} & import("react").AriaAttributes & {
+    pinTop?: import("../..").Item[];
+    pinBottom?: import("../..").Item[];
+    footer?: import("react").ReactNode;
+    header?: import("react").ReactNode;
+    headerDivider?: boolean;
+    footerDivider?: boolean;
+    footerActiveElementsRefs?: import("react").RefObject<HTMLElement>[];
+    keyboardNavigationRef?: import("react").RefObject<{
+        focusItem(id: import("../..").ItemId): void;
+    }>;
+    search?: import("../../..").SearchState;
+    tabIndex?: number;
+    collapse?: import("..").CollapseState;
+    className?: string;
+    loading?: boolean;
+    onKeyDown?(e: KeyboardEvent<HTMLElement>): void;
+    hasListInFocusChain?: boolean;
+    scrollToSelectedItem?: boolean;
+    scrollContainerClassName?: string;
+    limitedScrollHeight?: boolean;
+} & import("..").SelectionState & Omit<import("..").PublicListContextType, "virtualized"> & import("../../..").ScrollProps & import("..").EmptyState & {
+    items: import("../..").Item[];
+    virtualized?: boolean;
+} & import("react").RefAttributes<HTMLElement>>;
+/**
+ * Список с drag&drop-переупорядочиванием строк за ручку слева. Управляемый: порядок не хранит,
+ * а отдаёт обновлённое дерево в `onItemsReorder`. Модель айтемов — `ReorderItem` (плоская строка
+ * либо группа с заголовком); `collapse`/`next-list`/`group-select` и виртуализация не поддержаны.
+ */
+export declare const ReorderableList: import("react").ForwardRefExoticComponent<{
+    'data-test-id'?: string;
+} & import("react").AriaAttributes & {
+    pinTop?: import("../..").Item[];
+    pinBottom?: import("../..").Item[];
+    footer?: import("react").ReactNode;
+    header?: import("react").ReactNode;
+    headerDivider?: boolean;
+    footerDivider?: boolean;
+    footerActiveElementsRefs?: import("react").RefObject<HTMLElement>[];
+    keyboardNavigationRef?: import("react").RefObject<{
+        focusItem(id: import("../..").ItemId): void;
+    }>;
+    search?: import("../../..").SearchState;
+    tabIndex?: number;
+    collapse?: import("..").CollapseState;
+    className?: string;
+    loading?: boolean;
+    onKeyDown?(e: KeyboardEvent<HTMLElement>): void;
+    hasListInFocusChain?: boolean;
+    scrollToSelectedItem?: boolean;
+    scrollContainerClassName?: string;
+    limitedScrollHeight?: boolean;
+} & import("..").SelectionState & Omit<import("..").PublicListContextType, "virtualized"> & import("../../..").ScrollProps & import("..").EmptyState & {
+    items: import("../..").ReorderItem[];
+    onItemsReorder(items: import("../..").ReorderItem[]): void;
+} & import("react").RefAttributes<HTMLElement>>;

package/dist/esm/components/Lists/List/List.js

@@ -0,0 +1,56 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { isBrowser } from '@cloud-ru/ds-utils';
+import cn from 'classnames';
+import mergeRefs from 'merge-refs';
+import { forwardRef, useCallback, useMemo, useRef } from 'react';
+import { DEFAULT_SIZE } from '../../../constants.js';
+import { HiddenTabButton } from '../../../helperComponents/index.js';
+import { CollapseContext, FocusListContext, NewListContextProvider, SelectionProvider } from '../contexts/index.js';
+import { useListItemsModel, useNewKeyboardNavigation } from '../hooks.js';
+import { ListPrivate } from '../ListPrivate/index.js';
+import styles from '../styles.module.css';
+const ListImpl = forwardRef(({ items: itemsProp = [], search, pinBottom: pinBottomProp = [], pinTop: pinTopProp = [], footerActiveElementsRefs, onKeyDown, tabIndex = 0, className, collapse = {}, selection, contentRender, size = DEFAULT_SIZE, marker = true, keyboardNavigationRef, hasListInFocusChain = true, onItemsReorder, ...props }, ref) => {
+    const { openCollapseItems, toggleOpenCollapseItem, searchItem, flattenItems, focusFlattenItems, memorizedItems, ids, expandedIds, firstItemId, onDragEnd, sortableIds, } = useListItemsModel({
+        items: itemsProp,
+        pinTop: pinTopProp,
+        pinBottom: pinBottomProp,
+        search,
+        collapse,
+        selectionMode: selection?.mode,
+        footerActiveElementsRefs,
+        onItemsReorder,
+    });
+    const listRef = useRef(null);
+    const btnRef = useRef(null);
+    const { handleListKeyDownFactory, activeItemId, resetActiveItemId, forceUpdateActiveItemId } = useNewKeyboardNavigation({
+        mainRef: listRef,
+        btnRef,
+        focusFlattenItems,
+        keyboardNavigationRef,
+        hasListInFocusChain,
+        firstItemId,
+    });
+    const handleListKeyDown = useCallback((e) => handleListKeyDownFactory(ids, expandedIds)(e), [handleListKeyDownFactory, ids, expandedIds]);
+    const isActive = isBrowser() && listRef.current === document.activeElement && activeItemId === undefined;
+    const mergedHandlerKeyDown = (e) => {
+        onKeyDown?.(e);
+        handleListKeyDown?.(e);
+    };
+    const handleOnFocus = () => {
+        resetActiveItemId();
+    };
+    const collapseContextValue = useMemo(() => ({ openCollapseItems, toggleOpenCollapseItem }), [openCollapseItems, toggleOpenCollapseItem]);
+    const focusListContextValue = useMemo(() => ({ activeItemId, handleListKeyDownFactory, forceUpdateActiveItemId }), [activeItemId, handleListKeyDownFactory, forceUpdateActiveItemId]);
+    return (_jsx(NewListContextProvider, { flattenItems: flattenItems, focusFlattenItems: focusFlattenItems, contentRender: contentRender, size: size, marker: marker, firstItemId: firstItemId, virtualized: props.virtualized, children: _jsx(SelectionProvider, { ...selection, children: _jsx(CollapseContext.Provider, { value: collapseContextValue, children: _jsx(FocusListContext.Provider, { value: focusListContextValue, children: _jsxs("div", { className: cn(styles.wrapper, className), "data-active": isActive || undefined, children: [_jsx(ListPrivate, { ...props, items: memorizedItems.items.focusCloseChildIds, pinTop: memorizedItems.pinTop.focusCloseChildIds, pinBottom: memorizedItems.pinBottom.focusCloseChildIds, searchItem: searchItem, ref: mergeRefs(ref, listRef), onFocus: handleOnFocus, onKeyDown: mergedHandlerKeyDown, tabIndex: hasListInFocusChain ? tabIndex : undefined, search: search, nested: false, onDragEnd: onDragEnd, sortableIds: sortableIds }), hasListInFocusChain && _jsx(HiddenTabButton, { ref: btnRef, listRef: listRef, tabIndex: tabIndex })] }) }) }) }) }));
+});
+ListImpl.displayName = 'ListImpl';
+/** Список айтемов: base / collapse / group / next-list, с опциональной виртуализацией. */
+export const List = forwardRef((props, ref) => _jsx(ListImpl, { ...props, ref: ref }));
+List.displayName = 'List';
+/**
+ * Список с drag&drop-переупорядочиванием строк за ручку слева. Управляемый: порядок не хранит,
+ * а отдаёт обновлённое дерево в `onItemsReorder`. Модель айтемов — `ReorderItem` (плоская строка
+ * либо группа с заголовком); `collapse`/`next-list`/`group-select` и виртуализация не поддержаны.
+ */
+export const ReorderableList = forwardRef((props, ref) => (_jsx(ListImpl, { ...props, ref: ref })));
+ReorderableList.displayName = 'ReorderableList';

package/dist/esm/components/Lists/List/index.d.ts

@@ -0,0 +1 @@
+export * from './List.js';

package/dist/esm/components/Lists/List/index.js

@@ -0,0 +1 @@
+export * from './List.js';

package/dist/esm/components/Lists/ListPrivate/ListPrivate.d.ts

@@ -0,0 +1,18 @@
+import { DragEndEvent } from '@dnd-kit/core';
+import { ItemId } from '../../Items/index.js';
+export declare const ListPrivate: import("react").ForwardRefExoticComponent<Omit<import("..").ListImplProps, "items" | "virtualized" | "hasListInFocusChain" | "pinTop" | "pinBottom" | "onItemsReorder"> & {
+    nested?: boolean;
+    active?: boolean;
+    tabIndex?: number;
+    virtualized?: boolean;
+    onFocus?(e: import("react").FocusEvent<HTMLElement>): void;
+    onBlur?(e: import("react").FocusEvent<HTMLElement>): void;
+    onKeyDown?(e: import("react").KeyboardEvent<HTMLElement>): void;
+    limitedScrollHeight?: boolean;
+    searchItem?: import("../..").FlattenBaseItem;
+    pinTop?: ItemId[];
+    items: ItemId[];
+    pinBottom?: ItemId[];
+    onDragEnd?(event: DragEndEvent): void;
+    sortableIds?: ItemId[];
+} & import("react").RefAttributes<HTMLElement>>;