@mantine-vue/core 1.1.1

package/lib/components/Transition/use-transition.d.ts

@@ -0,0 +1,18 @@
+import type { TransitionStatus } from './get-transition-styles';
+export interface UseTransitionInput {
+    mounted: () => boolean;
+    duration: () => number;
+    exitDuration: () => number;
+    timingFunction: () => string;
+    onEnter?: () => void;
+    onExit?: () => void;
+    onEntered?: () => void;
+    onExited?: () => void;
+    enterDelay?: () => number | undefined;
+    exitDelay?: () => number | undefined;
+}
+export declare function useTransition({ mounted, duration, exitDuration, timingFunction, onEnter, onExit, onEntered, onExited, enterDelay, exitDelay, }: UseTransitionInput): {
+    transitionDuration: import("vue").Ref<number, number>;
+    transitionStatus: import("vue").Ref<TransitionStatus, TransitionStatus>;
+    transitionTimingFunction: import("vue").ComputedRef<string>;
+};

package/lib/components/Tree/FlatTreeNode.d.ts

@@ -0,0 +1,145 @@
+import { type CSSProperties, type PropType, type VNodeChild } from 'vue';
+import type { FlatTreeLineState } from './flatten-tree-data/flatten-tree-data';
+import type { RenderNode, TreeNodeData } from './Tree';
+import type { TreeController } from './use-tree';
+export interface FlatTreeNodeProps {
+    node: TreeNodeData;
+    level: number;
+    parent: string | null;
+    hasChildren: boolean;
+    expanded: boolean;
+    tree: TreeController;
+    expandOnClick?: boolean;
+    selectOnClick?: boolean;
+    expandOnSpace?: boolean;
+    checkOnSpace?: boolean;
+    renderNode?: RenderNode;
+    style?: CSSProperties;
+    tabIndex?: number;
+    linesPath?: FlatTreeLineState[];
+}
+export declare const FlatTreeNode: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    node: {
+        type: PropType<TreeNodeData>;
+        required: true;
+    };
+    level: {
+        type: NumberConstructor;
+        required: true;
+    };
+    parent: {
+        type: PropType<string | null>;
+        default: null;
+    };
+    hasChildren: {
+        type: BooleanConstructor;
+        required: true;
+    };
+    expanded: {
+        type: BooleanConstructor;
+        required: true;
+    };
+    tree: {
+        type: PropType<TreeController>;
+        required: true;
+    };
+    expandOnClick: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    selectOnClick: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    expandOnSpace: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    checkOnSpace: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    renderNode: {
+        type: PropType<RenderNode>;
+        default: undefined;
+    };
+    style: {
+        type: PropType<CSSProperties>;
+        default: undefined;
+    };
+    tabIndex: {
+        type: NumberConstructor;
+        default: number;
+    };
+    linesPath: {
+        type: PropType<FlatTreeLineState[]>;
+        default: undefined;
+    };
+}>, () => VNodeChild, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    node: {
+        type: PropType<TreeNodeData>;
+        required: true;
+    };
+    level: {
+        type: NumberConstructor;
+        required: true;
+    };
+    parent: {
+        type: PropType<string | null>;
+        default: null;
+    };
+    hasChildren: {
+        type: BooleanConstructor;
+        required: true;
+    };
+    expanded: {
+        type: BooleanConstructor;
+        required: true;
+    };
+    tree: {
+        type: PropType<TreeController>;
+        required: true;
+    };
+    expandOnClick: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    selectOnClick: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    expandOnSpace: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    checkOnSpace: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    renderNode: {
+        type: PropType<RenderNode>;
+        default: undefined;
+    };
+    style: {
+        type: PropType<CSSProperties>;
+        default: undefined;
+    };
+    tabIndex: {
+        type: NumberConstructor;
+        default: number;
+    };
+    linesPath: {
+        type: PropType<FlatTreeLineState[]>;
+        default: undefined;
+    };
+}>> & Readonly<{}>, {
+    style: CSSProperties;
+    parent: string | null;
+    tabIndex: number;
+    expandOnClick: boolean;
+    renderNode: RenderNode;
+    selectOnClick: boolean;
+    expandOnSpace: boolean;
+    checkOnSpace: boolean;
+    linesPath: FlatTreeLineState[];
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

package/lib/components/Tree/Tree.d.ts

@@ -0,0 +1,237 @@
+import { type Component, type PropType, type VNodeChild } from 'vue';
+import { type BoxProps } from '../../core';
+import type { TreeDragDropPayload } from './move-tree-node/move-tree-node';
+import type { TreeAllowDrop, TreeDragHandleProps } from './use-tree-node-drag-drop';
+import { type TreeController } from './use-tree';
+export interface TreeNodeData {
+    label: VNodeChild | (() => VNodeChild);
+    value: string;
+    nodeProps?: Record<string, any>;
+    children?: TreeNodeData[];
+    hasChildren?: boolean;
+}
+export interface RenderTreeNodePayload {
+    level: number;
+    expanded: boolean;
+    hasChildren: boolean;
+    selected: boolean;
+    isRoot: boolean;
+    isLoading: boolean;
+    loadError: Error | null;
+    node: TreeNodeData;
+    tree: TreeController;
+    elementProps: Record<string, any>;
+    dragHandleProps: TreeDragHandleProps | undefined;
+}
+export type RenderNode = (payload: RenderTreeNodePayload) => VNodeChild;
+export type TreeStylesNames = 'root' | 'node' | 'subtree' | 'label';
+export type TreeCssVariables = {
+    root: '--level-offset';
+};
+export interface TreeDragState {
+    draggedValue: string | null;
+    currentDropTarget: HTMLElement | null;
+}
+export interface TreeProps extends BoxProps {
+    data: TreeNodeData[];
+    levelOffset?: string | number;
+    expandOnClick?: boolean;
+    expandOnSpace?: boolean;
+    checkOnSpace?: boolean;
+    selectOnClick?: boolean;
+    tree?: TreeController;
+    renderNode?: RenderNode;
+    clearSelectionOnOutsideClick?: boolean;
+    allowRangeSelection?: boolean;
+    keepMounted?: boolean;
+    onDragDrop?: (payload: TreeDragDropPayload) => void;
+    allowDrop?: TreeAllowDrop;
+    withDragHandle?: boolean;
+    withLines?: boolean;
+}
+export type TreeFactory = any;
+export declare const Tree: import("../..").WithBoxProps<import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    component: {
+        type: PropType<string | Component>;
+        default: string;
+    };
+    data: {
+        type: PropType<TreeNodeData[]>;
+        required: true;
+    };
+    levelOffset: {
+        type: PropType<string | number>;
+        default: string;
+    };
+    expandOnClick: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    expandOnSpace: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    checkOnSpace: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    selectOnClick: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    tree: {
+        type: PropType<TreeController>;
+        default: undefined;
+    };
+    renderNode: {
+        type: PropType<RenderNode>;
+        default: undefined;
+    };
+    clearSelectionOnOutsideClick: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    allowRangeSelection: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    keepMounted: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    onDragDrop: {
+        type: PropType<(payload: TreeDragDropPayload) => void>;
+        default: undefined;
+    };
+    allowDrop: {
+        type: PropType<TreeAllowDrop>;
+        default: undefined;
+    };
+    withDragHandle: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    withLines: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    classNames: {
+        type: (ObjectConstructor | FunctionConstructor)[];
+        default: undefined;
+    };
+    styles: {
+        type: (ObjectConstructor | FunctionConstructor)[];
+        default: undefined;
+    };
+    vars: {
+        type: (ObjectConstructor | FunctionConstructor)[];
+        default: undefined;
+    };
+    unstyled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    component: {
+        type: PropType<string | Component>;
+        default: string;
+    };
+    data: {
+        type: PropType<TreeNodeData[]>;
+        required: true;
+    };
+    levelOffset: {
+        type: PropType<string | number>;
+        default: string;
+    };
+    expandOnClick: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    expandOnSpace: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    checkOnSpace: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    selectOnClick: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    tree: {
+        type: PropType<TreeController>;
+        default: undefined;
+    };
+    renderNode: {
+        type: PropType<RenderNode>;
+        default: undefined;
+    };
+    clearSelectionOnOutsideClick: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    allowRangeSelection: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    keepMounted: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    onDragDrop: {
+        type: PropType<(payload: TreeDragDropPayload) => void>;
+        default: undefined;
+    };
+    allowDrop: {
+        type: PropType<TreeAllowDrop>;
+        default: undefined;
+    };
+    withDragHandle: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    withLines: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    classNames: {
+        type: (ObjectConstructor | FunctionConstructor)[];
+        default: undefined;
+    };
+    styles: {
+        type: (ObjectConstructor | FunctionConstructor)[];
+        default: undefined;
+    };
+    vars: {
+        type: (ObjectConstructor | FunctionConstructor)[];
+        default: undefined;
+    };
+    unstyled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>> & Readonly<{}>, {
+    classNames: Function | Record<string, any>;
+    styles: Function | Record<string, any>;
+    keepMounted: boolean;
+    component: string | Component;
+    vars: Function | Record<string, any>;
+    unstyled: boolean;
+    expandOnClick: boolean;
+    renderNode: RenderNode;
+    selectOnClick: boolean;
+    allowRangeSelection: boolean;
+    expandOnSpace: boolean;
+    checkOnSpace: boolean;
+    onDragDrop: (payload: TreeDragDropPayload) => void;
+    allowDrop: TreeAllowDrop;
+    withDragHandle: boolean;
+    levelOffset: string | number;
+    tree: import("./use-tree").UseTreeReturnType;
+    clearSelectionOnOutsideClick: boolean;
+    withLines: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>>;

package/lib/components/Tree/TreeNode.d.ts

@@ -0,0 +1,2 @@
+import { defineComponent } from 'vue';
+export declare const TreeNode: ReturnType<typeof defineComponent>;

package/lib/components/Tree/filter-tree-data/filter-tree-data.d.ts

@@ -0,0 +1,4 @@
+import type { TreeNodeData } from '../Tree';
+export type TreeNodeFilter = (query: string, node: TreeNodeData) => boolean;
+export declare function defaultTreeNodeFilter(query: string, node: TreeNodeData): boolean;
+export declare function filterTreeData(data: TreeNodeData[], query: string, filter?: TreeNodeFilter): TreeNodeData[];

package/lib/components/Tree/flatten-tree-data/flatten-tree-data.d.ts

@@ -0,0 +1,12 @@
+import type { TreeNodeData } from '../Tree';
+import type { TreeExpandedState } from '../use-tree';
+export type FlatTreeLineState = 'continuing' | 'closing' | 'none';
+export interface FlattenedTreeNodeData {
+    node: TreeNodeData;
+    level: number;
+    parent: string | null;
+    hasChildren: boolean;
+    expanded: boolean;
+    linesPath: FlatTreeLineState[];
+}
+export declare function flattenTreeData(data: TreeNodeData[], expandedState: TreeExpandedState): FlattenedTreeNodeData[];

package/lib/components/Tree/get-all-checked-nodes/get-all-checked-nodes.d.ts

@@ -0,0 +1,11 @@
+import type { TreeNodeData } from '../Tree';
+export interface CheckedNodeStatus {
+    checked: boolean;
+    indeterminate: boolean;
+    hasChildren: boolean;
+    value: string;
+}
+export declare function getAllCheckedNodes(data: TreeNodeData[], checkedState: string[], acc?: CheckedNodeStatus[]): {
+    result: CheckedNodeStatus[];
+    currentTreeChecked: CheckedNodeStatus[];
+};

package/lib/components/Tree/get-children-nodes-values/get-children-nodes-values.d.ts

@@ -0,0 +1,4 @@
+import type { TreeNodeData } from '../Tree';
+export declare function findTreeNode(value: string, data: TreeNodeData[]): TreeNodeData | null;
+export declare function getChildrenNodesValues(value: string, data: TreeNodeData[], acc?: string[]): string[];
+export declare function getAllChildrenNodes(data: TreeNodeData[]): string[];

package/lib/components/Tree/index.d.ts

@@ -0,0 +1,15 @@
+export { Tree } from './Tree';
+export { FlatTreeNode } from './FlatTreeNode';
+export { useTree, getTreeExpandedState } from './use-tree';
+export { mergeAsyncChildren } from './merge-async-children/merge-async-children';
+export { moveTreeNode } from './move-tree-node/move-tree-node';
+export { filterTreeData, defaultTreeNodeFilter } from './filter-tree-data/filter-tree-data';
+export { flattenTreeData } from './flatten-tree-data/flatten-tree-data';
+export type { TreeProps, TreeStylesNames, TreeFactory, TreeCssVariables, TreeNodeData, RenderTreeNodePayload, RenderNode, } from './Tree';
+export type { UseTreeInput, UseTreeReturnType, TreeController, TreeExpandedState } from './use-tree';
+export type { CheckedNodeStatus } from './get-all-checked-nodes/get-all-checked-nodes';
+export type { TreeNodeFilter } from './filter-tree-data/filter-tree-data';
+export type { TreeDragDropPosition, TreeDragDropPayload } from './move-tree-node/move-tree-node';
+export type { FlattenedTreeNodeData, FlatTreeLineState, } from './flatten-tree-data/flatten-tree-data';
+export type { FlatTreeNodeProps } from './FlatTreeNode';
+export type { TreeAllowDrop, TreeDragHandleProps } from './use-tree-node-drag-drop';

package/lib/components/Tree/is-node-checked/is-node-checked.d.ts

@@ -0,0 +1,2 @@
+import type { TreeNodeData } from '../Tree';
+export declare function isNodeChecked(value: string, data: TreeNodeData[], checkedState: string[]): boolean;

package/lib/components/Tree/is-node-indeterminate/is-node-indeterminate.d.ts

@@ -0,0 +1,2 @@
+import type { TreeNodeData } from '../Tree';
+export declare function isNodeIndeterminate(value: string, data: TreeNodeData[], checkedState: string[]): boolean;

package/lib/components/Tree/merge-async-children/merge-async-children.d.ts

@@ -0,0 +1,2 @@
+import type { TreeNodeData } from '../Tree';
+export declare function mergeAsyncChildren(data: TreeNodeData[], parentValue: string, children: TreeNodeData[]): TreeNodeData[];

package/lib/components/Tree/move-tree-node/move-tree-node.d.ts

@@ -0,0 +1,8 @@
+import type { TreeNodeData } from '../Tree';
+export type TreeDragDropPosition = 'before' | 'after' | 'inside';
+export interface TreeDragDropPayload {
+    draggedNode: string;
+    targetNode: string;
+    position: TreeDragDropPosition;
+}
+export declare function moveTreeNode(data: TreeNodeData[], payload: TreeDragDropPayload): TreeNodeData[];

package/lib/components/Tree/use-tree-node-drag-drop.d.ts

@@ -0,0 +1,34 @@
+import { type Ref } from 'vue';
+import type { TreeDragDropPayload } from './move-tree-node/move-tree-node';
+import type { TreeDragState, TreeNodeData } from './Tree';
+export type TreeAllowDrop = (payload: TreeDragDropPayload) => boolean;
+export interface TreeDragHandleProps {
+    onMousedown: (event: MouseEvent) => void;
+}
+interface Input {
+    nodeValue: string;
+    hasChildren: () => boolean;
+    isExpanded: () => boolean;
+    data: () => TreeNodeData[];
+    onDragDrop?: (payload: TreeDragDropPayload) => void;
+    dragState: Ref<TreeDragState>;
+    allowDrop?: TreeAllowDrop;
+    withDragHandle?: boolean;
+}
+export declare function useTreeNodeDragDrop(input: Input): {
+    getElementProps: () => {};
+    dragHandleProps: undefined;
+} | {
+    getElementProps: () => {
+        draggable: boolean;
+        onDragstart: (event: DragEvent) => void;
+        onDragover: (event: DragEvent) => void;
+        onDragleave: (event: DragEvent) => void;
+        onDrop: (event: DragEvent) => void;
+        onDragend: (event: DragEvent) => void;
+    };
+    dragHandleProps: {
+        onMousedown: () => void;
+    } | undefined;
+};
+export {};

package/lib/components/Tree/use-tree.d.ts

@@ -0,0 +1,55 @@
+import { type MaybeRefOrGetter, type Ref } from 'vue';
+import { type CheckedNodeStatus } from './get-all-checked-nodes/get-all-checked-nodes';
+import type { TreeNodeData } from './Tree';
+export type TreeExpandedState = Record<string, boolean>;
+export declare function getTreeExpandedState(data: TreeNodeData[], values: string[] | '*'): TreeExpandedState;
+export interface UseTreeInput {
+    initialExpandedState?: TreeExpandedState;
+    expandedState?: MaybeRefOrGetter<TreeExpandedState | undefined>;
+    onExpandedStateChange?: (state: TreeExpandedState) => void;
+    initialSelectedState?: string[];
+    selectedState?: MaybeRefOrGetter<string[] | undefined>;
+    onSelectedStateChange?: (state: string[]) => void;
+    initialCheckedState?: string[];
+    checkedState?: MaybeRefOrGetter<string[] | undefined>;
+    onCheckedStateChange?: (state: string[]) => void;
+    multiple?: boolean;
+    onNodeExpand?: (value: string) => void;
+    onNodeCollapse?: (value: string) => void;
+    onLoadChildren?: (nodeValue: string) => Promise<void>;
+    checkStrictly?: boolean;
+}
+export interface UseTreeReturnType {
+    checkStrictly: boolean;
+    multiple: boolean;
+    expandedState: Readonly<Ref<TreeExpandedState>>;
+    selectedState: Readonly<Ref<string[]>>;
+    checkedState: Readonly<Ref<string[]>>;
+    anchorNode: Ref<string | null>;
+    initialize(data: TreeNodeData[]): void;
+    toggleExpanded(value: string): void;
+    collapse(value: string): void;
+    expand(value: string): void;
+    expandAllNodes(): void;
+    collapseAllNodes(): void;
+    setExpandedState(value: TreeExpandedState): void;
+    toggleSelected(value: string): string[];
+    select(value: string): void;
+    deselect(value: string): void;
+    clearSelected(): void;
+    setSelectedState(value: string[]): void;
+    checkNode(value: string): void;
+    uncheckNode(value: string): void;
+    checkAllNodes(): void;
+    uncheckAllNodes(): void;
+    setCheckedState(value: string[]): void;
+    getCheckedNodes(): CheckedNodeStatus[];
+    isNodeChecked(value: string): boolean;
+    isNodeIndeterminate(value: string): boolean;
+    isNodeLoading(value: string): boolean;
+    getNodeLoadError(value: string): Error | null;
+    loadNode(value: string): Promise<void>;
+    invalidateNode(value: string): void;
+}
+export declare function useTree(input?: UseTreeInput): UseTreeReturnType;
+export type TreeController = ReturnType<typeof useTree>;