@elliemae/ds-treeview 2.3.0-alpha.2 → 2.3.0-alpha.7

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

@@ -1,196 +0,0 @@
-/// <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>;
-        nodePath: TreeModel.Node<Item>[];
-    }
-    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;
-        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: Item[], oldData: Item[], draggedItem: Item) => 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;
-    };
-    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

@@ -1,16 +0,0 @@
-/// <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

@@ -1,54 +0,0 @@
-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[];
-        withRadioChecks: boolean;
-        withCheckboxChecks: boolean;
-        withDragAndDrop: boolean;
-        relativeMouseCord: MouseCoord;
-        setRelativeMouseCord: StateSetter<MouseCoord>;
-        triggerTreeRerender: () => void;
-        tree?: TreeModel;
-        treeRoot?: TreeModel.Node<DSTreeviewT.Item>;
-        virtualListHelpers: ReturnType<typeof useVirtual>;
-        virtualListRef?: React.MutableRefObject<HTMLUListElement | undefined>;
-        isDragging: boolean;
-        setIsDragging: StateSetter<boolean>;
-        isKeyboardDragging: boolean;
-        setIsKeyboardDragging: StateSetter<boolean>;
-        draggedItem: DSTreeviewT.Item | null;
-        setDraggedItem: StateSetter<DSTreeviewT.Item | null>;
-        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

@@ -1,2 +0,0 @@
-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/dnd-helpers.d.ts

@@ -1,39 +0,0 @@
-import type { DSTreeviewT } from '../react-desc-prop-types';
-import type { DSTreeviewInternalsT } from '../sharedTypes';
-interface MetaInfoT {
-    isBefore: boolean;
-    isAfter: boolean;
-    draggedItem: DSTreeviewT.Item;
-    overItem: DSTreeviewT.Item;
-}
-interface KinshipT {
-    newParentNode: DSTreeviewT.Item['node'];
-    newNestedIndex: number;
-}
-export declare const keyCodes: {
-    lift: number[];
-    drop: number[];
-    cancel: number[];
-    up: number[];
-    down: number[];
-};
-export declare const sameParentAsHoverItemDrop: ({ isBefore, isAfter, draggedItem, overItem, movementDirection, }: MetaInfoT & {
-    movementDirection: DSTreeviewInternalsT.DnDMovementDirectionT;
-}) => {
-    newNestedIndex: number;
-    newParentNode: import("tree-model/types").Node<DSTreeviewT.Item>;
-};
-export declare const inferHoverItemKinshipDrop: ({ isBefore, isAfter, draggedItem, overItem, movementDirection, }: MetaInfoT & {
-    movementDirection: DSTreeviewInternalsT.DnDMovementDirectionT;
-}) => {
-    newNestedIndex: number;
-    newParentNode: import("tree-model/types").Node<DSTreeviewT.Item>;
-};
-export declare const isDropValid: ({ isBefore, isAfter, draggedItem, overItem, restrictDragAndDrop, }: MetaInfoT & {
-    restrictDragAndDrop: boolean;
-}) => boolean;
-export declare const inferKeyboardKinshipDrop: ({ items, newIndex, }: {
-    items: DSTreeviewT.Item[];
-    newIndex: number;
-}) => Partial<KinshipT>;
-export {};

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

@@ -1,14 +0,0 @@
-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

@@ -1,5 +0,0 @@
-import type { DSTreeviewT } from '../react-desc-prop-types';
-import type { DSTreeviewInternalsT } from '../sharedTypes';
-export declare const useOnItemKeyDown: (item: DSTreeviewT.Item) => (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

@@ -1,6 +0,0 @@
-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

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

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

@@ -1,7 +0,0 @@
-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

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

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

@@ -1,25 +0,0 @@
-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>;
-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 {};

package/types/utils/useDnDHelpers.d.ts

@@ -1,26 +0,0 @@
-/// <reference types="node" />
-/// <reference types="mocha" />
-/// <reference types="webpack-env" />
-/// <reference types="styled-components" />
-import React from 'react';
-import type { DSTreeviewT } from '../react-desc-prop-types';
-import type { DSTreeviewInternalsT } from '../sharedTypes';
-export declare const useDnDHelpers: () => {
-    updateBeforeSortStart: (beforeStartArgs: {
-        index: number;
-        isKeySorting: boolean;
-    }) => Promise<unknown>;
-    onSortStart: () => void;
-    onSortEnd: ({ oldIndex, newIndex, isKeySorting }: {
-        oldIndex: number;
-        newIndex: number;
-        isKeySorting: boolean;
-    }) => void;
-    onMouseDragOverItem: ({ event, item, itemIndex, setIsDraggingOverThis, openFolderOnHoverTimeout, }: {
-        event: React.MouseEvent<HTMLLIElement>;
-        item: DSTreeviewT.Item;
-        itemIndex: number;
-        setIsDraggingOverThis: DSTreeviewInternalsT.StateSetter<boolean>;
-        openFolderOnHoverTimeout: React.MutableRefObject<NodeJS.Timeout | null>;
-    }) => void;
-};

package/types/utils/useInstanceRefActions.d.ts

@@ -1,3 +0,0 @@
-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

@@ -1,13 +0,0 @@
-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[];
-    tree: TreeModel;
-    treeRoot: TreeModel.Node<DSTreeviewT.Item>;
-    rerenderItems: {};
-    triggerTreeRerender: () => void;
-    updateUserExpandedState: () => void;
-};