{"version":3,"sources":["jsdelivr-header.js","rollup://@epam/uui-core/src/constants/selectors.ts","rollup://@epam/uui-core/src/helpers/forwardRef.ts","rollup://@epam/uui-core/src/helpers/withMods.ts","rollup://@epam/uui-core/src/helpers/events.ts","rollup://@epam/uui-core/src/helpers/arrayToMatrix.ts","rollup://@epam/uui-core/src/helpers/cx.ts","rollup://@epam/uui-core/src/helpers/ssr.ts","rollup://@epam/uui-core/src/helpers/getOffset.ts","rollup://@epam/uui-core/src/services/BaseContext.ts","rollup://@epam/uui-core/src/services/dnd/DndContext.tsx","rollup://@epam/uui-core/src/services/UuiContext.ts","rollup://@epam/uui-core/src/services/dnd/DragGhost.tsx","rollup://@epam/uui-core/src/services/dnd/helpers.ts","rollup://@epam/uui-core/src/services/dnd/DndActor.tsx","rollup://@epam/uui-core/src/services/LayoutContext.ts","rollup://@epam/uui-core/src/services/routing/StubAdaptedRouter.tsx","rollup://@epam/uui-core/src/helpers/queryToSearch.ts","rollup://@epam/uui-core/src/helpers/searchToQuery.ts","rollup://@epam/uui-core/src/services/routing/HistoryAdaptedRouter.tsx","rollup://@epam/uui-core/src/services/routing/NextRouterAdapter.tsx","rollup://@epam/uui-core/src/services/routing/NextAppRouterAdapter.tsx","rollup://@epam/uui-core/src/services/routing/interfaces/IRouter6.ts","rollup://@epam/uui-core/src/services/routing/Router6AdaptedRouter.ts","rollup://@epam/uui-core/src/services/analytics/GAListener.ts","rollup://@epam/uui-core/src/services/AnalyticsContext.ts","rollup://@epam/uui-core/src/helpers/cookie.ts","rollup://@epam/uui-core/src/services/AuthRecoveryService.ts","rollup://@epam/uui-core/src/services/ApiContext.ts","rollup://@epam/uui-core/src/services/ErrorContext.ts","rollup://@epam/uui-core/src/services/LockContext.ts","rollup://@epam/uui-core/src/services/ModalContext.ts","rollup://@epam/uui-core/src/services/NotificationContext.tsx","rollup://@epam/uui-core/src/services/UserSettingsContext.ts","rollup://@epam/uui-core/src/hooks/useUuiServices.ts","rollup://@epam/uui-core/src/services/ContextProvider.tsx","rollup://@epam/uui-core/src/helpers/IEditableDebouncer.ts","rollup://@epam/uui-core/src/helpers/getOrderBetween.ts","rollup://@epam/uui-core/src/helpers/urlUtils.ts","rollup://@epam/uui-core/src/data/querying/getOrderComparer.ts","rollup://@epam/uui-core/src/helpers/orderBy.ts","rollup://@epam/uui-core/src/helpers/applyColumnsConfig.ts","rollup://@epam/uui-core/src/helpers/formatBytes.ts","rollup://@epam/uui-core/src/helpers/numericInputCalculations.ts","rollup://@epam/uui-core/src/helpers/mobile.ts","rollup://@epam/uui-core/src/helpers/uuiLogger.ts","rollup://@epam/uui-core/src/helpers/clearEmptyValueFromRecord.ts","rollup://@epam/uui-core/src/helpers/createSkinComponent.ts","rollup://@epam/uui-core/src/helpers/range.ts","rollup://@epam/uui-core/src/helpers/getDir.ts","rollup://@epam/uui-core/src/types/dataSources.ts","rollup://@epam/uui-core/src/helpers/dayJsHelper.ts","rollup://@epam/uui-core/src/data/querying/getFilterPredicate.ts","rollup://@epam/uui-core/src/data/querying/getSearchFilter.ts","rollup://@epam/uui-core/src/data/querying/runDataQuery.ts","rollup://@epam/uui-core/src/data/processing/views/tree/constants.ts","rollup://@epam/uui-core/src/data/processing/views/helpers/convert.ts","rollup://@epam/uui-core/src/data/processing/views/helpers/setters.ts","rollup://@epam/uui-core/src/data/processing/views/helpers/status.ts","rollup://@epam/uui-core/src/hooks/usePrevious.ts","rollup://@epam/uui-core/src/data/processing/views/tree/helpers/map.ts","rollup://@epam/uui-core/src/data/processing/views/tree/ItemsAccessor.ts","rollup://@epam/uui-core/src/data/processing/views/tree/treeStructure/helpers/checked.ts","rollup://@epam/uui-core/src/data/processing/views/tree/treeStructure/helpers/FetchingHelper.ts","rollup://@epam/uui-core/src/data/processing/views/tree/ItemsMap.ts","rollup://@epam/uui-core/src/data/processing/views/tree/helpers/comparators.ts","rollup://@epam/uui-core/src/data/processing/views/tree/Tree.ts","rollup://@epam/uui-core/src/data/processing/views/tree/treeStructure/TreeStructure.ts","rollup://@epam/uui-core/src/data/processing/views/tree/treeStructure/helpers/CheckingHelper.ts","rollup://@epam/uui-core/src/data/processing/views/tree/treeStructure/helpers/FilterHelper.ts","rollup://@epam/uui-core/src/data/processing/views/tree/treeStructure/helpers/SearchHelper.ts","rollup://@epam/uui-core/src/data/processing/views/tree/treeStructure/helpers/SortHelper.ts","rollup://@epam/uui-core/src/data/processing/views/tree/helpers/merge.ts","rollup://@epam/uui-core/src/data/processing/views/tree/treeStructure/helpers/PatchHelper.ts","rollup://@epam/uui-core/src/data/processing/views/tree/treeStructure/helpers/TreeHelper.ts","rollup://@epam/uui-core/src/data/processing/views/tree/treeState/TreeState.ts","rollup://@epam/uui-core/src/data/processing/views/tree/hooks/strategies/lazyTree/helpers.ts","rollup://@epam/uui-core/src/data/processing/views/tree/hooks/common/useDataSourceStateWithDefaults.ts","rollup://@epam/uui-core/src/data/processing/views/tree/ItemsStatusCollector.ts","rollup://@epam/uui-core/src/data/processing/views/tree/hooks/common/useItemsStatusCollector.ts","rollup://@epam/uui-core/src/data/processing/views/tree/hooks/common/useItemsStorage.ts","rollup://@epam/uui-core/src/data/processing/views/tree/helpers/patch.ts","rollup://@epam/uui-core/src/data/processing/views/tree/hooks/common/usePatchTree.ts","rollup://@epam/uui-core/src/data/processing/views/tree/hooks/strategies/checked.ts","rollup://@epam/uui-core/src/data/processing/views/tree/hooks/common/useDepsChanged.ts","rollup://@epam/uui-core/src/data/processing/views/tree/hooks/common/useUpdateTreeState.ts","rollup://@epam/uui-core/src/data/processing/views/tree/hooks/common/useSelectedOnlyTree.ts","rollup://@epam/uui-core/src/data/processing/views/tree/hooks/common/useSearchTreeState.ts","rollup://@epam/uui-core/src/data/processing/views/tree/hooks/common/useUpdateTree.ts","rollup://@epam/uui-core/src/data/processing/views/tree/hooks/common/useSearchTree.ts","rollup://@epam/uui-core/src/data/processing/views/tree/hooks/common/useSortTreeState.ts","rollup://@epam/uui-core/src/data/processing/views/tree/hooks/common/useSortTree.ts","rollup://@epam/uui-core/src/data/processing/views/tree/hooks/common/useFilterTree.ts","rollup://@epam/uui-core/src/data/processing/views/tree/hooks/common/useFilterTreeState.ts","rollup://@epam/uui-core/src/data/processing/views/tree/hooks/common/useActualItemsStorage.ts","rollup://@epam/uui-core/src/data/processing/views/tree/hooks/common/useAbortController.ts","rollup://@epam/uui-core/src/data/processing/views/tree/hooks/strategies/asyncTree/useLoadData.ts","rollup://@epam/uui-core/src/data/processing/views/tree/hooks/strategies/asyncTree/useAsyncTree.ts","rollup://@epam/uui-core/src/data/processing/views/tree/hooks/strategies/lazyTree/useLoadData.ts","rollup://@epam/uui-core/src/data/processing/views/tree/hooks/strategies/lazyTree/useLazyFetchingAdvisor.ts","rollup://@epam/uui-core/src/data/processing/views/tree/hooks/strategies/lazyTree/useLazyTree.ts","rollup://@epam/uui-core/src/data/processing/views/tree/hooks/strategies/syncTree/useCreateTree.ts","rollup://@epam/uui-core/src/data/processing/views/tree/hooks/strategies/syncTree/useSyncTree.ts","rollup://@epam/uui-core/src/data/processing/views/tree/hooks/strategies/index.ts","rollup://@epam/uui-core/src/data/processing/views/tree/hooks/useTree.ts","rollup://@epam/uui-core/src/data/processing/views/tree/ItemsStorage.ts","rollup://@epam/uui-core/src/data/processing/views/dataRows/services/buildParentsLookup.ts","rollup://@epam/uui-core/src/data/processing/views/dataRows/services/useCheckingService.ts","rollup://@epam/uui-core/src/data/processing/views/dataRows/services/useFoldingService.ts","rollup://@epam/uui-core/src/data/processing/views/dataRows/services/useFocusService.ts","rollup://@epam/uui-core/src/data/processing/views/dataRows/services/useSelectingService.ts","rollup://@epam/uui-core/src/data/processing/views/dataRows/services/useCascadeSelectionService.ts","rollup://@epam/uui-core/src/data/processing/views/dataRows/useDataRowProps.ts","rollup://@epam/uui-core/src/data/processing/views/dataRows/stats.ts","rollup://@epam/uui-core/src/data/processing/views/dataRows/useBuildRows.ts","rollup://@epam/uui-core/src/data/processing/views/dataRows/useSelectAll.ts","rollup://@epam/uui-core/src/data/processing/views/dataRows/usePinnedRows.ts","rollup://@epam/uui-core/src/data/processing/views/dataRows/useUpdateRowProps.ts","rollup://@epam/uui-core/src/data/processing/views/dataRows/useDataRows.ts","rollup://@epam/uui-core/src/data/processing/BaseDataSource.tsx","rollup://@epam/uui-core/src/data/processing/ArrayDataSource.tsx","rollup://@epam/uui-core/src/hooks/useColumnsConfig.ts","rollup://@epam/uui-core/src/ssr/useLayoutEffectSafeForSsr.ts","rollup://@epam/uui-core/src/hooks/useVirtualList/utils.ts","rollup://@epam/uui-core/src/hooks/useVirtualList/useVirtualList.ts","rollup://@epam/uui-core/src/hooks/useScrollShadows.ts","rollup://@epam/uui-core/src/hooks/useForceUpdate.ts","rollup://@epam/uui-core/src/hooks/useUuiError.ts","rollup://@epam/uui-core/src/hooks/useTableState/utils.ts","rollup://@epam/uui-core/src/hooks/useTableState/useTableState.ts","rollup://@epam/uui-core/src/hooks/useLayer.ts","rollup://@epam/uui-core/src/hooks/useResizeObserver.ts","rollup://@epam/uui-core/src/hooks/useDocumentDir.tsx","rollup://@epam/uui-core/src/hooks/useIsActive.ts","rollup://@epam/uui-core/src/data/processing/AsyncDataSource.tsx","rollup://@epam/uui-core/src/helpers/useMemoWithDestructor.ts","rollup://@epam/uui-core/src/data/processing/hooks/useAsyncDataSource.ts","rollup://@epam/uui-core/src/data/processing/hooks/useArrayDataSource.ts","rollup://@epam/uui-core/src/data/processing/LazyDataSource.tsx","rollup://@epam/uui-core/src/data/processing/hooks/useLazyDataSource.ts","rollup://@epam/uui-core/src/i18n.ts","rollup://@epam/uui-core/src/data/validation/validate.ts","rollup://@epam/uui-core/src/data/validation/validateServerErrorState.ts","rollup://@epam/uui-core/src/data/validation/mergeValidation.ts","rollup://@epam/uui-core/src/data/lenses/lensesImpl.tsx","rollup://@epam/uui-core/src/data/lenses/LensBuilder.ts","rollup://@epam/uui-core/src/data/lenses/builders.ts","rollup://@epam/uui-core/src/data/lenses/index.ts","rollup://@epam/uui-core/src/data/forms/useLock.ts","rollup://@epam/uui-core/src/data/forms/shouldCreateUndoCheckpoint.ts","rollup://@epam/uui-core/src/data/forms/useForm.ts","rollup://@epam/uui-core/src/data/forms/Form.tsx","rollup://@epam/uui-core/src/ssr/useUuiServicesSsr.tsx","rollup://@epam/uui-core/src/ssr/useNextAppRouter.ts"],"names":[],"mappings":"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","file":"/npm/@epam/uui-core@6.4.1/index.js","sourceRoot":"","sourcesContent":["/**\n * Minified by jsDelivr using Terser v5.39.0.\n * Original file: /npm/@epam/uui-core@6.4.1/index.js\n *\n * Do NOT use SRI with dynamically generated files! More information: https://www.jsdelivr.com/using-sri-with-dynamic-files\n */\n","export const uuiElement = {\n    widget: 'uui-widget',\n    buttonBox: 'uui-button-box',\n    anchor: 'uui-anchor',\n    inputBox: 'uui-input-box',\n    input: 'uui-input',\n    placeholder: 'uui-placeholder',\n    valueInPlaceholder: 'uui-value-in-placeholder',\n    checkbox: 'uui-checkbox',\n    checkboxContainer: 'uui-checkbox-container',\n    foldingArrow: 'uui-folding-arrow',\n    radioInput: 'uui-radioinput',\n    icon: 'uui-icon',\n    iconPrimary: 'uui-icon-primary',\n    count: 'uui-count',\n    caption: 'uui-caption',\n    label: 'uui-label',\n    labeledContainer: 'uui-labeled-container',\n    inputLabel: 'uui-input-label',\n    invalidMessage: 'uui-invalid-message',\n    dropdownBody: 'uui-dropdown-body',\n    switchBody: 'uui-switch-body',\n    switchToggler: 'uui-switch-toggler',\n    ratingStar: 'uui-rating-star',\n    tooltipContainer: 'uui-tooltip-container',\n    tooltipBody: 'uui-tooltip-body',\n    tooltipArrow: 'uui-tooltip-arrow',\n    modalBlocker: 'uui-modal-blocker',\n    modalWindow: 'uui-modal-window',\n    textareaCounter: 'uui-textarea-counter',\n} as const;\n\nexport const uuiMod = {\n    enabled: 'uui-enabled',\n    disabled: 'uui-disabled',\n    readonly: 'uui-readonly',\n    focus: 'uui-focus',\n    active: 'uui-active',\n    invalid: 'uui-invalid',\n    checked: 'uui-checked',\n    selected: 'uui-selected',\n    opened: 'uui-opened',\n    loading: 'uui-loading',\n    error: 'uui-error',\n} as const;\n\nexport const labelMod = {\n    left: 'uui-label-left',\n    top: 'uui-label-top',\n} as const;\n\nexport const directionMode = {\n    vertical: 'uui-vertical-direction',\n    horizontal: 'uui-horizontal-direction',\n} as const;\n\nexport const uuiMarkers = {\n    lockFocus: '-lock-focus',\n    clickable: '-clickable',\n    focusable: '-focusable',\n    draggable: '-draggable',\n    resizable: 'uui-resizable',\n    hasValue: 'uui-has-value',\n    scrolledLeft: '-scrolled-left',\n    scrolledRight: '-scrolled-right',\n    scrolledTop: '-scrolled-top',\n    scrolledBottom: '-scrolled-bottom',\n} as const;\n\nexport const uuiDndState = {\n    draggedOut: 'uui-dragged-out',\n    dropAccepted: 'uui-drop-accepted',\n    dragGhost: 'uui-drag-ghost',\n} as const;\n\nexport const uuiDataTableHeaderCell = {\n    uuiTableHeaderCell: 'uui-table-header-cell',\n    uuiTableHeaderCaption: 'uui-table-header-caption',\n    uuiTableHeaderCaptionWrapper: 'uui-table-header-caption-wrapper',\n    uuiTableHeaderCaptionTooltip: 'uui-table-header-caption-tooltip',\n    uuiTableHeaderCheckbox: 'uui-table-header-checkbox',\n    uuiTableHeaderSortIcon: 'uui-table-header-sort-icon',\n    uuiTableHeaderFilterIcon: 'uui-table-header-filter-icon',\n    uuiTableHeaderDropdownIcon: 'uui-table-header-dropdown-icon',\n    uuiTableHeaderFoldAllIcon: 'uui-table-header-fold-all-icon',\n} as const;\n\nexport const uuiDataTableHeaderGroupCell = {\n    uuiTableHeaderGroupCell: 'uui-table-header-group-cell',\n    uuiTableHeaderGroupCaption: 'uui-table-header-group-caption',\n    uuiTableHeaderGroupCaptionWrapper: 'uui-table-header-group-caption-wrapper',\n    uuiTableHeaderGroupCaptionTooltip: 'uui-table-header-group-caption-tooltip',\n} as const;\n\nexport const uuiScrollShadows = {\n    top: 'uui-scroll-shadow-top',\n    topVisible: 'uui-scroll-shadow-top-visible',\n    bottom: 'uui-scroll-shadow-bottom',\n    bottomVisible: 'uui-scroll-shadow-bottom-visible',\n} as const;\n","import React from 'react';\n\n/**\n * React forward-ref function, with a patched type, allowed generic types to pass-thru\n * More here: https://fettblog.eu/typescript-react-generic-forward-refs/\n * We go with re-export this way, instead of patching React typings, to not break typings in dependent projects.\n */\nexport const forwardRef = React.forwardRef as <T, P = {}>(\n    render: (props: P, ref: React.Ref<T>) => React.ReactElement<any> | null\n) => (props: P & React.RefAttributes<T>) => React.ReactElement<any> | null;\n","import * as React from 'react';\nimport { CX, IHasCX } from '../types';\nimport { forwardRef } from './forwardRef';\n\nexport function withMods<TSource, TResult>(\n    Component: React.ComponentType<TSource>,\n    getCx?: (props: Readonly<TResult>) => CX,\n    getProps?: (props: TResult) => Partial<TSource>,\n): React.ComponentType<TResult & React.RefAttributes<any>> {\n    const isClassComponent = Component.prototype instanceof React.Component;\n\n    // Class components needs to be wrapped in any case,\n    // as they might rely on withMods to add forwardedRef.\n    if (!isClassComponent && !getProps && !getCx) {\n        return Component as any;\n    }\n\n    function applyMods(props: Readonly<TResult>) {\n        // Most components are wrapped in withMods component.\n        // Please keep this method simple and performant.\n        // Don't clone objects/arrays if not needed.\n\n        const modProps = getProps?.(props);\n        const result: Readonly<TResult> = Object.assign({}, props, modProps);\n\n        const cx = getCx?.(props);\n\n        if (cx) {\n            (result as IHasCX).cx = [cx, (props as any).cx];\n        }\n\n        return result;\n    }\n\n    let wrappedComponent: React.ComponentType<TResult & React.RefAttributes<any>>;\n\n    if (!Component) {\n        // Happens in tests, probably due to circular dependencies.\n        return null;\n    } else if (isClassComponent) {\n        // Class component. Wrap with forwardRef, and pass ref in the forwardedRef prop\n        wrappedComponent = forwardRef<any, Readonly<TResult>>((props, ref) => {\n            const allProps: any = applyMods(props);\n            allProps.forwardedRef = ref;\n            return React.createElement(Component, allProps);\n        });\n    } else if ((Component as any).render) {\n        // React.forwardRef component.\n        // Basically its object like { $$type: Symbol(FORWARD_REF), render: (props, ref) => ... }\n        // However, $$type is not exposed, so there's no good way to detect this.\n        // We re-wrap it in another forward ref, to avoid unnecessary stacking two forwardRefs\n        wrappedComponent = forwardRef(\n            (props: Readonly<TResult>, ref: any) => (Component as any).render(applyMods(props), ref),\n        );\n    } else if (Component instanceof Function) {\n        // Plain functional component. Just wrap with function, and apply mods to props\n        wrappedComponent = (props: TResult) => (Component as Function)(applyMods(props));\n    } else {\n        // Any other type of component. E.g. React.memo.\n        // Wrap it in another functional component\n        wrappedComponent = forwardRef<any, Readonly<TResult>>((props: TResult, ref) => {\n            const resultProps = applyMods(props);\n            (resultProps as any).ref = ref;\n            return React.createElement(Component, resultProps);\n        });\n    }\n\n    wrappedComponent.displayName = `${Component?.displayName || Component?.name || 'unknown'} (withMods)`;\n\n    return wrappedComponent;\n}\n","import * as React from 'react';\nimport { uuiElement, uuiMarkers } from '../constants';\n\nexport function isEventTargetInsideClickable(e: React.SyntheticEvent<Element>): boolean {\n    return isAnyParentHasClass(_getEventTarget(e), e.currentTarget, [uuiMarkers.clickable]);\n}\n\nexport function isEventTargetInsideDraggable(e: React.PointerEvent, toElement: Node) {\n    return isAnyParentHasClass(_getEventTarget(e), toElement, [uuiMarkers.draggable]);\n}\n\nexport function isEventTargetInsideInput(e: Event | React.PointerEvent, toElement: Node) {\n    return isAnyParentHasClass(_getEventTarget(e), toElement, [uuiElement.input]);\n}\n\nexport function releasePointerCaptureOnEventTarget(e: React.PointerEvent) {\n    (_getEventTarget(e) as HTMLElement).releasePointerCapture(e.pointerId);\n}\n\n/**\n * Iterates parent elements starting from \"fromElement\" and goes through its parents until \"toElement\" is found.\n * It returns true if any element along this path contains one of the class names specified in the \"classNames\" array.\n *\n * @param fromElement\n * @param toElement\n * @param classNames\n */\nexport function isAnyParentHasClass(fromElement: EventTarget, toElement: Node, classNames: string[]): boolean {\n    let el = fromElement as HTMLElement;\n    while (el && toElement !== el) {\n        if (el.classList && classNames.some((className) => el.classList.contains(className))) {\n            return true;\n        }\n        el = _getParentElement(el) as HTMLElement;\n    }\n    return false;\n}\n\nexport function blurFocusedElement() {\n    const elem = _getActiveElement() as HTMLElement;\n    elem?.blur();\n}\n\nexport function preventDefaultIfTargetFocused(e: Event) {\n    if (_getActiveElement() === e.target) {\n        e.preventDefault();\n    }\n}\n\n/**\n * Works exactly like native \"closest\" method, with next enhancements:\n * - supports HTMLElement as a selector\n * - takes Event as an input and performs search for the \"event target\" or \"event related target\" for focus/blur events.\n *\n * @param event\n * @param condition\n */\nexport function closestTargetParentByCondition(e: Event, condition: string | HTMLElement) {\n    const element = _getInteractionTarget(e) as HTMLElement;\n    if (!element || !condition) {\n        return null;\n    }\n    const conditionCallback = (elem: HTMLElement) => {\n        if (typeof condition === 'string') {\n            return elem.matches(condition);\n        }\n        return condition === elem;\n    };\n    if (conditionCallback(element)) {\n        return element;\n    }\n    let parent = _getParentElement(element) as HTMLElement;\n    while (parent) {\n        if (conditionCallback(parent)) {\n            return parent as HTMLElement;\n        }\n        parent = _getParentElement(parent) as HTMLElement;\n    }\n    return null;\n}\n\nexport function getScrollParentOfEventTarget(event: Event, dimension: 'x' | 'y'): HTMLElement {\n    const node = _getEventTarget(event) as HTMLElement;\n    return _getScrollParent(node, dimension);\n}\n\n/**\n * ↓ PRIVATE methods below this comment ↓\n */\n\n/**\n * Works as normal \"element.parentElement\" with next enhancement:\n * - If direct parent element is a shadow root, then it returns the shadow host element instead of null.\n * @param element\n */\nfunction _getParentElement(element: Element) {\n    let parentElem: Element = element.parentElement;\n    const parentNode: Node = element.parentNode;\n    if (!parentElem && parentNode instanceof ShadowRoot) {\n        parentElem = parentNode.host;\n    }\n    return parentElem;\n}\n\n/**\n * Works as normal \"document.activeElement\" with next enhancement:\n * - if focused element is located inside shadow DOM, then it returns actual focused element instead of the shadow DOM host.\n */\nfunction _getActiveElement(): HTMLElement | null {\n    const activeEl = document.activeElement || null;\n    if (activeEl && activeEl.shadowRoot) {\n        return activeEl.shadowRoot.activeElement as HTMLElement;\n    }\n    return activeEl as HTMLElement;\n}\n\nfunction _getScrollParent(node: HTMLElement, dimension: 'x' | 'y'): HTMLElement {\n    if (node == null) {\n        return null;\n    }\n\n    const isElement = node instanceof HTMLElement;\n    const style = isElement && window.getComputedStyle(node);\n\n    let overflow: string;\n    let scrollSize: number;\n    let clientSize: number;\n\n    if (dimension === 'x') {\n        overflow = style && style.overflowX;\n        scrollSize = node.scrollWidth;\n        clientSize = node.clientWidth;\n    } else {\n        overflow = style && style.overflowY;\n        scrollSize = node.scrollHeight;\n        clientSize = node.clientHeight;\n    }\n\n    const isScrollable = overflow !== 'visible' && overflow !== 'hidden';\n\n    if (isScrollable && scrollSize > clientSize) {\n        return node;\n    } else {\n        return _getScrollParent(_getParentElement(node) as HTMLElement, dimension);\n    }\n}\n\n/**\n * 1. For native Event - works as normal \"event.target\" with next enhancement:\n *    - If event occurs inside shadow DOM and caught outside the shadow dom then the real target is returned instead of the shadow DOM host.\n * 2. For React synthetic event - just returns \"event.target\" because it already points to the actual target.\n *\n * @param event\n */\nfunction _getEventTarget(event: Event | React.SyntheticEvent) {\n    if (event instanceof Event) {\n        let target;\n        if (['focus', 'blur', 'focusin', 'focusout'].includes(event.type)) {\n            target = (event as FocusEvent).relatedTarget;\n        } else {\n            target = event.target;\n        }\n\n        if (target instanceof Element && target.shadowRoot) {\n            /**\n             * If event occurs inside shadow DOM and caught outside the shadow dom,\n             * then \"event.target\" points to the shadow dom host, instead of the real target\n             */\n            return event.composedPath()[0];\n        }\n        return target;\n    }\n    // event target is always correct in synthetic events.\n    return event.target;\n}\n\nconst _isFocusEvent = (e: Event | React.SyntheticEvent | FocusEvent): e is FocusEvent =>\n    ['focus', 'blur', 'focusin', 'focusout'].includes(e.type);\n\nfunction _getInteractionTarget(e: Event | React.SyntheticEvent) {\n    if (_isFocusEvent(e)) {\n        return e.relatedTarget;\n    }\n\n    return _getEventTarget(e);\n}\n","export function arrayToMatrix(array: Array<any>, divider: number) {\n    const matrix = [];\n    for (let i = 0; i < array.length / divider; i += 1) {\n        matrix.push(array.slice(i * divider, (i + 1) * divider));\n    }\n    return matrix;\n}\n","import classNames from 'classnames';\n\ninterface ClassDictionary {\n    [id: string]: any;\n}\n\ninterface ClassArray extends Array<ClassValue> {}\n\n/* The ClassValue type is a union type that represents the valid values that can be passed as arguments to the classnames function. It can be one of the following types:\n- string: A string representing a class name.\n- number: A number representing a class name. This is useful when using CSS modules.\n- ClassDictionary: An object whose keys are class names and values are booleans. If the value is true, the corresponding class name will be included in the resulting string, otherwise it will be omitted.\n- ClassArray: An array of values of type ClassValue. This allows you to pass multiple class names or class dictionaries as arguments to classnames.\n- undefined: If undefined is passed as an argument, it will be ignored.\n- null: If null is passed as an argument, it will be ignored.\n- boolean: If a boolean value is passed as an argument, it will be ignored if it is false and included if it is true. */\nexport type ClassValue = string | number | ClassDictionary | ClassArray | undefined | null | boolean;\n\nexport const cx = (...args: ClassValue[]) => {\n    return classNames(...args);\n};\n","export const isClientSide = typeof window !== 'undefined';\n","export function getOffset(element: Element) {\n    const box = element.getBoundingClientRect();\n\n    return {\n        top: box.top + window.pageYOffset - document.documentElement.clientTop,\n        left: box.left + window.pageXOffset - document.documentElement.clientLeft,\n    };\n}\n","import ReactDOM from 'react-dom';\n\nexport class BaseContext<TState = {}> {\n    private handlers: ((state: TState) => void)[] = [];\n\n    init() {\n\n    }\n\n    subscribe(handler: (state: TState) => void) {\n        this.handlers.push(handler);\n    }\n\n    unsubscribe(handler: (state: TState) => void) {\n        this.handlers = this.handlers.filter((h) => h !== handler);\n    }\n\n    update(state: TState) {\n        ReactDOM.unstable_batchedUpdates(() => {\n            this.handlers.forEach((h) => h && h(state));\n        });\n    }\n\n    destroyContext() {\n        this.handlers = [];\n    }\n}\n","import { isClientSide } from '../../helpers/ssr';\nimport { getOffset } from '../../helpers/getOffset';\nimport { getScrollParentOfEventTarget } from '../../helpers/events';\nimport * as React from 'react';\nimport { IDndContext } from '../../types/contexts';\nimport { BaseContext } from '../BaseContext';\n\nconst maxScrollSpeed = 2000; // px/second\n\nexport interface DndContextState {\n    isDragging: boolean;\n    ghostOffsetX?: number;\n    ghostOffsetY?: number;\n    ghostWidth?: number;\n\n    renderGhost?(): React.ReactNode;\n}\n\nexport class DndContext extends BaseContext<DndContextState> implements IDndContext {\n    public isDragging = false;\n    public dragData: any;\n    private scrollZoneSize = 85;\n    private ghostOffsetX: number = 0;\n    private ghostOffsetY: number = 0;\n    private ghostWidth: number = 300;\n    private renderGhostCallback: () => React.ReactNode = null;\n    private lastScrollTime = new Date().getTime();\n    private mouseCoordsService = new MouseCoordsService();\n\n    init() {\n        super.init();\n\n        if (isClientSide) {\n            this.mouseCoordsService.init();\n            window.addEventListener('pointermove', this.windowPointerMoveHandler);\n            window.addEventListener('pointerup', this.windowPointerUpHandler);\n        }\n    }\n\n    public destroyContext() {\n        super.destroyContext();\n        if (isClientSide) {\n            window.removeEventListener('pointermove', this.windowPointerMoveHandler);\n            window.removeEventListener('pointerup', this.windowPointerUpHandler);\n            this.mouseCoordsService.destroy();\n\n            // Cleanup cursor override if still present\n            this.cleanupCursorOverride();\n        }\n    }\n\n    /**\n     * Cleans up cursor override styles and classes.\n     * This method ensures that any temporary cursor modifications during drag operations\n     * are properly removed to prevent memory leaks and UI inconsistencies.\n     *\n     * - Removes the injected <style> element with id 'uui-drag-cursor-override'\n     * - Removes the 'uui-dragging' class from document.body\n     * - Safe to call multiple times (idempotent)\n     */\n    private cleanupCursorOverride() {\n        const style = document.getElementById('uui-drag-cursor-override');\n        if (style) {\n            document.head.removeChild(style);\n        }\n        document.body.classList.remove('uui-dragging');\n    }\n\n    public getMouseCoords = (): TMouseCoords => {\n        return this.mouseCoordsService.getCoords();\n    };\n\n    public startDrag(node: HTMLElement, data: {}, renderGhost: () => React.ReactNode) {\n        const offset = getOffset(node);\n        const mouseCoords = this.mouseCoordsService.getCoords();\n\n        this.ghostOffsetX = offset.left - mouseCoords.mouseDownPageX - parseInt(getComputedStyle(node, null).marginLeft, 10);\n        this.ghostOffsetY = offset.top - mouseCoords.mouseDownPageY - parseInt(getComputedStyle(node, null).marginTop, 10);\n        this.ghostWidth = node.offsetWidth + parseInt(getComputedStyle(node, null).marginLeft, 10) + parseInt(getComputedStyle(node, null).marginRight, 10);\n\n        this.dragData = data;\n        this.renderGhostCallback = renderGhost;\n\n        // Set cursor for drag operation\n        // This creates a global cursor override to ensure 'grabbing' cursor is shown\n        // during drag operations, regardless of individual element cursor styles\n        // Remove any existing style first to prevent duplicates\n        this.cleanupCursorOverride();\n\n        // Inject CSS that forces 'grabbing' cursor on all elements during drag\n        // Uses high specificity selector with !important to override any existing styles\n        const style = document.createElement('style');\n        style.id = 'uui-drag-cursor-override';\n        style.textContent = 'body.uui-dragging *, body.uui-dragging *:hover { cursor: grabbing !important; }';\n        document.head.appendChild(style);\n        document.body.classList.add('uui-dragging');\n\n        // prepare scroll\n        this.lastScrollTime = new Date().getTime();\n        isClientSide && window.requestAnimationFrame(() => this.scrollWindow());\n\n        this.update({\n            isDragging: true,\n            ghostOffsetX: this.ghostOffsetX,\n            ghostOffsetY: this.ghostOffsetY,\n            ghostWidth: this.ghostWidth,\n            renderGhost: this.renderGhostCallback,\n        });\n        this.isDragging = true;\n\n        // To close dropdowns\n        const ev = document.createEvent('Events');\n        ev.initEvent('dragstart', true, false);\n        document.body.dispatchEvent(ev);\n    }\n\n    public endDrag() {\n        if (!this.isDragging) {\n            return;\n        }\n\n        // Reset cursor immediately\n        // Clean up cursor override to restore normal cursor behavior\n        // Must be done synchronously to prevent cursor flickering or stuck states\n        this.cleanupCursorOverride();\n\n        new Promise<void>((res) => {\n            this.update({ isDragging: false });\n            res();\n        }).then(() => {\n            this.renderGhostCallback = null;\n            this.dragData = null;\n            this.isDragging = false;\n        });\n    }\n\n    xScrollNode: HTMLElement = null;\n    yScrollNode: HTMLElement = null;\n    private windowPointerMoveHandler = (e: PointerEvent) => {\n        if (this.isDragging) {\n            this.xScrollNode = getScrollParentOfEventTarget(e, 'x');\n            this.yScrollNode = getScrollParentOfEventTarget(e, 'y');\n        }\n    };\n\n    /**\n     * Handles global pointer up events to ensure drag operations are properly terminated.\n     * This is a safety mechanism that cleans up drag state even if endDrag() fails to be called.\n     *\n     * - Cleans up cursor override styles immediately\n     * - Calls endDrag() to complete the drag operation cleanup\n     * - Prevents stuck drag states that could occur from unexpected pointer releases\n     */\n    private windowPointerUpHandler = () => {\n        this.cleanupCursorOverride();\n        this.endDrag();\n    };\n\n    private getScrollStep(nodeSize: number, nodeOffset: number, nodeScroll: number, mousePageCoord: number, mouseDelta: number) {\n        const now = new Date().getTime();\n\n        const startToMouse = mousePageCoord - nodeOffset;\n        const endToMouse = nodeOffset + nodeSize - mousePageCoord;\n        const scrollZoneSize = Math.min(this.scrollZoneSize, nodeSize / 4);\n\n        let scrollDir = 0;\n\n        // left/up\n        if (mouseDelta < 0.5) {\n            scrollDir = -Math.max(0, (scrollZoneSize - startToMouse) / scrollZoneSize);\n        }\n\n        // right/down\n        if (mouseDelta > 0.5) {\n            scrollDir = Math.max(0, (scrollZoneSize - endToMouse) / scrollZoneSize);\n        }\n\n        if (scrollDir !== 0) {\n            const step = ((now - this.lastScrollTime) / 1000) * maxScrollSpeed * scrollDir;\n            return nodeScroll + step;\n        }\n    }\n\n    private scrollWindow() {\n        const now = new Date().getTime();\n        const mouseCoords = this.mouseCoordsService.getCoords();\n\n        if (this.xScrollNode) {\n            const scrollX = this.getScrollStep(\n                this.xScrollNode.offsetWidth,\n                getOffset(this.xScrollNode).left,\n                this.xScrollNode.scrollLeft,\n                mouseCoords.mousePageX,\n                mouseCoords.mouseDxSmooth,\n            );\n\n            if (scrollX !== undefined && scrollX !== 0) {\n                this.xScrollNode.scrollLeft = scrollX;\n            }\n        }\n\n        if (this.yScrollNode) {\n            const scrollY = this.getScrollStep(\n                this.yScrollNode.offsetHeight,\n                getOffset(this.yScrollNode).top,\n                this.yScrollNode.scrollTop,\n                mouseCoords.mousePageY,\n                mouseCoords.mouseDySmooth,\n            );\n\n            if (scrollY !== undefined && scrollY !== 0) {\n                this.yScrollNode.scrollTop = scrollY;\n            }\n        }\n\n        this.lastScrollTime = now;\n\n        if (this.isDragging) {\n            window.requestAnimationFrame(() => this.scrollWindow());\n        }\n    }\n}\n\nexport type TMouseCoords = {\n    mousePageX: number,\n    mousePageY: number,\n    mouseDx: number,\n    mouseDy: number,\n    mouseDxSmooth: number,\n    mouseDySmooth: number,\n    mouseDownPageX: number,\n    mouseDownPageY: number,\n    buttons: number,\n};\n\nclass MouseCoordsService {\n    private _prevMouseCoords: TMouseCoords;\n\n    init = () => {\n        this._prevMouseCoords = {\n            mousePageX: 0,\n            mousePageY: 0,\n            mouseDx: 0,\n            mouseDy: 0,\n            mouseDxSmooth: 0,\n            mouseDySmooth: 0,\n            mouseDownPageX: 0,\n            mouseDownPageY: 0,\n            buttons: 0,\n        };\n        if (isClientSide) {\n            document.addEventListener('pointermove', this.handleMouseCoordsChange);\n        }\n    };\n\n    public destroy() {\n        if (isClientSide) {\n            document.removeEventListener('pointermove', this.handleMouseCoordsChange);\n        }\n    }\n\n    private handleMouseCoordsChange = (e: PointerEvent) => {\n        this._prevMouseCoords = getMouseCoordsFromPointerEvent(e, this._prevMouseCoords);\n    };\n\n    public getCoords = () => {\n        return this._prevMouseCoords;\n    };\n}\n\nfunction getMouseCoordsFromPointerEvent(e: PointerEvent, prevCoords: TMouseCoords): TMouseCoords {\n    const mouseDx = e.pageX - prevCoords.mousePageX;\n    const mouseDy = e.pageY - prevCoords.mousePageY;\n    const mouseDxSmooth = prevCoords.mouseDxSmooth * 0.8 + mouseDx * 0.2;\n    const mouseDySmooth = prevCoords.mouseDySmooth * 0.8 + mouseDy * 0.2;\n    const mousePageX = e.pageX;\n    const mousePageY = e.pageY;\n    const result: TMouseCoords = {\n        mouseDx,\n        mouseDy,\n        mouseDxSmooth,\n        mouseDySmooth,\n        mousePageX,\n        mousePageY,\n        buttons: e.buttons,\n        mouseDownPageX: prevCoords.mouseDownPageX || 0,\n        mouseDownPageY: prevCoords.mouseDownPageY || 0,\n    };\n    if ((prevCoords.buttons === 0 && e.buttons > 0) || e.pointerType === 'touch') {\n        result.mouseDownPageX = mousePageX;\n        result.mouseDownPageY = mousePageY;\n    }\n    return result;\n}\n","import { createContext } from 'react';\nimport { CommonContexts } from '../types';\n\nexport const UuiContext = createContext({} as CommonContexts<any, any>);\n","import * as React from 'react';\nimport { UuiContexts } from '../../types/contexts';\nimport { DndContextState } from './DndContext';\nimport { LayoutLayer } from '../LayoutContext';\nimport { UuiContext } from '../UuiContext';\n\nexport interface DragGhostProps {}\n\ninterface DragGhostState extends DndContextState {\n    pointerX?: number;\n    pointerY?: number;\n}\n\nexport class DragGhost extends React.Component<DragGhostProps, DragGhostState> {\n    static contextType = UuiContext;\n    context: UuiContexts;\n    private layer: LayoutLayer = null;\n    state: DragGhostState = {\n        isDragging: false,\n    };\n\n    onPointerMove = (e: PointerEvent) => {\n        if (this.state.isDragging) {\n            this.setState((state) => ({ ...state, pointerX: e.clientX, pointerY: e.clientY }));\n        }\n    };\n\n    contextUpdateHandler = (state: DndContextState) => {\n        if (state.isDragging && !this.layer) {\n            this.layer = this.context.uuiLayout?.getLayer();\n        } else if (!state.isDragging && this.layer) {\n            this.context.uuiLayout.releaseLayer(this.layer);\n            this.layer = null;\n        }\n        const mouseCoords = this.context.uuiDnD.getMouseCoords();\n        this.setState({ ...state, pointerX: mouseCoords.mousePageX, pointerY: mouseCoords.mousePageY });\n    };\n\n    componentDidMount() {\n        if (!this.context) return;\n        this.context.uuiDnD.subscribe(this.contextUpdateHandler);\n        window.addEventListener('pointermove', this.onPointerMove);\n    }\n\n    componentWillUnmount() {\n        this.layer && this.context.uuiLayout.releaseLayer(this.layer);\n        window.removeEventListener('pointermove', this.onPointerMove);\n        this.context.uuiDnD.unsubscribe(this.contextUpdateHandler);\n    }\n\n    getGhostCoords(pointerX: number, pointerY: number) {\n        return {\n            left: pointerX + this.state.ghostOffsetX,\n            top: pointerY + this.state.ghostOffsetY,\n        };\n    }\n\n    render() {\n        if (!this.state.isDragging || !this.state.renderGhost) {\n            return null;\n        }\n\n        return (\n            <div\n                style={ {\n                    position: 'fixed',\n                    width: this.state.ghostWidth,\n                    left: this.state.pointerX + this.state.ghostOffsetX,\n                    top: this.state.pointerY + this.state.ghostOffsetY,\n                    pointerEvents: 'none',\n                    zIndex: this.layer.zIndex,\n                } }\n            >\n                {this.state.renderGhost()}\n            </div>\n        );\n    }\n}\n","export function getSector(x: number, y: number) {\n    const rads = Math.atan2(y, x); // (-PI, PI)\n    const rotatedRads = rads + Math.PI * 2 + Math.PI / 2; // rotate to make positive and align with clock convention (top is the 0)\n    const sector = Math.floor((rotatedRads / (Math.PI * 2)) * 8) % 8;\n    return sector;\n}\n","import * as React from 'react';\nimport {\n    IDndActor, DropPosition, AcceptDropParams, DndActorRenderParams, DropPositionOptions,\n} from '../../types/dnd';\n\nimport { UuiContexts } from '../../types/contexts';\n\nimport {\n    isEventTargetInsideDraggable,\n    isEventTargetInsideInput,\n    releasePointerCaptureOnEventTarget,\n} from '../../helpers/events';\nimport { getSector } from './helpers';\nimport { uuiDndState, uuiMarkers } from '../../constants';\nimport { UuiContext } from '../UuiContext';\nimport { DndContextState } from './DndContext';\n\nexport interface DndActorProps<TSrcData, TDstData> extends IDndActor<TSrcData, TDstData> {\n    /** Render callback for DragActor content */\n    render(props: DndActorRenderParams): React.ReactNode;\n}\n\nconst DND_START_THRESHOLD = 5;\n\ninterface DndActorState {\n    pointerX: number;\n    pointerY: number;\n    isMouseDown: boolean;\n    isDragging: boolean;\n    isMouseOver: boolean;\n    position?: DropPosition;\n    dndContextState: DndContextState;\n}\n\nconst initialState: DndActorState = {\n    pointerX: 0,\n    pointerY: 0,\n    isMouseDown: false,\n    isDragging: false,\n    isMouseOver: false,\n    position: null,\n    dndContextState: {\n        isDragging: false,\n    },\n};\n\n/**\n * This workaround is needed to make it tree-shakable, but it does not look good.\n * It's better to rewrite it to functional component instead.\n * The key point here is to get rid of any static props (like sectorPositionPriorities, contextType).\n */\n\nexport const DndActor = TREE_SHAKEABLE_INIT();\nfunction TREE_SHAKEABLE_INIT() {\n    return class DndActorComponent<TSrcData = any, TDstData = any> extends React.Component<DndActorProps<TSrcData, TDstData>, DndActorState> {\n        state = initialState;\n        static contextType = UuiContext;\n        public context: UuiContexts;\n        dndRef = React.createRef<HTMLElement>();\n\n        componentDidMount() {\n            this.context?.uuiDnD?.subscribe?.(this.contextUpdateHandler);\n            window.addEventListener('pointerup', this.windowPointerUpHandler);\n            window.addEventListener('pointermove', this.windowPointerMoveHandler);\n        }\n\n        componentWillUnmount() {\n            window.removeEventListener('pointerup', this.windowPointerUpHandler);\n            window.removeEventListener('pointermove', this.windowPointerMoveHandler);\n            this.context.uuiDnD.unsubscribe(this.contextUpdateHandler);\n        }\n\n        contextUpdateHandler = (dndContextState: DndContextState) => {\n            this.setState({ dndContextState });\n        };\n\n        windowPointerUpHandler = () => {\n            if (this.state.isDragging || this.state.isMouseDown) {\n                this.setState(() => initialState);\n                this.context.uuiDnD.endDrag();\n            }\n        };\n\n        windowPointerMoveHandler = (e: MouseEvent) => {\n            if (\n                !this.state.isMouseDown\n                    || e.buttons === 0 // can happen if native drag-n-drop occurs\n                    || this.state.isDragging\n            ) return;\n\n            if (isEventTargetInsideInput(e, this.dndRef.current)) {\n                return;\n            }\n\n            const mouseCoords = this.context.uuiDnD.getMouseCoords();\n            const dist = Math.sqrt(Math.pow(this.state.pointerX - mouseCoords.mousePageX, 2) + Math.pow(this.state.pointerY - mouseCoords.mousePageY, 2));\n\n            if (dist > DND_START_THRESHOLD) {\n                this.context.uuiDnD.startDrag(this.dndRef.current, this.props.srcData, () =>\n                    this.props.render({\n                        isDragGhost: true,\n                        isDraggedOver: false,\n                        isDraggable: false,\n                        isDraggedOut: false,\n                        isDropAccepted: false,\n                        isDndInProgress: true,\n                        eventHandlers: {},\n                        classNames: [uuiDndState.dragGhost],\n                    }));\n\n                this.setState((s) => ({\n                    ...s,\n                    isDragging: true,\n                    isDropAccepted: false /* TBD: fix state when DnD is just started, and drop is accepted by underlying element */,\n                }));\n            }\n        };\n\n        getDropParams(e: React.MouseEvent<HTMLElement>): AcceptDropParams<TSrcData, TDstData> {\n            const {\n                left, top, width, height,\n            } = e.currentTarget.getBoundingClientRect();\n\n            return {\n                srcData: this.context.uuiDnD.dragData,\n                dstData: this.props.dstData,\n                offsetLeft: e.clientX - left,\n                offsetTop: e.clientY - top,\n                targetWidth: width,\n                targetHeight: height,\n            };\n        }\n\n        static sectorPositionPriorities: Record<string, DropPosition[]> = {\n            0: [\n                'top', 'right', 'inside',\n            ],\n            1: [\n                'right', 'top', 'inside',\n            ],\n            2: [\n                'right', 'bottom', 'inside',\n            ],\n            3: [\n                'bottom', 'right', 'inside',\n            ],\n            4: [\n                'bottom', 'left', 'inside',\n            ],\n            5: [\n                'left', 'bottom', 'inside',\n            ],\n            6: [\n                'left', 'top', 'inside',\n            ],\n            7: [\n                'top', 'left', 'inside',\n            ],\n        };\n\n        getPosition(params: AcceptDropParams<TSrcData, TDstData>, options: DropPositionOptions): DropPosition {\n            if (options == null) return null;\n\n            // Compute x/y offsets relative to the center, normalized by element dimensions:\n            // -------------------------------\n            // |(-1, -1)   (0,-1)     (1, -1)|\n            // |                             |\n            // |(-1,  0)   (0, 0)     (1,  0)|\n            // |                             |\n            // |(-1,  1)   (0, 1)     (1,  1)|\n            // -------------------------------\n            const x = (params.offsetLeft / params.targetWidth - 0.5) * 2;\n            const y = (params.offsetTop / params.targetHeight - 0.5) * 2;\n\n            if (options.inside) {\n                const insideBoxLeft = options.left ? -0.5 : -1;\n                const insideBoxRight = options.right ? 0.5 : 1;\n                const insideBoxTop = options.top ? -0.5 : -1;\n                const insideBoxBottom = options.bottom ? 0.5 : 1;\n\n                if (insideBoxLeft < x && x < insideBoxRight && insideBoxTop < y && y < insideBoxBottom) {\n                    return 'inside';\n                }\n            }\n\n            // Compute the sector#. Basically it's clock-wise angle of mouse pointer normalized to [0,7) range\n            //    7 | 0\n            // 6    |    1\n            // -----|------\n            // 5    |    2\n            //    4 | 3\n            const sector = getSector(x, y);\n\n            // Get possible positions, ordered by priority, from the lookup table\n            const optionsByPriority = DndActor.sectorPositionPriorities[sector + ''].filter((o) => options[o]);\n\n            if (optionsByPriority.length > 0) {\n                return optionsByPriority[0];\n            } else {\n                return null;\n            }\n        }\n\n        render() {\n            const params: DndActorRenderParams = {\n                isDraggable: !!this.props.srcData,\n                isDraggedOut: this.state.isDragging,\n                isDraggedOver: this.context.uuiDnD?.isDragging && this.state.isMouseOver,\n                isDropAccepted: this.state.isMouseOver && !!this.state.position,\n                isDragGhost: false,\n                isDndInProgress: this.state.dndContextState.isDragging,\n                dragData: this.state.isMouseOver ? this.context.uuiDnD.dragData : null,\n                eventHandlers: {},\n                position: this.state.isMouseOver ? this.state.position : null,\n                classNames: null,\n                ref: this.dndRef,\n            };\n\n            params.classNames = [\n                params.isDropAccepted && uuiDndState.dropAccepted, params.isDraggedOut && uuiDndState.draggedOut, params.isDraggable && uuiMarkers.draggable,\n            ].filter(Boolean);\n\n            if (!!this.props.srcData) {\n                params.eventHandlers.onPointerDown = (e: React.PointerEvent<any>) => {\n                    if (isEventTargetInsideDraggable(e, e.currentTarget)) {\n                        return;\n                    }\n                    e.persist();\n                    if (e.button === 0) {\n                        this.setState(() => {\n                            const mouseCoords = this.context.uuiDnD.getMouseCoords();\n                            return {\n                                ...initialState,\n                                isMouseDown: true,\n                                pointerX: mouseCoords.mousePageX,\n                                pointerY: mouseCoords.mousePageY,\n                            };\n                        });\n\n                        if (!isEventTargetInsideInput(e, e.currentTarget)) {\n                            // This prevents text selection start\n                            // dnd don't work without it in ff\n                            e.preventDefault();\n                            e.stopPropagation();\n                        }\n                    }\n                };\n            }\n\n            if (this.props.canAcceptDrop) {\n                const pointerLeaveHandler = () => {\n                    if (this.context.uuiDnD.isDragging) {\n                        this.setState((s) => ({ ...s, isMouseOver: false, position: null }));\n                    }\n                };\n\n                const pointerMoveHandler = (e: React.PointerEvent<any>) => {\n                    if (this.context.uuiDnD.isDragging) {\n                        if (isEventTargetInsideDraggable(e, e.currentTarget)) {\n                            return pointerLeaveHandler();\n                        }\n\n                        releasePointerCaptureOnEventTarget(e); // allows you to trigger pointer events on other nodes\n\n                        const dropParams = this.getDropParams(e);\n                        const positionOptions = this.props.canAcceptDrop(dropParams);\n                        const position = this.getPosition(dropParams, positionOptions);\n                        this.setState((s) => ({ ...s, isMouseOver: true, position }));\n                    }\n                };\n\n                params.eventHandlers.onTouchStart = (e) => e.preventDefault(); // prevent defaults on ios\n\n                params.eventHandlers.onPointerEnter = pointerMoveHandler;\n                params.eventHandlers.onPointerMove = pointerMoveHandler;\n                params.eventHandlers.onPointerLeave = pointerLeaveHandler;\n            }\n\n            params.eventHandlers.onPointerUp = (e) => {\n                if (this.context.uuiDnD.isDragging) {\n                    if (isEventTargetInsideDraggable(e, e.currentTarget)) {\n                        return;\n                    }\n                    e.preventDefault();\n                    if (!!this.state.position) {\n                        this.props.onDrop && this.props.onDrop({\n                            ...this.getDropParams(e),\n                            position: this.state.position,\n                        });\n                    }\n                    this.context.uuiDnD.endDrag();\n                    this.setState(() => initialState);\n                } else {\n                    // TBD: investigate. Should blur inputs, but doesn't work so far.\n                    // if (this.state.pendingMouseDownTarget) {\n                    //     $(this.state.pendingMouseDownTarget).trigger(\"mousedown\");\n                    //     $(this.state.pendingMouseDownTarget).trigger(\"mouseup\");\n                    //     $(this.state.pendingMouseDownTarget).trigger(\"click\");\n                    //     this.setState(s => ({ ...s, pendingMouseDownTarget: null }));\n                    // }\n                }\n            };\n\n            return this.props.render(params);\n        }\n    };\n}\n","import { BaseContext } from './BaseContext';\nimport { isClientSide } from '../helpers/ssr';\n\nexport interface LayoutLayer {\n    /** ID of the layer */\n    id: number;\n    /** Level of the layer depth */\n    depth: number;\n    /** zIndex of the layer */\n    zIndex: number;\n}\nfunction genUniqueId() {\n    return [Math.random(), Math.random()].reduce((acc, n) => (acc + n.toString(36).substring(2)), '');\n}\n\nfunction getPortalRootById(id: string) {\n    let root = document.getElementById(id);\n    if (!root) {\n        /*\n         * document.getElementById doesn't find elements by ID if they are located in shadow DOM.\n         * so, as a fallback, we try to find shadow host by attribute name like this: [data-<id>]\n         * and after that - try to find by id in the shadow root.\n         */\n        const shadow = document.querySelector(`[data-shadow-host-id=\"${id}\"]`);\n        root = shadow?.shadowRoot?.getElementById(id);\n    }\n    return root;\n}\n\nfunction maxBy<T>(arr: T[], getMax: (item: T) => number) {\n    let maxItem: T;\n    arr.forEach((value) => {\n        if (maxItem === undefined) {\n            maxItem = value;\n        }\n\n        if (getMax(value) > getMax(maxItem)) {\n            maxItem = value;\n        }\n    });\n\n    return maxItem;\n}\n\nexport class LayoutContext extends BaseContext {\n    layerIdCounter = 0;\n    layers: LayoutLayer[] = [];\n\n    private readonly portalRootId: string = genUniqueId();\n\n    public getPortalRoot() {\n        /**\n         * TODO: we should remove this part: document.getElementById('main') || document.getElementById('root')\n         */\n        if (isClientSide) {\n            return getPortalRootById(this.portalRootId) || document.getElementById('main') || document.getElementById('root') || document.body;\n        }\n    }\n\n    public getPortalRootId() {\n        return this.portalRootId;\n    }\n\n    public getLayer(): LayoutLayer {\n        const topLayer = maxBy(this.layers, (l) => l.depth);\n        const depth = topLayer ? topLayer.depth + 1 : 0;\n        const layer = {\n            id: this.layerIdCounter++,\n            depth,\n            zIndex: depth * 100 + 2000,\n        };\n\n        this.layers.push(layer);\n\n        return layer;\n    }\n\n    public releaseLayer(layer: LayoutLayer | number) {\n        let id: number;\n        if (typeof layer === 'number') {\n            id = layer;\n        } else {\n            id = layer.id;\n        }\n        this.layers = this.layers.filter((l) => l.id !== id);\n    }\n}\n","import { IRouterContext, Link } from '../../types';\n\nexport class StubAdaptedRouter implements IRouterContext {\n    private warningMessage = 'Warning: [RouterContext] there is not Router Adapter provided. StubAdapter is used';\n    throwError() {\n        if (process.env.NODE_ENV !== 'test') {\n            console.error(this.warningMessage);\n        }\n    }\n\n    public getCurrentLink(): Link {\n        this.throwError();\n        if (process.env.NODE_ENV === 'test') {\n            return { pathname: '', query: {} };\n        }\n        return null;\n    }\n\n    public redirect(): void {\n        this.throwError();\n    }\n\n    public transfer(): void {\n        this.throwError();\n    }\n\n    public isActive(): boolean {\n        this.throwError();\n        return false;\n    }\n\n    public createHref(): string {\n        this.throwError();\n        return '';\n    }\n\n    public listen(): () => void {\n        this.throwError();\n        return () => {};\n    }\n\n    public block(): () => void {\n        this.throwError();\n        return () => {};\n    }\n}\n","export const queryToSearch = (query: Record<string, any>): string => {\n    if (!query) return '';\n\n    const params = new URLSearchParams();\n\n    Object.keys(query).forEach((key) => {\n        if (query[key] === undefined) return;\n\n        if (typeof query[key] === 'object') {\n            params.set(key, JSON.stringify(query[key]));\n        } else {\n            params.set(key, query[key]);\n        }\n    });\n\n    return params.toString();\n};\n","export const searchToQuery = (search: string): Record<string, any> => {\n    const query = {} as any;\n    new URLSearchParams(search).forEach((value, key) => {\n        if (!value) return;\n\n        try {\n            query[key] = JSON.parse(decodeURIComponent(value));\n        } catch (e) {\n            query[key] = value;\n        }\n    });\n\n    return query;\n};\n","import { Link } from '../../types/objects';\nimport { IRouterContext } from '../../types/contexts';\nimport { queryToSearch } from '../../helpers/queryToSearch';\nimport { searchToQuery } from '../../helpers/searchToQuery';\n\nexport interface IHistory4 {\n    location: Link;\n    push(link: Link): void;\n    replace(link: Link): void;\n    createHref(link: Link): string;\n    listen(listener: (location: Link) => void): () => void;\n    block(listener: (args: any) => any): () => void;\n}\n\nexport class HistoryAdaptedRouter implements IRouterContext {\n    constructor(private history: IHistory4) {}\n    public getCurrentLink(): Link {\n        return HistoryAdaptedRouter.searchToQuery(this.history.location);\n    }\n\n    public redirect(link: Link): void {\n        this.history.push(HistoryAdaptedRouter.queryToSearch(link));\n    }\n\n    public transfer(link: Link): void {\n        this.history.replace(HistoryAdaptedRouter.queryToSearch(link));\n    }\n\n    public isActive(link: Link): boolean {\n        const current = this.getCurrentLink();\n        return current.pathname === link.pathname;\n    }\n\n    public createHref(link: Link): string {\n        return this.history.createHref(HistoryAdaptedRouter.queryToSearch(link));\n    }\n\n    public listen(listener: (link: Link) => void) {\n        return this.history.listen(listener);\n    }\n\n    public block(listener: (link: Link) => void) {\n        return this.history.block((location) => {\n            listener(location);\n            return false;\n        });\n    }\n\n    private static searchToQuery(link: Link): Link {\n        if (link.query !== undefined) return link;\n\n        return {\n            ...link,\n            query: searchToQuery(link.search),\n        };\n    }\n\n    private static queryToSearch(link: Link): Link {\n        if (!link.query) return link;\n\n        return {\n            ...link,\n            search: queryToSearch(link.query),\n        };\n    }\n}\n","import { IRouterContext, Link } from '../../types';\nimport { queryToSearch } from '../../helpers/queryToSearch';\n\nconst createHref = (location: Link, basePath: string) => {\n    const { pathname, query } = location;\n    const search = new URLSearchParams(query).toString();\n    return `${basePath}${pathname}${search ? '?' + search : ''}`;\n};\n\nconst parseQuery = (link: Link): Link => {\n    const query = {} as any;\n    Object.keys(link.query).forEach((key) => {\n        const value = link.query[key];\n        if (!value) return;\n\n        try {\n            query[key] = JSON.parse(decodeURIComponent(value));\n        } catch (e) {\n            query[key] = value;\n        }\n    });\n\n    return {\n        ...link,\n        query,\n    };\n};\n\n/**\n * Source: https://github.com/vercel/next.js/blob/031cf7009239be5ebccd8f72418adfd2bb4af5c8/packages/next/src/shared/lib/router/router.ts#L657\n * This type is compatible with both versions of Next.js: v13 and v14.\n */\ntype TNext14Router = {\n    pathname: string,\n    basePath: string,\n    query: any,\n    push(...args: any[]): void,\n    replace(...args: any[]): void,\n    events: {\n        on(type: any, handler: (...evts: any[]) => void): void;\n        off(type: any, handler: (...evts: any[]) => void): void;\n        emit(type: any): void;\n    }\n};\n\nexport class NextRouterAdapter implements IRouterContext {\n    private isBlockRun: boolean;\n    private blockedUrl: Link | null;\n    constructor(\n        private router: TNext14Router,\n    ) {\n        this.isBlockRun = false;\n        this.blockedUrl = null;\n    }\n\n    public getCurrentLink(): Link {\n        const parsedLink = parseQuery({\n            pathname: this.router.pathname,\n            query: this.router.query,\n        });\n        return parsedLink;\n    }\n\n    parseLinkWithQuery(link: Link): Link {\n        const result = {\n            ...link,\n            search: queryToSearch(link.query),\n        };\n        delete result.query;\n        return result;\n    }\n\n    public redirect(link: Link): void {\n        this.router.push(this.parseLinkWithQuery(link));\n        if (this.isBlockRun) {\n            this.blockedUrl = link;\n        }\n    }\n\n    public transfer(link: Link): void {\n        this.router.replace(this.parseLinkWithQuery(link));\n        if (this.isBlockRun) {\n            this.blockedUrl = link;\n        }\n    }\n\n    public isActive(link: Link): boolean {\n        const current = this.getCurrentLink();\n        return current.pathname === link.pathname;\n    }\n\n    public createHref(link: Link): string {\n        return createHref(link, this.router.basePath);\n    }\n\n    private handleBeforeHistoryChange = (url: Link, listener: (link: Link) => void) => {\n        listener(url);\n        if (this.isBlockRun && this.blockedUrl) {\n            this.router.events.emit('routeChangeError');\n        }\n    };\n\n    public listen(listener: (link: Link) => void) {\n        const localHandler = (url: Link) => this.handleBeforeHistoryChange(url, listener);\n        this.router.events.on('beforeHistoryChange', localHandler);\n        return () => this.router.events.off('beforeHistoryChange', localHandler);\n    }\n\n    private handleRouterChangeError = (listener: (link: Link) => void) => {\n        listener(this.blockedUrl);\n        throw 'Block history changing';\n    };\n\n    public block(listener: (link: Link) => void) {\n        const localHandler = () => this.handleRouterChangeError(listener);\n        this.router.events.on('routeChangeError', localHandler);\n        this.isBlockRun = true;\n\n        return () => {\n            this.isBlockRun = false;\n            this.blockedUrl = null;\n            this.router.events.off('routeChangeError', localHandler);\n        };\n    }\n}\n","import { IRouterContext, Link } from '../../types';\n\ninterface NavigateOptions {\n    scroll?: boolean;\n}\n\nexport type TNextAppRouter = {\n    push(href: string, options?: NavigateOptions): void;\n    replace(href: string, options?: NavigateOptions): void;\n};\n\nexport type ReadonlySearchParams = URLSearchParams & {\n    append(): void;\n    delete(): void;\n    set(): void;\n    sort(): void;\n};\n\nconst beforeHistoryChangeEvent = 'beforeHistoryChange';\nconst blockNavigationEvent = 'blockNavigation';\n\nexport class NextAppRouterAdapter implements IRouterContext {\n    private isBlockRun: boolean;\n    private pathname?: string;\n    private searchParams?: ReadonlySearchParams;\n\n    constructor(private router: TNextAppRouter) {\n        this.isBlockRun = false;\n    }\n\n    public updateURLParams(\n        pathname: string,\n        searchParams: ReadonlySearchParams,\n    ): void {\n        this.pathname = pathname;\n        this.searchParams = searchParams;\n    }\n\n    public getCurrentLink(): Link {\n        return this.pathname\n            ? parseQuery({\n                pathname: this.pathname,\n                query: paramsToQuery(this.searchParams),\n            })\n            : {\n                pathname: '',\n                query: {},\n            };\n    }\n\n    public redirect(link: Link): void {\n        document.dispatchEvent(createBeforeHistoryEvent());\n\n        if (this.isBlockRun) {\n            document.dispatchEvent(createBlockNavigationEvent(link));\n        } else {\n            const search = link.search ? '?' + link.search : '';\n            this.router.push(link.pathname + search);\n        }\n    }\n\n    public transfer(link: Link): void {\n        document.dispatchEvent(createBeforeHistoryEvent());\n\n        if (this.isBlockRun) {\n            document.dispatchEvent(createBlockNavigationEvent(link));\n        } else {\n            const search = link.search ? '?' + link.search : '';\n            this.router.replace(link.pathname + search);\n        }\n    }\n\n    public isActive(link: Link): boolean {\n        const current = this.getCurrentLink();\n        return current.pathname === link.pathname;\n    }\n\n    // See https://nextjs.org/docs/app/api-reference/next-config-js/basePath\n    // https://nextjs.org/docs/pages/building-your-application/configuring/environment-variables#bundling-environment-variables-for-the-browser\n    public createHref(link: Link): string {\n        return createHref(\n            link,\n            process.env.NEXT_PUBLIC_BASE_PATH || '',\n        );\n    }\n\n    public listen(listener: (link: Link) => void) {\n        const onBeforeHistoryChange = (event: Event) => {\n            listener((event as any).detail.link);\n        };\n\n        document.addEventListener(\n            beforeHistoryChangeEvent,\n            onBeforeHistoryChange,\n        );\n        return () => {\n            document.removeEventListener(\n                beforeHistoryChangeEvent,\n                onBeforeHistoryChange,\n            );\n        };\n    }\n\n    // adapter state might be invalid in potential edge case like\n    // unblocking one form shouldn't unblock another one\n    public block(listener: (link: Link) => void) {\n        const onBlockNavigation = (event: Event) => {\n            const payload = (event as any).detail;\n            listener(payload.link);\n        };\n\n        this.isBlockRun = true;\n        document.addEventListener(blockNavigationEvent, onBlockNavigation);\n\n        return () => {\n            this.isBlockRun = false;\n            document.removeEventListener(\n                blockNavigationEvent,\n                onBlockNavigation,\n            );\n        };\n    }\n}\n\nconst createBeforeHistoryEvent = () =>\n    new CustomEvent(beforeHistoryChangeEvent, {\n        detail: {},\n    });\n\nconst createBlockNavigationEvent = (link: Link) =>\n    new CustomEvent(blockNavigationEvent, {\n        detail: { link },\n    });\n\nconst createHref = (location: Link, basePath: string) => {\n    const { pathname, query } = location;\n    const search = new URLSearchParams(query).toString();\n    return `${basePath}${pathname}${search ? '?' + search : ''}`;\n};\n\nconst parseQuery = (link: Link): Link => {\n    const query = {} as any;\n    Object.keys(link.query).forEach((key) => {\n        const value = link.query[key];\n        if (!value) return;\n\n        try {\n            query[key] = JSON.parse(decodeURIComponent(value));\n        } catch (e) {\n            query[key] = value;\n        }\n    });\n\n    return {\n        ...link,\n        query,\n    };\n};\n\nconst paramsToQuery = (params?: ReadonlySearchParams) => {\n    return params\n        ? [...params.entries()].reduce<Record<string, string>>(\n            (acc, [key, value]) => {\n                acc[key] = value;\n                return acc;\n            },\n            {},\n        )\n        : {};\n};\n","/**\n * From: react-router version 6.14.0\n *\n * The type definition of the IRouter6 is not complete (It's OK as long as we only use a subset of its API)\n *\n * NOTE: Complete definitions of the router is located in @remix-run/router:\n * https://github.com/remix-run/react-router/blob/main/packages/router/router.ts#L57\n */\nexport type IRouter6 = {\n    state: RouterState;\n    navigate(to: To | null, opts?: RouterNavigateOptions): Promise<void>;\n    navigate(to: number): Promise<void>;\n    getBlocker: (key: string, fn: BlockerFunction) => unknown;\n    subscribe: (fn: (state: RouterState) => void) => () => void;\n    deleteBlocker: (key: string) => void;\n    createHref(location: Location | URL): string;\n};\nexport type RouterState = {\n    location: Location;\n    blockers: Map<string, unknown>;\n    historyAction: Action;\n};\nexport type BlockerFunction = (args: { nextLocation: Location, historyAction: Action }) => boolean;\nexport interface Location extends Path {\n    state: any;\n    key: string;\n}\nexport type To = string | Partial<Path>;\nexport type Path = {\n    pathname: string;\n    search: string;\n    hash: string;\n};\nexport enum Action {\n    Pop = 'POP',\n    Push = 'PUSH',\n    Replace = 'REPLACE'\n}\ntype RouterNavigateOptions = {\n    replace?: boolean;\n    state?: any;\n};\n","import { IRouterContext } from '../../types/contexts';\nimport { Link } from '../../types/objects';\nimport { queryToSearch } from '../../helpers/queryToSearch';\nimport { searchToQuery } from '../../helpers/searchToQuery';\nimport { Action, BlockerFunction, IRouter6, Location, To } from './interfaces/IRouter6';\n\nexport type { IRouter6 };\n\ntype History4Action = 'PUSH' | 'POP' | 'REPLACE';\nfunction mapRouter6ActionToHistory4Action(src: Action): History4Action {\n    if (src === Action.Pop) {\n        return 'POP';\n    } else if (src === Action.Push) {\n        return 'PUSH';\n    }\n    return 'REPLACE';\n}\n\n/**\n * Adds exactly 1 beforeunload event. It is no-op is such event is already added.\n * It's needed to make react-router 6 compatible with \"history.block\".\n */\nexport function getBeforeUnloadSingletone() {\n    const BeforeUnloadEventType = 'beforeunload';\n    let _unblockFn: () => void;\n\n    return {\n        ensureBlock: () => {\n            if (_unblockFn) {\n                return;\n            }\n            function promptBeforeUnload(event: BeforeUnloadEvent) {\n                // According to the specification, to show the confirmation dialog an event handler should call preventDefault() on the event.\n                event.preventDefault();\n                event.returnValue = '';\n            }\n            window.addEventListener(BeforeUnloadEventType, promptBeforeUnload);\n            _unblockFn = function unblockFn() {\n                window.removeEventListener(BeforeUnloadEventType, promptBeforeUnload);\n            };\n        },\n        unblock: () => {\n            if (_unblockFn) {\n                _unblockFn();\n                _unblockFn = undefined;\n            }\n        },\n    };\n}\n\nexport function getRouter6BlockFn(router: IRouter6) {\n    let blockerKeyIndex = 0;\n    // uui- prefix looks sufficient so that we don't interfere with any internal blockers of router 6.\n    const nextBlockerKey = () => `uui-${++blockerKeyIndex}`;\n    const beforeUnloadSingletone = getBeforeUnloadSingletone();\n\n    return function router6BlockFn(blockerFunction: (location: Location, action: History4Action) => void) {\n        const _blockerFn: BlockerFunction = (params) => {\n            blockerFunction(params.nextLocation, mapRouter6ActionToHistory4Action(params.historyAction));\n            return true;\n            // true means - block navigation.\n            // we want to be compatible with the history 5 behavior for \"block\" as much as possible.\n            // I.e.: keep navigation blocked until unblock function is explicitly invoked.\n            // https://github.com/remix-run/history/blob/dev/docs/blocking-transitions.md\n        };\n        const key = nextBlockerKey();\n        router.getBlocker(key, _blockerFn);\n        beforeUnloadSingletone.ensureBlock();\n        return function unblock() {\n            router.deleteBlocker(key);\n            if (router.state.blockers.size === 0) {\n                // keep this singletone as long as there are any blockers\n                beforeUnloadSingletone.unblock();\n            }\n        };\n    };\n}\n\nfunction locationToLink(loc: Location): Link {\n    return {\n        ...loc,\n        query: searchToQuery(loc.search),\n    };\n}\nconst withFallback = <T>(v: T, fallback: string = '') => typeof v !== 'undefined' ? v : fallback;\nfunction linkToRouter6Dest(link: Link): { to: To, state?: any } {\n    return {\n        to: {\n            hash: withFallback(link.hash),\n            search: queryToSearch(link.query) || link.search,\n            pathname: withFallback(link.pathname),\n        },\n        state: link.state,\n    };\n}\n\nfunction linkToLocation(link: Link): Location {\n    return {\n        hash: withFallback(link.hash),\n        search: queryToSearch(link.query),\n        pathname: withFallback(link.pathname),\n        key: withFallback(link.key),\n        state: link.state,\n    };\n}\n\n/**\n *\n * NOTE: Next methods/properties of the router are marked as PRIVATE - DO NOT USE in the https://github.com/remix-run/react-router/blob/main/packages/router/router.ts#L57\n *  - state\n *  - getBlocker\n *  - subscribe\n *  - deleteBlocker\n *  - createHref\n * So we should be extra careful if decide to use another version of the react-router.\n * Though, it's OK to use such API, because there are no alternatives yet (see https://github.com/remix-run/react-router/issues/9422)\n *\n * IMPORTANT: As of now, it was tested only using react-router 6.14.0\n */\nexport class Router6AdaptedRouter implements IRouterContext {\n    constructor(private router6: IRouter6) {}\n\n    public getCurrentLink(): Link {\n        return locationToLink(this.router6.state.location);\n    }\n\n    public redirect(link: Link | string): void {\n        // NOTE: navigate is async in the router 6\n        if (typeof link === 'string') {\n            this.router6.navigate(link);\n        } else {\n            const { to, state } = linkToRouter6Dest(link);\n            this.router6.navigate(to, { state });\n        }\n    }\n\n    public transfer(link: Link): void {\n        // NOTE: it's async in the router 6\n        const { to, state } = linkToRouter6Dest(link);\n        this.router6.navigate(to, { state, replace: true });\n    }\n\n    public isActive(link: Link): boolean {\n        const current = this.getCurrentLink();\n        return current.pathname === link.pathname;\n    }\n\n    public createHref(link: Link): string {\n        return this.router6.createHref(linkToLocation(link));\n    }\n\n    public listen(listener: (link: Link) => void) {\n        return this.router6.subscribe((rState) => {\n            listener(rState.location);\n        });\n    }\n\n    public block: (listener: (link: Link) => void) => () => void = getRouter6BlockFn(this.router6);\n}\n","import { IAnalyticsListener } from '../../types/contexts';\nimport { AnalyticsEvent } from '../../types/objects';\n\nexport class GAListener implements IAnalyticsListener {\n    public gaCode: string;\n    constructor(gaCode: string) {\n        this.gaCode = gaCode;\n\n        this.init();\n    }\n\n    public init() {\n        this.addGaScript();\n        this.sendToGA('js', new Date());\n        this.sendPageView(window.location.pathname);\n    }\n\n    private addGaScript() {\n        (window as any).dataLayer = (window as any).dataLayer || [];\n\n        const gtagScript = document.createElement('script');\n        gtagScript.src = `https://www.googletagmanager.com/gtag/js?id=${this.gaCode}`;\n        gtagScript.async = true;\n        document.head.appendChild(gtagScript);\n    }\n\n    private hasConsent(): boolean {\n        const dataLayer = (window as any).dataLayer ?? [];\n        return dataLayer.length === 0 ? false : dataLayer.some((item: any) => item.event === 'OneTrustLoaded' && item.OnetrustActiveGroups?.includes('C0002'));\n    }\n\n    public sendEvent(event: AnalyticsEvent, parameters: Omit<AnalyticsEvent, 'name'>, eventType?: string) {\n        if (!this.hasConsent()) {\n            return; // Do not send events if cookie consent is not given\n        }\n        switch (eventType) {\n            case 'pageView':\n                this.sendPageView(event.path);\n                break;\n\n            default:\n                this.sendToGA('event', event.name, parameters);\n                break;\n        }\n    }\n\n    // eslint-disable-next-line @typescript-eslint/no-unused-vars\n    private sendToGA(...args: any[]) {\n        (window as any).dataLayer.push(arguments); // For GA it's important to pass exactly arguments\n    }\n\n    private sendPageView(path: string) {\n        this.sendToGA('config', this.gaCode, { page_path: path, anonymize_ip: true });\n    }\n}\n","import { BaseContext } from './BaseContext';\nimport { IRouterContext, IAnalyticsListener, IAnalyticsContext } from '../types/contexts';\nimport { AnalyticsEvent, Link } from '../types/objects';\nimport { isClientSide } from '../helpers/ssr';\n\ninterface AnalyticsContextOptions {\n    /** Instance of UUI router context */\n    router: IRouterContext;\n}\n\nexport class AnalyticsContext extends BaseContext implements IAnalyticsContext {\n    private removeRouteListener: () => void;\n    private currentLocation: string;\n    private readonly router: IRouterContext;\n    public listeners: IAnalyticsListener[] = [];\n    constructor(options: AnalyticsContextOptions) {\n        super();\n        this.router = options.router;\n    }\n\n    public destroyContext() {\n        super.destroyContext();\n        if (isClientSide) {\n            this.removeRouteListener?.();\n        }\n    }\n\n    init() {\n        super.init();\n\n        if (isClientSide) {\n            this.currentLocation = window.location?.pathname;\n            this.removeRouteListener = this.router?.listen(this.handleChangeRoute);\n        }\n    }\n\n    public sendEvent(event: AnalyticsEvent | null | undefined, eventType: 'event' | 'pageView' | 'apiTiming' = 'event') {\n        if (!event) return;\n        if (this.listeners.length) this.listeners.forEach((listener) => listener.sendEvent(event, this.getParameters(event), eventType));\n    }\n\n    private handleChangeRoute = (location: Link) => {\n        if (this.currentLocation !== location?.pathname) {\n            this.currentLocation = location?.pathname;\n            this.sendEvent({ path: location?.pathname, name: 'pageView' }, 'pageView');\n        }\n    };\n\n    public addListener(listener: IAnalyticsListener) {\n        this.listeners.push(listener);\n    }\n\n    private getParameters(options: AnalyticsEvent) {\n        const parameters: any = { ...options };\n        delete parameters.name;\n        return parameters;\n    }\n}\n","export function getCookie(name: string) {\n    const matches = document.cookie.match(new RegExp('(?:^|; )' + name.replace(/([\\.$?*|{}\\(\\)\\[\\]\\\\\\/\\+^])/g, '\\\\$1') + '=([^;]*)'));\n    return matches ? decodeURIComponent(matches[1]) : undefined;\n}\n\n// options - (expires, path, domain, secure)\nexport function setCookie(name: string, value: string, options?: any) {\n    options = options || {};\n\n    let expires = options.expires;\n\n    if (typeof expires == 'number' && expires) {\n        const d = new Date();\n        d.setTime(d.getTime() + expires * 1000);\n        options.expires = d;\n        expires = d;\n    }\n    if (expires && expires.toUTCString) {\n        options.expires = expires.toUTCString();\n    }\n\n    value = encodeURIComponent(value);\n\n    let updatedCookie = name + '=' + value;\n\n    for (const propName in options) {\n        updatedCookie += '; ' + propName;\n        const propValue = options[propName];\n        if (propValue !== true) {\n            updatedCookie += '=' + propValue;\n        }\n    }\n\n    document.cookie = updatedCookie;\n}\n\nexport function deleteCookie(name: string) {\n    setCookie(name, '', { expires: -1 });\n}\n","import { isClientSide } from '../helpers/ssr';\n\nconst AUTH_RECOVERY_STORAGE_ITEM_KEY = 'uui-auth-recovery-success';\n\nexport type AuthRecoveryContextProps = {\n    apiReloginPath: string;\n    onSuccessAuthRecovery: () => void;\n};\n\nexport class AuthRecoveryService {\n    constructor(private props: AuthRecoveryContextProps) {}\n\n    init = () => {\n        if (isClientSide) {\n            window.addEventListener('storage', this.handleStorageUpdate);\n        }\n    };\n\n    destroy = () => {\n        if (isClientSide) {\n            window.removeEventListener('storage', this.handleStorageUpdate);\n        }\n    };\n\n    tryToRecover = () => {\n        // The auth cannot recover when the Access session has expired and \"opener\" is present. So we erase opener here.\n        window.open(this.props.apiReloginPath, '_blank', 'noopener,noreferrer');\n    };\n\n    private handleStorageUpdate = (e: StorageEvent) => {\n        if (e.key === AUTH_RECOVERY_STORAGE_ITEM_KEY && e.newValue === 'true') {\n            this.props.onSuccessAuthRecovery();\n            window.localStorage.removeItem(AUTH_RECOVERY_STORAGE_ITEM_KEY);\n        }\n    };\n}\n","import { BaseContext } from './BaseContext';\nimport { AnalyticsContext } from './AnalyticsContext';\nimport {\n    IApiContext, ApiStatus, ApiRecoveryReason, ApiCallInfo, IProcessRequest,\n} from '../types';\nimport { isClientSide } from '../helpers/ssr';\nimport { getCookie } from '../helpers/cookie';\nimport { AuthRecoveryService } from './AuthRecoveryService';\n\ninterface ApiCall extends ApiCallInfo {\n    /** Request promise resolve callback */\n    resolve: (value?: any) => any;\n    /** Request promise reject callback */\n    reject: (value?: any) => any;\n}\n\nexport class ApiCallError extends Error {\n    constructor(public call: ApiCall) {\n        super('ApiContext: API call failed');\n    }\n}\n\n/**\n * Options which are passed to the HTTP request.\n */\nexport interface FetchingOptions {\n    /**\n     * Signal of request aborting.\n     */\n    signal: AbortSignal;\n}\n\nexport interface FileUploadOptions {\n    /** Called during the file uploading, used to track upload progress */\n    onProgress?: (progress: number) => any;\n    /** Callback to receive the instance of xhr. Can be used to abort the request. */\n    getXHR?: (xhr: XMLHttpRequest) => any;\n}\n\nexport interface FileUploadResponse {\n    /** ID of the file */\n    id: number;\n    /** Name of the file */\n    name: string;\n    /** File size */\n    size: number;\n    /** Path to the file source */\n    path?: string;\n    /** Type of file representation. Used for UUI SlateRTE file displaying. */\n    type?: BlockTypes;\n    /** Extension of the file */\n    extension?: string;\n    /** Upload error  */\n    error?: {\n        /** If true, indicates about error while file uploading */\n        isError: boolean;\n        /** Error message */\n        message?: string;\n    };\n}\n\nexport type BlockTypes = 'attachment' | 'iframe' | 'image';\nexport interface ApiContextProps {\n    /** Url to the relogin page. Used to open new browser window by this path, in case of auth lost error.\n     * Opened by this path page, should process authentication and then post 'authSuccess' cross-window message to the opener, to recover failed requests.\n     * @default '/auth/login'\n     * */\n    apiReloginPath?: string;\n    /** Url to the api, which ApiContext will start pinging in case of 'connection lost', until it gets 200 status. Then it will retry failed requests.\n     * @default '/auth/ping'\n     * */\n    apiPingPath?: string;\n    /** Url to the server api under which all requests will be processed. Usefully for cases, when all api located by some specific url, which is not much app url.\n     * @default ''\n     * */\n    apiServerUrl?: string;\n\n    /**\n     * Allows to replace fetch implementation, for adding auth headers, mocking for testing, etc.\n     * By default, standard fetch will be used.\n     */\n    fetch?: typeof fetch;\n}\n\nexport class ApiContext extends BaseContext implements IApiContext {\n    private queue: ApiCall[] = [];\n    private isRunScheduled = false;\n    public status: ApiStatus = 'idle';\n    public recoveryReason: ApiRecoveryReason | null = null;\n    public apiReloginPath: string;\n    private readonly authRecoveryContext: AuthRecoveryService;\n\n    constructor(private props: ApiContextProps, private analyticsCtx?: AnalyticsContext) {\n        super();\n        this.apiReloginPath = this.props.apiReloginPath ?? '/auth/login';\n        this.props.apiPingPath = this.props.apiPingPath ?? '/auth/ping';\n        this.props.apiServerUrl = this.props.apiServerUrl ?? '';\n        this.authRecoveryContext = new AuthRecoveryService({\n            apiReloginPath: this.apiReloginPath,\n            onSuccessAuthRecovery: this.handleSuccessAuthRecovery,\n        });\n    }\n\n    init() {\n        super.init();\n        this.authRecoveryContext.init();\n    }\n\n    private handleSuccessAuthRecovery = () => {\n        if (this.status === 'recovery' && this.recoveryReason === 'auth-lost') {\n            this.setStatus('running');\n            this.runQueue();\n            this.update({});\n        }\n    };\n\n    public destroyContext() {\n        this.authRecoveryContext.destroy();\n        super.destroyContext();\n    }\n\n    public getActiveCalls(): ApiCallInfo[] {\n        return this.queue;\n    }\n\n    public reset() {\n        if (this.status === 'error' || this.status === 'recovery') {\n            this.queue = [];\n            this.status = 'running';\n        }\n    }\n\n    private setStatus(status: ApiStatus, recoveryReason: ApiRecoveryReason = null) {\n        this.status = status;\n        this.recoveryReason = recoveryReason;\n        this.update({});\n    }\n\n    private handleApiError(call: ApiCall, reason?: ApiRecoveryReason) {\n        const error = new ApiCallError(call);\n\n        if (call.options?.errorHandling === 'manual' && !(reason === 'auth-lost' || reason === 'connection-lost' || reason === 'abort-signal')) {\n            this.removeFromQueue(call);\n            call.reject(error);\n            return;\n        }\n\n        if (reason === 'abort-signal') {\n            call.status = 'error';\n            this.setStatus('error');\n            call.reject(call.error);\n            return;\n        }\n\n        if (reason) {\n            call.status = 'scheduled';\n            if (this.status === 'recovery') {\n                return;\n            }\n            this.setStatus('recovery', reason);\n            if (reason === 'auth-lost') {\n                this.authRecoveryContext.tryToRecover();\n            } else {\n                this.recoverConnection();\n            }\n        } else {\n            call.status = 'error';\n            this.setStatus('error');\n            call.reject(error);\n        }\n    }\n\n    private startCall(call: ApiCall) {\n        const fetchOptions = call.options?.fetchOptions;\n\n        const headers = new Headers(fetchOptions?.headers);\n\n        if (!headers.has('Content-Type')) {\n            headers.append('Content-Type', 'application/json');\n        }\n\n        const csrfCookie = isClientSide && getCookie('CSRF-TOKEN');\n\n        if (csrfCookie) {\n            headers.append('X-CSRF-Token', csrfCookie);\n        }\n\n        call.attemptsCount += 1;\n        call.status = 'running';\n        call.startedAt = new Date();\n\n        const fetcher = this.props.fetch || fetch;\n\n        fetcher(\n            this.props.apiServerUrl + call.url,\n            {\n                method: call.method,\n                body: call.requestData && JSON.stringify(call.requestData),\n                credentials: 'include',\n                ...fetchOptions,\n                headers,\n            },\n        )\n            .then((response) => {\n                this.handleResponse(call, response);\n            })\n            .catch((error: Error) => {\n                if (error?.name === 'AbortError') {\n                    this.removeFromQueue(call);\n                    this.handleApiError({ ...call, error }, 'abort-signal');\n                }\n                if (call.attemptsCount < 2) {\n                    this.handleApiError(call, 'connection-lost');\n                } else {\n                    this.handleApiError(call);\n                }\n            });\n    }\n\n    private handleResponse(call: ApiCall, response: Response) {\n        call.finishedAt = new Date();\n        call.httpStatus = response.status;\n        if (response.ok) {\n            this.analyticsCtx?.sendEvent(\n                {\n                    name: 'timing_complete',\n                    parameters: {\n                        value: call.finishedAt.getTime() - call.startedAt.getTime(),\n                        name: call.name,\n                        event_category: window.location.pathname,\n                    },\n                },\n                'apiTiming',\n            );\n\n            if (response.status === 204) {\n                return this.resolveCall(call, null);\n            }\n\n            call.options.parseResponse(response)\n                .then((result) => {\n                    call.responseData = result;\n                    this.resolveCall(call, result);\n                })\n                .catch((e) => {\n                    if (e?.name === 'AbortError') {\n                        this.removeFromQueue(call);\n                        return;\n                    }\n\n                    /* Problem with response JSON parsing */\n                    call.status = 'error';\n                    this.setStatus('error');\n                    call.reject(e);\n                });\n        } else if (\n            /* Network and server-related problems. We'll ping the server and then retry the call in this case. */\n            (response.status === 408\n                || /* Request Timeout */ response.status === 420\n                || /* Enhance Your Calm */ response.status === 429\n                || /* Too Many Requests */ response.status === 502\n                || /* Bad Gateway */ response.status === 503\n                || /* Service Unavailable */ response.status === 504)\n            && /* Gateway Timeout */ call.attemptsCount < 2 /*\n                    There can be cases, when server returns some of these states, while /ping works.\n                    To not enter infinite loop in this case, we limit number of retries.\n                */\n        ) {\n            let reason: ApiRecoveryReason = 'connection-lost';\n            if (response.status === 420 || response.status === 429) {\n                reason = 'server-overload';\n            }\n            if (response.status === 503) {\n                reason = 'maintenance';\n            }\n\n            this.handleApiError(call, reason);\n        } else if (response.status === 401) {\n            /* Authentication cookies invalidated */ this.handleApiError(call, 'auth-lost');\n        } else {\n            // Try to parse response\n            call.options.parseResponse(response)\n                .catch(() => null) // Ignore parsing errors\n                .then((result) => {\n                    call.responseData = result;\n                    this.handleApiError(call);\n                });\n        }\n    }\n\n    private removeFromQueue(call: ApiCall) {\n        this.queue = this.queue.filter((c) => c !== call);\n        if (this.status === 'error' && !this.queue.some((c) => c.status === 'error')) {\n            this.setStatus('idle');\n            this.runQueue();\n        }\n    }\n\n    private resolveCall(call: ApiCall, result: any) {\n        this.removeFromQueue(call);\n        call.resolve(result);\n    }\n\n    private runQueue() {\n        this.isRunScheduled = false;\n        if (this.status === 'idle' || this.status === 'running') {\n            this.queue.filter((c) => c.status === 'scheduled').forEach((c) => this.startCall(c));\n        }\n    }\n\n    private recoverConnection() {\n        const retry = () => setTimeout(() => this.recoverConnection(), 2000);\n        const fetcher = this.props.fetch || fetch;\n        fetcher(this.props.apiPingPath, {\n            method: 'GET',\n            credentials: 'include',\n        })\n            .then((response) => {\n                if (response.ok) {\n                    this.setStatus('running');\n                    this.runQueue();\n                    this.update({});\n                } else {\n                    retry();\n                }\n            })\n            .catch(retry);\n    }\n\n    private scheduleRun() {\n        if (!this.isRunScheduled) {\n            setTimeout(() => this.runQueue(), 0);\n            this.isRunScheduled = false;\n        }\n    }\n\n    private defaultParseResponse = (res: Response) => {\n        return res.json();\n    };\n\n    public processRequest: IProcessRequest = (url, method, data, options) => {\n        let name = url;\n        if (data && data.operationName) {\n            name += ' ' + data.operationName;\n        }\n\n        options = {\n            errorHandling: 'page',\n            parseResponse: this.defaultParseResponse,\n            ...options,\n        };\n\n        return new Promise((resolve, reject) => {\n            const call: ApiCall = {\n                name,\n                url,\n                method,\n                requestData: data,\n                options,\n                resolve,\n                reject,\n                status: 'scheduled',\n                attemptsCount: 0,\n                dismissError: () => {\n                    this.removeFromQueue(call);\n                    this.update({});\n                },\n            };\n            this.queue.push(call);\n            this.scheduleRun();\n        });\n    };\n\n    public uploadFile(url: string, file: File, options?: FileUploadOptions) {\n        const trackProgress = (event: any) => {\n            const progress = +((event.loaded / event.total) * 100).toFixed(2);\n            options.onProgress && options.onProgress(progress);\n        };\n\n        return new Promise<FileUploadResponse>((resolve, reject) => {\n            const formData = new FormData();\n            formData.append('file', file);\n\n            const xhr = new XMLHttpRequest();\n            xhr.open('POST', url, true);\n\n            const csrfCookie = getCookie('CSRF-TOKEN');\n            if (csrfCookie) {\n                xhr.setRequestHeader('X-CSRF-Token', csrfCookie);\n            }\n\n            xhr.withCredentials = true;\n\n            const removeAllListeners = () => {\n                xhr.upload.removeEventListener('progress', trackProgress);\n                xhr.removeEventListener('abort', removeAllListeners);\n            };\n\n            if (options.onProgress) {\n                xhr.upload.addEventListener('progress', trackProgress, false);\n            }\n\n            if (options.getXHR) {\n                xhr.addEventListener('abort', removeAllListeners, false);\n                options.getXHR(xhr);\n            }\n\n            xhr.onreadystatechange = () => {\n                if (xhr.readyState !== 4) return;\n                let response;\n                try {\n                    response = JSON.parse(xhr.response);\n                } catch {\n                    reject({ error: { isError: true, message: 'File upload error' } });\n                }\n                if (!new RegExp('^2[0-9][0-9]').test(xhr.status.toString())) {\n                    reject({ error: { isError: true, message: response?.error?.message } });\n                }\n\n                removeAllListeners();\n                resolve(response);\n            };\n            xhr.send(formData);\n        });\n    }\n}\n","import { BaseContext } from './BaseContext';\nimport { AnalyticsContext } from './AnalyticsContext';\nimport { IErrorContext } from '../types';\nimport { ModalContext } from './ModalContext';\n\nexport class ErrorContext extends BaseContext implements IErrorContext {\n    constructor(private analyticsCtx: AnalyticsContext, private modalCtx: ModalContext) {\n        super();\n        this.analyticsCtx = analyticsCtx;\n    }\n\n    public currentError: Error = null;\n    public errorCallback: Function = null;\n    public reportError(error: Error) {\n        this.currentError = error;\n\n        this.errorCallback && this.errorCallback(error);\n        this.update({});\n    }\n\n    public discardError() {\n        this.currentError = null;\n    }\n\n    public recover() {\n        this.discardError();\n        this.update({});\n    }\n\n    public onError(callback: Function) {\n        this.errorCallback = callback;\n    }\n}\n\nexport interface ErrorPageInfo {\n    /** Error status code */\n    status?: number;\n    /** Title of error page */\n    title?: React.ReactNode;\n    /** Subtitle of error page */\n    subtitle?: React.ReactNode;\n    /** Url of error image to display on error page */\n    imageUrl?: string;\n    /** Url of error image to display on error page in case of mobile layout (app width < 720px) */\n    mobileImageUrl?: string;\n    /** Additional message with link to the support portal */\n    supportLink?: React.ReactNode;\n}\n\nexport class UuiError extends Error {\n    constructor(public info: ErrorPageInfo) {\n        super('UUI Error');\n        this.name = 'UuiError';\n        // Set the prototype explicitly.\n        // https://github.com/Microsoft/TypeScript/wiki/Breaking-Changes#extending-built-ins-like-error-array-and-map-may-no-longer-work\n        Object.setPrototypeOf(this, UuiError.prototype);\n    }\n}\n","import { BaseContext } from './BaseContext';\nimport { Link } from '../types/objects';\nimport { IRouterContext } from '../types/contexts';\nimport { isClientSide } from '../helpers/ssr';\n\nexport class Lock {\n    constructor(public tryRelease?: () => Promise<void>) {}\n}\n\nexport class LockContext extends BaseContext {\n    private currentLock: Lock | null;\n    private unblock: any;\n    constructor(private router: IRouterContext) {\n        super();\n    }\n\n    public destroyContext() {\n        this.clearLock();\n        super.destroyContext();\n    }\n\n    public acquire(tryRelease?: () => Promise<any>): Promise<Lock | null> {\n        if (this.currentLock) {\n            return this.tryRelease().then(() => this.acquire(tryRelease));\n        } else {\n            const lock = new Lock(tryRelease);\n            if (isClientSide) {\n                this.unblock = this.router.block((location) => {\n                    this.routerWillLeave(location);\n                });\n                this.currentLock = lock;\n            } else {\n                console.warn(\"An attempt to acquire lock in server side won't have any effect.\");\n            }\n            return Promise.resolve(lock);\n        }\n    }\n\n    public getCurrentLock(): Lock | null {\n        return this.currentLock;\n    }\n\n    public tryRelease(): Promise<any> {\n        if (this.currentLock) {\n            if (this.currentLock.tryRelease) {\n                return this.currentLock.tryRelease().then(() => {\n                    this.clearLock();\n                });\n            } else {\n                this.clearLock();\n                return Promise.resolve();\n            }\n        } else {\n            return Promise.reject('Current lock is null');\n        }\n    }\n\n    public async withLock<T = any>(action: () => Promise<T>): Promise<T> {\n        await this.acquire(() => Promise.reject());\n        return action().finally(() => this.clearLock());\n    }\n\n    public routerWillLeave(nextLocation: Link) {\n        if (this.currentLock) {\n            this.tryRelease()\n                .then(() => {\n                    this.router.redirect(nextLocation);\n                })\n                .catch(() => {});\n        }\n    }\n\n    private clearLock() {\n        this.currentLock = null;\n        this.unblock?.();\n    }\n\n    public release(lock: Lock) {\n        if (lock && this.currentLock === lock) {\n            this.clearLock();\n        } else {\n            throw new Error(\"Attempting to release a lock, which wasn't acquired\");\n        }\n    }\n}\n","import { BaseContext } from './BaseContext';\nimport { LayoutContext } from './LayoutContext';\nimport * as React from 'react';\nimport { IModalContext } from '../types/contexts';\nimport { IModal } from '../types/props';\n\nexport interface ModalOperation {\n    /** Modal component that should be rendered */\n    component?: React.ComponentType<any>;\n    /** Modal component props */\n    props: IModal<any>;\n}\n\nlet idCounter = 0;\n\nexport class ModalOperationCancelled {}\n\nexport class ModalContext extends BaseContext implements IModalContext {\n    private operations: ModalOperation[] = [];\n    constructor(private layoutCtx: LayoutContext) {\n        super();\n    }\n\n    public destroyContext() {\n        super.destroyContext();\n        this.closeAll();\n    }\n\n    public show<TResult, TParameters = {}>(render: (props: IModal<TResult, TParameters>) => React.ReactElement<any>, parameters?: TParameters): Promise<TResult> {\n        const ModalAdapter = class extends React.Component<IModal<TResult, TParameters>> {\n            render() {\n                return render(this.props);\n            }\n        };\n\n        return this.showModal(ModalAdapter, parameters);\n    }\n\n    public closeAll() {\n        this.operations = [];\n        this.update({});\n    }\n\n    private showModal<TParameters, TResult>(component: React.ComponentType<IModal<TResult, TParameters>>, parameters?: TParameters): Promise<TResult> {\n        const layer = this.layoutCtx.getLayer();\n        return new Promise((resolve, reject) => {\n            const modalProps: IModal<TResult, TParameters> = {\n                success: (r) => {\n                    this.operations.pop();\n                    this.layoutCtx.releaseLayer(layer);\n                    resolve(r);\n                    this.update({});\n                },\n                abort: (r) => {\n                    this.operations.pop();\n                    this.layoutCtx.releaseLayer(layer);\n                    reject(r ? r : new ModalOperationCancelled());\n                    this.update({});\n                },\n                zIndex: layer.zIndex,\n                depth: layer.depth,\n                isActive: true,\n                key: idCounter++ + '',\n                parameters,\n            };\n\n            const operation: ModalOperation = { component, props: modalProps };\n\n            this.operations.push(operation);\n\n            this.update({});\n        });\n    }\n\n    public isModalOperationActive() {\n        return this.operations.length > 0;\n    }\n\n    public getOperations(): ModalOperation[] {\n        return this.operations.map((op, n) => ({\n            ...op, props: { ...op.props, isActive: n === this.operations.length - 1 },\n        }));\n    }\n}\n","import * as React from 'react';\nimport { BaseContext } from './BaseContext';\nimport { NotificationParams, INotificationContext } from '../types/contexts';\nimport { LayoutContext } from './LayoutContext';\nimport { INotification } from '../types/props';\n\nlet idCounter = 0;\n\nexport interface NotificationOperation {\n    /** Notification component that should be rendered */\n    component: React.ComponentType<any>;\n    /** Notification component props */\n    props: INotification;\n    /** Notification config */\n    config: NotificationParams;\n}\n\nexport class NotificationContext extends BaseContext implements INotificationContext {\n    private notifications: NotificationOperation[] = [];\n    constructor(private layoutCtx: LayoutContext) {\n        super();\n    }\n\n    public destroyContext() {\n        this.clearAll();\n        super.destroyContext();\n    }\n\n    public show(render: (props: INotification) => React.ReactNode, notificationParams: NotificationParams): Promise<void> {\n        const NotificationAdapter = class extends React.Component<INotification> {\n            render() {\n                return render(this.props);\n            }\n        };\n\n        const params: NotificationParams = {\n            duration: 7,\n            position: 'bot-left',\n            ...notificationParams,\n        };\n\n        return new Promise((resolve, reject) => {\n            const layer = this.layoutCtx.getLayer();\n            let durationTimer: ReturnType<typeof setTimeout>;\n\n            const notificationProps: INotification = {\n                onClose: () => {\n                    this.remove(layer.id);\n                    this.layoutCtx.releaseLayer(layer);\n                    reject();\n                    this.update({});\n                },\n                onSuccess: () => {\n                    this.remove(layer.id);\n                    this.layoutCtx.releaseLayer(layer);\n                    resolve();\n                    this.update({});\n                },\n                clearTimer: () => clearTimeout(durationTimer),\n                refreshTimer: () => {\n                    if (params.duration !== 'forever') {\n                        clearTimeout(durationTimer);\n                        durationTimer = setTimeout(() => {\n                            notificationProps.onClose();\n                        }, params.duration * 1000);\n                    }\n                },\n                id: layer.id,\n                key: idCounter++ + '',\n            };\n\n            if (params.duration !== 'forever') {\n                durationTimer = setTimeout(() => {\n                    notificationProps.onClose();\n                }, params.duration * 1000);\n            }\n\n            const operation: NotificationOperation = { component: NotificationAdapter, props: notificationProps, config: params };\n\n            this.notifications.push(operation);\n\n            this.update({});\n        });\n    }\n\n    public getNotifications(): NotificationOperation[] {\n        return this.notifications;\n    }\n\n    public handleRedirect() {\n        this.notifications = [];\n    }\n\n    public remove(id: number) {\n        this.notifications = this.notifications.filter((i) => {\n            if (i.props.id === id) {\n                this.layoutCtx.releaseLayer(i.props.id);\n                return false;\n            }\n            return true;\n        });\n        this.update({});\n    }\n\n    public clearAll() {\n        this.notifications.map((i) => this.layoutCtx.releaseLayer(i.props.id));\n        this.notifications = [];\n        this.update({});\n    }\n}\n","export class UserSettingsContext {\n    get<TValue>(key: any, initial?: TValue): TValue {\n        if (!key) {\n            return initial || null;\n        }\n\n        const keyStr = JSON.stringify(key);\n\n        const json = window.localStorage.getItem(keyStr);\n        if (!json) {\n            return initial;\n        }\n        return JSON.parse(json);\n    }\n\n    set<TValue>(key: any, value: TValue) {\n        const keyStr = JSON.stringify(key);\n\n        if (key) {\n            window.localStorage.setItem(keyStr, JSON.stringify(value));\n        }\n    }\n}\n","import { AnalyticsContext } from '../services/AnalyticsContext';\nimport { ApiContext, ApiContextProps } from '../services/ApiContext';\nimport { ErrorContext } from '../services/ErrorContext';\nimport { DndContext } from '../services/dnd/DndContext';\nimport { LayoutContext } from '../services/LayoutContext';\nimport { LockContext } from '../services/LockContext';\nimport { ModalContext } from '../services/ModalContext';\nimport { NotificationContext } from '../services/NotificationContext';\nimport { ApiCallOptions, CommonContexts, IProcessRequest, IRouterContext } from '../types';\nimport { UserSettingsContext } from '../services/UserSettingsContext';\nimport { useEffect, useState } from 'react';\n\nexport interface UuiServicesProps<TApi> extends ApiContextProps {\n    /** Function to get the api definitions.\n     * Usually, api definitions this is an object which contain object with all api requests of the app.\n     * Then you can call this requests via 'uuiContext.api.myApi(myData)'\n     * */\n    apiDefinition?: (processRequest: IProcessRequest) => TApi;\n}\nexport interface UseUuiServicesProps<TApi, TAppContext> extends UuiServicesProps<TApi> {\n    /** AppContext value */\n    appContext?: TAppContext;\n    /** Instance of the router */\n    router: IRouterContext;\n}\n\nfunction createServices<TApi, TAppContext>(props: UseUuiServicesProps<TApi, TAppContext>) {\n    const {\n        router, appContext, apiDefinition, apiReloginPath, apiServerUrl, apiPingPath, fetch,\n    } = props;\n\n    const uuiLayout = new LayoutContext();\n    const uuiModals = new ModalContext(uuiLayout);\n    const uuiNotifications = new NotificationContext(uuiLayout);\n    const uuiAnalytics = new AnalyticsContext({ router });\n    const uuiLocks = new LockContext(router);\n    const uuiErrors = new ErrorContext(uuiAnalytics, uuiModals);\n    const uuiApi = new ApiContext({ apiPingPath, apiReloginPath, apiServerUrl, fetch }, uuiAnalytics);\n\n    const rawApi = apiDefinition ? apiDefinition(uuiApi.processRequest.bind(uuiApi)) : ({} as TApi);\n    const withOptions = (options: ApiCallOptions) => apiDefinition((url, method, data, defaultOptions) =>\n        uuiApi.processRequest(url, method, data, { ...defaultOptions, ...options }));\n    const api = { ...rawApi, withOptions };\n\n    const uuiUserSettings = new UserSettingsContext();\n    const uuiDnD = new DndContext();\n    const services: CommonContexts<TApi, TAppContext> = {\n        uuiAnalytics,\n        uuiErrors,\n        uuiApi,\n        api,\n        uuiLayout,\n        uuiNotifications,\n        uuiModals,\n        uuiUserSettings,\n        uuiDnD,\n        uuiRouter: router,\n        uuiLocks,\n        uuiApp: appContext || ({} as TAppContext),\n    };\n    return {\n        services,\n        destroyServices: () => {\n            uuiAnalytics.destroyContext();\n            uuiErrors.destroyContext();\n            uuiApi.destroyContext();\n            uuiLayout.destroyContext();\n            uuiNotifications.destroyContext();\n            uuiModals.destroyContext();\n            uuiDnD.destroyContext();\n            uuiLocks.destroyContext();\n        },\n        init: () => {\n            uuiAnalytics.init();\n            uuiErrors.init();\n            uuiApi.init();\n            uuiLayout.init();\n            uuiNotifications.init();\n            uuiModals.init();\n            uuiDnD.init();\n            uuiLocks.init();\n        },\n    };\n}\nexport const useUuiServices = <TApi, TAppContext>(props: UseUuiServicesProps<TApi, TAppContext>) => {\n    const [result] = useState(() => createServices<TApi, TAppContext>(props));\n\n    // Workaround to discard all errors on navigation. Need to find a better way. YakovZh\n    result.services.uuiErrors.discardError();\n    result.services.uuiApi.reset();\n\n    useEffect(() => {\n        result.init();\n\n        (window as any).UUI_VERSION = __PACKAGE_VERSION__; // it replaced with current uui version during build time\n\n        return () => {\n            result.destroyServices();\n        };\n    }, []);\n\n    return { services: result.services };\n};\n","import React, {\n    useContext, useEffect, useState,\n} from 'react';\nimport { IHasChildren } from '../types/props';\nimport { CommonContexts } from '../types/contexts';\nimport { HistoryAdaptedRouter, IHistory4, StubAdaptedRouter } from './routing';\nimport { DragGhost } from './dnd/DragGhost';\nimport { GAListener } from './analytics';\nimport { UuiServicesProps, useUuiServices } from '../hooks/useUuiServices';\nimport { UuiContext } from './UuiContext';\n\nexport interface ContextProviderProps<TApi, TAppContext> extends UuiServicesProps<TApi>, IHasChildren {\n    /** Callback to load the AppContext data. AppContext is used to load global data, before application mount */\n    loadAppContext?: (api: TApi) => Promise<TAppContext>;\n    /** Called when all contexts were initiated */\n    onInitCompleted(svc: CommonContexts<TApi, TAppContext>): void;\n    /** Instance of react-router history.\n     * Note, that it should be the same object which you passed to the Router.\n     * */\n    history?: IHistory4;\n    /** Code of Google Analytics.\n     * If provided, user interactions events will be sent to your GA.\n     * */\n    gaCode?: string;\n}\n\nexport function ContextProvider<TApi, TAppContext>(props: ContextProviderProps<TApi, TAppContext>) {\n    const [isLoaded, setIsLoaded] = useState(false);\n    const {\n        loadAppContext, onInitCompleted, children: propsChildren, history, gaCode, ...restProps\n    } = props;\n\n    const router = !!history ? new HistoryAdaptedRouter(history) : new StubAdaptedRouter();\n\n    const { services } = useUuiServices<TApi, TAppContext>({ ...restProps, router });\n    services.history = history;\n\n    useEffect(() => {\n        const loadAppContextPromise = loadAppContext || (() => Promise.resolve({} as TAppContext));\n        gaCode && services.uuiAnalytics.addListener(new GAListener(gaCode));\n        loadAppContextPromise(services.api).then((appCtx) => {\n            services.uuiApp = appCtx;\n            onInitCompleted(services);\n            setIsLoaded(true);\n        });\n    }, []);\n\n    const children = isLoaded ? propsChildren : '';\n\n    return (\n        (\n            <UuiContext.Provider value={ services }>\n                {children}\n                <DragGhost />\n            </UuiContext.Provider>\n        )\n    );\n}\n\nexport function useUuiContext<TApi = any, TAppContext = any>(): CommonContexts<TApi, TAppContext> {\n    const context = useContext(UuiContext);\n    if (!Object.keys(context).length) {\n        throw new Error('useUuiContext must be called within UuiContextProvider');\n    }\n    return context;\n}\n","import React from 'react';\nimport { IEditable, IAnalyticableOnChange } from '../types';\nimport debounce from 'lodash.debounce';\nimport { useUuiContext } from '../services';\nimport {\n    ReactElement, useCallback, useEffect, useMemo, useRef, useState,\n} from 'react';\n\n/**\n * IEditableDebouncer component options.\n */\nexport interface IEditableDebouncerOptions {\n    /** Pass true to disable debouncing */\n    disableDebounce?: boolean;\n    /** Debounce delay in ms. Default value is 500ms */\n    debounceDelay?: number;\n}\n\n/**\n * IEditableDebouncer component props.\n */\nexport interface IEditableDebouncerProps<T> extends IEditable<T>, IEditableDebouncerOptions, IAnalyticableOnChange<T> {\n    /**\n     * Render wrapped component.\n     * Receives props and forwarded ref as a second parameter.\n     */\n    render: (props: IEditable<T>, ref: React.Ref<any>) => React.ReactNode;\n}\n\nconst defaultDelay = 500;\n\nconst IEditableDebouncerImpl = <T,>(\n    props: IEditableDebouncerProps<T>,\n    ref: React.Ref<any>,\n) => {\n    const [state, setState] = useState({ value: props.value });\n    const lastSentValue = useRef(props.value);\n    const context = useUuiContext();\n\n    useEffect(() => {\n        if ((props.value !== lastSentValue.current)) {\n            setState({ value: props.value });\n            lastSentValue.current = props.value;\n        }\n    }, [props.value]);\n\n    const debouncedOnValueChange = useMemo(() => {\n        return debounce(\n            (value) => {\n                lastSentValue.current = value;\n                props.onValueChange(value);\n\n                if (props.getValueChangeAnalyticsEvent) {\n                    const event = props.getValueChangeAnalyticsEvent(value, props.value);\n                    context.uuiAnalytics.sendEvent(event);\n                }\n            },\n            props.debounceDelay != null ? props.debounceDelay : defaultDelay,\n            { leading: false, trailing: true },\n        );\n    }, [\n        props.onValueChange, props.getValueChangeAnalyticsEvent, props.debounceDelay, props.value,\n    ]);\n\n    const handleValueChange = useCallback(\n        (newValue: T) => {\n            setState({ value: newValue });\n            if (props.disableDebounce) {\n                props.onValueChange(newValue);\n            } else {\n                debouncedOnValueChange(newValue);\n            }\n        },\n        [\n            props.disableDebounce, props.onValueChange, debouncedOnValueChange,\n        ],\n    );\n\n    const propsToRender = useMemo(\n        () => ({\n            value: state.value,\n            onValueChange: handleValueChange,\n        }),\n        [state.value, handleValueChange],\n    );\n\n    return props.render?.(propsToRender, ref) as ReactElement<any>;\n};\n\nconst IEditableDebouncerForwardRef = React.forwardRef(IEditableDebouncerImpl) as <T>(\n    props: IEditableDebouncerProps<T> & { ref?: React.Ref<any> }\n) => React.ReactElement | null;\n\n/**\n * Wrap other IEditable components into the IEditableDebouncer to debounce onValueChange calls.\n * Useful for search inputs, or any other components that cause expensive computations on change.\n * Wrapped component still behaves as controlled component, and will react to external value changes immediately.\n */\nexport const IEditableDebouncer = React.memo(IEditableDebouncerForwardRef) as typeof IEditableDebouncerForwardRef;\n","const base = 26;\nconst memoized: string[] = [];\n\n/**\n * Computes order string from integer item index in a sequence.\n * Useful for creating initial orders of items, which can be later manipulated with getOrderBetween to insert or move items.\n * @param input integer order of item\n * @returns order string\n */\nexport function indexToOrder(input: number) {\n    const existing = memoized[input];\n    if (existing) {\n        return existing;\n    }\n\n    const aChar = 97;\n    const digits = [];\n\n    let lastInputValue = input;\n    while (lastInputValue > 0) {\n        digits.unshift((lastInputValue % base) + aChar);\n        lastInputValue = Math.floor(lastInputValue / base);\n    }\n    const order = String.fromCharCode(\n        // Put number of digits first, to establish order between numbers\n        // of different length (the longer is bigger)\n        // We add '+ 1' is to start number of digits from 'b'\n        // to leave room to insert orders before numberToOrder(0), w/o using digits.\n        digits.length + aChar + 1,\n        ...digits,\n    );\n    memoized[input] = order;\n    return order;\n}\n\nexport const minOrderStr = 'a';\nexport const maxOrderStr = 'zzzz';\n\n/**\n * Calculates a string, which is between two strings, if strings are sorted in alphabetic order.\n *\n * Examples:\n *\n *  - 'a', 'z' => 's'\n *  - 'a', 'b' => 'as'\n *  - 'as, 'b' => 'au'\n *  - 'aa, 'ab' => 'aas' // there's no precision limit\n *  - null, 'c' => 'b' // insert first\n *  - 'c', null => 'u' // insert last\n *\n * This approach allows to add order to arbitrary list of items.\n *\n * Any item can be moved to any place in the list by modifying only one attribute. So:\n * - you can save only moved item(s) to server, not the whole list\n * - you can store items in any suitable structure, e.g. - Map<id, Item>, instead of plain arrays\n * - server can trivially update items, as usual fields\n * - server can sort items as well - we use only ASCII 0-9 and a-z, to there's no collation issues\n * - it's better than using integer numbers: no need to renumber items in case you need to insert an item between 1 and 2\n * - it's better than using floats: they can have limited precision, which can lead to complicated issues\n *\n * The function implements a basic average of 2 numbers: (a + b)/2, interpreting strings as fractional part of base-36 number.\n *\n * Read more [here](https://uui.epam.com/documents?id=dragAndDrop&mode=doc&skin=UUI4_promo&category=advanced)\n * @param inputA order string before (can be start for the start of the list)\n * @param inputB order string after (can be null for the end of the list)\n * @returns order string between inputA and inputB\n */\nexport function getOrderBetween(inputA: string | null, inputB: string | null): string {\n    const radix = 36;\n    let a = inputA;\n    const b = inputB || 'z';\n\n    if (!a) {\n        // We were generating chars 0-z prior. Now we try yo use only a-z.\n        // This is done to avoid issues with string sort/compare algorithms (e.g. Intl.Collator().compare we use in DataSources),\n        // which compare number so '1' < '10', and we rely on plain char-by-char comparators.\n\n        // However, there's no options to generate value less than 'a' w/o digits.\n        // This can happen for already generated orders.\n        a = (b <= 'a') ? '0' : 'a';\n    }\n\n    const throwError = () => {\n        throw new Error(`getOrderBetween: can't find values between ${inputA} and ${inputB}`);\n    };\n\n    if (a >= b) {\n        throwError();\n    }\n\n    let result = '';\n    let n = 0;\n\n    // If we see two close chars, like 'a' and 'b' or '1' and '2' - we can't fit another\n    // char between them at this position.\n    // However, this means that A is already less than B, and we\n    // can use this when comparing next positions.\n    let resultIsLessThanB = false;\n\n    while (true) {\n        const aChar = a[n];\n\n        // If result < B according to prior chars, any letter greater than aChar will be ok\n        const bChar = resultIsLessThanB ? 'z' : b[n];\n\n        let aDigit = parseInt(aChar || '0', radix);\n        const bDigit = parseInt(bChar || 'z', radix);\n\n        // We were generating chars 0-z, however now we try to use a-z if possible.\n        // Unfortunately, it's not possible, if order already contains digits.\n        if (bDigit > 10) {\n            aDigit = Math.max(10, aDigit);\n        }\n\n        const midDigit = Math.floor((aDigit + bDigit) / 2);\n\n        result += midDigit.toString(radix);\n\n        if (aDigit !== midDigit) {\n            break;\n        }\n\n        if (aDigit < bDigit) {\n            resultIsLessThanB = true;\n        }\n\n        n++;\n    }\n\n    return result;\n}\n","export function isUrl(url: string): boolean {\n    const expression = /[-a-zA-Z0-9@:%_\\+.~#?&//=]{2,256}\\.[a-z]{2,4}\\b(\\/[-a-zA-Z0-9@:%_\\+.~#?&//=]*)?/gi;\n    const regex = new RegExp(expression);\n    return !!url.match(regex);\n}\n\nexport function prependHttp(url: string, options: { https: boolean }) {\n    if (typeof url !== 'string') {\n        throw new TypeError(`Expected \\`url\\` to be of type \\`string\\`, got \\`${typeof url}\\``);\n    }\n\n    url = url.trim();\n\n    if (/^\\.*\\/|^(?!localhost)\\w+:/.test(url)) {\n        return url;\n    }\n\n    return url.replace(/^(?!(?:\\w+:)?\\/\\/)/, options.https ? 'https://' : 'http://');\n}\n","import { SortingOption } from '../../types/dataSources';\n\nconst eqPredicate = () => 0;\n\n// Previous versions use this comparer. While it works great for human-readable strings, it's broken for dates. Also, we need a plain sort in case of 'order' fields.\n// const compareScalars = (new Intl.Collator(undefined, {numeric: true, sensitivity: 'base'})).compare;\n\nexport function compareScalars(a: any, b: any, order: number) {\n    if (a == null) {\n        if (b == null) {\n            return 0;\n        }\n        return -order;\n    }\n    if (b == null) return order;\n    if (a < b) return -order;\n    if (a === b) return 0;\n\n    return order;\n}\n\nexport function getOrderComparer<TEntity>(sorting: SortingOption[]): (a: TEntity, b: TEntity) => number {\n    if (!sorting || sorting.length === 0) {\n        return eqPredicate;\n    }\n\n    const sortingOrders = sorting.map((s) => (s.direction === 'desc' ? -1 : 1));\n\n    const comparer = (a: any, b: any) => {\n        for (let n = 0; n < sorting.length; n++) {\n            const fieldName = sorting[n].field;\n            const compareResult = compareScalars(a[fieldName], b[fieldName], sortingOrders[n]);\n            if (compareResult !== 0) {\n                return compareResult;\n            }\n        }\n        return 0;\n    };\n\n    return comparer;\n}\n","import { compareScalars } from '../data/querying/getOrderComparer';\n\n/**\n * Function, which orders array of items by criteria in some direction.\n * @param arr - list of items to be ordered.\n * @param by - criteria of ordering.\n * @param order - direction of ordering. Default: 'asc'.\n * @returns - array of data, ordered by criteria.\n */\nexport function orderBy<T>(arr: T[], by: (item: T) => string | number | null | undefined, order: 'asc' | 'desc' = 'asc') {\n    const sortedArr = [...arr];\n    const sign = order === 'desc' ? -1 : 1;\n    return sortedArr.sort((a, b) => {\n        const aBy = by(a);\n        const bBy = by(b);\n        return compareScalars(aBy, bBy, sign);\n    });\n}\n","import { ColumnsConfig, DataColumnProps } from '../types';\nimport { getOrderBetween } from './getOrderBetween';\nimport { orderBy } from './orderBy';\n\nexport const applyColumnsConfig = <TItem, TId>(columns: DataColumnProps<TItem, TId>[], config: ColumnsConfig) => {\n    const newColumns = columns.reduce<DataColumnProps<TItem, TId>[]>((acc, c) => {\n        const { fix, width, ...restColumnProps } = c;\n        const cfg = config[c.key];\n\n        cfg.isVisible\n            && acc.push({\n                ...restColumnProps,\n                width: cfg.width,\n                ...(cfg.fix ? { fix: cfg.fix } : {}),\n            });\n        return acc;\n    }, []);\n\n    return orderBy(newColumns, (i) => config[i.key].order);\n};\n\nexport const getColumnsConfig = <TItem, TId>(columns: DataColumnProps<TItem, TId>[], config: ColumnsConfig) => {\n    const resultConfig: ColumnsConfig = { };\n\n    const sortedOrders = orderBy(Object.values(config ?? {}).filter(Boolean), (f) => f.order);\n    const lastItemOrder: string | null = sortedOrders?.length ? sortedOrders[sortedOrders.length - 1]?.order : null;\n\n    let prevOrder = lastItemOrder || 'a';\n\n    columns.forEach((column) => {\n        const hasPrevColumnConfig = !!config?.[column.key];\n        if (hasPrevColumnConfig) {\n            resultConfig[column.key] = config?.[column.key];\n        } else {\n            const order = getOrderBetween(prevOrder, null);\n\n            resultConfig[column.key] = {\n                width: column.width,\n                fix: column.fix ?? (column.isLocked ? 'left' : undefined),\n                isVisible: !column.isHiddenByDefault,\n                order: order,\n            };\n            prevOrder = order;\n        }\n    });\n\n    return resultConfig;\n};\n","export function formatBytes(bytes: number, decimals = 2, withSizes = true) {\n    if (bytes === 0) return '0 Bytes';\n\n    const k = 1024;\n    const dm = decimals < 0 ? 0 : decimals;\n    const sizes = [\n        'Bytes', 'KB', 'MB', 'GB', 'TB', 'PB', 'EB', 'ZB', 'YB',\n    ];\n\n    const i = Math.floor(Math.log(bytes) / Math.log(k));\n\n    const numbersResult = parseFloat((bytes / Math.pow(k, i)).toFixed(dm));\n    return withSizes ? `${numbersResult} ${sizes[i]}` : `${numbersResult}`;\n}\n","type CalculatedDTO = {\n    value: number | null;\n    step?: number;\n    action?: 'incr' | 'decr';\n};\n\ntype ValidationDTO = {\n    value: number;\n    min?: number;\n    max?: number;\n};\n\nexport const getMinMaxValidatedValue = ({ value, min = 0, max = Number.MAX_SAFE_INTEGER }: ValidationDTO): number => {\n    if (value > max) {\n        return max;\n    } else if (value < min) {\n        return min;\n    } else {\n        return value;\n    }\n};\n\nexport const getCalculatedValue = ({ value: initialValue, step = 1, action = 'incr' }: CalculatedDTO): number => {\n    const value = initialValue || 0;\n    const valueDecimalLength = getDecimalLength(value);\n    const stepDecimalLength = getDecimalLength(step);\n    const decimalLength = valueDecimalLength >= stepDecimalLength ? valueDecimalLength : stepDecimalLength;\n\n    let adjustedValue = value;\n    switch (action) {\n        case 'decr':\n            adjustedValue = value - step;\n            break;\n        case 'incr':\n            adjustedValue = value + step;\n            break;\n        default:\n            return 0;\n    }\n    return Number(adjustedValue.toFixed(decimalLength));\n};\n\nexport const getDecimalLength = (value: number | null): number => {\n    const splitedValue = String(value).split('.');\n    if (splitedValue.length === 1) return 0;\n    return splitedValue[1].length;\n};\n\nexport const getSeparatedValue = (value: number | null, formatOptions: Intl.NumberFormatOptions = {}, locale?: string): string | null => {\n    if (!value && value !== 0) return null;\n    return value.toLocaleString(locale, formatOptions);\n};\n","import { Middleware } from '@floating-ui/react';\nimport { isClientSide } from './ssr';\n\nexport const isMobile = (screenWidth: number = 720) => {\n    return isClientSide && window.matchMedia?.(`screen and (max-width: ${screenWidth}px)`).matches;\n};\n\nexport const mobilePositioning: Middleware = {\n    name: 'mobilePositioning',\n    fn({ x, y }) {\n        return {\n            x: isMobile() ? 0 : x,\n            y: isMobile() ? 0 : y,\n        };\n    },\n};\n","/* eslint-disable no-console */\nenum MsgLevel {\n    error = 'error',\n    warn = 'warn',\n    log = 'log'\n}\n\nfunction getCurrentStack(cutItems: number = 0) {\n    let stack = new Error().stack;\n    if (cutItems > 0) {\n        const rest = stack.slice(1).split('\\n');\n        stack = rest.slice(cutItems).join('\\n');\n    }\n    return stack;\n}\n\nfunction getKey(msg: string, args: any[]) {\n    return msg + args.join();\n}\n\nclass UuiLogger {\n    private msgHistory: { [key: string]: true } = {};\n\n    private msgAddToHistory = (msg: string, args: any[]) => {\n        this.msgHistory[getKey(msg, args)] = true;\n    };\n\n    private msgIsAlreadyLogged = (msg: string, args: any[]) => {\n        const isNew = !this.msgHistory[getKey(msg, args)];\n        return !isNew;\n    };\n\n    private addToLog = (severity: MsgLevel, msg: string, args: any[]): void => {\n        if (this.msgIsAlreadyLogged(msg, args)) {\n            return;\n        }\n        this.msgAddToHistory(msg, args);\n        let method = console[severity];\n        // @ts-ignore\n        const origMethodReplaced = method.__REACT_DEVTOOLS_STRICT_MODE_ORIGINAL_METHOD__;\n\n        if (origMethodReplaced) {\n            method = origMethodReplaced;\n        }\n        method(msg, ...args);\n    };\n\n    /**\n     * Logs warning to console in development mode. Has no effect in production mode.\n     *\n     * @param msg\n     * @param args\n     */\n    public warn = (msg: string, ...args: any[]) => {\n        if (__DEV__) {\n            const stack = getCurrentStack(3);\n\n            this.addToLog(MsgLevel.error, `[UUI Warning]: ${msg}\\n\\n%s`, [...args, stack]);\n        }\n    };\n\n    /**\n     * Logs warning to console in development mode. Has no effect in production mode.\n     * @param props\n     */\n    public warnAboutDeprecatedPropValue = <T1, T2 extends keyof T1>(\n        props: {\n            component?: string,\n            propName: T2,\n            propValue: T1[T2],\n            propValueUseInstead?: T1[T2],\n            condition?: () => boolean,\n        },\n    ) => {\n        const {\n            propName,\n            propValue,\n            propValueUseInstead,\n            condition,\n            component,\n        } = props;\n        const shouldWarn = condition ? condition() : true;\n        if (shouldWarn) {\n            const comp = component ? `(${component}) ` : '';\n            const instead = propValueUseInstead ? `Please use ${propValueUseInstead} value instead.` : '';\n            this.warn(`${comp}The ${propValue} value of ${String(propName)} is deprecated and will be removed in future versions. ${instead}`);\n        }\n    };\n}\n\nexport const devLogger = new UuiLogger();\n","export const clearEmptyValueFromRecord = <TRecord extends Record<string, any> = Record<string, any>>(record: TRecord): TRecord => {\n    if (record === undefined || record === null || typeof record !== 'object') {\n        return record;\n    }\n\n    return Object.keys(record).reduce((acc: TRecord | undefined, key) => {\n        let newAcc = acc;\n        if (record[key] !== undefined) {\n            if (!newAcc) {\n                newAcc = {} as TRecord;\n            }\n            (newAcc as Record<string, any>)[key] = record[key];\n        }\n        return newAcc;\n    }, undefined);\n};\n","import * as React from 'react';\nimport { CX } from '../types';\nimport { withMods } from './withMods';\n\nexport function createSkinComponent<SourceProps, SkinProps = {}>(\n    Component: React.ComponentType<SourceProps>,\n    getProps?: (props: Readonly<SkinProps>) => Partial<SkinProps | SourceProps>,\n    getCx?: (props: Readonly<SkinProps>) => CX,\n) : (props: SkinProps & React.RefAttributes<any>) => React.ReactElement<any> | null {\n    return withMods(Component as any, getCx as any, getProps as any) as any;\n}\n","function rangeFromTo(start: number, end: number, step?: number) {\n    const defaultStepForRange = (end >= start) ? 1 : -1;\n\n    return Array.from({ length: (end - start) / (step || defaultStepForRange) }, (_, index) => {\n        if (step === 0) {\n            return 1;\n        }\n\n        return start + (index * (step ?? defaultStepForRange));\n    });\n}\n\n/**\n * Factory of numeric sequences with the exact step.\n * @param start - a start number of the sequence inclusively.\n * @param end - an end number of the sequence exclusively.\n * @param step - step of the progression. Defaults:\n * - if start <= end, step = 1\n * - if start > end, step = -1.\n * @returns a sequence of numbers in progression, described by bounds with a specific step.\n */\nexport function range(start: number, end?: number, step?: number) {\n    if (end === undefined) {\n        return rangeFromTo(0, start, step);\n    }\n\n    return rangeFromTo(start, end, step);\n}\n","export type HTMLDir = 'rtl' | 'ltr';\n\nexport function getDir(): HTMLDir {\n    if (typeof window !== 'undefined') {\n        return window.document.dir as HTMLDir;\n    }\n\n    return 'ltr';\n}\n","import { ICheckable } from './props';\nimport { DataRowOptions, DataRowProps } from './dataRows';\nimport { IImmutableMap, IMap } from './objects';\nimport { PatchOrderingType } from '../data';\nimport { FetchingOptions } from '../services';\n\nexport interface SearchConfig<TItem> {\n    /**\n     * A pure function that gets search value for each item.\n     * @default (item) => item.name.\n     */\n    getSearchFields?(item: TItem): string[];\n\n    /**\n     * Enables sorting of search results by relevance.\n     * - The highest priority has records, which have a full match with a search keyword.\n     * - The lower one has records, which have a search keyword at the 0 position, but not the full match.\n     * - Then, records, which contain a search keyword as a separate word, but not at the beginning.\n     * - And the lowest one - any other match of the search keyword.\n     *\n     * Example:\n     * - `search`: 'some'\n     * - `record string`: 'some word', `rank` = 4\n     * - `record string`: 'someone', `rank` = 3\n     * - `record string`: 'I know some guy', `rank` = 2\n     * - `record string`: 'awesome', `rank` = 1\n     *\n     * @default true\n     */\n    sortSearchByRelevance?: boolean;\n}\n\nexport interface SortConfig<TItem> {\n    /**\n     * A pure function that gets sorting value for current sorting value\n     */\n    sortBy?(item: TItem, sorting: SortingOption): any;\n}\n\nexport interface FilterConfig<TItem, TFilter> {\n    /**\n     * A pure function that returns filter callback to be applied for each item.\n     * The callback should return true, if item passed the filter.\n     */\n    getFilter?(filter: TFilter): (item: TItem) => boolean;\n}\n\nexport type SortDirection = 'asc' | 'desc';\n\nexport interface SortingOption<T = any> {\n    /** Field of sorted entity under which sorting is performed */\n    field: keyof T;\n    /** Direction of a sorting */\n    direction?: SortDirection;\n}\n\nexport interface VirtualListRange {\n    /**\n     * Index of the topmost item, in rendered batch.\n     * Note - this item might not be visible, as Virtual List maintain some reserve of rows on top / at the bottom of the list\n     */\n    topIndex?: number;\n    /**\n     * Number of currently rendered items.\n     * Virtual list updates this value automatically, if it too small.\n     * Note Virtual List renders more items, that actually visible,\n     * as it need maintain some reserve of rows on top / at the bottom of the list.\n     */\n    visibleCount?: number;\n}\n\nexport type ScrollAlign = 'top' | 'nearest';\n\n/**\n * Holds configuration of the force scrolling behavior.\n */\nexport interface ScrollToConfig {\n    /** Index of the row to be scrolled to. */\n    index?: number;\n\n    /** Scrolling movement behavior. */\n    behavior?: ScrollBehavior;\n\n    /** Alignment behavior. This property specifies, to which position a row with an index should be scrolled to.\n     * @default 'top'\n     *\n     * If `nearest` is specified, a list will be scrolled to a row in the nearest position only if row is not visible.\n     * If a row is closer to the bottom, the list will be scrolled to the row in the bottom position of a scroll container.\n     * If closer to the top, will be scrolled to the row in the top position.\n     *\n     * If `top` is specified, scrolling a list to a row to the top part of the container will happen in any case.\n    */\n    align?: ScrollAlign;\n}\n\n/** Holds state of a Virtual List - top visible item index, and estimated count of visible items */\nexport interface VirtualListState extends VirtualListRange {\n    /**\n     * Virtual list ensures that row with this Index is within the visible area, if not Virtual List .\n     * Virtual list updates this value on scroll to null when appear in the visible area.\n     * If this value is updated manually, Virtual List would scroll to the specified items.\n     * It would attempt to put scroll so this item will be at the top of the list.\n     */\n    scrollTo?: ScrollToConfig;\n}\n\nexport interface IDataSource<TItem, TId, TFilter> {\n    getId(item: TItem): TId;\n    getById(id: TId): TItem | void;\n    setItem(item: TItem): void;\n    useView(\n        value: DataSourceState<any, TId>,\n        onValueChange: SetDataSourceState<TFilter, TId>,\n        options?: any,\n        deps?: any[],\n    ): IDataSourceView<TItem, TId, TFilter>;\n}\n\n/**\n * Patch tree configuration.\n */\nexport interface PatchOptions<TItem, TId> extends SortConfig<TItem> {\n    /**\n     * Edited items array, which should be added/updated/deleted upon the tree.\n     * Note: Search and filter are not applied to the patched items. This is to ensure that newly added or edited items are not filtered out from the view.\n     */\n    patch?: IMap<TId, TItem> | IImmutableMap<TId, TItem>;\n\n    /**\n     * To enable deleting of the items, it is required to specify getter for deleted state.\n     */\n    isDeleted?(item: TItem): boolean;\n\n    /**\n     * Provides information about the relative position of the new item.\n     * @param item - new item, position should be got for.\n     * @returns relative position in the list of items.\n     * @default PatchOrdering.TOP\n     */\n    getNewItemPosition?: (item: TItem) => PatchOrderingType;\n\n    /**\n     *\n     * Provides information about the temporary order of the new item.\n     * @param item - new item, temporary order should be got for.\n     * @returns temporary order\n     *\n     * @experimental The API of this feature can be changed in the future releases.\n     */\n    getItemTemporaryOrder?: (item: TItem) => string;\n\n    /**\n     * If enabled, items position is fixed between sorting.\n     * @default true\n     */\n    fixItemBetweenSortings?: boolean;\n}\n\nexport interface FlattenSearchResultsConfig {\n    /**\n     * Falls back to plain list from tree, if there's search.\n     * Default is true.\n     *\n     * If enabled, and search is active:\n     * - API will be called with parentId and parent undefined\n     * - getChildCount is ignored, all nodes are assumed to have no children\n     *\n     * See more here: https://github.com/epam/UUI/issues/8\n     */\n    flattenSearchResults?: boolean;\n}\n\nexport interface BaseDataSourceConfig<TItem, TId, TFilter = any> extends PatchOptions<TItem, TId> {\n    /**\n     * Should return unique ID of the TItem\n     * If omitted, we assume that every TItem has and unique id in its 'id' field.\n     * @param item - record, which id should be returned.\n     * @returns item id.\n     */\n    getId?(item: TItem): TId;\n\n    /**\n     * Set to true, if you use IDs which can't act as javascript Map key (objects or arrays).\n     * In this case, IDs will be internally JSON.stringify-ed to be used as Maps keys.\n     */\n    complexIds?: boolean;\n\n    /** Should return ID of the Item's parent. Usually it's i => i.parentId.\n     * If specified, Data Source will build items hierarchy.\n     *\n     * Also, it is used by LazyDataSource to pre-fetch missing parents of loaded items. This is required in following cases:\n     * - when a child item is pre-selected, but not yet loaded at start. We need to load it's parent chain\n     *   to highlight parents with selected children\n     * - in flattenSearch mode, we usually want to display a path to each item (e.g. Canada/Ontario/Paris),\n     *   We need to load parents with a separate call (if backend doesn't pre-fetch them)\n     *\n     * @param item - record, which paretnId should be returned.\n     * @returns item parentId.\n     */\n    getParentId?(item: TItem): TId | undefined;\n\n    /**\n     * Specifies if rows are selectable, checkable, draggable, clickable, and more.\n     * See DataRowOptions for more details.\n     * If options depends on the item itself, use getRowOptions.\n     * Specifying both rowOptions and getRowOptions might help to render better loading skeletons: we use only rowOptions in this case, as we haven't loaded an item yet.\n     * Make sure all callbacks are properly memoized, as changing them will trigger re-renders or row, which would impact performance\n     * @param item An item to get options for\n     */\n    rowOptions?: DataRowOptions<TItem, TId>;\n\n    /**\n     * For each row, specify if row is selectable, editable, checkable, draggable, clickable, have its own set of columns, and more.\n     * To make rows editable, pass IEditable interface to each row. This works the same way as for other editable components.\n     * See DataRowOptions for more details.\n     * If both getRowOptions and rowOptions specified, we'll use getRowOptions for loaded rows, and rowOptions only for loading rows.\n     * Make sure all callbacks are properly memoized, as changing them will trigger re-renders or row, which would impact performance\n     * @param item - record, configuration should be returned for.\n     * @param index - index of a row. It is optional and should not be expected, that it is provided on every call.\n     */\n    getRowOptions?(item: TItem, index?: number): DataRowOptions<TItem, TId>;\n\n    /**\n     * Can be specified to unfold all or some items at start.\n     * If not specified, all rows would be folded.\n     * @param item - record, folding value should be returned for.\n     * @param dataSourceState - dataSource state with current `foldAll` value. It provides the possibility to respect foldAll change, if `isFoldedByDefault` is implemented.\n     */\n    isFoldedByDefault?(item: TItem, state: DataSourceState<TFilter, TId>): boolean;\n\n    /**\n     * Controls how the selection (checking items) of a parent node affects the selection of its all children, and vice versa.\n     * - false: All nodes are selected independently (default).\n     * - true or 'explicit': Selecting a parent node explicitly selects all its children. Unchecking the last parent's child unchecks its parent.\n     * - 'implicit': Selecting a parent node means that all children are considered checked.\n     *   The user sees all these nodes as checked on the UI, but only the selected parent is visible in the PickerInput tags, and only the checked\n     *   parent is present in the Picker's value or DataSourceState.checked array. When the user unchecks the first child of such a parent,\n     *   its parents become unchecked and all children but the unchecked one become checked, making children's selection explicit. If the last\n     *   unchecked child gets checked, all children from the checked are removed, returning to the implicit state when only the parent is checked.\n     */\n    cascadeSelection?: CascadeSelection;\n\n    /**\n     * Enables/disables selectAll functionality. If disabled explicitly, `selectAll`, returned from a view is null.\n     * @default true\n     */\n    selectAll?: true | false;\n\n    /**\n     * Enables returning only selected rows and loading missing selected/checked rows, if it is required/possible.\n     * If enabled, `useView` returns only selected rows from `IDataSourceView.getVisibleRows`.\n     */\n    showSelectedOnly?: boolean;\n}\n\n/** Holds state of a components displaying lists - like tables. Holds virtual list position, filter, search, selection, etc. */\nexport interface DataSourceState<TFilter = Record<string, any>, TId = any> extends VirtualListState {\n    /**\n     * Search value, used to filter data based on it.\n     * Included in the API request object when using a LazyDataSource.\n     * For Array and Async data sources, searching is performed internally by the datasource.\n     * */\n    search?: string;\n    /** Array of checked items IDs */\n    checked?: TId[];\n    /**\n     * A map of item IDs to their folding state.\n     * If an item ID is present with a `true` value, it's folded; otherwise, it's not folded.\n     * */\n    folded?: Record<string, boolean>;\n    /**\n     * Filter value used to filter data based on it.\n     * Included in the API request object when using a LazyDataSource.\n     * For Array and Async data sources, filtering is performed internally by the datasource.\n     * */\n    filter?: TFilter;\n    /**\n     * Sorting value, used to sort data based on it.\n     * Included in the API request object when using a LazyDataSource.\n     * For Array and Async data sources, sorting is performed internally by the datasource.\n     * */\n    sorting?: SortingOption[];\n    /** ID of selected item. It can be only one selected item at the moment. */\n    selectedId?: TId;\n    /** Index of currently focused item */\n    focusedIndex?: number;\n    /** Current page number */\n    page?: number;\n    /** The amount of items per page */\n    pageSize?: number;\n\n    /**\n     * Provides default folding of nodes if the opposite value is not present in the folded map.\n     * It is used to collapse/expand all nodes.\n     */\n    foldAll?: boolean;\n}\n\n/**\n * DataSource state update handler.\n */\nexport type SetDataSourceState<TFilter = Record<string, any>, TId = any> = (\n    updateState: (prevState: DataSourceState<TFilter, TId>) => DataSourceState<TFilter, TId>\n) => void;\n\nexport const CascadeSelectionTypes = {\n    IMPLICIT: 'implicit',\n    EXPLICIT: 'explicit',\n} as const;\n\nexport type CascadeSelection = boolean | typeof CascadeSelectionTypes.EXPLICIT | typeof CascadeSelectionTypes.IMPLICIT;\n\n/**\n * Type of the position an item to be placed to.\n */\nexport type PositionType = 'initial' | 'top' | 'bottom';\n\n/**\n * Position an item should be placed to.\n */\nexport type Position<TId> = PositionType | { after: TId };\n\nexport type SortedPatchByParentId<TItem, TId> = IMap<\nTId,\n{\n    top: TId[],\n    bottom: TId[],\n    updated: TId[],\n    moved: TId[],\n    withTempOrder: TId[],\n    updatedItemsMap: IMap<TId, TItem>,\n    newItems: TItem[],\n}\n>;\n\nexport interface BaseListViewProps<TItem, TId, TFilter> extends BaseDataSourceConfig<TItem, TId, TFilter> {}\n\nexport type IDataSourceViewConfig = {\n    complexIds?: boolean;\n    cascadeSelection?: CascadeSelection;\n    selectAll?: true | false;\n    backgroundReload?: boolean;\n    flattenSearchResults?: boolean;\n};\n\n// eslint-disable-next-line @typescript-eslint/no-unused-vars\nexport type IDataSourceView<TItem, TId, TFilter> = {\n    getConfig(): IDataSourceViewConfig;\n    getById(id: TId, index: number): DataRowProps<TItem, TId>;\n    getListProps(): DataSourceListProps;\n    getVisibleRows(): DataRowProps<TItem, TId>[];\n    getSelectedRowsCount(): number;\n    reload(): void;\n    clearAllChecked(): void;\n\n    selectAll?: ICheckable;\n};\n\nexport type DataSourceListCounts = {\n    /**\n     * Count of rows, after applying filter, and folding on tree nodes.\n     * Obsolete! Please switch to exactRowsCount / knownRowsCount\n     */\n    rowsCount?: number;\n\n    /** Count of rows, if all rows loaded. Can be null while initial loading, or if API doesn't return count  */\n    exactRowsCount?: number;\n\n    /**\n     * There's at least knownRowsCount rows. There can be more if list is lazy loaded.\n     * Equals to exactRowsCount if all rows are loaded, or if API returns rows count\n     * Otherwise, exactRowsCount will be null, and knownRowsCount will specify number of loaded rows.\n     */\n    knownRowsCount?: number;\n\n    /** Total count of items, before applying the filter. If there's a tree, it counts all nodes, including folded children  */\n    totalCount?: number;\n};\n\nexport interface DataSourceListProps extends DataSourceListCounts {\n    /**\n     * ICheckable object for Select All behavior.\n     * If omitted, Select All action will be absent.\n     * */\n    selectAll?: ICheckable;\n\n    /** Signals that data is reloading on search/sort/filter/reload. */\n    isReloading?: boolean;\n}\n\n// Lazy Data Source API\n\n/** The range (from/count) of required rows for LazyDataSourceApiRequest */\nexport interface LazyDataSourceApiRequestRange {\n    /** Element index to fetch from. */\n    from: number;\n    /** Count of elements to be retrieved. */\n    count?: number;\n}\n\n/** Defines input arguments for Lazy Data Source APIs */\n// eslint-disable-next-line @typescript-eslint/no-unused-vars\nexport interface LazyDataSourceApiRequest<TItem, TId = any, TFilter = {}> {\n    /**\n     * The filter object, by which data should be filtered.\n     * It is a merged result of filters from DataSourceState and LazyDataSourceProps.\n     */\n    filter?: TFilter;\n\n    /** Sorting options, by which data should be sorted. */\n    sorting?: SortingOption[];\n\n    /** The search string, by which data should be searched. */\n    search?: string;\n\n    /** Specifies a range of the rows to be retrieved. */\n    range?: LazyDataSourceApiRequestRange;\n\n    /** Page number for which data should be retrieved. */\n    page?: number;\n\n    /** Number of items at the page. */\n    pageSize?: number;\n\n    /**\n     * An array of item IDs to be retrieved from the API.\n     * Other request options like filter, search and others should be ignored when IDs are provided.\n     * Used for requesting specific items separately from the list.\n     */\n    ids?: TId[];\n\n    /**\n     * Cursor for cursor-based pagination.\n     *\n     * This property is used when implementing cursor-based pagination\n     * instead of traditional range-based pagination.\n     *\n     * The cursor is typically an opaque string or token that the server\n     * understands to determine the next set of items to return.\n     *\n     * If the previous API response includes a cursor, it will be passed in\n     * this property, to fetch more records.\n     *\n     * Note, that if you use cursors, you can ignore the range.from field. It would still have a\n     * valid value through - how many items are already fetched.\n     *\n     * You still need to account range.count, and return at least as much items as requested.\n     * Returning more items than range.count is supported.\n     */\n    cursor?: any;\n}\n\n/** Defines Lazy Data Source APIs response shape */\nexport interface LazyDataSourceApiResponse<TItem> {\n    /** List of items which was requested via API */\n    items: TItem[];\n\n    /**\n     * API can set 'from' field if it wants to return more items than what was requested in request.range.\n     * This can be used to return all items at once (with from:0, count: totalCount), or align response to pages.\n     */\n    from?: number;\n\n    /**\n     * Total count of items which match current filter and pagination.\n     * If not specified, total count will be detected only when user scrolls to the end of the list.\n     */\n    count?: number;\n\n    /**\n     * Total count of items which match current filter.\n     */\n    totalCount?: number;\n\n    /**\n     * Cursor for cursor-based pagination.\n     *\n     * The cursor is typically an opaque string or token that the server\n     * understands to determine the next set of items to return.\n     *\n     * You can pass cursor of the last item in the list, usually provided by the server.\n     * In this case, this cursor will be provided to the next request, allowing to fetch the next part of the list.\n     *\n     * The absence of cursor doesn't imply the end of the list. The end of the list\n     * is determined by comparing the number of items returned with the number requested:\n     * if fewer items than requested are returned, it implies that the end of the list has been reached.\n     */\n    cursor?: any;\n}\n\n/** Defines the context of API request. E.g. parent if we require to retrieve sub-list of the tree */\nexport interface LazyDataSourceApiRequestContext<TItem, TId> extends FetchingOptions {\n    /**\n     * The ID of the parent item whose children are being requested.\n     * Used for lazy-loading data in tree lists.\n     */\n    parentId?: TId | null;\n    /** The parent entity whose children are being requested */\n    parent?: TItem | null;\n}\n\n/** Defines API to retrieve data for DataSources */\nexport type LazyDataSourceApi<TItem, TId, TFilter> = (\n    /** Defines input arguments for Lazy Data Source APIs */\n    request: LazyDataSourceApiRequest<TItem, TId, TFilter>,\n    /** Defines the context of API request. */\n    context: LazyDataSourceApiRequestContext<TItem, TId>,\n) => Promise<LazyDataSourceApiResponse<TItem>>;\n","/* eslint-disable no-restricted-imports */\nimport dayjs from 'dayjs';\nimport isSameOrBefore from 'dayjs/plugin/isSameOrBefore';\nimport isSameOrAfter from 'dayjs/plugin/isSameOrAfter';\n\nexport type { Dayjs } from 'dayjs';\n\nexport const uuiDayjs = TREE_SHAKEABLE_INIT();\n\nfunction TREE_SHAKEABLE_INIT() {\n    let extended = false;\n    return {\n        get dayjs() {\n            if (!extended) {\n                dayjs.extend(isSameOrBefore);\n                dayjs.extend(isSameOrAfter);\n                extended = true;\n            }\n            return dayjs;\n        },\n    };\n}\n","import { DataQueryFilter, DataQueryFilterCondition } from '../../types/dataQuery';\nimport { uuiDayjs } from '../../helpers/dayJsHelper';\n\nexport function simplifyPredicates<T>(filter: DataQueryFilter<T>) {\n    if (!filter) {\n        return {};\n    }\n    const result: DataQueryFilter<T> = filter;\n    const keys = Object.keys(filter) as (keyof T)[];\n    for (let n = 0; n < keys.length; n++) {\n        const key = keys[n];\n        const condition = filter[key] as DataQueryFilterCondition<any>;\n        if (condition != null && typeof condition === 'object') {\n            if ('inRange' in condition) {\n                const value = condition.inRange;\n                result[key] = {\n                    gte: value.from,\n                    lte: value.to,\n                };\n            }\n            if ('notInRange' in condition) {\n                const value = condition.notInRange;\n                result[key] = {\n                    not: {\n                        gte: value.from,\n                        lte: value.to,\n                    },\n                };\n            }\n\n            if (Array.isArray(condition)) {\n                result[key] = {\n                    in: condition,\n                };\n            }\n        }\n    }\n    return result;\n}\n\nfunction isDate(val: string): boolean {\n    return uuiDayjs.dayjs(val).isValid();\n}\n\nconst truePredicate = () => true;\n\nexport function getFilterPredicate<T>(filter: DataQueryFilter<T>): (e: T) => boolean {\n    filter = simplifyPredicates(filter);\n\n    if (filter == null) {\n        return truePredicate;\n    }\n\n    const predicates: ((item: T) => boolean)[] = [];\n    const keys = Object.keys(filter) as (keyof T)[];\n\n    for (let n = 0; n < keys.length; n++) {\n        const key = keys[n];\n        const condition = filter[key] as DataQueryFilterCondition<any>;\n\n        if (condition != null && typeof condition === 'object') {\n            if ('isNull' in condition) {\n                if (condition.isNull) {\n                    predicates.push((item: T) => item[key] == null);\n                } else {\n                    predicates.push((item: T) => item[key] != null);\n                }\n            }\n\n            if ('in' in condition && Array.isArray(condition.in)) {\n                const values = condition.in as any[];\n                predicates.push((item: T) => values.includes(item[key]));\n            }\n\n            if ('nin' in condition && Array.isArray(condition.nin)) {\n                const values = condition.nin as any[];\n                predicates.push((item: T) => !values.includes(item[key]));\n            }\n\n            if (condition.gte != null) {\n                const conditionValue = condition.gte;\n                predicates.push((item: T) => {\n                    const value = item[key];\n                    if (typeof value === 'string' && isDate(conditionValue)) {\n                        return uuiDayjs.dayjs(value).isSameOrAfter(conditionValue);\n                    }\n                    return !(value !== null && value !== undefined) || value >= conditionValue;\n                });\n            }\n\n            if (condition.lte != null) {\n                const conditionValue = condition.lte;\n                predicates.push((item: T) => {\n                    const value = item[key];\n                    if (typeof value === 'string' && isDate(conditionValue)) {\n                        return uuiDayjs.dayjs(value).isSameOrBefore(conditionValue);\n                    }\n                    return !(value !== null && value !== undefined) || value <= conditionValue;\n                });\n            }\n\n            if (condition.gt != null) {\n                const conditionValue = condition.gt;\n                predicates.push((item: T) => {\n                    const value = item[key];\n                    if (typeof value === 'string' && isDate(conditionValue)) {\n                        return uuiDayjs.dayjs(value).isAfter(conditionValue);\n                    }\n                    return !(value !== null && value !== undefined) || value > conditionValue;\n                });\n            }\n\n            if (condition.lt != null) {\n                const conditionValue = condition.lt;\n                predicates.push((item: T) => {\n                    const value = item[key];\n                    if (typeof value === 'string' && isDate(conditionValue)) {\n                        return uuiDayjs.dayjs(value).isBefore(conditionValue);\n                    }\n                    return !(value !== null && value !== undefined) || value < conditionValue;\n                });\n            }\n\n            if (condition.eq !== undefined && condition.eq !== null) {\n                const conditionValue = condition.eq;\n                predicates.push((item: T) => item[key] === conditionValue);\n            }\n\n            if (condition.neq !== undefined && condition.neq !== null) {\n                const conditionValue = condition.neq;\n                predicates.push((item: T) => item[key] !== conditionValue);\n            }\n\n            if ('not' in condition) {\n                const predicate = getFilterPredicate({ [key]: condition.not });\n                predicates.push((i) => !predicate(i));\n            }\n        } else {\n            predicates.push((item: T) => {\n                if (typeof condition === 'string' && isDate(condition)) {\n                    return uuiDayjs.dayjs(item[key] as any).isSame(condition);\n                } else {\n                    return item[key] === condition;\n                }\n            });\n        }\n    }\n\n    if (predicates.length === 1) {\n        return predicates[0];\n    } else if (predicates.length === 0) {\n        return truePredicate;\n    } else {\n        return (item: T) => {\n            for (let n = 0; n < predicates.length; n++) {\n                if (!predicates[n](item)) {\n                    return false;\n                }\n            }\n            return true;\n        };\n    }\n}\n","const getRank = (match: RegExpMatchArray) => {\n    const [word] = match;\n    const { index, input } = match;\n\n    if (index === 0) {\n        return word.length === input.length || input[index + word.length] === ' ' ? 4 : 3;\n    }\n\n    return input[index - 1] === ' ' ? 2 : 1;\n};\n\nexport function getSearchFilter(searchString: string): (texts: string[]) => number | boolean {\n    if (!searchString) {\n        return () => true;\n    }\n    const searchStr = searchString.replace(/[\\s\\n\\r\\t\\0]+/g, ' ').trim(); // trim and normalize whitespaces\n\n    // split by comma-separated groups, then by spaces, and make regex of each word\n    const words = searchStr\n        .split(' ')\n        .map((word) => word.trim())\n        .filter((s) => s.length > 0)\n        .map((word) => word.trim().replace(/[-[\\]{}()*+?.,\\\\^$|#\\s]/g, '\\\\$&')) // esape regex characters inside the string\n        .map((word) => new RegExp(word, 'i'));\n\n    return (texts) => {\n        if (!words.length) {\n            return true;\n        }\n\n        const ranks = words.map((wordRegex) => {\n            // matching regex word with fields values\n            const wordRanks = texts.map((text) => {\n                const match = text.match(wordRegex);\n                if (match === null) {\n                    return null;\n                }\n                return getRank(match);\n            });\n\n            // if keyword was not found in every field value\n            if (wordRanks.every((rank) => rank === null)) {\n                return false;\n            }\n            return Math.max(...wordRanks);\n        });\n\n        // some keyword of a group was not found in fields values\n        if (ranks.some((rank) => !rank)) {\n            return false;\n        }\n\n        return (ranks as number[]).reduce((totalRank, rank) => totalRank + rank, 0);\n    };\n}\n","import { DataQuery } from '../../types/dataQuery';\nimport { getOrderComparer } from './getOrderComparer';\nimport { getFilterPredicate } from './getFilterPredicate';\nimport { getSearchFilter } from './getSearchFilter';\nimport { orderBy } from '../../helpers';\nimport { LazyDataSourceApiResponse } from '../../types/dataSources';\n\nexport function runDataQuery<TItem extends { id: any }>(\n    allItems: TItem[],\n    request: DataQuery<TItem> & { ids?: any[] },\n    searchBy?: (item: TItem) => string[],\n):LazyDataSourceApiResponse<TItem> {\n    let items = allItems || [];\n    request = request || {};\n\n    if (request.ids) {\n        return {\n            items: items.filter((i) => request.ids.includes(i.id)),\n        };\n    }\n\n    if (request.search) {\n        searchBy = searchBy || ((i: any) => [i.name]);\n        const searchFilter = getSearchFilter(request.search);\n        items = items.filter((item) => searchFilter(searchBy(item)));\n    }\n\n    if (request.filter) {\n        const predicate = getFilterPredicate(request.filter);\n        items = items.filter(predicate);\n    }\n\n    if (request.sorting) {\n        const comparer = getOrderComparer(request.sorting);\n        items.sort(comparer);\n    } else {\n        items = orderBy(items, ({ name }: any) => name);\n    }\n\n    const filteredAndSorted = items;\n    if (request.range) {\n        const from = request.range.from || 0;\n        const count = request.range.count == null ? items.length : request.range.count;\n        items = items.slice(from, from + count);\n    }\n\n    return {\n        items,\n        count: filteredAndSorted.length,\n    };\n}\n","export const ROOT_ID: undefined = undefined;\n\n// ITreeNodeStatus\nexport const PARTIALLY_LOADED = 'PARTIALLY_LOADED';\nexport const FULLY_LOADED = 'FULLY_LOADED';\nexport const EMPTY = 'EMPTY';\n\n// RecordStatus && not found item in tree\nexport const NOT_FOUND_RECORD = Symbol('NOT_FOUND_RECORD');\n\n// RecordStatus\nexport const PENDING_RECORD = Symbol('PENDING_RECORD');\nexport const LOADING_RECORD = Symbol('LOADING_RECORD');\nexport const LOADED_RECORD = Symbol('LOADED_RECORD');\nexport const FAILED_RECORD = Symbol('FAILED_RECORD');\n\nexport const PatchOrdering = {\n    TOP: Symbol('ORDERING_TOP'),\n    BOTTOM: Symbol('ORDERING_BOTTOM'),\n};\n","export const idToKey = <TId, >(id: TId) => typeof id === 'object' ? JSON.stringify(id) : `${id}`;\n","export const setObjectFlag = (object: any, key: string, value: boolean) => {\n    return { ...object, [key]: value };\n};\n","import { LOADING_RECORD, PENDING_RECORD } from '../tree/constants';\nimport { RecordStatus } from '../tree/types';\n\nexport const isInProgress = (status: RecordStatus): status is typeof PENDING_RECORD | typeof LOADING_RECORD =>\n    [PENDING_RECORD, LOADING_RECORD].includes(status);\n","import { useEffect, useRef } from 'react';\nimport isEqual from 'react-fast-compare';\n\n/**\n * Hook configuration, which defines if previous value will be deeply compared with new value to be saved or not.\n */\nexport interface UsePreviousConfig {\n    /**\n     * If compare is set to true, previous value will be deeply compared with the new value,\n     * and previous value will be updated only if value is changed (not the link to the object).\n     * Otherwise, previous value will be returned.\n     * If compare is false, previous value will be changed on every rerender.\n     */\n    compare?: boolean;\n}\n\n/**\n * Hook, which returns previous version of the value, passed to the arguments.\n * @param value\n * @param config - Hook configuration, which defines if previous value will be deeply compared with new value to be saved or not.\n * @param config.compare - If compare is set to true, previous value will be deeply compared with the new value,\n * and previous value will be updated only if value is changed (not the link to the object). Otherwise, previous value will be returned.\n * If compare is false, previous value will be changed on every rerender.\n * @returns previous version of the value, passed to the props.\n */\nexport function usePrevious<T>(value: T, { compare }: UsePreviousConfig = {}): T | null {\n    const previousValueRef = useRef<T>(null);\n\n    useEffect(() => {\n        if (compare) {\n            if (!isEqual(previousValueRef.current, value)) {\n                previousValueRef.current = value;\n            }\n        } else {\n            previousValueRef.current = value;\n        }\n    }, [value]);\n\n    return previousValueRef.current;\n}\n","import { IImmutableMap, IMap } from '../../../../../types';\nimport { ITreeParams } from '../treeStructure/types';\n\nexport function cloneMap<T extends IMap<any, any> | IImmutableMap<any, any>>(map: T): T extends IMap<infer TKey, infer TValue>\n    ? IMap<TKey, TValue>\n    : T extends IImmutableMap<infer TKey, infer TValue>\n        ? IImmutableMap<TKey, TValue> : never {\n    return new (map.constructor as any)(map);\n}\n\nexport function newMap<TKey, TValue>(params: Pick<ITreeParams<any, any>, 'complexIds'>) {\n    if (params.complexIds) {\n        return new CompositeKeysMap<TKey, TValue>();\n    } else {\n        return new Map<TKey, TValue>();\n    }\n}\n\nexport class CompositeKeysMap<TKey, TValue> implements IMap<TKey, TValue> {\n    map: Map<string, TValue>;\n    constructor(original?: CompositeKeysMap<TKey, TValue>) {\n        if (original) {\n            this.map = new Map(original.map);\n        } else {\n            this.map = new Map();\n        }\n    }\n\n    private keyToString(key: TKey) {\n        return key === undefined ? undefined : JSON.stringify(key);\n    }\n\n    public get(key: TKey): TValue | undefined {\n        return this.map.get(this.keyToString(key));\n    }\n\n    public set(key: TKey, value: TValue) {\n        this.map.set(this.keyToString(key), value);\n        return this;\n    }\n\n    public delete(key: TKey) {\n        return this.map.delete(this.keyToString(key));\n    }\n\n    * [Symbol.iterator](): IterableIterator<[TKey, TValue]> {\n        for (const [key, value] of this.map) {\n            yield [key !== undefined ? JSON.parse(key) : undefined, value];\n        }\n    }\n\n    public has(key: TKey) {\n        return this.map.has(this.keyToString(key));\n    }\n\n    get size() {\n        return this.map.size;\n    }\n}\n","import { ItemsMap } from './ItemsMap';\nimport { NOT_FOUND_RECORD } from './constants';\nimport { IItemsAccessor } from './treeStructure/types';\n\nexport class ItemsAccessor<TItem, TId> implements IItemsAccessor<TItem, TId> {\n    constructor(\n        private itemsMap: ItemsMap<TId, TItem>,\n    ) {}\n\n    get = (id: TId) =>\n        this.itemsMap.has(id) ? this.itemsMap.get(id) : NOT_FOUND_RECORD;\n\n    forEach(action: (item: TItem, id: TId) => void): void {\n        this.itemsMap.forEach(action);\n    }\n\n    public static toItemsAccessor<TId, TItem>(itemsMap: ItemsMap<TId, TItem>) {\n        return new ItemsAccessor(itemsMap);\n    }\n}\n","import type { DataSourceState, IImmutableMap, IMap } from '../../../../../../types';\n\nexport const getSelectedAndChecked = <TItem, TId>(\n    dataSourceState: DataSourceState<any, TId>,\n    patch: IMap<TId, TItem> | IImmutableMap<TId, TItem>,\n) => {\n    let checked: TId[] = [];\n    if (dataSourceState.checked?.length) {\n        checked = [...dataSourceState.checked];\n    }\n    if (dataSourceState.selectedId !== null && dataSourceState.selectedId !== undefined) {\n        checked = [...checked, dataSourceState.selectedId];\n    }\n\n    if (!patch || !patch.size) {\n        return checked;\n    }\n\n    return checked.filter((id) => !patch.has(id));\n};\n","import isEqual from 'react-fast-compare';\nimport { LazyDataSourceApiRequestContext, LazyDataSourceApiRequestRange } from '../../../../../../types';\nimport { TreeStructure } from '../TreeStructure';\nimport { cloneMap, newMap } from '../../helpers/map';\nimport { ItemsAccessor } from '../../ItemsAccessor';\nimport type { LoadOptions, LoadAllOptions, LoadItemsOptions, LoadMissingItemsAndParentsOptions, LoadOptionsMissing } from './types';\nimport { ITreeNodeInfo } from '../types';\nimport { NOT_FOUND_RECORD } from '../../constants';\nimport { getSelectedAndChecked } from './checked';\nimport { LoadAllConfig } from '../../treeState/types';\n\nexport class FetchingHelper {\n    public static async loadAll<TItem, TId, TFilter>({\n        treeStructure,\n        itemsMap,\n        options,\n        dataSourceState,\n    }: LoadAllOptions<TItem, TId, TFilter>) {\n        const response = await options.api(\n            {\n                sorting: dataSourceState.sorting,\n                search: dataSourceState.search,\n                filter: options.filter,\n                page: dataSourceState.page,\n                pageSize: dataSourceState.pageSize,\n            },\n            {\n                signal: options.signal,\n            },\n        );\n\n        const newItemsMap = itemsMap.clear().setItems(response.items);\n\n        return {\n            itemsMap: newItemsMap,\n            treeStructure: TreeStructure.createFromItems({\n                params: treeStructure.getParams(),\n                items: response.items,\n                itemsAccessor: ItemsAccessor.toItemsAccessor(newItemsMap),\n            }),\n            loadedItems: response.items,\n        };\n    }\n\n    public static async load<TItem, TId, TFilter = any>({\n        tree,\n        options,\n        dataSourceState,\n        patch,\n    }: LoadOptions<TItem, TId, TFilter>) {\n        const { loadedItems: loadedMissingItems, loadedItemsMap, byParentId, nodeInfoById } = await this.loadMissing<TItem, TId, TFilter>({\n            tree,\n            options,\n            dataSourceState,\n        });\n\n        const missing = getSelectedAndChecked(dataSourceState, patch);\n\n        const { loadedItems: loadedMissingItemsAndParents } = await this.loadMissingItemsAndParents<TItem, TId, TFilter>({\n            tree,\n            newItemsMap: loadedItemsMap,\n            options,\n            itemsToLoad: missing,\n        });\n\n        return {\n            loadedItems: loadedMissingItems.concat(loadedMissingItemsAndParents),\n            byParentId,\n            nodeInfoById,\n        };\n    }\n\n    private static async loadMissing<TItem, TId, TFilter = any>({\n        tree,\n        options,\n        dataSourceState,\n    }: LoadOptionsMissing<TItem, TId, TFilter>) {\n        const requiredRowsCount = dataSourceState.topIndex + dataSourceState.visibleCount;\n\n        const byParentId = newMap<TId, TId[]>(tree.getParams());\n        const nodeInfoById = newMap<TId, ITreeNodeInfo>(tree.getParams());\n\n        const newItemsMap = newMap<TId, TItem>(tree.getParams());\n        const flatten = dataSourceState.search && options.flattenSearchResults;\n        const loadAllChildren: (id: TId) => LoadAllConfig = options.loadAllChildren ?? (() => ({ nestedChildren: true, children: false }));\n\n        let newItems: TItem[] = [];\n        const loadRecursive = async (\n            parentId: TId,\n            parent: TItem,\n            { children: parentLoadAllChildren, nestedChildren: parentLoadAllNestedChildren }: LoadAllConfig,\n            remainingRowsCount: number,\n        ) => {\n            let recursiveLoadedCount = 0;\n\n            const { ids, nodeInfo, loadedItems } = await this.loadItems<TItem, TId, TFilter>({\n                tree,\n                byParentId,\n                options,\n                parentId,\n                parent,\n                dataSourceState,\n                remainingRowsCount,\n                loadAll: parentLoadAllChildren,\n            });\n\n            const { ids: originalIds, ...originalNodeInfo } = tree.getItems(parentId);\n            const currentIds = byParentId.has(parentId) ? byParentId.get(parentId) : originalIds;\n\n            if (ids !== currentIds\n                    || nodeInfo.count !== originalNodeInfo.count\n                    || nodeInfo.totalCount !== originalNodeInfo.totalCount\n                    || nodeInfo.assumedCount !== originalNodeInfo.assumedCount\n                    || nodeInfo.cursor !== originalNodeInfo.cursor) {\n                nodeInfoById.set(parentId, nodeInfo);\n            }\n\n            byParentId.set(parentId, ids);\n\n            recursiveLoadedCount += ids.length;\n            if (loadedItems.length > 0) {\n                loadedItems.forEach((item) => {\n                    const id = tree.getParams().getId(item);\n                    const prevNodeInfo = nodeInfoById.get(id) ?? {};\n                    const assumedCount = flatten ? undefined : prevNodeInfo.assumedCount ?? tree.getParams().getChildCount?.(item);\n                    nodeInfoById.set(id, { ...prevNodeInfo, ...(tree.getParams().getChildCount ? { assumedCount } : {}) });\n                    newItemsMap.set(id, item);\n                });\n                newItems = newItems.concat(loadedItems);\n            }\n\n            if (!flatten && tree.getParams().getChildCount) {\n                const childrenPromises: Promise<any>[] = [];\n\n                for (let n = 0; n < ids.length; n++) {\n                    const id = ids[n];\n                    const itemInTree = tree.getById(id);\n                    let item: TItem = itemInTree === NOT_FOUND_RECORD ? undefined : itemInTree;\n                    if (newItemsMap.has(id)) {\n                        item = newItemsMap.get(id);\n                    }\n\n                    let isFolded = false;\n                    let hasChildren = false;\n\n                    if (tree.getParams().getChildCount) {\n                        // not a root node\n                        const childrenCount = tree.getParams().getChildCount(item);\n                        if (childrenCount) {\n                            // foldable\n                            isFolded = options.isFolded(item);\n                            hasChildren = true;\n                        }\n                    }\n\n                    const { nestedChildren, children } = loadAllChildren(id);\n\n                    const shouldLoadAllChildren = hasChildren && children;\n                    const loadAll = parentLoadAllNestedChildren ? parentLoadAllChildren || shouldLoadAllChildren : shouldLoadAllChildren;\n\n                    remainingRowsCount--;\n\n                    if (hasChildren && ((!isFolded && remainingRowsCount > 0) || loadAll)) {\n                        const childPromise = loadRecursive(id, item, { children: loadAll, nestedChildren }, remainingRowsCount);\n\n                        childrenPromises.push(childPromise);\n\n                        if (options.fetchStrategy === 'sequential') {\n                            const loadedCount = await childPromise;\n                            remainingRowsCount -= loadedCount;\n                            recursiveLoadedCount += loadedCount;\n                        }\n                    }\n                }\n\n                const childCounts = await Promise.all(childrenPromises);\n                if (options.fetchStrategy === 'parallel') {\n                    const recursiveChildrenCount = childCounts.reduce((a, b) => a + b, 0);\n                    recursiveLoadedCount += recursiveChildrenCount;\n                    remainingRowsCount -= recursiveChildrenCount;\n                }\n            }\n\n            return recursiveLoadedCount;\n        };\n\n        await loadRecursive(undefined, undefined, loadAllChildren(undefined), requiredRowsCount);\n\n        return {\n            tree,\n            loadedItemsMap: newItemsMap,\n            loadedItems: newItems,\n            byParentId,\n            nodeInfoById,\n        };\n    }\n\n    private static async loadMissingItemsAndParents<TItem, TId, TFilter>({\n        tree,\n        newItemsMap,\n        options,\n        itemsToLoad,\n    }: LoadMissingItemsAndParentsOptions<TItem, TId, TFilter>) {\n        const updatedItemsMap = cloneMap(newItemsMap);\n        let iteration = 0;\n        let prevMissingIds = new Set<TId>();\n        let loadedItems: TItem[] = [];\n        const isItemNotLoaded = (id: TId) => tree.getById(id) === NOT_FOUND_RECORD && !updatedItemsMap.has(id);\n\n        while (true) {\n            const missingIds = new Set<TId>();\n            if (itemsToLoad && itemsToLoad.length > 0) {\n                itemsToLoad.forEach((id) => {\n                    if (isItemNotLoaded(id)) {\n                        missingIds.add(id);\n                    }\n                });\n            }\n            if (tree.getParams().getParentId) {\n                for (const [, item] of updatedItemsMap) {\n                    const parentId = tree.getParams().getParentId(item);\n                    if (parentId != null && isItemNotLoaded(parentId)) {\n                        missingIds.add(parentId);\n                    }\n                }\n            }\n\n            if (missingIds.size === 0) {\n                break;\n            } else {\n                const ids = Array.from(missingIds);\n                const response = await options.api({ ids }, { signal: options.signal });\n                if (response.items.length !== ids.length) {\n                    console.error(`LazyTree: api does not returned requested items. Check that you handle 'ids' argument correctly.\n                        Read more here: https://github.com/epam/UUI/issues/89`);\n                }\n\n                const newItems = response.items.filter((item) => {\n                    const id = item ? tree.getParams().getId(item) : null;\n                    return id !== null;\n                });\n\n                newItems.forEach((item) => {\n                    const id = tree.getParams().getId(item);\n                    updatedItemsMap.set(id, item);\n                });\n\n                loadedItems = loadedItems.concat(newItems);\n                if (prevMissingIds.size === missingIds.size && isEqual(prevMissingIds, missingIds)) {\n                    break;\n                }\n\n                prevMissingIds = new Set([...missingIds]);\n            }\n            iteration++;\n\n            if (iteration > 1000) {\n                throw new Error('LazyTree: More than 1000 iterations are made to load required items and their parents by ID. Check your api implementation');\n            }\n        }\n        return { itemsMap: updatedItemsMap, loadedItems };\n    }\n\n    private static async loadItems<TItem, TId, TFilter>({\n        tree,\n        options,\n        byParentId,\n        parentId,\n        parent,\n        dataSourceState,\n        remainingRowsCount,\n        loadAll,\n    }: LoadItemsOptions<TItem, TId, TFilter>) {\n        const {\n            ids: originalIds,\n            count: childrenCount,\n            totalCount,\n            assumedCount: prevAssumedCount,\n            cursor: prevCursor,\n        } = tree.getItems(parentId);\n        const inputIds = byParentId.has(parentId) ? byParentId.get(parentId) ?? originalIds : originalIds;\n\n        let ids = inputIds ?? [];\n        const loadedItems: TItem[] = [];\n\n        const flatten = dataSourceState.search && options.flattenSearchResults;\n\n        // Selection cascading forces to load all nodes under particular node\n        if (loadAll) {\n            remainingRowsCount = Number.MAX_SAFE_INTEGER;\n        }\n\n        const missingCount = Math.max(0, remainingRowsCount - ids.length);\n\n        const availableCount = childrenCount != null ? childrenCount - ids.length : missingCount;\n\n        const range: LazyDataSourceApiRequestRange = { from: ids.length };\n\n        let skipRequest = false;\n        if (!loadAll) {\n            range.count = missingCount;\n            skipRequest = options.isLoadStrict ? true : skipRequest;\n        }\n\n        if (missingCount === 0 || availableCount === 0 || skipRequest) {\n            return {\n                ids,\n                nodeInfo: { count: childrenCount, totalCount, assumedCount: prevAssumedCount, cursor: prevCursor },\n                loadedItems,\n            };\n        }\n\n        // Need to load additional items in the current layer\n        const requestContext: LazyDataSourceApiRequestContext<TItem, TId> = { signal: options.signal };\n\n        if (!flatten) {\n            if (parent != null) {\n                requestContext.parentId = parentId;\n                requestContext.parent = parent;\n            } else {\n                // in flatten mode, we don't set parent and parentId even for root - as we don't want to limit results to top-level nodes only\n                requestContext.parentId = null;\n                requestContext.parent = null;\n            }\n        }\n\n        const response = await options.api(\n            {\n                sorting: dataSourceState.sorting,\n                search: dataSourceState.search,\n                filter: options.filter,\n                range,\n                page: dataSourceState.page,\n                pageSize: dataSourceState.pageSize,\n                cursor: prevCursor,\n            },\n            requestContext,\n        );\n\n        const from = response.from == null ? range.from : response.from;\n\n        if (response.items?.length) {\n            ids = [...ids];\n            for (let n = 0; n < response.items.length; n++) {\n                const item = response.items[n];\n                loadedItems.push(item);\n                const id = tree.getParams().getId(item);\n                ids[n + from] = id;\n            }\n        }\n\n        let newNodesCount;\n\n        const loadedItemsCount = (response.items?.length ?? 0);\n        if (response.count !== null && response.count !== undefined) {\n            newNodesCount = response.count;\n        } else if (loadedItemsCount < missingCount) {\n            newNodesCount = from + loadedItemsCount;\n        }\n\n        let assumedCount = undefined;\n        if (!flatten && parent && tree.getParams().getChildCount) {\n            assumedCount = tree.getParams().getChildCount(parent);\n        }\n\n        let nodeInfo = { count: childrenCount, totalCount, assumedCount: prevAssumedCount, cursor: response.cursor };\n        if (newNodesCount !== childrenCount || assumedCount !== prevAssumedCount) {\n            nodeInfo = { ...nodeInfo, count: newNodesCount, assumedCount };\n        }\n\n        nodeInfo = { ...nodeInfo, totalCount: response.totalCount ?? totalCount };\n        return {\n            ids,\n            nodeInfo,\n            loadedItems,\n        };\n    }\n}\n","import { IImmutableMap, IMap } from '../../../../types/objects';\nimport { cloneMap, newMap } from './helpers/map';\n\nexport interface ItemsMapParams<TItem, TId> {\n    getId: (item: TItem) => TId;\n    complexIds?: boolean;\n}\n\nexport class ItemsMap<TId, TItem> implements IImmutableMap<TId, TItem> {\n    private _itemsMap: IMap<TId, TItem>;\n    private params: ItemsMapParams<TItem, TId>;\n\n    constructor(\n        itemsMap: IMap<TId, TItem>,\n        params: ItemsMapParams<TItem, TId>,\n    );\n\n    constructor(itemsMap: ItemsMap<TId, TItem>);\n\n    constructor(...args: [IMap<TId, TItem>, ItemsMapParams<TItem, TId>] | [ItemsMap<TId, TItem>]) {\n        if (args.length === 1) {\n            const [itemsMap] = args;\n            this.params = itemsMap.params;\n            this._itemsMap = cloneMap(itemsMap._itemsMap);\n        } else {\n            const [map, params] = args;\n            this.params = params;\n            this._itemsMap = map ? cloneMap(map) : newMap(params);\n        }\n    }\n\n    get(id: TId) {\n        return this._itemsMap.has(id) ? this._itemsMap.get(id) : undefined;\n    }\n\n    has(id: TId) {\n        return this._itemsMap.has(id);\n    }\n\n    set(...args: [TId, TItem] | [TId]): ItemsMap<TId, TItem> {\n        const [id, item] = args;\n        let itemsMap = cloneMap(this._itemsMap);\n\n        if (args.length > 1) {\n            itemsMap.set(id, item);\n        } else {\n            itemsMap = itemsMap.set(id);\n        }\n\n        return new ItemsMap(itemsMap, this.params);\n    }\n\n    delete(id: TId) {\n        const itemsMap = cloneMap(this._itemsMap);\n        itemsMap.delete(id);\n        return new ItemsMap(itemsMap, this.params);\n    }\n\n    forEach(action: (item: TItem, id: TId) => void) {\n        for (const [id] of this._itemsMap) {\n            action(this.get(id), id);\n        }\n    }\n\n    clear() {\n        return new ItemsMap(newMap<TId, TItem>(this.params), this.params);\n    }\n\n    setItems(items: TItem[]) {\n        let updated = false;\n        const itemsLink = cloneMap(this._itemsMap);\n\n        items.forEach((item) => {\n            const isExistingItem = itemsLink.has(this.params.getId(item));\n\n            if (!isExistingItem || (isExistingItem && item !== itemsLink.get(this.params.getId(item)))) {\n                itemsLink.set(this.params.getId(item), item);\n                updated = true;\n            }\n        });\n\n        if (updated) {\n            return new ItemsMap(itemsLink, this.params);\n        }\n\n        return this;\n    }\n\n    get size() {\n        return this._itemsMap.size;\n    }\n\n    [Symbol.iterator]() {\n        return this._itemsMap[Symbol.iterator]();\n    }\n\n    public static fromObject<TId extends symbol | string | number, TItem>(\n        obj: Record<TId, TItem>,\n        params: ItemsMapParams<TItem, TId>,\n    ) {\n        const itemsMap = newMap<TId, TItem>(params);\n        for (const [, value] of Object.entries<TItem>(obj)) {\n            itemsMap.set(params.getId(value), value);\n        }\n\n        return new ItemsMap<TId, TItem>(itemsMap, params);\n    }\n\n    public static blank<TId, TItem>(\n        params: ItemsMapParams<TItem, TId>,\n    ) {\n        return new ItemsMap<TId, TItem>(newMap<TId, TItem>(params), params);\n    }\n}\n","import { ApplySortOptions } from '../treeState/types';\n\nexport const simpleComparator = <T extends string | number>(a: T, b: T) => {\n    if (a < b) {\n        return -1;\n    }\n\n    return a === b ? 0 : 1;\n};\n\nexport const buildComparators = <TItem, TId, TFilter>(options: ApplySortOptions<TItem, TId, TFilter>) => {\n    const compareScalars = new Intl.Collator(undefined, { numeric: true, sensitivity: 'base' }).compare;\n    const comparators: ((a: TItem, b: TItem) => number)[] = [];\n\n    if (options.sorting) {\n        options.sorting.forEach((sortingOption) => {\n            const sortByFn = options.sortBy || ((i: TItem) => i[sortingOption.field as keyof TItem] ?? '');\n            const sign = sortingOption.direction === 'desc' ? -1 : 1;\n            comparators.push((a, b) => sign * compareScalars(sortByFn(a, sortingOption) + '', sortByFn(b, sortingOption) + ''));\n        });\n    }\n\n    return comparators;\n};\n\nexport const composeComparators = <TItem, TId>(comparators: ((a: TItem, b: TItem) => number)[], getId: (item: TItem) => TId) => {\n    return (a: TItem, b: TItem) => {\n        for (let n = 0; n < comparators.length; n++) {\n            const compare = comparators[n];\n            const result = compare(a, b);\n            if (result !== 0) {\n                return result;\n            }\n        }\n\n        const aId = getId(a);\n        const bId = getId(b);\n\n        const aCompareId = typeof aId === 'object' && aId !== null ? JSON.stringify(aId) : aId as string | number;\n        const bCompareId = typeof bId === 'object' && bId !== null ? JSON.stringify(bId) : bId as string | number;\n\n        return simpleComparator(aCompareId, bCompareId);\n    };\n};\n\nexport const buildSorter = <TItem, TId, TFilter>(options: ApplySortOptions<TItem, TId, TFilter>) => {\n    const comparators = buildComparators(options);\n    const composedComparator = composeComparators(comparators, options.getId);\n    return (items: TItem[]) => {\n        if (comparators.length === 0) {\n            return items;\n        }\n\n        items = [...items];\n        items.sort(composedComparator);\n        return items;\n    };\n};\n","import isEqual from 'react-fast-compare';\nimport { CascadeSelection, CascadeSelectionTypes, DataRowPathItem, DataSourceState, IMap, LazyDataSourceApi } from '../../../../types';\nimport { ITree } from './ITree';\nimport { FetchingOptions } from '../../../../services';\nimport { FULLY_LOADED, NOT_FOUND_RECORD, ROOT_ID } from './constants';\nimport { FetchingHelper } from './treeStructure/helpers/FetchingHelper';\nimport type { ITreeNodeInfo, ITreeParams } from './treeStructure/types';\nimport { TreeStructure } from './treeStructure';\nimport { ItemsMap } from './ItemsMap';\nimport { ItemsAccessor } from './ItemsAccessor';\nimport { newMap } from './helpers';\n\nexport interface LoadOptions<TItem, TId, TFilter = any> extends FetchingOptions {\n    tree: ITree<TItem, TId>;\n    api: LazyDataSourceApi<TItem, TId, TFilter>;\n    getChildCount?(item: TItem): number;\n    isFolded?: (item: TItem) => boolean;\n    dataSourceState: DataSourceState<TFilter, TId>;\n    filter?: TFilter;\n}\n\nexport interface LoadMissingOnCheckOptions<TItem, TId, TFilter = any> extends Omit<LoadOptions<TItem, TId, TFilter>, 'withNestedChildren'> {\n    cascadeSelection?: CascadeSelection;\n    checkedId?: TId;\n    isRoot: boolean;\n    isChecked: boolean;\n}\n\n/**\n * Structured result of tree records loading.\n */\nexport interface ITreeLoadResult<TItem, TId> {\n    /**\n     * Loaded records.\n     */\n    loadedItems: TItem[];\n    /**\n     * Loaded records, structured by parents IDs.\n     */\n    byParentId: IMap<TId, TId[]>;\n    /**\n     * Loading node info, like count/assumedCount/totalCount, by IDs.\n     */\n    nodeInfoById: IMap<TId, ITreeNodeInfo>;\n}\n\nexport class Tree {\n    public static createFromItems<TItem, TId>({ params, items }: {\n        params: ITreeParams<TItem, TId>,\n        items: TItem[],\n    }) {\n        const itemsMap = ItemsMap.blank<TId, TItem>(params);\n        const itemsAccessor = ItemsAccessor.toItemsAccessor(itemsMap.setItems(items));\n        return TreeStructure.createFromItems({ params, items, itemsAccessor });\n    }\n\n    public static getParents<TItem, TId>(id: TId, tree: ITree<TItem, TId>) {\n        const parentIds: TId[] = [];\n        let parentId = id;\n        while (true) {\n            const item = tree.getById(parentId);\n            if (item === NOT_FOUND_RECORD) {\n                break;\n            }\n            parentId = tree.getParams().getParentId?.(item);\n            if (parentId === undefined || parentId === null) {\n                break;\n            }\n            parentIds.unshift(parentId);\n        }\n        return parentIds;\n    }\n\n    public static getPathById<TItem, TId>(id: TId, tree: ITree<TItem, TId>): DataRowPathItem<TId, TItem>[] {\n        const foundParents = this.getParents(id, tree);\n        const path: DataRowPathItem<TId, TItem>[] = [];\n        foundParents.forEach((parentId) => {\n            const parent = tree.getById(parentId);\n            if (parent === NOT_FOUND_RECORD) {\n                return;\n            }\n            const pathItem: DataRowPathItem<TId, TItem> = this.getPathItem(parent, tree);\n            path.push(pathItem);\n        });\n        return path;\n    }\n\n    public static getPathItem<TItem, TId>(item: TItem, tree: ITree<TItem, TId>): DataRowPathItem<TId, TItem> {\n        const parentId = tree.getParams().getParentId?.(item);\n        const id = tree.getParams().getId(item);\n\n        const { ids, count, status } = tree.getItems(parentId);\n        const lastId = ids[ids.length - 1];\n\n        const isLastChild = lastId !== undefined\n            && lastId === id\n            && status === FULLY_LOADED\n            && count === ids.length;\n\n        return {\n            id: tree.getParams().getId(item),\n            value: item,\n            isLastChild,\n        };\n    }\n\n    public static forEach<TItem, TId>(\n        tree: ITree<TItem, TId>,\n        action: (item: TItem, id: TId, parentId: TId, stop: () => void) => void,\n        options?: {\n            direction?: 'bottom-up' | 'top-down';\n            parentId?: TId;\n            includeParent?: boolean;\n        },\n    ) {\n        let shouldStop = false;\n        const stop = () => {\n            shouldStop = true;\n        };\n\n        options = { direction: 'top-down', parentId: undefined, ...options };\n        if (options.includeParent == null) {\n            options.includeParent = options.parentId != null;\n        }\n\n        const iterateNodes = (ids: TId[]) => {\n            if (shouldStop) return;\n            ids.forEach((id) => {\n                if (shouldStop) return;\n                const item = tree.getById(id);\n                const parentId = item !== NOT_FOUND_RECORD ? tree.getParams().getParentId?.(item) : undefined;\n                walkChildrenRec(item === NOT_FOUND_RECORD ? undefined : item, id, parentId);\n            });\n        };\n\n        const walkChildrenRec = (item: TItem, id: TId, parentId: TId) => {\n            if (options.direction === 'top-down') {\n                action(item, id, parentId, stop);\n            }\n            const { ids: childrenIds } = tree.getItems(id);\n            childrenIds && iterateNodes(childrenIds);\n            if (options.direction === 'bottom-up') {\n                action(item, id, parentId, stop);\n            }\n        };\n\n        if (options.includeParent) {\n            iterateNodes([options.parentId]);\n        } else {\n            iterateNodes(tree.getItems(options.parentId).ids);\n        }\n    }\n\n    public static forEachChildren<TItem, TId>(\n        tree: ITree<TItem, TId>,\n        action: (id: TId) => void,\n        isSelectable: (id: TId, item: TItem | typeof NOT_FOUND_RECORD) => boolean,\n        parentId?: TId,\n        includeParent: boolean = true,\n    ) {\n        this.forEach(\n            tree,\n            (item, id) => {\n                if (item && isSelectable(id, item)) {\n                    action(id);\n                }\n            },\n            { parentId: parentId, includeParent },\n        );\n    }\n\n    public static async load<TItem, TId, TFilter = any>({\n        tree,\n        dataSourceState,\n        api,\n        getChildCount,\n        isFolded,\n        filter,\n        signal,\n    }: LoadOptions<TItem, TId, TFilter>): Promise<ITreeLoadResult<TItem, TId>> {\n        return await FetchingHelper.load<TItem, TId, TFilter>({\n            tree,\n            options: {\n                api,\n                getChildCount,\n                isFolded,\n                filter: { ...dataSourceState?.filter, ...filter },\n                signal,\n            },\n            dataSourceState,\n        });\n    }\n\n    public static async loadMissingOnCheck<TItem, TId, TFilter = any>({\n        tree,\n        dataSourceState,\n        api,\n        getChildCount,\n        isFolded,\n        filter,\n        cascadeSelection,\n        isRoot,\n        isChecked,\n        checkedId,\n        signal,\n    }: LoadMissingOnCheckOptions<TItem, TId, TFilter>): Promise<ITree<TItem, TId> | ITreeLoadResult<TItem, TId>> {\n        const isImplicitMode = cascadeSelection === CascadeSelectionTypes.IMPLICIT;\n\n        if (!cascadeSelection && !isRoot) {\n            return tree;\n        }\n\n        const parents = this.getParents(checkedId, tree);\n        return await FetchingHelper.load<TItem, TId, TFilter>({\n            tree,\n            options: {\n                api,\n                getChildCount,\n                isFolded,\n                filter: { ...dataSourceState?.filter, ...filter },\n                loadAllChildren: (itemId) => {\n                    const loadAllConfig = { nestedChildren: !isImplicitMode, children: false };\n                    if (!cascadeSelection) {\n                        return { ...loadAllConfig, children: isChecked && isRoot };\n                    }\n\n                    if (!isChecked && isRoot) {\n                        return { ...loadAllConfig, children: false };\n                    }\n\n                    if (isImplicitMode) {\n                        return { ...loadAllConfig, children: itemId === ROOT_ID || parents.some((parent) => isEqual(parent, itemId)) };\n                    }\n\n                    const { ids } = tree.getItems(undefined);\n                    const rootIsNotLoaded = ids.length === 0;\n\n                    const shouldLoadChildrenAfterSearch = (!!dataSourceState.search?.length\n                        && (parents.some((parent) => isEqual(parent, itemId))\n                        || (itemId === ROOT_ID && rootIsNotLoaded)));\n\n                    // `isEqual` is used, because complex ids can be recreated after fetching of parents.\n                    // So, they should be compared not by reference, but by value.\n                    const shouldLoadAllChildren = isRoot\n                        || isEqual(itemId, checkedId)\n                        || shouldLoadChildrenAfterSearch;\n\n                    return { children: shouldLoadAllChildren, nestedChildren: !shouldLoadChildrenAfterSearch };\n                },\n                isLoadStrict: true,\n                signal,\n            },\n            dataSourceState: { ...dataSourceState, search: null },\n        });\n    }\n\n    public static computeSubtotals<TItem, TId, TSubtotals>(\n        tree: ITree<TItem, TId>,\n        get: (item: TItem, hasChildren: boolean) => TSubtotals,\n        add: (a: TSubtotals, b: TSubtotals) => TSubtotals,\n    ): IMap<TId, TSubtotals> {\n        const subtotalsMap = newMap<TId | undefined, TSubtotals>(tree.getParams());\n\n        Tree.forEach(\n            tree,\n            (item, id, parentId) => {\n                const { ids } = tree.getItems(id);\n                const hasChildren = ids.length > 0;\n                let itemSubtotals = get(item, hasChildren);\n\n                // add already computed children subtotals\n                if (subtotalsMap.has(id)) {\n                    itemSubtotals = add(itemSubtotals, subtotalsMap.get(id));\n                }\n\n                // store\n                subtotalsMap.set(id, itemSubtotals);\n\n                // add value to parent\n                let parentSubtotals: TSubtotals;\n                if (!subtotalsMap.has(parentId)) {\n                    parentSubtotals = itemSubtotals;\n                } else {\n                    parentSubtotals = add(itemSubtotals, subtotalsMap.get(parentId));\n                }\n                subtotalsMap.set(parentId, parentSubtotals);\n            },\n            { direction: 'bottom-up' },\n        );\n        return subtotalsMap;\n    }\n}\n","import { IMap } from '../../../../../types';\nimport { ITreeNodeInfo, ITreeParams, IItemsAccessor } from './types';\nimport { newMap } from '../helpers/map';\nimport { EMPTY, FULLY_LOADED, NOT_FOUND_RECORD, PARTIALLY_LOADED, ROOT_ID } from '../constants';\nimport { ItemsMap } from '../ItemsMap';\nimport { ITree, ITreeItemsInfo, ITreeNodeStatus } from '../ITree';\n// eslint-disable-next-line import/no-cycle\nimport { Tree } from '../Tree';\n\nexport class TreeStructure<TItem, TId> implements ITree<TItem, TId> {\n    constructor(\n        private _params: ITreeParams<TItem, TId>,\n        private readonly _itemsAccessor: IItemsAccessor<TItem, TId>,\n        protected readonly _byParentId: IMap<TId, TId[]> = newMap(_params),\n        protected readonly _nodeInfoById: IMap<TId, ITreeNodeInfo> = newMap(_params),\n    ) {}\n\n    getItemsAccessor(): IItemsAccessor<TItem, TId> {\n        return this.itemsAccessor;\n    }\n\n    public get itemsAccessor() {\n        return this._itemsAccessor;\n    }\n\n    public getParams() {\n        return this._params;\n    }\n\n    public get byParentId() {\n        return this._byParentId;\n    }\n\n    public get nodeInfoById() {\n        return this._nodeInfoById;\n    }\n\n    public getRootItems() {\n        return this.getItems(undefined).ids\n            .map((id) => this.itemsAccessor.get(id)!)\n            .filter<TItem>((item): item is TItem => item !== NOT_FOUND_RECORD);\n    }\n\n    public getById(id: TId) {\n        return this.itemsAccessor.get(id);\n    }\n\n    public getItems(parentId?: TId): ITreeItemsInfo<TId> {\n        const currentParentId = parentId ?? undefined;\n        const ids = this.byParentId.get(currentParentId) ?? [];\n        const { count, ...restNodeInfo } = this.nodeInfoById.get(currentParentId) || {};\n\n        let status: ITreeNodeStatus = count === undefined ? PARTIALLY_LOADED : EMPTY;\n        if (count !== 0 && ids.length === count) {\n            status = FULLY_LOADED;\n        }\n\n        return { ids, count, status, ...restNodeInfo };\n    }\n\n    public getChildren(parentId: TId) {\n        const { ids } = this.getItems(parentId);\n        const children = ids.map((id) => this.itemsAccessor.get(id));\n        return children.filter<TItem>((item): item is TItem => item !== NOT_FOUND_RECORD);\n    }\n\n    public getTotalCount() {\n        let count = undefined;\n        for (const [, info] of this.nodeInfoById) {\n            if (info.count == null) {\n                // TBD: getTotalCount() is used for totalCount, but we can't have correct count until all branches are loaded\n                return null;\n            } else {\n                if (count === undefined) {\n                    count = 0;\n                }\n                count += info.count;\n            }\n        }\n        return count;\n    }\n\n    public computeSubtotals<TSubtotals>(get: (item: TItem, hasChildren: boolean) => TSubtotals, add: (a: TSubtotals, b: TSubtotals) => TSubtotals) {\n        const subtotalsMap = newMap<TId | undefined, TSubtotals>(this.getParams());\n\n        Tree.forEach(\n            this,\n            (item, id, parentId) => {\n                let itemSubtotals = get(item, this.byParentId.has(id));\n\n                // add already computed children subtotals\n                if (subtotalsMap.has(id)) {\n                    itemSubtotals = add(itemSubtotals, subtotalsMap.get(id));\n                }\n\n                // store\n                subtotalsMap.set(id, itemSubtotals);\n\n                // add value to parent\n                let parentSubtotals: TSubtotals;\n                if (!subtotalsMap.has(parentId)) {\n                    parentSubtotals = itemSubtotals;\n                } else {\n                    parentSubtotals = add(itemSubtotals, subtotalsMap.get(parentId));\n                }\n                subtotalsMap.set(parentId, parentSubtotals);\n            },\n            { direction: 'bottom-up' },\n        );\n        return subtotalsMap;\n    }\n\n    public static create<TItem, TId>(\n        params: ITreeParams<TItem, TId>,\n        itemsAccessor: IItemsAccessor<TItem, TId>,\n        byParentId?: IMap<TId, TId[]>,\n        nodeInfoById?: IMap<TId, ITreeNodeInfo>,\n    ): TreeStructure<TItem, TId> {\n        return new TreeStructure(params, itemsAccessor, byParentId, nodeInfoById);\n    }\n\n    public static withNewItemsAccessor<TItem, TId>(itemsAccessor: IItemsAccessor<TItem, TId>, treeStructure: TreeStructure<TItem, TId>) {\n        return TreeStructure.create<TItem, TId>(treeStructure.getParams(), itemsAccessor, treeStructure.byParentId, treeStructure.nodeInfoById);\n    }\n\n    public static createFromItems<TItem, TId>({\n        params,\n        items,\n        itemsAccessor,\n    }: {\n        params: ITreeParams<TItem, TId>,\n        items: TItem[] | ItemsMap<TId, TItem>,\n        itemsAccessor: IItemsAccessor<TItem, TId>,\n    }) {\n        const byParentId = newMap<TId, TId[]>(params);\n\n        const itemsMap = newMap<TId, TItem>(params);\n\n        items.forEach((item) => {\n            const parentId = params.getParentId?.(item) ?? undefined;\n\n            if (!byParentId.has(parentId)) {\n                byParentId.set(parentId, []);\n            }\n            const children = byParentId.get(parentId);\n            children.push(params.getId(item));\n\n            byParentId.set(parentId, children);\n            itemsMap.set(parentId, item);\n        });\n\n        const newNodeInfoById = newMap<TId, ITreeNodeInfo>(params);\n        for (const [parentId, ids] of byParentId) {\n            const assumedCount = itemsMap.has(parentId) ? params.getChildCount?.(itemsMap.get(parentId)) : undefined;\n            newNodeInfoById.set(parentId, { count: ids.length, ...(params.getChildCount ? { assumedCount } : {}) });\n        }\n\n        // if items is empty, count should be defined, otherwise, loading placeholders will be rendered.\n        if (!newNodeInfoById.size) {\n            newNodeInfoById.set(undefined, { count: 0 });\n        }\n\n        return this.create<TItem, TId>(params, itemsAccessor, byParentId, newNodeInfoById);\n    }\n\n    public isBlank() {\n        return !this.nodeInfoById.has(ROOT_ID);\n    }\n}\n","import isEqual from 'react-fast-compare';\nimport { CascadeSelectionTypes } from '../../../../../../types';\nimport { Tree } from '../../Tree';\nimport { NOT_FOUND_RECORD, ROOT_ID } from '../../constants';\nimport { newMap } from '../../helpers/map';\nimport { ActForCheckableOptions, CascadeSelectionOptions, CheckParentsWithFullCheckOptions, ClearAllOptions, ClearIfTreeNotLoadedOptions, ClearUnknownItemsOptions, SelectionOptions } from './types';\n\nexport class CheckingHelper {\n    public static cascadeSelection<TItem, TId>({\n        tree,\n        currentCheckedIds,\n        checkedId,\n        isChecked,\n        isCheckable,\n        isUnknown,\n        cascadeSelectionType,\n    }: CascadeSelectionOptions<TItem, TId>) {\n        const isImplicitMode = cascadeSelectionType === CascadeSelectionTypes.IMPLICIT;\n        let checkedIdsMap = newMap<TId, boolean>(tree.getParams());\n        if (!(checkedId === ROOT_ID && isImplicitMode)) {\n            currentCheckedIds.forEach((id) => checkedIdsMap.set(id, true));\n        }\n        const optionsWithDefaults = { isCheckable: isCheckable ?? (() => true), cascadeSelectionType };\n\n        const { count } = tree.getItems(undefined);\n        const treeIsLoaded = count !== 0;\n        // If clear items while tree is not loaded yet (while clearing tags of PickerInput before opening body).\n        if (!treeIsLoaded && !isChecked) {\n            checkedIdsMap = this.clearIfTreeNotLoaded({\n                tree,\n                checkedIdsMap,\n                checkedId,\n                isCheckable: optionsWithDefaults.isCheckable,\n            });\n        }\n\n        if (treeIsLoaded && !optionsWithDefaults.cascadeSelectionType) {\n            checkedIdsMap = this.simpleSelection({\n                tree,\n                checkedIdsMap,\n                checkedId,\n                isChecked,\n                ...optionsWithDefaults,\n            });\n        }\n\n        if (treeIsLoaded && (\n            optionsWithDefaults.cascadeSelectionType === true\n            || optionsWithDefaults.cascadeSelectionType === CascadeSelectionTypes.EXPLICIT)\n        ) {\n            checkedIdsMap = this.explicitCascadeSelection({\n                tree,\n                checkedIdsMap,\n                checkedId,\n                isChecked,\n                ...optionsWithDefaults,\n            });\n        }\n\n        if (treeIsLoaded && optionsWithDefaults.cascadeSelectionType === CascadeSelectionTypes.IMPLICIT) {\n            checkedIdsMap = this.implicitCascadeSelection({\n                tree,\n                checkedIdsMap,\n                checkedId,\n                isChecked,\n                ...optionsWithDefaults,\n            });\n        }\n\n        if (!isChecked && checkedId === ROOT_ID && checkedIdsMap.size > 0) {\n            checkedIdsMap = this.clearUnknownItems({ checkedIdsMap, isUnknown });\n        }\n\n        const result = [];\n        for (const [id, value] of checkedIdsMap) {\n            value && result.push(id);\n        }\n\n        return result;\n    }\n\n    private static simpleSelection<TItem, TId>({\n        tree,\n        checkedIdsMap,\n        checkedId,\n        isChecked,\n        isCheckable,\n    }: SelectionOptions<TItem, TId>) {\n        if (isChecked) {\n            // eslint-disable-next-line eqeqeq\n            if (checkedId != ROOT_ID) {\n                checkedIdsMap.set(checkedId, true);\n            } else {\n                Tree.forEachChildren<TItem, TId>(\n                    tree,\n                    (id) => { checkedIdsMap.set(id, true); },\n                    isCheckable,\n                );\n            }\n            return checkedIdsMap;\n        }\n\n        // eslint-disable-next-line eqeqeq\n        if (checkedId != ROOT_ID) {\n            checkedIdsMap.delete(checkedId);\n            return checkedIdsMap;\n        }\n\n        return this.clearAllChecked({ tree, checkedIdsMap, isCheckable });\n    }\n\n    private static clearAllChecked<TItem, TId>({\n        tree,\n        checkedIdsMap,\n        isCheckable,\n    }: ClearAllOptions<TItem, TId>) {\n        for (const [checkedItemId, isItemChecked] of checkedIdsMap) {\n            if (isItemChecked) {\n                this.actForCheckable({\n                    tree,\n                    action: (id) => checkedIdsMap.delete(id),\n                    isCheckable,\n                    id: checkedItemId,\n                });\n            }\n        }\n        return checkedIdsMap;\n    }\n\n    private static actForCheckable<TItem, TId>({\n        tree,\n        action,\n        isCheckable,\n        id,\n    }: ActForCheckableOptions<TItem, TId>) {\n        const item = tree.getById(id);\n        if (isCheckable(id, item)) {\n            action(id);\n        }\n    }\n\n    private static explicitCascadeSelection<TItem, TId>({\n        tree,\n        checkedIdsMap,\n        checkedId,\n        isChecked,\n        isCheckable,\n    }: SelectionOptions<TItem, TId>) {\n        if (isChecked) {\n            // eslint-disable-next-line eqeqeq\n            if (checkedId != ROOT_ID) {\n                checkedIdsMap.set(checkedId, true);\n            }\n            // check all children recursively\n            Tree.forEachChildren<TItem, TId>(\n                tree,\n                // eslint-disable-next-line eqeqeq\n                (id) => id != ROOT_ID && checkedIdsMap.set(id, true),\n                isCheckable,\n                checkedId,\n            );\n            return this.checkParentsWithFullCheck({ tree, checkedIdsMap, checkedId, isCheckable });\n        }\n\n        // eslint-disable-next-line eqeqeq\n        if (checkedId != ROOT_ID) {\n            checkedIdsMap.delete(checkedId);\n            // uncheck all children recursively\n            Tree.forEachChildren<TItem, TId>(\n                tree,\n                (id) => checkedIdsMap.delete(id),\n                isCheckable,\n                checkedId,\n            );\n\n            Tree.getParents(checkedId, tree).forEach((parentId) => checkedIdsMap.delete(parentId));\n\n            return checkedIdsMap;\n        }\n\n        return this.clearAllChecked({ tree, checkedIdsMap, isCheckable });\n    }\n\n    private static implicitCascadeSelection<TItem, TId>({\n        tree,\n        checkedIdsMap,\n        checkedId,\n        isChecked,\n        isCheckable,\n    }: SelectionOptions<TItem, TId>) {\n        if (isChecked) {\n            // eslint-disable-next-line eqeqeq\n            if (checkedId != ROOT_ID) {\n                checkedIdsMap.set(checkedId, true);\n            }\n\n            // In implicit mode, no children are loaded into the parent.\n            // When some child is checked and the search is cleared, while checking the top parent no children will be loaded,\n            // so there will be no children in the list of checked parent's children. Because of such behavior, explicitly checked\n            // children will not be removed from the list.\n            // To remove them, it is required to pass through all the checked items and check, if their parents don't contain the checked item.\n            if (checkedIdsMap.size) {\n                for (const [id] of checkedIdsMap) {\n                    if (isEqual(id, checkedId)) {\n                        continue;\n                    }\n                    const path = Tree.getPathById(id, tree);\n                    if (path.some((item) => isEqual(item.id, checkedId))) {\n                        checkedIdsMap.delete(id);\n                    }\n                }\n            }\n\n            if (checkedId === ROOT_ID) {\n                const { ids: childrenIds } = tree.getItems(checkedId);\n\n                // if selectedId is undefined and it is selected, that means selectAll\n                childrenIds.forEach((id) => checkedIdsMap.set(id, true));\n            }\n            // check parents if all children are checked\n            return this.checkParentsWithFullCheck({\n                tree,\n                checkedIdsMap,\n                checkedId,\n                isCheckable,\n                removeExplicitChildrenSelection: true,\n            });\n        }\n\n        // eslint-disable-next-line eqeqeq\n        if (checkedId != ROOT_ID) {\n            checkedIdsMap.delete(checkedId);\n\n            const selectNeighboursOnly = (itemId: TId) => {\n                const item = tree.getById(itemId);\n                if (item === NOT_FOUND_RECORD) {\n                    return;\n                }\n\n                const parentId = tree.getParams().getParentId?.(item);\n                const parents = Tree.getParents(itemId, tree);\n                // if some parent is checked, it is required to check all children explicitly,\n                // except unchecked one.\n                const someParentIsChecked = parents.some((parent) => checkedIdsMap.get(parent));\n                tree.getItems(parentId).ids.forEach((id) => {\n                    if (itemId !== id && someParentIsChecked) {\n                        checkedIdsMap.set(id, true);\n                    }\n                });\n                checkedIdsMap.delete(parentId);\n            };\n\n            const parents = Tree.getParents(checkedId, tree);\n            [checkedId, ...parents.reverse()].forEach(selectNeighboursOnly);\n\n            return checkedIdsMap;\n        }\n\n        return this.clearAllChecked({ tree, checkedIdsMap, isCheckable });\n    }\n\n    private static checkParentsWithFullCheck<TItem, TId>({\n        tree,\n        checkedIdsMap,\n        checkedId,\n        isCheckable,\n        removeExplicitChildrenSelection,\n    }: CheckParentsWithFullCheckOptions<TItem, TId>) {\n        Tree.getParents(checkedId, tree)\n            .reverse()\n            .forEach((parentId) => {\n                const { ids: childrenIds } = tree.getItems(parentId);\n                if (childrenIds && childrenIds.every((childId) => checkedIdsMap.has(childId))) {\n                    checkedIdsMap.set(parentId, true);\n\n                    if (removeExplicitChildrenSelection) {\n                        Tree.forEachChildren(\n                            tree,\n                            (id) => checkedIdsMap.delete(id),\n                            isCheckable,\n                            parentId,\n                            false,\n                        );\n                    }\n                }\n            });\n        return checkedIdsMap;\n    }\n\n    private static clearIfTreeNotLoaded<TItem, TId>({\n        tree,\n        checkedIdsMap,\n        checkedId,\n        isCheckable,\n    }: ClearIfTreeNotLoadedOptions<TItem, TId>) {\n        if (checkedId !== ROOT_ID) {\n            const item = tree.getById(checkedId);\n            if (isCheckable(checkedId, item)) {\n                checkedIdsMap.delete(checkedId);\n            }\n        } else {\n            for (const [selectedItemId, isItemSelected] of checkedIdsMap) {\n                const selectedItem = tree.getById(selectedItemId);\n                if (isItemSelected && isCheckable(selectedItemId, selectedItem)) {\n                    checkedIdsMap.delete(selectedItemId);\n                }\n            }\n        }\n        return checkedIdsMap;\n    }\n\n    private static clearUnknownItems<TId>({\n        checkedIdsMap,\n        isUnknown,\n    }: ClearUnknownItemsOptions<TId>) {\n        for (const [selectedItemId, isItemSelected] of checkedIdsMap) {\n            if (isItemSelected && isUnknown(selectedItemId)) {\n                checkedIdsMap.delete(selectedItemId);\n            }\n        }\n        return checkedIdsMap;\n    }\n}\n","import { NOT_FOUND_RECORD } from '../../constants';\nimport { ITree } from '../../ITree';\nimport { TreeStructure } from '../TreeStructure';\nimport { ApplyFilterToTreeSnapshotOptions, FilterOptions } from './types';\n\nexport class FilterHelper {\n    public static filter<TItem, TId, TFilter>({\n        tree,\n        getFilter,\n        filter,\n        newTreeInstance = (options) => TreeStructure.createFromItems(options),\n    }: FilterOptions<TItem, TId, TFilter>): ITree<TItem, TId> {\n        const isMatchingFilter = getFilter?.(filter);\n        return this.applyFilterToTreeSnapshot({ tree, newTreeInstance, filter: isMatchingFilter });\n    }\n\n    private static applyFilterToTreeSnapshot<TItem, TId>({\n        tree,\n        filter,\n        newTreeInstance,\n    }: ApplyFilterToTreeSnapshotOptions<TItem, TId>) {\n        if (!filter) return tree;\n\n        const matchedItems: TItem[] = [];\n        const applyFilterRec = (ids: TId[]) => {\n            let isSomeMatching: number | boolean = false;\n            ids.forEach((id) => {\n                const item = tree.getById(id);\n                if (item === NOT_FOUND_RECORD) return;\n\n                const isItemMatching = filter(item);\n                const { ids: children } = tree.getItems(id);\n                const isSomeChildMatching = applyFilterRec(children);\n                const isMatching = isItemMatching || isSomeChildMatching;\n                if (isMatching) {\n                    matchedItems.push(item);\n                }\n\n                if (!isSomeMatching) {\n                    isSomeMatching = isMatching;\n                }\n            });\n\n            return isSomeMatching;\n        };\n\n        const { ids: root } = tree.getItems(undefined);\n        applyFilterRec(root);\n\n        return newTreeInstance({\n            itemsAccessor: tree.getItemsAccessor(),\n            params: tree.getParams(),\n            items: matchedItems,\n        });\n    }\n}\n","import { TreeStructure } from '../TreeStructure';\nimport { getSearchFilter } from '../../../../../querying';\nimport { ApplySearchToTreeSnapshotOptions, SearchOptions } from './types';\nimport { orderBy } from '../../../../../../helpers';\nimport { ITree } from '../../ITree';\nimport { NOT_FOUND_RECORD } from '../../constants';\n\nexport class SearchHelper {\n    public static search<TItem, TId, TFilter>(\n        options: SearchOptions<TItem, TId, TFilter>,\n    ): ITree<TItem, TId> {\n        const search = this.buildSearchFilter(options);\n        return this.applySearchToTree({ ...options, search });\n    }\n\n    private static buildSearchFilter<TItem, TId, TFilter>({\n        search,\n        getSearchFields,\n    }: SearchOptions<TItem, TId, TFilter>) {\n        if (!search) return null;\n\n        if (!getSearchFields) {\n            console.warn(\n                '[Tree] Search value is set, but options.getSearchField is not specified. Nothing to search on.',\n            );\n            return null;\n        }\n        const searchFilter = getSearchFilter(search);\n        return (i: TItem) => searchFilter(getSearchFields(i));\n    }\n\n    private static applySearchToTree<TItem, TId>({\n        tree,\n        search,\n        sortSearchByRelevance,\n        newTreeInstance = (options) => TreeStructure.createFromItems(options),\n    }: ApplySearchToTreeSnapshotOptions<TItem, TId>) {\n        if (!search) return tree;\n\n        const matchedItems: TItem[] = [];\n        const ranks: Map<TId, number> = new Map();\n\n        const applySearchRec = (parentId?: TId) => {\n            let isSomeMatching: number | boolean = false;\n            const { ids: children } = tree.getItems(parentId);\n            children.forEach((id) => {\n                const item = tree.getById(id);\n                if (item === NOT_FOUND_RECORD) return;\n\n                const isItemMatching = search(item);\n                const isSomeChildMatching = applySearchRec(\n                    id,\n                );\n\n                const isMatching = isItemMatching || isSomeChildMatching;\n                if (isMatching !== false) {\n                    matchedItems.push(item);\n                    if (typeof isMatching !== 'boolean') {\n                        const rank = ranks.has(id)\n                            ? Math.max(ranks.get(id), isMatching)\n                            : isMatching;\n                        ranks.set(tree.getParams().getId(item), rank);\n                    }\n                }\n\n                if (!isSomeMatching) {\n                    isSomeMatching = isMatching;\n                } else if (typeof isMatching === 'number') {\n                    isSomeMatching = typeof isSomeMatching === 'number'\n                        ? Math.max(isMatching, isSomeMatching)\n                        : isMatching;\n                }\n            });\n\n            return isSomeMatching;\n        };\n\n        applySearchRec(undefined);\n\n        const searchItems = sortSearchByRelevance\n            ? this.sortByRanks(\n                matchedItems,\n                ranks,\n                tree.getParams().getId,\n            )\n            : matchedItems;\n\n        return newTreeInstance({\n            itemsAccessor: tree.getItemsAccessor(),\n            params: tree.getParams(),\n            items: searchItems,\n        });\n    }\n\n    private static sortByRanks<TItem, TId>(\n        items: TItem[],\n        ranks: Map<TId, number>,\n        getId: (item: TItem) => TId,\n    ) {\n        if (ranks.size === 0) {\n            return items;\n        }\n        const itemsToSort = [...items];\n\n        return orderBy(\n            itemsToSort,\n            (item) => {\n                const id = getId(item);\n                if (!ranks.has(id)) {\n                    return 0;\n                }\n                return ranks.get(id);\n            },\n            'desc',\n        );\n    }\n}\n","import { NOT_FOUND_RECORD } from '../../constants';\nimport { buildSorter } from '../../helpers';\nimport { ITree } from '../../ITree';\nimport { TreeStructure } from '../TreeStructure';\nimport type { SortOptions } from './types';\n\nexport class SortHelper {\n    public static sort<TItem, TId, TFilter>({\n        tree,\n        newTreeInstance = (options) => TreeStructure.createFromItems(options),\n        ...options\n    }: SortOptions<TItem, TId, TFilter>) {\n        const sort = buildSorter({ ...options, getId: tree.getParams().getId });\n        const sortedItems: TItem[][] = [];\n        const sortRec = (items: TItem[]) => {\n            sortedItems.push(sort(items));\n            items.forEach((item) => {\n                const id = tree.getParams().getId(item);\n                sortRec(SortHelper.getItems(tree, id));\n            });\n        };\n\n        sortRec(SortHelper.getItems(tree, undefined));\n        return newTreeInstance({\n            params: tree.getParams(),\n            items: sortedItems.flat(),\n            itemsAccessor: tree.getItemsAccessor(),\n        });\n    }\n\n    private static getItems<TItem, TId>(tree: ITree<TItem, TId>, parentId: TId) {\n        const { ids = [] } = tree.getItems(parentId);\n        return ids.map((i) => tree.getById(i)).filter((i): i is TItem => i !== NOT_FOUND_RECORD);\n    }\n}\n","import { newMap } from './map';\n\nexport interface MergeOptions<TId> {\n    isDeleted?: (id: TId) => boolean;\n    complexIds?: boolean;\n}\n\nexport function merge<TId>(\n    mergeSrcArr: TId[],\n    mergeTgArr: TId[],\n    compare: (idFromSource: TId, idFromTarget: TId, sourceIndex: number, targetIndex: number) => number,\n    initialArr: TId[] = [],\n    options: MergeOptions<TId> = {},\n): [TId[], boolean] {\n    const { complexIds, isDeleted } = options;\n\n    let srcItemIndex = 0,\n        tgItemIndex = 0,\n        isUpdated = false;\n\n    const merged: TId[] = [...initialArr];\n    const patchedItems = newMap<TId, boolean>({ complexIds });\n\n    mergeSrcArr.forEach((id) => {\n        patchedItems.set(id, true);\n    });\n\n    while (srcItemIndex < mergeSrcArr.length || tgItemIndex < mergeTgArr.length) {\n        if (srcItemIndex >= mergeSrcArr.length) {\n            if (!patchedItems.get(mergeTgArr[tgItemIndex]) && !isDeleted?.(mergeTgArr[tgItemIndex])) {\n                merged.push(mergeTgArr[tgItemIndex]);\n            }\n            if (isDeleted?.(mergeTgArr[tgItemIndex])) {\n                isUpdated = true;\n            }\n\n            tgItemIndex++;\n            continue;\n        }\n\n        if (tgItemIndex >= mergeTgArr.length) {\n            if (!isDeleted?.(mergeSrcArr[srcItemIndex])) {\n                merged.push(mergeSrcArr[srcItemIndex]);\n                isUpdated = true;\n            }\n            srcItemIndex++;\n            continue;\n        }\n\n        const srcItemId = mergeSrcArr[srcItemIndex];\n        const tgItemId = mergeTgArr[tgItemIndex];\n\n        if (isDeleted?.(srcItemId)) {\n            srcItemIndex++;\n            continue;\n        }\n\n        if (isDeleted?.(tgItemId)) {\n            isUpdated = true;\n            tgItemIndex++;\n            continue;\n        }\n\n        if (patchedItems.has(tgItemId)) {\n            isUpdated = true;\n            tgItemIndex++;\n            continue;\n        }\n\n        const result = compare(srcItemId, tgItemId, srcItemIndex, tgItemIndex);\n        if (result === -1) {\n            merged.push(srcItemId);\n            isUpdated = true;\n            srcItemIndex++;\n        } else {\n            if (!patchedItems.has(tgItemId) && !isDeleted?.(tgItemId)) {\n                merged.push(tgItemId);\n            }\n            if (isDeleted?.(tgItemId)) {\n                isUpdated = true;\n            }\n\n            tgItemIndex++;\n        }\n    }\n\n    return [merged, isUpdated];\n}\n","import { IImmutableMap, IMap } from '../../../../../../types';\nimport { indexToOrder } from '../../../../../../helpers';\nimport { buildComparators, composeComparators, simpleComparator } from '../../helpers';\nimport { NOT_FOUND_RECORD } from '../../constants';\nimport { ItemsAccessor } from '../../ItemsAccessor';\nimport { TreeStructure } from '../TreeStructure';\nimport { cloneMap, newMap } from '../../helpers/map';\nimport { merge } from '../../helpers/merge';\nimport type { PatchIntoTreeStructureOptions } from './types';\nimport { ItemsMap } from '../../ItemsMap';\n\ninterface ApplyPatchWithSortingOptions<TItem, TId> {\n    comparator: (a: TItem, b: TItem) => number;\n    patchAtLastSort: IMap<TId, TItem> | IImmutableMap<TId, TItem>;\n    originalItemsMap: ItemsMap<TId, TItem>;\n    patchedItemsMap: ItemsMap<TId, TItem>;\n    isDeleted: (id: TId) => boolean;\n    complexIds?: boolean;\n}\n\ninterface ApplyPatchTemporaryReorderingOptions<TItem, TId> {\n    getItemTemporaryOrder: (item: TItem) => string;\n    patchedItemsMap: ItemsMap<TId, TItem>;\n    isDeleted: (id: TId) => boolean;\n    complexIds?: boolean;\n}\n\nexport class PatchHelper {\n    private static applyPatchWithSorting<TItem, TId>(\n        patchIds: TId[],\n        originalIds: TId[],\n        {\n            comparator,\n            patchAtLastSort,\n            originalItemsMap,\n            patchedItemsMap,\n            isDeleted,\n            complexIds,\n        }: ApplyPatchWithSortingOptions<TItem, TId>,\n        initialIds: TId[] = [],\n    ) {\n        return merge(\n            patchIds,\n            originalIds,\n            (patchItemId, itemId) => {\n                const inPatchBeforeSort = patchAtLastSort.has(patchItemId);\n                const inOriginalTree = originalItemsMap.has(patchItemId);\n\n                let patchItemToCompare;\n                if (inPatchBeforeSort) {\n                    patchItemToCompare = patchAtLastSort.get(patchItemId);\n                } else if (inOriginalTree) {\n                    patchItemToCompare = originalItemsMap.get(patchItemId);\n                } else {\n                    patchItemToCompare = patchedItemsMap.get(patchItemId);\n                }\n\n                const item = originalItemsMap.get(itemId);\n                return comparator(patchItemToCompare, item);\n            },\n            initialIds,\n            { isDeleted, complexIds },\n        );\n    }\n\n    private static applyPatchTemporaryReordering<TItem, TId>(\n        patchIds: TId[],\n        originalIds: TId[],\n        {\n            getItemTemporaryOrder,\n            patchedItemsMap,\n            isDeleted,\n            complexIds,\n        }: ApplyPatchTemporaryReorderingOptions<TItem, TId>,\n    ) {\n        return merge(\n            patchIds,\n            originalIds,\n\n            (patchItemId, itemId, _, itemIndex) => {\n                const a = patchedItemsMap.get(patchItemId);\n                const b = patchedItemsMap.get(itemId);\n\n                const aTempOrder = getItemTemporaryOrder(a);\n                const bTempOrder = getItemTemporaryOrder(b) ?? indexToOrder(itemIndex);\n                return simpleComparator(aTempOrder, bTempOrder);\n            },\n            [],\n            { isDeleted, complexIds },\n        );\n    }\n\n    public static patch<TItem, TId>({\n        itemsMap: originalItemsMap,\n        treeStructure,\n        sortedPatch,\n        patchAtLastSort,\n        getItemTemporaryOrder,\n        isDeleted,\n        sorting,\n        sortBy,\n    }: PatchIntoTreeStructureOptions<TItem, TId>) {\n        if (!sortedPatch || !sortedPatch.size) return { treeStructure, itemsMap: originalItemsMap, newItems: [] };\n\n        const newByParentId = cloneMap(treeStructure.byParentId); // shallow clone, still need to copy arrays inside!\n        let patchedItemsMap = originalItemsMap;\n        let newItems: TItem[] = [];\n        const comparators = buildComparators({ sorting, sortBy, getId: treeStructure.getParams().getId });\n        const composedComparator = composeComparators(comparators, treeStructure.getParams().getId);\n\n        const complexIds = treeStructure.getParams().complexIds;\n        const parentsWithNewChildren = newMap<TId, boolean>({ complexIds });\n        let isUpdated = false;\n        for (const [patchParentId, sorted] of sortedPatch) {\n            patchedItemsMap = patchedItemsMap.setItems(sorted.newItems);\n            newItems = newItems.concat(sorted.newItems);\n            const itemIds = newByParentId.get(patchParentId) ?? [];\n\n            // eslint-disable-next-line no-loop-func\n            const isDeletedFn = (id: TId) => isDeleted?.(patchedItemsMap.get(id)) ?? false;\n\n            const [sortedItems, isUpdatedOnPatch] = this.applyPatchWithSorting(\n                sorted.updated,\n                itemIds,\n                {\n                    comparator: composedComparator,\n                    patchAtLastSort,\n                    originalItemsMap,\n                    patchedItemsMap,\n                    isDeleted: isDeletedFn,\n                    complexIds,\n                },\n                sorted.top,\n            );\n\n            const sortedItemsWithBottom = sortedItems.concat(sorted.bottom);\n\n            const [reorderedItems, isUpdatedOnReordering] = this.applyPatchTemporaryReordering(\n                sorted.withTempOrder,\n                sortedItemsWithBottom,\n                {\n                    getItemTemporaryOrder,\n                    patchedItemsMap,\n                    isDeleted: isDeletedFn,\n                    complexIds,\n                },\n            );\n\n            // eslint-disable-next-line no-loop-func\n            sorted.moved.forEach((id) => {\n                const item = treeStructure.getById(id);\n                if (item !== NOT_FOUND_RECORD) {\n                    const parentId = treeStructure.getParams().getParentId?.(item) ?? undefined;\n                    const prevItems = newByParentId.get(parentId);\n                    newByParentId.set(parentId, prevItems.filter((itemId) => itemId !== id));\n                }\n                const newItem = patchedItemsMap.get(id);\n                const newParentId = treeStructure.getParams().getParentId?.(newItem) ?? undefined;\n                parentsWithNewChildren.set(newParentId, true);\n            });\n\n            newByParentId.set(patchParentId, reorderedItems);\n            if (isUpdatedOnReordering || isUpdatedOnPatch || sorted.top.length || sorted.bottom.length || sorted.moved.length) {\n                isUpdated = true;\n            }\n        }\n\n        if (!isUpdated) {\n            return { treeStructure, itemsMap: originalItemsMap, newItems };\n        }\n\n        const newNodeInfoById = cloneMap(treeStructure.nodeInfoById);\n        for (const [parentId, ids] of newByParentId) {\n            if (treeStructure.nodeInfoById.has(parentId)) {\n                const prevNodeInfo = treeStructure.nodeInfoById.get(parentId);\n                if (prevNodeInfo.count !== undefined) {\n                    // Count, different from ids.length can be sent by server.\n                    // After patch, it is required to add a delta of new and old children, to figure out,\n                    // how patch affected count by adding/deleting/moving children.\n                    const newCount = prevNodeInfo.count + (ids.length - (treeStructure.byParentId.get(parentId)?.length ?? 0));\n                    newNodeInfoById.set(parentId, { ...prevNodeInfo, count: newCount });\n                } else if (parentsWithNewChildren.has(parentId)) {\n                    const { assumedCount, ...prev } = prevNodeInfo;\n                    newNodeInfoById.set(parentId, { ...prev, ...(assumedCount === undefined ? { count: ids.length } : { assumedCount }) });\n                }\n            } else {\n                newNodeInfoById.set(parentId, { count: ids.length });\n            }\n        }\n\n        return {\n            treeStructure: TreeStructure.create(\n                treeStructure.getParams(),\n                ItemsAccessor.toItemsAccessor(patchedItemsMap),\n                newByParentId,\n                newNodeInfoById,\n            ),\n            itemsMap: patchedItemsMap,\n            newItems,\n        };\n    }\n}\n","import type { ITree } from '../../ITree';\nimport { NOT_FOUND_RECORD } from '../../constants';\n\nexport class TreeHelper {\n    public static getParents<TItem, TId>(id: TId, tree: ITree<TItem, TId>) {\n        const parentIds: TId[] = [];\n        let parentId = id;\n        while (true) {\n            const item = tree.getById(parentId);\n            if (item === NOT_FOUND_RECORD) {\n                break;\n            }\n            parentId = tree.getParams().getParentId?.(item);\n            if (parentId === undefined) {\n                break;\n            }\n            parentIds.unshift(parentId);\n        }\n        return parentIds;\n    }\n}\n","import { ItemsStorage } from '../ItemsStorage';\nimport type {\n    ExtendedPatchOptions,\n    FilterOptions, LoadAllOptions, LoadOptions,\n    SearchOptions, SortOptions, TreeStructureId, UpdateTreeStructuresOptions,\n} from './types';\nimport { TreeStructure, FetchingHelper, FilterHelper, SortHelper, SearchHelper, PatchHelper } from '../treeStructure';\nimport { ItemsMap } from '../ItemsMap';\nimport { ItemsAccessor } from '../ItemsAccessor';\nimport { NOT_FOUND_RECORD } from '../constants';\nimport { cloneMap, newMap } from '../helpers';\nimport type { ITreeNodeInfo, ITreeParams } from '../treeStructure';\nimport { TreeHelper } from '../treeStructure/helpers/TreeHelper';\nimport type { PatchIntoTreeStructureOptions } from '../treeStructure/helpers/types';\n\nexport class TreeState<TItem, TId> {\n    protected constructor(\n        private _fullTree: TreeStructure<TItem, TId> | null,\n        private _visibleTree: TreeStructure<TItem, TId> | null,\n        private _selectedOnlyTree: TreeStructure<TItem, TId> | null,\n        protected _itemsMap: ItemsMap<TId, TItem>,\n        protected _setItems: ItemsStorage<TItem, TId>['setItems'],\n    ) {}\n\n    public get itemsMap() {\n        return this._itemsMap;\n    }\n\n    public get setItems() {\n        return this._setItems;\n    }\n\n    public get visible() {\n        return this._visibleTree;\n    }\n\n    public get selectedOnly() {\n        return this._selectedOnlyTree;\n    }\n\n    public get full() {\n        return this._fullTree;\n    }\n\n    public getById(id: TId) {\n        return this.itemsMap.has(id) ? this.itemsMap.get(id) : NOT_FOUND_RECORD;\n    }\n\n    public async load<TFilter>({\n        using,\n        options,\n        dataSourceState,\n    }: LoadOptions<TItem, TId, TFilter>): Promise<TreeState<TItem, TId>> {\n        const treeStructure = this.getTreeStructure(using);\n\n        const { loadedItems, byParentId, nodeInfoById } = await FetchingHelper.load<TItem, TId, TFilter>({\n            tree: treeStructure,\n            options,\n            dataSourceState,\n        });\n\n        if (!loadedItems.length && !byParentId.size && !nodeInfoById.size) {\n            if (using === undefined && treeStructure !== this.getTreeStructure('visible')) {\n                return this.withNewTreeStructures({\n                    using,\n                    treeStructure,\n                    itemsMap: this.itemsMap,\n                });\n            }\n\n            return this;\n        }\n\n        const itemsMap = loadedItems.length ? this.setItems(loadedItems, { on: 'load' }) : this.itemsMap;\n        const newByParentId = byParentId.size ? cloneMap(treeStructure.byParentId) : treeStructure.byParentId;\n        for (const [id, ids] of byParentId) {\n            newByParentId.set(id, ids);\n        }\n        const newNodeInfoById = nodeInfoById.size ? cloneMap(treeStructure.nodeInfoById) : treeStructure.nodeInfoById;\n        for (const [id, nodeInfo] of nodeInfoById) {\n            newNodeInfoById.set(id, nodeInfo);\n        }\n        let treeToUpdate: TreeStructureId = using;\n        if (treeToUpdate === 'visible') {\n            treeToUpdate = dataSourceState.search ? 'visible' : undefined;\n        }\n\n        return this.withNewTreeStructures({\n            using: treeToUpdate,\n            treeStructure: TreeStructure.create(\n                treeStructure.getParams(),\n                ItemsAccessor.toItemsAccessor(itemsMap),\n                newByParentId,\n                newNodeInfoById,\n            ),\n            itemsMap,\n        });\n    }\n\n    public async loadAll<TFilter>({\n        using,\n        options,\n        dataSourceState,\n    }: LoadAllOptions<TItem, TId, TFilter>): Promise<TreeState<TItem, TId>> {\n        const treeStructure = this.getTreeStructure(using);\n\n        const { treeStructure: newTreeStructure, itemsMap: newItemsMap, loadedItems } = await FetchingHelper.loadAll({\n            treeStructure,\n            itemsMap: this.itemsMap,\n            options,\n            dataSourceState,\n        });\n\n        if (newTreeStructure === treeStructure && newItemsMap === this.itemsMap && !loadedItems.length) {\n            return this;\n        }\n\n        if (loadedItems.length) {\n            this.setItems(loadedItems, { reset: true });\n        }\n\n        return this.withNewTreeStructures({ using, treeStructure: newTreeStructure, itemsMap: newItemsMap });\n    }\n\n    public filter<TFilter>({\n        filter,\n        getFilter,\n    }: FilterOptions<TItem, TId, TFilter>): TreeState<TItem, TId> {\n        const tree = this.getTreeStructure('full');\n        const newTreeStructure = FilterHelper.filter<TItem, TId, TFilter>({ tree, getFilter, filter }) as TreeStructure<TItem, TId>;\n\n        if (tree === newTreeStructure) {\n            return this;\n        }\n\n        return this.withNewTreeStructures({ treeStructure: newTreeStructure, itemsMap: this.itemsMap });\n    }\n\n    public sort<TFilter>({\n        sorting,\n        sortBy,\n    }: SortOptions<TItem, TId, TFilter>): TreeState<TItem, TId> {\n        const tree = this.getTreeStructure('full');\n        const newTreeStructure = SortHelper.sort<TItem, TId, TFilter>({ tree, sorting, sortBy }) as TreeStructure<TItem, TId>;\n\n        if (tree === newTreeStructure) {\n            return this;\n        }\n\n        return this.withNewTreeStructures({ treeStructure: newTreeStructure, itemsMap: this.itemsMap });\n    }\n\n    public search<TFilter>({\n        search,\n        getSearchFields,\n        sortSearchByRelevance,\n    }: SearchOptions<TItem, TId, TFilter>): TreeState<TItem, TId> {\n        const treeStructure = this.getTreeStructure('full');\n        const newTreeStructure = SearchHelper.search({ tree: treeStructure, search, getSearchFields, sortSearchByRelevance }) as TreeStructure<TItem, TId>;\n\n        if (newTreeStructure === treeStructure) {\n            return this;\n        }\n\n        return this.withNewTreeStructures({ using: 'visible', treeStructure: newTreeStructure, itemsMap: this.itemsMap });\n    }\n\n    private patchTreeStructure(\n        { treeStructure, itemsMap, sortedPatch, patchAtLastSort, getItemTemporaryOrder, isDeleted, sorting, sortBy }: PatchIntoTreeStructureOptions<TItem, TId>,\n    ) {\n        const { treeStructure: newTreeStructure, itemsMap: newItemsMap, newItems } = PatchHelper.patch<TItem, TId>({\n            treeStructure,\n            itemsMap: itemsMap,\n            sortedPatch,\n            patchAtLastSort,\n            getItemTemporaryOrder,\n            isDeleted,\n            sorting,\n            sortBy,\n        });\n\n        if (newTreeStructure === treeStructure && newItemsMap === itemsMap && !newItems.length) {\n            return { treeStructure, itemsMap };\n        }\n\n        return { treeStructure: newTreeStructure, itemsMap: newItemsMap };\n    }\n\n    public patch(\n        { sortedPatch, patchAtLastSort, getItemTemporaryOrder, isDeleted, sorting, sortBy }: ExtendedPatchOptions<TItem, TId>,\n    ): TreeState<TItem, TId> {\n        const { treeStructure: newFull } = this.patchTreeStructure({\n            treeStructure: this.getTreeStructure('full'),\n            itemsMap: this.itemsMap,\n            sortedPatch,\n            patchAtLastSort,\n            getItemTemporaryOrder,\n            isDeleted,\n            sorting,\n            sortBy,\n        });\n\n        const { treeStructure: newVisible, itemsMap: updatedItemsMap } = this.patchTreeStructure({\n            treeStructure: this.getTreeStructure('visible'),\n            itemsMap: this.itemsMap,\n            sortedPatch,\n            patchAtLastSort,\n            getItemTemporaryOrder,\n            isDeleted,\n            sorting,\n            sortBy,\n        });\n\n        if (this.getTreeStructure('full') === newFull && this.getTreeStructure('visible') === newVisible) {\n            return this;\n        }\n\n        const itemsAccessor = ItemsAccessor.toItemsAccessor(updatedItemsMap);\n        const selectedOnly = TreeStructure.withNewItemsAccessor(itemsAccessor, this._selectedOnlyTree);\n        return TreeState.create(newFull, newVisible, selectedOnly, updatedItemsMap, this._setItems);\n    }\n\n    /**\n     * TODO: Add later `selectedOnlyMode: 'tree' | 'flat'.\n     */\n    private buildSelectedOnlyTree(checkedIds: TId[]) {\n        const foundIds = checkedIds\n            .filter((id) => this.getById(id) !== NOT_FOUND_RECORD);\n        let items = new ItemsMap<TId, TItem>(null, this.selectedOnly.getParams());\n        foundIds.forEach((id) => {\n            const parents = TreeHelper.getParents(id, this.full);\n            parents\n                .filter((parentId) => !items.has(parentId) && this.getById(parentId) !== NOT_FOUND_RECORD)\n                .forEach((parentId) => {\n                    items = items.set(parentId, this.getById(parentId) as TItem);\n                });\n\n            items = items.set(id, this.getById(id) as TItem);\n        });\n\n        const newSelectedOnly = TreeStructure.createFromItems({\n            params: this.selectedOnly.getParams(),\n            items,\n            itemsAccessor: ItemsAccessor.toItemsAccessor(this.itemsMap),\n        });\n\n        return TreeState.create(\n            this.full,\n            this.visible,\n            newSelectedOnly,\n            this.itemsMap,\n            this.setItems,\n        );\n    }\n\n    public buildSelectedOnly(checkedIds: TId[]) {\n        const foundIds = (checkedIds ?? [])\n            .filter((id) => this.getById(id) !== NOT_FOUND_RECORD);\n\n        const byParentId = newMap<TId, TId[]>(this.selectedOnly.getParams());\n        const nodeInfoById = newMap<TId, ITreeNodeInfo>(this.selectedOnly.getParams());\n        byParentId.set(undefined, foundIds);\n        nodeInfoById.set(undefined, { count: foundIds.length });\n\n        const newSelectedOnly = TreeStructure.create(\n            this.selectedOnly.getParams(),\n            ItemsAccessor.toItemsAccessor(this.itemsMap),\n            byParentId,\n            nodeInfoById,\n        );\n\n        return TreeState.create(\n            this.full,\n            this.visible,\n            newSelectedOnly,\n            this.itemsMap,\n            this.setItems,\n        );\n    }\n\n    public updateItemsMap(itemsMap: ItemsMap<TId, TItem>) {\n        if (itemsMap === this.itemsMap) {\n            return this;\n        }\n\n        const itemsAccessor = ItemsAccessor.toItemsAccessor(itemsMap);\n        return new TreeState(\n            TreeStructure.withNewItemsAccessor(itemsAccessor, this.full),\n            TreeStructure.withNewItemsAccessor(itemsAccessor, this.visible),\n            TreeStructure.withNewItemsAccessor(itemsAccessor, this.selectedOnly),\n            itemsMap,\n            this.setItems,\n        );\n    }\n\n    public updateSetItems(setItems: ItemsStorage<TItem, TId>['setItems']) {\n        if (this._setItems !== setItems) {\n            this._setItems = setItems;\n        }\n        return this;\n    }\n\n    private getTreeStructure(treeStructureId: TreeStructureId = 'full') {\n        return (treeStructureId ?? 'full') === 'full' ? this._fullTree : this._visibleTree;\n    }\n\n    public clearStructure(newParams?: ITreeParams<TItem, TId>): TreeState<TItem, TId> {\n        const params = newParams || this.visible.getParams();\n        return TreeState.create(\n            this.full,\n            TreeStructure.create(params, ItemsAccessor.toItemsAccessor(this.itemsMap)),\n            this.selectedOnly,\n            this.itemsMap,\n            this.setItems,\n        );\n    }\n\n    public reset(): TreeState<TItem, TId> {\n        return TreeState.create(\n            this.full,\n            this.full,\n            this.selectedOnly,\n            this.itemsMap,\n            this.setItems,\n        );\n    }\n\n    private withNewTreeStructures({\n        using,\n        treeStructure,\n        itemsMap,\n    }: UpdateTreeStructuresOptions<TItem, TId>): TreeState<TItem, TId> {\n        const itemsAccessor = ItemsAccessor.toItemsAccessor(itemsMap);\n        const selectedOnly = TreeStructure.withNewItemsAccessor(itemsAccessor, this._selectedOnlyTree);\n        if (!using) {\n            return TreeState.create(treeStructure, treeStructure, selectedOnly, itemsMap, this._setItems);\n        }\n        const visibleTree = using === 'visible'\n            ? treeStructure\n            : TreeStructure.withNewItemsAccessor(itemsAccessor, this._visibleTree);\n\n        const fullTree = using === 'full'\n            ? treeStructure\n            : TreeStructure.withNewItemsAccessor(itemsAccessor, this._fullTree);\n\n        return TreeState.create(fullTree, visibleTree, selectedOnly, itemsMap, this._setItems);\n    }\n\n    public static create<TItem, TId>(\n        fullTree: TreeStructure<TItem, TId>,\n        visibleTree: TreeStructure<TItem, TId>,\n        selectedOnlyTree: TreeStructure<TItem, TId>,\n        itemsMap: ItemsMap<TId, TItem>,\n        setItems: ItemsStorage<TItem, TId>['setItems'],\n    ) {\n        return new TreeState(\n            fullTree,\n            visibleTree,\n            selectedOnlyTree,\n            itemsMap,\n            setItems,\n        );\n    }\n\n    public static createFromItems<TItem, TId>(\n        items: TItem[] | undefined,\n        itemsMap: ItemsMap<TId, TItem> | undefined,\n        params: ITreeParams<TItem, TId>,\n        setItems: ItemsStorage<TItem, TId>['setItems'],\n    ) {\n        if (items === undefined && itemsMap === undefined) {\n            throw Error('At least one of the following args should be defined: `items` or `itemsMap`.');\n        }\n\n        let treeItemsMap: ItemsMap<TId, TItem>;\n        if (itemsMap) {\n            treeItemsMap = items ? itemsMap.setItems(items) : itemsMap;\n        } else {\n            treeItemsMap = new ItemsMap(new Map(), params).setItems(items);\n        }\n\n        const itemsAccessor = ItemsAccessor.toItemsAccessor(treeItemsMap);\n        const treeStructure = TreeStructure.createFromItems({ params, items: items ?? treeItemsMap, itemsAccessor });\n        return new TreeState(\n            treeStructure,\n            treeStructure,\n            TreeStructure.create(params, ItemsAccessor.toItemsAccessor(itemsMap)),\n            treeItemsMap,\n            setItems,\n        );\n    }\n\n    public static createFromItemsMap<TItem, TId>(\n        itemsMap: ItemsMap<TId, TItem> | undefined,\n        setItems: ItemsStorage<TItem, TId>['setItems'],\n        params: ITreeParams<TItem, TId>,\n    ) {\n        const itemsAccessor = ItemsAccessor.toItemsAccessor(itemsMap);\n        const treeStructure = TreeStructure.createFromItems({ params, items: itemsMap, itemsAccessor });\n        return this.create(\n            treeStructure,\n            treeStructure,\n            TreeStructure.create(params, ItemsAccessor.toItemsAccessor(itemsMap)),\n            itemsMap,\n            setItems,\n        );\n    }\n\n    public static blank<TItem, TId>(params: ITreeParams<TItem, TId>, itemsMap: ItemsMap<TId, TItem>, setItems: ItemsStorage<TItem, TId>['setItems']): TreeState<TItem, TId> {\n        const treeStructure = TreeStructure.create(params, ItemsAccessor.toItemsAccessor(itemsMap));\n\n        return this.create(\n            treeStructure,\n            treeStructure,\n            treeStructure,\n            itemsMap,\n            setItems,\n        );\n    }\n\n    public isBlank() {\n        return this.visible.isBlank() || this.full.isBlank();\n    }\n}\n","import isEqual from 'react-fast-compare';\nimport { DataSourceState } from '../../../../../../../types';\n\nexport const searchWasChanged = <TFilter, TId>(\n    prevValue?: DataSourceState<TFilter, TId>, newValue?: DataSourceState<TFilter, TId>,\n) => newValue?.search !== prevValue?.search;\n\nexport const sortingWasChanged = <TFilter, TId>(\n    prevValue?: DataSourceState<TFilter, TId>, newValue?: DataSourceState<TFilter, TId>,\n) => !isEqual(newValue?.sorting, prevValue?.sorting);\n\nexport const filterWasChanged = <TFilter, TId>(\n    prevValue: DataSourceState<TFilter, TId>, newValue?: DataSourceState<TFilter, TId>,\n) => !isEqual(newValue?.filter, prevValue?.filter);\n\nexport const isQueryChanged = <TFilter, TId>(prevValue: DataSourceState<TFilter, TId>, newValue: DataSourceState<TFilter, TId>) =>\n    searchWasChanged(prevValue, newValue)\n    || sortingWasChanged(prevValue, newValue)\n    || filterWasChanged(prevValue, newValue)\n    || newValue?.page !== prevValue?.page\n    || newValue?.pageSize !== prevValue?.pageSize;\n","import { useRef } from 'react';\nimport { DataSourceState } from '../../../../../../types';\n\ninterface UseDataSourceStateWithDefaults<TId, TFilter = any> {\n    dataSourceState: DataSourceState<TFilter, TId>;\n}\n\nconst getDataSourceStateWithDefaults = <TId, TFilter = any>(dataSourceState: DataSourceState<TFilter, TId>) =>\n    ((dataSourceState.topIndex === undefined || dataSourceState.visibleCount)\n        ? {\n            ...dataSourceState,\n            topIndex: dataSourceState.topIndex ?? 0,\n            visibleCount: dataSourceState.visibleCount ?? 20,\n        }\n        : dataSourceState);\n\nexport function useDataSourceStateWithDefaults<TId, TFilter = any>({ dataSourceState }: UseDataSourceStateWithDefaults<TId, TFilter>) {\n    const dataSourceStateRef = useRef(getDataSourceStateWithDefaults(dataSourceState));\n\n    dataSourceStateRef.current = getDataSourceStateWithDefaults(dataSourceState);\n\n    return dataSourceStateRef.current;\n}\n","import { IMap, LazyDataSourceApi } from '../../../../types';\nimport { ItemsMap } from './ItemsMap';\nimport { FAILED_RECORD, LOADED_RECORD, LOADING_RECORD, NOT_FOUND_RECORD, PENDING_RECORD } from './constants';\nimport { ITreeParams } from './exposed';\nimport { newMap } from './helpers';\nimport { RecordStatus } from './types';\n\ninterface OnStatusUpdateSubscribe<TId> {\n    (itemsStatusMap: IMap<TId, RecordStatus>): void;\n}\n\nexport class ItemsStatusCollector<TItem, TId, TFilter = any> {\n    private itemsStatusMap: IMap<TId, RecordStatus>;\n    private subscriptions: IMap<OnStatusUpdateSubscribe<TId>, undefined>;\n\n    constructor(\n        itemsStatusMap: IMap<TId, RecordStatus>,\n        private params: ITreeParams<TItem, TId>,\n    ) {\n        this.itemsStatusMap = itemsStatusMap ?? newMap(params);\n        this.subscriptions = newMap(params);\n    }\n\n    public setPending(ids: TId[]) {\n        this.setStatus(ids, PENDING_RECORD);\n    }\n\n    public setLoading(ids: TId[]) {\n        this.setStatus(ids, LOADING_RECORD);\n    }\n\n    public setLoaded(ids: TId[]) {\n        this.setStatus(ids, LOADED_RECORD);\n    }\n\n    public setFailed(ids: TId[]) {\n        this.setStatus(ids, FAILED_RECORD);\n    }\n\n    public setNotFound(ids: TId[]) {\n        this.setStatus(ids, NOT_FOUND_RECORD);\n    }\n\n    public withPending(ids: TId[]) {\n        ids.forEach((id) => {\n            this.itemsStatusMap.set(id, PENDING_RECORD);\n        });\n\n        return this;\n    }\n\n    public getItemStatus = (itemsMap: ItemsMap<TId, TItem>) => (id: TId) => {\n        if (itemsMap.has(id)) {\n            return LOADED_RECORD;\n        }\n\n        const status = this.itemsStatusMap.get(id) ?? NOT_FOUND_RECORD;\n        if (status === LOADED_RECORD) {\n            return LOADING_RECORD;\n        }\n\n        return status;\n    };\n\n    public watch(api: LazyDataSourceApi<TItem, TId, TFilter>): LazyDataSourceApi<TItem, TId, TFilter> {\n        return async (request, context) => {\n            if (request.ids) {\n                try {\n                    this.setLoading(request.ids);\n                    const result = await api(request, context);\n                    const loadedIds: Array<[TId, TId]> = (result.items ?? []).map((item) => {\n                        const id = this.params.getId(item);\n                        return [id, id];\n                    });\n\n                    this.setLoaded(loadedIds.map(([id]) => id));\n\n                    const loadedIdsMap = new Map<TId, TId>(loadedIds);\n                    const notLoadedIds = request.ids.filter((id) => !loadedIdsMap.has(id));\n\n                    this.setNotFound(notLoadedIds);\n\n                    return result;\n                } catch (e) {\n                    this.setFailed(request.ids);\n                    throw e;\n                }\n            }\n\n            return await api(request, context);\n        };\n    }\n\n    private setStatus(ids: TId[], status: RecordStatus) {\n        ids.forEach((id) => {\n            this.itemsStatusMap.set(id, status);\n        });\n\n        this.onUpdate();\n    }\n\n    private onUpdate() {\n        for (const [onSubscribe] of this.subscriptions) {\n            onSubscribe?.(this.itemsStatusMap);\n        }\n    }\n\n    public subscribe(onSubscribe: OnStatusUpdateSubscribe<TId>): (() => void) {\n        this.subscriptions = this.subscriptions.set(onSubscribe);\n        return () => this.subscriptions.delete(onSubscribe);\n    }\n}\n","import { useMemo } from 'react';\nimport { DataSourceState, IMap, PatchOptions } from '../../../../../../types';\nimport { RecordStatus } from '../../types';\nimport { ItemsStatusCollector } from '../../ItemsStatusCollector';\nimport { ITreeParams, getSelectedAndChecked } from '../../treeStructure';\n\nexport interface UseItemsStatusCollectorProps<TItem, TId, TFilter = any> extends ITreeParams<TItem, TId>, Pick<PatchOptions<TItem, TId>, 'patch'> {\n    itemsStatusMap?: IMap<TId, RecordStatus>;\n    itemsStatusCollector?: ItemsStatusCollector<TItem, TId, TFilter>;\n    dataSourceState: DataSourceState<TFilter, TId>;\n}\n\nexport function useItemsStatusCollector<TItem, TId>(\n    {\n        itemsStatusMap,\n        complexIds,\n        getId,\n        itemsStatusCollector,\n        dataSourceState,\n        patch,\n    }: UseItemsStatusCollectorProps<TItem, TId>,\n    deps: any[],\n) {\n    const statusCollector = useMemo(() => {\n        if (itemsStatusCollector) {\n            return itemsStatusCollector;\n        }\n\n        return new ItemsStatusCollector(itemsStatusMap, { complexIds, getId });\n    }, deps);\n\n    return useMemo(() => {\n        return statusCollector.withPending(getSelectedAndChecked(dataSourceState, patch));\n    }, [statusCollector]);\n}\n","import { useEffect, useMemo, useState } from 'react';\nimport { ItemsStorage } from '../../../..';\nimport { ItemsMapParams } from '../../ItemsMap';\nimport { SharedItemsState } from '../strategies/types';\n\nexport interface UseItemsStorageProps<TItem, TId> extends SharedItemsState<TItem, TId> {\n    items?: TItem[];\n    params: ItemsMapParams<TItem, TId>;\n}\n\nexport function useItemsStorage<TItem, TId>({ itemsMap: outerItemsMap, setItems, items, params }: UseItemsStorageProps<TItem, TId>) {\n    const itemsStorage = useMemo(() => {\n        if (!outerItemsMap) {\n            return new ItemsStorage({ items, params });\n        }\n        return null;\n    }, [outerItemsMap, items]);\n\n    const [itemsMap, setItemsMap] = useState(outerItemsMap ?? itemsStorage?.getItemsMap());\n\n    useEffect(() => {\n        if (itemsStorage) {\n            const unsubscribe = itemsStorage.subscribe(() => {\n                setItemsMap(itemsStorage.getItemsMap());\n            });\n\n            return () => {\n                unsubscribe();\n            };\n        }\n    }, []);\n\n    useEffect(() => {\n        if (Array.isArray(items)) {\n            if (itemsStorage) {\n                itemsStorage.setItems(items);\n            }\n            setItems?.(items);\n        }\n    }, [items]);\n\n    const currentItemsMap = outerItemsMap ?? itemsMap;\n    return {\n        itemsMap: currentItemsMap,\n        setItems: setItems ?? (itemsStorage?.setItems ?? currentItemsMap.setItems),\n    };\n}\n","import { NOT_FOUND_RECORD } from '../constants';\nimport { newMap } from './map';\nimport { DataSourceState, IImmutableMap, IMap, PatchOptions, SortConfig, SortedPatchByParentId } from '../../../../../types';\nimport { buildComparators, composeComparators } from '../helpers';\nimport { PatchOrdering } from '../constants';\nimport { ITree } from '../ITree';\n\nconst groupByParentId = <TItem, TId>(\n    patch: IMap<TId, TItem> | IImmutableMap<TId, TItem> | undefined,\n    getParentId?: (item: TItem) => TId,\n    complexIds?: boolean,\n): IMap<TId, TItem[]> => {\n    const patchByParentId = newMap<TId, TItem[]>({ complexIds });\n    if (!patch) {\n        return patchByParentId;\n    }\n\n    for (const [, item] of patch) {\n        const parentId = getParentId?.(item) ?? undefined;\n        if (!patchByParentId.has(parentId)) {\n            patchByParentId.set(parentId, []);\n        }\n        const prevItems = patchByParentId.get(parentId);\n        patchByParentId.set(parentId, [...prevItems, item]);\n    }\n    return patchByParentId;\n};\n\nconst getPatchByCategories = <TItem, TId>(\n    items: TItem[],\n    tree: ITree<TItem, TId>,\n    patchAtLastSort: IMap<TId, TItem> | IImmutableMap<TId, TItem>,\n    getNewItemPosition: PatchOptions<TItem, TId>['getNewItemPosition'],\n    getItemTemporaryOrder: PatchOptions<TItem, TId>['getItemTemporaryOrder'] | undefined,\n    isDeleted: undefined | ((item: TItem) => boolean),\n    fixItemBetweenSortings?: boolean,\n) => {\n    const { getId, getParentId, complexIds } = tree.getParams();\n    const top: TId[] = [];\n    const bottom: TId[] = [];\n    const updated: TId[] = [];\n    const movedToOtherParent: TId[] = [];\n    const updatedItemsMap: IMap<TId, TItem> = newMap({ complexIds });\n    const newItems: TItem[] = [];\n    const withTempOrder: TId[] = [];\n\n    for (const item of items) {\n        const id = getId(item);\n        const itemInOriginalTree = tree.getById(id) !== NOT_FOUND_RECORD;\n        const itemInPatchBeforeSort = patchAtLastSort.has(id);\n        updatedItemsMap.set(id, item);\n        newItems.push(item);\n        const tempOrder = getItemTemporaryOrder?.(item);\n        const prevItem = patchAtLastSort.get(id) ?? tree.getById(id) as TItem;\n        const prevParentId = getParentId?.(prevItem) ?? undefined;\n        const newParentId = getParentId?.(item) ?? undefined;\n        if (!fixItemBetweenSortings) {\n            const realPrevItem = tree.getById(id) as TItem;\n            if (realPrevItem !== NOT_FOUND_RECORD) {\n                const realPrevParentId = getParentId?.(realPrevItem) ?? undefined;\n                if (realPrevParentId !== newParentId) {\n                    movedToOtherParent.push(id);\n                }\n            }\n        } else if (prevParentId !== newParentId) {\n            movedToOtherParent.push(id);\n        }\n\n        if (tempOrder) {\n            if (isDeleted?.(item)) {\n                continue;\n            }\n            withTempOrder.push(id);\n            continue;\n        }\n\n        if (!itemInPatchBeforeSort && !itemInOriginalTree) {\n            const position = getNewItemPosition(item);\n\n            if (isDeleted?.(item)) {\n                continue;\n            }\n\n            if (position === PatchOrdering.BOTTOM) {\n                bottom.push(id);\n            } else {\n                top.unshift(id);\n            }\n            continue;\n        }\n\n        if (prevParentId !== newParentId) {\n            const position = getNewItemPosition(item);\n            if (position === PatchOrdering.BOTTOM) {\n                bottom.push(id);\n            } else {\n                top.unshift(id);\n            }\n\n            continue;\n        }\n\n        updated.push(id);\n    }\n\n    return { top, bottom, movedToOtherParent, updated, withTempOrder, updatedItemsMap, newItems };\n};\n\nconst sortUpdatedItems = <TItem, TId>(\n    updated: TId[],\n    composedComparator: (a: TItem, b: TItem) => number,\n    tree: ITree<TItem, TId>,\n    patchAtLastSort: IMap<TId, TItem> | IImmutableMap<TId, TItem>,\n) => {\n    return updated.sort((aId, bId) => {\n        const bItem = patchAtLastSort.get(bId) ?? tree.getById(bId) as TItem;\n        const aItem = patchAtLastSort.get(aId) ?? tree.getById(aId) as TItem;\n\n        return composedComparator(aItem, bItem);\n    });\n};\n\nconst sortByTemporaryOrder = <TItem, TId>(\n    withTempOrder: TId[],\n    getItemTemporaryOrder: PatchOptions<TItem, TId>['getItemTemporaryOrder'] | undefined,\n    updatedItemsMap: IMap<TId, TItem>,\n) => {\n    const comparator = (a: string, b: string) => a < b ? -1 : 1;\n    return withTempOrder.sort((aId, bId) => {\n        const a = updatedItemsMap.get(aId);\n        const b = updatedItemsMap.get(bId);\n        return comparator(getItemTemporaryOrder(a), getItemTemporaryOrder((b)));\n    });\n};\n\nconst sortPatchByParentId = <TItem, TId, TFilter>(\n    tree: ITree<TItem, TId>,\n    groupedByParentId: IMap<TId, TItem[]>,\n    getNewItemPosition: PatchOptions<TItem, TId>['getNewItemPosition'],\n    getItemTemporaryOrder: PatchOptions<TItem, TId>['getItemTemporaryOrder'] | undefined,\n    patchAtLastSort: IMap<TId, TItem> | IImmutableMap<TId, TItem>,\n    sortBy: SortConfig<TItem>['sortBy'],\n    sorting: DataSourceState<TFilter, TId>['sorting'],\n    isDeleted: undefined | ((item: TItem) => boolean),\n    fixItemBetweenSortings?: boolean,\n) => {\n    const { complexIds } = tree.getParams();\n    const comparators = buildComparators({ sorting, sortBy, getId: tree.getParams().getId });\n    const composedComparator = composeComparators(comparators, tree.getParams().getId);\n\n    const sorted: SortedPatchByParentId<TItem, TId> = newMap({ complexIds });\n    for (const [parentId, items] of groupedByParentId) {\n        const { top, bottom, updated, movedToOtherParent, withTempOrder, updatedItemsMap, newItems } = getPatchByCategories(\n            items,\n            tree,\n            patchAtLastSort,\n            getNewItemPosition,\n            getItemTemporaryOrder,\n            isDeleted,\n            fixItemBetweenSortings,\n        );\n\n        const sortedUpdated = sortUpdatedItems(updated, composedComparator, tree, patchAtLastSort);\n        const sortedByTempOrder = sortByTemporaryOrder(withTempOrder, getItemTemporaryOrder, updatedItemsMap);\n\n        sorted.set(parentId, {\n            top,\n            bottom,\n            updated: sortedUpdated,\n            moved: movedToOtherParent,\n            withTempOrder: sortedByTempOrder,\n            updatedItemsMap,\n            newItems,\n        });\n    }\n    return sorted;\n};\n\nexport const getSortedPatchByParentId = <TItem, TId, TFilter>(\n    tree: ITree<TItem, TId>,\n    patch: IMap<TId, TItem> | IImmutableMap<TId, TItem>,\n    patchAtLastSort: IMap<TId, TItem> | IImmutableMap<TId, TItem>,\n    getNewItemPosition: PatchOptions<TItem, TId>['getNewItemPosition'],\n    getItemTemporaryOrder: PatchOptions<TItem, TId>['getItemTemporaryOrder'] | undefined,\n    sortBy: SortConfig<TItem>['sortBy'],\n    sorting: DataSourceState<TFilter, TId>['sorting'],\n    isDeleted?: (item: TItem) => boolean,\n    fixItemBetweenSortings?: boolean,\n) => {\n    const params = tree.getParams();\n    const grouped = groupByParentId(patch, params.getParentId, params.complexIds);\n    return sortPatchByParentId(tree, grouped, getNewItemPosition, getItemTemporaryOrder, patchAtLastSort, sortBy, sorting, isDeleted, fixItemBetweenSortings);\n};\n","import { useCallback, useMemo } from 'react';\nimport { newMap } from '../../helpers';\nimport { DataSourceState, IImmutableMap, IMap, PatchOptions } from '../../../../../../types';\nimport { PatchOrdering } from '../../constants';\nimport { usePrevious } from '../../../../../../hooks/usePrevious';\nimport { getSortedPatchByParentId } from '../../helpers/patch';\nimport { TreeState } from '../../treeState';\n\nexport interface UsePatchTreeProps<TItem, TId, TFilter = any> extends PatchOptions<TItem, TId> {\n    tree: TreeState<TItem, TId>;\n    sorting: DataSourceState<TFilter, TId>['sorting'];\n\n}\n\nexport function usePatchTree<TItem, TId, TFilter = any>(\n    {\n        tree,\n        patch,\n        getNewItemPosition = () => PatchOrdering.TOP,\n        getItemTemporaryOrder,\n        fixItemBetweenSortings = true,\n        isDeleted,\n        sorting,\n        sortBy,\n    }: UsePatchTreeProps<TItem, TId, TFilter>,\n) {\n    const prevPatch = usePrevious(patch);\n    const params = tree.visible.getParams();\n\n    const patchAtLastSort = useMemo(() => {\n        return prevPatch === null ? newMap<TId, TItem>({ complexIds: params.complexIds }) : patch;\n    }, [sorting]);\n\n    const sortedPatch = useMemo(\n        () => getSortedPatchByParentId(\n            tree.visible,\n            patch,\n            fixItemBetweenSortings ? patchAtLastSort : patch,\n            getNewItemPosition,\n            getItemTemporaryOrder,\n            sortBy,\n            sorting,\n            isDeleted,\n            fixItemBetweenSortings,\n        ),\n        [patch, sorting, fixItemBetweenSortings],\n    );\n    const patchedTree = useMemo(() => {\n        return tree.patch({\n            sortedPatch,\n            patchAtLastSort: fixItemBetweenSortings ? patchAtLastSort : patch,\n            getItemTemporaryOrder,\n            isDeleted,\n            sorting,\n            sortBy,\n            ...tree.visible.getParams(),\n        });\n    }, [tree, patch]);\n\n    const applyPatch = useCallback((updated: IMap<TId, TItem> | IImmutableMap<TId, TItem>) => {\n        const patchAfterSort = getSortedPatchByParentId(\n            tree.visible,\n            updated,\n            fixItemBetweenSortings ? patchAtLastSort : updated,\n            getNewItemPosition,\n            getItemTemporaryOrder,\n            sortBy,\n            sorting,\n            isDeleted,\n            fixItemBetweenSortings,\n        );\n\n        return tree.patch({\n            sortedPatch: patchAfterSort,\n            patchAtLastSort: fixItemBetweenSortings ? patchAtLastSort : updated,\n            getItemTemporaryOrder,\n            isDeleted,\n            sorting,\n            sortBy,\n            ...tree.visible.getParams(),\n        }).visible;\n    }, [tree, sorting, fixItemBetweenSortings]);\n\n    return { tree: patchedTree, applyPatch };\n}\n","import isEqual from 'react-fast-compare';\nimport { DataSourceState } from '../../../../../../types';\n\nexport const isSelectedOrCheckedChanged = (dataSourceState: DataSourceState, prevDataSourceState: DataSourceState) => {\n    return (\n        dataSourceState.checked?.length && !isEqual(prevDataSourceState?.checked, dataSourceState.checked)\n    ) || (dataSourceState.selectedId !== null\n        && dataSourceState.selectedId !== undefined\n        && dataSourceState.selectedId !== prevDataSourceState?.selectedId);\n};\n\nexport const getChecked = (dataSourceState: DataSourceState) => {\n    if (dataSourceState.checked !== null) {\n        return dataSourceState.checked;\n    }\n\n    if (dataSourceState.selectedId !== null && dataSourceState.selectedId !== undefined) {\n        return [dataSourceState.selectedId];\n    }\n    return [];\n};\n","import { usePrevious } from '../../../../../../hooks/usePrevious';\n\nexport function useDepsChanged(deps: any[]) {\n    const prevDeps = usePrevious(deps);\n    const isDepsChanged = prevDeps?.length !== deps.length\n        || (prevDeps ?? []).some((devVal, index) => devVal !== deps[index]);\n\n    return isDepsChanged;\n}\n","import { useMemo, useRef } from 'react';\nimport { TreeState } from '../../treeState';\nimport { usePrevious } from '../../../../../../hooks/usePrevious';\nimport { useDepsChanged } from './useDepsChanged';\n\nexport interface UseUpdateTreeStateProps<TItem, TId> {\n    tree: TreeState<TItem, TId>;\n    shouldUpdate: () => boolean;\n    update: (tree: TreeState<TItem, TId>) => TreeState<TItem, TId>;\n}\n\nexport function useUpdateTreeState<TItem, TId>(\n    {\n        tree,\n        shouldUpdate,\n        update,\n    }: UseUpdateTreeStateProps<TItem, TId>,\n    deps: any[],\n) {\n    const treeRef = useRef<TreeState<TItem, TId>>(null);\n    const prevTree = usePrevious(tree);\n    const depsChanged = useDepsChanged(deps);\n\n    const updatedTree = useMemo(() => {\n        if (treeRef.current === null || prevTree !== tree || shouldUpdate() || depsChanged) {\n            treeRef.current = update(tree);\n        }\n        return treeRef.current;\n    }, [tree, depsChanged, ...deps]);\n\n    return updatedTree;\n}\n","import { usePrevious } from '../../../../../../hooks/usePrevious';\nimport { DataSourceState } from '../../../../../../types';\nimport { TreeState } from '../../treeState';\nimport { getChecked, isSelectedOrCheckedChanged } from '../strategies/checked';\nimport { useUpdateTreeState } from './useUpdateTreeState';\n\nexport type UseSelectedOnlyTreeProps<TItem, TId, TFilter = any> = {\n    tree: TreeState<TItem, TId>;\n    dataSourceState: DataSourceState<TFilter, TId>;\n};\n\nexport function useSelectedOnlyTree<TItem, TId, TFilter = any>(\n    { tree, dataSourceState }: UseSelectedOnlyTreeProps<TItem, TId, TFilter>,\n    deps: any[],\n) {\n    const prevDataSourceState = usePrevious(dataSourceState);\n\n    const selectedOnlyTree = useUpdateTreeState({\n        tree,\n        shouldUpdate: () => isSelectedOrCheckedChanged(dataSourceState, prevDataSourceState),\n        update: (currentTree) => currentTree.buildSelectedOnly(getChecked(dataSourceState)),\n    }, [dataSourceState.checked, dataSourceState.selectedId, ...deps]);\n\n    return selectedOnlyTree;\n}\n","import { usePrevious } from '../../../../../../hooks/usePrevious';\nimport { DataSourceState } from '../../../../../../types';\nimport { TreeState } from '../../treeState';\nimport { useUpdateTreeState } from './useUpdateTreeState';\n\nexport type UseSearchTreeStateProps<TItem, TId, TFilter = any> = {\n    getSearchFields?: (item: TItem) => string[];\n    sortSearchByRelevance?: boolean;\n    tree: TreeState<TItem, TId>;\n    dataSourceState: DataSourceState<TFilter, TId>;\n};\n\nexport function useSearchTreeState<TItem, TId, TFilter = any>(\n    {\n        tree,\n        dataSourceState: { search },\n        getSearchFields,\n        sortSearchByRelevance,\n    }: UseSearchTreeStateProps<TItem, TId, TFilter>,\n    deps: any[] = [],\n) {\n    const prevSearch = usePrevious(search);\n\n    const searchTree = useUpdateTreeState({\n        tree,\n        shouldUpdate: () => !tree.isBlank() && search !== prevSearch,\n        update: (currentTree) => currentTree.search({ search, getSearchFields, sortSearchByRelevance }),\n    }, [search, ...deps]);\n\n    if (tree === null || tree.isBlank()) {\n        return tree;\n    }\n\n    return searchTree;\n}\n","import { useMemo, useRef } from 'react';\nimport { usePrevious } from '../../../../../../hooks/usePrevious';\nimport { useDepsChanged } from './useDepsChanged';\nimport { ITree } from '../../ITree';\n\nexport interface UseUpdateTreeProps<TItem, TId> {\n    tree: ITree<TItem, TId>;\n    shouldUpdate: () => boolean;\n    update: (tree: ITree<TItem, TId>) => ITree<TItem, TId>;\n}\n\nexport function useUpdateTree<TItem, TId>(\n    {\n        tree,\n        shouldUpdate,\n        update,\n    }: UseUpdateTreeProps<TItem, TId>,\n    deps: any[],\n) {\n    const treeRef = useRef<ITree<TItem, TId>>(null);\n    const prevTree = usePrevious(tree);\n    const depsChanged = useDepsChanged(deps);\n\n    const updatedTree = useMemo(() => {\n        if (treeRef.current === null || prevTree !== tree || shouldUpdate() || depsChanged) {\n            treeRef.current = update(tree);\n        }\n        return treeRef.current;\n    }, [tree, depsChanged, ...deps]);\n\n    return updatedTree;\n}\n","import { usePrevious } from '../../../../../../hooks/usePrevious';\nimport { DataSourceState, SearchConfig } from '../../../../../../types';\nimport { ITree } from '../../ITree';\nimport { SearchHelper } from '../../treeStructure';\nimport { CreateTreeInstance } from '../../treeStructure/helpers/types';\nimport { useUpdateTree } from './useUpdateTree';\n\n/**\n * Search tree hook props.\n */\nexport interface UseSearchTreeProps<TItem, TId, TFilter = any> extends SearchConfig<TItem>, CreateTreeInstance<TItem, TId> {\n    /**\n     * Tree with data.\n     */\n    tree: ITree<TItem, TId>;\n    /**\n     * State of the dataSource.\n     */\n    dataSourceState: DataSourceState<TFilter, TId>;\n    /**\n     * Are data loading.\n     */\n    isLoading?: boolean;\n}\n\n/**\n * Search tree by criteria.\n * @returns tree with search-matching records.\n */\nexport function useSearchTree<TItem, TId, TFilter = any>(\n    {\n        tree,\n        newTreeInstance,\n        dataSourceState: { search },\n        getSearchFields,\n        sortSearchByRelevance,\n    }: UseSearchTreeProps<TItem, TId, TFilter>,\n    deps: any[] = [],\n) {\n    const prevSearch = usePrevious(search);\n\n    const searchTree = useUpdateTree({\n        tree,\n        shouldUpdate: () => !tree.isBlank() && search !== prevSearch,\n        update: (currentTree) => SearchHelper.search({\n            tree: currentTree,\n            newTreeInstance,\n            search,\n            getSearchFields,\n            sortSearchByRelevance,\n        }),\n    }, [search, ...deps]);\n\n    if (tree === null || tree.isBlank()) {\n        return tree;\n    }\n\n    return searchTree;\n}\n","import { usePrevious } from '../../../../../../hooks/usePrevious';\nimport { DataSourceState, SortingOption } from '../../../../../../types';\nimport { TreeState } from '../../treeState';\nimport { useUpdateTreeState } from './useUpdateTreeState';\n\nexport type UseSortTreeStateProps<TItem, TId, TFilter = any> = {\n    sortBy?(item: TItem, sorting: SortingOption): any;\n    tree: TreeState<TItem, TId>;\n    dataSourceState: DataSourceState<TFilter, TId>;\n};\n\nexport function useSortTreeState<TItem, TId, TFilter = any>(\n    {\n        tree,\n        dataSourceState: { sorting },\n        sortBy,\n    }: UseSortTreeStateProps<TItem, TId, TFilter>,\n    deps: any[],\n): TreeState<TItem, TId> {\n    const prevSorting = usePrevious(sorting);\n\n    const sortTree = useUpdateTreeState({\n        tree,\n        shouldUpdate: () => !tree.isBlank() && sorting !== prevSorting,\n        update: (currentTree) => currentTree.sort({ sorting, sortBy }),\n    }, [sorting, ...deps]);\n\n    if (tree === null || tree.isBlank()) {\n        return tree;\n    }\n\n    return sortTree;\n}\n","import { usePrevious } from '../../../../../../hooks/usePrevious';\nimport { DataSourceState, SortConfig } from '../../../../../../types';\nimport { ITree } from '../../ITree';\nimport { SortHelper } from '../../treeStructure';\nimport { CreateTreeInstance } from '../../treeStructure/helpers/types';\nimport { useUpdateTree } from './useUpdateTree';\n\n/**\n * Sort tree hook props.\n */\nexport interface UseSortTreeProps<TItem, TId, TFilter = any> extends SortConfig<TItem>, CreateTreeInstance<TItem, TId> {\n    /**\n     * Tree with data.\n     */\n    tree: ITree<TItem, TId>;\n    /**\n     * State of the dataSource.\n     */\n    dataSourceState: DataSourceState<TFilter, TId>;\n    /**\n     * Are data loading.\n     */\n    isLoading?: boolean;\n}\n\n/**\n * Sorts tree by criteria.\n * @returns tree with sorted records.\n */\nexport function useSortTree<TItem, TId, TFilter = any>(\n    {\n        tree,\n        dataSourceState: { sorting },\n        sortBy,\n        newTreeInstance,\n    }: UseSortTreeProps<TItem, TId, TFilter>,\n    deps: any[],\n): ITree<TItem, TId> {\n    const prevSorting = usePrevious(sorting);\n\n    const sortTree = useUpdateTree({\n        tree,\n        shouldUpdate: () => !tree.isBlank() && sorting !== prevSorting,\n        update: (currentTree) => SortHelper.sort({ tree: currentTree, sorting, sortBy, newTreeInstance }),\n    }, [sorting, ...deps]);\n\n    if (tree === null || tree.isBlank()) {\n        return tree;\n    }\n\n    return sortTree;\n}\n","import { usePrevious } from '../../../../../../hooks/usePrevious';\nimport { DataSourceState, FilterConfig } from '../../../../../../types';\nimport { ITree } from '../../ITree';\nimport { FilterHelper } from '../../treeStructure';\nimport { CreateTreeInstance } from '../../treeStructure/helpers/types';\nimport { useUpdateTree } from './useUpdateTree';\n\n/**\n * Filter tree hook props.\n */\nexport interface UseFilterTreeProps<TItem, TId, TFilter = any> extends FilterConfig<TItem, TFilter>, CreateTreeInstance<TItem, TId> {\n    /**\n     * Tree with data.\n     */\n    tree: ITree<TItem, TId>;\n    /**\n     * State of the dataSource.\n     */\n    dataSourceState: DataSourceState<TFilter, TId>;\n}\n\n/**\n * Filters tree by criteria.\n * @returns tree without filtered records.\n */\nexport function useFilterTree<TItem, TId, TFilter = any>(\n    { tree, newTreeInstance, dataSourceState: { filter }, getFilter }: UseFilterTreeProps<TItem, TId, TFilter>,\n    deps: any[],\n) {\n    const prevFilter = usePrevious(filter);\n    const filteredTree = useUpdateTree({\n        tree,\n        shouldUpdate: () => !tree.isBlank() && filter !== prevFilter,\n        update: (currentTree) => FilterHelper.filter({ tree: currentTree, filter, getFilter, newTreeInstance }),\n    }, [filter, ...deps]);\n\n    if (tree === null || tree.isBlank()) {\n        return tree;\n    }\n\n    return filteredTree;\n}\n","import { usePrevious } from '../../../../../../hooks/usePrevious';\nimport { DataSourceState } from '../../../../../../types';\nimport { TreeState } from '../../treeState';\nimport { useUpdateTreeState } from './useUpdateTreeState';\n\nexport type UseFilterTreeStateProps<TItem, TId, TFilter = any> = {\n    getFilter?: (filter: TFilter) => (item: TItem) => boolean;\n    tree: TreeState<TItem, TId>;\n    dataSourceState: DataSourceState<TFilter, TId>;\n};\n\nexport function useFilterTreeState<TItem, TId, TFilter = any>(\n    { tree, dataSourceState: { filter }, getFilter }: UseFilterTreeStateProps<TItem, TId, TFilter>,\n    deps: any[],\n) {\n    const prevFilter = usePrevious(filter);\n    const filteredTree = useUpdateTreeState({\n        tree,\n        shouldUpdate: () => filter !== prevFilter,\n        update: (currentTree) => currentTree.filter({ filter, getFilter }),\n    }, [filter, ...deps]);\n\n    if (tree === null || tree.isBlank()) {\n        return tree;\n    }\n\n    return filteredTree;\n}\n","import { useMemo } from 'react';\nimport { ItemsMap } from '../../ItemsMap';\nimport { TreeState } from '../../treeState';\nimport { ItemsStorage } from '../../ItemsStorage';\n\ninterface UseActualItemsStorageProps<TItem, TId> {\n    tree: TreeState<TItem, TId>;\n    itemsMap: ItemsMap<TId, TItem>;\n    setItems: ItemsStorage<TItem, TId>['setItems'];\n}\n\nexport function useActualItemsStorage<TItem, TId>({\n    tree, itemsMap, setItems,\n}: UseActualItemsStorageProps<TItem, TId>) {\n    return useMemo(() => {\n        const updatedTree = tree.updateSetItems(setItems);\n        // if clear cache was executed, itemsMap should not be rewritten.\n        if (!itemsMap.size) {\n            return updatedTree;\n        }\n\n        return updatedTree.updateItemsMap(itemsMap);\n    }, [tree, itemsMap, setItems]);\n}\n","import { useCallback, useEffect, useRef } from 'react';\n\nexport const useAbortController = () => {\n    const abortControllerRef = useRef<AbortController>(null);\n\n    const getAbortSignal = useCallback(() => {\n        if (!abortControllerRef.current || abortControllerRef.current.signal.aborted) {\n            abortControllerRef.current = new AbortController();\n        }\n\n        return abortControllerRef.current.signal;\n    }, [abortControllerRef.current]);\n\n    useEffect(() => {\n        if (!abortControllerRef.current || abortControllerRef.current.signal.aborted) {\n            abortControllerRef.current = new AbortController();\n        }\n\n        return () => {\n            if (abortControllerRef.current && !abortControllerRef.current.signal.aborted) {\n                abortControllerRef.current.abort();\n            }\n        };\n    }, []);\n\n    return { getAbortSignal };\n};\n","import { useEffect, useState } from 'react';\nimport { DataSourceState, IImmutableMap, IMap, LazyDataSourceApi } from '../../../../../../../types';\nimport { TreeState } from '../../../treeState';\nimport { usePrevious } from '../../../../../../../hooks/usePrevious';\nimport { isQueryChanged } from '../lazyTree/helpers';\nimport { useAbortController, useItemsStatusCollector } from '../../common';\nimport { getSelectedAndChecked } from '../../../treeStructure';\nimport { NOT_FOUND_RECORD } from '../../../constants';\nimport { ItemsStatuses } from '../types';\n\nexport interface LoadResult<TItem, TId> {\n    isUpdated: boolean;\n    isOutdated: boolean;\n    tree: TreeState<TItem, TId>;\n    error?: Error;\n}\n\nexport interface UseLoadDataProps<TItem, TId, TFilter = any> extends ItemsStatuses<TItem, TId, TFilter> {\n    tree: TreeState<TItem, TId>;\n    api: LazyDataSourceApi<TItem, TId, TFilter>;\n    dataSourceState?: DataSourceState<TFilter, TId>;\n    forceReload?: boolean;\n    showSelectedOnly?: boolean;\n    complexIds?: boolean;\n    getId: (item: TItem) => TId;\n    isLoaded?: boolean;\n    onForceReloadComplete?: () => void;\n    patch?: IMap<TId, TItem> | IImmutableMap<TId, TItem>;\n}\n\nexport function useLoadData<TItem, TId, TFilter = any>(\n    {\n        tree, api, dataSourceState, showSelectedOnly, isLoaded: isPrevouslyLoaded,\n        complexIds, getId, onForceReloadComplete, forceReload, patch,\n        itemsStatusCollector: externalItemsStatusCollector, itemsStatusMap,\n    }: UseLoadDataProps<TItem, TId, TFilter>,\n    deps: any[],\n) {\n    const prevDataSourceState = usePrevious(dataSourceState);\n    const prevForceReload = usePrevious(forceReload);\n\n    const [loadedTree, setLoadedTree] = useState(tree);\n    const [isLoaded, setIsLoaded] = useState(isPrevouslyLoaded);\n    const [isLoading, setIsLoading] = useState(false);\n    const [isFetching, setIsFetching] = useState(false);\n\n    const itemsStatusCollector = useItemsStatusCollector(\n        {\n            itemsStatusMap,\n            complexIds,\n            getId,\n            itemsStatusCollector: externalItemsStatusCollector,\n            dataSourceState,\n            patch,\n        },\n        [itemsStatusMap, externalItemsStatusCollector],\n    );\n\n    const { getAbortSignal } = useAbortController();\n\n    const loadData = async (\n        sourceTree: TreeState<TItem, TId>,\n        dsState: DataSourceState<TFilter, TId> = {},\n    ): Promise<LoadResult<TItem, TId>> => {\n        const loadingTree = sourceTree;\n        const { checked, ...partialDsState } = dsState;\n        try {\n            const signal = getAbortSignal();\n\n            const newTreePromise = sourceTree.loadAll<TFilter>({\n                using: partialDsState.search ? 'visible' : undefined,\n                options: {\n                    api: itemsStatusCollector.watch(api),\n                    filter: {\n                        ...dsState?.filter,\n                    },\n                    signal,\n                },\n                dataSourceState: partialDsState,\n            });\n\n            const newTree = await newTreePromise;\n            const linkToTree = sourceTree;\n\n            // If tree is changed during this load, than there was reset occurred (new value arrived)\n            // We need to tell caller to reject this result\n            const isOutdated = linkToTree !== loadingTree;\n            const isUpdated = linkToTree !== newTree;\n            return { isUpdated, isOutdated, tree: newTree };\n        } catch (e) {\n            // TBD - correct error handling\n            console.error('useLoadData: Error while loading items.', e);\n            return { isUpdated: false, isOutdated: false, tree: loadingTree, error: e };\n        }\n    };\n\n    const shouldForceReload = prevForceReload !== forceReload && forceReload;\n\n    const shouldLoad = (\n        !isFetching\n        && !isLoaded\n        && (!showSelectedOnly || (showSelectedOnly && getSelectedAndChecked(dataSourceState, patch).length))\n    )\n    || forceReload;\n\n    useEffect(() => {\n        if (shouldForceReload) {\n            setLoadedTree(tree);\n        }\n    }, [shouldForceReload]);\n\n    useEffect(() => {\n        if (isLoaded) {\n            setIsLoaded(false);\n        }\n    }, [...deps]);\n\n    useEffect(() => {\n        if (shouldLoad) {\n            setIsFetching(true);\n            if (!isQueryChanged(prevDataSourceState, dataSourceState)) {\n                setIsLoading(true);\n            }\n            const checked = getSelectedAndChecked(dataSourceState, patch);\n\n            loadData(tree, dataSourceState)\n                .then(({ isOutdated, isUpdated, tree: newTree }) => {\n                    if (isUpdated && !isOutdated) {\n                        setLoadedTree(newTree);\n\n                        const notLoaded = checked.filter((id) => newTree.getById(id) === NOT_FOUND_RECORD);\n                        itemsStatusCollector.setNotFound(notLoaded);\n                        if (forceReload) {\n                            onForceReloadComplete();\n                        }\n                    }\n                })\n                .catch((e) => {\n                    itemsStatusCollector.setFailed(checked);\n                    throw e;\n                })\n                .finally(() => {\n                    setIsLoaded(true);\n                    setIsFetching(false);\n                    setIsLoading(false);\n                });\n        }\n    }, [...deps, shouldLoad, shouldForceReload]);\n\n    return { tree: loadedTree, isLoading, isFetching, isLoaded, itemsStatusCollector };\n}\n","import { useCallback, useEffect, useMemo, useState } from 'react';\nimport { TreeState } from '../../../treeState';\nimport { AsyncTreeProps } from './types';\nimport { useLoadData } from './useLoadData';\nimport { usePrevious } from '../../../../../../../hooks/usePrevious';\nimport {\n    useItemsStorage, useDataSourceStateWithDefaults, useSortTreeState,\n    useSearchTreeState, useSelectedOnlyTree, usePatchTree,\n    useActualItemsStorage,\n    useFilterTreeState,\n} from '../../common';\nimport { UseTreeResult } from '../../types';\n\nexport function useAsyncTree<TItem, TId, TFilter = any>(\n    props: AsyncTreeProps<TItem, TId, TFilter>,\n    deps: [],\n): UseTreeResult<TItem, TId, TFilter> {\n    const {\n        getId,\n        complexIds,\n        getParentId,\n        getFilter,\n        getSearchFields,\n        sortBy,\n        sortSearchByRelevance = true,\n        rowOptions,\n        getRowOptions,\n        setDataSourceState,\n        isFoldedByDefault,\n        cascadeSelection,\n        showSelectedOnly,\n        patch,\n        isDeleted,\n        getNewItemPosition,\n        itemsStatusMap,\n        selectAll,\n        isLoaded,\n        getItemTemporaryOrder,\n        fixItemBetweenSortings,\n    } = props;\n\n    const { itemsMap, setItems } = useItemsStorage({\n        itemsMap: props.itemsMap,\n        setItems: props.setItems,\n        params: { getId, complexIds },\n    });\n\n    const [isForceReload, setIsForceReload] = useState(false);\n\n    const baseTree = useMemo(() => {\n        if (isLoaded) {\n            return TreeState.createFromItemsMap(itemsMap, setItems, { getId, getParentId, complexIds });\n        }\n        return TreeState.blank({ getId, getParentId, complexIds }, itemsMap, setItems);\n    }, [...deps, isLoaded]);\n\n    const [incommingTree, setIncommingTree] = useState(baseTree);\n\n    const prevIsForceReload = usePrevious(isForceReload);\n    const dataSourceState = useDataSourceStateWithDefaults({ dataSourceState: props.dataSourceState });\n\n    useEffect(() => {\n        setIncommingTree(baseTree);\n    }, [baseTree]);\n\n    const { tree: treeWithData, itemsStatusCollector, isLoading, isFetching } = useLoadData({\n        getId,\n        complexIds,\n        api: (_, options) => props.api(options).then((items) => ({ items })),\n        tree: incommingTree,\n        dataSourceState: {\n            visibleCount: dataSourceState.visibleCount,\n            topIndex: dataSourceState.topIndex,\n            checked: dataSourceState.checked,\n            selectedId: dataSourceState.selectedId,\n        },\n        itemsStatusCollector: props.itemsStatusCollector,\n        forceReload: isForceReload,\n        onForceReloadComplete: () => setIsForceReload(false),\n        showSelectedOnly,\n        isLoaded,\n        itemsStatusMap,\n    }, [...deps, isForceReload, incommingTree]);\n\n    const actualTree = useActualItemsStorage({ tree: treeWithData, itemsMap, setItems });\n\n    const prevIsFetching = usePrevious(isFetching);\n\n    useEffect(() => {\n        if (prevIsForceReload !== isForceReload && isForceReload\n                && prevIsFetching !== isFetching && !isFetching) {\n            setIsForceReload(false);\n        }\n    }, [actualTree]);\n\n    const reload = useCallback(() => {\n        setIncommingTree(TreeState.blank({ getId, getParentId, complexIds }, itemsMap, setItems));\n        setIsForceReload(true);\n    }, [setIsForceReload]);\n\n    const filteredTree = useFilterTreeState(\n        { tree: actualTree, getFilter, dataSourceState },\n        [actualTree],\n    );\n\n    const sortTree = useSortTreeState(\n        { tree: filteredTree, sortBy, dataSourceState },\n        [filteredTree],\n    );\n\n    const searchTree = useSearchTreeState(\n        {\n            tree: sortTree,\n            getSearchFields,\n            sortSearchByRelevance,\n            dataSourceState,\n        },\n        [sortTree],\n    );\n\n    const treeWithSelectedOnly = useSelectedOnlyTree({\n        tree: searchTree,\n        dataSourceState,\n    }, [searchTree]);\n\n    const treeWithNewItemsMap = useActualItemsStorage({\n        tree: treeWithSelectedOnly,\n        itemsMap,\n        setItems,\n    });\n\n    const { tree, applyPatch } = usePatchTree({\n        tree: treeWithNewItemsMap,\n        patch: showSelectedOnly ? null : patch,\n        isDeleted,\n        getNewItemPosition,\n        getItemTemporaryOrder,\n        fixItemBetweenSortings,\n        sorting: dataSourceState.sorting,\n        sortBy,\n    });\n\n    const totalCount = useMemo(() => {\n        const { totalCount: rootTotalCount } = tree.visible.getItems(undefined);\n\n        return rootTotalCount ?? tree.visible.getTotalCount?.() ?? 0;\n    }, [tree.visible]);\n\n    return {\n        tree: showSelectedOnly ? tree.selectedOnly : tree.visible,\n        treeWithoutPatch: treeWithNewItemsMap.visible,\n        selectionTree: tree.full,\n        reload,\n        totalCount,\n        getItemStatus: itemsStatusCollector.getItemStatus(itemsMap),\n        rowOptions,\n        getRowOptions,\n        getParentId,\n        getId,\n        dataSourceState,\n        setDataSourceState,\n        isFoldedByDefault,\n        cascadeSelection,\n        showSelectedOnly,\n        selectAll,\n        applyPatch,\n\n        isLoading,\n        isFetching,\n    };\n}\n","import { useCallback, useRef } from 'react';\nimport { CascadeSelectionTypes, DataSourceState, LazyDataSourceApi } from '../../../../../../../types';\nimport isEqual from 'react-fast-compare';\nimport { TreeState } from '../../../treeState';\nimport { Tree } from '../../../Tree';\nimport { LazyTreeProps } from './types';\nimport { CommonTreeConfig } from '../types';\nimport { ROOT_ID } from '../../../constants';\nimport { LoadAllConfig, TreeStructureId } from '../../../treeState/types';\nimport { useAbortController } from '../../common';\n\nexport interface UseLoadDataProps<TItem, TId, TFilter = any> extends\n    Pick<LazyTreeProps<TItem, TId, TFilter>, 'getChildCount'>,\n    Pick<CommonTreeConfig<TItem, TId, TFilter>, 'dataSourceState' | 'cascadeSelection'> {\n\n    api: LazyDataSourceApi<TItem, TId, TFilter>;\n    filter?: TFilter;\n    isFolded: (item: TItem) => boolean;\n    fetchStrategy?: 'sequential' | 'parallel';\n    flattenSearchResults?: boolean;\n    getChildCount?(item: TItem): number;\n}\n\nexport interface LoadResult<TItem, TId> {\n    isUpdated: boolean;\n    isOutdated: boolean;\n    tree: TreeState<TItem, TId>;\n}\n\ninterface LoadMissingOptions<TItem, TId, TFilter> {\n    using?: TreeStructureId;\n    tree: TreeState<TItem, TId>;\n    abortInProgress?: boolean;\n    loadAllChildren?(id: TId): LoadAllConfig;\n    isLoadStrict?: boolean;\n    dataSourceState?: DataSourceState<TFilter, TId>;\n}\n\ninterface LoadMissingOptionsOnCheck<TItem, TId> {\n    tree: TreeState<TItem, TId>;\n    id: TId;\n    isChecked: boolean;\n    isRoot: boolean;\n}\n\nexport function useLoadData<TItem, TId, TFilter = any>(\n    props: UseLoadDataProps<TItem, TId, TFilter>,\n) {\n    const { api, filter, isFolded, cascadeSelection } = props;\n\n    const promiseInProgressRef = useRef<Promise<LoadResult<TItem, TId>>>(undefined);\n\n    const { getAbortSignal } = useAbortController();\n\n    const loadMissingImpl = useCallback(async ({\n        using,\n        tree,\n        loadAllChildren = () => ({ nestedChildren: true, children: false }),\n        isLoadStrict,\n        dataSourceState,\n    }: LoadMissingOptions<TItem, TId, TFilter>): Promise<LoadResult<TItem, TId>> => {\n        const loadingTree = tree;\n        const completeDsState = { ...props.dataSourceState, ...dataSourceState };\n        try {\n            const newTreePromise = tree.load({\n                using,\n                options: {\n                    ...props,\n                    loadAllChildren,\n                    isLoadStrict,\n                    isFolded,\n                    api,\n                    filter: {\n                        ...filter,\n                        ...props.dataSourceState?.filter,\n                        ...dataSourceState?.filter,\n                    },\n                    signal: getAbortSignal(),\n                },\n                dataSourceState: completeDsState,\n            });\n\n            const newTree = await newTreePromise;\n            const linkToTree = tree;\n\n            // If tree is changed during this load, than there was reset occurred (new value arrived)\n            // We need to tell caller to reject this result\n            const isOutdated = linkToTree !== loadingTree;\n            const isUpdated = linkToTree !== newTree;\n            return { isUpdated, isOutdated, tree: newTree };\n        } catch (e) {\n            // TBD - correct error handling\n            console.error('LazyListView: Error while loading items.', e);\n            return { isUpdated: false, isOutdated: false, tree: loadingTree };\n        }\n    }, [isFolded, api, filter, props.dataSourceState, getAbortSignal]);\n\n    const loadMissing = useCallback(({\n        tree,\n        using,\n        abortInProgress,\n        loadAllChildren,\n        isLoadStrict,\n        dataSourceState,\n    }: LoadMissingOptions<TItem, TId, TFilter>): Promise<LoadResult<TItem, TId>> => {\n        // Make tree updates sequential, by executing all consequent calls after previous promise completed\n        if (abortInProgress && promiseInProgressRef.current) {\n            promiseInProgressRef.current = Promise.resolve({ isUpdated: false, isOutdated: false, tree });\n        }\n\n        promiseInProgressRef.current = promiseInProgressRef.current\n            ? promiseInProgressRef.current.then(({ tree: currentTree }) =>\n                loadMissingImpl({ tree: currentTree, using, loadAllChildren, isLoadStrict, dataSourceState }))\n            : loadMissingImpl({ tree, using, loadAllChildren, isLoadStrict, dataSourceState });\n\n        return promiseInProgressRef.current;\n    }, [loadMissingImpl]);\n\n    const loadMissingOnCheck = useCallback(async ({ tree, id, isRoot, isChecked }: LoadMissingOptionsOnCheck<TItem, TId>) => {\n        const isImplicitMode = cascadeSelection === CascadeSelectionTypes.IMPLICIT;\n\n        if (!cascadeSelection && !isRoot) {\n            return tree;\n        }\n\n        const parents = Tree.getParents(id, tree.full);\n        const { tree: treeWithMissingRecords } = await loadMissing({\n            tree: tree,\n            // If cascadeSelection is implicit and the element is unchecked, it is necessary to load all children\n            // of all parents of the unchecked element to be checked explicitly. Only one layer of each parent should be loaded.\n            // Otherwise, should be loaded only checked element and all its nested children.\n            loadAllChildren: (itemId) => {\n                const loadAllConfig = { nestedChildren: !isImplicitMode, children: false };\n                if (!cascadeSelection) {\n                    return { ...loadAllConfig, children: isChecked && isRoot };\n                }\n\n                if (!isChecked && isRoot) {\n                    return { ...loadAllConfig, children: false };\n                }\n\n                if (isImplicitMode) {\n                    return { ...loadAllConfig, children: itemId === ROOT_ID || parents.some((parent) => isEqual(parent, itemId)) };\n                }\n\n                const { ids } = tree.full.getItems(undefined);\n                const rootIsNotLoaded = ids.length === 0;\n\n                const shouldLoadChildrenAfterSearch = (!!props.dataSourceState.search?.length\n                    && (parents.some((parent) => isEqual(parent, itemId))\n                    || (itemId === ROOT_ID && rootIsNotLoaded)));\n\n                // `isEqual` is used, because complex ids can be recreated after fetching of parents.\n                // So, they should be compared not by reference, but by value.\n                const shouldLoadAllChildren = isRoot\n                    || isEqual(itemId, id)\n                    || shouldLoadChildrenAfterSearch;\n\n                return {\n                    children: shouldLoadAllChildren,\n                    // If checking is run after the search, it is required to load only\n                    // children of the checked item parents, without nestings.\n                    nestedChildren: !shouldLoadChildrenAfterSearch,\n                };\n            },\n            isLoadStrict: true,\n            dataSourceState: { search: null },\n            using: 'full',\n        });\n\n        return treeWithMissingRecords;\n    }, [cascadeSelection, loadMissing, props.dataSourceState.search]);\n\n    return { loadMissing, loadMissingOnCheck };\n}\n","import isEqual from 'react-fast-compare';\nimport { usePrevious } from '../../../../../../../hooks/usePrevious';\nimport { DataSourceState } from '../../../../../../../types';\nimport { isQueryChanged } from './helpers';\nimport { useCallback, useEffect, useMemo } from 'react';\nimport { useDepsChanged } from '../../common/useDepsChanged';\n\nexport interface LazyFetchingAdvice {\n    shouldLoad: boolean;\n    shouldRefetch: boolean;\n    shouldFetch: boolean;\n    shouldReload: boolean;\n    updatedAt: number;\n}\n\nexport interface UseLazyFetchingAdvisorProps<TId, TFilter = any> {\n    dataSourceState: DataSourceState<TFilter, TId>;\n    filter?: TFilter;\n    forceReload?: boolean;\n    backgroundReload?: boolean;\n    showSelectedOnly?: boolean;\n    /**\n     * Fetching function, which should be called if fetch is required.\n     * @param lazyLoadingAdvice - fetching advice.\n     */\n    onFetch?: (lazyLoadingAdvice: LazyFetchingAdvice) => void;\n}\n\nexport function useLazyFetchingAdvisor<TId, TFilter = any>(\n    {\n        dataSourceState,\n        filter,\n        forceReload,\n        backgroundReload,\n        showSelectedOnly,\n        onFetch,\n    }: UseLazyFetchingAdvisorProps<TId, TFilter>,\n    deps: any[] = [],\n) {\n    const depsChanged = useDepsChanged(deps);\n    const areMoreRowsNeeded = useCallback((\n        prevValue?: DataSourceState<TFilter, TId>,\n        newValue?: DataSourceState<TFilter, TId>,\n    ) => {\n        const isFetchPositionAndAmountChanged = prevValue?.topIndex !== newValue?.topIndex\n            || prevValue?.visibleCount !== newValue?.visibleCount;\n\n        return isFetchPositionAndAmountChanged;\n    }, []);\n\n    const prevFilter = usePrevious(filter);\n    const prevDataSourceState = usePrevious(dataSourceState);\n    const prevShowSelectedOnly = usePrevious(showSelectedOnly);\n\n    const isFoldingChanged = !prevDataSourceState || dataSourceState.folded !== prevDataSourceState.folded;\n\n    const shouldRefetch = useMemo(\n        () => !prevDataSourceState\n            || !isEqual(prevFilter, filter)\n            || isQueryChanged(prevDataSourceState, dataSourceState)\n            || (prevShowSelectedOnly !== showSelectedOnly && !showSelectedOnly)\n            || forceReload\n            || depsChanged,\n        [dataSourceState, filter, forceReload, depsChanged],\n    );\n\n    const moreRowsNeeded = areMoreRowsNeeded(prevDataSourceState, dataSourceState);\n\n    const shouldReload = shouldRefetch && !backgroundReload;\n    const shouldLoad = isFoldingChanged || moreRowsNeeded || shouldReload;\n    const shouldFetch = shouldRefetch || isFoldingChanged || moreRowsNeeded;\n\n    const updatedAt = useMemo(() => Date.now(), [\n        shouldLoad,\n        shouldReload,\n        shouldFetch,\n        shouldRefetch,\n        filter,\n        showSelectedOnly,\n        dataSourceState.folded,\n        dataSourceState.topIndex,\n        dataSourceState.visibleCount,\n    ]);\n\n    useEffect(() => {\n        onFetch?.({ shouldFetch, shouldLoad, shouldReload, shouldRefetch, updatedAt });\n    }, [shouldFetch, shouldLoad, shouldRefetch, shouldReload, updatedAt]);\n\n    return useMemo(() => ({\n        shouldLoad,\n        shouldRefetch,\n        shouldFetch,\n        shouldReload,\n        updatedAt,\n    }), [\n        shouldLoad,\n        shouldRefetch,\n        shouldFetch,\n        shouldReload,\n        updatedAt,\n    ]);\n}\n","import { useCallback, useEffect, useMemo, useState } from 'react';\nimport { LazyTreeProps } from './types';\nimport { usePrevious } from '../../../../../../../hooks/usePrevious';\nimport { useFoldingService } from '../../../../dataRows/services';\nimport { useLoadData } from './useLoadData';\nimport { UseTreeResult } from '../../types';\nimport {\n    useDataSourceStateWithDefaults,\n    useSelectedOnlyTree,\n    useItemsStorage,\n    usePatchTree,\n    useItemsStatusCollector,\n    useActualItemsStorage,\n} from '../../common';\nimport { TreeState } from '../../../treeState';\nimport { useLazyFetchingAdvisor } from './useLazyFetchingAdvisor';\nimport { isSelectedOrCheckedChanged } from '../checked';\n\nexport function useLazyTree<TItem, TId, TFilter = any>(\n    {\n        flattenSearchResults = true,\n        ...restProps\n    }: LazyTreeProps<TItem, TId, TFilter>,\n    deps: any[],\n): UseTreeResult<TItem, TId, TFilter> {\n    const props = { flattenSearchResults, ...restProps };\n    const {\n        filter,\n        backgroundReload,\n        showSelectedOnly,\n        isFoldedByDefault,\n        getId,\n        getParentId,\n        setDataSourceState,\n        cascadeSelection,\n        getRowOptions,\n        rowOptions,\n        selectAll,\n        fetchStrategy,\n        getChildCount,\n        itemsStatusMap,\n        complexIds,\n        patch,\n        isDeleted,\n        getNewItemPosition,\n        sortBy,\n        fixItemBetweenSortings,\n        getItemTemporaryOrder,\n    } = props;\n\n    const dataSourceState = useDataSourceStateWithDefaults({\n        dataSourceState: props.dataSourceState,\n    });\n    const { itemsMap, setItems } = useItemsStorage({\n        itemsMap: props.itemsMap,\n        setItems: props.setItems,\n        params: { getId, complexIds },\n    });\n\n    const itemsStatusCollector = useItemsStatusCollector(\n        {\n            itemsStatusCollector: props.itemsStatusCollector,\n            itemsStatusMap,\n            complexIds,\n            getId,\n            dataSourceState,\n            patch,\n        },\n        [itemsStatusMap, props.itemsStatusCollector],\n    );\n\n    const api = useMemo(\n        () => itemsStatusCollector.watch(props.api),\n        [itemsStatusCollector, props.api],\n    );\n\n    const blankTree = useMemo(\n        () =>\n            TreeState.blank(\n                { getId, getParentId, getChildCount, complexIds },\n                itemsMap,\n                setItems,\n            ),\n        deps,\n    );\n\n    const [treeWithData, setTreeWithData] = useState(blankTree);\n\n    const prevDataSourceState = usePrevious(dataSourceState);\n\n    const [isFetching, setIsFetching] = useState(false);\n    const [isLoading, setIsLoading] = useState(false);\n    const [isForceReload, setIsForceReload] = useState(false);\n\n    const { isFolded } = useFoldingService({\n        getId,\n        isFoldedByDefault,\n        dataSourceState,\n        setDataSourceState,\n    });\n\n    useEffect(() => {\n        setTreeWithData(blankTree);\n    }, [blankTree]);\n\n    const { loadMissing, loadMissingOnCheck } = useLoadData({\n        api,\n        filter,\n        dataSourceState,\n        isFolded,\n        fetchStrategy,\n        flattenSearchResults,\n        getChildCount,\n        cascadeSelection,\n    });\n\n    const loadMissingRecordsOnCheck = useCallback(\n        async (id: TId, isChecked: boolean, isRoot: boolean) => {\n            const newTree = await loadMissingOnCheck({\n                tree,\n                id,\n                isChecked,\n                isRoot,\n            });\n            if (tree !== treeWithData || tree !== newTree) {\n                setTreeWithData(newTree);\n            }\n\n            return newTree.full;\n        },\n        [loadMissingOnCheck, setTreeWithData, treeWithData],\n    );\n\n    const { shouldRefetch, shouldLoad, shouldFetch, shouldReload, updatedAt } = useLazyFetchingAdvisor(\n        {\n            dataSourceState,\n            filter,\n            forceReload: isForceReload,\n            backgroundReload,\n            showSelectedOnly,\n        },\n        [...deps],\n    );\n\n    const treeWithDataActual = useActualItemsStorage({\n        tree: treeWithData,\n        setItems,\n        itemsMap,\n    });\n\n    useEffect(() => {\n        if (\n            showSelectedOnly\n      && isSelectedOrCheckedChanged(dataSourceState, prevDataSourceState)\n        ) {\n            loadMissing({\n                tree: treeWithDataActual,\n                using: 'full',\n                abortInProgress: shouldRefetch,\n                dataSourceState: {\n                    visibleCount: 0,\n                    topIndex: 0,\n                },\n            }).then(({ isUpdated, isOutdated, tree: newTree }) => {\n                if (!isOutdated && (isUpdated || newTree !== treeWithDataActual)) {\n                    setTreeWithData(newTree);\n                }\n            });\n        }\n    }, [\n        showSelectedOnly,\n        dataSourceState.checked,\n        dataSourceState.selectedId,\n        shouldRefetch,\n        updatedAt,\n    ]);\n\n    useEffect(() => {\n        if (showSelectedOnly) {\n            return;\n        }\n\n        let currentTree = treeWithDataActual;\n        if (shouldRefetch) {\n            setIsFetching(true);\n            currentTree = treeWithDataActual.clearStructure({\n                getId,\n                getParentId,\n                getChildCount,\n                complexIds,\n            });\n        }\n\n        if (shouldLoad) {\n            if (currentTree !== treeWithDataActual) {\n                setTreeWithData(currentTree);\n            }\n            setIsLoading(true);\n        }\n\n        if (shouldFetch) {\n            loadMissing({\n                tree: currentTree,\n                using: 'visible',\n                abortInProgress: shouldRefetch,\n            })\n                .then(({ isUpdated, isOutdated, tree: newTree }) => {\n                    if (!isOutdated && (isUpdated || newTree !== treeWithDataActual)) {\n                        setTreeWithData(newTree);\n                    }\n                })\n                .finally(() => {\n                    setIsFetching(false);\n                    setIsLoading(false);\n                    if (isForceReload === true) {\n                        setIsForceReload(false);\n                    }\n                });\n        }\n    }, [\n        showSelectedOnly,\n        shouldFetch,\n        shouldLoad,\n        shouldRefetch,\n        shouldReload,\n        updatedAt,\n    ]);\n\n    const treeWithSelectedOnly = useSelectedOnlyTree(\n        {\n            tree: treeWithDataActual,\n            dataSourceState,\n        },\n        [treeWithDataActual],\n    );\n\n    const { tree, applyPatch } = usePatchTree({\n        tree: treeWithSelectedOnly,\n        patch: showSelectedOnly ? null : patch,\n        isDeleted,\n        getNewItemPosition,\n        getItemTemporaryOrder,\n        fixItemBetweenSortings,\n        sorting: dataSourceState.sorting,\n        sortBy,\n    });\n\n    const reload = useCallback(() => {\n        setIsForceReload(true);\n    }, [props, setTreeWithData]);\n\n    const totalCount = useMemo(() => {\n        const { totalCount: rootTotalCount } = tree.visible.getItems(undefined);\n\n        return rootTotalCount ?? tree.visible.getTotalCount?.();\n    }, [tree.visible]);\n\n    return {\n        tree: showSelectedOnly ? tree.selectedOnly : tree.visible,\n        treeWithoutPatch: treeWithSelectedOnly.visible,\n        selectionTree: tree.full,\n        totalCount,\n        dataSourceState,\n        setDataSourceState,\n        isFoldedByDefault,\n        getId,\n        getParentId,\n        cascadeSelection,\n        getRowOptions,\n        rowOptions,\n        reload,\n        isFetching,\n        isLoading,\n        getItemStatus: itemsStatusCollector.getItemStatus(itemsMap),\n        flattenSearchResults,\n        loadMissingRecordsOnCheck,\n        showSelectedOnly,\n        selectAll,\n        applyPatch,\n    };\n}\n","import { useMemo } from 'react';\nimport { SyncTreeProps } from './types';\nimport { TreeState } from '../../../treeState';\nimport { SharedItemsState } from '../types';\n\nexport interface UseCreateTreeProps<TItem, TId, TFilter = any> extends\n    Pick<\n    SyncTreeProps<TItem, TId, TFilter>,\n    'complexIds' | 'getId' | 'getParentId'\n    >,\n    SharedItemsState<TItem, TId> {\n    items?: TItem[] | TreeState<TItem, TId>;\n}\n\nexport function useCreateTree<TItem, TId, TFilter = any>(\n    props: UseCreateTreeProps<TItem, TId, TFilter>,\n    deps: any[],\n): TreeState<TItem, TId> {\n    const { items, itemsMap, setItems, complexIds, getId, getParentId } = props;\n    const tree = useMemo(() => {\n        if (items instanceof TreeState) {\n            return items;\n        }\n\n        return TreeState.createFromItems<TItem, TId>(\n            items,\n            itemsMap,\n            { getId, getParentId, complexIds },\n            setItems,\n        );\n    }, [...deps, itemsMap]);\n\n    return tree;\n}\n","import { useCallback, useMemo, useState } from 'react';\nimport { SyncTreeProps } from './types';\nimport { useCreateTree } from './useCreateTree';\nimport {\n    useFilterTreeState, useSearchTreeState, useSortTreeState, useDataSourceStateWithDefaults,\n    useItemsStorage, usePatchTree, useSelectedOnlyTree,\n} from '../../common';\nimport { UseTreeResult } from '../../types';\n\nexport function useSyncTree<TItem, TId, TFilter = any>(\n    { sortSearchByRelevance = true, items, ...restProps }: SyncTreeProps<TItem, TId, TFilter>,\n    deps: any[],\n): UseTreeResult<TItem, TId, TFilter> {\n    const props = { ...restProps, sortSearchByRelevance };\n    const [triggerValue, trigger] = useState(false);\n\n    const resetTree = useCallback(() => {\n        trigger((currentTriggerValue) => !currentTriggerValue);\n    }, [trigger]);\n\n    const {\n        getId,\n        getParentId,\n        complexIds,\n        getFilter,\n        getSearchFields,\n        sortBy,\n        rowOptions,\n        getRowOptions,\n        setDataSourceState,\n        isFoldedByDefault,\n        cascadeSelection,\n        showSelectedOnly,\n        selectAll,\n        fixItemBetweenSortings,\n        getNewItemPosition,\n        isDeleted,\n    } = props;\n\n    const { itemsMap, setItems } = useItemsStorage({\n        items,\n        setItems: props.setItems,\n        params: { getId, complexIds },\n    });\n\n    const fullTree = useCreateTree(\n        { items, itemsMap, setItems, getId, getParentId, complexIds },\n        [...deps, items, itemsMap, setItems, triggerValue],\n    );\n\n    const dataSourceState = useDataSourceStateWithDefaults({ dataSourceState: props.dataSourceState });\n\n    const filteredTree = useFilterTreeState(\n        { tree: fullTree, getFilter, dataSourceState },\n        [fullTree],\n    );\n\n    const sortTree = useSortTreeState(\n        { tree: filteredTree, sortBy, dataSourceState },\n        [filteredTree],\n    );\n\n    const searchTree = useSearchTreeState(\n        { tree: sortTree, getSearchFields, sortSearchByRelevance, dataSourceState },\n        [sortTree],\n    );\n\n    const treeWithSelectedOnly = useSelectedOnlyTree({\n        tree: searchTree,\n        dataSourceState,\n    }, [searchTree]);\n\n    const { tree, applyPatch } = usePatchTree({\n        tree: treeWithSelectedOnly,\n        patch: showSelectedOnly ? null : restProps.patch,\n        isDeleted,\n        getNewItemPosition,\n        fixItemBetweenSortings,\n        sorting: dataSourceState.sorting,\n        sortBy,\n    });\n\n    const reload = useCallback(() => {\n        resetTree();\n    }, [resetTree]);\n\n    const totalCount = useMemo(() => {\n        const { totalCount: rootTotalCount } = tree.visible.getItems(undefined);\n\n        return rootTotalCount ?? tree.visible.getTotalCount?.() ?? 0;\n    }, [tree.visible]);\n\n    return {\n        tree: showSelectedOnly ? tree.selectedOnly : tree.visible,\n        treeWithoutPatch: treeWithSelectedOnly.visible,\n        selectionTree: tree.full,\n        totalCount,\n        rowOptions,\n        getRowOptions,\n        getParentId,\n        getId,\n        dataSourceState,\n        setDataSourceState,\n        isFoldedByDefault,\n        reload,\n        cascadeSelection,\n        showSelectedOnly,\n        selectAll,\n        applyPatch,\n    };\n}\n","import { useAsyncTree } from './asyncTree';\nimport { useLazyTree } from './lazyTree';\nimport { useSyncTree } from './syncTree';\n\nexport const strategies = {\n    sync: useSyncTree,\n    async: useAsyncTree,\n    lazy: useLazyTree,\n};\n\nexport type {\n    UseTreeProps,\n    LoadMissingRecords,\n    GetItemStatus,\n} from './types';\n","import { useMemo } from 'react';\nimport { UseTreeResult } from './types';\nimport { TreeHook, UseTreeProps } from './strategies/types';\nimport { usePrevious } from '../../../../../hooks/usePrevious';\nimport { strategies } from './strategies';\n\nexport function useTree<TItem, TId, TFilter = any>(props: UseTreeProps<TItem, TId, TFilter>, deps: any[]): UseTreeResult<TItem, TId, TFilter> {\n    const prevType = usePrevious(props.type);\n\n    if (prevType && props.type !== prevType) {\n        throw new Error(\"Tree type can't be changed between renders\");\n    }\n\n    const useStrategy: TreeHook<typeof props.type> = useMemo(\n        () => strategies[props.type] as TreeHook<typeof props.type>,\n        [props.type],\n    );\n\n    const tree = useStrategy<TItem, TId>(props, [...deps]);\n\n    return tree;\n}\n","import { ItemsMap, ItemsMapParams } from './ItemsMap';\n\nexport type OnUpdate<TId, TItem> = (newItemsMap: ItemsMap<TId, TItem>) => void;\n\nexport interface ModificationOptions {\n    reset?: boolean;\n    on?: 'load' | 'patch'\n}\n\nexport interface ItemsStorageParams<TItem, TId> {\n    items?: TItem[];\n    params: ItemsMapParams<TItem, TId>;\n}\n\n/**\n * Storage of items with subscriptions. Enables sharing loaded data between multiple consumers.\n * @internal For internal usage only. API can be changed in future releases.\n */\nexport class ItemsStorage<TItem, TId> {\n    private subs: Map<OnUpdate<TId, TItem>, void> = new Map();\n    private _itemsMap: ItemsMap<TId, TItem>;\n\n    constructor({ items, params }: ItemsStorageParams<TItem, TId>) {\n        this._itemsMap = new ItemsMap(\n            null,\n            params,\n        );\n        if (items?.length) {\n            this.setItems(items);\n        }\n    }\n\n    subscribe(onUpdate: OnUpdate<TId, TItem>) {\n        this.subs.set(onUpdate);\n        onUpdate(this._itemsMap);\n        return () => this.subs.delete(onUpdate);\n    }\n\n    setItems = (items: TItem[], options?: ModificationOptions) => {\n        const itemsMap = options?.reset\n            ? this._itemsMap.clear().setItems(items)\n            : this._itemsMap.setItems(items);\n\n        if (itemsMap !== this._itemsMap) {\n            this._itemsMap = itemsMap;\n            this.subs.forEach((_, onUpdate) => onUpdate(itemsMap));\n        }\n\n        return this._itemsMap;\n    };\n\n    public getItemsMap = () => {\n        return this._itemsMap;\n    };\n}\n","import { ITree, NOT_FOUND_RECORD, Tree } from '../../tree';\n\nexport const idToKey = <TId>(id: TId) => typeof id === 'object' ? JSON.stringify(id) : `${id}`;\n\nexport const buildParentsLookup = <TItem, TId>(ids: TId[], tree: ITree<TItem, TId>, getParentId?: (item: TItem) => TId) => {\n    const idsByKey: Record<string, boolean> = {};\n    const someChildInIdsByKey: Record<string, boolean> = {};\n    const checkedItems = ids ?? [];\n    for (let i = checkedItems.length - 1; i >= 0; i--) {\n        const id = checkedItems[i];\n        idsByKey[idToKey(id)] = true;\n        if (!tree || !getParentId) {\n            continue;\n        }\n\n        const item = tree.getById(id);\n        if (item === NOT_FOUND_RECORD) {\n            continue;\n        }\n\n        const parentId = getParentId(item);\n        if (!someChildInIdsByKey[idToKey(parentId)]) {\n            const parents = Tree.getParents(id, tree).reverse();\n            for (const parent of parents) {\n                if (someChildInIdsByKey[idToKey(parent)]) {\n                    break;\n                }\n                someChildInIdsByKey[idToKey(parent)] = true;\n            }\n        }\n    }\n    return { idsByKey, someChildInIdsByKey };\n};\n","import { useCallback, useMemo } from 'react';\nimport { CascadeSelectionTypes, DataRowProps } from '../../../../../types';\nimport type { ITree } from '../../tree/ITree';\nimport { NOT_FOUND_RECORD, FAILED_RECORD } from '../../tree/constants';\nimport { CommonTreeConfig, GetItemStatus } from '../../tree/hooks/strategies/types';\nimport { CascadeSelectionService } from './useCascadeSelectionService';\nimport { isInProgress } from '../../helpers';\nimport { buildParentsLookup, idToKey } from './buildParentsLookup';\nimport { CheckingHelper } from '../../tree/treeStructure';\n\n/**\n * Checking service configuration.\n */\nexport interface UseCheckingServiceProps<TItem, TId, TFilter = any> extends\n    Pick<\n    CommonTreeConfig<TItem, TId, TFilter>,\n    'getParentId' | 'dataSourceState' | 'setDataSourceState'\n    | 'rowOptions' | 'getRowOptions' | 'cascadeSelection'\n    >,\n    CascadeSelectionService<TItem, TId>,\n    GetItemStatus<TId> {\n    /**\n     * Tree-like data, selection should be performed on.\n     */\n    tree: ITree<TItem, TId>;\n}\n\n/**\n * Service, which provides checking functionality and checking/parially checking info.\n */\nexport interface CheckingService<TItem, TId> {\n    /**\n     * Provides knowledge about checked state of the row.\n     * @param row - row, which checked state info should be returned.\n     * @returns if row is checked.\n     */\n    isRowChecked: (row: DataRowProps<TItem, TId>) => boolean;\n\n    /**\n     * Provides knowledge about children checked state of the row.\n     * @param row - row, which children checked state info should be returned.\n     * @returns if row children are checked.\n     */\n    isRowChildrenChecked: (row: DataRowProps<TItem, TId>) => boolean;\n\n    /**\n     * Checking handler of a row.\n     * @param row - row, which should be checked.\n     */\n    handleOnCheck: (row: DataRowProps<TItem, TId>) => void;\n\n    /**\n     * Select all handler of a row.\n     * @param selectAll - specifies, if select all or clear all should be performed.\n     */\n    handleSelectAll: (selectAll: boolean) => void;\n\n    /**\n     * Clears all checked.\n     */\n    clearAllChecked: () => void;\n\n    /**\n     * Provides info about the ability to check and item.\n     * @param id - id of the item to check if checkable.\n     * @param item - record, if it is present or not found record symbol.\n     * @returns if item with some id is checkable.\n     */\n    isItemCheckable: (id: TId, item: TItem | typeof NOT_FOUND_RECORD) => boolean;\n}\n\n/**\n * Service, which provides checking functionality.\n * @returns checking service.\n */\nexport function useCheckingService<TItem, TId>(\n    {\n        tree,\n        getParentId,\n        dataSourceState,\n        setDataSourceState,\n        cascadeSelection,\n        getRowOptions,\n        rowOptions,\n        getCompleteTreeForCascadeSelection,\n        getItemStatus,\n    }: UseCheckingServiceProps<TItem, TId>,\n): CheckingService<TItem, TId> {\n    const checked = dataSourceState.checked ?? [];\n    const checkingInfoById = useMemo(\n        () => buildParentsLookup(checked, tree, getParentId),\n        [tree, getParentId, checked],\n    );\n\n    const { idsByKey: checkedByKey, someChildInIdsByKey: someChildCheckedByKey } = checkingInfoById;\n\n    const isRowChecked = useCallback((row: DataRowProps<TItem, TId>) => {\n        const exactCheck = !!checkedByKey[row.rowKey];\n        if (exactCheck || cascadeSelection !== CascadeSelectionTypes.IMPLICIT) {\n            return exactCheck;\n        }\n\n        const { path } = row;\n        return path.some(({ id }) => !!checkedByKey[idToKey(id)]);\n    }, [checkedByKey]);\n\n    const isRowChildrenChecked = useCallback((row: DataRowProps<TItem, TId>) => {\n        if (cascadeSelection === CascadeSelectionTypes.IMPLICIT) {\n            return isRowChecked(row) || someChildCheckedByKey[row.rowKey] || false;\n        }\n\n        return someChildCheckedByKey[row.rowKey] ?? false;\n    }, [someChildCheckedByKey, isRowChecked, tree]);\n\n    const getRowProps = useCallback((item: TItem) => {\n        const externalRowOptions = getRowOptions ? getRowOptions(item) : {};\n        return { ...rowOptions, ...externalRowOptions };\n    }, [rowOptions, getRowOptions]);\n\n    const isItemCheckable = useCallback((id: TId, item: TItem | typeof NOT_FOUND_RECORD) => {\n        if (item === NOT_FOUND_RECORD) {\n            if (!getItemStatus) {\n                return true;\n            }\n\n            const status = getItemStatus(id);\n            if (isInProgress(status)) {\n                return false;\n            }\n\n            if (status === FAILED_RECORD || status === NOT_FOUND_RECORD) {\n                return true;\n            }\n\n            return false;\n        }\n\n        const rowProps = getRowProps(item);\n        return rowProps?.checkbox?.isVisible && !rowProps?.checkbox?.isDisabled;\n    }, [getRowProps]);\n\n    const isItemUnknown = useCallback((id: TId) => {\n        const item = tree.getById(id);\n        if (item !== NOT_FOUND_RECORD) {\n            return false;\n        }\n        if (!getItemStatus) {\n            return true;\n        }\n\n        const status = getItemStatus(id);\n        return status === FAILED_RECORD || status === NOT_FOUND_RECORD;\n    }, [tree, getItemStatus]);\n\n    const handleCheck = useCallback(async (isChecked: boolean, checkedId?: TId, isRoot?: boolean) => {\n        const completeTree = await getCompleteTreeForCascadeSelection(checkedId, isChecked, isRoot);\n        setDataSourceState((dsState) => ({\n            ...dsState,\n            checked: CheckingHelper.cascadeSelection({\n                tree: completeTree,\n                currentCheckedIds: dsState.checked ?? [],\n                checkedId,\n                isChecked,\n                isCheckable: isItemCheckable,\n                isUnknown: isItemUnknown,\n                cascadeSelectionType: cascadeSelection,\n            }),\n        }));\n    }, [getCompleteTreeForCascadeSelection, setDataSourceState, isItemCheckable, isItemUnknown, cascadeSelection]);\n\n    const handleSelectAll = useCallback((isChecked: boolean) => {\n        handleCheck(isChecked, undefined, true);\n    }, [handleCheck]);\n\n    const clearAllChecked = useCallback(() => {\n        handleCheck(false, undefined, true);\n    }, [handleCheck]);\n\n    const handleOnCheck = useCallback((rowProps: DataRowProps<TItem, TId>) => {\n        const id = rowProps.id;\n        const isChecked = !rowProps.isChecked;\n\n        handleCheck(isChecked, id);\n    }, [handleCheck]);\n\n    return {\n        isRowChecked,\n        isRowChildrenChecked,\n        handleOnCheck,\n        handleSelectAll,\n        clearAllChecked,\n        isItemCheckable,\n    };\n}\n","import { useCallback } from 'react';\nimport { DataRowProps, DataSourceState, ScrollToConfig } from '../../../../../types';\nimport { idToKey, setObjectFlag } from '../../helpers';\nimport { CommonTreeConfig } from '../../tree/hooks/strategies/types';\n\n/**\n * Folding service configuration.\n */\nexport type UseFoldingServiceProps<TItem, TId, TFilter = any> = Pick<\nCommonTreeConfig<TItem, TId, TFilter>,\n'getId' | 'dataSourceState' | 'setDataSourceState' | 'isFoldedByDefault'\n>;\n\n/**\n * Service, which provides folding functionality and folding info.\n */\nexport interface FoldingService<TItem, TId> {\n    /**\n     * Folding event handler.\n     * @param row - row, which should be folded.\n     */\n    handleOnFold: (row: DataRowProps<TItem, TId>) => void;\n    /**\n     * Provides knowledge about folding state of the row.\n     * @param row - row, which folding state info should be returned.\n     * @returns if row is folded.\n     */\n    isFolded: (item: TItem) => boolean\n}\n\n/**\n * Service, which provides folding functionality.\n * @returns folding service.\n */\nexport function useFoldingService<TItem, TId, TFilter = any>({\n    dataSourceState,\n    setDataSourceState,\n    isFoldedByDefault,\n    getId,\n}: UseFoldingServiceProps<TItem, TId, TFilter>): FoldingService<TItem, TId> {\n    const defaultIsFolded = (state: DataSourceState<TFilter, TId>) => {\n        return state.foldAll;\n    };\n\n    const isFolded = useCallback((item: TItem) => {\n        const searchIsApplied = !!dataSourceState?.search;\n        if (searchIsApplied) {\n            return false;\n        }\n\n        const folded = dataSourceState.folded || {};\n        const key = idToKey(getId(item));\n        if (folded[key] != null) {\n            return folded[key];\n        }\n\n        if (isFoldedByDefault) {\n            return isFoldedByDefault(item, { foldAll: dataSourceState?.foldAll });\n        }\n\n        return defaultIsFolded(dataSourceState) ?? true;\n    }, [isFoldedByDefault, dataSourceState?.search, dataSourceState?.folded, dataSourceState?.foldAll]);\n\n    const handleOnFold = useCallback((rowProps: DataRowProps<TItem, TId>) => {\n        setDataSourceState((dsState) => {\n            const fold = !rowProps.isFolded;\n            const indexToScroll = rowProps.index - (rowProps.path?.length ?? 0);\n            const scrollTo: ScrollToConfig = fold && rowProps.isPinned\n                ? { index: indexToScroll, align: 'nearest' }\n                : dsState.scrollTo;\n\n            return {\n                ...dsState,\n                scrollTo,\n                folded: setObjectFlag(dsState && dsState.folded, rowProps.rowKey, fold),\n            };\n        });\n    }, [setDataSourceState]);\n\n    return { handleOnFold, isFolded };\n}\n","import { useCallback } from 'react';\nimport { SetDataSourceState } from '../../../../../types';\n\n/**\n * Focus service configuration.\n */\nexport interface UseFocusServiceProps<TId, TFilter = any> {\n    /**\n     * DataSource state update handler.\n     */\n    setDataSourceState?: SetDataSourceState<TFilter, TId>;\n}\n\n/**\n * Focus service functionality.\n */\nexport interface FocusService {\n    /**\n     * Focus event handler.\n     * @param focusedIndex - index of the row to be focused.\n     */\n    handleOnFocus: (focusedIndex: number) => void;\n}\n\n/**\n * Service, which provides focus functionality.\n * @returns focus service.\n */\nexport function useFocusService<TId, TFilter = any>({\n    setDataSourceState,\n}: UseFocusServiceProps<TId, TFilter>): FocusService {\n    const handleOnFocus = useCallback((focusIndex: number) => {\n        setDataSourceState((dataSourceState) => ({ ...dataSourceState, focusedIndex: focusIndex }));\n    }, [setDataSourceState]);\n\n    return { handleOnFocus };\n}\n","import { useCallback, useMemo } from 'react';\nimport { DataRowProps } from '../../../../../types';\nimport { buildParentsLookup, idToKey } from './buildParentsLookup';\nimport { ITree } from '../../tree';\nimport { CommonTreeConfig } from '../../tree/hooks/strategies/types';\n\n/**\n * Checking service configuration.\n */\nexport interface UseSelectingServiceProps<TItem, TId, TFilter = any> extends\n    Pick<\n    CommonTreeConfig<TItem, TId, TFilter>,\n    'getParentId' | 'dataSourceState' | 'setDataSourceState'\n    > {\n    /**\n     * Tree-like data, selection should be performed on.\n     */\n    tree: ITree<TItem, TId>;\n}\n\n/**\n * Service, which provides selecting functionality and seleting info.\n */\nexport interface SelectingService<TItem, TId> {\n    /**\n     * Selecting handler of a row.\n     * @param row - row, which should be selected.\n     */\n    handleOnSelect: (row: DataRowProps<TItem, TId>) => void;\n\n    /**\n     * Provides knowledge about selection state of the row.\n     * @param row - row, which selection state info should be returned.\n     * @returns if row is selected.\n     */\n    isRowSelected: (row: DataRowProps<TItem, TId>) => boolean;\n\n    /**\n     * Provides knowledge about children selection state of the row.\n     * @param row - row, which children selection state info should be returned.\n     * @returns if row is selected.\n     */\n    isRowChildSelected: (row: DataRowProps<TItem, TId>) => boolean;\n}\n\n/**\n * Service, which provides selection functionality.\n * @returns selecting service.\n */\nexport function useSelectingService<TItem, TId, TFilter = any>({\n    tree,\n    getParentId,\n    dataSourceState,\n    setDataSourceState,\n}: UseSelectingServiceProps<TItem, TId, TFilter>): SelectingService<TItem, TId> {\n    const { selectedId } = dataSourceState;\n    const selectingInfoById = useMemo(\n        () => buildParentsLookup(selectedId === null ? [] : [selectedId], tree, getParentId),\n        [tree, getParentId, selectedId],\n    );\n\n    const { idsByKey: selectedByKey, someChildInIdsByKey: someChildSelectedByKey } = selectingInfoById;\n\n    const isRowSelected = useCallback((row: DataRowProps<TItem, TId>) => {\n        return !!selectedByKey[idToKey(row.id)];\n    }, [selectedByKey]);\n\n    const isRowChildSelected = useCallback((row: DataRowProps<TItem, TId>) => {\n        return someChildSelectedByKey[idToKey(row.id)] ?? false;\n    }, [someChildSelectedByKey]);\n\n    const handleOnSelect = useCallback((rowProps: DataRowProps<TItem, TId>) => {\n        setDataSourceState((dsState) => ({\n            ...dsState,\n            selectedId: rowProps.id,\n        }));\n    }, [setDataSourceState]);\n\n    return { handleOnSelect, isRowSelected, isRowChildSelected };\n}\n","import { useCallback } from 'react';\nimport { ITree } from '../../tree';\nimport { LoadMissingRecords } from '../../tree/hooks/strategies/types';\n\n/**\n * Cascade selection service configuration.\n */\nexport interface UseCascadeSelectionServiceProps<TItem, TId> extends\n    LoadMissingRecords<TItem, TId> {\n    /**\n     * Tree-like data, cascade selection should be performed on.\n     */\n    tree: ITree<TItem, TId>;\n}\n\n/**\n * A service which provides cascade selection functionality with loading missing records.\n */\nexport interface CascadeSelectionService<TItem, TId> {\n    /**\n     * Provides a cascade selection functionality.\n     * @param isChecked - checking state of the item.\n     * @param checkedId - ID of the item to be checked. If `undefined` - root is checked.\n     * @param isRoot - marks if cascade selection should be performed on all the items.\n     * @param checked - current state of checked items.\n     * @returns new checked items.\n     */\n    getCompleteTreeForCascadeSelection: (id: TId, isChecked: boolean, isRoot: boolean) => Promise<ITree<TItem, TId>>;\n}\n\n/**\n * Service, which provides cascade selection functionality with support of loading missing records as needed.\n * @returns cascade selection service.\n */\nexport function useCascadeSelectionService<TItem, TId>({\n    tree,\n    loadMissingRecordsOnCheck = async () => tree,\n}: UseCascadeSelectionServiceProps<TItem, TId>): CascadeSelectionService<TItem, TId> {\n    const getCompleteTreeForCascadeSelection = useCallback(async (checkedId: TId, isChecked: boolean, isRoot?: boolean) => {\n        return await loadMissingRecordsOnCheck(checkedId, isChecked, isRoot);\n    }, [tree, loadMissingRecordsOnCheck]);\n\n    return { getCompleteTreeForCascadeSelection };\n}\n","import { useCallback, useMemo } from 'react';\nimport { DataRowPathItem, DataRowProps } from '../../../../types';\nimport { CheckingService, FocusService, FoldingService, SelectingService } from './services';\nimport { idToKey } from '../helpers';\nimport { CommonTreeConfig } from '../tree/hooks/strategies/types/common';\nimport { ITree, Tree } from '../tree';\n\nexport interface UseDataRowPropsProps<TItem, TId, TFilter = any> extends Omit<CheckingService<TItem, TId>, 'clearAllChecked' | 'handleSelectAll'>,\n    FocusService,\n    SelectingService<TItem, TId>,\n    FoldingService<TItem, TId>,\n    Pick<\n    CommonTreeConfig<TItem, TId, TFilter>,\n    'dataSourceState' | 'rowOptions' | 'getRowOptions' | 'getId'\n    > {\n    /**\n     * Tree-like data, rows to be built from.\n     */\n    tree: ITree<TItem, TId>;\n\n    getEstimatedChildrenCount: (id: TId) => number;\n}\n\nexport function useDataRowProps<TItem, TId, TFilter = any>(\n    {\n        tree,\n        getId,\n        dataSourceState,\n        getRowOptions,\n        rowOptions,\n        isFolded,\n        handleOnCheck,\n        handleOnSelect,\n        handleOnFocus,\n        handleOnFold,\n        isRowSelected,\n        isRowChildSelected,\n        isRowChecked,\n        isRowChildrenChecked,\n        getEstimatedChildrenCount,\n    }: UseDataRowPropsProps<TItem, TId, TFilter>,\n) {\n    const updateRowOptions = useCallback((row: DataRowProps<TItem, TId>) => {\n        const externalRowOptions = (getRowOptions && !row.isLoading)\n            ? getRowOptions(row.value, row.index)\n            : {};\n\n        const fullRowOptions = { ...rowOptions, ...externalRowOptions };\n\n        const estimatedChildrenCount = getEstimatedChildrenCount(row.id);\n        row.isFoldable = false;\n        if (estimatedChildrenCount > 0) {\n            row.isFoldable = true;\n        }\n\n        const isCheckable = !!(fullRowOptions?.checkbox && fullRowOptions?.checkbox?.isVisible && !fullRowOptions?.checkbox?.isDisabled);\n        const isSelectable = fullRowOptions && fullRowOptions.isSelectable;\n        if (fullRowOptions != null) {\n            const rowValue = row.value;\n            Object.assign(row, fullRowOptions);\n            row.value = fullRowOptions.value ?? rowValue;\n        }\n        row.isFocused = dataSourceState.focusedIndex === row.index;\n        row.isChecked = isRowChecked(row);\n        row.isSelected = isRowSelected(row);\n        row.isCheckable = isCheckable;\n        row.onCheck = isCheckable ? handleOnCheck : undefined;\n\n        row.onSelect = fullRowOptions?.isSelectable ? handleOnSelect : undefined;\n        row.onFocus = (isSelectable || isCheckable || row.isFoldable) ? handleOnFocus : undefined;\n        row.onFold = row.isFoldable ? handleOnFold : undefined;\n        row.isFolded = row.isFoldable && isFolded(row.value);\n\n        row.isChildrenChecked = isRowChildrenChecked(row);\n        row.isChildrenSelected = isRowChildSelected(row);\n\n        return row;\n    }, [\n        tree,\n        getRowOptions,\n        rowOptions,\n        getEstimatedChildrenCount,\n        dataSourceState.focusedIndex,\n        dataSourceState.selectedId,\n        isRowChecked,\n        isRowChildrenChecked,\n        handleOnCheck,\n        handleOnSelect,\n        handleOnFocus,\n        isFolded,\n        handleOnFold,\n    ]);\n\n    const getRowProps = useCallback((item: TItem, index: number): DataRowProps<TItem, TId> => {\n        const id = getId(item);\n        const key = idToKey(id);\n        const path = Tree.getPathById(id, tree);\n        const parentId = path.length > 0 ? path[path.length - 1].id : undefined;\n        const rowProps = {\n            id,\n            parentId,\n            key,\n            rowKey: key,\n            index,\n            value: item,\n            depth: path.length,\n            path,\n        } as DataRowProps<TItem, TId>;\n\n        return updateRowOptions(rowProps);\n    }, [getId, tree, updateRowOptions]);\n\n    const getEmptyRowProps = useCallback((id: any, index: number = 0, path: DataRowPathItem<TId, TItem>[] = null): DataRowProps<TItem, TId> => {\n        const checked = dataSourceState?.checked ?? [];\n        const isChecked = checked.includes(id);\n        return {\n            id,\n            rowKey: idToKey(id),\n            value: undefined,\n            index,\n            depth: path ? path.length : 0,\n            path: path ?? [],\n            checkbox: rowOptions?.checkbox?.isVisible && { isVisible: true, isDisabled: true },\n            isChecked,\n        };\n    }, [dataSourceState?.checked, rowOptions]);\n\n    const getLoadingRowProps = useCallback((id: any, index: number = 0, path: DataRowPathItem<TId, TItem>[] = null): DataRowProps<TItem, TId> => {\n        const rowProps = getEmptyRowProps(id, index, path);\n        return {\n            ...rowProps,\n            checkbox: { ...rowProps.checkbox, isDisabled: true },\n            isLoading: true,\n        };\n    }, [getEmptyRowProps]);\n\n    const getUnknownRowProps = useCallback((id: any, index: number = 0, path: DataRowPathItem<TId, TItem>[] = null): DataRowProps<TItem, TId> => {\n        const emptyRowProps = getEmptyRowProps(id, index, path);\n        const checkbox = (rowOptions?.checkbox?.isVisible || emptyRowProps.isChecked)\n            ? { isVisible: true, isDisabled: false }\n            : undefined;\n\n        const isCheckable = checkbox && checkbox.isVisible && !checkbox.isDisabled;\n        return {\n            ...emptyRowProps,\n            checkbox,\n            isUnknown: true,\n            onCheck: isCheckable ? handleOnCheck : undefined,\n        };\n    }, [getEmptyRowProps, rowOptions, handleOnCheck]);\n\n    return useMemo(\n        () => ({ getRowProps, getEmptyRowProps, getLoadingRowProps, getUnknownRowProps, updateRowOptions }),\n        [getRowProps, getEmptyRowProps, getLoadingRowProps, getUnknownRowProps, updateRowOptions],\n    );\n}\n","import { CascadeSelection, CascadeSelectionTypes, DataRowProps } from '../../../../types';\n\nexport interface NodeStats {\n    isSomeCheckable: boolean;\n    isSomeChecked: boolean;\n    isAllChecked: boolean;\n    isSomeSelected: boolean;\n    hasMoreRows: boolean;\n    isSomeCheckboxEnabled: boolean;\n\n    isSomeEnabledChecked: boolean;\n    isAllDisabledChecked: boolean;\n    isPartiallyLoaded?: boolean;\n}\n\nexport const getDefaultNodeStats = (): NodeStats => ({\n    isSomeCheckable: false,\n    isSomeChecked: false,\n    isAllChecked: true,\n    isSomeSelected: false,\n    hasMoreRows: false,\n    isSomeCheckboxEnabled: false,\n    isPartiallyLoaded: false,\n    isAllDisabledChecked: true,\n    isSomeEnabledChecked: false,\n});\n\nexport const mergeStats = (parentStats: NodeStats, childStats: NodeStats) => ({\n    ...parentStats,\n    isSomeSelected: parentStats.isSomeSelected || childStats.isSomeSelected,\n    isSomeCheckable: parentStats.isSomeCheckable || childStats.isSomeCheckable,\n    isSomeChecked: parentStats.isSomeChecked || childStats.isSomeChecked,\n    isAllChecked: parentStats.isAllChecked && childStats.isAllChecked,\n    isSomeCheckboxEnabled: parentStats.isSomeCheckboxEnabled || childStats.isSomeCheckboxEnabled,\n    hasMoreRows: parentStats.hasMoreRows || childStats.hasMoreRows,\n    isPartiallyLoaded: parentStats.isPartiallyLoaded || childStats.isPartiallyLoaded,\n    isAllDisabledChecked: parentStats.isAllDisabledChecked && childStats.isAllDisabledChecked,\n    isSomeEnabledChecked: parentStats.isSomeEnabledChecked || childStats.isSomeEnabledChecked,\n});\n\nexport const getRowStats = <TItem, TId>(row: DataRowProps<TItem, TId>, actualStats: NodeStats, cascadeSelection: CascadeSelection): NodeStats => {\n    let {\n        isSomeCheckable, isSomeChecked, isAllChecked, isSomeSelected, isSomeCheckboxEnabled, isSomeEnabledChecked, isAllDisabledChecked,\n    } = actualStats;\n    const isImplicitCascadeSelection = cascadeSelection === CascadeSelectionTypes.IMPLICIT;\n\n    if (row.checkbox && row.checkbox.isVisible) {\n        isSomeCheckable = true;\n        if (row.isChecked || row.isChildrenChecked) {\n            isSomeChecked = true;\n        }\n        if (!row.checkbox.isDisabled || isSomeCheckboxEnabled) {\n            isSomeCheckboxEnabled = true;\n        }\n\n        if (!row.checkbox.isDisabled && row.isChecked) {\n            isSomeEnabledChecked = true;\n        }\n\n        if (!row.isChecked && !isImplicitCascadeSelection) {\n            if (row.checkbox.isDisabled) {\n                isAllDisabledChecked = false;\n            } else {\n                isAllChecked = false;\n            }\n        } else if (row.parentId === undefined && !row.isChecked && isImplicitCascadeSelection) {\n            isAllChecked = false;\n\n            if (row.checkbox.isDisabled) {\n                isAllDisabledChecked = false;\n            }\n        }\n    }\n\n    if (row.isSelected || row.isChildrenSelected) {\n        isSomeSelected = true;\n    }\n\n    return {\n        ...actualStats,\n        isSomeCheckable,\n        isSomeChecked,\n        isAllChecked,\n        isSomeSelected,\n        isSomeCheckboxEnabled,\n        isSomeEnabledChecked,\n        isAllDisabledChecked,\n    };\n};\n","import { useMemo } from 'react';\nimport { ITree, NOT_FOUND_RECORD, PARTIALLY_LOADED, Tree } from '../tree';\nimport { DataRowPathItem, DataRowProps } from '../../../../types';\nimport { idToKey } from '../helpers';\nimport { NodeStats, getDefaultNodeStats, getRowStats, mergeStats } from './stats';\nimport { CommonTreeConfig } from '../tree/hooks/strategies/types/common';\n\nexport interface UseBuildRowsProps<TItem, TId, TFilter = any> extends\n    Pick<\n    CommonTreeConfig<TItem, TId, TFilter>,\n    'dataSourceState' | 'rowOptions' | 'getRowOptions' | 'cascadeSelection'\n    > {\n\n    tree: ITree<TItem, TId>;\n\n    getEstimatedChildrenCount: (id: TId) => number;\n    getMissingRecordsCount: (id: TId, totalRowsCount: number, loadedChildrenCount: number) => number;\n    maxVisibleRowIndex: number;\n\n    getRowProps: (item: TItem, index: number) => DataRowProps<TItem, TId>;\n    getLoadingRowProps: (id: any, index?: number, path?: DataRowPathItem<TId, TItem>[]) => DataRowProps<TItem, TId>;\n\n    isLoading?: boolean;\n}\n\nexport function useBuildRows<TItem, TId, TFilter = any>({\n    tree,\n    dataSourceState,\n    getEstimatedChildrenCount,\n    getMissingRecordsCount,\n    cascadeSelection,\n    maxVisibleRowIndex,\n    getRowProps,\n    getLoadingRowProps,\n    isLoading = false,\n}: UseBuildRowsProps<TItem, TId, TFilter>) {\n    const buildRows = () => {\n        const rows: DataRowProps<TItem, TId>[] = [];\n        const pinned: Record<string, number> = {};\n        const pinnedByParentId: Record<string, number[]> = {};\n\n        const iterateNode = (\n            parentId: TId,\n            appendRows: boolean, // Will be false, if we are iterating folded nodes.\n        ): NodeStats => {\n            let currentLevelRows = 0;\n            let stats = getDefaultNodeStats();\n\n            const layerRows: DataRowProps<TItem, TId>[] = [];\n\n            const { ids, count, status } = tree.getItems(parentId);\n\n            if (status === PARTIALLY_LOADED) {\n                stats.isPartiallyLoaded = true;\n            }\n\n            for (let n = 0; n < ids.length; n++) {\n                const id = ids[n];\n                const item = tree.getById(id);\n                if (item === NOT_FOUND_RECORD) {\n                    continue;\n                }\n\n                const row = getRowProps(item, rows.length);\n                if (appendRows) {\n                    rows.push(row);\n                    layerRows.push(row);\n                    currentLevelRows++;\n                }\n\n                stats = getRowStats(row, stats, cascadeSelection);\n                row.isLastChild = n === ids.length - 1 && count === ids.length;\n                const assumedChildrenOfParent = getEstimatedChildrenCount(parentId);\n                row.indent = (!assumedChildrenOfParent && parentId !== undefined) ? 0 : row.path.length + 1;\n\n                const estimatedChildrenCount = getEstimatedChildrenCount(id);\n                if (estimatedChildrenCount !== undefined) {\n                    const { ids: childrenIds, status: childStatus } = tree.getItems(id);\n\n                    if (childStatus === PARTIALLY_LOADED) {\n                        stats.isPartiallyLoaded = true;\n                    }\n\n                    if (estimatedChildrenCount > 0) {\n                        if (childrenIds.length > 0) {\n                        // some children are loaded\n                            const childStats = iterateNode(id, appendRows && !row.isFolded);\n                            row.isChildrenChecked = row.isChildrenChecked || childStats.isSomeChecked;\n                            row.isChildrenSelected = row.isChildrenSelected || childStats.isSomeSelected;\n                            stats = mergeStats(stats, childStats);\n                        // while searching and no children in visible tree, no need to append placeholders.\n                        } else if (!dataSourceState.search && !row.isFolded && appendRows) {\n                        // children are not loaded\n                            const parentsWithRow = [...row.path, Tree.getPathItem(item, tree)];\n                            for (let m = 0; m < estimatedChildrenCount && rows.length < maxVisibleRowIndex; m++) {\n                                const loadingRow = getLoadingRowProps('_loading_' + rows.length, rows.length, parentsWithRow);\n                                loadingRow.indent = parentsWithRow.length + 1;\n                                loadingRow.isLastChild = m === estimatedChildrenCount - 1;\n                                rows.push(loadingRow);\n                                currentLevelRows++;\n                            }\n                        }\n                    }\n                }\n\n                row.isPinned = row.pin?.(row) ?? false;\n                if (row.isPinned) {\n                    pinned[idToKey(row.id)] = row.index;\n                    if (!pinnedByParentId[idToKey(row.parentId)]) {\n                        pinnedByParentId[idToKey(row.parentId)] = [];\n                    }\n                    pinnedByParentId[idToKey(row.parentId)]?.push(row.index);\n                }\n            }\n\n            const pathToParent = Tree.getPathById(parentId, tree);\n            const parent = tree.getById(parentId);\n            const parentPathItem = parent !== NOT_FOUND_RECORD ? [Tree.getPathItem(parent, tree)] : [];\n            const path = parentId ? [...pathToParent, ...parentPathItem] : pathToParent;\n            if (appendRows) {\n                let missingCount = getMissingRecordsCount(parentId, rows.length, currentLevelRows);\n                if (missingCount > 0) {\n                    stats.hasMoreRows = true;\n                }\n                // Append loading rows, stop at maxVisibleRowIndex (maximum assumed row visible)\n                while (rows.length < maxVisibleRowIndex && missingCount > 0) {\n                    const row = getLoadingRowProps('_loading_' + rows.length, rows.length, path);\n                    rows.push(row);\n                    layerRows.push(row);\n                    currentLevelRows++;\n                    missingCount--;\n                }\n            }\n\n            const isListFlat = path.length === 0 && !layerRows.some((r) => r.isFoldable);\n            if (isListFlat) {\n                layerRows.forEach((r) => {\n                    r.indent = 0;\n                });\n            }\n\n            return stats;\n        };\n\n        const stats = iterateNode(undefined, true);\n\n        return {\n            rows,\n            pinned,\n            pinnedByParentId,\n            stats,\n        };\n    };\n\n    return useMemo(() => buildRows(), [tree, dataSourceState.folded, dataSourceState.checked, isLoading, dataSourceState.foldAll]);\n}\n","import { useMemo } from 'react';\nimport { NodeStats } from './stats';\nimport { ITree } from '../tree';\n\nexport interface UseSelectAllProps<TItem, TId> {\n    tree: ITree<TItem, TId>;\n    selectAll?: boolean;\n    stats: NodeStats;\n    checked?: TId[];\n    areCheckboxesVisible: boolean;\n    handleSelectAll: (isChecked: boolean) => void;\n}\n\nexport function useSelectAll<TItem, TId>(props: UseSelectAllProps<TItem, TId>) {\n    const isSelectAllEnabled = useMemo(() => props.selectAll === undefined ? true : props.selectAll, [props.selectAll]);\n\n    const selectAll = useMemo(() => {\n        if (props.stats.isSomeCheckable && isSelectAllEnabled) {\n            // For case when we full list is loaded(Array, Async, Full loaded lazy) and all checkboxes are disabled\n            if (!props.stats.isPartiallyLoaded && !props.stats.isSomeCheckboxEnabled) {\n                return {\n                    value: props.stats.isAllDisabledChecked,\n                    onValueChange: props.handleSelectAll,\n                    isDisabled: true,\n                    indeterminate: props.checked && props.checked.length > 0 && !props.stats.isAllDisabledChecked,\n                };\n            }\n\n            // For case when list a partially loaded,\n            // we can't rely on props.stats.isSomeEnabledChecked in indeterminate calculation,\n            // because we might not have loaded checked items yet and can't check if they disabled or not\n            if (props.stats.isPartiallyLoaded) {\n                return {\n                    value: props.stats.isSomeCheckboxEnabled ? props.stats.isAllChecked : false,\n                    onValueChange: props.handleSelectAll,\n                    indeterminate: props.checked && props.checked.length > 0 && !props.stats.isAllChecked,\n                };\n            }\n\n            return {\n                value: props.stats.isSomeCheckboxEnabled ? props.stats.isAllChecked : false,\n                onValueChange: props.handleSelectAll,\n                indeterminate: props.checked && props.checked.length > 0 && !props.stats.isAllChecked && props.stats.isSomeEnabledChecked,\n            };\n        } else if (props.tree.getItems().ids.length === 0 && props.areCheckboxesVisible && isSelectAllEnabled) {\n            // Nothing loaded yet, but we guess that something is checkable. Add disabled checkbox for less flicker.\n            return {\n                value: false,\n                onValueChange: () => {},\n                isDisabled: true,\n                indeterminate: props.checked?.length > 0,\n            };\n        }\n        return null;\n    }, [\n        props.tree,\n        props.areCheckboxesVisible,\n        props.checked,\n        props.stats,\n        isSelectAllEnabled,\n        props.handleSelectAll,\n    ]);\n\n    return selectAll;\n}\n","import { useCallback } from 'react';\nimport { DataRowProps } from '../../../../types';\nimport { idToKey } from '../helpers';\n\nexport interface UsePinnedRowsProps<TItem, TId> {\n    rows: DataRowProps<TItem, TId>[];\n    pinned: Record<string, number>;\n    pinnedByParentId: Record<string, number[]>;\n}\n\nexport function usePinnedRows<TItem, TId>({\n    rows,\n    pinned,\n    pinnedByParentId,\n}: UsePinnedRowsProps<TItem, TId>) {\n    const getLastPinnedBeforeRow = useCallback((row: DataRowProps<TItem, TId>, pinnedIndexes: number[]) => {\n        const isBeforeOrEqualToRow = (pinnedRowIndex: number) => {\n            const pinnedRow = rows[pinnedRowIndex];\n            if (!pinnedRow) {\n                return false;\n            }\n            return row.index >= pinnedRow.index;\n        };\n\n        let foundRowIndex = -1;\n        for (const pinnedRowIndex of pinnedIndexes) {\n            if (isBeforeOrEqualToRow(pinnedRowIndex)) {\n                foundRowIndex = pinnedRowIndex;\n            } else if (foundRowIndex !== -1) {\n                break;\n            }\n        }\n\n        if (foundRowIndex === -1) {\n            return undefined;\n        }\n        return foundRowIndex;\n    }, [rows]);\n\n    const getLastHiddenPinnedByParent = useCallback((row: DataRowProps<TItem, TId>, alreadyAdded: TId[]) => {\n        const pinnedIndexes = pinnedByParentId[idToKey(row.parentId)];\n        if (!pinnedIndexes || !pinnedIndexes.length) {\n            return undefined;\n        }\n\n        const lastPinnedBeforeRow = getLastPinnedBeforeRow(row, pinnedIndexes);\n        if (lastPinnedBeforeRow === undefined) {\n            return undefined;\n        }\n\n        const lastHiddenPinned = rows[lastPinnedBeforeRow];\n        if (!lastHiddenPinned || alreadyAdded.includes(lastHiddenPinned.id)) {\n            return undefined;\n        }\n\n        return lastHiddenPinned;\n    }, [pinnedByParentId, rows, getLastPinnedBeforeRow]);\n\n    const withPinnedRows = useCallback((allRows: DataRowProps<TItem, TId>[]) => {\n        if (!allRows.length) return [];\n\n        const rowsWithPinned: DataRowProps<TItem, TId>[] = [];\n        const alreadyAdded = allRows.map(({ id }) => id);\n        const [firstRow] = allRows;\n        firstRow.path.forEach((item) => {\n            const pinnedIndex = pinned[idToKey(item.id)];\n            if (pinnedIndex === undefined) return;\n\n            const parent = rows[pinnedIndex];\n            if (!parent || alreadyAdded.includes(parent.id)) return;\n\n            rowsWithPinned.push(parent);\n            alreadyAdded.push(parent.id);\n        });\n\n        const lastHiddenPinned = getLastHiddenPinnedByParent(firstRow, alreadyAdded);\n        if (lastHiddenPinned) {\n            rowsWithPinned.push(lastHiddenPinned);\n        }\n\n        return rowsWithPinned.concat(allRows);\n    }, [pinned, rows, getLastHiddenPinnedByParent]);\n\n    return withPinnedRows;\n}\n","import { DataRowProps } from '../../../../types';\n\ninterface UseUpdateRowProps<TItem, TId> {\n    rows: DataRowProps<TItem, TId>[];\n    updateRowOptions: (row: DataRowProps<TItem, TId>) => DataRowProps<TItem, TId>;\n}\n\nexport function useUpdateRowOptions<TItem, TId>({\n    rows, updateRowOptions,\n}: UseUpdateRowProps<TItem, TId>) {\n    return rows.map((row) => {\n        if (!row.isLoading) {\n            return updateRowOptions(row);\n        }\n        return row;\n    });\n}\n","import { useCallback, useMemo } from 'react';\nimport { DataSourceListProps } from '../../../../types';\nimport { useCheckingService, useFoldingService, useFocusService, useSelectingService } from './services';\nimport { useDataRowProps } from './useDataRowProps';\nimport { useBuildRows } from './useBuildRows';\nimport { useSelectAll } from './useSelectAll';\nimport { usePinnedRows } from './usePinnedRows';\nimport { useUpdateRowOptions } from './useUpdateRowProps';\nimport { CommonTreeConfig, ITreeLoadingState } from '../tree/hooks/strategies/types/common';\nimport { NOT_FOUND_RECORD, ITree } from '../tree';\nimport { EMPTY, FULLY_LOADED } from '../tree/constants';\nimport { CascadeSelectionService } from './services/useCascadeSelectionService';\nimport { GetItemStatus } from '../tree/hooks/strategies/types';\nimport { isInProgress } from '../helpers';\n\n/**\n * `useDataRows` configuration.\n */\nexport interface UseDataRowsProps<TItem, TId, TFilter = any> extends\n    Omit<CommonTreeConfig<TItem, TId, TFilter>, 'patch'>,\n    ITreeLoadingState,\n    Partial<CascadeSelectionService<TItem, TId>>,\n    GetItemStatus<TId> {\n\n    /**\n     * Tree-like data, rows to be built from.\n     */\n    tree: ITree<TItem, TId>;\n}\n\n/**\n * Hook, which builds rows, based on the tree.\n * @returns rows and other IDataSourceView fields.\n */\nexport function useDataRows<TItem, TId, TFilter = any>(\n    props: UseDataRowsProps<TItem, TId, TFilter>,\n) {\n    const {\n        tree,\n        getId,\n        getParentId,\n        dataSourceState,\n\n        getRowOptions,\n        rowOptions,\n        getItemStatus,\n\n        cascadeSelection,\n        isLoading,\n        isFetching,\n        setDataSourceState,\n        isFoldedByDefault,\n        getCompleteTreeForCascadeSelection = async () => tree,\n    } = props;\n\n    const maxVisibleRowIndex = useMemo(\n        () => dataSourceState.topIndex + dataSourceState.visibleCount,\n        [tree, dataSourceState.topIndex, dataSourceState.visibleCount],\n    );\n\n    const getEstimatedChildrenCount = useCallback((id: TId) => {\n        if (id === undefined) {\n            const { count, status } = tree.getItems(id);\n            return count !== undefined && status === FULLY_LOADED ? count : undefined;\n        }\n\n        const item = tree.getById(id);\n        if (item === NOT_FOUND_RECORD) return undefined;\n\n        const nodeInfo = tree.getItems(id);\n        if ('assumedCount' in nodeInfo && nodeInfo.assumedCount === undefined) {\n            return undefined;\n        }\n\n        const { count, status } = nodeInfo;\n        if (count !== undefined && (status === FULLY_LOADED || status === EMPTY)) {\n            // nodes are already loaded, and we know the actual count\n            return count;\n        }\n\n        return nodeInfo.assumedCount;\n    }, [props, tree]);\n\n    const getMissingRecordsCount = useCallback((id: TId, totalRowsCount: number, loadedChildrenCount: number) => {\n        const { count } = tree.getItems(id);\n\n        // Estimate how many more nodes there are at current level, to put 'loading' placeholders.\n        if (count !== undefined) {\n            // Exact count known\n            return count - loadedChildrenCount;\n        }\n\n        const estimatedChildCount = getEstimatedChildrenCount(id);\n        // estimatedChildCount = undefined for top-level rows only.\n        if (id === undefined && totalRowsCount < maxVisibleRowIndex) {\n            return maxVisibleRowIndex - totalRowsCount; // let's put placeholders down to the bottom of visible list\n        }\n\n        if (estimatedChildCount > loadedChildrenCount) {\n            // According to assumedCount (put into estimatedChildCount), there are more rows on this level\n            return estimatedChildCount - loadedChildrenCount;\n        }\n\n        // We have a bad estimate - it even less that actual items we have\n        // This would happen is assumedCount provides a guess count, and we scroll thru children past this count\n        // let's guess we have at least 1 item more than loaded\n        return 1;\n    }, [maxVisibleRowIndex, tree, getEstimatedChildrenCount]);\n\n    const { handleOnCheck, isRowChecked, isRowChildrenChecked, isItemCheckable, handleSelectAll } = useCheckingService({\n        tree,\n        dataSourceState,\n        setDataSourceState,\n        cascadeSelection,\n        getParentId,\n        rowOptions,\n        getRowOptions,\n        getCompleteTreeForCascadeSelection,\n        getItemStatus,\n    });\n\n    const foldingService = useFoldingService({\n        dataSourceState, setDataSourceState, isFoldedByDefault, getId,\n    });\n\n    const focusService = useFocusService({ setDataSourceState });\n\n    const selectingService = useSelectingService({\n        tree,\n        getParentId,\n        dataSourceState,\n        setDataSourceState,\n    });\n\n    const { getRowProps, getUnknownRowProps, getLoadingRowProps, updateRowOptions } = useDataRowProps<TItem, TId, TFilter>({\n        tree,\n        getId,\n\n        dataSourceState,\n\n        rowOptions,\n        getRowOptions,\n\n        getEstimatedChildrenCount,\n\n        handleOnCheck,\n        isRowChecked,\n        isRowChildrenChecked,\n        isItemCheckable,\n\n        ...foldingService,\n        ...selectingService,\n        ...focusService,\n    });\n\n    const { rows: allRows, pinned, pinnedByParentId, stats } = useBuildRows({\n        tree,\n        dataSourceState,\n        cascadeSelection,\n        maxVisibleRowIndex,\n        getEstimatedChildrenCount,\n        getMissingRecordsCount,\n        getRowProps,\n        getLoadingRowProps,\n        isLoading,\n    });\n\n    const updatedRows = useUpdateRowOptions({ rows: allRows, updateRowOptions });\n\n    const withPinnedRows = usePinnedRows({\n        rows: updatedRows,\n        pinned,\n        pinnedByParentId,\n    });\n\n    const selectAll = useSelectAll({\n        tree,\n        checked: dataSourceState.checked,\n        selectAll: props.selectAll,\n        stats,\n        areCheckboxesVisible: rowOptions?.checkbox?.isVisible,\n        handleSelectAll,\n    });\n\n    const isItemLoaded = (item: TItem | typeof NOT_FOUND_RECORD): item is TItem => {\n        return item !== NOT_FOUND_RECORD;\n    };\n\n    const getById = (id: TId, index: number) => {\n        const itemStatus = getItemStatus?.(id);\n        const item = tree.getById(id);\n        if (!isItemLoaded(item)) {\n            if (isInProgress(itemStatus)) {\n                return getLoadingRowProps(id, index, []);\n            }\n\n            return getUnknownRowProps(id, index, []);\n        }\n\n        return getRowProps(item, index);\n    };\n\n    const listProps = useMemo((): DataSourceListProps => {\n        const itemsInfo = tree.getItems(undefined);\n        const { count, ids } = itemsInfo;\n        const isTreeLikeStructure = ids.some((id) => {\n            const info = tree.getItems(id);\n            return ('assumedCount' in info) || info.ids.length > 0;\n        });\n\n        const isFlatList = !isTreeLikeStructure;\n        const completeFlatListRowsCount = isFlatList && count != null ? count : undefined;\n        let rowsCount;\n        if (completeFlatListRowsCount !== undefined) {\n            // We have a flat list, and know exact count of items on top level. So, we can have an exact number of rows w/o iterating the whole tree.\n            rowsCount = completeFlatListRowsCount;\n        } else if (!stats.hasMoreRows) {\n            // We are at the bottom of the list. Some children might still be loading, but that's ok - we'll re-count everything after we load them.\n            rowsCount = updatedRows.length;\n        } else {\n            // We definitely have more rows to show below the last visible row.\n            // We need to add at least 1 row below, so VirtualList or other component would not detect the end of the list, and query loading more rows later.\n            // We have to balance this number.\n            // To big - would make scrollbar size to shrink when we hit bottom\n            // To small - and VirtualList will re-request rows until it will fill it's last block.\n            // So, it should be at least greater than VirtualList block size (default is 20)\n            // Probably, we'll move this const to props later if needed;\n            const rowsToAddBelowLastKnown = 20;\n\n            rowsCount = Math.max(updatedRows.length, maxVisibleRowIndex + rowsToAddBelowLastKnown);\n        }\n\n        return {\n            rowsCount,\n            knownRowsCount: updatedRows.length,\n            exactRowsCount: updatedRows.length,\n            selectAll,\n            isReloading: isFetching,\n        };\n    }, [updatedRows.length, selectAll, stats.hasMoreRows, maxVisibleRowIndex, tree, isFetching]);\n\n    const rows = useMemo(\n        () => {\n            const from = dataSourceState.topIndex;\n            const count = dataSourceState.visibleCount;\n            const visibleRowsWithPins = withPinnedRows(updatedRows.slice(from, from + count));\n            if (stats.hasMoreRows) {\n                // We don't run rebuild rows on scrolling. We rather wait for the next load to happen.\n                // So there can be a case when we haven't updated rows (to add more loading rows), and view is scrolled down\n                // We need to add more loading rows in such case.\n                const lastRow = updatedRows[updatedRows.length - 1];\n\n                while (visibleRowsWithPins.length < count && from + visibleRowsWithPins.length < listProps.rowsCount) {\n                    const index = from + visibleRowsWithPins.length;\n                    const row = getLoadingRowProps('_loading_' + index, index);\n                    row.indent = lastRow.indent;\n                    row.path = lastRow.path;\n                    row.depth = lastRow.depth;\n                    visibleRowsWithPins.push(row);\n                }\n            }\n\n            return visibleRowsWithPins;\n        },\n        [\n            tree,\n            updatedRows,\n            dataSourceState.topIndex,\n            dataSourceState.visibleCount,\n            withPinnedRows,\n            listProps,\n            getLoadingRowProps,\n        ],\n    );\n\n    const getSelectedRowsCount = () => {\n        const count = dataSourceState.checked?.length ?? 0;\n        if (!count) {\n            return (dataSourceState.selectedId !== undefined && dataSourceState.selectedId !== null) ? 1 : 0;\n        }\n\n        return count;\n    };\n\n    const clearAllChecked = useCallback(() => handleSelectAll(false), [handleSelectAll]);\n\n    return {\n        listProps,\n        rows,\n        getSelectedRowsCount,\n        getById,\n        clearAllChecked,\n\n        selectAll,\n    };\n}\n","import {\n    BaseListViewProps, DataSourceState, IDataSource, IDataSourceView, SetDataSourceState,\n} from '../../types/dataSources';\nimport { ITree } from './views';\n\nexport abstract class BaseDataSource<TItem, TId, TFilter = any> implements IDataSource<TItem, TId, TFilter> {\n    protected trees = new Map<ITree<TItem, TId>, () => void>();\n\n    constructor(public props: BaseListViewProps<TItem, TId, TFilter>) {}\n\n    abstract getById(id: TId): TItem | void;\n    abstract setItem(item: TItem): void;\n\n    abstract useView(\n        value: DataSourceState<TFilter, TId>,\n        onValueChange: SetDataSourceState<TFilter, TId>,\n        options?: Partial<BaseListViewProps<TItem, TId, TFilter>>,\n        deps?: any[],\n    ): IDataSourceView<TItem, TId, TFilter>;\n\n    public abstract setProps(newProps: BaseListViewProps<TItem, TId, TFilter>): void;\n\n    public destroy() {\n        this.trees.clear();\n    }\n\n    public getId = (item: TItem & { id?: TId }): TId => {\n        if (item == null) return null;\n\n        const id = this.props.getId?.(item) || item.id;\n\n        if (id == null) {\n            throw new Error(`Item ID not found. Check 'getId' prop value. Item: ${JSON.stringify(item)}`);\n        }\n\n        return id;\n    };\n\n    protected reload() { \n        this.trees.forEach((reload) => reload());\n    }\n}\n","import { useEffect, useMemo } from 'react';\nimport { IDataSourceView, DataSourceState, SetDataSourceState } from '../../types/dataSources';\nimport { BaseDataSource } from './BaseDataSource';\nimport { ArrayListViewProps, useCascadeSelectionService, useDataRows, ITree, useTree } from './views';\nimport { ItemsStorage } from './views/tree/ItemsStorage';\n\nexport interface ArrayDataSourceProps<TItem, TId, TFilter> extends ArrayListViewProps<TItem, TId, TFilter> {}\n\nexport class ArrayDataSource<TItem = any, TId = any, TFilter = any> extends BaseDataSource<TItem, TId, TFilter> {\n    props: ArrayDataSourceProps<TItem, TId, TFilter>;\n    tree: ITree<TItem, TId>;\n\n    itemsStorage: ItemsStorage<TItem, TId>;\n    \n    constructor(props: ArrayDataSourceProps<TItem, TId, TFilter>) {\n        super(props);\n        this.setProps(props);\n        const params = { getId: this.getId, complexIds: props.complexIds };\n        this.itemsStorage = new ItemsStorage({ items: props.items, params: params });\n    }\n\n    public setProps(props: ArrayDataSourceProps<TItem, TId, TFilter>) {\n        this.props = props;\n    }\n\n    public getById = (id: TId): TItem | undefined => {\n        return this.itemsStorage.getItemsMap().get(id);\n    };\n\n    protected defaultGetParentId = (item: TItem) => {\n        return (item as any)['parentId'];\n    };\n\n    setItem(item: TItem): void {\n        const id = this.getId(item);\n        const prevItem = this.getById(id);\n        if (!prevItem) {\n            this.itemsStorage.setItems([item]);\n        }\n    }\n\n    useView(\n        value: DataSourceState<TFilter, TId>,\n        onValueChange: SetDataSourceState<TFilter, TId>,\n        options?: Partial<ArrayListViewProps<TItem, TId, TFilter>>,\n        deps: any[] = [],\n    ): IDataSourceView<TItem, TId, TFilter> {\n        const { items, ...restDSProps } = this.props;\n\n        // eslint-disable-next-line react-hooks/rules-of-hooks\n        const { tree, selectionTree, reload, totalCount, ...restProps } = useTree({\n            type: 'sync',\n            ...restDSProps,\n            ...options,\n            \n            items,\n            setItems: this.itemsStorage.setItems,\n            dataSourceState: value,\n            setDataSourceState: onValueChange,\n            // These defaults are added for compatibility reasons.\n            // We'll require getId and getParentId callbacks in other APIs, including the views.\n            getId: this.getId,\n            getParentId: options?.getParentId ?? this.props.getParentId ?? this.defaultGetParentId,\n        }, [...deps, this]);\n\n        // eslint-disable-next-line react-hooks/rules-of-hooks\n        useEffect(() => {\n            this.trees.set(tree, reload);\n            return () => { \n                this.trees.delete(tree);\n            };\n        }, [tree, reload]);\n\n        // eslint-disable-next-line react-hooks/rules-of-hooks\n        const cascadeSelectionService = useCascadeSelectionService({\n            tree: selectionTree,\n        });\n\n        // eslint-disable-next-line react-hooks/rules-of-hooks\n        const { rows, listProps, selectAll, getById, getSelectedRowsCount, clearAllChecked } = useDataRows({\n            tree,\n            ...restProps,\n            ...cascadeSelectionService,\n        });\n\n        // eslint-disable-next-line react-hooks/rules-of-hooks\n        return useMemo(() => ({\n            getVisibleRows: () => rows,\n            getListProps: () => ({ ...listProps, totalCount }),\n            selectAll,\n            getConfig: () => restProps,\n            reload,\n            getById,\n            getSelectedRowsCount,\n            clearAllChecked,\n        }), [\n            rows,\n            listProps,\n            selectAll,\n            restProps,\n            totalCount,\n            reload,\n            getById,\n            getSelectedRowsCount,\n            clearAllChecked,\n        ]);\n    }\n}\n","import { ColumnsConfig, DataColumnProps } from '../types';\nimport { applyColumnsConfig, getColumnsConfig } from '../helpers';\n\nexport const useColumnsConfig = <TItem, TId>(initialColumns: DataColumnProps<TItem, TId>[], columnsConfig: ColumnsConfig) => {\n    const config = getColumnsConfig(initialColumns, columnsConfig);\n    const defaultConfig = getColumnsConfig(initialColumns, {});\n    const columns = applyColumnsConfig(initialColumns, config);\n\n    return { columns, config, defaultConfig };\n};\n","import { useEffect, useLayoutEffect } from 'react';\n\n/**\n * NextJs doesn't support useLayoutEffect, this code suppresses the warning by replacing useLayoutEffect to useEffect in SSR.\n * See also the discussion here: https://github.com/facebook/react/issues/14927#issuecomment-572720368\n */\nexport const useLayoutEffectSafeForSsr = typeof window !== 'undefined' ? useLayoutEffect : useEffect;\n","import type { ScrollToConfig, VirtualListState } from '../../types';\nimport { RowsInfo, VirtualListInfo } from './types';\n\nexport const getUpdatedRowHeights = (virtualListInfo: VirtualListInfo) => {\n    const newRowHeights = [...virtualListInfo.rowHeights];\n    const { listContainer, rowsSelector } = virtualListInfo;\n    const rows = rowsSelector\n        ? listContainer.querySelectorAll(rowsSelector)\n        : listContainer.children;\n\n    Array.from<Element>(rows).forEach((node, index) => {\n        const topIndex = virtualListInfo.value.topIndex || 0;\n        const { height } = node.getBoundingClientRect();\n        if (!height) return;\n        newRowHeights[topIndex + index] = height;\n    });\n    return newRowHeights;\n};\n\nexport const getAverageRowHeight = (rowHeights: Array<number | undefined>) => {\n    const notEmptyRowsHeights = rowHeights.filter((height) => height !== undefined);\n    if (!notEmptyRowsHeights.length) {\n        return 1;\n    }\n    const totalRowHeights = notEmptyRowsHeights.reduce((sum, next) => sum + next, 0);\n    return totalRowHeights / notEmptyRowsHeights.length;\n};\n\nexport const getUpdatedRowOffsets = (\n    { rowOffsets, rowsCount, listOffset, rowHeights, averageRowHeight }: VirtualListInfo,\n) => {\n    const newRowOffsets = [...rowOffsets];\n    for (let n = 0; n <= rowsCount; n++) {\n        newRowOffsets[n] = n === 0\n            ? listOffset\n            : newRowOffsets[n - 1] + (rowHeights[n - 1] || averageRowHeight);\n    }\n    return newRowOffsets;\n};\n\nexport const getNewEstimatedContainerHeight = (rowOffsets: number[], rowsCount: number, listOffset: number) =>\n    rowOffsets[rowsCount] - listOffset;\n\nexport const getUpdatedRowsInfo = (\n    virtualListInfo: VirtualListInfo,\n): RowsInfo => {\n    if (!virtualListInfo.scrollContainer\n        || !virtualListInfo.listContainer\n        || virtualListInfo.listOffset == null\n        || !virtualListInfo.value\n    ) {\n        return {\n            rowHeights: virtualListInfo.rowHeights,\n            rowOffsets: virtualListInfo.rowOffsets,\n            estimatedHeight: virtualListInfo.estimatedHeight,\n        };\n    }\n    const rowHeights = getUpdatedRowHeights(virtualListInfo);\n    const averageRowHeight = getAverageRowHeight(rowHeights);\n    const rowOffsets = getUpdatedRowOffsets({ ...virtualListInfo, rowHeights, averageRowHeight });\n\n    const estimatedHeight = getNewEstimatedContainerHeight(\n        rowOffsets,\n        virtualListInfo.rowsCount,\n        virtualListInfo.listOffset,\n    );\n\n    return {\n        estimatedHeight,\n        rowHeights,\n        rowOffsets,\n        averageRowHeight,\n    };\n};\n\nconst getNewTopIndex = (info: VirtualListInfo) => {\n    const { overdrawRows, blockSize, value } = info;\n    let newTopIndex = getRealTopIndex(info);\n    newTopIndex = newTopIndex - overdrawRows;\n    newTopIndex = Math.max(0, newTopIndex);\n\n    const topIndexDiff = Math.abs(value.topIndex - newTopIndex);\n    // Number of rows to be scrolled up or down to trigger topIndex change.\n    // This tolerance is required to avoid problems when scroll position is close to blocks boundaries, and even tiny difference\n    // in row heights (e.g. 1px margin collapse) can cause endless loop of re-renderings\n    const loadingThreshold = 5;\n    if (topIndexDiff < loadingThreshold) {\n        return value.topIndex;\n    }\n\n    return Math.floor(newTopIndex / blockSize) * blockSize; // Align to blockSize\n};\n\nconst getNewBottomIndex = (info: VirtualListInfo) => {\n    const { rowsCount, overdrawRows, blockSize } = info;\n\n    let bottomIndex = getRealBottomIndex(info);\n    bottomIndex = bottomIndex + overdrawRows; // draw more rows at the bottom to remove visible blank areas while scrolling down\n    bottomIndex = Math.floor(bottomIndex / blockSize) * blockSize; // Align to block size\n    return Math.min(bottomIndex, rowsCount ?? 0); // clamp to rowsCount\n};\n\nexport const getRealTopIndex = ({ rowsCount, scrollContainer, rowOffsets }: VirtualListInfo) => {\n    let realTopIndex = 0;\n    const containerScrollTop = scrollContainer?.scrollTop ?? 0;\n    while (realTopIndex < rowsCount && rowOffsets[realTopIndex] < containerScrollTop) {\n        realTopIndex += 1;\n    }\n    return realTopIndex;\n};\n\nconst getRealBottomIndex = ({ rowsCount, scrollContainer, rowOffsets, value: { topIndex } }: VirtualListInfo) => {\n    let bottomIndex = topIndex;\n    const containerScrollTop = scrollContainer?.scrollTop ?? 0;\n\n    const containerScrollBottom = containerScrollTop + scrollContainer?.clientHeight ?? 0;\n    while (bottomIndex < rowsCount && rowOffsets[bottomIndex] < containerScrollBottom) {\n        bottomIndex++;\n    }\n    return bottomIndex;\n};\n\nexport const getRowsToFetchForScroll = (virtualListInfo: VirtualListInfo) => {\n    const topIndex = getNewTopIndex(virtualListInfo);\n    const bottomIndex = getNewBottomIndex({ ...virtualListInfo, value: { ...virtualListInfo.value, topIndex } });\n\n    const { value, blockSize } = virtualListInfo;\n    // We never reduce visible count intentionally - it can be set so a larger value intentionally.\n    // Also, reducing it can cause bouncing between two near values, causing unnecessary re-renders.\n    const visibleCount = Math.max(value.visibleCount ?? blockSize, bottomIndex - topIndex);\n\n    return { visibleCount, topIndex };\n};\n\nexport const getScrollToCoordinate = (\n    info: VirtualListInfo,\n    scrollTo: ScrollToConfig,\n) => {\n    const topCoordinate = getTopCoordinate(info, scrollTo);\n    const { index, align } = scrollTo;\n    if (!align || align === 'top') {\n        return topCoordinate;\n    }\n\n    const realTopIndex = getRealTopIndex(info);\n    const realBottomIndex = getRealBottomIndex({\n        ...info, value: { ...info.value, topIndex: realTopIndex },\n    });\n\n    if (index < realTopIndex) {\n        return topCoordinate;\n    }\n\n    if (index >= realBottomIndex - 1) {\n        return getTopCoordinate(info, { ...scrollTo, index: scrollTo.index + 1 }) - info.scrollContainer?.clientHeight;\n    }\n\n    return undefined;\n};\n\nexport const getTopCoordinate = (\n    { rowOffsets, listOffset, value, rowHeights }: VirtualListInfo,\n    scrollTo: ScrollToConfig,\n) => {\n    let rowCoordinate = rowOffsets[scrollTo.index];\n    if (rowCoordinate === undefined) {\n        const { topIndex = 0, visibleCount = 0 } = value;\n        const visibleRowsCount = topIndex + visibleCount;\n        const assumedRowsCount = Math.max(scrollTo.index - visibleRowsCount, 0);\n        const averageRowHeight = getAverageRowHeight(rowHeights);\n        const assumedRowsHeight = assumedRowsCount * averageRowHeight;\n        const heightOfExistingRows = rowOffsets[visibleRowsCount] ?? rowOffsets[rowOffsets.length - 1];\n        rowCoordinate = heightOfExistingRows + assumedRowsHeight;\n    }\n    return rowCoordinate - listOffset;\n};\n\nexport const assumeHeightForScrollToIndex = (value: VirtualListState, estimatedHeight: number, averageRowHeight: number) => {\n    const { topIndex = 0, visibleCount = 0, scrollTo } = value;\n    const scrollToIndex = scrollTo?.index ?? 0;\n    const skipRowsCount = Math.max(0, scrollToIndex - (topIndex + visibleCount - 1));\n    return estimatedHeight + skipRowsCount * averageRowHeight;\n};\n\nexport const getTopIndexWithOffset = (index: number, overdrawRows: number, blockSize: number) => {\n    let topIndex = index - overdrawRows; // draw more rows at the top to remove visible blank areas while scrolling up\n    topIndex = Math.floor(topIndex / blockSize) * blockSize; // Align to blockSize\n    return Math.max(0, topIndex);\n};\n\nexport const getOffsetYForIndex = (index: number | null | undefined, rowOffsets: number[], listOffset: number) => {\n    if (rowOffsets.length === 0 || index == null) return 0;\n    const offsetY = rowOffsets[index] - listOffset;\n    if (isNaN(offsetY)) {\n        return 0;\n    }\n    return offsetY;\n};\n","import * as React from 'react';\nimport type { ScrollToConfig } from '../../types';\nimport { useLayoutEffectSafeForSsr } from '../../ssr/useLayoutEffectSafeForSsr';\nimport {\n    getRowsToFetchForScroll, getUpdatedRowsInfo, assumeHeightForScrollToIndex,\n    getOffsetYForIndex, getScrollToCoordinate, getRealTopIndex, getTopIndexWithOffset,\n} from './utils';\nimport { UseVirtualListProps, UseVirtualListApi, RowsInfo } from './types';\nimport { usePrevious } from '../usePrevious';\nimport { devLogger } from '../../helpers';\n\nexport function useVirtualList<List extends HTMLElement = any, ScrollContainer extends HTMLElement = any>(\n    props: UseVirtualListProps,\n): UseVirtualListApi<List, ScrollContainer> {\n    const {\n        onValueChange,\n        value,\n        rowsCount,\n        onScroll,\n        blockSize = 20,\n        overdrawRows = 20,\n        rowsSelector,\n    } = props;\n    const [estimatedHeight, setEstimatedHeight] = React.useState<number>(0);\n    const [listOffset, setListOffset] = React.useState<number>();\n    const [scrolledTo, setScrolledTo] = React.useState<ScrollToConfig>(null);\n    const listContainer = React.useRef<List>(undefined);\n    const scrollContainer = React.useRef<ScrollContainer>(undefined);\n    const rowHeights = React.useRef<number[]>([]);\n    const rowOffsets = React.useRef<number[]>([]);\n    const scrollContainerHeightChangesCount = React.useRef<number>(0);\n    const scrollContainerHeightIsNotLimited = React.useRef(false);\n    const prevScrollContainerClientHeight = usePrevious(scrollContainer.current?.clientHeight);\n\n    const virtualListInfo = React.useMemo(() => ({\n        rowHeights: rowHeights.current,\n        rowOffsets: rowOffsets.current,\n        value,\n        rowsCount,\n        blockSize,\n        overdrawRows,\n        listOffset,\n        estimatedHeight,\n        rowsSelector,\n    }), [\n        rowHeights.current,\n        rowOffsets.current,\n        value,\n        rowsCount,\n        blockSize,\n        overdrawRows,\n        listOffset,\n        estimatedHeight,\n        rowsSelector,\n    ]);\n\n    useLayoutEffectSafeForSsr(() => {\n        if (__DEV__) {\n            if (scrollContainer.current?.clientHeight\n                && prevScrollContainerClientHeight\n                && scrollContainer.current?.clientHeight !== prevScrollContainerClientHeight\n            ) {\n                ++scrollContainerHeightChangesCount.current;\n            } else {\n                scrollContainerHeightChangesCount.current = 0;\n            }\n            if (scrollContainerHeightChangesCount.current > 20 && !scrollContainerHeightIsNotLimited.current) {\n                scrollContainerHeightIsNotLimited.current = true;\n                devLogger.warn('[VirtualList]: The scroll container height is not limited. Please ensure that the VirtualList\\'s parent container has a defined, limited height.');\n            }\n        }\n    });\n\n    useLayoutEffectSafeForSsr(() => {\n        // Set listOffset only for the first time on list initialization\n        if (!scrollContainer.current || !listContainer.current || listOffset !== undefined) return;\n        const { top: scrollContainerTop, bottom } = scrollContainer.current.getBoundingClientRect();\n        const { top: listContainerTop } = listContainer.current.getBoundingClientRect();\n        if (bottom === scrollContainerTop) return;\n\n        const newListOffset = listContainerTop - scrollContainerTop;\n\n        setListOffset(newListOffset);\n    });\n\n    const getTopIndexAndVisibleCountOnScroll = React.useCallback(() => {\n        if (!scrollContainer.current || !virtualListInfo.value) {\n            return {\n                visibleCount: virtualListInfo.value?.visibleCount,\n                topIndex: virtualListInfo.value?.topIndex,\n            };\n        }\n\n        return getRowsToFetchForScroll({\n            ...virtualListInfo,\n            scrollContainer: scrollContainer.current,\n            listContainer: listContainer.current,\n        });\n    }, [virtualListInfo]);\n\n    useLayoutEffectSafeForSsr(() => {\n        const rowsInfo = getUpdatedRowsInfo({\n            ...virtualListInfo,\n            scrollContainer: scrollContainer.current,\n            listContainer: listContainer.current,\n        });\n        rowHeights.current = rowsInfo.rowHeights;\n        rowOffsets.current = rowsInfo.rowOffsets;\n        if (scrollContainer.current && value) onScroll?.(scrollContainer.current);\n        if (!scrollContainer.current || !value) return;\n\n        if (value?.scrollTo !== scrolledTo && value?.scrollTo?.index != null) {\n            handleForceScrollToIndex(rowsInfo);\n        } else {\n            if (!scrollContainerHeightIsNotLimited.current) {\n                handleScrollOnRerender(rowsInfo);\n            }\n        }\n    });\n\n    useLayoutEffectSafeForSsr(() => {\n        const maxBottomIndex = Math.ceil(rowsCount / blockSize) * blockSize;\n        if (virtualListInfo.value?.topIndex + virtualListInfo.value?.visibleCount > maxBottomIndex) {\n            const newTopIndex = Math.max(maxBottomIndex - blockSize, 0);\n            onValueChange({ ...value, topIndex: newTopIndex, visibleCount: blockSize });\n        }\n    }, [rowsCount]);\n\n    const handleForceScrollToIndex = (rowsInfo: RowsInfo) => {\n        const assumedHeight = assumeHeightForScrollToIndex(value, rowsInfo.estimatedHeight, rowsInfo.averageRowHeight);\n        const estimatedHeightToSet = rowsCount >= value.scrollTo.index\n            ? rowsInfo.estimatedHeight\n            : assumedHeight;\n        setEstimatedHeight(estimatedHeightToSet);\n        scrollToIndex(value.scrollTo);\n    };\n\n    const handleScrollOnRerender = (rowsInfo: RowsInfo) => {\n        const { topIndex } = value;\n        const { topIndex: newTopIndex, visibleCount } = getNewRowsOnScroll();\n\n        if (estimatedHeight !== rowsInfo.estimatedHeight) {\n            setEstimatedHeight(rowsInfo.estimatedHeight);\n        }\n        if (topIndex !== newTopIndex || visibleCount !== value.visibleCount) {\n            onValueChange({ ...value, topIndex: newTopIndex, visibleCount });\n        }\n    };\n\n    const getNewRowsOnScroll = React.useCallback(() => {\n        const { topIndex, visibleCount } = getTopIndexAndVisibleCountOnScroll();\n        if (topIndex !== value.topIndex || visibleCount > value.visibleCount) {\n            return { topIndex, visibleCount };\n        }\n\n        return value;\n    }, [getTopIndexAndVisibleCountOnScroll, onValueChange, value]);\n\n    const scrollContainerToPosition = React.useCallback(\n        (scrollTo: ScrollToConfig) => {\n            const topCoordinate = getScrollToCoordinate({\n                ...virtualListInfo,\n                scrollContainer: scrollContainer.current,\n                listContainer: listContainer.current,\n            }, scrollTo);\n            if (topCoordinate === undefined) {\n                return [true, true]; // already at the necessary position, scroll doesn't have to be performed.\n            }\n\n            if (isNaN(topCoordinate)) {\n                return [false, false];\n            }\n\n            scrollContainer.current.scrollTo({ top: topCoordinate, behavior: scrollTo.behavior });\n            const scrollPositionDiff = (+topCoordinate.toFixed(0)) - (+scrollContainer.current.scrollTop.toFixed(0));\n\n            return [\n                scrollPositionDiff <= 1 // if scroll position is equal to expected one\n                && virtualListInfo.rowHeights[scrollTo.index] !== undefined, // and required row with necessary index is present\n                true,\n            ];\n        },\n        [scrollContainer.current, rowOffsets.current, virtualListInfo],\n    );\n\n    const scrollToIndex = React.useCallback(\n        (scrollTo: ScrollToConfig) => {\n            const topIndex = getTopIndexWithOffset(scrollTo.index, overdrawRows, blockSize);\n            const { visibleCount } = getTopIndexAndVisibleCountOnScroll();\n\n            const [wasScrolled, ok] = scrollContainerToPosition(scrollTo);\n            if ((ok && !wasScrolled) || value.topIndex !== topIndex || value.visibleCount !== visibleCount) {\n                onValueChange({ ...value, topIndex, visibleCount, scrollTo });\n            }\n\n            const realTopIndex = getRealTopIndex({\n                ...virtualListInfo,\n                scrollContainer: scrollContainer.current,\n                listContainer: listContainer.current,\n            });\n            // prevents from cycling, while force scrolling to a row, which will never appear, when using LazyListView.\n            const shouldScrollToUnknownIndex = value.topIndex === topIndex && value.scrollTo?.index > realTopIndex;\n            if ((ok && wasScrolled) || shouldScrollToUnknownIndex) {\n                if (value.scrollTo?.index === scrollTo.index) {\n                    setScrolledTo(value.scrollTo);\n                } else {\n                    onValueChange({ ...value, scrollTo });\n                    setScrolledTo(scrollTo);\n                }\n            }\n        },\n        [\n            scrollContainer.current,\n            rowOffsets.current,\n            value?.topIndex,\n            value?.scrollTo,\n            overdrawRows,\n            blockSize,\n            scrollContainerToPosition,\n            virtualListInfo,\n        ],\n    );\n\n    const offsetY = React.useMemo(\n        () => getOffsetYForIndex(value?.topIndex, rowOffsets.current, listOffset),\n        [rowOffsets.current, listOffset, value?.topIndex],\n    );\n\n    const handleScroll = React.useCallback(() => {\n        if (!scrollContainer.current && !value) return;\n        onScroll?.(scrollContainer.current);\n\n        if (value.scrollTo !== scrolledTo && value.scrollTo?.index != null) {\n            return;\n        }\n        const newValue = getNewRowsOnScroll();\n        if (value.topIndex !== newValue.topIndex || value.visibleCount !== newValue.visibleCount) {\n            onValueChange({ ...value, ...newValue });\n        }\n    }, [value, onScroll, scrolledTo, scrollContainer.current, getNewRowsOnScroll]);\n\n    return {\n        estimatedHeight,\n        offsetY,\n        listOffset,\n\n        scrollContainerRef: scrollContainer,\n        listContainerRef: listContainer,\n\n        handleScroll,\n        scrollToIndex,\n    };\n}\n","import * as React from 'react';\nimport { getDir } from '../helpers';\n\nconst scrollMarkers = {\n    scrolledLeft: '-scrolled-left',\n    scrolledRight: '-scrolled-right',\n    scrolledTop: '-scrolled-top',\n    scrolledBottom: '-scrolled-bottom',\n};\n\nexport function useScrollShadows(root: HTMLElement | null, view: HTMLElement | null) {\n    const rtlMultiplier = getDir() === 'rtl' ? -1 : 1;\n\n    const updateScrollShadows = React.useCallback(() => {\n        if (!root || !view) return;\n\n        const {\n            scrollLeft,\n            scrollTop,\n            scrollWidth,\n            scrollHeight,\n            clientWidth,\n            clientHeight,\n        } = view;\n\n        const normalizedScrollLeft = scrollLeft * rtlMultiplier;\n\n        root.classList.toggle(\n            scrollMarkers.scrolledRight,\n            normalizedScrollLeft > 0,\n        );\n\n        root.classList.toggle(\n            scrollMarkers.scrolledLeft,\n            scrollWidth - clientWidth - normalizedScrollLeft > 1,\n        );\n\n        root.classList.toggle(\n            scrollMarkers.scrolledTop,\n            scrollTop > 0,\n        );\n\n        root.classList.toggle(\n            scrollMarkers.scrolledBottom,\n            scrollHeight - clientHeight - scrollTop > 1,\n        );\n    }, [root, view]);\n\n    React.useEffect(() => {\n        if (!root || !view) return;\n\n        updateScrollShadows();\n\n        const handleScroll = () => updateScrollShadows();\n        view.addEventListener('scroll', handleScroll, { passive: true });\n\n        let resizeTimeout: number;\n        const resizeObserver = new ResizeObserver(() => {\n            // Prevent ResizeObserver loop by debouncing with requestAnimationFrame\n            if (resizeTimeout) {\n                cancelAnimationFrame(resizeTimeout);\n            }\n            resizeTimeout = requestAnimationFrame(() => {\n                updateScrollShadows();\n            });\n        });\n        resizeObserver.observe(view);\n\n        const handleResize = () => updateScrollShadows();\n        window.addEventListener('resize', handleResize, { passive: true });\n\n        return () => {\n            view.removeEventListener('scroll', handleScroll);\n            resizeObserver.disconnect();\n            window.removeEventListener('resize', handleResize);\n            if (resizeTimeout) {\n                cancelAnimationFrame(resizeTimeout);\n            }\n        };\n    }, [root, updateScrollShadows]);\n}\n","import { useState, useCallback } from 'react';\n\nexport const useForceUpdate = () => {\n    const [, updateState] = useState<object>();\n    return useCallback(() => updateState({}), []);\n};\n","import { useEffect } from 'react';\nimport { useUuiContext, UuiError, ErrorPageInfo } from '../services';\nimport {\n    ApiCallInfo, ApiRecoveryReason,\n} from '../types';\nimport { useForceUpdate } from './useForceUpdate';\nimport { isClientSide } from '../helpers/ssr';\n\nexport type UuiRecoveryErrorInfo = {\n    title: string;\n    subtitle: string;\n};\n\nexport type ApiCallErrorType = 'permissionDenied' | 'notFound' | 'serverError' | 'serviceUnavailable' | 'default';\n\nexport interface UseUuiErrorOptions {\n    /** Config with information which data will be displayed in case of particular API error.\n     * If omitted, default config will be used.\n     * */\n    errorConfig?: Record<ApiCallErrorType, ErrorPageInfo>;\n    /** Config with information which data will be displayed in case recovery errors.\n     * If omitted, default config will be used.\n     * */\n    recoveryConfig?: Record<ApiRecoveryReason, UuiRecoveryErrorInfo>;\n}\n\nexport interface UseUuiErrorProps {\n    /** Pure function to get error info for display based on error.\n     * If omitted, error info from default config or options.errorConfig will be used.\n     */\n    getErrorInfo: (error: any, defaultErrorInfo: ErrorPageInfo) => ErrorPageInfo;\n    /** Error handling options */\n    options?: UseUuiErrorOptions;\n}\n\nexport const useUuiError = (props: UseUuiErrorProps) => {\n    const forceUpdate = useForceUpdate();\n    const {\n        uuiApi, uuiErrors, uuiRouter, uuiModals,\n    } = useUuiContext();\n    const { getErrorInfo, options: { errorConfig, recoveryConfig } = {} } = props;\n    const apiErrors: ApiCallInfo[] = [];\n    const apiNotifications: ApiCallInfo[] = [];\n\n    const onRouteChange = () => {\n        let hasError = false;\n        if (uuiApi.getActiveCalls().some((c) => c.status === 'error')) {\n            uuiApi.reset();\n            hasError = true;\n        }\n\n        if (uuiErrors.currentError !== null) {\n            uuiErrors.recover();\n            hasError = true;\n        }\n\n        hasError && forceUpdate();\n    };\n\n    useEffect(() => {\n        let routerUnsubscribe: () => void;\n        if (isClientSide) {\n            routerUnsubscribe = uuiRouter.listen(onRouteChange);\n        }\n        uuiApi.subscribe(forceUpdate);\n        uuiErrors.subscribe(forceUpdate);\n\n        return () => {\n            uuiApi.unsubscribe(forceUpdate);\n            uuiErrors.unsubscribe(forceUpdate);\n            routerUnsubscribe?.();\n        };\n    }, []);\n\n    const getDefaultErrorInfo = (errorCode: number): ErrorPageInfo => {\n        switch (errorCode) {\n            case 403:\n                return errorConfig?.permissionDenied;\n            case 404:\n                return errorConfig?.notFound;\n            case 500:\n                return errorConfig?.serverError;\n            case 503:\n                return errorConfig?.serviceUnavailable;\n            default:\n                return errorConfig?.default;\n        }\n    };\n\n    const getError = (error: any, errorInfo: ErrorPageInfo) => {\n        const resultError = getErrorInfo ? getErrorInfo(error, errorInfo) : errorInfo;\n        return { errorType: 'error', errorInfo: resultError };\n    };\n\n    uuiApi.getActiveCalls().forEach((c) => {\n        if (c.status === 'error' && c.options.errorHandling === 'page') {\n            apiErrors.push(c);\n        } else if (c.status === 'error' && c.options.errorHandling === 'notification') {\n            apiNotifications.push(c);\n        }\n    });\n\n    if (apiErrors.length) {\n        uuiModals.closeAll();\n        return getError(apiErrors[0], getDefaultErrorInfo(apiErrors[0].httpStatus));\n    } else if (apiNotifications.length) {\n        return { errorType: 'notification', errorInfo: apiNotifications };\n    } else if (uuiApi.status === 'recovery') {\n        return { errorType: 'recovery', errorInfo: recoveryConfig[uuiApi.recoveryReason] };\n    } else if (uuiErrors.currentError != null) {\n        const error = uuiErrors.currentError;\n        let status;\n        let info = {};\n\n        if (error instanceof UuiError) {\n            status = error.info.status;\n            info = error.info;\n        }\n        const defaultErrorInfo = getDefaultErrorInfo(status);\n\n        return getError(error, { ...defaultErrorInfo, ...info });\n    } else {\n        return { errorType: undefined, errorInfo: undefined };\n    }\n};\n","import isEqual from 'react-fast-compare';\nimport { DataTableState, FiltersConfig, TableFiltersConfig } from '../../types/tables';\nimport { clearEmptyValueFromRecord, getOrderBetween } from '../../helpers';\n\nexport const stateToQueryObject = (state: DataTableState, currentQuery: any) => {\n    const queryObject = {\n        ...currentQuery,\n        filter: state.filter,\n        presetId: state.presetId,\n        sorting: state.sorting,\n        viewState: state.viewState,\n        columnsConfig: state.columnsConfig,\n        page: state.page,\n        pageSize: state.pageSize,\n    };\n\n    return clearEmptyValueFromRecord(queryObject) || {};\n};\n\nexport const getValueFromUrl = (query: any) => {\n    return {\n        filter: query.filter,\n        columnsConfig: query.columnsConfig,\n        presetId: query.presetId,\n        page: query.page,\n        pageSize: query.pageSize,\n        sorting: query.sorting,\n        viewState: query.viewState,\n    };\n};\n\nexport const normalizeTableStateValue = <TFilter, TViewState>(\n    newValue: DataTableState<TFilter, TViewState>,\n    prevValue: DataTableState<TFilter, TViewState>,\n    filters: TableFiltersConfig<TFilter>[],\n) => {\n    const newFilter = clearEmptyValueFromRecord(newValue.filter);\n    const newViewState = clearEmptyValueFromRecord(newValue.viewState);\n    const filtersConfig = normalizeFilterConfig(newValue?.filtersConfig, newFilter, filters);\n\n    const newTableState = {\n        ...newValue,\n        filtersConfig: filtersConfig,\n        filter: newFilter,\n        viewState: newViewState,\n    };\n\n    // reset paging on filter change\n    if (prevValue?.page !== undefined && !isEqual(prevValue?.filter, newFilter)) {\n        newTableState.page = 1;\n    }\n    return newTableState;\n};\n\nexport const normalizeFilterConfig = <TFilter>(filtersConfig: FiltersConfig, filterValue: Record<string, any> | undefined, filters: TableFiltersConfig<TFilter>[]) => {\n    if (!filters) {\n        return undefined;\n    }\n\n    const result: FiltersConfig = {};\n    let order: string | null = null;\n    filters.forEach((filter) => {\n        if (filter.isAlwaysVisible || filterValue?.[filter.field as string] || filtersConfig?.[filter.field]) {\n            const newOrder = filtersConfig?.[filter?.field]?.order || getOrderBetween(order, null);\n            const isVisible = filtersConfig?.[filter?.field]?.isVisible;\n            result[filter.field] = {\n                isVisible: isVisible ?? true,\n                order: newOrder,\n            };\n            order = newOrder;\n        }\n    });\n    return result;\n};\n","import { useCallback, useRef, useState } from 'react';\nimport isEqual from 'react-fast-compare';\nimport {\n    ColumnsConfig, DataTableState, FiltersConfig, IEditable, ITablePreset, ITableState, TableFiltersConfig,\n} from '../../types';\nimport { getOrderBetween, orderBy } from '../../helpers';\nimport { useUuiContext } from '../../services';\nimport { stateToQueryObject, getValueFromUrl, normalizeTableStateValue, normalizeFilterConfig } from './utils';\n\ninterface UseTableStateHookBaseParams<TFilter = Record<string, any>, TViewState = any> {\n    /** Filters configuration, can be omitted if you don't need filters */\n    filters?: TableFiltersConfig<TFilter>[];\n    /** Initial presets array */\n    initialPresets?: ITablePreset<TFilter, TViewState>[];\n    /** Called when preset was created. Should return the ID of new preset */\n    onPresetCreate?(preset: ITablePreset<TFilter, TViewState>): Promise<number>;\n    /** Called when preset was updated */\n    onPresetUpdate?(preset: ITablePreset<TFilter, TViewState>): Promise<void>;\n    /** Called when preset was deleted */\n    onPresetDelete?(preset: ITablePreset<TFilter, TViewState>): Promise<void>;\n    /** Initial visibleCount table state value */\n    initialVisibleCount?: number;\n}\n\ninterface UseTableStateHookImplParams<TFilter = Record<string, any>, TViewState = any> extends UseTableStateHookBaseParams<TFilter, TViewState> {\n    value: DataTableState<TFilter, TViewState>;\n    onValueChange: (update: (val: DataTableState<TFilter, TViewState>) => DataTableState<TFilter, TViewState>) => void;\n}\n\nexport const useTableStateImpl = <TFilter = Record<string, any>, TViewState = any>\n(params: UseTableStateHookImplParams<TFilter, TViewState>): ITableState<TFilter, TViewState> => {\n    const context = useUuiContext();\n    const [presets, setPresets] = useState(params?.initialPresets ?? []);\n\n    const setColumnsConfig = useCallback((columnsConfig: ColumnsConfig) => {\n        params.onValueChange((val) => ({\n            ...val,\n            columnsConfig,\n        }));\n    }, []);\n\n    const setFiltersConfig = useCallback((filtersConfig: FiltersConfig) => {\n        params.onValueChange((val) => ({\n            ...val,\n            filtersConfig,\n        }));\n    }, []);\n\n    const setFilter = useCallback((filter: TFilter) => {\n        params.onValueChange((val) => ({\n            ...val,\n            filter,\n        }));\n    }, []);\n\n    const getActivePresetId = () => {\n        const presetId = params.value?.presetId;\n        return presetId ? +presetId : undefined;\n    };\n\n    const choosePreset = useCallback((preset: ITablePreset<TFilter, TViewState>) => {\n        params.onValueChange((val) => ({\n            ...val,\n            filter: preset.filter,\n            columnsConfig: preset.columnsConfig,\n            filtersConfig: preset.filtersConfig,\n            sorting: preset.sorting,\n            presetId: preset.id,\n            viewState: preset.viewState,\n        }));\n    }, []);\n\n    const getNewPresetOrder = useCallback(() => {\n        const maxOrder = orderBy(presets, (i) => i.order, 'desc')[0]?.order;\n        return getOrderBetween(maxOrder, null);\n    }, [presets]);\n\n    const createPreset = useCallback(async (preset: ITablePreset<TFilter, TViewState>) => {\n        const newId = await params?.onPresetCreate?.(preset);\n        const newPreset = {\n            ...preset,\n            id: newId,\n        };\n\n        setPresets((prevValue) => [...prevValue, newPreset]);\n        choosePreset(newPreset);\n\n        return newId;\n    }, [params?.onPresetCreate]);\n\n    const createNewPreset = useCallback((name: string) => {\n        const currentTableStateValue = params.value;\n        const newPreset: ITablePreset<TFilter, TViewState> = {\n            id: null,\n            name: name,\n            filter: currentTableStateValue.filter,\n            columnsConfig: currentTableStateValue.columnsConfig,\n            filtersConfig: currentTableStateValue.filtersConfig,\n            sorting: currentTableStateValue.sorting,\n            viewState: currentTableStateValue.viewState,\n            isReadonly: false,\n            order: getNewPresetOrder(),\n        };\n\n        return createPreset(newPreset);\n    }, [params.value, getNewPresetOrder]);\n\n    const hasPresetChanged = useCallback((preset: ITablePreset<TFilter, TViewState>) => {\n        const currentTableStateValue = params.value;\n        return (\n            !isEqual(preset.filter, currentTableStateValue.filter)\n            || !isEqual(preset.columnsConfig, currentTableStateValue.columnsConfig)\n            || !isEqual(preset.sorting, currentTableStateValue.sorting)\n            || !isEqual(preset.viewState, currentTableStateValue.viewState)\n        );\n    }, [params.value]);\n\n    const duplicatePreset = useCallback(async (preset: ITablePreset<TFilter, TViewState>) => {\n        const newPreset: ITablePreset<TFilter, TViewState> = {\n            ...preset,\n            isReadonly: false,\n            id: null,\n            name: preset.name + '_copy',\n            order: getNewPresetOrder(),\n        };\n\n        return createPreset(newPreset);\n    }, [createPreset, getNewPresetOrder]);\n\n    const deletePreset = useCallback(\n        (preset: ITablePreset<TFilter, TViewState>) => {\n            const removePreset = () => {\n                params.onValueChange((val) => ({\n                    ...val,\n                    presetId: undefined,\n                }));\n                setPresets((prevValue) =>\n                    prevValue.filter((p) => p.id !== preset.id));\n            };\n\n            const promiseFulfilled = params?.onPresetDelete ? params.onPresetDelete(preset) : Promise.resolve();\n            return promiseFulfilled\n                .then(removePreset)\n                .catch(() => null);\n        },\n        [params?.onPresetDelete],\n    );\n\n    const updatePreset = useCallback(async (preset: ITablePreset<TFilter, TViewState>) => {\n        setPresets((prevValue) => {\n            const newPresets = [...prevValue];\n            newPresets.splice(\n                prevValue.findIndex((p) => p.id === preset.id),\n                1,\n                preset,\n            );\n            return newPresets;\n        });\n\n        params?.onPresetUpdate(preset);\n    }, [params?.onPresetUpdate]);\n\n    const getPresetLink = useCallback((preset: ITablePreset<TFilter, TViewState>) => {\n        return (\n            window.location.origin\n            + context.uuiRouter.createHref({\n                pathname: context.uuiRouter.getCurrentLink().pathname,\n                query: stateToQueryObject({ ...preset, presetId: preset.id }, context.uuiRouter.getCurrentLink().query),\n            })\n        );\n    }, []);\n\n    const setTableState = useCallback((newValue: React.SetStateAction<DataTableState<TFilter, TViewState>>) => {\n        params.onValueChange(typeof newValue === 'function' ? newValue : () => newValue);\n    }, []);\n\n    return {\n        tableState: params.value,\n        setTableState,\n        setColumnsConfig,\n        setFiltersConfig,\n        setFilter,\n        presets,\n        activePresetId: getActivePresetId(),\n        choosePreset,\n        createNewPreset,\n        hasPresetChanged,\n        duplicatePreset,\n        deletePreset,\n        updatePreset,\n        getPresetLink,\n    };\n};\n\nexport interface UseTableStateHookParams<TFilter = Record<string, any>, TViewState = any>\n    extends UseTableStateHookBaseParams<TFilter, TViewState>, Partial<IEditable<DataTableState<TFilter, TViewState>>> {}\n\nexport const useTableState = <TFilter = Record<string, any>, TViewState = any>\n(params: UseTableStateHookParams<TFilter, TViewState> = {}): ITableState<TFilter, TViewState> => {\n    const context = useUuiContext();\n\n    const externalValue = useRef(params?.value);\n\n    const [tableStateValue, setTableStateValue] = useState<DataTableState<TFilter, TViewState>>(() => {\n        const value = getValueFromUrl(context.uuiRouter.getCurrentLink().query);\n        const activePreset = params?.initialPresets?.find((p: ITablePreset<TFilter, TViewState>) => p.id === value.presetId);\n        const filtersConfig = normalizeFilterConfig(activePreset?.filtersConfig, value.filter, params?.filters);\n        return {\n            ...value,\n            filtersConfig,\n            topIndex: 0,\n            visibleCount: params?.initialVisibleCount || 40,\n        };\n    });\n\n    const getTableStateValue = () => {\n        if (params?.onValueChange) {\n            return params?.value;\n        }\n\n        const valueFromUrl = getValueFromUrl(context.uuiRouter.getCurrentLink().query);\n        const urlKeys = Object.keys(valueFromUrl) as Array<keyof typeof valueFromUrl>;\n        urlKeys.forEach((urlKey) => {\n            if (!isEqual(valueFromUrl[urlKey], tableStateValue[urlKey]) || !(urlKey in tableStateValue)) {\n                tableStateValue[urlKey] = valueFromUrl[urlKey];\n            }\n        });\n\n        return tableStateValue;\n    };\n\n    const setValueToUrl = (value: DataTableState<TFilter, TViewState>) => {\n        const oldQuery = context.uuiRouter.getCurrentLink().query;\n        const newQuery = stateToQueryObject(value, context.uuiRouter.getCurrentLink().query);\n\n        if (JSON.stringify(oldQuery) !== JSON.stringify(newQuery)) {\n            context.uuiRouter.redirect({\n                pathname: context.uuiRouter.getCurrentLink().pathname,\n                query: newQuery,\n            });\n        }\n    };\n    const onValueChange = useCallback((update: (val: DataTableState<TFilter, TViewState>) => DataTableState<TFilter, TViewState>) => {\n        if (params?.onValueChange) {\n            const newValue = update(externalValue.current);\n            const resultValue = normalizeTableStateValue(newValue, externalValue.current, params.filters);\n            externalValue.current = resultValue;\n            params?.onValueChange(resultValue);\n        } else {\n            setTableStateValue((currentValue) => {\n                const newValue = update(currentValue);\n                const resultValue = normalizeTableStateValue(newValue, currentValue, params.filters);\n                setValueToUrl(resultValue);\n\n                return resultValue;\n            });\n        }\n    }, []);\n\n    return useTableStateImpl({\n        ...params,\n        onValueChange,\n        value: getTableStateValue(),\n    });\n};\n","import { useEffect, useRef } from 'react';\nimport { LayoutLayer, useUuiContext } from '../services';\n\nexport const useLayer = () => {\n    const context = useUuiContext();\n    const layer = useRef<LayoutLayer>(undefined);\n\n    useEffect(() => {\n        layer.current = context.uuiLayout.getLayer();\n        return () => layer.current && context.uuiLayout?.releaseLayer(layer.current);\n    }, []);\n\n    return layer.current;\n};\n","import debounce from 'lodash.debounce';\nimport { useEffect, useMemo } from 'react';\n\n/**\n * Props of useResizeObserver hook.\n */\nexport interface UseResizeObserverProps {\n    /**\n     * The handler for the resizing event, called when the size of any observed elements changes.\n     */\n    onResize: ResizeObserverCallback;\n    /**\n     * Elements whose size changes should be tracked.\n     */\n    observables: Element[];\n    /**\n     * Delay (in milliseconds) before calling the onResize handler.\n     */\n    delay?: number;\n}\n\n/**\n * Hook that provides the ability to observe size changes of various elements.\n * @returns An observer that tracks size changes of the observed elements.\n */\nexport function useResizeObserver(props: UseResizeObserverProps) {\n    const onResize = useMemo(() => {\n        if (props.delay === undefined) {\n            return props.onResize;\n        }\n        return debounce(props.onResize, props.delay, { leading: false, trailing: true });\n    }, [props.delay, props.onResize]);\n\n    const resizeObserver = useMemo(() => new ResizeObserver(onResize), [onResize]);\n\n    const observables = props.observables.filter(Boolean);\n    useEffect(() => {\n        observables.forEach((observable) => resizeObserver.observe(observable));\n\n        return () => {\n            resizeObserver.disconnect();\n        };\n    }, [observables.length]);\n\n    return resizeObserver;\n}\n","import { useState, useEffect } from 'react';\nimport { getDir, HTMLDir } from '../helpers';\n\nexport function useDocumentDir(): HTMLDir {\n    const [dir, setDir] = useState<HTMLDir>(getDir());\n\n    useEffect(() => {\n        const observer = new MutationObserver((mutations) => {\n            mutations.forEach((mutation) => {\n                if (mutation.type === 'attributes' && mutation.attributeName === 'dir') {\n                    setDir(getDir());\n                }\n            });\n        });\n\n        observer.observe(document?.documentElement, { attributes: true });\n\n        return () => {\n            observer.disconnect();\n        };\n    }, []);\n\n    return dir;\n}\n","import { useUuiContext } from '../services';\nimport { ICanBeActive, ICanRedirect } from '../types';\nimport { devLogger } from '../helpers';\n\nexport interface UseIsActiveProps extends ICanBeActive, Pick<ICanRedirect, 'link'> {}\n\nexport interface UseIsActiveResult {\n    isActive: boolean;\n}\n\nexport const useIsActive = (props: UseIsActiveProps): UseIsActiveResult => {\n    const context = useUuiContext();\n    let isActive: boolean;\n\n    if (props.isActive !== undefined) {\n        isActive = props.isActive;\n    } else if (props.isLinkActive !== undefined) {\n        devLogger.warn('useIsActive: isLinkActive prop is deprecated. Use isActive prop instead.');\n        isActive = props.isLinkActive;\n    } else if (props.link && context.uuiRouter) {\n        isActive = context.uuiRouter.isActive(props.link);\n    } else {\n        isActive = false;\n    }\n\n    return {\n        isActive,\n    };\n};\n","import { useCallback, useEffect, useMemo, useState } from 'react';\nimport { FetchingOptions } from '../../services';\nimport { ArrayDataSource, ArrayDataSourceProps } from './ArrayDataSource';\nimport { useForceUpdate } from '../../hooks';\nimport { DataSourceState, IDataSourceView, SetDataSourceState } from '../../types';\nimport { useCascadeSelectionService, useDataRows, useTree, newMap } from './views';\nimport { ItemsStorage } from './views/tree/ItemsStorage';\nimport { AsyncListViewProps } from './views/types';\nimport { ItemsStatusCollector } from './views/tree/ItemsStatusCollector';\n\nexport interface AsyncDataSourceProps<TItem, TId, TFilter> extends AsyncListViewProps<TItem, TId, TFilter> {}\n\nexport class AsyncDataSource<TItem = any, TId = any, TFilter = any> extends ArrayDataSource<TItem, TId> {\n    api: (options: FetchingOptions) => Promise<TItem[]> = null;\n    itemsStatusCollector: ItemsStatusCollector<TItem, TId, TFilter>;\n\n    constructor(props: AsyncDataSourceProps<TItem, TId, TFilter>) {\n        super({\n            ...props,\n            items: [],\n        });\n        const params = { getId: this.getId, complexIds: this.props.complexIds };\n        this.api = props.api;\n        this.itemsStatusCollector = new ItemsStatusCollector(newMap(params), params);\n        this._signals = new Set();\n        this._abortController = new AbortController();\n    }\n\n    private _abortController: AbortController;\n    private _signals: Set<AbortSignal>;\n\n    private _cache: Promise<TItem[]>;\n    private get cache(): Promise<TItem[]> {\n        return this._cache;\n    }\n\n    private set cache(_cache: Promise<TItem[]> | null) {\n        this._cache = _cache;\n    }\n    \n    private cachedApi = async (options: FetchingOptions) => {\n        if (!options.signal.onabort) {\n            options.signal.onabort = () => {\n                let areAllAborted = false;\n                this._signals.forEach((s) => {\n                    if (options.signal === s || s.aborted) {\n                        areAllAborted = true;\n                    }\n                });\n                \n                if (areAllAborted) {\n                    this._abortController.abort();\n                    this.cache = null;\n                    this._abortController = new AbortController();\n                }\n            };\n        }\n\n        this._signals.add(options.signal);\n\n        if (!this.cache) {\n            this.cache = this.api({ signal: this._abortController.signal });\n        }\n\n        return this.cache;\n    };\n\n    public setProps(newProps: ArrayDataSourceProps<TItem, TId, TFilter>) {\n        const props = { ...newProps };\n        // We'll receive items=null on updates (because we inherit ArrayDataSource, but nobody would actually pass items there - they are expected to come from API)\n        // so this tweak is required to not reset items on any update\n        props.items = newProps.items || this.props.items;\n\n        super.setProps(props);\n        if (newProps.items && newProps.items !== this.props.items) {\n            this.itemsStorage.setItems(newProps.items, { reset: true });\n        }\n    }\n\n    reload() {\n        this.cache = null;\n        this._signals = new Set();\n        this._abortController = new AbortController();\n\n        this.setProps({ ...this.props, items: [] });\n        const params = { getId: this.getId, complexIds: this.props.complexIds };\n        this.itemsStorage = new ItemsStorage({ items: [], params });\n        this.itemsStatusCollector = new ItemsStatusCollector(newMap(params), params);\n        super.reload();\n    }\n\n    useView(\n        value: DataSourceState<TFilter, TId>,\n        onValueChange: SetDataSourceState<any, TId>,\n        options?: Partial<AsyncListViewProps<TItem, TId, TFilter>>,\n        deps: any[] = [],\n    ): IDataSourceView<TItem, TId, TFilter> {\n        // eslint-disable-next-line react-hooks/rules-of-hooks\n        const forceUpdate = useForceUpdate();\n        // eslint-disable-next-line react-hooks/rules-of-hooks\n        const [itemsMap, setItemsMap] = useState(this.itemsStorage.getItemsMap());\n\n        const { items, ...props } = { ...this.props, ...options };\n\n        // eslint-disable-next-line react-hooks/rules-of-hooks\n        const { tree, reload, selectionTree, totalCount, ...restProps } = useTree({\n            type: 'async',\n            ...props,\n            api: this.cachedApi,\n            itemsMap,\n            setItems: this.itemsStorage.setItems,\n            itemsStatusCollector: this.itemsStatusCollector,\n            isLoaded: this.props.items.length > 0,\n            getId: this.getId,\n            getParentId: options?.getParentId ?? this.props.getParentId ?? this.defaultGetParentId,\n            dataSourceState: value,\n            setDataSourceState: onValueChange,\n        }, [...deps, this]);\n\n        // eslint-disable-next-line react-hooks/rules-of-hooks\n        const clearCacheAndReload = useCallback(() => {\n            this.cache = null;\n            reload();\n        }, [reload, this]);\n\n        // eslint-disable-next-line react-hooks/rules-of-hooks\n        useEffect(() => {\n            const unsubscribe = this.itemsStorage.subscribe((newItemsMap) => {\n                if (itemsMap !== newItemsMap) {\n                    setItemsMap(newItemsMap);\n                }\n            });\n\n            return () => {\n                unsubscribe();\n            };\n        }, [this.itemsStorage]);\n\n        // eslint-disable-next-line react-hooks/rules-of-hooks\n        useEffect(() => {\n            const unsubscribe = this.itemsStatusCollector.subscribe(() => {\n                forceUpdate();\n            });\n\n            return () => {\n                unsubscribe();\n            };\n        }, [this.itemsStatusCollector]);\n\n        // eslint-disable-next-line react-hooks/rules-of-hooks\n        useEffect(() => {\n            this.trees.set(tree, reload);\n            return () => {\n                this.trees.delete(tree);\n            };\n        }, [tree, reload]);\n\n        // eslint-disable-next-line react-hooks/rules-of-hooks\n        const cascadeSelectionService = useCascadeSelectionService({\n            tree: selectionTree,\n        });\n\n        // eslint-disable-next-line react-hooks/rules-of-hooks\n        const { rows, listProps, selectAll, getById, getSelectedRowsCount, clearAllChecked } = useDataRows({\n            tree,\n            ...restProps,\n            ...cascadeSelectionService,\n        });\n\n        // eslint-disable-next-line react-hooks/rules-of-hooks\n        return useMemo(() => ({\n            getVisibleRows: () => rows,\n            getListProps: () => ({ ...listProps, totalCount }),\n            selectAll,\n            getConfig: () => restProps,\n            reload: clearCacheAndReload,\n            getById,\n            getSelectedRowsCount,\n            clearAllChecked,\n        }), [\n            rows,\n            listProps,\n            selectAll,\n            restProps,\n            totalCount,\n            clearCacheAndReload,\n            getById,\n            getSelectedRowsCount,\n            clearAllChecked,\n        ]);\n    }\n}\n","import { useEffect, useRef } from 'react';\n\nexport function useMemoWithDestructor<T>(create: () => T, update: (instance: T) => void, destroy: (value: T) => any, deps: any[]) {\n    const ref = useRef<T>(undefined);\n    const prevDeps = useRef(deps);\n\n    const isDepsChanged = prevDeps.current.length !== deps.length || prevDeps.current.some((devVal, index) => devVal !== deps[index]);\n\n    if (ref.current == null || isDepsChanged) {\n        prevDeps.current = deps;\n        ref.current = create();\n    }\n\n    update(ref.current);\n\n    const current = ref.current;\n\n    useEffect(() => {\n        // Value here is memoized in closure at the time of its creation.\n        // So we are not destroying the value we just created above.\n        return () => current && destroy(current);\n    }, deps);\n\n    return ref.current;\n}\n","import { AsyncDataSource, AsyncDataSourceProps } from '../AsyncDataSource';\nimport { useMemoWithDestructor } from '../../../helpers/useMemoWithDestructor';\n\nexport function useAsyncDataSource<TItem, TId, TFilter>(props: AsyncDataSourceProps<TItem, TId, TFilter>, deps: any[]) {\n    return useMemoWithDestructor(\n        () => new AsyncDataSource({ ...props }),\n        (dataSource) => dataSource.setProps(props as any /* due to broken inheritance of AsyncDataSource from ArrayDataSource */),\n        (dataSource) => dataSource.destroy(),\n        deps,\n    );\n}\n","import { ArrayDataSource, ArrayDataSourceProps } from '../ArrayDataSource';\nimport { useMemoWithDestructor } from '../../../helpers/useMemoWithDestructor';\n\nexport function useArrayDataSource<TItem, TId, TFilter>(props: ArrayDataSourceProps<TItem, TId, TFilter>, deps: any[]) {\n    return useMemoWithDestructor(\n        () => new ArrayDataSource({ ...props }),\n        (dataSource) => dataSource.setProps(props),\n        (dataSource) => dataSource.destroy(),\n        deps,\n    );\n}\n","import { useEffect, useMemo, useState } from 'react';\nimport { LazyListViewProps, useCascadeSelectionService, useDataRows, useTree, newMap } from './views';\nimport { useForceUpdate } from '../../hooks';\nimport { BaseDataSource } from './BaseDataSource';\nimport { DataSourceState, IDataSourceView, SetDataSourceState } from '../../types';\nimport { ItemsStorage } from './views/tree/ItemsStorage';\nimport { ItemsStatusCollector } from './views/tree/ItemsStatusCollector';\n\nexport interface LazyDataSourceProps<TItem, TId, TFilter> extends LazyListViewProps<TItem, TId, TFilter> {}\n\nexport class LazyDataSource<TItem = any, TId = any, TFilter = any> extends BaseDataSource<TItem, TId, TFilter> {\n    props: LazyDataSourceProps<TItem, TId, TFilter>;\n    itemsStorage: ItemsStorage<TItem, TId>;\n    itemsStatusCollector: ItemsStatusCollector<TItem, TId, TFilter>;\n\n    constructor(props: LazyDataSourceProps<TItem, TId, TFilter>) {\n        super(props);\n        this.props = {\n            ...props,\n            flattenSearchResults: props.flattenSearchResults ?? true,\n        };\n        const params = { getId: this.getId, complexIds: this.props.complexIds };\n        this.itemsStorage = new ItemsStorage({ items: [], params });\n        this.itemsStatusCollector = new ItemsStatusCollector(newMap(params), params);\n    }\n\n    public setProps(props: LazyDataSourceProps<TItem, TId, TFilter>) {\n        this.props = {\n            ...this.props,\n            ...props,\n            flattenSearchResults: props.flattenSearchResults ?? true,\n        };\n    }\n\n    public getById = (id: TId): TItem | void => {\n        const map = this.itemsStorage.getItemsMap();\n        return map.has(id) ? map.get(id) : null;\n    };\n\n    setItem(item: TItem) {\n        this.itemsStorage.setItems([item]);\n    }\n\n    public clearCache() {\n        const params = { getId: this.getId, complexIds: this.props.complexIds };\n        this.itemsStorage = new ItemsStorage({ items: [], params });\n        this.itemsStatusCollector = new ItemsStatusCollector(newMap(params), params);\n        super.reload();\n    }\n\n    useView<TState extends DataSourceState<any, TId>>(\n        value: TState,\n        onValueChange: SetDataSourceState<any, TId>,\n        props?: Partial<LazyListViewProps<TItem, TId, TFilter>>,\n        deps: any[] = [],\n    ): IDataSourceView<TItem, TId, TFilter> {\n        // eslint-disable-next-line react-hooks/rules-of-hooks\n        const forceUpdate = useForceUpdate();\n        // eslint-disable-next-line react-hooks/rules-of-hooks\n        const [itemsMap, setItemsMap] = useState(this.itemsStorage.getItemsMap());\n\n        // eslint-disable-next-line react-hooks/rules-of-hooks\n        const { tree, selectionTree, reload, totalCount, loadMissingRecordsOnCheck, ...restProps } = useTree({\n            type: 'lazy',\n            ...this.props,\n            itemsMap,\n            setItems: this.itemsStorage.setItems,\n            itemsStatusCollector: this.itemsStatusCollector,\n            dataSourceState: value,\n            setDataSourceState: onValueChange as React.Dispatch<React.SetStateAction<DataSourceState<any, TId>>>,\n            // These defaults are added for compatibility reasons.\n            // We'll require getId and getParentId callbacks in other APIs, including the views.\n            getId: this.getId,\n            ...props,\n        }, [...deps, this]);\n\n        // eslint-disable-next-line react-hooks/rules-of-hooks\n        useEffect(() => {\n            const unsubscribe = this.itemsStorage.subscribe((newItemsMap) => {\n                if (itemsMap !== newItemsMap) {\n                    setItemsMap(newItemsMap);\n                }\n            });\n\n            return () => {\n                unsubscribe();\n            };\n        }, [this.itemsStorage]);\n\n        // eslint-disable-next-line react-hooks/rules-of-hooks\n        useEffect(() => {\n            const unsubscribe = this.itemsStatusCollector.subscribe(() => {\n                forceUpdate();\n            });\n            \n            return () => {\n                unsubscribe();\n            };\n        }, [this.itemsStatusCollector]);\n\n        // eslint-disable-next-line react-hooks/rules-of-hooks\n        useEffect(() => {\n            this.trees.set(tree, reload);\n            return () => { \n                this.trees.delete(tree);\n            };\n        }, [tree, reload]);\n\n        // eslint-disable-next-line react-hooks/rules-of-hooks\n        const cascadeSelectionService = useCascadeSelectionService({\n            tree: selectionTree,\n            loadMissingRecordsOnCheck,\n        });\n\n        // eslint-disable-next-line react-hooks/rules-of-hooks\n        const { rows, listProps, selectAll, getById, getSelectedRowsCount, clearAllChecked } = useDataRows({\n            tree,\n            ...restProps,\n            ...cascadeSelectionService,\n        });\n\n        // eslint-disable-next-line react-hooks/rules-of-hooks\n        return useMemo(() => ({\n            getVisibleRows: () => rows,\n            getListProps: () => ({ ...listProps, totalCount }),\n            selectAll,\n            getConfig: () => restProps,\n            reload,\n            getById,\n            getSelectedRowsCount,\n            clearAllChecked,\n        }), [\n            rows,\n            listProps,\n            selectAll,\n            restProps,\n            totalCount,\n            reload,\n            getById,\n            getSelectedRowsCount,\n            clearAllChecked,\n        ]);\n    }\n}\n","import { LazyDataSource, LazyDataSourceProps } from '../LazyDataSource';\nimport { useMemoWithDestructor } from '../../../helpers/useMemoWithDestructor';\n\nexport function useLazyDataSource<TItem, TId, TFilter>(props: LazyDataSourceProps<TItem, TId, TFilter>, deps: any[]) {\n    return useMemoWithDestructor(\n        () => new LazyDataSource({ ...props }),\n        (dataSource) => dataSource.setProps(props),\n        (dataSource) => dataSource.destroy(),\n        deps,\n    );\n}\n","export const i18n = {\n    lenses: {\n        validation: {\n            isRequiredMessage: 'The field is mandatory',\n            lessThanMinimumValueMessage: (minValue: number) => `Value should not be less than ${minValue}`,\n            greaterThanMaximumValueMessage: (maxValue: number) => `Value should not be greater than ${maxValue}`,\n            greaterThanMaximumLengthMessage: (maxLength: number) => `Maximum length is ${maxLength} characters`,\n        },\n    },\n    locale: undefined as string,\n};\n","import { i18n } from '../../i18n';\nimport { Metadata } from '../../types';\nimport { ValidationState } from '../lenses';\n\nexport type ValidationMode = 'change' | 'save';\nexport const blankValidationState: ValidationState = {};\n\ntype Iterable<U> = U & { [Symbol.iterator](): IterableIterator<[string, unknown]> };\ntype IterableWithGet<U> = Iterable<U> & { get(key: string): unknown };\n\nconst isIterable = <U>(value: U): value is Iterable<U> => typeof value === 'object' && Symbol.iterator in value;\nconst shouldAccessWithGet = <U>(value: U): value is IterableWithGet<U> => typeof value === 'object' && 'get' in value;\n\nconst getValue = <U extends {}>(key: string, value: U) => {\n    if (value === null || typeof value !== 'object') {\n        return undefined;\n    }\n\n    if (shouldAccessWithGet(value)) {\n        return value.get(key);\n    }\n\n    return value[key as keyof U];\n};\n\nexport const validate = <T>(value: T, meta: Metadata<T>, initValue: T, validateOn: ValidationMode): ValidationState => {\n    const validateRec = <U>(innerValue: U, path: U[], innerMeta: Metadata<U>, innerInitValue: U): ValidationState => {\n        const itemResult: ValidationState = validateValue(innerValue, path, innerMeta);\n        const validateItem = (key: string, validationMeta: Metadata<any>) => {\n            const childValue = getValue(key, innerValue);\n            const newPath = [childValue, ...path];\n            const initChildValue = getValue(key, innerInitValue);\n            const isChildChanged = childValue !== initChildValue;\n\n            let childResult;\n            switch (validateOn) {\n                case 'change': {\n                    childResult = isChildChanged ? validateRec(childValue, newPath, validationMeta, initChildValue) : { isInvalid: false };\n                    break;\n                }\n                case 'save': {\n                    childResult = validateRec(childValue, newPath, validationMeta, initChildValue);\n                }\n            }\n\n            itemResult.isInvalid = childResult.isInvalid || itemResult.isInvalid;\n            itemResult.validationProps = itemResult.validationProps || {};\n            itemResult.validationProps[key] = childResult;\n        };\n\n        if (innerMeta.props) {\n            for (const key in innerMeta.props) {\n                const childMeta = innerMeta.props[key];\n                if (childMeta) {\n                    validateItem(key, childMeta);\n                }\n            }\n        }\n\n        if (innerMeta.all && innerValue != null) {\n            if (!Array.isArray(innerValue) && isIterable(innerValue)) {\n                for (const [key] of innerValue) {\n                    validateItem(key, innerMeta.all);\n                }\n            } else {\n                for (const key in innerValue) {\n                    validateItem(key, innerMeta.all);\n                }\n            }\n        }\n\n        return itemResult;\n    };\n    return validateRec(value, [value], meta, initValue);\n};\n\nconst validateValue = (value: any, path: any[], meta: Metadata<any>): ValidationState => {\n    if (meta.validators) {\n        const customValidationMessages = meta.validators\n            .map((validator) => validator.apply(null, path))\n            .reduce((a, b) => a.concat(b), [])\n            .filter((msg: string | null) => !!msg);\n\n        if (customValidationMessages.length > 0) {\n            return {\n                isInvalid: true,\n                validationMessage: customValidationMessages[0],\n            };\n        }\n    }\n\n    if (meta.isRequired) {\n        if (value == null || (typeof value === 'string' && value.trim() === '') || (Array.isArray(value) && value.length === 0)) {\n            return {\n                isInvalid: true,\n                validationMessage: i18n.lenses.validation.isRequiredMessage,\n            };\n        }\n    }\n\n    if (meta.minValue != null && value != null && value < meta.minValue) {\n        return {\n            isInvalid: true,\n            validationMessage: i18n.lenses.validation.lessThanMinimumValueMessage(meta.minValue),\n        };\n    }\n\n    if (meta.maxValue != null && value != null && value > meta.maxValue) {\n        return {\n            isInvalid: true,\n            validationMessage: i18n.lenses.validation.greaterThanMaximumValueMessage(meta.maxValue),\n        };\n    }\n\n    if (meta.maxLength != null && value != null && value.length > meta.maxLength) {\n        return {\n            isInvalid: true,\n            validationMessage: i18n.lenses.validation.greaterThanMaximumLengthMessage(meta.maxLength),\n        };\n    }\n\n    return {\n        isInvalid: false,\n    };\n};\n","import { ValidationState } from '../lenses';\n\nexport function validateServerErrorState<T extends any>(currentFormState: T, lastSentFormState: T, serverValidation: ValidationState) {\n    let result: ValidationState = { isInvalid: false };\n\n    if (serverValidation.validationProps) {\n        Object.keys(serverValidation.validationProps).forEach((key) => {\n            const childProps = serverValidation.validationProps[key];\n            validateItem(key, currentFormState?.[key as keyof typeof currentFormState], lastSentFormState?.[key as keyof typeof lastSentFormState], childProps, result);\n        });\n    } else {\n        result = validateValue(currentFormState, lastSentFormState, serverValidation);\n    }\n\n    return result;\n}\n\nfunction validateValue(newValue: any, oldValue: any, validationProp: ValidationState): ValidationState {\n    if (!validationProp.isInvalid) return { isInvalid: false };\n\n    return newValue === oldValue\n        ? {\n            isInvalid: true,\n            validationMessage: validationProp.validationMessage,\n        }\n        : {\n            isInvalid: false,\n        };\n}\n\nfunction validateItem(key: string, currentFormStatePart: any, lastSavedFormStatePart: any, serverValidation: ValidationState, parentResult: ValidationState) {\n    const valueResult = validateValue(currentFormStatePart, lastSavedFormStatePart, serverValidation);\n    const recursiveResult = validateServerErrorState(currentFormStatePart, lastSavedFormStatePart, serverValidation);\n\n    recursiveResult.isInvalid = recursiveResult.isInvalid || valueResult.isInvalid;\n\n    if (valueResult.validationMessage) {\n        recursiveResult.validationMessage = valueResult.validationMessage;\n    }\n\n    parentResult.validationProps = parentResult.validationProps || {};\n    parentResult.validationProps[key] = recursiveResult;\n    parentResult.isInvalid = parentResult.isInvalid || recursiveResult.isInvalid;\n}\n","import { ValidationState } from '../lenses';\n\nexport function mergeValidation(clientValidation: ValidationState, serverValidation: ValidationState) {\n    const result = serverValidation.isInvalid ? serverValidation : clientValidation;\n\n    if (clientValidation.isInvalid) mergeValidationProps(clientValidation.validationProps, result);\n\n    return result;\n}\n\nfunction mergeValidationProps(validationProps: ValidationState['validationProps'], resultPart: ValidationState) {\n    if (!validationProps) return;\n    if (!resultPart.validationProps) resultPart.validationProps = {};\n\n    Object.keys(validationProps).forEach((key) => {\n        const prop = validationProps[key];\n        const isInvalid = prop.isInvalid || resultPart.validationProps[key]?.isInvalid || false;\n        const validationMessage = prop.validationMessage ?? resultPart.validationProps[key]?.validationMessage;\n\n        resultPart.validationProps[key] = validationMessage\n            ? {\n                isInvalid,\n                validationMessage,\n            }\n            : {\n                isInvalid,\n            };\n\n        if (prop.isInvalid) {\n            mergeValidationProps(prop.validationProps, resultPart.validationProps[key]);\n        }\n    });\n}\n","import { IImmutableMap, IMap, Metadata } from '../../types';\nimport { cloneMap } from '../processing';\nimport { blankValidationState } from '../validation';\nimport { ValidationState } from './types';\n\nexport interface ILensImpl<TBig, TSmall> {\n    get(big: TBig | null): TSmall | null;\n    set(big: TBig | null, small: TSmall): TBig;\n    getValidationState?(big?: ValidationState): ValidationState | undefined;\n    getMetadata?(big?: Metadata<TBig>): Metadata<TSmall> | undefined;\n}\nexport const identityLens: ILensImpl<any, any> = {\n    get(big: any) {\n        return big;\n    },\n    set(big: any, small: any) {\n        return small;\n    },\n    getValidationState(big: ValidationState) {\n        return big;\n    },\n    getMetadata(big: Metadata<any>) {\n        return big;\n    },\n};\n\nexport function identity<A>(): ILensImpl<A, A> {\n    return identityLens;\n}\n\nfunction getMetadata<T>(big: T) {\n    const metadata: Metadata<T> = big || { all: { props: {} } };\n    const metadataProps = metadata.all;\n    const { isDisabled, isRequired, isReadonly } = metadata;\n    return {\n        ...metadataProps, isDisabled, isReadonly, isRequired,\n    } as any;\n}\n\nfunction getValidationState(big: ValidationState, field: string | number, defaultValidationStateProps: ValidationState['validationProps'] = {}) {\n    const validationStateProps = (big || blankValidationState).validationProps || defaultValidationStateProps;\n    return validationStateProps[field];\n}\n\nexport function prop<TObject, TKey extends keyof TObject>(name: TKey): ILensImpl<TObject, TObject[TKey]> {\n    return {\n        get(big) {\n            if (big == null) {\n                return undefined;\n            } else {\n                return big[name];\n            }\n        },\n        set(big: TObject, small: TObject[TKey]) {\n            const newObject = {\n                ...(big as any),\n                [name]: small,\n            };\n            return newObject;\n        },\n        getValidationState(big: ValidationState) {\n            return getValidationState(big, name as string, { [name]: { isInvalid: false } });\n        },\n        getMetadata(big: Metadata<TObject>) {\n            const metadata: Metadata<TObject> = big || { props: {} };\n            const metadataProps = metadata.props || ({} as any);\n            const { isDisabled, isRequired, isReadonly } = metadata;\n            return {\n                isDisabled, isReadonly, isRequired, ...metadataProps[name],\n            };\n        },\n    };\n}\n\nexport function key<TItem, TId>(id: TId): ILensImpl<IMap<TId, TItem> | IImmutableMap<TId, TItem>, TItem> {\n    return {\n        get(big: IMap<TId, TItem> | IImmutableMap<TId, TItem>) {\n            if (big == null) {\n                return undefined;\n            } else {\n                return big.get(id);\n            }\n        },\n        set(big: IMap<TId, TItem> | IImmutableMap<TId, TItem>, small: TItem) {\n            const newMap = cloneMap(big);\n            return newMap.set(id, small);\n        },\n        getValidationState(big: ValidationState) {\n            return getValidationState(big, id as string);\n        },\n        getMetadata(big: Metadata<IMap<TId, TItem> | IImmutableMap<TId, TItem>>) {\n            return getMetadata(big);\n        },\n    };\n}\n\nexport function index<TItem>(num: number): ILensImpl<TItem[], TItem> {\n    return {\n        get(big: TItem[]) {\n            if (big == null) {\n                return undefined;\n            } else {\n                return big[num];\n            }\n        },\n        set(big: TItem[], small: TItem) {\n            const newArray = [...big];\n            newArray[num] = small;\n            return newArray;\n        },\n        getValidationState(big: ValidationState) {\n            return getValidationState(big, num);\n        },\n        getMetadata(big: Metadata<TItem[]>) {\n            return getMetadata(big);\n        },\n    };\n}\n\nexport function defaultValue<A>(value: A): ILensImpl<A, A> {\n    return {\n        get(big: A) {\n            if (big === undefined || big === null) {\n                return value;\n            } else {\n                return big;\n            }\n        },\n        set(big: A, small: A) {\n            return small;\n        },\n        getMetadata(big: Metadata<any>) {\n            return big;\n        },\n        getValidationState(big: any) {\n            return big;\n        },\n    };\n}\n\nexport function compose<TBig, TMiddle, TSmall>(left: ILensImpl<TBig, TMiddle>, right: ILensImpl<TMiddle, TSmall>): ILensImpl<TBig, TSmall> {\n    if (left === identityLens) {\n        return right as any;\n    }\n\n    if (right === identityLens) {\n        return left as any;\n    }\n\n    return {\n        get(big: TBig) {\n            const middle = left.get(big);\n            const small = right.get(middle);\n            return small;\n        },\n        set(big: TBig, small: TSmall) {\n            let middle = left.get(big);\n            middle = right.set(middle, small);\n            return left.set(big, middle);\n        },\n        getValidationState(big?: TBig) {\n            const middle = left.getValidationState && left.getValidationState(big);\n            const small = right.getValidationState && right.getValidationState(middle);\n            return small;\n        },\n        getMetadata(big?: Metadata<TBig>) {\n            const middle = left.getMetadata && left.getMetadata(big);\n            const small = right.getMetadata && right.getMetadata(middle);\n            return small;\n        },\n    };\n}\n","import { IEditable } from '../../types';\nimport * as Impl from './lensesImpl';\nimport { ILensImpl } from './lensesImpl';\nimport { ILens, ArrayElement, IMapElement } from './types';\n\nexport class LensBuilder<TRoot = any, TFocused = any> implements ILens<TFocused> {\n    public readonly handleValueChange: (newValue: TFocused) => void = null;\n    constructor(public readonly lens: ILensImpl<TRoot, TFocused>) {\n        this.handleValueChange = (newValue: TFocused) => {\n            this.lens.set(null, newValue);\n        };\n    }\n\n    public get(): TFocused {\n        return this.lens.get(null);\n    }\n\n    public key<TId>(id: TId): LensBuilder<TRoot, IMapElement<TFocused>> {\n        return this.compose(Impl.key(id) as any, id);\n    }\n\n    public set(value: TFocused) {\n        this.lens.set(null, value);\n    }\n\n    public update(fn: (current: TFocused) => TFocused) {\n        this.lens.set(null, fn(this.lens.get(null)));\n    }\n\n    public static MAX_CACHE_SIZE = 1000;\n    private cache = new Map();\n    public compose<TSmall>(lens: ILensImpl<TFocused, TSmall>, cacheKey?: any): LensBuilder<TRoot, TSmall> {\n        if (cacheKey != null && this.cache.has(cacheKey)) {\n            return this.cache.get(cacheKey);\n        }\n\n        const result = new LensBuilder(Impl.compose(this.lens, lens));\n\n        if (cacheKey != null) {\n            this.cache.set(cacheKey, result);\n        }\n\n        if (this.cache.size > LensBuilder.MAX_CACHE_SIZE) {\n            const { value } = this.cache.keys().next();\n            this.cache.delete(value);\n        }\n\n        return result;\n    }\n\n    public prop<K extends keyof TFocused>(name: K): LensBuilder<TRoot, NonNullable<TFocused[K]>> {\n        return this.compose(Impl.prop(name), name) as any;\n    }\n\n    public index(index: number): LensBuilder<TRoot, ArrayElement<TFocused>> {\n        return this.compose(Impl.index(index) as any, index);\n    }\n\n    public onChange(fn: (oldValue: TFocused, newValue: TFocused) => TFocused): LensBuilder<TRoot, TFocused> {\n        return this.compose({\n            get: (i) => i, set: fn, getValidationState: this.lens.getValidationState, getMetadata: this.lens.getMetadata as any,\n        }, fn);\n    }\n\n    public default(value: TFocused): LensBuilder<TRoot, TFocused> {\n        return this.compose(Impl.defaultValue(value), value);\n    }\n\n    public toProps(): IEditable<TFocused> {\n        const validationState = this.lens.getValidationState && this.lens.getValidationState(null);\n        const metadata = this.lens.getMetadata && this.lens.getMetadata(null);\n        return {\n            value: this.lens.get(null),\n            onValueChange: this.handleValueChange,\n            ...validationState,\n            ...metadata,\n        };\n    }\n\n    // pick<K extends keyof TFocused>(...keys: K[]): IEditable<Pick<TFocused, K>> {\n    //     throw \"Not implemented\";\n    // }\n}\n","import { LensBuilder } from './LensBuilder';\nimport { IEditable } from '../../types';\nimport { ILens } from './types';\n\n/** @deprecated This helper to be removed in future versions, as it's intended for Class-components, and very rarely used */\nexport function onEditableComponent<T>(component: any): ILens<T> {\n    return new LensBuilder<T, T>({\n        get() {\n            return component.props.value;\n        },\n        set(big: any, small: any) {\n            component.props.onValueChange(small);\n            return small;\n        },\n        getValidationState() {\n            const { isInvalid, validationMessage, validationProps } = component.props;\n            return { isInvalid, validationMessage, validationProps };\n        },\n        getMetadata() {\n            const {\n                isReadonly, isDisabled, isRequired, props, all,\n            } = component.props;\n            return {\n                isReadonly, isDisabled, isRequired, props, all,\n            };\n        },\n    });\n}\n\nexport function onEditable<T>(editable: IEditable<T>): ILens<T> {\n    return new LensBuilder<T, T>({\n        get() {\n            return editable.value;\n        },\n        set(big: any, small: any) {\n            editable.onValueChange(small);\n            return small;\n        },\n        getValidationState() {\n            return editable;\n        },\n    });\n}\n\n/** @deprecated This helper to be removed in future versions, as it's intended for Class-components, and very rarely used */\nexport function onState<T>(component: any): ILens<T> {\n    return new LensBuilder<T, T>({\n        get() {\n            return component.state;\n        },\n        set(_, small: any) {\n            component.setState(small);\n            return small;\n        },\n    });\n}\n","import * as L from './builders';\n\nexport * from './types';\nexport const Lens = L;\n","import { useEffect, useRef } from 'react';\nimport { useUuiContext } from '../../services';\nimport { Link } from '../../types';\n\nexport interface UseLockProps {\n    /** Callback, which will be called on router change */\n    handleLeave?: (nextLocation: Link, currentLocation: Link) => Promise<boolean | 'remain'>;\n    /**\n     * Pass true to enable lock mechanism.\n     * If false, the lock mechanism will be disabled - router can't be blocked\n     */\n    isEnabled: boolean;\n}\n\nexport function useLock({ handleLeave, isEnabled }: UseLockProps) {\n    const context = useUuiContext();\n    const unblockRouterRef = useRef(() => {});\n    const isBlockerRef = useRef(false);\n\n    const block = () => {\n        if (!isEnabled || isBlockerRef.current === true) return;\n        blockRouter();\n    };\n\n    const unblock = () => {\n        unblockRouterRef.current();\n        isBlockerRef.current = false;\n    };\n\n    const blockRouter = () => {\n        isBlockerRef.current = true;\n        const routerWillLeave = (nextLocation: Link) => {\n            const currentLocation = context.uuiRouter.getCurrentLink();\n\n            return handleLeave(nextLocation, currentLocation)\n                .then((res) => {\n                    unblock();\n                    context.uuiRouter.redirect(nextLocation);\n                    if (res === 'remain') {\n                        blockRouter();\n                    }\n                })\n                .catch(() => {});\n        };\n        const unblockRouter = context.uuiRouter.block((location) => {\n            routerWillLeave(location);\n        });\n        unblockRouterRef.current = unblockRouter;\n    };\n\n    useEffect(() => {\n        return () => {\n            unblock();\n        };\n    }, []);\n\n    return {\n        block,\n        unblock,\n        isLocked: isBlockerRef.current === true,\n    };\n}\n","import { IMap } from '../../types';\n\ntype FieldValue = Object | Array<any> | IMap<string, any>;\n\nconst getKeys = (a: FieldValue, b: FieldValue, c: FieldValue) => {\n    if (Array.isArray(a) && Array.isArray(b) && Array.isArray(c)) {\n        return Object.keys({ ...a, ...b, ...c });\n    }\n\n    return Array.from(new Set([...getObjectOrMapKeys(a), ...getObjectOrMapKeys(b), ...getObjectOrMapKeys(c)]));\n};\n\nconst getObjectOrMapKeys = (a: Object | IMap<string, any> | any) => {\n    if (typeof a !== 'object') {\n        return [];\n    }\n\n    if (!Array.isArray(a) && Symbol.iterator in a && typeof a[Symbol.iterator] === 'function') {\n        const keys = [];\n        for (const [key] of a) {\n            keys.push(key);\n        }\n\n        return keys;\n    }\n\n    return Object.keys(a);\n};\n\nconst getValue = (a: FieldValue, key: keyof Object) => {\n    if (('get' in a && typeof a.get === 'function')) {\n        return a.get(key);\n    }\n\n    return a[key];\n};\n\n/**\n * Determines if useForm should create a new undo checkpoint.\n * c is the new change, a and b are previous checkpoints.\n * Returns false only if:\n * - a and b has exactly the same structure (types of fields recursively)\n * - scalar fields changed between b and c, are the same as between a and b.\n * In other words, it returns true only if user just edited the very same scalar field, as he did the last time\n */\nexport function shouldCreateUndoCheckpoint(a: any, b: any, c: any): boolean {\n    // The field type is changed this time.\n    // Probably is was null and became an object, or array become object.\n    // Consider this a major change (adding row, creating some object for the first time)\n    if (typeof b !== typeof c || Array.isArray(b) !== Array.isArray(c)) {\n        return true;\n    }\n\n    // The field is an object of array - need to recurse thru it\n    if (typeof c === 'object' && typeof b === 'object' && typeof c === 'object') {\n        // Ignore that a, b, or c might be an empty array or object and has different structure.\n        // If it's type changed, we already exited with 'true' on the first step\n        // If some there's a difference between keys, values, array length\n        // - we'll find this on the next level of recursion\n        a = a || {};\n        b = b || {};\n        c = c || {};\n        const keys: any[] = getKeys(a, b, c);\n        return keys.some((key) => shouldCreateUndoCheckpoint(getValue(a, key), getValue(b, key), getValue(c, key)));\n    }\n\n    // The field is scalar (null, undefined, boolean, string, number, NaN)\n    // In this case, we only need a checkpoint if it's changed for the first time.\n    // E.g.\n    // 'a' => 'ab' && 'ab' => 'abc' - false, we created checkpoint last time\n    // 'a' => 'ab' && 'ab' => 'ab' - false, this field wasn't changed this time\n    // 'a' => 'a' && 'a' => 'a'  - false, this field wasn't changed at all\n    // 'a' => 'a' && 'a' => 'ab' - true, this field is changed for the first time\n    return a === b && b !== c;\n}\n","import React, { useRef, useEffect, useMemo, useCallback } from 'react';\nimport {\n    mergeValidation,\n    validate as uuiValidate,\n    validateServerErrorState,\n} from '../../data/validation';\nimport { useForceUpdate } from '../../hooks';\nimport { UuiContexts, Link } from '../../types';\nimport { ValidationState } from '../lenses';\nimport { useUuiContext } from '../../services';\nimport { LensBuilder } from '../lenses/LensBuilder';\nimport isEqual from 'react-fast-compare';\nimport { FormProps, FormSaveResponse, IFormApi } from './Form';\nimport { useLock } from './useLock';\nimport { shouldCreateUndoCheckpoint } from './shouldCreateUndoCheckpoint';\nimport { flushSync } from 'react-dom';\n\ninterface FormState<T> {\n    form: T;\n    validationState: ValidationState;\n    serverValidationState: ValidationState;\n    lastSentForm?: T;\n    isChanged: boolean;\n    formHistory: T[];\n    historyIndex: number;\n    isInProgress: boolean;\n    isInSaveMode: boolean;\n}\n\nexport type UseFormProps<T> = Omit<FormProps<T>, 'renderForm'>;\n\nexport function useForm<T>(props: UseFormProps<T>): IFormApi<T> {\n    const context: UuiContexts = useUuiContext();\n\n    const initialForm = useRef<FormState<T>>({\n        isChanged: false,\n        isInProgress: false,\n        form: props.value,\n        validationState: { isInvalid: false },\n        serverValidationState: undefined,\n        formHistory: [props.value],\n        historyIndex: 0,\n        isInSaveMode: false,\n    });\n\n    const propsRef = useRef(props);\n    propsRef.current = props;\n\n    const getMetadata = (value: T) =>\n        propsRef.current.getMetadata ? propsRef.current.getMetadata(value) : {};\n\n    const prevFormValue = useRef<T>(props.value);\n\n    const formState = useRef(initialForm.current);\n\n    const forceUpdate = useForceUpdate();\n\n    const updateFormState = (\n        update: (current: FormState<T>) => FormState<T>,\n    ) => {\n        const newState = update(formState.current);\n        formState.current = newState;\n        forceUpdate();\n    };\n\n    const handleSave = useCallback((isSavedBeforeLeave?: boolean) => {\n        let savePromise: any;\n        updateFormState((currentState) => {\n            let newState = { ...currentState, isInSaveMode: true };\n            newState.isInSaveMode = true;\n            newState = updateValidationStates(newState);\n            if (!newState.validationState.isInvalid) {\n                newState.isInProgress = true;\n                newState.serverValidationState = undefined; // reset serverValidationState if valid form is saving\n                savePromise = propsRef.current\n                    .onSave(formState.current.form)\n                    .then((response) =>\n                        handleSaveResponse(response, isSavedBeforeLeave))\n                    .catch((err) => { handleError(err); return Promise.reject(); });\n            } else {\n                savePromise = Promise.reject();\n            }\n            return newState;\n        });\n        return savePromise;\n    }, []);\n\n    const removeUnsavedChanges = useCallback(() => {\n        context.uuiUserSettings.set(props.settingsKey, null);\n    }, [context.uuiUserSettings, props.settingsKey]);\n\n    const handleLeave = useCallback(async (nextLocation?: Link, currentLocation?: Link, beforeLeave?: FormProps<T>['beforeLeave']) => {\n        if (props.beforeLeave) {\n            const beforeLeaveCb = beforeLeave || props.beforeLeave;\n            const res = await beforeLeaveCb(nextLocation, currentLocation);\n            if (res === true) {\n                return handleSave(true);\n            }\n            if (res === false) {\n                resetForm(initialForm.current);\n                return Promise.resolve();\n            }\n            if (res === 'remain') {\n                return Promise.resolve('remain');\n            }\n        }\n        return Promise.resolve();\n    }, [\n        props.beforeLeave,\n        handleSave,\n        removeUnsavedChanges,\n    ]);\n\n    const { isLocked, block, unblock } = useLock({ handleLeave, isEnabled: !!props.beforeLeave });\n\n    const getMergedValidationState = () => {\n        const {\n            form, lastSentForm, serverValidationState, validationState,\n        } = formState.current;\n        if (serverValidationState) {\n            const serverValidation = validateServerErrorState(form, lastSentForm, serverValidationState);\n            return mergeValidation(validationState, serverValidation);\n        }\n        return validationState;\n    };\n\n    const lens = useMemo(\n        () =>\n            new LensBuilder<T, T>({\n                get: () => formState.current.form,\n                set: (_, small: T) => {\n                    handleFormUpdate(() => small);\n                    return small;\n                },\n                getValidationState: getMergedValidationState,\n                getMetadata: () => getMetadata(formState.current.form),\n            }),\n        [],\n    );\n\n    useEffect(() => {\n        const unsavedChanges = getUnsavedChanges();\n        if (!unsavedChanges || !props.loadUnsavedChanges || isEqual(unsavedChanges, initialForm.current.form)) return;\n        props\n            .loadUnsavedChanges()\n            .then(() => handleFormUpdate(() => unsavedChanges))\n            .catch(() => null);\n    }, []);\n\n    useEffect(() => {\n        if (!isEqual(props.value, prevFormValue.current)) {\n            resetForm({\n                ...initialForm.current,\n                form: props.value,\n                formHistory: [props.value],\n            });\n            prevFormValue.current = props.value;\n        }\n    }, [props.value]);\n\n    const getUnsavedChanges = (): T => {\n        return context.uuiUserSettings.get<T>(props.settingsKey);\n    };\n\n    const handleFormUpdate = (update: (current: T) => T, options?: { addCheckpoint?: boolean }) =>\n        updateFormState((currentState) => {\n            options = options ?? {};\n            options.addCheckpoint = options.addCheckpoint ?? true;\n\n            const newForm = update(currentState.form);\n            let { historyIndex, formHistory } = currentState;\n\n            // Determine if change is significant and we need to create new checkpoint.\n            // If false - we'll just update the latest checkpoint.\n            // We need to always create a checkpoint at the first change, to save initial form state.\n            const needCheckpoint = historyIndex === 0 || shouldCreateUndoCheckpoint(formHistory[historyIndex - 1], formHistory[historyIndex], newForm);\n\n            if (options.addCheckpoint && needCheckpoint) {\n                historyIndex++;\n            }\n            formHistory = formHistory.slice(0, historyIndex).concat(newForm);\n\n            if (options.addCheckpoint || context.uuiUserSettings.get(props.settingsKey)) {\n                context.uuiUserSettings.set(props.settingsKey, newForm);\n            }\n\n            const isChanged = !isEqual(initialForm.current.form, newForm);\n\n            if (isChanged === true) {\n                block();\n            } else {\n                unblock();\n            }\n\n            let newState = {\n                ...currentState,\n                form: newForm,\n                isChanged: isChanged,\n                historyIndex,\n                formHistory,\n            };\n\n            if (currentState.isInSaveMode || props.validationOn === 'change') {\n                newState = updateValidationStates(newState);\n            }\n\n            return newState;\n        });\n\n    const resetForm = (withNewState: FormState<T>) => {\n        updateFormState((currentState) => {\n            const newFormState = { ...currentState, ...withNewState };\n            if (newFormState !== currentState) {\n                initialForm.current = newFormState;\n                return newFormState;\n            }\n        });\n\n        removeUnsavedChanges();\n        unblock();\n    };\n\n    const updateValidationStates = (state: FormState<T>): FormState<T> => {\n        const valueToValidate = state.form;\n        const metadata = getMetadata(valueToValidate);\n        const isInSaveMode = state.isInSaveMode;\n        const validationMode = isInSaveMode || !props.validationOn ? 'save' : props.validationOn;\n        const validationState = uuiValidate(valueToValidate, metadata, initialForm.current.form, validationMode);\n\n        const newState = { ...state, validationState };\n\n        if (!validationState.isInvalid) {\n            // When form became valid, we switch inSaveMode to false\n            newState.isInSaveMode = false;\n        }\n        return newState;\n    };\n\n    const handleError = (err?: any) => {\n        updateFormState((currentValue) => ({\n            ...currentValue,\n            isInProgress: false,\n        }));\n\n        propsRef.current.onError?.(err);\n    };\n\n    const handleSaveResponse = (response: FormSaveResponse<T> | void, isSavedBeforeLeave?: boolean) => {\n        const newFormValue = (response && response.form) || formState.current.form;\n        const newState: FormState<T> = {\n            ...formState.current,\n            historyIndex: 0,\n            formHistory: [newFormValue],\n            isChanged: response && response.validation?.isInvalid ? formState.current.isChanged : false,\n            form: newFormValue,\n            isInProgress: false,\n            serverValidationState: (response && response.validation) || formState.current.serverValidationState,\n            lastSentForm: response && response.validation?.isInvalid ? response.form || formState.current.form : formState.current.lastSentForm,\n        };\n        if (response && response.validation) {\n            flushSync(() => {\n                updateFormState(() => newState);\n            });\n            return Promise.reject(); // Save wasn't success, reject save promise, which is then used by handleLeave\n        }\n        flushSync(() => {\n            resetForm(newState);\n        });\n\n        if (propsRef.current.onSuccess && response) {\n            propsRef.current.onSuccess(response.form, isSavedBeforeLeave);\n        }\n    };\n\n    const handleUndo = useCallback(\n        () =>\n            updateFormState((currentState) => {\n                const { formHistory, historyIndex } = currentState;\n                const previousIndex = historyIndex - 1;\n\n                if (previousIndex >= 0) {\n                    const previousItem = formHistory[previousIndex];\n                    let newState = {\n                        ...currentState,\n                        isChanged: previousIndex !== 0,\n                        form: previousItem,\n                        historyIndex: previousIndex,\n                    };\n                    if (currentState.validationState.isInvalid) {\n                        newState = updateValidationStates(newState);\n                    }\n                    return newState;\n                } else {\n                    return currentState;\n                }\n            }),\n        [],\n    );\n\n    const handleRedo = useCallback(\n        () =>\n            updateFormState((currentState) => {\n                const { formHistory, historyIndex } = currentState;\n                const nextIndex = historyIndex + 1;\n                if (nextIndex < currentState.formHistory.length) {\n                    const nextItem = formHistory[nextIndex];\n                    let newState = {\n                        ...currentState, form: nextItem, historyIndex: nextIndex, isChanged: true,\n                    };\n                    if (currentState.validationState.isInvalid) {\n                        newState = updateValidationStates(newState);\n                    }\n                    return newState;\n                } else {\n                    return currentState;\n                }\n            }),\n        [],\n    );\n\n    const validate = useCallback(() => {\n        const formSate = { ...formState.current, isInSaveMode: true };\n        const newState = updateValidationStates(formSate);\n        updateFormState(() => newState);\n\n        return newState.validationState;\n    }, []);\n\n    const handleRevert = useCallback(() => {\n        resetForm(initialForm.current);\n    }, [props.value]);\n\n    const handleValueChange = useCallback((newValue: T) => {\n        handleFormUpdate(() => newValue);\n    }, []);\n\n    const handleSetValue = useCallback((value: React.SetStateAction<T>) => {\n        handleFormUpdate((currentValue) => {\n            const newValue: T = value instanceof Function ? value(currentValue) : value;\n            return newValue;\n        });\n    }, []);\n\n    const handleReplaceValue = useCallback((value: React.SetStateAction<T>) => {\n        updateFormState((currentValue) => {\n            const newFormValue = value instanceof Function ? value(currentValue.form) : value;\n            return {\n                ...currentValue,\n                form: newFormValue,\n            };\n        });\n    }, []);\n\n    const saveCallback = useCallback(() => {\n        handleSave().catch(() => {});\n    }, [handleSave]);\n\n    const handleClose = useCallback<IFormApi<T>['close']>((options) => {\n        return isLocked ? handleLeave(null, null, options?.beforeLeave) : Promise.resolve();\n    }, [isLocked]);\n\n    const setServerValidationState = useCallback((value: React.SetStateAction<ValidationState>) => {\n        updateFormState((currentValue) => {\n            const newValue = value instanceof Function ? value(currentValue.serverValidationState) : value;\n            return {\n                ...currentValue,\n                serverValidationState: newValue,\n            };\n        });\n    }, []);\n\n    const mergedValidationState = getMergedValidationState();\n\n    return {\n        setValue: handleSetValue,\n        replaceValue: handleReplaceValue,\n        isChanged: formState.current.isChanged,\n        close: handleClose,\n        lens,\n        save: saveCallback,\n        undo: handleUndo,\n        redo: handleRedo,\n        revert: handleRevert,\n        validate,\n        canUndo: formState.current.historyIndex > 0,\n        canRedo: formState.current.historyIndex < formState.current.formHistory.length - 1,\n        canRevert: formState.current.form !== props.value,\n        value: formState.current.form,\n        onValueChange: handleValueChange,\n        isInvalid: mergedValidationState.isInvalid,\n        validationMessage: mergedValidationState.validationMessage,\n        validationProps: mergedValidationState.validationProps,\n        serverValidationState: formState.current.serverValidationState,\n        setServerValidationState,\n        isInProgress: formState.current.isInProgress,\n    };\n}\n","import React, { ReactNode } from 'react';\nimport { useForm } from './useForm';\nimport { IEditable } from '../../types/props';\nimport { Metadata } from '../../types/validation';\nimport { ILens, ValidationState } from '../../data/lenses';\nimport { ValidationMode } from '../../data/validation';\nimport { Link } from '../../types';\n\nexport interface FormSaveResponse<T> {\n    /** New form value, which will replace previous one */\n    form?: T;\n    /** Server-side validation state. It's applied in priority over client validation. */\n    validation?: ValidationState;\n}\n\nexport interface FormProps<T> {\n    /** Initial Form value\n     * If changed after initialization, form will be reverted to the new value\n     * */\n    value: T;\n\n    /**\n     * Render the form body, provided by form state\n     * */\n    renderForm: (props: IFormApi<T>) => ReactNode;\n\n    /**\n     * Returns form metadata - information used to validate the form.\n     * @param state Metadata can depend on state, and will be re-computed on updates\n     */\n    getMetadata?(state: T): Metadata<T>;\n\n    /**\n     * Occurs when 'save' function is called on Form.\n     * Should save form data (usually with API call to server).\n     * Server can also reject form, and provide validation errors in response.\n     * @param state Form state to save\n     */\n    onSave(state: T): Promise<FormSaveResponse<T> | void>;\n\n    /**\n     * Called when form is unmounted, but user still have unsaved changes.\n     * Accepts a Promise<boolean | 'remain'> to be returned.\n     * If promise resolves to true - save procedure is performed.\n     * If promise resolves to false - save action will not be called, form will be unblocked.\n     * If promise resolves to 'remain' - form will be remained in the same state - blocked and not saved.\n     * The common use-case is to show a modal with \"Save Changes?\" dialog\n     * Skins usually implement this as default behavior. To prevent it, you can pass null to this prop to override it.\n     */\n    beforeLeave?: ((nextLocation: Link, currentLocation: Link) => Promise<boolean | 'remain'>) | null;\n\n    /**\n     * Used to restore unsaved user edits from the last session (usually to localstorage, via uuiUserSettings context)\n     * If unsaved changes are detected, this callback is called. If it is resolved - the form restores unsaved edits.\n     * The common use-case is to show a modal with \"You have unsaved changes, restore them?\" dialog\n     * Skins usually implement this as default behavior. To prevent it, you can pass null to this prop to override it.\n     */\n    loadUnsavedChanges?: () => Promise<void>;\n\n    /**\n     * Called after successful save.\n     * @param state Saved state\n     * @param isSavedBeforeLeave true, if save is triggered via leaving the page, and \"Save Changes?\" dialog\n     */\n    onSuccess?(state: T, isSavedBeforeLeave?: boolean): any;\n\n    /** Called when save fails */\n    onError?(error: any): any;\n\n    /**\n     * The key, under which form save unsaved state usually to localstorage, via uuiUserSettings context)\n     */\n    settingsKey?: string;\n\n    /**\n     * Controls when form validation occurs:\n     * save (default, recommended) - form is validated on save. If form is invalid - it will be revalidated on every change, until become valid\n     * change - form is validated on every user change. Only fields changes in current edit session are validated\n     */\n    validationOn?: ValidationMode;\n}\n\nexport interface IFormApi<T> extends IEditable<T>, ValidationState {\n    /**\n     * Lens - a helper to split parts of the form state, validation, and setState callbacks, and pass this to components\n     */\n    lens: ILens<T>;\n\n    /**\n     * Sets form value. The signature is the same for setState in React.useState - either new value, or callback to update the value.\n     * The change is threated as user input - sets isChanged and creates undo endpoint\n     */\n    setValue: (s: React.SetStateAction<T>) => void;\n\n    /**\n     * Replaces form value. The signature is the same for setState in React.useState - either new value, or callback to update the value.\n     * The change is not threated as user input - it replaces last changed state, and doesn't create undo checkpoint.\n     */\n    replaceValue: (s: React.SetStateAction<T>) => void;\n\n    /**\n     * Triggers save procedure - validation, calling props.onSave, and processing results\n     */\n    save(): void;\n\n    /**\n     * Undo to last checkpoint\n     */\n    undo(): void;\n\n    /**\n     * Redo last action\n     */\n    redo(): void;\n\n    /**\n     * Reverts all changes up to the initial or last saved state\n     */\n    revert(): void;\n\n    /**\n     * Try to leave form and ask to save unsaved changes\n     * You can provide your own `beforeLeave` callback via options param, this callback will be called before close action.\n     * If `beforeLeave` param is omitted, default UUI beforeLeave implementation will be used\n     */\n    close(options?: { beforeLeave?: FormProps<T>['beforeLeave'] }): Promise<any>;\n\n    /**\n     * Forces form to validate value.\n     * Validation is usually done automatically, according to validationOn prop.\n     * Use this method only in corner cases.\n     */\n    validate(): ValidationState;\n\n    /** True if there are changes to undo */\n    canUndo: boolean;\n\n    /** True if there are changes to redo */\n    canRedo: boolean;\n\n    /** True if there are changes to revers */\n    canRevert: boolean;\n\n    /** True if form is changed since the initial state, or the last save */\n    isChanged: boolean;\n\n    /** True if save is in progress */\n    isInProgress: boolean;\n\n    /** Validation state which was returned from `onSave` callback  */\n    serverValidationState: ValidationState;\n\n    /** Sets new server validation state from client side */\n    setServerValidationState: (s: React.SetStateAction<ValidationState>) => void\n}\n\nexport function Form<T>({ renderForm, ...props }: FormProps<T>) {\n    const useFormProps = useForm<T>(props);\n    return <>{renderForm(useFormProps)}</>;\n}\n","import { useMemo } from 'react';\nimport { NextRouterAdapter } from '../services';\nimport { useUuiServices, UseUuiServicesProps } from '../hooks/useUuiServices';\n\nexport interface IContextProviderSsrProps<TApi, TAppContext>\n    extends UseUuiServicesProps<TApi, TAppContext> {\n    router: any;\n}\n\n/**\n * This hook creates UUI context compatible with Next.js pages router\n *\n * @example\n * const { services } = useUuiServicesSsr({ ... });\n * <UuiContext.Provider value={ services }> ... </UuiContext.Provider>\n * // And then, use it in code like this:\n * const services = useUuiContext<TApi, AppContextType>();\n *\n * @param props\n */\nexport function useUuiServicesSsr<TApi, TAppContext>(\n    props: IContextProviderSsrProps<TApi, TAppContext>,\n) {\n    const { router, ...restProps } = props;\n    const nextRouterWithAdapter = useMemo(() => new NextRouterAdapter(router), [router]);\n    const { services } = useUuiServices<TApi, TAppContext>({\n        ...restProps,\n        router: nextRouterWithAdapter,\n    });\n    return { services };\n}\n","import { useEffect, useMemo } from 'react';\nimport {\n    NextAppRouterAdapter, ReadonlySearchParams, TNextAppRouter,\n} from '../services/routing/NextAppRouterAdapter';\n\n/**\n * Creates app router adapter instance for Nextjs\n */\nexport const useNextAppRouter = ({\n    router,\n    pathname,\n    searchParams,\n}: {\n    router: TNextAppRouter;\n    pathname: string;\n    searchParams: ReadonlySearchParams;\n}) => {\n    const appRouterAdapter = useMemo(\n        () => new NextAppRouterAdapter(router),\n        [router],\n    );\n\n    // avoid re-creation router adapter by updating router related stuff here\n    useEffect(() => {\n        appRouterAdapter.updateURLParams(pathname, searchParams);\n    }, [appRouterAdapter, searchParams, pathname]);\n\n    return appRouterAdapter;\n};\n"]}