@elliemae/ds-treeview 2.3.0-alpha.8 → 2.3.0-next.2

package/types/plugins/selectable/index.d.ts

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

package/types/plugins/toolbar/TreeToolbarPlugin.d.ts

@@ -0,0 +1 @@
+export declare const TreeToolbarPlugin = "tree-toolbar";

package/types/plugins/toolbar/index.d.ts

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

package/types/plugins/tree/TreeDataPlugin.d.ts

@@ -0,0 +1 @@
+export declare const TreePluginList = "tree-data";

package/types/plugins/tree/index.d.ts

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

package/types/plugins/virtualization/TreeVirtualizationPlugin.d.ts

@@ -0,0 +1 @@
+export declare const TreeVirtualizationPlugin = "tree-virtualization";

package/types/plugins/virtualization/index.d.ts

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

package/types/react-desc-prop-types.d.ts

@@ -0,0 +1,210 @@
+/// <reference path="../../../../shared/typings/react-desc.d.ts" />
+/// <reference types="react" />
+import TreeModel from 'tree-model';
+import { useVirtual } from 'react-virtual';
+export declare namespace DSTreeviewT {
+    type StringOrNum = string | number;
+    type SelectionState = boolean | 'mixed';
+    type SelectionItems = Record<StringOrNum, SelectionState>;
+    type ScrollToFunc = ReturnType<typeof useVirtual>['scrollToIndex'];
+    type ScrollToItemOptions = Parameters<ReturnType<typeof useVirtual>['scrollToIndex']>[1];
+    type ScrollToItemFunc = (options: ScrollToItemOptions) => void;
+    type ExpandedItems = Record<StringOrNum, true>;
+    interface SimpleItem {
+        [key: string]: unknown;
+        name: string;
+        children?: SimpleItem[];
+        id: StringOrNum;
+    }
+    interface Item extends SimpleItem {
+        children: Item[];
+        treeDepth?: number;
+        virtualIndex?: number;
+        isChecked?: boolean | 'mixed';
+        isGroup?: boolean;
+        isExpanded?: boolean;
+        childrenMatchesSearchQuery?: boolean;
+        matchesSearchQuery?: boolean;
+        nodeItemRef?: React.RefObject<HTMLLIElement>;
+        model: TreeModel.Node<Item>['model'];
+        node: TreeModel.Node<Item> & {
+            parent?: TreeModel.Node<Item>;
+        };
+        nodePath: TreeModel.Node<Item>[];
+    }
+    interface DndItem {
+        uid: string;
+        depth: number;
+        realIndex: number;
+        childrenCount: number;
+        parentId: string | null;
+        original: SimpleItem;
+    }
+    interface Actions {
+        toggleExpandAll: (isExpand: boolean) => Promise<DSTreeviewT.Item[]>;
+        scrollTo: DSTreeviewT.ScrollToFunc;
+        setSelectedItemByVirtualIndex: (index: number) => void;
+        setFocusedItemByVirtualIndex: (index: number, scrollOpts: DSTreeviewT.ScrollToItemOptions & {
+            withScroll?: boolean;
+        }) => void;
+    }
+    interface InstanceRef {
+        actions: Actions;
+    }
+    interface DefaultProps {
+        plugins: string[];
+        selection: SelectionItems;
+        instanceRef: React.MutableRefObject<InstanceRef>;
+        isItemDisabled: (item: Item) => boolean;
+        disableIcons: boolean;
+        fluid: boolean;
+        isMultiSelect: boolean;
+        isSingleSelect: boolean;
+        getIsDropValid: (active: DndItem, over: DndItem, dropIndicatorPosition: 'none' | 'before' | 'after' | 'inside') => boolean;
+        restrictDragAndDrop: boolean;
+        showChildrenAmount: boolean;
+        sortable: boolean;
+        isLoading: boolean;
+        highlightOnlyQuery: boolean;
+        onItemClick: (item: Item, e: React.MouseEvent<HTMLLIElement>) => void;
+        onItemFocus: (meta: {
+            scrollToItem: ScrollToItemFunc;
+            itemIndex: number;
+            item: Item;
+        }) => void;
+        onVisibleItemsChange: (newVisibleItems: Item[]) => void;
+        onOrderChange: (newData: SimpleItem[], oldData: SimpleItem[], draggedItem: DndItem) => void;
+        onSelectionChange: (selection: SelectionItems, item: Item, meta: {
+            scrollToItem: ScrollToItemFunc;
+            itemIndex: number;
+        }) => void;
+        onExpandChange: (expandedHashmap: ExpandedItems, itemToggled: Item | null | undefined) => void;
+        onInstanceRefInitialized: (instanceRef: React.MutableRefObject<InstanceRef>) => void;
+        rowSize: 'normal' | 'compact';
+        labelOverflow: 'wrap' | 'wrap-all' | 'truncate';
+        noItemsPlaceholder: string;
+        nameKey: string;
+        width: StringOrNum;
+        height: StringOrNum;
+        groupIcon: JSX.Element | null;
+        itemIcon: JSX.Element | null;
+        searchQuery: string;
+    }
+    interface PropsOptional {
+        expanded: ExpandedItems;
+        rightAddons: ((item: Item) => React.ReactNode | React.ReactNode[]) | JSX.Element;
+    }
+    interface PropsRequired {
+        data: Item[];
+    }
+    interface Props extends DefaultProps, PropsOptional, PropsRequired {
+    }
+}
+export declare const TreeViewPropTypes: {
+    data: import("react-desc").PropTypesDescValue;
+    plugins: {
+        deprecated: import("react-desc").PropTypesDescValidator;
+    };
+    selection: {
+        deprecated: import("react-desc").PropTypesDescValidator;
+    };
+    expanded: {
+        deprecated: import("react-desc").PropTypesDescValidator;
+    };
+    instanceRef: {
+        defaultValue(arg: import("react-desc").ReactDescPossibleDefaultValues): {
+            deprecated: import("react-desc").PropTypesDescValidator;
+        };
+        isRequired: import("react-desc").PropTypesDescValue;
+    };
+    isItemDisabled: {
+        deprecated: import("react-desc").PropTypesDescValidator;
+    };
+    disableIcons: {
+        deprecated: import("react-desc").PropTypesDescValidator;
+    };
+    fluid: {
+        deprecated: import("react-desc").PropTypesDescValidator;
+    };
+    isMultiSelect: {
+        deprecated: import("react-desc").PropTypesDescValidator;
+    };
+    isSingleSelect: {
+        deprecated: import("react-desc").PropTypesDescValidator;
+    };
+    isLoading: {
+        deprecated: import("react-desc").PropTypesDescValidator;
+    };
+    getIsDropValid: {
+        deprecated: import("react-desc").PropTypesDescValidator;
+    };
+    restrictDragAndDrop: {
+        deprecated: import("react-desc").PropTypesDescValidator;
+    };
+    showChildrenAmount: {
+        deprecated: import("react-desc").PropTypesDescValidator;
+    };
+    sortable: {
+        deprecated: import("react-desc").PropTypesDescValidator;
+    };
+    onItemClick: {
+        deprecated: import("react-desc").PropTypesDescValidator;
+    };
+    onItemFocus: {
+        deprecated: import("react-desc").PropTypesDescValidator;
+    };
+    onVisibleItemsChange: {
+        deprecated: import("react-desc").PropTypesDescValidator;
+    };
+    onOrderChange: {
+        deprecated: import("react-desc").PropTypesDescValidator;
+    };
+    onSelectionChange: {
+        deprecated: import("react-desc").PropTypesDescValidator;
+    };
+    onExpandChange: {
+        deprecated: import("react-desc").PropTypesDescValidator;
+    };
+    onInstanceRefInitialized: {
+        deprecated: import("react-desc").PropTypesDescValidator;
+    };
+    rowSize: {
+        deprecated: import("react-desc").PropTypesDescValidator;
+    };
+    labelOverflow: {
+        deprecated: import("react-desc").PropTypesDescValidator;
+    };
+    width: {
+        deprecated: import("react-desc").PropTypesDescValidator;
+    };
+    height: {
+        deprecated: import("react-desc").PropTypesDescValidator;
+    };
+    groupIcon: {
+        defaultValue(arg: import("react-desc").ReactDescPossibleDefaultValues): {
+            deprecated: import("react-desc").PropTypesDescValidator;
+        };
+        isRequired: import("react-desc").PropTypesDescValue;
+    };
+    itemIcon: {
+        defaultValue(arg: import("react-desc").ReactDescPossibleDefaultValues): {
+            deprecated: import("react-desc").PropTypesDescValidator;
+        };
+        isRequired: import("react-desc").PropTypesDescValue;
+    };
+    searchQuery: {
+        defaultValue(arg: import("react-desc").ReactDescPossibleDefaultValues): {
+            deprecated: import("react-desc").PropTypesDescValidator;
+        };
+        isRequired: import("react-desc").PropTypesDescValue;
+    };
+    noItemsPlaceholder: {
+        deprecated: import("react-desc").PropTypesDescValidator;
+    };
+    name: {
+        deprecated: import("react-desc").PropTypesDescValidator;
+    };
+    highlightOnlyQuery: {
+        deprecated: import("react-desc").PropTypesDescValidator;
+    };
+};

package/types/related-components/TreeViewSearchBar.d.ts

@@ -0,0 +1,16 @@
+/// <reference types="react" />
+interface PropsT {
+    handleChange: (opt: {
+        target: {
+            value: string;
+        };
+    }) => void;
+    onNext: () => void;
+    onPrevious: () => void;
+    onClear: () => void;
+    currentResultIndex: number;
+    totalResults: number;
+    value: string;
+}
+export declare function TreeViewSearchBar(props: PropsT): JSX.Element;
+export {};

package/types/sharedTypes.d.ts

@@ -0,0 +1,47 @@
+import TreeModel from 'tree-model';
+import { useVirtual } from 'react-virtual';
+import type { SetStateAction } from 'react';
+import type { DSTreeviewT } from './react-desc-prop-types';
+export declare namespace DSTreeviewInternalsT {
+    type GenericFunc<T extends unknown[]> = (..._args: T) => void;
+    type DnDMovementDirectionT = 'topToBottom' | 'bottomToTop';
+    interface MouseCoord {
+        isBefore: boolean;
+        isAfter: boolean;
+        isValid: boolean;
+        item: DSTreeviewT.Item | null;
+        x: number | null;
+        y: number | null;
+        relativeElementDOMRect: DOMRect | null;
+        relativeElementIndex: number | null;
+    }
+    type StateSetter<T = unknown> = React.Dispatch<SetStateAction<T>>;
+    interface CTX {
+        props: DSTreeviewT.Props;
+        visibleItems: DSTreeviewT.Item[];
+        flattenedItems: DSTreeviewT.DndItem[];
+        withRadioChecks: boolean;
+        withCheckboxChecks: boolean;
+        withDragAndDrop: boolean;
+        triggerTreeRerender: () => void;
+        tree?: TreeModel;
+        treeRoot?: TreeModel.Node<DSTreeviewT.Item>;
+        virtualListHelpers: ReturnType<typeof useVirtual>;
+        virtualListRef?: React.MutableRefObject<HTMLUListElement | undefined>;
+        uniqueTreeViewUUID: string;
+        selectedItem: DSTreeviewT.Item | null;
+        setSelectedItem: StateSetter<DSTreeviewT.Item | null>;
+        focusedItem: DSTreeviewT.Item | null;
+        setFocusedItem: StateSetter<DSTreeviewT.Item | null>;
+        selectedCheckboxes: DSTreeviewT.SelectionItems;
+        setSelectedCheckboxes: StateSetter<DSTreeviewT.SelectionItems>;
+        expandedGroups: DSTreeviewT.ExpandedItems;
+        setExpandedGroups: StateSetter<DSTreeviewT.ExpandedItems>;
+        latestToggledItem?: DSTreeviewT.Item | null | undefined;
+        setLatestToggledItem: StateSetter<DSTreeviewT.Item | null>;
+        hoverItem: DSTreeviewT.Item | null;
+        setHoverItem: StateSetter<DSTreeviewT.Item | null>;
+        handleExpandGroup: (itemToToggle: DSTreeviewT.Item, triggerTreeRerender: () => void, updateUserExpandedState: () => void, scrollTo?: DSTreeviewT.ScrollToFunc, e?: React.MouseEvent<HTMLElement> | React.KeyboardEvent<HTMLElement>) => void;
+        updateUserExpandedState: () => void;
+    }
+}

package/types/utils/array-helpers.d.ts

@@ -0,0 +1,2 @@
+export declare const arrayMoveMutate: (array: unknown[], from: number, to: number) => void;
+export declare const arrayMove: (array: unknown[], from: number, to: number) => unknown[];

package/types/utils/group-expands-helpers.d.ts

@@ -0,0 +1,14 @@
+import type { DSTreeviewT } from '../react-desc-prop-types';
+import type { DSTreeviewInternalsT } from '../sharedTypes';
+export declare const updateExpandedState: (treeRoot: DSTreeviewT.Item['node'], onExpandChange: DSTreeviewT.Props['onExpandChange'] | null | undefined) => void;
+export declare const toggleItemExpand: (itemToToggle: DSTreeviewT.Item, triggerTreeRerender: () => void, updateUserExpandedState: DSTreeviewInternalsT.CTX['updateUserExpandedState'], scrollTo?: DSTreeviewT.ScrollToFunc) => void;
+export declare const expandItemModel: (modelToExpand: DSTreeviewT.Item['model']) => void;
+export declare const collapseItemModel: (modelToCollapse: DSTreeviewT.Item['model']) => void;
+export declare const expandAll: (treeRoot: DSTreeviewT.Item['node'], triggerTreeRerender: () => void) => void;
+export declare const collapseAll: (treeRoot: DSTreeviewT.Item['node'], triggerTreeRerender: () => void) => void;
+export declare const getToggleExpandShouldExpand: (treeRoot: DSTreeviewT.Item['node']) => boolean;
+export declare const toggleExpandAllHelper: (isExpand: boolean | 'toggle', treeRoot: DSTreeviewT.Item['node'], triggerTreeRerender: () => void, setLatestToggledItem: DSTreeviewInternalsT.CTX['setLatestToggledItem'], updateUserExpandedState: DSTreeviewInternalsT.CTX['updateUserExpandedState']) => void;
+export declare const useNotifyExpandedChange: (propsWithDefaults: DSTreeviewT.Props, { latestToggledItem, expandedGroups, }: {
+    latestToggledItem?: DSTreeviewInternalsT.CTX['latestToggledItem'];
+    expandedGroups?: DSTreeviewT.ExpandedItems | undefined;
+}) => void;

package/types/utils/keyboard-helpers.d.ts

@@ -0,0 +1,6 @@
+import type { DSTreeviewT } from '../react-desc-prop-types';
+import type { DSTreeviewInternalsT } from '../sharedTypes';
+import { SortableItemContextType } from '../hoc/SortableItemContext';
+export declare const useOnItemKeyDown: (item: DSTreeviewT.Item, draggableProps: SortableItemContextType['draggableProps']) => (e: React.KeyboardEvent<HTMLLIElement>) => void;
+export declare const useGlobalKeyboardListener: (func: (e: KeyboardEvent) => void) => void;
+export declare const useGlobalToggleAllExpandShortcut: (treeRoot: DSTreeviewT.Item['node'], triggerTreeRerender: () => void, setLatestToggledItem: DSTreeviewInternalsT.CTX['setLatestToggledItem'], updateUserExpandedState: DSTreeviewInternalsT.CTX['updateUserExpandedState']) => void;

package/types/utils/object-helpers.d.ts

@@ -0,0 +1,6 @@
+export declare const unfreeze: (o: string | number | unknown[] | Date | null | undefined | Record<string, unknown>) => string | number | unknown[] | Date | Record<string, unknown> | null | undefined;
+declare type GenericItemT<T = unknown> = {
+    [key: string]: T;
+};
+export declare function filterObject<T = unknown>(obj: GenericItemT<T>, predicate: (val: T) => boolean): GenericItemT<T>;
+export {};

package/types/utils/refs-helpers.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="react" />
+declare type GenericMergeableRef = null | undefined | React.MutableRefObject<unknown> | ((ref: HTMLElement) => void) | false;
+export declare const setMultipleRefs: (...refs: GenericMergeableRef[]) => (ref: HTMLElement) => void;
+export {};

package/types/utils/selectable-helper.d.ts

@@ -0,0 +1,7 @@
+import type { DSTreeviewT } from '../react-desc-prop-types';
+export declare const getGroupCheckState: (node: DSTreeviewT.Item['node']) => boolean | "mixed";
+export declare const selectCheckboxItemModelParentsTillRoot: (modelToCheck: DSTreeviewT.Item, triggerTreeRerender?: (() => void) | null) => DSTreeviewT.SelectionItems;
+export declare const toggleCheckboxItem: (itemToSelect: DSTreeviewT.Item, triggerTreeRerender?: (() => void) | null) => {
+    [x: string]: DSTreeviewT.SelectionState;
+    [x: number]: DSTreeviewT.SelectionState;
+};

package/types/utils/string-helpers.d.ts

@@ -0,0 +1 @@
+export declare const standardizeSearchQueryString: (input: string) => string;

package/types/utils/tree-helpers.d.ts

@@ -0,0 +1,28 @@
+import type TreeModel from 'tree-model';
+import type { DSTreeviewT } from '../react-desc-prop-types';
+export declare const walkVisibles: (node: DSTreeviewT.Item['node'], callback: (node: DSTreeviewT.Item['node']) => void, skipRoot?: boolean, highlightOnlyQuery?: boolean) => void;
+export declare const walkParents: (nodePath: DSTreeviewT.Item['nodePath'], callback: (currParent: DSTreeviewT.Item['node']) => void, skipRoot?: boolean) => void;
+declare type RecursiveCallbackT = (childNode: DSTreeviewT.Item['node'], cb?: RecursiveCallbackT, isFirst?: boolean) => void;
+export declare const walkAllNodeChildren: (node: DSTreeviewT.Item['node'], callback: RecursiveCallbackT, isFirst?: boolean) => void;
+export declare const getNodeById: (treeRoot: DSTreeviewT.Item['node'], id: DSTreeviewT.StringOrNum) => TreeModel.Node<DSTreeviewT.Item>;
+export declare const cloneNode: (tree: TreeModel, node: DSTreeviewT.Item) => TreeModel.Node<DSTreeviewT.Item>;
+export declare const itemsShareSameParent: (items?: DSTreeviewT.Item[]) => boolean;
+export declare const getItemsParentNode: (items?: DSTreeviewT.Item[], skipSameParentCheck?: boolean) => TreeModel.Node<DSTreeviewT.Item> & {
+    parent?: TreeModel.Node<DSTreeviewT.Item> | undefined;
+};
+export declare const getNodeMatchesSearchQuery: (node: DSTreeviewT.Item['node'], searchQuery?: string) => boolean;
+export declare const getChildrenMatchesSearchQuery: (parentNode: DSTreeviewT.Item['node'], searchQuery?: string) => boolean;
+/**
+ * Mutate in place a node from tree-model normalizing object properties like "isGroup" even if user didn't specify it explicitly,
+ * after execution the node will have "nodePath" "treeDepth" "nodeItemRef" "isGroup" "isExpanded"
+ * (optionally, based on the provided arguments) "matchesSearchQuery" "childrenMatchesSearchQuery" "isChecked"
+ *
+ * @param {Object} node - node (based on 'tree-model' lib) that you wish to mutate with extra props
+ * @param {string} [searchQuery=''] - optional string used to parse "matchesSearchQuery"/"childrenMatchesSearchQuery" properties
+ * @param {Object} [selection=null] - optional selection hashmap used to parse "isChecked" properties
+ * @param {Object} [expanded=null] - optional expanded hashmap used to parse "isExpanded" properties
+ */
+export declare const enrichNodeModelInPlace: (node: TreeModel.Node<DSTreeviewT.SimpleItem>, searchQuery?: string, selection?: DSTreeviewT.SelectionItems | null, expanded?: DSTreeviewT.ExpandedItems | null) => void;
+export declare const focusItem: (item: DSTreeviewT.Item | null) => void;
+export declare const flattenTreeForDnD: (data: DSTreeviewT.SimpleItem[], shouldDescend?: (datum: DSTreeviewT.SimpleItem) => boolean) => DSTreeviewT.DndItem[];
+export {};

package/types/utils/useInstanceRefActions.d.ts

@@ -0,0 +1,3 @@
+import type { DSTreeviewT } from '../react-desc-prop-types';
+import type { DSTreeviewInternalsT } from '../sharedTypes';
+export declare const useInstanceRefActions: ({ actions }: DSTreeviewT.InstanceRef, ctx: DSTreeviewInternalsT.CTX) => DSTreeviewT.Actions;

package/types/utils/useTree.d.ts

@@ -0,0 +1,14 @@
+import TreeModel from 'tree-model';
+import type { DSTreeviewT } from '../react-desc-prop-types';
+import type { DSTreeviewInternalsT } from '../sharedTypes';
+export declare const useTree: (data: DSTreeviewT.SimpleItem[], props: DSTreeviewT.Props, states: {
+    setExpandedGroups: DSTreeviewInternalsT.StateSetter<DSTreeviewT.ExpandedItems>;
+}) => {
+    visibleItems: DSTreeviewT.Item[];
+    flattenedItems: DSTreeviewT.DndItem[];
+    tree: TreeModel;
+    treeRoot: TreeModel.Node<DSTreeviewT.Item>;
+    rerenderItems: {};
+    triggerTreeRerender: () => void;
+    updateUserExpandedState: () => void;
+};

package/dist/cjs/TreeView.js

@@ -1,50 +0,0 @@
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __markAsModule = (target) => __defProp(target, "__esModule", { value: true });
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __reExport = (target, module2, copyDefault, desc) => {
-  if (module2 && typeof module2 === "object" || typeof module2 === "function") {
-    for (let key of __getOwnPropNames(module2))
-      if (!__hasOwnProp.call(target, key) && (copyDefault || key !== "default"))
-        __defProp(target, key, { get: () => module2[key], enumerable: !(desc = __getOwnPropDesc(module2, key)) || desc.enumerable });
-  }
-  return target;
-};
-var __toESM = (module2, isNodeMode) => {
-  return __reExport(__markAsModule(__defProp(module2 != null ? __create(__getProtoOf(module2)) : {}, "default", !isNodeMode && module2 && module2.__esModule ? { get: () => module2.default, enumerable: true } : { value: module2, enumerable: true })), module2);
-};
-var __toCommonJS = /* @__PURE__ */ ((cache) => {
-  return (module2, temp) => {
-    return cache && cache.get(module2) || (temp = __reExport(__markAsModule({}), module2, 1), cache && cache.set(module2, temp), temp);
-  };
-})(typeof WeakMap !== "undefined" ? /* @__PURE__ */ new WeakMap() : 0);
-var TreeView_exports = {};
-__export(TreeView_exports, {
-  TreeView: () => TreeView,
-  TreeViewWithSchema: () => TreeViewWithSchema
-});
-var React = __toESM(require("react"));
-var import_react = __toESM(require("react"));
-var import_react_desc = require("react-desc");
-var import_react_desc_prop_types = require("./react-desc-prop-types");
-var import_TreeViewContext = __toESM(require("./TreeViewContext"));
-var import_useTreeview = require("./config/useTreeview");
-var import_TreeList = require("./parts/TreeList");
-function TreeView(props) {
-  const { ctx } = (0, import_useTreeview.useTreeview)(props);
-  return /* @__PURE__ */ import_react.default.createElement(import_TreeViewContext.default.Provider, {
-    value: ctx
-  }, /* @__PURE__ */ import_react.default.createElement(import_TreeList.TreeList, null));
-}
-TreeView.propTypes = import_react_desc_prop_types.TreeViewPropTypes;
-const TreeViewWithSchema = (0, import_react_desc.describe)(TreeView);
-TreeViewWithSchema.propTypes = import_react_desc_prop_types.TreeViewPropTypes;
-module.exports = __toCommonJS(TreeView_exports);
-//# sourceMappingURL=TreeView.js.map

package/dist/cjs/TreeView.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../src/TreeView.tsx", "../../../../scripts/build/transpile/react-shim.js"],
-  "sourcesContent": ["import React, { WeakValidationMap } from 'react';\n\nimport { describe } from 'react-desc';\nimport { TreeViewPropTypes } from './react-desc-prop-types';\nimport TreeViewContext from './TreeViewContext';\nimport { useTreeview } from './config/useTreeview';\nimport { TreeList } from './parts/TreeList';\nimport type { DSTreeviewT } from './react-desc-prop-types';\nexport function TreeView(props: DSTreeviewT.Props) {\n  const { ctx } = useTreeview(props);\n\n  return (\n    <TreeViewContext.Provider value={ctx}>\n      <TreeList />\n    </TreeViewContext.Provider>\n  );\n}\n\nTreeView.propTypes = TreeViewPropTypes as WeakValidationMap<unknown>;\nconst TreeViewWithSchema = describe(TreeView);\nTreeViewWithSchema.propTypes = TreeViewPropTypes;\n\nexport { TreeViewWithSchema };\n", "import * as React from 'react';\nexport { React };\n"],
-  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;ACAA,YAAuB;ADAvB,mBAAyC;AAEzC,wBAAyB;AACzB,mCAAkC;AAClC,6BAA4B;AAC5B,yBAA4B;AAC5B,sBAAyB;AAElB,kBAAkB,OAA0B;AACjD,QAAM,EAAE,QAAQ,oCAAY;AAE5B,SACE,mDAAC,+BAAgB,UAAjB;AAAA,IAA0B,OAAO;AAAA,KAC/B,mDAAC,0BAAD;AAAA;AAKN,SAAS,YAAY;AACrB,MAAM,qBAAqB,gCAAS;AACpC,mBAAmB,YAAY;",
-  "names": []
-}

package/dist/cjs/TreeViewContext.js

@@ -1,116 +0,0 @@
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __markAsModule = (target) => __defProp(target, "__esModule", { value: true });
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __reExport = (target, module2, copyDefault, desc) => {
-  if (module2 && typeof module2 === "object" || typeof module2 === "function") {
-    for (let key of __getOwnPropNames(module2))
-      if (!__hasOwnProp.call(target, key) && (copyDefault || key !== "default"))
-        __defProp(target, key, { get: () => module2[key], enumerable: !(desc = __getOwnPropDesc(module2, key)) || desc.enumerable });
-  }
-  return target;
-};
-var __toESM = (module2, isNodeMode) => {
-  return __reExport(__markAsModule(__defProp(module2 != null ? __create(__getProtoOf(module2)) : {}, "default", !isNodeMode && module2 && module2.__esModule ? { get: () => module2.default, enumerable: true } : { value: module2, enumerable: true })), module2);
-};
-var __toCommonJS = /* @__PURE__ */ ((cache) => {
-  return (module2, temp) => {
-    return cache && cache.get(module2) || (temp = __reExport(__markAsModule({}), module2, 1), cache && cache.set(module2, temp), temp);
-  };
-})(typeof WeakMap !== "undefined" ? /* @__PURE__ */ new WeakMap() : 0);
-var TreeViewContext_exports = {};
-__export(TreeViewContext_exports, {
-  default: () => TreeViewContext_default,
-  defaultProps: () => defaultProps,
-  defaultRelativeMouseCoord: () => defaultRelativeMouseCoord
-});
-var React = __toESM(require("react"));
-var import_react = require("react");
-function noop(..._args) {
-}
-const defaultProps = {
-  plugins: [],
-  selection: {},
-  instanceRef: (0, import_react.createRef)(),
-  isItemDisabled: () => false,
-  disableIcons: false,
-  fluid: false,
-  isMultiSelect: false,
-  isSingleSelect: false,
-  getIsDropValid: () => true,
-  restrictDragAndDrop: false,
-  showChildrenAmount: false,
-  sortable: false,
-  isLoading: false,
-  highlightOnlyQuery: false,
-  onItemClick: noop,
-  onItemFocus: noop,
-  onVisibleItemsChange: noop,
-  onOrderChange: noop,
-  onSelectionChange: noop,
-  onExpandChange: noop,
-  onInstanceRefInitialized: noop,
-  rowSize: "normal",
-  labelOverflow: "wrap",
-  noItemsPlaceholder: "No items found",
-  nameKey: "name",
-  width: "100%",
-  height: "100%",
-  groupIcon: null,
-  itemIcon: null,
-  searchQuery: ""
-};
-const defaultRelativeMouseCoord = {
-  isBefore: false,
-  isAfter: false,
-  isValid: true,
-  item: null,
-  x: null,
-  y: null,
-  relativeElementDOMRect: null,
-  relativeElementIndex: null
-};
-const defaultContext = {
-  props: defaultProps,
-  visibleItems: [],
-  flattenedItems: [],
-  withRadioChecks: false,
-  withCheckboxChecks: false,
-  withDragAndDrop: false,
-  triggerTreeRerender: noop,
-  tree: void 0,
-  treeRoot: void 0,
-  virtualListHelpers: {
-    virtualItems: [],
-    totalSize: 0,
-    scrollToOffset: noop,
-    scrollToIndex: noop
-  },
-  virtualListRef: void 0,
-  uniqueTreeViewUUID: "",
-  selectedItem: null,
-  setSelectedItem: noop,
-  focusedItem: null,
-  setFocusedItem: noop,
-  selectedCheckboxes: {},
-  setSelectedCheckboxes: noop,
-  expandedGroups: {},
-  setExpandedGroups: noop,
-  latestToggledItem: null,
-  setLatestToggledItem: noop,
-  hoverItem: null,
-  setHoverItem: noop,
-  handleExpandGroup: noop,
-  updateUserExpandedState: noop
-};
-const TreeViewContext = (0, import_react.createContext)(defaultContext);
-var TreeViewContext_default = TreeViewContext;
-module.exports = __toCommonJS(TreeViewContext_exports);
-//# sourceMappingURL=TreeViewContext.js.map

package/dist/cjs/TreeViewContext.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../src/TreeViewContext.tsx", "../../../../scripts/build/transpile/react-shim.js"],
-  "sourcesContent": ["/* eslint-disable no-unused-vars */\nimport { createContext, createRef } from 'react';\nimport type { DSTreeviewT } from './react-desc-prop-types';\nimport type { DSTreeviewInternalsT } from './sharedTypes';\n\n// eslint-disable-next-line @typescript-eslint/no-unused-vars\nfunction noop<T extends unknown[]>(..._args: T): void {}\n\nexport const defaultProps = {\n  plugins: [],\n  selection: {},\n  instanceRef: createRef(),\n  isItemDisabled: () => false,\n  disableIcons: false,\n  fluid: false,\n  isMultiSelect: false,\n  isSingleSelect: false,\n  getIsDropValid: () => true,\n  restrictDragAndDrop: false,\n  showChildrenAmount: false,\n  sortable: false,\n  isLoading: false,\n  highlightOnlyQuery: false,\n  onItemClick: noop,\n  onItemFocus: noop,\n  onVisibleItemsChange: noop,\n  onOrderChange: noop,\n  onSelectionChange: noop,\n  onExpandChange: noop,\n  onInstanceRefInitialized: noop,\n  rowSize: 'normal',\n  labelOverflow: 'wrap',\n  noItemsPlaceholder: 'No items found',\n  nameKey: 'name',\n  width: '100%',\n  height: '100%',\n  groupIcon: null,\n  itemIcon: null,\n  searchQuery: '',\n  // workaround on the typings over the fact that\n  // when we instantiate the context we can't have all the props\n  // we only have a part of them but the final typings will include missing props\n  // this is safe to do because\n  // we will \"mergeWithDefaults\" + \"validatePropTypes\" when we do instantiate the context\n} as unknown as DSTreeviewT.Props;\n\nexport const defaultRelativeMouseCoord = {\n  isBefore: false,\n  isAfter: false,\n  isValid: true,\n  item: null,\n  x: null,\n  y: null,\n  relativeElementDOMRect: null,\n  relativeElementIndex: null,\n};\n\nconst defaultContext: DSTreeviewInternalsT.CTX = {\n  props: defaultProps,\n  visibleItems: [],\n  flattenedItems: [],\n  withRadioChecks: false,\n  withCheckboxChecks: false,\n  withDragAndDrop: false,\n  triggerTreeRerender: noop,\n  tree: undefined,\n  treeRoot: undefined,\n  virtualListHelpers: {\n    virtualItems: [],\n    totalSize: 0,\n    scrollToOffset: noop,\n    scrollToIndex: noop,\n  },\n  virtualListRef: undefined,\n  uniqueTreeViewUUID: '',\n  selectedItem: null,\n  setSelectedItem: noop,\n  focusedItem: null,\n  setFocusedItem: noop,\n  selectedCheckboxes: {},\n  setSelectedCheckboxes: noop,\n  expandedGroups: {},\n  setExpandedGroups: noop,\n  latestToggledItem: null,\n  setLatestToggledItem: noop,\n  hoverItem: null,\n  setHoverItem: noop,\n  handleExpandGroup: noop,\n  updateUserExpandedState: noop,\n};\n\n/** Context for cross component communication */\nconst TreeViewContext = createContext(defaultContext);\n\nexport default TreeViewContext;\n", "import * as React from 'react';\nexport { React };\n"],
-  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;ACAA,YAAuB;ADCvB,mBAAyC;AAKzC,iBAAsC,OAAgB;AAAA;AAE/C,MAAM,eAAe;AAAA,EAC1B,SAAS;AAAA,EACT,WAAW;AAAA,EACX,aAAa;AAAA,EACb,gBAAgB,MAAM;AAAA,EACtB,cAAc;AAAA,EACd,OAAO;AAAA,EACP,eAAe;AAAA,EACf,gBAAgB;AAAA,EAChB,gBAAgB,MAAM;AAAA,EACtB,qBAAqB;AAAA,EACrB,oBAAoB;AAAA,EACpB,UAAU;AAAA,EACV,WAAW;AAAA,EACX,oBAAoB;AAAA,EACpB,aAAa;AAAA,EACb,aAAa;AAAA,EACb,sBAAsB;AAAA,EACtB,eAAe;AAAA,EACf,mBAAmB;AAAA,EACnB,gBAAgB;AAAA,EAChB,0BAA0B;AAAA,EAC1B,SAAS;AAAA,EACT,eAAe;AAAA,EACf,oBAAoB;AAAA,EACpB,SAAS;AAAA,EACT,OAAO;AAAA,EACP,QAAQ;AAAA,EACR,WAAW;AAAA,EACX,UAAU;AAAA,EACV,aAAa;AAAA;AAQR,MAAM,4BAA4B;AAAA,EACvC,UAAU;AAAA,EACV,SAAS;AAAA,EACT,SAAS;AAAA,EACT,MAAM;AAAA,EACN,GAAG;AAAA,EACH,GAAG;AAAA,EACH,wBAAwB;AAAA,EACxB,sBAAsB;AAAA;AAGxB,MAAM,iBAA2C;AAAA,EAC/C,OAAO;AAAA,EACP,cAAc;AAAA,EACd,gBAAgB;AAAA,EAChB,iBAAiB;AAAA,EACjB,oBAAoB;AAAA,EACpB,iBAAiB;AAAA,EACjB,qBAAqB;AAAA,EACrB,MAAM;AAAA,EACN,UAAU;AAAA,EACV,oBAAoB;AAAA,IAClB,cAAc;AAAA,IACd,WAAW;AAAA,IACX,gBAAgB;AAAA,IAChB,eAAe;AAAA;AAAA,EAEjB,gBAAgB;AAAA,EAChB,oBAAoB;AAAA,EACpB,cAAc;AAAA,EACd,iBAAiB;AAAA,EACjB,aAAa;AAAA,EACb,gBAAgB;AAAA,EAChB,oBAAoB;AAAA,EACpB,uBAAuB;AAAA,EACvB,gBAAgB;AAAA,EAChB,mBAAmB;AAAA,EACnB,mBAAmB;AAAA,EACnB,sBAAsB;AAAA,EACtB,WAAW;AAAA,EACX,cAAc;AAAA,EACd,mBAAmB;AAAA,EACnB,yBAAyB;AAAA;AAI3B,MAAM,kBAAkB,gCAAc;AAEtC,IAAO,0BAAQ;",
-  "names": []
-}

package/dist/cjs/config/cssClassesConstants.js

@@ -1,41 +0,0 @@
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __markAsModule = (target) => __defProp(target, "__esModule", { value: true });
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __reExport = (target, module2, copyDefault, desc) => {
-  if (module2 && typeof module2 === "object" || typeof module2 === "function") {
-    for (let key of __getOwnPropNames(module2))
-      if (!__hasOwnProp.call(target, key) && (copyDefault || key !== "default"))
-        __defProp(target, key, { get: () => module2[key], enumerable: !(desc = __getOwnPropDesc(module2, key)) || desc.enumerable });
-  }
-  return target;
-};
-var __toESM = (module2, isNodeMode) => {
-  return __reExport(__markAsModule(__defProp(module2 != null ? __create(__getProtoOf(module2)) : {}, "default", !isNodeMode && module2 && module2.__esModule ? { get: () => module2.default, enumerable: true } : { value: module2, enumerable: true })), module2);
-};
-var __toCommonJS = /* @__PURE__ */ ((cache) => {
-  return (module2, temp) => {
-    return cache && cache.get(module2) || (temp = __reExport(__markAsModule({}), module2, 1), cache && cache.set(module2, temp), temp);
-  };
-})(typeof WeakMap !== "undefined" ? /* @__PURE__ */ new WeakMap() : 0);
-var cssClassesConstants_exports = {};
-__export(cssClassesConstants_exports, {
-  DSTreeViewPrefix: () => DSTreeViewPrefix,
-  treeItemBlockName: () => treeItemBlockName,
-  treeListBlockName: () => treeListBlockName,
-  treeListNoItemsBn: () => treeListNoItemsBn
-});
-var React = __toESM(require("react"));
-const DSTreeViewPrefix = "em-ds";
-const treeItemBlockName = "tree-item";
-const treeListBlockName = "tree-list";
-const treeListNoItemsBn = `${treeListBlockName}-no-items`;
-module.exports = __toCommonJS(cssClassesConstants_exports);
-//# sourceMappingURL=cssClassesConstants.js.map

package/dist/cjs/config/cssClassesConstants.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../../src/config/cssClassesConstants.tsx", "../../../../../scripts/build/transpile/react-shim.js"],
-  "sourcesContent": ["export const DSTreeViewPrefix = 'em-ds';\nexport const treeItemBlockName = 'tree-item';\nexport const treeListBlockName = 'tree-list';\nexport const treeListNoItemsBn = `${treeListBlockName}-no-items`;\n", "import * as React from 'react';\nexport { React };\n"],
-  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;ACAA,YAAuB;ADAhB,MAAM,mBAAmB;AACzB,MAAM,oBAAoB;AAC1B,MAAM,oBAAoB;AAC1B,MAAM,oBAAoB,GAAG;",
-  "names": []
-}