@central-design-system/components 3.0.0-beta.22 → 3.0.0-beta.23

package/dist/components/CdsTree/components/VirtualList/VirtualList.d.ts

@@ -0,0 +1,84 @@
+import { Component, PropType } from 'vue';
+declare type Key = string | number;
+export declare type ScrollAlign = 'top' | 'bottom' | 'auto';
+export declare type ScrollConfig = {
+    index: number;
+    align?: ScrollAlign;
+    offset?: number;
+} | {
+    key: Key;
+    align?: ScrollAlign;
+    offset?: number;
+};
+export declare type ScrollTo = (arg: number | ScrollConfig) => void;
+declare const _default: import("vue").DefineComponent<{
+    prefixCls: PropType<string>;
+    data: PropType<any[]>;
+    height: {
+        type: PropType<number>;
+        default: number;
+    };
+    itemHeight: {
+        type: PropType<number>;
+        default: number;
+    };
+    fullHeight: {
+        type: PropType<boolean>;
+        default: undefined;
+    };
+    itemKey: {
+        type: PropType<Key | ((item: Record<string, any>) => Key)>;
+        required: true;
+    };
+    component: {
+        type: PropType<string | Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>>;
+    };
+    /** Set `false` will always use real scroll instead of virtual one */
+    virtual: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    children: FunctionConstructor;
+    onScroll: FunctionConstructor;
+    onMousedown: FunctionConstructor;
+    onMouseEnter: FunctionConstructor;
+    onVisibleChange: PropType<(visibleList: any[], fullList: any[]) => void>;
+}, void, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    prefixCls: PropType<string>;
+    data: PropType<any[]>;
+    height: {
+        type: PropType<number>;
+        default: number;
+    };
+    itemHeight: {
+        type: PropType<number>;
+        default: number;
+    };
+    fullHeight: {
+        type: PropType<boolean>;
+        default: undefined;
+    };
+    itemKey: {
+        type: PropType<Key | ((item: Record<string, any>) => Key)>;
+        required: true;
+    };
+    component: {
+        type: PropType<string | Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>>;
+    };
+    /** Set `false` will always use real scroll instead of virtual one */
+    virtual: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    children: FunctionConstructor;
+    onScroll: FunctionConstructor;
+    onMousedown: FunctionConstructor;
+    onMouseEnter: FunctionConstructor;
+    onVisibleChange: PropType<(visibleList: any[], fullList: any[]) => void>;
+}>>, {
+    height: number;
+    virtual: boolean;
+    itemHeight: number;
+    fullHeight: boolean;
+}>;
+export default _default;

package/dist/components/CdsTree/components/VirtualList/features/index.d.ts

@@ -0,0 +1,5 @@
+export * from './useHeights';
+export * from './useOriginScroll';
+export * from './useFrameWheel';
+export * from './useMobileTouchMove';
+export * from './useScrollTo';

package/dist/components/CdsTree/components/VirtualList/features/useFrameWheel.d.ts

@@ -0,0 +1,10 @@
+import { Ref } from 'vue';
+interface FireFoxDOMMouseScrollEvent {
+    detail: number;
+    preventDefault: Function;
+}
+export declare function useFrameWheel(inVirtual: Ref<boolean>, isScrollAtTop: Ref<boolean>, isScrollAtBottom: Ref<boolean>, onWheelDelta: (offset: number) => void): {
+    onWheel: (e: WheelEvent) => void;
+    onFireFoxScroll: (e: FireFoxDOMMouseScrollEvent) => void;
+};
+export {};

package/dist/components/CdsTree/components/VirtualList/features/useHeights.d.ts

@@ -0,0 +1,9 @@
+import { Ref, ShallowRef } from 'vue';
+import { GetKey } from '../interface';
+export declare type CacheMap = Map<any, number>;
+export declare function useHeights<T>(mergedData: ShallowRef<any[]>, getKey: GetKey<T>, onItemAdd?: ((item: T) => void) | null, onItemRemove?: ((item: T) => void) | null): {
+    setInstance: (item: T, instance: HTMLElement) => void;
+    collectHeight: () => void;
+    heights: CacheMap;
+    updatedMark: Ref<Symbol>;
+};

package/dist/components/CdsTree/components/VirtualList/features/useMobileTouchMove.d.ts

@@ -0,0 +1,2 @@
+import { Ref } from 'vue';
+export declare function useMobileTouchMove(inVirtual: Ref<boolean>, listRef: Ref<HTMLDivElement | undefined>, callback: (offsetY: number, smoothOffset?: boolean) => boolean): void;

package/dist/components/CdsTree/components/VirtualList/features/useOriginScroll.d.ts

@@ -0,0 +1,2 @@
+import { Ref } from 'vue';
+export declare function useOriginScroll(isScrollAtTop: Ref<boolean>, isScrollAtBottom: Ref<boolean>): (deltaY: number, smoothOffset?: boolean) => boolean;

package/dist/components/CdsTree/components/VirtualList/features/useScrollTo.d.ts

@@ -0,0 +1,4 @@
+import { Ref, ShallowRef } from 'vue';
+import { GetKey } from '../interface';
+import { CacheMap } from './useHeights';
+export declare function useScrollTo(containerRef: Ref<Element | undefined>, mergedData: ShallowRef<any[]>, heights: CacheMap, props: any, getKey: GetKey, collectHeight: () => void, syncScrollTop: (newTop: number) => void, triggerFlash: () => void): (arg?: any) => void;

package/dist/components/CdsTree/components/VirtualList/index.d.ts

@@ -0,0 +1,2 @@
+export * from './VirtualList';
+export { default as VirtualList } from './VirtualList';

package/dist/components/CdsTree/components/VirtualList/interface.d.ts

@@ -0,0 +1,10 @@
+import { CSSProperties, VNodeTypes } from 'vue';
+declare type Key = string | number;
+export declare type RenderFunc<T> = (item: T, index: number, props: {
+    style?: CSSProperties;
+}) => VNodeTypes;
+export interface SharedConfig<T> {
+    getKey: (item: T) => Key;
+}
+export declare type GetKey<T = object> = (item: T) => Key;
+export {};

package/dist/components/CdsTree/composable/events.d.ts

@@ -0,0 +1,133 @@
+import { PropType } from 'vue';
+import { NTree } from '../../../components';
+export declare const makeTreeEventsProps: <Defaults extends {
+    onFocus?: unknown;
+    onBlur?: unknown;
+    onKeydown?: unknown;
+    onContextmenu?: unknown;
+    onClick?: unknown;
+    onDblclick?: unknown;
+    onScroll?: unknown;
+    onExpand?: unknown;
+    onCheck?: unknown;
+    onSelect?: unknown;
+    onLoad?: unknown;
+    onMouseenter?: unknown;
+    onMouseleave?: unknown;
+    onRightClick?: unknown;
+    onDragstart?: unknown;
+    onDragenter?: unknown;
+    onDragover?: unknown;
+    onDragleave?: unknown;
+    onDragend?: unknown;
+    onDrop?: unknown;
+    onActiveChange?: unknown;
+} = {}>(defaults?: Defaults | undefined) => import('../../../utils').AppendDefault<{
+    onFocus: {
+        type: PropType<(event: FocusEvent) => void>;
+        default: undefined;
+    };
+    onBlur: {
+        type: PropType<(event: FocusEvent) => void>;
+        default: undefined;
+    };
+    onKeydown: {
+        type: PropType<NTree.TEventHandler>;
+        default: undefined;
+    };
+    onContextmenu: {
+        type: PropType<NTree.TEventHandler>;
+        default: undefined;
+    };
+    onClick: {
+        type: PropType<NTree.TNodeMouseEventHandler>;
+        default: undefined;
+    };
+    onDblclick: {
+        type: PropType<NTree.TNodeMouseEventHandler>;
+        default: undefined;
+    };
+    onScroll: {
+        type: PropType<NTree.TEventHandler>;
+        default: undefined;
+    };
+    onExpand: {
+        type: PropType<(expandedKeys: NTree.TKey[], info: {
+            node: NTree.IEventDataNode;
+            expanded: boolean;
+            nativeEvent: MouseEvent;
+        }) => void>;
+        default: undefined;
+    };
+    onCheck: {
+        type: PropType<(checked: NTree.TKey[] | {
+            checked: NTree.TKey[];
+            halfChecked: NTree.TKey[];
+        }, info: NTree.ICheckInfo) => void>;
+        default: undefined;
+    };
+    onSelect: {
+        type: PropType<(selectedKeys: NTree.TKey[], info: {
+            event: 'select';
+            selected: boolean;
+            node: NTree.IEventDataNode;
+            selectedNodes: NTree.IDataNode[];
+            nativeEvent: MouseEvent;
+        }) => void>;
+        default: undefined;
+    };
+    onLoad: {
+        type: PropType<(loadedKeys: NTree.TKey[], info: {
+            event: 'load';
+            node: NTree.IEventDataNode;
+        }) => void>;
+        default: undefined;
+    };
+    onMouseenter: {
+        type: PropType<(info: NTree.TNodeMouseEventParams) => void>;
+        default: undefined;
+    };
+    onMouseleave: {
+        type: PropType<(info: NTree.TNodeMouseEventParams) => void>;
+        default: undefined;
+    };
+    onRightClick: {
+        type: PropType<(info: NTree.TNodeMouseEventParams) => void>;
+        default: undefined;
+    };
+    onDragstart: {
+        type: PropType<(info: NTree.TNodeDragEventParams) => void>;
+        default: undefined;
+    };
+    onDragenter: {
+        type: PropType<(info: NTree.TNodeDragEventParams & {
+            expandedKeys: NTree.TKey[];
+        }) => void>;
+        default: undefined;
+    };
+    onDragover: {
+        type: PropType<(info: NTree.TNodeDragEventParams) => void>;
+        default: undefined;
+    };
+    onDragleave: {
+        type: PropType<(info: NTree.TNodeDragEventParams) => void>;
+        default: undefined;
+    };
+    onDragend: {
+        type: PropType<(info: NTree.TNodeDragEventParams) => void>;
+        default: undefined;
+    };
+    onDrop: {
+        type: PropType<(info: NTree.TNodeDragEventParams & {
+            dragNode: NTree.IEventDataNode | null;
+            dragNodesKeys: NTree.TKey[];
+            dropPosition: number;
+            dropToGap: boolean;
+        }) => void>;
+        default: undefined;
+    };
+    onActiveChange: {
+        type: PropType<(key: NTree.TKey | null) => void>;
+        default: undefined;
+    };
+}, Defaults>;

package/dist/components/CdsTree/composable/index.d.ts

@@ -1 +1,3 @@
 export * from './tree';
+export * from './treeNode';
+export * from './events';

package/dist/components/CdsTree/composable/tree.d.ts

@@ -1,5 +1,278 @@
+import { ExtractPropTypes, PropType } from 'vue';
+import { SwitcherIconProps } from '../components/SwitcherIcon';
+import type { TCdsIconsName } from '@central-design-system/icons';
 import type { NTree } from '../interface';
 import type { ShallowRef } from 'vue';
+export declare const makeTreeProps: <Defaults extends {
+    treeData?: unknown;
+    selectable?: unknown;
+    multiple?: unknown;
+    checkable?: unknown;
+    draggable?: unknown;
+    checkedKeys?: unknown;
+    expandedKeys?: unknown;
+    selectedKeys?: unknown;
+    autoExpandParent?: unknown;
+    defaultExpandedKeys?: unknown;
+    defaultExpandParent?: unknown;
+    defaultExpandAll?: unknown;
+    defaultSelectedKeys?: unknown;
+    expandAction?: unknown;
+    checkStrictly?: unknown;
+    allowDrop?: unknown;
+    blockNode?: unknown;
+    fieldNames?: unknown;
+    showLine?: unknown;
+    showIcon?: unknown;
+    filterTreeNode?: unknown;
+    loadData?: unknown;
+    loadedKeys?: unknown;
+    icon?: unknown;
+    switcherIcon?: unknown;
+    openAnimation?: unknown;
+    virtual?: unknown;
+    height?: unknown;
+} = {}>(defaults?: Defaults | undefined) => import('../../../utils').AppendDefault<{
+    /**
+     * Данные дерева
+     */
+    treeData: {
+        type: PropType<NTree.IDataNode[]>;
+        default: undefined;
+    };
+    /**
+     * Выбираемые узлы дерева
+     */
+    selectable: {
+        type: PropType<boolean>;
+        default: boolean;
+    };
+    /**
+     * Множественный выбор узлов дерева
+     */
+    multiple: {
+        type: PropType<boolean>;
+        default: boolean;
+    };
+    /**
+     * Добавляет checkbox перед узлами дерева
+     */
+    checkable: {
+        type: PropType<boolean>;
+        default: boolean;
+    };
+    /**
+     * Разрешает перетаскивание узлов дерева
+     */
+    draggable: {
+        type: PropType<boolean | NTree.TDraggableConfig>;
+        default: boolean;
+    };
+    /**
+     * (v-model) Определяет ключи выбранных узлов дерева.
+     * Когда указан ключ узла дерева, который также является родительским узлом дерева, все дочерние узлы дерева будут checked;
+     * и наоборот, когда указан ключ узла дерева, который является дочерним узлом дерева, его родительский узел дерева также будет checked.
+     * Когда checkable и checkStrictly равны true, объект имеет свойство checked и halfChecked. Независимо от того, проверяется ли дочерний или родительский узел дерева, они не будут влиять друг на друга.
+     */
+    checkedKeys: {
+        type: PropType<NTree.TKey[] | {
+            checked: NTree.TKey[];
+            halfChecked: NTree.TKey[];
+        }>;
+        default: undefined;
+    };
+    /**
+     * (v-model) Определяет ключи раскрытых узлов дерева.
+     */
+    expandedKeys: {
+        type: PropType<NTree.TKey[]>;
+        default: undefined;
+    };
+    /**
+     * (v-model) Определяет ключи выбранных узлов дерева.
+     */
+    selectedKeys: {
+        type: PropType<NTree.TKey[]>;
+        default: undefined;
+    };
+    /**
+     * Автоматически раскрывать родительский узел
+     */
+    autoExpandParent: {
+        type: PropType<boolean>;
+        default: boolean;
+    };
+    /**
+     * Раскрывать все узлы по умолчанию
+     */
+    defaultExpandedKeys: {
+        type: PropType<NTree.TKey[]>;
+        default: () => never[];
+    };
+    /**
+     * Раскрывать родительские узлы по умолчанию
+     */
+    defaultExpandParent: {
+        type: PropType<boolean>;
+        default: boolean;
+    };
+    /**
+     * Раскрывать все узлы по умолчанию
+     */
+    defaultExpandAll: {
+        type: PropType<boolean>;
+        default: boolean;
+    };
+    /**
+     * Выбранные узлы дерева по умолчанию
+     */
+    defaultSelectedKeys: {
+        type: PropType<NTree.TKey[]>;
+        default: undefined;
+    };
+    /**
+     * Действие, которое будет раскрывать/скрывать узлы дерева
+     */
+    expandAction: {
+        type: PropType<NTree.TExpandAction>;
+        default: undefined;
+    };
+    /**
+     * Выбирает только родительский узел.
+     */
+    checkStrictly: {
+        type: PropType<boolean>;
+        default: boolean;
+    };
+    /**
+     * Разрешает сброс на узле
+     */
+    allowDrop: {
+        type: PropType<NTree.TAllowDrop<NTree.IDataNode>>;
+        default: () => true;
+    };
+    /**
+     * Узел дерева заполняет все оставшееся горизонтальное пространство
+     */
+    blockNode: {
+        type: PropType<boolean>;
+        default: boolean;
+    };
+    /**
+     * Заменяет поля title, key и children в treeNode на соответствующие поля в treeData
+     */
+    fieldNames: {
+        type: PropType<NTree.IFieldNames>;
+        default: undefined;
+    };
+    /**
+     * Показывает линии между узлами дерева
+     */
+    showLine: {
+        type: PropType<boolean | {
+            showLeafIcon: boolean | TCdsIconsName;
+        }>;
+        default: undefined;
+    };
+    /**
+     * Показывает иконку узла дерева
+     */
+    showIcon: {
+        type: PropType<boolean>;
+        default: boolean;
+    };
+    /**
+     * Функция для фильтрации (выделения) узлов дерева. Когда функция возвращает true, узел дерева будет выделен.
+     */
+    filterTreeNode: {
+        type: PropType<(treeNode: NTree.IEventDataNode) => boolean>;
+        default: undefined;
+    };
+    /**
+     * Загружает данные для узла дерева асинхронно
+     */
+    loadData: {
+        type: PropType<(treeNode: NTree.IEventDataNode) => Promise<any>>;
+        default: undefined;
+    };
+    /**
+     * Загруженные узлы дерева. Необходимо для работы с loadData
+     */
+    loadedKeys: {
+        type: PropType<NTree.TKey[]>;
+        default: () => never[];
+    };
+    /**
+     * Иконка узла дерева (также доступно через slot#icon)
+     */
+    icon: {
+        type: PropType<(nodeProps: NTree.ITreeNodeAttribute) => any>;
+        default: undefined;
+    };
+    /**
+     * Иконка открытия/закрытия узла дерева (также доступно через slot#switcherIcon)
+     */
+    switcherIcon: {
+        type: PropType<(nodeProps: SwitcherIconProps) => any>;
+        default: undefined;
+    };
+    /**
+     * Функция анимации открытия/закрытия узла дерева
+     */
+    openAnimation: {
+        type: FunctionConstructor;
+        default: undefined;
+    };
+    /**
+     * Включает виртуальную прокрутку списка в дереве, по-умолчанию включено
+     */
+    virtual: {
+        type: PropType<boolean>;
+        default: boolean;
+    };
+    /**
+     * Высота виртуального списка для прокрутки
+     */
+    height: {
+        type: PropType<number>;
+        default: undefined;
+    };
+}, Defaults>;
+export interface ITreeProps extends Partial<ExtractPropTypes<ReturnType<typeof makeTreeProps>>> {
+    onLoad?: (loadedKeys: NTree.TKey[], info: {
+        event: 'load';
+        node: NTree.IEventDataNode;
+    }) => void;
+    onDragenter?: (info: NTree.TNodeDragEventParams & {
+        expandedKeys: NTree.TKey[];
+    }) => void;
+    onDragstart?: (info: NTree.TNodeDragEventParams) => void;
+    onDragover?: (info: NTree.TNodeDragEventParams) => void;
+    onDragleave?: (info: NTree.TNodeDragEventParams) => void;
+    onDragend?: (info: NTree.TNodeDragEventParams) => void;
+    onDrop?: (info: NTree.TNodeDragEventParams & {
+        dragNode: NTree.IEventDataNode | null;
+        dragNodesKeys: NTree.TKey[];
+        dropPosition: number;
+        dropToGap: boolean;
+    }) => void;
+    onCheck?: (checked: {
+        checked: NTree.TKey[];
+        halfChecked: NTree.TKey[];
+    } | NTree.TKey[], info: NTree.ICheckInfo) => void;
+    onExpand?: (expandedKeys: NTree.TKey[], info: {
+        node: NTree.IEventDataNode;
+        expanded: boolean;
+        nativeEvent: MouseEvent;
+    }) => void;
+    onSelect?: (selectedKeys: NTree.TKey[], info: {
+        event: 'select';
+        selected: boolean;
+        node: NTree.IEventDataNode;
+        selectedNodes: NTree.IDataNode[];
+        nativeEvent: MouseEvent;
+    }) => void;
+}
 export declare function useMaxLevel<TreeDataType extends NTree.IBasicDataNode = NTree.IDataNode>(keyEntities: ShallowRef<Record<NTree.TKey, NTree.IDataEntity>>): {
     maxLevel: import("vue").Ref<number>;
     levelEntities: ShallowRef<Map<number, Set<NTree.IDataEntity<TreeDataType>>> | undefined>;

package/dist/components/CdsTree/composable/treeNode.d.ts

@@ -0,0 +1,75 @@
+import { ExtractPropTypes, PropType } from 'vue';
+import { NTree } from '../../../components';
+export declare const makeTreeNodeProps: <Defaults extends {
+    eventKey?: unknown;
+    prefixCls?: unknown;
+    title?: unknown;
+    data?: unknown;
+    parent?: unknown;
+    isStart?: unknown;
+    isEnd?: unknown;
+    active?: unknown;
+    onMousemove?: unknown;
+    isLeaf?: unknown;
+    checkable?: unknown;
+    selectable?: unknown;
+    disabled?: unknown;
+    disableCheckbox?: unknown;
+    icon?: unknown;
+    switcherIcon?: unknown;
+    domRef?: unknown;
+} = {}>(defaults?: Defaults | undefined) => import('../../../utils').AppendDefault<{
+    eventKey: {
+        type: PropType<NTree.TKey>;
+        default: string;
+    };
+    prefixCls: StringConstructor;
+    title: (StringConstructor | FunctionConstructor)[];
+    data: {
+        type: PropType<NTree.IDataNode>;
+        default: NTree.IDataNode;
+    };
+    parent: {
+        type: PropType<NTree.IDataNode>;
+        default: NTree.IDataNode;
+    };
+    isStart: {
+        type: PropType<boolean[]>;
+    };
+    isEnd: {
+        type: PropType<boolean[]>;
+    };
+    active: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    onMousemove: {
+        type: PropType<NTree.TEventHandler>;
+    };
+    isLeaf: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    checkable: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    selectable: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    disabled: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    disableCheckbox: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    icon: FunctionConstructor[];
+    switcherIcon: FunctionConstructor[];
+    domRef: {
+        type: PropType<(arg: any) => void>;
+    };
+}, Defaults>;
+export declare type ITreeNodeProps = Partial<ExtractPropTypes<ReturnType<typeof makeTreeNodeProps>>>;

package/dist/components/CdsTree/index.d.ts

@@ -0,0 +1,5 @@
+export * from './interface';
+export type { ITreeProps } from './composable';
+export { default as CdsTree } from './CdsTree.vue';
+export { default as CdsTreeNode } from './CdsTreeNode.vue';
+export { default as CdsTreeDirectory } from './CdsTreeDirectory.vue';