@ozen-ui/kit 0.66.0 → 0.68.0

package/__inner__/esm/components/BottomSheetBase/constants.d.ts

@@ -0,0 +1,10 @@
+export declare const BOTTOM_SHEET_BASE_CSS_VARIABLE: {
+    readonly HEIGHT: "bottom-sheet-base-height";
+    readonly OPEN_PERCENT: "bottom-sheet-base-open-percent";
+    readonly Y: "bottom-sheet-base-y";
+    readonly USER_SELECT: "bottom-sheet-base-user-select";
+};
+export type BottomSheetBaseCSSVariable = (typeof BOTTOM_SHEET_BASE_CSS_VARIABLE)[keyof typeof BOTTOM_SHEET_BASE_CSS_VARIABLE];
+export declare const BOTTOM_SHEET_BASE_CLOSABLE = true;
+export declare const BOTTOM_SHEET_BASE_HIDE_BACKDROP = false;
+export declare const BOTTOM_SHEET_BASE_DISABLE_SCROLL_LOCK = false;

package/__inner__/esm/components/BottomSheetBase/constants.js

@@ -0,0 +1,9 @@
+export var BOTTOM_SHEET_BASE_CSS_VARIABLE = {
+    HEIGHT: 'bottom-sheet-base-height',
+    OPEN_PERCENT: 'bottom-sheet-base-open-percent',
+    Y: 'bottom-sheet-base-y',
+    USER_SELECT: 'bottom-sheet-base-user-select',
+};
+export var BOTTOM_SHEET_BASE_CLOSABLE = true;
+export var BOTTOM_SHEET_BASE_HIDE_BACKDROP = false;
+export var BOTTOM_SHEET_BASE_DISABLE_SCROLL_LOCK = false;

package/__inner__/esm/components/BottomSheetBase/context/BottomSheetBaseContext.d.ts

@@ -0,0 +1,3 @@
+import type { BottomSheetBaseContextValue } from '../context';
+export declare const BottomSheetBaseContext: import("react").Context<BottomSheetBaseContextValue>;
+export declare const useBottomSheetBaseContext: () => BottomSheetBaseContextValue;

package/__inner__/esm/components/BottomSheetBase/context/BottomSheetBaseContext.js

@@ -0,0 +1,45 @@
+import { createContext, useContext } from 'react';
+import { IS_DEV } from '../../../constants/environment';
+export var BottomSheetBaseContext = createContext({
+    rootRef: {
+        current: null,
+    },
+    scrollRef: {
+        current: null,
+    },
+    contentRef: {
+        current: null,
+    },
+    blocksRefs: {
+        current: {},
+    },
+    minSnap: 0,
+    maxSnap: 0,
+    defaultSnap: 0,
+    snaps: [],
+    onClose: function () { },
+    isClosable: false,
+    canDrag: {
+        current: true,
+    },
+    snapsControl: {
+        point: {
+            current: 0,
+        },
+        to: function () { },
+        toDefault: function () { },
+        toClosed: function () { },
+        toAnimated: function () { },
+    },
+    findClosestSnap: {
+        current: function () { return 0; },
+    },
+    addBlockRef: function () { },
+});
+export var useBottomSheetBaseContext = function () {
+    return useContext(BottomSheetBaseContext);
+};
+// Именованный провайдер
+if (IS_DEV) {
+    BottomSheetBaseContext.displayName = 'BottomSheetBaseContext';
+}

package/__inner__/esm/components/BottomSheetBase/context/BottomSheetBaseContextProvider.d.ts

@@ -0,0 +1,3 @@
+import React from 'react';
+import type { BottomSheetBaseContextProviderProps } from './types';
+export declare const BottomSheetBaseContextProvider: ({ children, isOpen, snaps: snapsProp, maxHeight: maxHeightProp, defaultSnap: defaultSnapProp, onClose, isClosable, setIsAnimating, }: BottomSheetBaseContextProviderProps) => React.JSX.Element;

package/__inner__/esm/components/BottomSheetBase/context/BottomSheetBaseContextProvider.js

@@ -0,0 +1,78 @@
+import React, { useEffect, useRef } from 'react';
+import { useStoredValue } from '../../../hooks/useStoredValue';
+import { useBottomSheetBaseHeight, useBottomSheetBaseReady, useBottomSheetBaseSnaps, } from '../hooks';
+import { bottomSheetCalculateSnaps } from '../utils';
+import { BottomSheetBaseContext } from './BottomSheetBaseContext';
+export var BottomSheetBaseContextProvider = function (_a) {
+    var children = _a.children, isOpen = _a.isOpen, snapsProp = _a.snaps, maxHeightProp = _a.maxHeight, defaultSnapProp = _a.defaultSnap, onClose = _a.onClose, isClosable = _a.isClosable, setIsAnimating = _a.setIsAnimating;
+    var rootRef = useRef(null);
+    var scrollRef = useRef(null);
+    var contentRef = useRef(null);
+    var blocksRefs = useStoredValue({});
+    var _b = useBottomSheetBaseReady(), isReady = _b.isReady, registerReady = _b.registerReady;
+    var canDrag = useStoredValue(true);
+    var _c = useBottomSheetBaseHeight({
+        customMaxHeight: maxHeightProp,
+        contentRef: contentRef,
+        registerReady: registerReady,
+        blocksRefs: blocksRefs,
+    }), minHeight = _c.minHeight, maxHeight = _c.maxHeight, recalculateHeight = _c.recalculateHeight;
+    var addBlockRef = function (id, instance) {
+        blocksRefs.current[id] = instance;
+        recalculateHeight();
+    };
+    var _d = bottomSheetCalculateSnaps({
+        minHeight: minHeight,
+        maxHeight: maxHeight,
+        isReady: isReady,
+        snaps: snapsProp,
+        defaultSnap: defaultSnapProp,
+    }), minSnap = _d.minSnap, maxSnap = _d.maxSnap, defaultSnap = _d.defaultSnap, snaps = _d.snaps, findClosestSnapFn = _d.findClosestSnap;
+    var findClosestSnap = useStoredValue(function () { return findClosestSnapFn; });
+    useEffect(function () {
+        findClosestSnap.current = findClosestSnapFn;
+    }, [findClosestSnapFn]);
+    var snapsControl = useBottomSheetBaseSnaps({
+        minSnap: minSnap,
+        maxSnap: maxSnap,
+        defaultSnap: defaultSnap,
+        rootRef: rootRef,
+        onAnimationStart: function () {
+            canDrag.current = false;
+            setIsAnimating(true);
+        },
+        onAnimationFinish: function () {
+            canDrag.current = true;
+            setIsAnimating(false);
+        },
+        isReady: isReady,
+        findClosestSnap: findClosestSnap,
+    });
+    useEffect(function () {
+        if (!isReady) {
+            return;
+        }
+        if (isOpen) {
+            snapsControl.toDefault(true);
+        }
+        else {
+            snapsControl.toClosed(true);
+        }
+    }, [isOpen, isReady]);
+    return (React.createElement(BottomSheetBaseContext.Provider, { value: {
+            rootRef: rootRef,
+            contentRef: contentRef,
+            scrollRef: scrollRef,
+            addBlockRef: addBlockRef,
+            blocksRefs: blocksRefs,
+            minSnap: minSnap,
+            maxSnap: maxSnap,
+            snaps: snaps,
+            defaultSnap: defaultSnap !== null && defaultSnap !== void 0 ? defaultSnap : minSnap,
+            onClose: onClose,
+            isClosable: isClosable,
+            canDrag: canDrag,
+            snapsControl: snapsControl,
+            findClosestSnap: findClosestSnap,
+        } }, children));
+};

package/__inner__/esm/components/BottomSheetBase/context/index.d.ts

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

package/__inner__/esm/components/BottomSheetBase/context/index.js

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

package/__inner__/esm/components/BottomSheetBase/context/types.d.ts

@@ -0,0 +1,29 @@
+import type { PropsWithChildren, RefObject } from 'react';
+import type { StoredValue } from '../../../hooks/useStoredValue';
+import type { BottomSheetBaseAddBlockRef, BottomSheetBaseBlocksRefs, BottomSheetBaseContentRef, BottomSheetBaseGetMaxHeight, BottomSheetBaseGetSnap, BottomSheetBaseGetSnaps, BottomSheetBaseMaxHeight, BottomSheetBaseRootRef, BottomSheetBaseScrollRef, BottomSheetBaseSnap, BottomSheetBaseSnaps, BottomSheetBaseOnClose } from '../entities';
+import type { BottomSheetBaseFindClosestSnap, BottomSheetBaseSnapsControl } from '../hooks';
+export type BottomSheetBaseContextValue = {
+    rootRef: RefObject<BottomSheetBaseRootRef>;
+    scrollRef: RefObject<BottomSheetBaseScrollRef>;
+    contentRef: RefObject<BottomSheetBaseContentRef>;
+    blocksRefs: StoredValue<BottomSheetBaseBlocksRefs>;
+    maxSnap: BottomSheetBaseSnap;
+    minSnap: BottomSheetBaseSnap;
+    defaultSnap: number;
+    snaps: BottomSheetBaseSnaps;
+    onClose: () => void;
+    isClosable: boolean;
+    canDrag: StoredValue<boolean>;
+    snapsControl: BottomSheetBaseSnapsControl;
+    findClosestSnap: StoredValue<BottomSheetBaseFindClosestSnap>;
+    addBlockRef: BottomSheetBaseAddBlockRef;
+};
+export type BottomSheetBaseContextProviderProps = PropsWithChildren<{
+    isOpen: boolean;
+    snaps: BottomSheetBaseSnaps | BottomSheetBaseGetSnaps;
+    setIsAnimating: (isAnimating: boolean) => void;
+    defaultSnap?: BottomSheetBaseSnap | BottomSheetBaseGetSnap;
+    onClose: BottomSheetBaseOnClose;
+    isClosable: boolean;
+    maxHeight?: BottomSheetBaseMaxHeight | BottomSheetBaseGetMaxHeight;
+}>;

package/__inner__/esm/components/BottomSheetBase/entities/index.d.ts

@@ -0,0 +1,4 @@
+export * from './maxHeight';
+export * from './onClose';
+export * from './refs';
+export * from './snap';

package/__inner__/esm/components/BottomSheetBase/entities/index.js

@@ -0,0 +1,4 @@
+export * from './maxHeight';
+export * from './onClose';
+export * from './refs';
+export * from './snap';

package/__inner__/esm/components/BottomSheetBase/entities/maxHeight.d.ts

@@ -0,0 +1,6 @@
+export type BottomSheetBaseMaxHeight = number;
+export type BottomSheetBaseGetMaxHeightParams = {
+    minHeight: number;
+    maxHeight: number;
+};
+export type BottomSheetBaseGetMaxHeight = (params: BottomSheetBaseGetMaxHeightParams) => BottomSheetBaseMaxHeight;

package/__inner__/esm/components/BottomSheetBase/entities/maxHeight.js

@@ -0,0 +1 @@
+export {};

package/__inner__/esm/components/BottomSheetBase/entities/onClose.d.ts

@@ -0,0 +1 @@
+export type BottomSheetBaseOnClose = () => void;

package/__inner__/esm/components/BottomSheetBase/entities/onClose.js

@@ -0,0 +1 @@
+export {};

package/__inner__/esm/components/BottomSheetBase/entities/refs.d.ts

@@ -0,0 +1,7 @@
+export type BottomSheetBaseRef = HTMLDivElement;
+export type BottomSheetBaseRootRef = HTMLDivElement;
+export type BottomSheetBaseScrollRef = HTMLDivElement;
+export type BottomSheetBaseContentRef = HTMLDivElement;
+export type BottomSheetBaseBlockRef = HTMLDivElement;
+export type BottomSheetBaseAddBlockRef = (id: string, instance: BottomSheetBaseBlockRef | null) => void;
+export type BottomSheetBaseBlocksRefs = Record<string, BottomSheetBaseBlockRef | null>;

package/__inner__/esm/components/BottomSheetBase/entities/refs.js

@@ -0,0 +1 @@
+export {};

package/__inner__/esm/components/BottomSheetBase/entities/snap.d.ts

@@ -0,0 +1,8 @@
+export type BottomSheetBaseSnap = number;
+export type BottomSheetBaseSnaps = BottomSheetBaseSnap[];
+export type BottomSheetBaseGetSnapParams = {
+    minHeight: number;
+    maxHeight: number;
+};
+export type BottomSheetBaseGetSnap = (params: BottomSheetBaseGetSnapParams) => BottomSheetBaseSnap;
+export type BottomSheetBaseGetSnaps = (params: BottomSheetBaseGetSnapParams) => BottomSheetBaseSnap[];

package/__inner__/esm/components/BottomSheetBase/entities/snap.js

@@ -0,0 +1 @@
+export {};

package/__inner__/esm/components/BottomSheetBase/hooks/index.d.ts

@@ -0,0 +1,6 @@
+export * from './useBottomSheetBaseCSSValue';
+export * from './useBottomSheetBaseDrag';
+export * from './useBottomSheetBaseHeight';
+export * from './useBottomSheetBaseReady';
+export * from './useBottomSheetBaseSnaps';
+export * from './useBottomSheetBaseVisibility';

package/__inner__/esm/components/BottomSheetBase/hooks/index.js

@@ -0,0 +1,6 @@
+export * from './useBottomSheetBaseCSSValue';
+export * from './useBottomSheetBaseDrag';
+export * from './useBottomSheetBaseHeight';
+export * from './useBottomSheetBaseReady';
+export * from './useBottomSheetBaseSnaps';
+export * from './useBottomSheetBaseVisibility';

package/__inner__/esm/components/BottomSheetBase/hooks/useBottomSheetBaseCSSValue.d.ts

@@ -0,0 +1,11 @@
+import type { RefObject } from 'react';
+import { type BottomSheetBaseCSSVariable } from '../constants';
+export declare const useBottomSheetBaseCSSValue: <Value extends string | number>({ rootRef, defaultValue, variableName, formatValue, }: {
+    rootRef: RefObject<HTMLElement>;
+    defaultValue: Value;
+    variableName: BottomSheetBaseCSSVariable;
+    formatValue?: (value: Value) => string;
+}) => {
+    value: import("../../../hooks/useStoredValue").StoredValue<Value>;
+    setValue: (newValue: Value) => void;
+};

package/__inner__/esm/components/BottomSheetBase/hooks/useBottomSheetBaseCSSValue.js

@@ -0,0 +1,25 @@
+import { useEffect } from 'react';
+import { useStoredValue } from '../../../hooks/useStoredValue';
+import { setCSSProperty } from '../../../utils/css';
+export var useBottomSheetBaseCSSValue = function (_a) {
+    var rootRef = _a.rootRef, defaultValue = _a.defaultValue, variableName = _a.variableName, formatValue = _a.formatValue;
+    var value = useStoredValue(defaultValue);
+    var setPropertyValue = function (value) {
+        setCSSProperty({
+            element: rootRef.current,
+            variableName: variableName,
+            value: formatValue ? formatValue(value) : value,
+        });
+    };
+    var setValue = function (newValue) {
+        value.current = newValue;
+        setPropertyValue(newValue);
+    };
+    useEffect(function () {
+        setPropertyValue(value.current);
+    }, [rootRef.current]);
+    return {
+        value: value,
+        setValue: setValue,
+    };
+};

package/__inner__/esm/components/BottomSheetBase/hooks/useBottomSheetBaseDrag.d.ts

@@ -0,0 +1,5 @@
+import type { RefObject } from 'react';
+export declare const useBottomSheetBaseDrag: (target: RefObject<HTMLElement>, options?: {
+    isCloseOnTap?: boolean;
+    isDraggable?: boolean;
+}) => void;

package/__inner__/esm/components/BottomSheetBase/hooks/useBottomSheetBaseDrag.js

@@ -0,0 +1,89 @@
+import { __read } from "tslib";
+import { rubberbandIfOutOfBounds, useDrag } from '@use-gesture/react';
+import { clamp } from '../../../utils/math';
+import { isNaN } from '../../../utils/number';
+import { BOTTOM_SHEET_BASE_CSS_VARIABLE } from '../constants';
+import { useBottomSheetBaseContext } from '../context';
+import { useBottomSheetBaseCSSValue } from './useBottomSheetBaseCSSValue';
+var rubberbandIfOutOfBoundsConstant = 0.55;
+export var useBottomSheetBaseDrag = function (target, options) {
+    var _a = options !== null && options !== void 0 ? options : {}, _b = _a.isCloseOnTap, isCloseOnTap = _b === void 0 ? false : _b, _c = _a.isDraggable, isDraggable = _c === void 0 ? true : _c;
+    var _d = useBottomSheetBaseContext(), minSnap = _d.minSnap, onCloseContext = _d.onClose, canDrag = _d.canDrag, maxSnap = _d.maxSnap, isClosable = _d.isClosable, snapsControl = _d.snapsControl, findClosestSnap = _d.findClosestSnap, rootRef = _d.rootRef;
+    var userSelect = useBottomSheetBaseCSSValue({
+        rootRef: rootRef,
+        defaultValue: 'auto',
+        variableName: BOTTOM_SHEET_BASE_CSS_VARIABLE.USER_SELECT,
+    });
+    var onClose = function () {
+        snapsControl.toClosed(true);
+        onCloseContext === null || onCloseContext === void 0 ? void 0 : onCloseContext();
+    };
+    var calculateAnimationTime = function (pxChange, velocity) {
+        var rawTime = Math.abs(pxChange / velocity);
+        if (isNaN(rawTime)) {
+            return 0;
+        }
+        return clamp(rawTime, 200, 500);
+    };
+    var onDragStart = function () {
+        userSelect.setValue('none');
+    };
+    var onDragFinish = function () {
+        userSelect.setValue('auto');
+    };
+    useDrag(function (params) {
+        var cancel = params.cancel, down = params.down, first = params.first, last = params.last, _a = params.memo, memo = _a === void 0 ? snapsControl.point.current : _a, _b = __read(params.movement, 2), _my = _b[1], tap = params.tap, _c = __read(params.velocity, 2), velocity = _c[1];
+        var my = _my * -1;
+        if (!canDrag.current) {
+            cancel();
+            return memo;
+        }
+        if (isClosable && isCloseOnTap && tap) {
+            cancel();
+            setTimeout(function () { return onClose(); }, 0);
+            return memo;
+        }
+        if (tap) {
+            return memo;
+        }
+        if (first) {
+            onDragStart();
+        }
+        var rawOffset = memo + my;
+        var predictedDistance = my * velocity;
+        var predictedPoint = Math.max(minSnap, Math.min(maxSnap, rawOffset + predictedDistance * 2));
+        if (last && isClosable && rawOffset + predictedDistance < minSnap / 2) {
+            onDragFinish();
+            onClose();
+            return memo;
+        }
+        var newOffset = (function () {
+            if (!down) {
+                return predictedPoint;
+            }
+            if (!isClosable && minSnap === maxSnap) {
+                if (rawOffset < minSnap) {
+                    return rubberbandIfOutOfBounds(rawOffset, minSnap, maxSnap * 1.5, rubberbandIfOutOfBoundsConstant);
+                }
+                return rubberbandIfOutOfBounds(rawOffset, minSnap / 1.5, maxSnap, rubberbandIfOutOfBoundsConstant);
+            }
+            return rubberbandIfOutOfBounds(rawOffset, isClosable ? 0 : minSnap, maxSnap, rubberbandIfOutOfBoundsConstant);
+        })();
+        if (last) {
+            var closestSnap = findClosestSnap.current(newOffset);
+            snapsControl.toAnimated(closestSnap, {
+                duration: calculateAnimationTime(Math.abs(closestSnap - snapsControl.point.current), velocity),
+            });
+            onDragFinish();
+            return memo;
+        }
+        snapsControl.to(newOffset);
+        return memo;
+    }, {
+        target: isDraggable
+            ? target
+            : {
+                current: null,
+            },
+    });
+};

package/__inner__/esm/components/BottomSheetBase/hooks/useBottomSheetBaseHeight.d.ts

@@ -0,0 +1,14 @@
+import type { RefObject } from 'react';
+import type { StoredValue } from '../../../hooks/useStoredValue';
+import type { BottomSheetBaseBlocksRefs, BottomSheetBaseContentRef, BottomSheetBaseGetMaxHeight, BottomSheetBaseMaxHeight } from '../entities';
+import type { BottomSheetBaseRegisterReady } from '../hooks';
+export declare const useBottomSheetBaseHeight: ({ contentRef, blocksRefs, customMaxHeight: customMaxHeightProp, registerReady, }: {
+    contentRef: RefObject<BottomSheetBaseContentRef>;
+    blocksRefs: StoredValue<BottomSheetBaseBlocksRefs>;
+    customMaxHeight: BottomSheetBaseMaxHeight | BottomSheetBaseGetMaxHeight | undefined;
+    registerReady: BottomSheetBaseRegisterReady;
+}) => {
+    minHeight: number;
+    maxHeight: number;
+    recalculateHeight: () => void;
+};

package/__inner__/esm/components/BottomSheetBase/hooks/useBottomSheetBaseHeight.js

@@ -0,0 +1,77 @@
+import { __read, __spreadArray } from "tslib";
+import { useEffect, useMemo, useState } from 'react';
+import { isServer } from '../../../constants/environment';
+import { useEventListener } from '../../../hooks/useEventListener';
+import { useMultipleResizeObserver } from '../../../hooks/useMultipleResizeObserver';
+import { isFunction } from '../../../utils/isFunction';
+import { isNumber } from '../../../utils/number';
+export var useBottomSheetBaseHeight = function (_a) {
+    var contentRef = _a.contentRef, blocksRefs = _a.blocksRefs, customMaxHeightProp = _a.customMaxHeight, registerReady = _a.registerReady;
+    var setReadyContentHeight = useMemo(function () { return registerReady('contentHeight'); }, [registerReady]);
+    var setReadyMaxHeight = useMemo(function () { return registerReady('maxHeight'); }, [registerReady]);
+    var getElementHeight = function (element) {
+        var _a;
+        var rect = element === null || element === void 0 ? void 0 : element.getBoundingClientRect();
+        return (_a = rect === null || rect === void 0 ? void 0 : rect.height) !== null && _a !== void 0 ? _a : 0;
+    };
+    var getRawMaxHeight = function () {
+        if (isServer) {
+            return 0;
+        }
+        return window.innerHeight;
+    };
+    var _b = __read(useState(0), 2), minHeight = _b[0], setMinHeight = _b[1];
+    var getCustomMaxHeight = function () {
+        if (isFunction(customMaxHeightProp)) {
+            return customMaxHeightProp({
+                maxHeight: getRawMaxHeight(),
+                minHeight: minHeight,
+            });
+        }
+        return customMaxHeightProp;
+    };
+    var checkHasCustomMaxHeight = function (customMaxHeight) { return isNumber(customMaxHeight); };
+    var calculateMaxHeight = function () {
+        var customMaxHeight = getCustomMaxHeight();
+        if (checkHasCustomMaxHeight(customMaxHeight)) {
+            return customMaxHeight;
+        }
+        return getRawMaxHeight();
+    };
+    var _c = __read(useState(function () { return calculateMaxHeight(); }), 2), maxHeight = _c[0], setMaxHeightState = _c[1];
+    var calculateMinHeight = function (maxHeight) {
+        var contentHeight = getElementHeight(contentRef.current);
+        var notContentBlocksHeight = 0;
+        Object.values(blocksRefs.current).forEach(function (element) {
+            notContentBlocksHeight += getElementHeight(element);
+        });
+        return Math.max(0, Math.min(maxHeight - notContentBlocksHeight, contentHeight) +
+            notContentBlocksHeight);
+    };
+    var recalculateHeight = function () {
+        var newMaxHeight = calculateMaxHeight();
+        setMaxHeightState(newMaxHeight);
+        setMinHeight(calculateMinHeight(newMaxHeight));
+    };
+    useMultipleResizeObserver(__spreadArray(__spreadArray([], __read(Object.values(blocksRefs.current)), false), [contentRef.current], false), function () {
+        recalculateHeight();
+    });
+    useEffect(function () {
+        setReadyContentHeight();
+    }, []);
+    useEventListener({
+        eventName: 'resize',
+        handler: function () {
+            recalculateHeight();
+        },
+    });
+    useEffect(function () {
+        recalculateHeight();
+        setReadyMaxHeight();
+    }, [getCustomMaxHeight()]);
+    return {
+        minHeight: minHeight,
+        maxHeight: maxHeight,
+        recalculateHeight: recalculateHeight,
+    };
+};

package/__inner__/esm/components/BottomSheetBase/hooks/useBottomSheetBaseReady/index.d.ts

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

package/__inner__/esm/components/BottomSheetBase/hooks/useBottomSheetBaseReady/index.js

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

package/__inner__/esm/components/BottomSheetBase/hooks/useBottomSheetBaseReady/types.d.ts

@@ -0,0 +1 @@
+export type BottomSheetBaseRegisterReady = (key: string) => () => void;

package/__inner__/esm/components/BottomSheetBase/hooks/useBottomSheetBaseReady/types.js

@@ -0,0 +1 @@
+export {};

package/__inner__/esm/components/BottomSheetBase/hooks/useBottomSheetBaseReady/useBottomSheetBaseReady.d.ts

@@ -0,0 +1,5 @@
+import type { BottomSheetBaseRegisterReady } from '../../hooks';
+export declare const useBottomSheetBaseReady: () => {
+    isReady: boolean;
+    registerReady: BottomSheetBaseRegisterReady;
+};

package/__inner__/esm/components/BottomSheetBase/hooks/useBottomSheetBaseReady/useBottomSheetBaseReady.js

@@ -0,0 +1,30 @@
+import { __assign, __read } from "tslib";
+import { useCallback, useState } from 'react';
+import { useStoredValue } from '../../../../hooks/useStoredValue';
+export var useBottomSheetBaseReady = function () {
+    var _a = __read(useState(false), 2), isReady = _a[0], setReady = _a[1];
+    var isReadyMap = useStoredValue({});
+    var setIsReadyMap = function (map) {
+        isReadyMap.current = map;
+        var states = Object.values(isReadyMap.current);
+        if (states.length === 0) {
+            return;
+        }
+        var isReady = states.every(function (state) { return !!state; });
+        if (isReady) {
+            setReady(true);
+        }
+    };
+    var registerReady = useCallback(function (key) {
+        var _a;
+        setIsReadyMap(__assign(__assign({}, isReadyMap.current), (_a = {}, _a[key] = false, _a)));
+        return function () {
+            var _a;
+            if (isReadyMap.current[key]) {
+                return;
+            }
+            setIsReadyMap(__assign(__assign({}, isReadyMap.current), (_a = {}, _a[key] = true, _a)));
+        };
+    }, []);
+    return { isReady: isReady, registerReady: registerReady };
+};

package/__inner__/esm/components/BottomSheetBase/hooks/useBottomSheetBaseSnaps/index.d.ts

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

package/__inner__/esm/components/BottomSheetBase/hooks/useBottomSheetBaseSnaps/index.js

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

package/__inner__/esm/components/BottomSheetBase/hooks/useBottomSheetBaseSnaps/types.d.ts

@@ -0,0 +1,14 @@
+import type { StoredValue } from '../../../../hooks/useStoredValue';
+import type { AnimatePropertyOptions } from '../../../../utils/animateProperty';
+export type BottomSheetBaseFindClosestSnap = (point: number) => number;
+export type BottomSheetBaseSnapsControlToClosed = (isAnimated?: boolean) => void;
+export type BottomSheetBaseSnapsControlToDefault = (isAnimated?: boolean) => void;
+export type BottomSheetBaseSnapsControlTo = (snap: number) => void;
+export type BottomSheetBaseSnapsControlToAnimated = (newPoint: number, options?: AnimatePropertyOptions) => void;
+export type BottomSheetBaseSnapsControl = {
+    point: StoredValue<number>;
+    to: BottomSheetBaseSnapsControlTo;
+    toAnimated: BottomSheetBaseSnapsControlToAnimated;
+    toClosed: BottomSheetBaseSnapsControlToClosed;
+    toDefault: BottomSheetBaseSnapsControlToDefault;
+};

package/__inner__/esm/components/BottomSheetBase/hooks/useBottomSheetBaseSnaps/types.js

@@ -0,0 +1 @@
+export {};

package/__inner__/esm/components/BottomSheetBase/hooks/useBottomSheetBaseSnaps/useBottomSheetBaseSnaps.d.ts

@@ -0,0 +1,14 @@
+import type { RefObject } from 'react';
+import type { StoredValue } from '../../../../hooks/useStoredValue';
+import type { BottomSheetBaseRootRef, BottomSheetBaseSnap } from '../../entities';
+import type { BottomSheetBaseFindClosestSnap, BottomSheetBaseSnapsControl } from '../../hooks';
+export declare const useBottomSheetBaseSnaps: ({ minSnap, maxSnap, defaultSnap, rootRef, onAnimationStart, onAnimationFinish, isReady, findClosestSnap, }: {
+    minSnap: BottomSheetBaseSnap;
+    maxSnap: BottomSheetBaseSnap;
+    defaultSnap: BottomSheetBaseSnap;
+    rootRef: RefObject<BottomSheetBaseRootRef>;
+    onAnimationStart?: () => void;
+    onAnimationFinish?: () => void;
+    isReady: boolean;
+    findClosestSnap: StoredValue<BottomSheetBaseFindClosestSnap>;
+}) => BottomSheetBaseSnapsControl;