@ozen-ui/kit 0.70.0 → 0.71.1

package/__inner__/cjs/components/DataListBase/hooks/useDataListBaseControls/useDataListBaseControls.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useDataListBaseControls = void 0;
+var react_1 = require("react");
+var getNextIndex_1 = require("../../../../utils/getNextIndex");
+var getPrevIndex_1 = require("../../../../utils/getPrevIndex");
+var isKey_1 = require("../../../../utils/isKey");
+var isKeys_1 = require("../../../../utils/isKeys");
+var utils_1 = require("../../utils");
+var useDataListBaseControls = function (_a) {
+    var active = _a.active, valueControl = _a.valueControl, optionsStore = _a.optionsStore;
+    var findOption = function (value) {
+        var _a, _b;
+        if (value === null) {
+            return null;
+        }
+        var lastId = (0, utils_1.lastSelectedValue)(value !== null && value !== void 0 ? value : null);
+        return ((_b = (_a = optionsStore.options.current.find(function (option) { return option.id === lastId; })) === null || _a === void 0 ? void 0 : _a.id) !== null && _b !== void 0 ? _b : null);
+    };
+    (0, react_1.useEffect)(function () {
+        var _a, _b;
+        if (!active) {
+            return;
+        }
+        optionsStore.setFocused(findOption(optionsStore.focused.current));
+        optionsStore.setCurrentOption(valueControl.value
+            ? findOption((0, utils_1.lastSelectedValue)(valueControl.value))
+            : (_b = (_a = optionsStore.options.current[0]) === null || _a === void 0 ? void 0 : _a.id) !== null && _b !== void 0 ? _b : null);
+    }, [active]);
+    // Сброс
+    (0, react_1.useEffect)(function () {
+        if (!active) {
+            return undefined;
+        }
+        return function () {
+            optionsStore.setFocused(null);
+            optionsStore.setCurrentOption(null);
+        };
+    }, [active]);
+    var onKeyDown = function (event) {
+        var _a, _b, _c;
+        if (!active || !(0, isKeys_1.isKeys)(event, ['Enter', 'ArrowUp', 'ArrowDown'])) {
+            return;
+        }
+        var currentOption = (_a = optionsStore.focused.current) !== null && _a !== void 0 ? _a : optionsStore.currentOption.current;
+        if ((0, isKey_1.isKey)(event, 'Enter')) {
+            // Не обрабатываем ввод в пустом списке
+            if (!optionsStore.options.current.length) {
+                return;
+            }
+            if (!currentOption) {
+                return;
+            }
+            var optionFullInfo = optionsStore.getOptionFullInfo(currentOption);
+            if (!optionFullInfo || optionFullInfo.disabled) {
+                return;
+            }
+            event.preventDefault();
+            optionsStore.setFocused(optionFullInfo.id);
+            optionsStore.setCurrentOption(optionFullInfo.id);
+            valueControl.setValue(event, optionFullInfo.id);
+        }
+        if ((0, isKeys_1.isKeys)(event, ['ArrowUp', 'ArrowDown'])) {
+            event.preventDefault();
+            var availableOptions = optionsStore.availableOptions.current;
+            var currentIndex = currentOption
+                ? (0, utils_1.getOptionIndex)(availableOptions, currentOption)
+                : null;
+            var isArrowUp = (0, isKey_1.isKey)(event, 'ArrowUp');
+            var newIndex = isArrowUp
+                ? (0, getPrevIndex_1.getPrevIndex)(currentIndex !== null && currentIndex !== void 0 ? currentIndex : 0, availableOptions.length)
+                : (0, getNextIndex_1.getNextIndex)(currentIndex !== null && currentIndex !== void 0 ? currentIndex : -1, availableOptions.length);
+            var newItem = (_c = (_b = availableOptions[newIndex]) === null || _b === void 0 ? void 0 : _b.id) !== null && _c !== void 0 ? _c : null;
+            optionsStore.setFocused(newItem);
+        }
+    };
+    return { onKeyDown: onKeyDown };
+};
+exports.useDataListBaseControls = useDataListBaseControls;

package/__inner__/cjs/components/DataListBase/hooks/useDataListBaseEvents/index.d.ts

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

package/__inner__/cjs/components/DataListBase/hooks/useDataListBaseEvents/index.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./useDataListBaseEvents"), exports);

package/__inner__/cjs/components/DataListBase/hooks/useDataListBaseEvents/useDataListBaseEvents.d.ts

@@ -0,0 +1,8 @@
+import type { RefObject } from 'react';
+import type { DataListBaseControlsControl } from '../useDataListBaseControls';
+export declare const useDataListBaseEvents: ({ container, onClose, active, controlsControl, }: {
+    container: RefObject<HTMLElement>;
+    onClose: (() => void) | undefined;
+    active: boolean;
+    controlsControl: DataListBaseControlsControl;
+}) => void;

package/__inner__/cjs/components/DataListBase/hooks/useDataListBaseEvents/useDataListBaseEvents.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useDataListBaseEvents = void 0;
+var useEventListener_1 = require("../../../../hooks/useEventListener");
+var isKey_1 = require("../../../../utils/isKey");
+var useDataListBaseEvents = function (_a) {
+    var container = _a.container, onClose = _a.onClose, active = _a.active, controlsControl = _a.controlsControl;
+    // Назначает элементу контроля событие управления списком с клавиатуры
+    (0, useEventListener_1.useEventListener)({
+        eventName: 'keydown',
+        element: container,
+        active: active,
+        handler: function (event) {
+            controlsControl.onKeyDown(event);
+        },
+    });
+    // Закрывает список по нажатию на клавишу {Tab}
+    (0, useEventListener_1.useEventListener)({
+        active: active,
+        eventName: 'keydown',
+        element: container,
+        handler: function (event) {
+            if ((0, isKey_1.isKey)(event, 'Tab')) {
+                onClose === null || onClose === void 0 ? void 0 : onClose();
+            }
+        },
+    });
+};
+exports.useDataListBaseEvents = useDataListBaseEvents;

package/__inner__/cjs/components/DataListBase/hooks/useDataListBaseOptions/index.d.ts

@@ -0,0 +1,2 @@
+export * from './useDataListBaseOptions';
+export * from './types';

package/__inner__/cjs/components/DataListBase/hooks/useDataListBaseOptions/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./useDataListBaseOptions"), exports);
+tslib_1.__exportStar(require("./types"), exports);

package/__inner__/cjs/components/DataListBase/hooks/useDataListBaseOptions/types.d.ts

@@ -0,0 +1,7 @@
+import type { DataListBaseInternalOption } from '../../entities';
+export type DataListBaseOptionsIsFocused = (option: DataListBaseInternalOption) => boolean;
+export type DataListBaseOptionsIsSelected = (option: DataListBaseInternalOption) => boolean;
+export type DataListBaseOptionsControl = {
+    isFocused: DataListBaseOptionsIsFocused;
+    isSelected: DataListBaseOptionsIsSelected;
+};

package/__inner__/cjs/components/DataListBase/hooks/useDataListBaseOptions/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/__inner__/cjs/components/DataListBase/hooks/useDataListBaseOptions/useDataListBaseOptions.d.ts

@@ -0,0 +1,8 @@
+import type { DataListBaseOptionsStore } from '../useDataListBaseOptionsStore';
+import type { DataListBaseValueControl } from '../useDataListBaseValue';
+import type { DataListBaseOptionsControl } from './types';
+export declare const useDataListBaseOptions: <Multiple extends boolean>({ optionsStore, valueControl, multiple, }: {
+    optionsStore: DataListBaseOptionsStore;
+    valueControl: DataListBaseValueControl<Multiple>;
+    multiple: boolean;
+}) => DataListBaseOptionsControl;

package/__inner__/cjs/components/DataListBase/hooks/useDataListBaseOptions/useDataListBaseOptions.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useDataListBaseOptions = void 0;
+var utils_1 = require("../../utils");
+var useDataListBaseOptions = function (_a) {
+    var optionsStore = _a.optionsStore, valueControl = _a.valueControl, multiple = _a.multiple;
+    var isSelected = function (option) {
+        var _a, _b;
+        if ((0, utils_1.isMultipleInternalValue)(valueControl.value, multiple)) {
+            return ((_b = (_a = valueControl.value) === null || _a === void 0 ? void 0 : _a.some(function (selectedId) { return selectedId === option.id; })) !== null && _b !== void 0 ? _b : false);
+        }
+        return valueControl.value === option.id;
+    };
+    var isFocused = function (option) {
+        return option.id === optionsStore.focused.current;
+    };
+    return {
+        isFocused: isFocused,
+        isSelected: isSelected,
+    };
+};
+exports.useDataListBaseOptions = useDataListBaseOptions;

package/__inner__/cjs/components/DataListBase/hooks/useDataListBaseOptionsStore/index.d.ts

@@ -0,0 +1,2 @@
+export * from './useDataListBaseOptionsStore';
+export * from './types';

package/__inner__/cjs/components/DataListBase/hooks/useDataListBaseOptionsStore/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./useDataListBaseOptionsStore"), exports);
+tslib_1.__exportStar(require("./types"), exports);

package/__inner__/cjs/components/DataListBase/hooks/useDataListBaseOptionsStore/types.d.ts

@@ -0,0 +1,22 @@
+import type { StoredValue } from '../../../../hooks/useStoredValue';
+import type { DataListBaseInternalOption, DataListBaseOption, DataListBaseOptionId } from '../../entities';
+export type DataListBaseInternalOptionById = Record<DataListBaseOptionId, DataListBaseInternalOption>;
+export type DataListBaseRegisterOption = (option: DataListBaseInternalOption) => void;
+export type DataListBaseUnregisterOption = (option: DataListBaseInternalOption) => void;
+export type DataListBaseGetOptionIndex = (id: DataListBaseOptionId) => number | null;
+export type DataListBaseSetFocusedOption = (id: DataListBaseOptionId | null) => void;
+export type DataListBaseSetCurrentOption = (id: DataListBaseOptionId | null) => void;
+export type DataListBaseGetOptionFullInfo = (id: DataListBaseOptionId) => DataListBaseInternalOption | null;
+export type DataListBaseOptionsStore = {
+    availableOptions: StoredValue<DataListBaseOption[]>;
+    options: StoredValue<DataListBaseOption[]>;
+    focused: StoredValue<DataListBaseOptionId | null>;
+    setFocused: DataListBaseSetFocusedOption;
+    currentOption: StoredValue<DataListBaseOptionId | null>;
+    setCurrentOption: DataListBaseSetCurrentOption;
+    registerOption: DataListBaseRegisterOption;
+    unregisterOption: DataListBaseUnregisterOption;
+    getOptionIndex: DataListBaseGetOptionIndex;
+    getOptionFullInfo: DataListBaseGetOptionFullInfo;
+    hasOptions: boolean;
+};

package/__inner__/cjs/components/DataListBase/hooks/useDataListBaseOptionsStore/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/__inner__/cjs/components/DataListBase/hooks/useDataListBaseOptionsStore/useDataListBaseOptionsStore.d.ts

@@ -0,0 +1,3 @@
+import type { ReactNode } from 'react';
+import type { DataListBaseOptionsStore } from './types';
+export declare const useDataListBaseOptionsStore: (children: ReactNode) => DataListBaseOptionsStore;

package/__inner__/cjs/components/DataListBase/hooks/useDataListBaseOptionsStore/useDataListBaseOptionsStore.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useDataListBaseOptionsStore = void 0;
+var useRerender_1 = require("../../../../hooks/useRerender");
+var useStoredValue_1 = require("../../../../hooks/useStoredValue");
+var react_1 = require("../../../../utils/react");
+var utils_1 = require("../../utils");
+var useDataListBaseOptionsStore = function (children) {
+    var rerender = (0, useRerender_1.useRerender)();
+    var focused = (0, useStoredValue_1.useStoredValue)(null);
+    var currentOption = (0, useStoredValue_1.useStoredValue)(null);
+    var setFocused = function (option) {
+        focused.current = option;
+        rerender();
+    };
+    var setCurrent = function (option) {
+        currentOption.current = option;
+        rerender();
+    };
+    var registeredOptions = (0, useStoredValue_1.useStoredValue)({});
+    var options = (0, useStoredValue_1.useStoredValue)([]);
+    var availableOptions = (0, useStoredValue_1.useStoredValue)([]);
+    options.current = [];
+    availableOptions.current = [];
+    (0, react_1.extractElementsFromChildren)((0, react_1.resolveChildren)(children), utils_1.isDataListBaseItem, function (element) {
+        var _a;
+        var option = {
+            id: element.props.listId,
+            disabled: (_a = element.props.disabled) !== null && _a !== void 0 ? _a : false,
+        };
+        options.current.push(option);
+        if (!option.disabled) {
+            availableOptions.current.push(option);
+        }
+    });
+    var getOptionIndex = function (id) {
+        return (0, utils_1.getOptionIndex)(options.current, id);
+    };
+    var registerOption = function (option) {
+        registeredOptions.current[option.id] = option;
+    };
+    var unregisterOption = function (option) {
+        delete registeredOptions.current[option.id];
+    };
+    var getOptionFullInfo = function (id) { var _a; return (_a = registeredOptions.current[id]) !== null && _a !== void 0 ? _a : null; };
+    var hasOptions = options.current.length > 0;
+    return {
+        availableOptions: availableOptions,
+        options: options,
+        focused: focused,
+        setFocused: setFocused,
+        currentOption: currentOption,
+        setCurrentOption: setCurrent,
+        getOptionIndex: getOptionIndex,
+        registerOption: registerOption,
+        unregisterOption: unregisterOption,
+        getOptionFullInfo: getOptionFullInfo,
+        hasOptions: hasOptions,
+    };
+};
+exports.useDataListBaseOptionsStore = useDataListBaseOptionsStore;

package/__inner__/cjs/components/DataListBase/hooks/useDataListBaseScroll/index.d.ts

@@ -0,0 +1,2 @@
+export * from './useDataListBaseScroll';
+export * from './types';

package/__inner__/cjs/components/DataListBase/hooks/useDataListBaseScroll/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./useDataListBaseScroll"), exports);
+tslib_1.__exportStar(require("./types"), exports);

package/__inner__/cjs/components/DataListBase/hooks/useDataListBaseScroll/types.d.ts

@@ -0,0 +1,5 @@
+import type { DataListBaseOptionId } from '../../entities';
+export type DataListBaseScrollToOption = (optionId: DataListBaseOptionId) => void;
+export type DataListBaseScrollControl = {
+    scrollToOption: DataListBaseScrollToOption;
+};

package/__inner__/cjs/components/DataListBase/hooks/useDataListBaseScroll/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/__inner__/cjs/components/DataListBase/hooks/useDataListBaseScroll/useDataListBaseScroll.d.ts

@@ -0,0 +1,10 @@
+import type { RefObject } from 'react';
+import type { DataListBaseOptionsStore } from '../useDataListBaseOptionsStore';
+import type { DataListBaseValueControl } from '../useDataListBaseValue';
+import type { DataListBaseScrollControl } from './types';
+export declare const useDataListBaseScroll: ({ dataListRef, valueControl, active, optionsStore, }: {
+    dataListRef: RefObject<HTMLElement>;
+    valueControl: DataListBaseValueControl<boolean>;
+    active: boolean;
+    optionsStore: DataListBaseOptionsStore;
+}) => DataListBaseScrollControl;

package/__inner__/cjs/components/DataListBase/hooks/useDataListBaseScroll/useDataListBaseScroll.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useDataListBaseScroll = void 0;
+var react_1 = require("react");
+var usePrevious_1 = require("../../../../hooks/usePrevious");
+var scrollContainerToElement_1 = require("../../../../utils/scrollContainerToElement");
+var useDataListBaseScroll = function (_a) {
+    var dataListRef = _a.dataListRef, valueControl = _a.valueControl, active = _a.active, optionsStore = _a.optionsStore;
+    var scrollToOption = function (optionId) {
+        var optionInfo = optionsStore.getOptionFullInfo(optionId);
+        if (!optionInfo) {
+            return;
+        }
+        var hasFocusedElement = !!optionsStore.focused.current;
+        (0, scrollContainerToElement_1.scrollContainerToElement)({
+            container: dataListRef.current,
+            element: optionInfo.ref.current,
+            behavior: hasFocusedElement ? 'smooth' : 'instant',
+        });
+    };
+    var previousCurrent = (0, usePrevious_1.usePrevious)(optionsStore.currentOption.current);
+    (0, react_1.useEffect)(function () {
+        var _a;
+        if (!active) {
+            return;
+        }
+        var firstCurrent = previousCurrent === null ? optionsStore.currentOption.current : null;
+        var selected = (_a = optionsStore.focused.current) !== null && _a !== void 0 ? _a : firstCurrent;
+        if (selected !== null) {
+            // Прокрутка списка
+            setTimeout(function () {
+                // Прокрутка списка
+                scrollToOption(selected);
+            });
+        }
+    }, [active, optionsStore.focused.current, valueControl.lastSelected]);
+    return { scrollToOption: scrollToOption };
+};
+exports.useDataListBaseScroll = useDataListBaseScroll;

package/__inner__/cjs/components/DataListBase/hooks/useDataListBaseValue/index.d.ts

@@ -0,0 +1,2 @@
+export * from './useDataListBaseValue';
+export * from './types';

package/__inner__/cjs/components/DataListBase/hooks/useDataListBaseValue/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./useDataListBaseValue"), exports);
+tslib_1.__exportStar(require("./types"), exports);

package/__inner__/cjs/components/DataListBase/hooks/useDataListBaseValue/types.d.ts

@@ -0,0 +1,10 @@
+import type { SyntheticEvent } from 'react';
+import type { DataListBaseOptionId, DataListBaseValue } from '../../entities';
+export type DataListBaseValueControlSetValue = (event: SyntheticEvent | KeyboardEvent | null, option: DataListBaseOptionId | null) => void;
+export type DataListBaseValueControl<Multiple extends boolean> = {
+    value: DataListBaseValue<Multiple> | undefined;
+    setValue: DataListBaseValueControlSetValue;
+    hasValue: boolean;
+    selectedOptionsLength: number;
+    lastSelected: DataListBaseOptionId | null;
+};

package/__inner__/cjs/components/DataListBase/hooks/useDataListBaseValue/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/__inner__/cjs/components/DataListBase/hooks/useDataListBaseValue/useDataListBaseValue.d.ts

@@ -0,0 +1,10 @@
+import type { DataListBaseOnChange, DataListBaseValue } from '../../entities';
+import type { DataListBaseBaseProps } from '../../types';
+import type { DataListBaseValueControl } from './types';
+export declare const useDataListBaseValue: <Multiple extends boolean>({ value: valueProp, defaultValue, onChange: onChangeProp, inProps, multiple, }: {
+    value: DataListBaseValue<Multiple> | undefined;
+    defaultValue: DataListBaseValue<Multiple> | undefined;
+    onChange: DataListBaseOnChange<Multiple>;
+    inProps: DataListBaseBaseProps<Multiple>;
+    multiple: Multiple;
+}) => DataListBaseValueControl<Multiple>;

package/__inner__/cjs/components/DataListBase/hooks/useDataListBaseValue/useDataListBaseValue.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useDataListBaseValue = void 0;
+var tslib_1 = require("tslib");
+var useControlled_1 = require("../../../../hooks/useControlled");
+var isNotNil_1 = require("../../../../utils/isNotNil");
+var utils_1 = require("../../utils");
+var useDataListBaseValue = function (_a) {
+    var _b;
+    var valueProp = _a.value, defaultValue = _a.defaultValue, onChangeProp = _a.onChange, inProps = _a.inProps, multiple = _a.multiple;
+    var _c = tslib_1.__read((0, useControlled_1.useControlled)({
+        value: valueProp === undefined ? undefined : valueProp,
+        defaultValue: defaultValue === undefined ? undefined : defaultValue,
+        name: 'DataListBase',
+        state: 'value',
+    }), 2), valueState = _c[0], setValueState = _c[1];
+    var onChange = function (event, option, changedOption) {
+        setValueState(option);
+        onChangeProp === null || onChangeProp === void 0 ? void 0 : onChangeProp(event, option, changedOption);
+    };
+    var setValue = function (event, optionId) {
+        var _a, _b;
+        if (!optionId) {
+            onChange(event, null, null);
+            return;
+        }
+        var params = tslib_1.__assign(tslib_1.__assign({}, inProps), { onChange: onChange });
+        if ((0, utils_1.isMultipleProps)(params) &&
+            (0, utils_1.isMultipleInternalValue)(valueState, multiple)) {
+            var value_1 = valueState !== null && valueState !== void 0 ? valueState : [];
+            var optionIsAlreadySelected_1 = valueState === null || valueState === void 0 ? void 0 : valueState.find(function (selectedOptionId) { return selectedOptionId === optionId; });
+            var result = (function () {
+                if (optionIsAlreadySelected_1) {
+                    var options_1 = [];
+                    value_1.forEach(function (selectedOption) {
+                        if (selectedOption !== optionId) {
+                            options_1.push(selectedOption);
+                        }
+                    });
+                    return options_1;
+                }
+                if (optionId) {
+                    return tslib_1.__spreadArray(tslib_1.__spreadArray([], tslib_1.__read(value_1), false), [optionId], false);
+                }
+                return tslib_1.__spreadArray([], tslib_1.__read(value_1), false);
+            })();
+            (_a = params.onChange) === null || _a === void 0 ? void 0 : _a.call(params, event, result, optionId);
+            return;
+        }
+        if ((0, utils_1.isSingleProps)(params)) {
+            (_b = params.onChange) === null || _b === void 0 ? void 0 : _b.call(params, event, optionId, optionId);
+        }
+    };
+    var hasValue = (0, utils_1.isMultipleInternalValue)(valueState, multiple)
+        ? !!valueState && valueState.length > 0
+        : (0, isNotNil_1.isNotNil)(valueState);
+    var selectedOptionsLength = (0, utils_1.isMultipleInternalValue)(valueState, multiple)
+        ? (_b = valueState === null || valueState === void 0 ? void 0 : valueState.length) !== null && _b !== void 0 ? _b : 0
+        : 0;
+    var lastSelected = (0, utils_1.lastSelectedValue)(valueState !== null && valueState !== void 0 ? valueState : null);
+    return {
+        value: valueState,
+        setValue: setValue,
+        hasValue: hasValue,
+        selectedOptionsLength: selectedOptionsLength,
+        lastSelected: lastSelected,
+    };
+};
+exports.useDataListBaseValue = useDataListBaseValue;

package/__inner__/cjs/components/DataListBase/index.d.ts

@@ -0,0 +1,7 @@
+export * from './entities';
+export * from './hooks';
+export * from './utils';
+export * from './constants';
+export * from './DataListBase';
+export * from './DataListBaseContext';
+export * from './types';

package/__inner__/cjs/components/DataListBase/index.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./entities"), exports);
+tslib_1.__exportStar(require("./hooks"), exports);
+tslib_1.__exportStar(require("./utils"), exports);
+tslib_1.__exportStar(require("./constants"), exports);
+tslib_1.__exportStar(require("./DataListBase"), exports);
+tslib_1.__exportStar(require("./DataListBaseContext"), exports);
+tslib_1.__exportStar(require("./types"), exports);

package/__inner__/cjs/components/DataListBase/types.d.ts

@@ -0,0 +1,35 @@
+import type { ElementType, ReactElement, ReactNode } from 'react';
+import type { WithRequired } from '../../types/object';
+import type { WithDisplayName } from '../../types/react';
+import type { PolymorphicComponentPropsWithRef, PolymorphicComponentRef } from '../../utils/polymorphicComponentWithRef';
+import type { PopoverBaseProps } from '../Popover';
+import type { DATA_LIST_BASE_DEFAULT_TAG } from './constants';
+import type { DataListBaseOnChange, DataListBaseOptionId, DataListBaseValue } from './entities';
+import type { DataListBaseOptionsStore } from './hooks';
+export type DataListBaseItemProps = {
+    /** Id компонента */
+    listId: DataListBaseOptionId;
+    /** Если `true`, то отключает взаимодействие с компонентом  */
+    disabled?: boolean;
+};
+export type DataListBaseBaseProps<Multiple extends boolean = false> = WithRequired<PopoverBaseProps, 'anchorRef'> & {
+    /** Контент */
+    children: ReactNode;
+    /** Если `true` из списка можно выбрать несколько вариантов */
+    multiple?: Multiple;
+    /** Выбранная или выбранные опции */
+    value?: DataListBaseValue<Multiple>;
+    /** Выбранная опция по умолчанию */
+    defaultValue?: DataListBaseValue<Multiple>;
+    /** Функция обратного вызова для выбора значения */
+    onChange?: DataListBaseOnChange<Multiple>;
+    /** Если `true, отображает загрузку элемента */
+    loading?: boolean;
+    /** Если `true, отключает возможность выбора элементов */
+    disabled?: boolean;
+    /** Внешний store с опциями */
+    optionsStore?: DataListBaseOptionsStore;
+};
+export type DataListBaseRef = PolymorphicComponentRef<typeof DATA_LIST_BASE_DEFAULT_TAG>;
+export type DataListBaseProps<As extends ElementType = typeof DATA_LIST_BASE_DEFAULT_TAG, Multiple extends boolean = false> = PolymorphicComponentPropsWithRef<DataListBaseBaseProps<Multiple>, As>;
+export type DataListBaseComponent = WithDisplayName<(<As extends ElementType = typeof DATA_LIST_BASE_DEFAULT_TAG, Multiple extends boolean = false>(props: PolymorphicComponentPropsWithRef<DataListBaseBaseProps<Multiple>, As>) => ReactElement | null)>;

package/__inner__/cjs/components/DataListBase/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/__inner__/cjs/components/DataListBase/utils/getOptionIndex.d.ts

@@ -0,0 +1,2 @@
+import type { DataListBaseOption, DataListBaseOptionId } from '../entities';
+export declare const getOptionIndex: (options: DataListBaseOption[], id: DataListBaseOptionId) => number | null;

package/__inner__/cjs/components/DataListBase/utils/getOptionIndex.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getOptionIndex = void 0;
+var getOptionIndex = function (options, id) {
+    var index = options.findIndex(function (option) { return option.id === id; });
+    if (index === -1) {
+        return null;
+    }
+    return index;
+};
+exports.getOptionIndex = getOptionIndex;

package/__inner__/cjs/components/DataListBase/utils/index.d.ts

@@ -0,0 +1,6 @@
+export * from './getOptionIndex';
+export * from './isDataListBaseItem';
+export * from './isMultiple';
+export * from './isSelectedValue';
+export * from './isSingle';
+export * from './lastSelectedValue';

package/__inner__/cjs/components/DataListBase/utils/index.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./getOptionIndex"), exports);
+tslib_1.__exportStar(require("./isDataListBaseItem"), exports);
+tslib_1.__exportStar(require("./isMultiple"), exports);
+tslib_1.__exportStar(require("./isSelectedValue"), exports);
+tslib_1.__exportStar(require("./isSingle"), exports);
+tslib_1.__exportStar(require("./lastSelectedValue"), exports);

package/__inner__/cjs/components/DataListBase/utils/isDataListBaseItem.d.ts

@@ -0,0 +1,3 @@
+import type { ReactElement } from 'react';
+import type { DataListBaseItemProps } from '../types';
+export declare const isDataListBaseItem: (child: ReactElement) => child is ReactElement<DataListBaseItemProps>;

package/__inner__/cjs/components/DataListBase/utils/isDataListBaseItem.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isDataListBaseItem = void 0;
+var react_1 = require("../../../utils/react");
+var constants_1 = require("../constants");
+var isDataListBaseItem = function (child) {
+    return (0, react_1.isNodeWithDisplayName)(child, constants_1.DATA_LIST_BASE_ITEM_DISPLAY_NAME);
+};
+exports.isDataListBaseItem = isDataListBaseItem;

package/__inner__/cjs/components/DataListBase/utils/isMultiple.d.ts

@@ -0,0 +1,4 @@
+import type { DataListBaseValue, DataListBaseMultipleValue } from '../entities';
+import type { DataListBaseBaseProps } from '../types';
+export declare const isMultipleProps: (props: DataListBaseBaseProps<boolean>) => props is DataListBaseBaseProps<true>;
+export declare const isMultipleInternalValue: (_: DataListBaseValue<boolean> | undefined, multiple: boolean) => _ is DataListBaseMultipleValue | undefined;

package/__inner__/cjs/components/DataListBase/utils/isMultiple.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isMultipleInternalValue = exports.isMultipleProps = void 0;
+var isMultipleProps = function (props) { return !!props.multiple; };
+exports.isMultipleProps = isMultipleProps;
+var isMultipleInternalValue = function (_, multiple) { return multiple; };
+exports.isMultipleInternalValue = isMultipleInternalValue;

package/__inner__/cjs/components/DataListBase/utils/isSelectedValue.d.ts

@@ -0,0 +1,2 @@
+import type { DataListBaseValue, DataListBaseValueNonNullable } from '../entities';
+export declare const isSelectedValue: <Multiple extends boolean>(selected: DataListBaseValue<Multiple>) => selected is DataListBaseValueNonNullable<Multiple>;

package/__inner__/cjs/components/DataListBase/utils/isSelectedValue.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isSelectedValue = void 0;
+var isSelectedValue = function (selected) { return selected !== null; };
+exports.isSelectedValue = isSelectedValue;

package/__inner__/cjs/components/DataListBase/utils/isSingle.d.ts

@@ -0,0 +1,4 @@
+import type { DataListBaseSingleValue, DataListBaseValue } from '../entities';
+import type { DataListBaseBaseProps } from '../types';
+export declare const isSingleProps: (props: DataListBaseBaseProps<boolean>) => props is DataListBaseBaseProps<false>;
+export declare const isSingleInternalValue: (_: DataListBaseValue<boolean> | undefined, multiple: boolean) => _ is DataListBaseSingleValue | undefined;

package/__inner__/cjs/components/DataListBase/utils/isSingle.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isSingleInternalValue = exports.isSingleProps = void 0;
+var isSingleProps = function (props) { return !props.multiple; };
+exports.isSingleProps = isSingleProps;
+var isSingleInternalValue = function (_, multiple) { return !multiple; };
+exports.isSingleInternalValue = isSingleInternalValue;