@homecode/ui 4.11.1

package/dist/esm/src/components/Router/Redirect.js

@@ -0,0 +1,12 @@
+import { useEffect } from 'react';
+import STORE from './store.js';
+
+const Redirect = (props) => {
+    useEffect(() => {
+        STORE.replaceState(props.to, { replace: true });
+    }, []);
+    return null;
+};
+Redirect.displayName = 'Redirect';
+
+export { Redirect };

package/dist/esm/src/components/Router/Route.js

@@ -0,0 +1,4 @@
+const Route = (props) => null;
+Route.displayName = 'Route';
+
+export { Route };

package/dist/esm/src/components/Router/Router.helpers.js

@@ -0,0 +1,33 @@
+const replaceParamsInPath = (path, params) => {
+    if (path === '/')
+        return '';
+    return Object.keys(params).reduce((updatedPath, paramKey) => {
+        return updatedPath.replace(`:${paramKey}`, params[paramKey]);
+    }, path);
+};
+function parsePath(currPath, routePath, exact = false) {
+    const pathParts = currPath.split('/');
+    const routePathParts = routePath.split('/');
+    let matched = true;
+    if (exact && routePathParts.length !== pathParts.length) {
+        return null;
+    }
+    const params = {};
+    for (let i = 0; i < routePathParts.length; i++) {
+        const routeToken = routePathParts[i];
+        const currentPathToken = pathParts[i];
+        if (currentPathToken && routeToken.startsWith(':')) {
+            const paramName = routeToken.slice(1);
+            params[paramName] = currentPathToken;
+        }
+        else if (routeToken !== currentPathToken) {
+            matched = false;
+            break;
+        }
+    }
+    if (!matched)
+        return null;
+    return params;
+}
+
+export { parsePath, replaceParamsInPath };

package/dist/esm/src/components/Router/Router.js

@@ -0,0 +1,68 @@
+import { jsx, Fragment } from 'react/jsx-runtime';
+import { useContext, useEffect, useMemo } from 'react';
+import { withStore } from 'justorm/react';
+import STORE from './store.js';
+import Context from './context.js';
+import { parsePath, replaceParamsInPath } from './Router.helpers.js';
+export { Route } from './Route.js';
+export { Redirect } from './Redirect.js';
+export { Link } from './Link/Link.js';
+
+const Router = withStore({
+    router: ['path'],
+})((props) => {
+    const { children, single, basePath = '', store: { router }, } = props;
+    const ctx = useContext(Context);
+    const fullPath = ctx.basePath + basePath;
+    useEffect(() => {
+        const onPopState = () => {
+            STORE.go(window.location.pathname, { replace: true });
+        };
+        window.addEventListener('popstate', onPopState);
+        return () => window.removeEventListener('popstate', onPopState);
+    }, []);
+    const matchedRoutes = useMemo(() => {
+        const childs = [];
+        let noMatchRoute;
+        let isRouteMatched = false;
+        for (const child of React.Children.toArray(children)) {
+            if (!React.isValidElement(child)) {
+                childs.push(child);
+                continue;
+            }
+            // @ts-ignore
+            const isRouteComponent = child.type.displayName === 'Route';
+            const { path, exact, component: Component, ...rest } = child.props;
+            if (!path) {
+                if (isRouteComponent && Component) {
+                    noMatchRoute = jsx(Component, { ...rest });
+                    continue;
+                }
+                childs.push(child);
+                continue;
+            }
+            if (single && isRouteMatched) {
+                continue;
+            }
+            const tailPath = fullPath && path === '/' ? '' : path;
+            const routePath = fullPath + tailPath;
+            const params = parsePath(router.path, routePath, exact);
+            if (params) {
+                const routeBasePath = fullPath + replaceParamsInPath(path, params);
+                const matchedRoute = (jsx(Context.Provider, { value: { basePath: routeBasePath }, children: jsx(Component, { ...rest, pathParams: params }) }, path));
+                isRouteMatched = true;
+                childs.push(matchedRoute);
+            }
+        }
+        if (childs.length === 0 && noMatchRoute) {
+            return noMatchRoute;
+        }
+        return childs;
+    }, [children, router.path, fullPath, single]);
+    return jsx(Fragment, { children: matchedRoutes });
+});
+Router.displayName = 'Router';
+const RouterStore = STORE;
+const RouterContext = Context;
+
+export { Router, RouterContext, RouterStore };

package/dist/esm/src/components/Router/context.js

@@ -0,0 +1,5 @@
+import { createContext } from 'react';
+
+var Context = createContext({ basePath: '' });
+
+export { Context as default };

package/dist/esm/src/components/Router/store.js

@@ -0,0 +1,55 @@
+import { createStore } from 'justorm/react';
+import { addUniq, spliceWhere } from '../../tools/array.js';
+import { parseQueryParams } from '../../tools/queryParams.js';
+import { isBrowser } from '../../tools/env.js';
+import 'nanoid';
+import '../../tools/dom.js';
+import 'timen';
+import 'compareq';
+import 'lodash.pick';
+
+const LISTENERS = [];
+const STORE = createStore('router', {
+    path: isBrowser && location.pathname,
+    params: {},
+    query: parseQueryParams(),
+    queryString: isBrowser && location.search,
+    on(cb) {
+        addUniq(LISTENERS, cb);
+    },
+    un(cb) {
+        spliceWhere(LISTENERS, cb);
+    },
+    go(href, { replace } = {}) {
+        if (href === this.path)
+            return;
+        history[replace ? 'replaceState' : 'pushState']({}, '', href);
+        onRouteChange(href);
+    },
+    back() {
+        history.back();
+        onRouteChange();
+    },
+    replaceState(href, { quiet } = {}) {
+        history.replaceState({}, '', href);
+        if (!quiet)
+            onRouteChange(href);
+    },
+});
+function onRouteChange(href = window.location.pathname) {
+    STORE.queryString = location.search;
+    STORE.query = parseQueryParams();
+    STORE.path = href.replace(/\?.+/, '') || '/';
+    LISTENERS.forEach(cb => cb(STORE.path));
+}
+function updateRouteState() {
+    if (STORE.path !== window.location.pathname ||
+        STORE.queryString !== location.search)
+        onRouteChange();
+}
+if (isBrowser) {
+    window.addEventListener('popstate', updateRouteState);
+    window.addEventListener('pushstate', updateRouteState);
+}
+
+export { STORE as default };

package/dist/esm/src/components/Scroll/Scroll.js

@@ -0,0 +1,274 @@
+import { jsx, jsxs } from 'react/jsx-runtime';
+import { Component, createRef, createElement } from 'react';
+import cn from 'classnames';
+import { createStore } from 'justorm/react';
+import omit from 'lodash.omit';
+import Time from 'timen';
+import { isTouch } from '../../tools/dom.js';
+import { unobserve, observe } from '../../tools/resizeObserver.js';
+import S from './Scroll.styl.js';
+import debounce from '../../tools/debounce.js';
+
+const getEventCoords = e => ({
+    x: e.clientX,
+    y: e.clientY,
+});
+const AXES = ['x', 'y'];
+const BY_AXIS = {
+    x: {
+        scrollPos: 'scrollLeft',
+        scrollSize: 'scrollWidth',
+        size: 'width',
+        offsetSize: 'offsetWidth',
+        innerSize: 'clientWidth',
+        posField: 'left',
+    },
+    y: {
+        scrollPos: 'scrollTop',
+        scrollSize: 'scrollHeight',
+        size: 'height',
+        offsetSize: 'offsetHeight',
+        innerSize: 'clientHeight',
+        posField: 'top',
+    },
+};
+class Scroll extends Component {
+    innerElem;
+    onInnerRef = elem => {
+        if (this.innerElem) {
+            unobserve(this.innerElem, this.updateAll);
+        }
+        this.innerElem = elem;
+        this.props.onInnerRef?.(elem);
+        if (elem) {
+            this.updateAll();
+            observe(elem, this.updateAll);
+        }
+    };
+    thumbELem = {
+        x: createRef(),
+        y: createRef(),
+    };
+    store;
+    isTouch;
+    timers = Time.create();
+    currAxis;
+    pos = { x: 0, y: 0 };
+    prevCoords = { x: 0, y: 0 };
+    prevScrolls = { x: 0, y: 0 };
+    prevBoundings = { x: 0, y: 0 };
+    unsubscribeScrollHeightObserver;
+    static defaultProps = { size: 'm' };
+    constructor(props) {
+        super(props);
+        this.isTouch = isTouch();
+        this.store = createStore(this, {
+            isScrolling: false,
+            activeAxis: null,
+            coeff: { x: 0, y: 0 },
+        });
+    }
+    componentDidMount() {
+        this.updateAll();
+        this.unsubscribeScrollHeightObserver = Time.every(100, this.observeScrollHeight);
+        document.addEventListener('scroll', this.onDocScroll);
+    }
+    componentWillUnmount() {
+        this.unsubscribeScrollHeightObserver?.();
+        this.unsubscribePointerMoveUp();
+        document.removeEventListener('scroll', this.onDocScroll);
+    }
+    eachAxis = fn => AXES.map(axis => this.props[axis] && fn(axis));
+    observeScrollHeight = () => {
+        this.eachAxis(axis => {
+            if ((this.props[axis] && this.isScrollChanged(axis)) ||
+                this.isBoudingsChanged(axis)) {
+                this.update(axis);
+            }
+        });
+    };
+    isScrollChanged(axis) {
+        const currScrolls = this.getScrollSize(axis);
+        const isChanged = this.prevScrolls[axis] !== currScrolls[axis];
+        if (isChanged)
+            this.prevScrolls[axis] = currScrolls;
+        return isChanged;
+    }
+    isBoudingsChanged(axis) {
+        const curroffsetSize = this.getoffsetSize(axis);
+        const isChanged = this.prevBoundings[axis] !== curroffsetSize[axis];
+        if (isChanged)
+            this.prevBoundings[axis] = curroffsetSize[axis];
+        return isChanged;
+    }
+    getoffsetSize = axis => this.innerElem[BY_AXIS[axis].offsetSize];
+    getInnerSize = axis => this.innerElem[BY_AXIS[axis].innerSize];
+    getScrollSize = axis => this.innerElem[BY_AXIS[axis].scrollSize];
+    getScrollPos = axis => this.innerElem[BY_AXIS[axis].scrollPos];
+    getThumbSize = axis => this.thumbELem[axis].current[BY_AXIS[axis].offsetSize];
+    getOffset(axis) {
+        const offset = this.props.offset?.[axis];
+        const isVertical = axis === 'y';
+        const before = isVertical ? 'top' : 'left';
+        const after = isVertical ? 'bottom' : 'right';
+        return {
+            [before]: offset?.before || 0,
+            [after]: offset?.after || 0,
+        };
+    }
+    getCoeffStyle = axis => `${this.store.coeff[axis] * 100}%`;
+    getPosStyle = axis => `${this.pos[axis]}px`;
+    updateAll = () => {
+        this.eachAxis(this.update);
+    };
+    update = axis => {
+        this.updateCoeff(axis);
+        this.updatePos(axis);
+    };
+    updateCoeff(axis) {
+        const thumb = this.thumbELem[axis].current;
+        if (!this.innerElem)
+            return;
+        const sizeField = BY_AXIS[axis].size;
+        this.store.coeff[axis] = this.getInnerSize(axis) / this.getScrollSize(axis);
+        if (thumb)
+            thumb.style[sizeField] = this.getCoeffStyle(axis);
+    }
+    updatePos = axis => {
+        const thumb = this.thumbELem[axis].current;
+        if (!this.innerElem || !thumb)
+            return;
+        const { offset } = this.props;
+        const offsetBefore = offset?.[axis]?.before || 0;
+        const offsetAfter = offset?.[axis]?.after || 0;
+        const innerSize = this.getInnerSize(axis);
+        const thumbSize = this.getThumbSize(axis);
+        const scrollSize = this.getScrollSize(axis);
+        const scrollPos = this.getScrollPos(axis);
+        const posField = BY_AXIS[axis].posField;
+        // const AXIS = axis.toUpperCase();
+        const pos = thumbSize
+            ? (innerSize - thumbSize - offsetBefore - offsetAfter) *
+                (scrollPos / (scrollSize - innerSize))
+            : 0;
+        this.pos[axis] = pos;
+        // thumb.style.transform = `translate${AXIS}(${pos}px)`;
+        thumb.style[posField] = this.getPosStyle(axis);
+    };
+    updateScroll = (axis, e) => {
+        const coords = getEventCoords(e);
+        const scrollPos = BY_AXIS[axis].scrollPos;
+        const pos = coords[axis] - this.prevCoords[axis];
+        this.prevCoords = coords;
+        this.innerElem[scrollPos] += pos / this.store.coeff[axis];
+    };
+    dropScrollingState = debounce(() => (this.store.isScrolling = false), 2000);
+    subscribePointerMoveUp = () => {
+        document.addEventListener('pointermove', this.onPointerMove, {
+            passive: false, // do not generate passive event warning
+        });
+        document.addEventListener('pointerup', this.onPointerUp);
+    };
+    unsubscribePointerMoveUp = () => {
+        document.removeEventListener('pointermove', this.onPointerMove);
+        document.removeEventListener('pointerup', this.onPointerUp);
+    };
+    onDocScroll = e => {
+        const { activeAxis } = this.store;
+        // if dragging thumb - prevent any other scrolls
+        if (activeAxis && this.innerElem !== e.target) {
+            e.preventDefault();
+            e.stopPropagation();
+        }
+    };
+    onInnerScroll = e => {
+        if (this.innerElem !== e.target)
+            return;
+        const { onScroll } = this.props;
+        const { activeAxis, isScrolling } = this.store;
+        onScroll?.(e);
+        if (!activeAxis) {
+            this.eachAxis(axis => {
+                if (this.isScrollChanged(axis))
+                    this.update(axis);
+            });
+        }
+        if (!isScrolling)
+            this.store.isScrolling = true;
+        this.dropScrollingState();
+    };
+    onPointerDown = (axis, e) => {
+        e.preventDefault();
+        e.stopPropagation();
+        // TOOD: if target is bar(not thumb) - move thumb to target coords
+        this.prevCoords = getEventCoords(e);
+        this.store.activeAxis = axis;
+        this.subscribePointerMoveUp();
+    };
+    onPointerMove = e => {
+        const { activeAxis: axis } = this.store;
+        if (!axis)
+            return;
+        e.preventDefault();
+        e.stopPropagation();
+        this.updateScroll(axis, e);
+        this.updatePos(axis);
+    };
+    onPointerUp = e => {
+        e.stopPropagation();
+        this.store.activeAxis = null;
+        this.dropScrollingState();
+        this.unsubscribePointerMoveUp();
+    };
+    renderBar = axis => {
+        const { thumbClassName } = this.props;
+        const { activeAxis, coeff } = this.store;
+        if (coeff[axis] === 1)
+            return null;
+        const sizeField = BY_AXIS[axis].size;
+        const posField = BY_AXIS[axis].posField;
+        const thumbStyle = {
+            [sizeField]: this.getCoeffStyle(axis),
+            [posField]: this.getPosStyle(axis),
+        };
+        const barProps = {
+            className: cn(S.bar, S[axis], activeAxis === axis && S.isActive),
+            style: this.getOffset(axis),
+            onPointerDown: this.onPointerDown.bind(this, axis),
+        };
+        return (createElement("div", { ...barProps, key: `bar-${axis}` },
+            jsx("div", { className: cn(S.thumb, thumbClassName), style: thumbStyle, ref: this.thumbELem[axis] })));
+    };
+    renderInner() {
+        const { innerClassName, innerProps, children, smooth } = this.props;
+        const { activeAxis } = this.store;
+        const innerClasses = cn(S.inner, innerProps?.className, innerClassName, !activeAxis && smooth && S.smooth);
+        const props = { ...innerProps };
+        props.onScrollCapture = this.onInnerScroll;
+        return (createElement("div", { ...props, className: innerClasses, ref: this.onInnerRef, key: "inner" }, children));
+    }
+    render() {
+        const { y, x, size, fadeSize, extraWide, autoHide, className } = this.props;
+        const { isScrolling, activeAxis } = this.store;
+        const classes = cn(S.root, y && S.y, x && S.x, S[`size-${size}`], fadeSize && S[`fadeSize-${fadeSize}`], autoHide && S.autoHide, extraWide && S.extraWide, (isScrolling || activeAxis) && S.isScrolling, this.isTouch && S.isTouch, className);
+        const props = omit(this.props, [
+            'x',
+            'y',
+            'offset',
+            'size',
+            'fadeSize',
+            'smooth',
+            'className',
+            'innerClassName',
+            'innerProps',
+            'onInnerRef',
+            'thumbClassName',
+            'autoHide',
+            'children',
+            'extraWide',
+        ]);
+        return (jsxs("div", { className: classes, ...props, children: [this.renderInner(), this.eachAxis(this.renderBar)] }));
+    }
+}
+
+export { Scroll };

package/dist/esm/src/components/Scroll/Scroll.styl.js

@@ -0,0 +1,7 @@
+import styleInject from '../../../node_modules/style-inject/dist/style-inject.es.js';
+
+var css_248z = ".Scroll_root__NNx5K{display:flex;overflow:hidden;position:relative}.Scroll_inner__DmxTb{-webkit-overflow-scrolling:touch;-ms-overflow-style:none;overflow:hidden;position:relative;scrollbar-width:none;width:100%}.Scroll_inner__DmxTb.Scroll_smooth__2vqKe{scroll-behavior:smooth}.Scroll_inner__DmxTb::-webkit-scrollbar{display:none}.Scroll_y__2xWol .Scroll_inner__DmxTb{max-height:100%;overflow-y:auto}.Scroll_x__--Ycm .Scroll_inner__DmxTb{max-width:100%;overflow-x:auto}.Scroll_y__2xWol.Scroll_fadeSize-s__WeI0f .Scroll_inner__DmxTb{-webkit-mask-image:linear-gradient(180deg,transparent 2px,#000 10px,#000 calc(100% - 10px),transparent);mask-image:linear-gradient(180deg,transparent 2px,#000 10px,#000 calc(100% - 10px),transparent)}.Scroll_x__--Ycm.Scroll_fadeSize-s__WeI0f .Scroll_inner__DmxTb{-webkit-mask-image:linear-gradient(90deg,transparent 2px,#000 10px,#000 calc(100% - 10px),transparent);mask-image:linear-gradient(90deg,transparent 2px,#000 10px,#000 calc(100% - 10px),transparent)}.Scroll_y__2xWol.Scroll_fadeSize-m__Hb-1p .Scroll_inner__DmxTb{-webkit-mask-image:linear-gradient(180deg,transparent 2px,#000 16px,#000 calc(100% - 16px),transparent);mask-image:linear-gradient(180deg,transparent 2px,#000 16px,#000 calc(100% - 16px),transparent)}.Scroll_x__--Ycm.Scroll_fadeSize-m__Hb-1p .Scroll_inner__DmxTb{-webkit-mask-image:linear-gradient(90deg,transparent 2px,#000 16px,#000 calc(100% - 16px),transparent);mask-image:linear-gradient(90deg,transparent 2px,#000 16px,#000 calc(100% - 16px),transparent)}.Scroll_y__2xWol.Scroll_fadeSize-l__E0CbA .Scroll_inner__DmxTb{-webkit-mask-image:linear-gradient(180deg,transparent 2px,#000 20px,#000 calc(100% - 20px),transparent);mask-image:linear-gradient(180deg,transparent 2px,#000 20px,#000 calc(100% - 20px),transparent)}.Scroll_x__--Ycm.Scroll_fadeSize-l__E0CbA .Scroll_inner__DmxTb{-webkit-mask-image:linear-gradient(90deg,transparent 2px,#000 20px,#000 calc(100% - 20px),transparent);mask-image:linear-gradient(90deg,transparent 2px,#000 20px,#000 calc(100% - 20px),transparent)}.Scroll_y__2xWol.Scroll_fadeSize-xl__jcYk0 .Scroll_inner__DmxTb{-webkit-mask-image:linear-gradient(180deg,transparent 2px,#000 30px,#000 calc(100% - 30px),transparent);mask-image:linear-gradient(180deg,transparent 2px,#000 30px,#000 calc(100% - 30px),transparent)}.Scroll_x__--Ycm.Scroll_fadeSize-xl__jcYk0 .Scroll_inner__DmxTb{-webkit-mask-image:linear-gradient(90deg,transparent 2px,#000 30px,#000 calc(100% - 30px),transparent);mask-image:linear-gradient(90deg,transparent 2px,#000 30px,#000 calc(100% - 30px),transparent)}.Scroll_autoHide__URLqx>.Scroll_bar__6CL7R{opacity:0}.Scroll_isScrolling__yV2Pj.Scroll_autoHide__URLqx>.Scroll_bar__6CL7R{opacity:1;transition:none}.Scroll_thumb__ccEPj{background-color:var(--accent-color-alpha-200);border-radius:1px;position:absolute;transform-origin:center;transition:background-color .1s ease-out}.Scroll_y__2xWol>.Scroll_thumb__ccEPj{min-height:30px;top:0;width:100%}.Scroll_x__--Ycm>.Scroll_thumb__ccEPj{height:100%;left:0;min-width:30px}.Scroll_bar__6CL7R{cursor:pointer;overflow:hidden;position:absolute;touch-action:none;transition:opacity .3s ease-out .1s;z-index:2}.Scroll_bar__6CL7R:before{background-color:var(--accent-color-alpha-100);border-radius:2px;content:\"\";opacity:0;position:absolute;transition:opacity .2s ease-out .3s}.Scroll_bar__6CL7R.Scroll_isActive__Nkkmi,.Scroll_bar__6CL7R:hover{z-index:1}.Scroll_bar__6CL7R.Scroll_isActive__Nkkmi:before,.Scroll_bar__6CL7R:hover:before{opacity:1;transition-delay:0s}.Scroll_bar__6CL7R.Scroll_isActive__Nkkmi .Scroll_thumb__ccEPj,.Scroll_bar__6CL7R:hover .Scroll_thumb__ccEPj{background-color:var(--active-color)}.Scroll_bar__6CL7R.Scroll_y__2xWol{bottom:8px;right:0;top:8px;width:16px}.Scroll_isTouch__Vb2mT .Scroll_bar__6CL7R.Scroll_y__2xWol{width:32px}.Scroll_bar__6CL7R.Scroll_y__2xWol .Scroll_thumb__ccEPj,.Scroll_bar__6CL7R.Scroll_y__2xWol:before{right:30%}.Scroll_bar__6CL7R.Scroll_y__2xWol:before{height:100%}.Scroll_bar__6CL7R.Scroll_x__--Ycm{bottom:0;height:16px;left:8px;right:8px}.Scroll_isTouch__Vb2mT .Scroll_bar__6CL7R.Scroll_x__--Ycm{height:32px}.Scroll_bar__6CL7R.Scroll_x__--Ycm .Scroll_thumb__ccEPj,.Scroll_bar__6CL7R.Scroll_x__--Ycm:before{bottom:30%}.Scroll_bar__6CL7R.Scroll_x__--Ycm:before{width:100%}.Scroll_bar__6CL7R.Scroll_x__--Ycm{height:32px}.Scroll_size-s__px8sG>.Scroll_bar__6CL7R.Scroll_x__--Ycm .Scroll_thumb__ccEPj,.Scroll_size-s__px8sG>.Scroll_bar__6CL7R.Scroll_x__--Ycm:before{height:1px}.Scroll_size-m__gfTwB>.Scroll_bar__6CL7R.Scroll_x__--Ycm .Scroll_thumb__ccEPj,.Scroll_size-m__gfTwB>.Scroll_bar__6CL7R.Scroll_x__--Ycm:before{border-radius:2.5px;height:5px}.Scroll_size-l__Pe4z7>.Scroll_bar__6CL7R.Scroll_x__--Ycm .Scroll_thumb__ccEPj,.Scroll_size-l__Pe4z7>.Scroll_bar__6CL7R.Scroll_x__--Ycm:before{border-radius:4.5px;height:9px}.Scroll_bar__6CL7R.Scroll_y__2xWol{width:32px}.Scroll_size-s__px8sG>.Scroll_bar__6CL7R.Scroll_y__2xWol .Scroll_thumb__ccEPj,.Scroll_size-s__px8sG>.Scroll_bar__6CL7R.Scroll_y__2xWol:before{width:1px}.Scroll_size-m__gfTwB>.Scroll_bar__6CL7R.Scroll_y__2xWol .Scroll_thumb__ccEPj,.Scroll_size-m__gfTwB>.Scroll_bar__6CL7R.Scroll_y__2xWol:before{border-radius:2.5px;width:5px}.Scroll_size-l__Pe4z7>.Scroll_bar__6CL7R.Scroll_y__2xWol .Scroll_thumb__ccEPj,.Scroll_size-l__Pe4z7>.Scroll_bar__6CL7R.Scroll_y__2xWol:before{border-radius:4.5px;width:9px}.Scroll_extraWide__IL5ZI .Scroll_bar__6CL7R.Scroll_x__--Ycm{height:52px}.Scroll_extraWide__IL5ZI .Scroll_bar__6CL7R.Scroll_y__2xWol{width:52px}";
+var S = {"root":"Scroll_root__NNx5K","inner":"Scroll_inner__DmxTb","smooth":"Scroll_smooth__2vqKe","y":"Scroll_y__2xWol","x":"Scroll_x__--Ycm","fadeSize-s":"Scroll_fadeSize-s__WeI0f","fadeSize-m":"Scroll_fadeSize-m__Hb-1p","fadeSize-l":"Scroll_fadeSize-l__E0CbA","fadeSize-xl":"Scroll_fadeSize-xl__jcYk0","autoHide":"Scroll_autoHide__URLqx","bar":"Scroll_bar__6CL7R","isScrolling":"Scroll_isScrolling__yV2Pj","thumb":"Scroll_thumb__ccEPj","isActive":"Scroll_isActive__Nkkmi","isTouch":"Scroll_isTouch__Vb2mT","size-s":"Scroll_size-s__px8sG","size-m":"Scroll_size-m__gfTwB","size-l":"Scroll_size-l__Pe4z7","extraWide":"Scroll_extraWide__IL5ZI"};
+styleInject(css_248z);
+
+export { S as default };

package/dist/esm/src/components/Select/Select.helpers.js

@@ -0,0 +1,37 @@
+function isMultiple(value) {
+    return Array.isArray(value);
+}
+function renderLabel({ label, render }) {
+    if (render)
+        return render(label);
+    return label;
+}
+function buildOptionsTree(options, idsMap) {
+    function buildOption(id) {
+        const { items, childIds } = idsMap;
+        const data = { ...items[id] };
+        const childs = childIds[id];
+        if (childs)
+            data.children = childs.map(buildOption);
+        return data;
+    }
+    return options.reduce((acc, { id, parentId }) => (parentId ? acc : [...acc, buildOption(id)]), []);
+}
+function mapById(options) {
+    return options.reduce((acc, item) => {
+        const { items, childIds } = acc;
+        const { id, parentId } = item;
+        items[id] = item;
+        if (parentId) {
+            if (!childIds[parentId])
+                childIds[parentId] = [];
+            childIds[parentId].push(id);
+        }
+        return acc;
+    }, {
+        items: {},
+        childIds: {},
+    });
+}
+
+export { buildOptionsTree, isMultiple, mapById, renderLabel };