cosey 0.6.29 → 0.6.31

package/components/horizontal-tree/horizontal-tree.api.d.ts

@@ -1,25 +1,52 @@
-export interface HorizontalTreeProps<INode extends Record<PropertyKey, any> = any> {
-    data?: INode[];
-    props?: {
-        children?: string;
-        label?: string;
-        disabled?: string | ((data: INode[], node: INode) => string);
-        class?: string | ((data: INode[], node: INode) => string);
-    };
-    nodeKey?: string;
-    nodeWidth?: string;
-    mergeLast?: boolean;
-    showCheckbox?: boolean;
-    checkStrictly?: boolean;
-}
-export interface HorizontalTreeSlots<INode extends Record<PropertyKey, any> = any> {
-    default?: (props: Record<string, never>) => any;
-    node?: (node: INode) => any;
-}
-export interface HorizontalTreeEmits<INode extends Record<PropertyKey, any> = any> {
-    (e: 'check-change', node: INode, checked: boolean): void;
+import type { ExtractPropTypes, PropType, SlotsType, VNodeChild } from 'vue';
+import { ExtraTreeNode } from '../../utils';
+type INode = Record<PropertyKey, any>;
+export declare const horizontalTreeProps: {
+    data: {
+        type: PropType<INode[]>;
+    };
+    props: {
+        type: PropType<{
+            children?: string;
+            label?: string;
+            disabled?: string | ((data: INode[], node: INode) => string);
+            class?: string | ((data: INode[], node: INode) => string);
+        }>;
+    };
+    nodeKey: {
+        type: StringConstructor;
+    };
+    nodeWidth: {
+        type: StringConstructor;
+        default: string;
+    };
+    mergeLast: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    showCheckbox: {
+        type: BooleanConstructor;
+    };
+    checkStrictly: {
+        type: BooleanConstructor;
+    };
+    renderNode: {
+        type: PropType<(node: ExtraTreeNode<any>, defaultRender: () => VNodeChild) => VNodeChild>;
+    };
+    renderContent: {
+        type: PropType<(node: ExtraTreeNode<any>, defaultRender: () => VNodeChild) => VNodeChild>;
+    };
+};
+export type HorizontalTreeProps = ExtractPropTypes<typeof horizontalTreeProps>;
+export interface HorizontalTreeSlots {
+    default: {};
 }
-export interface HorizontalTreeExpose<INode extends Record<PropertyKey, any> = any> {
+export declare const horizontalTreeSlots: SlotsType<HorizontalTreeSlots>;
+export declare const horizontalTreeEmits: {
+    'check-change': (node: ExtraTreeNode<any>, checked: boolean) => boolean;
+};
+export type HorizontalTreeEmits = typeof horizontalTreeEmits;
+export interface HorizontalTreeExpose {
     getCheckedNodes: () => INode[];
     setCheckedNodes: (nodes: INode[]) => void;
     getCheckedKeys: () => (string | number)[];
@@ -29,3 +56,4 @@ export interface HorizontalTreeExpose<INode extends Record<PropertyKey, any> = a
     getHalfCheckedKeys: () => (string | number)[];
     getNode: (key: string | number) => INode | undefined;
 }
+export {};

package/components/horizontal-tree/horizontal-tree.api.js

@@ -1 +1,39 @@
+import { isObject, isBoolean } from '../../utils/is.js';
 
+const horizontalTreeProps = {
+  data: {
+    type: Array
+  },
+  props: {
+    type: Object
+  },
+  nodeKey: {
+    type: String
+  },
+  nodeWidth: {
+    type: String,
+    default: "120px"
+  },
+  mergeLast: {
+    type: Boolean,
+    default: true
+  },
+  showCheckbox: {
+    type: Boolean
+  },
+  checkStrictly: {
+    type: Boolean
+  },
+  renderNode: {
+    type: Function
+  },
+  renderContent: {
+    type: Function
+  }
+};
+const horizontalTreeSlots = Object;
+const horizontalTreeEmits = {
+  "check-change": (node, checked) => isObject(node) && isBoolean(checked)
+};
+
+export { horizontalTreeEmits, horizontalTreeProps, horizontalTreeSlots };

package/components/horizontal-tree/horizontal-tree.d.ts

@@ -0,0 +1,122 @@
+import { ExtraTreeNode } from '../../utils';
+declare const _default: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    data: {
+        type: import("vue").PropType<{
+            [x: string]: any;
+            [x: number]: any;
+            [x: symbol]: any;
+        }[]>;
+    };
+    props: {
+        type: import("vue").PropType<{
+            children?: string;
+            label?: string;
+            disabled?: string | ((data: {
+                [x: string]: any;
+                [x: number]: any;
+                [x: symbol]: any;
+            }[], node: {
+                [x: string]: any;
+                [x: number]: any;
+                [x: symbol]: any;
+            }) => string);
+            class?: string | ((data: {
+                [x: string]: any;
+                [x: number]: any;
+                [x: symbol]: any;
+            }[], node: {
+                [x: string]: any;
+                [x: number]: any;
+                [x: symbol]: any;
+            }) => string);
+        }>;
+    };
+    nodeKey: {
+        type: StringConstructor;
+    };
+    nodeWidth: {
+        type: StringConstructor;
+        default: string;
+    };
+    mergeLast: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    showCheckbox: {
+        type: BooleanConstructor;
+    };
+    checkStrictly: {
+        type: BooleanConstructor;
+    };
+    renderNode: {
+        type: import("vue").PropType<(node: ExtraTreeNode<any>, defaultRender: () => import("vue").VNodeChild) => import("vue").VNodeChild>;
+    };
+    renderContent: {
+        type: import("vue").PropType<(node: ExtraTreeNode<any>, defaultRender: () => import("vue").VNodeChild) => import("vue").VNodeChild>;
+    };
+}>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    'check-change': (node: ExtraTreeNode<any>, checked: boolean) => boolean;
+}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    data: {
+        type: import("vue").PropType<{
+            [x: string]: any;
+            [x: number]: any;
+            [x: symbol]: any;
+        }[]>;
+    };
+    props: {
+        type: import("vue").PropType<{
+            children?: string;
+            label?: string;
+            disabled?: string | ((data: {
+                [x: string]: any;
+                [x: number]: any;
+                [x: symbol]: any;
+            }[], node: {
+                [x: string]: any;
+                [x: number]: any;
+                [x: symbol]: any;
+            }) => string);
+            class?: string | ((data: {
+                [x: string]: any;
+                [x: number]: any;
+                [x: symbol]: any;
+            }[], node: {
+                [x: string]: any;
+                [x: number]: any;
+                [x: symbol]: any;
+            }) => string);
+        }>;
+    };
+    nodeKey: {
+        type: StringConstructor;
+    };
+    nodeWidth: {
+        type: StringConstructor;
+        default: string;
+    };
+    mergeLast: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    showCheckbox: {
+        type: BooleanConstructor;
+    };
+    checkStrictly: {
+        type: BooleanConstructor;
+    };
+    renderNode: {
+        type: import("vue").PropType<(node: ExtraTreeNode<any>, defaultRender: () => import("vue").VNodeChild) => import("vue").VNodeChild>;
+    };
+    renderContent: {
+        type: import("vue").PropType<(node: ExtraTreeNode<any>, defaultRender: () => import("vue").VNodeChild) => import("vue").VNodeChild>;
+    };
+}>> & Readonly<{
+    "onCheck-change"?: ((node: any, checked: boolean) => any) | undefined;
+}>, {
+    mergeLast: boolean;
+    checkStrictly: boolean;
+    showCheckbox: boolean;
+    nodeWidth: string;
+}, import("vue").SlotsType<import("./horizontal-tree.api").HorizontalTreeSlots>, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;

package/components/horizontal-tree/horizontal-tree.js

@@ -0,0 +1,210 @@
+import { defineComponent, computed, watch, createVNode, isVNode } from 'vue';
+import { horizontalTreeEmits, horizontalTreeSlots, horizontalTreeProps } from './horizontal-tree.api.js';
+import stdin_default$1, { HorizontalTreeNodeWidthVar } from './horizontal-tree.style.js';
+import { ElCheckbox } from 'element-plus';
+import { useTreeCheck } from '../../hooks/useTreeCheck.js';
+import { mapTree, extraTreeToTable, walkTree } from '../../utils/tree.js';
+import { useComponentConfig } from '../config-provider/config-provider.api.js';
+import { useLocale } from '../../hooks/useLocale.js';
+import { isString } from '../../utils/is.js';
+
+function _isSlot(s) {
+  return typeof s === 'function' || Object.prototype.toString.call(s) === '[object Object]' && !isVNode(s);
+}
+var stdin_default = defineComponent({
+  name: "CoHorizontalTree",
+  props: horizontalTreeProps,
+  slots: horizontalTreeSlots,
+  emits: horizontalTreeEmits,
+  setup(props, {
+    emit,
+    expose
+  }) {
+    const {
+      prefixCls
+    } = useComponentConfig("horizontal-tree", props);
+    const {
+      hashId
+    } = stdin_default$1(prefixCls);
+    const {
+      t
+    } = useLocale();
+    const propNames = computed(() => {
+      return Object.assign({
+        children: "children",
+        label: "label",
+        disabled: "disabled",
+        class: "class"
+      }, props.props);
+    });
+    const {
+      rootNode,
+      tree: checkableTree,
+      checkAllValue,
+      checkAllIndeterminate,
+      onCheckAllChange,
+      initialize,
+      setCheckedByNode
+    } = useTreeCheck({
+      mergeLast: props.mergeLast,
+      childrenKey: propNames.value.children,
+      checkStrictly: props.checkStrictly
+    });
+    const tree = computed(() => {
+      return mapTree(props.data || [], node => node);
+    });
+    watch(tree, () => {
+      initialize(tree.value);
+    }, {
+      immediate: true
+    });
+    const tableTree = computed(() => {
+      return extraTreeToTable(checkableTree.value, props.mergeLast);
+    });
+    const maxLevel = computed(() => Math.max(...tableTree.value.map(([item]) => item.reverseLevel)));
+    const getDisabled = node => {
+      return isString(propNames.value.disabled) ? node[propNames.value.disabled] : node[propNames.value.disabled(props.data, node)];
+    };
+    const getNodeClass = node => {
+      return isString(propNames.value.class) ? node[propNames.value.class] : node[propNames.value.class(props.data, node)];
+    };
+    const onCheckChange = (node, checked) => {
+      setCheckedByNode(node, checked);
+      emit("check-change", node.data, checked);
+    };
+    const getCheckedNodes = () => {
+      const nodes = [];
+      walkTree(checkableTree.value, "children", node => {
+        if (node.checkedStatus === "checked") {
+          nodes.push(node.data);
+        }
+      });
+      return nodes;
+    };
+    const setCheckedKeys = keys => {
+      const nodes = [];
+      walkTree(checkableTree.value, "children", node => {
+        const id = node.data[props.nodeKey];
+        if (keys.includes(id)) {
+          nodes.push(node);
+        }
+      });
+      setCheckedByNode(rootNode, false);
+      nodes.forEach(node => {
+        setCheckedByNode(node, true);
+      });
+    };
+    const getCheckedKeys = () => {
+      const keys = [];
+      walkTree(checkableTree.value, "children", node => {
+        if (node.checkedStatus === "checked") {
+          const key = node.data[props.nodeKey];
+          keys.push(key);
+        }
+      });
+      return keys;
+    };
+    const setCheckedNodes = nodes => {
+      const keys = nodes.map(node => node[props.nodeKey]);
+      setCheckedKeys(keys);
+    };
+    const setChecked = (key, checked) => {
+      walkTree(checkableTree.value, "children", node => {
+        if (node.data[props.nodeKey] === key) {
+          setCheckedByNode(node, checked);
+          return true;
+        }
+      });
+    };
+    const getHalfCheckedNodes = () => {
+      const nodes = [];
+      walkTree(checkableTree.value, "children", node => {
+        if (node.checkedStatus === "indeterminate") {
+          nodes.push(node.data);
+        }
+      });
+      return nodes;
+    };
+    const getHalfCheckedKeys = () => {
+      const nodes = getHalfCheckedNodes();
+      return nodes.map(node => node[props.nodeKey]);
+    };
+    const getNode = key => {
+      let _node;
+      walkTree(checkableTree.value, "children", node => {
+        if (node.data[props.nodeKey] === key) {
+          _node = node.data;
+          return true;
+        }
+      });
+      return _node;
+    };
+    expose({
+      getCheckedNodes,
+      setCheckedNodes,
+      setCheckedKeys,
+      getCheckedKeys,
+      setChecked,
+      getHalfCheckedNodes,
+      getHalfCheckedKeys,
+      getNode
+    });
+    function renderNode(node) {
+      let _slot;
+      function renderContent() {
+        return createVNode("span", {
+          "class": getNodeClass(node.data)
+        }, [node.data[propNames.value.label]]);
+      }
+      function renderMayCustomContent() {
+        return props.renderContent ? props.renderContent(node, renderContent) : renderContent();
+      }
+      return createVNode("div", {
+        "class": `${prefixCls.value}-node`
+      }, [props.showCheckbox ? createVNode(ElCheckbox, {
+        "disabled": getDisabled(node.data),
+        "modelValue": node.checkedStatus === "checked",
+        "indeterminate": node.checkedStatus === "indeterminate",
+        "onChange": value => onCheckChange(node, !!value)
+      }, _isSlot(_slot = renderMayCustomContent()) ? _slot : {
+        default: () => [_slot]
+      }) : renderMayCustomContent()]);
+    }
+    function renderMayCustomNode(node) {
+      return props.renderNode ? props.renderNode(node, () => renderNode(node)) : renderNode(node);
+    }
+    return () => {
+      let _slot2;
+      return createVNode("div", {
+        "class": [hashId.value, prefixCls.value],
+        "style": {
+          [HorizontalTreeNodeWidthVar]: props.nodeWidth
+        }
+      }, [tableTree.value.length === 0 ? createVNode("div", {
+        "class": `${prefixCls.value}-empty`
+      }, [t("co.common.noData")]) : createVNode("table", null, [props.showCheckbox && !props.checkStrictly && createVNode("thead", null, [createVNode("tr", null, [createVNode("td", {
+        "colspan": maxLevel.value
+      }, [createVNode("div", {
+        "class": `${prefixCls.value}-node`
+      }, [createVNode(ElCheckbox, {
+        "modelValue": checkAllValue.value,
+        "indeterminate": checkAllIndeterminate.value,
+        "onChange": onCheckAllChange
+      }, _isSlot(_slot2 = t("co.common.checkAll")) ? _slot2 : {
+        default: () => [_slot2]
+      })])])])]), createVNode("tbody", null, [tableTree.value.map((row, i) => {
+        return createVNode("tr", {
+          "key": i
+        }, [row.map((node, j) => {
+          return createVNode("td", {
+            "key": j,
+            "colspan": node.reverseLevel === 1 ? maxLevel.value - node.level + 1 : 1,
+            "rowspan": node.leafCount
+          }, [node.reverseLevel !== 1 || !props.mergeLast ? renderMayCustomNode(node) : createVNode("div", null, [node.parent.children?.map(renderMayCustomNode)])]);
+        })]);
+      })])])]);
+    };
+  }
+});
+
+export { stdin_default as default };

package/components/horizontal-tree/horizontal-tree.style.d.ts

@@ -1,3 +1,4 @@
+export declare const HorizontalTreeNodeWidthVar = "--co-horizontal-tree-node-width";
 declare const _default: (_prefixCls?: import("vue").ComputedRef<string> | string, themeManager?: import("../theme/theme-context").ThemeManager) => {
     hashId: import("vue").Ref<string, string>;
 };

package/components/horizontal-tree/horizontal-tree.style.js

@@ -1,5 +1,6 @@
 import { getSimpleStyleHook } from '../theme/getSimpleStyleHook.js';
 
+const HorizontalTreeNodeWidthVar = "--co-horizontal-tree-node-width";
 var stdin_default = getSimpleStyleHook("CoHorizontalTree", (token) => {
   const { componentCls } = token;
   return {
@@ -27,10 +28,10 @@ var stdin_default = getSimpleStyleHook("CoHorizontalTree", (token) => {
       },
       [`${componentCls}-node`]: {
         display: "inline-flex",
-        width: "var(--node-width)"
+        width: `var(${HorizontalTreeNodeWidthVar})`
       }
     }
   };
 });
 
-export { stdin_default as default };
+export { HorizontalTreeNodeWidthVar, stdin_default as default };

package/components/horizontal-tree/index.d.ts

@@ -1,64 +1,206 @@
 export * from './horizontal-tree.api';
 declare const _HorizontalTree: {
-    new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("./horizontal-tree.api").HorizontalTreeProps<any>> & Readonly<{
+    new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
+        data: {
+            type: import("vue").PropType<{
+                [x: string]: any;
+                [x: number]: any;
+                [x: symbol]: any;
+            }[]>;
+        };
+        props: {
+            type: import("vue").PropType<{
+                children?: string;
+                label?: string;
+                disabled?: string | ((data: {
+                    [x: string]: any;
+                    [x: number]: any;
+                    [x: symbol]: any;
+                }[], node: {
+                    [x: string]: any;
+                    [x: number]: any;
+                    [x: symbol]: any;
+                }) => string);
+                class?: string | ((data: {
+                    [x: string]: any;
+                    [x: number]: any;
+                    [x: symbol]: any;
+                }[], node: {
+                    [x: string]: any;
+                    [x: number]: any;
+                    [x: symbol]: any;
+                }) => string);
+            }>;
+        };
+        nodeKey: {
+            type: StringConstructor;
+        };
+        nodeWidth: {
+            type: StringConstructor;
+            default: string;
+        };
+        mergeLast: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        showCheckbox: {
+            type: BooleanConstructor;
+        };
+        checkStrictly: {
+            type: BooleanConstructor;
+        };
+        renderNode: {
+            type: import("vue").PropType<(node: import("../../utils").ExtraTreeNode<any>, defaultRender: () => import("vue").VNodeChild) => import("vue").VNodeChild>;
+        };
+        renderContent: {
+            type: import("vue").PropType<(node: import("../../utils").ExtraTreeNode<any>, defaultRender: () => import("vue").VNodeChild) => import("vue").VNodeChild>;
+        };
+    }>> & Readonly<{
         "onCheck-change"?: ((node: any, checked: boolean) => any) | undefined;
-    }>, {
-        getCheckedNodes: () => any[];
-        setCheckedNodes: (nodes: any[]) => void;
-        getCheckedKeys: () => (string | number)[];
-        setCheckedKeys: (keys: (string | number)[]) => void;
-        setChecked: (key: string | number, checked: boolean) => void;
-        getHalfCheckedNodes: () => any[];
-        getHalfCheckedKeys: () => (string | number)[];
-        getNode: (key: string | number) => any;
-    }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
-        "check-change": (node: any, checked: boolean) => any;
+    }>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+        'check-change': (node: import("../../utils").ExtraTreeNode<any>, checked: boolean) => boolean;
     }, import("vue").PublicProps, {
         mergeLast: boolean;
+        checkStrictly: boolean;
+        showCheckbox: boolean;
         nodeWidth: string;
-    }, false, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
+    }, true, {}, import("vue").SlotsType<import("./horizontal-tree.api").HorizontalTreeSlots>, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
         P: {};
         B: {};
         D: {};
         C: {};
         M: {};
         Defaults: {};
-    }, Readonly<import("./horizontal-tree.api").HorizontalTreeProps<any>> & Readonly<{
+    }, Readonly<import("vue").ExtractPropTypes<{
+        data: {
+            type: import("vue").PropType<{
+                [x: string]: any;
+                [x: number]: any;
+                [x: symbol]: any;
+            }[]>;
+        };
+        props: {
+            type: import("vue").PropType<{
+                children?: string;
+                label?: string;
+                disabled?: string | ((data: {
+                    [x: string]: any;
+                    [x: number]: any;
+                    [x: symbol]: any;
+                }[], node: {
+                    [x: string]: any;
+                    [x: number]: any;
+                    [x: symbol]: any;
+                }) => string);
+                class?: string | ((data: {
+                    [x: string]: any;
+                    [x: number]: any;
+                    [x: symbol]: any;
+                }[], node: {
+                    [x: string]: any;
+                    [x: number]: any;
+                    [x: symbol]: any;
+                }) => string);
+            }>;
+        };
+        nodeKey: {
+            type: StringConstructor;
+        };
+        nodeWidth: {
+            type: StringConstructor;
+            default: string;
+        };
+        mergeLast: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        showCheckbox: {
+            type: BooleanConstructor;
+        };
+        checkStrictly: {
+            type: BooleanConstructor;
+        };
+        renderNode: {
+            type: import("vue").PropType<(node: import("../../utils").ExtraTreeNode<any>, defaultRender: () => import("vue").VNodeChild) => import("vue").VNodeChild>;
+        };
+        renderContent: {
+            type: import("vue").PropType<(node: import("../../utils").ExtraTreeNode<any>, defaultRender: () => import("vue").VNodeChild) => import("vue").VNodeChild>;
+        };
+    }>> & Readonly<{
         "onCheck-change"?: ((node: any, checked: boolean) => any) | undefined;
-    }>, {
-        getCheckedNodes: () => any[];
-        setCheckedNodes: (nodes: any[]) => void;
-        getCheckedKeys: () => (string | number)[];
-        setCheckedKeys: (keys: (string | number)[]) => void;
-        setChecked: (key: string | number, checked: boolean) => void;
-        getHalfCheckedNodes: () => any[];
-        getHalfCheckedKeys: () => (string | number)[];
-        getNode: (key: string | number) => any;
-    }, {}, {}, {}, {
+    }>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, {
         mergeLast: boolean;
+        checkStrictly: boolean;
+        showCheckbox: boolean;
         nodeWidth: string;
     }>;
     __isFragment?: never;
     __isTeleport?: never;
     __isSuspense?: never;
-} & import("vue").ComponentOptionsBase<Readonly<import("./horizontal-tree.api").HorizontalTreeProps<any>> & Readonly<{
+} & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
+    data: {
+        type: import("vue").PropType<{
+            [x: string]: any;
+            [x: number]: any;
+            [x: symbol]: any;
+        }[]>;
+    };
+    props: {
+        type: import("vue").PropType<{
+            children?: string;
+            label?: string;
+            disabled?: string | ((data: {
+                [x: string]: any;
+                [x: number]: any;
+                [x: symbol]: any;
+            }[], node: {
+                [x: string]: any;
+                [x: number]: any;
+                [x: symbol]: any;
+            }) => string);
+            class?: string | ((data: {
+                [x: string]: any;
+                [x: number]: any;
+                [x: symbol]: any;
+            }[], node: {
+                [x: string]: any;
+                [x: number]: any;
+                [x: symbol]: any;
+            }) => string);
+        }>;
+    };
+    nodeKey: {
+        type: StringConstructor;
+    };
+    nodeWidth: {
+        type: StringConstructor;
+        default: string;
+    };
+    mergeLast: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    showCheckbox: {
+        type: BooleanConstructor;
+    };
+    checkStrictly: {
+        type: BooleanConstructor;
+    };
+    renderNode: {
+        type: import("vue").PropType<(node: import("../../utils").ExtraTreeNode<any>, defaultRender: () => import("vue").VNodeChild) => import("vue").VNodeChild>;
+    };
+    renderContent: {
+        type: import("vue").PropType<(node: import("../../utils").ExtraTreeNode<any>, defaultRender: () => import("vue").VNodeChild) => import("vue").VNodeChild>;
+    };
+}>> & Readonly<{
     "onCheck-change"?: ((node: any, checked: boolean) => any) | undefined;
-}>, {
-    getCheckedNodes: () => any[];
-    setCheckedNodes: (nodes: any[]) => void;
-    getCheckedKeys: () => (string | number)[];
-    setCheckedKeys: (keys: (string | number)[]) => void;
-    setChecked: (key: string | number, checked: boolean) => void;
-    getHalfCheckedNodes: () => any[];
-    getHalfCheckedKeys: () => (string | number)[];
-    getNode: (key: string | number) => any;
-}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
-    "check-change": (node: any, checked: boolean) => any;
+}>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    'check-change': (node: import("../../utils").ExtraTreeNode<any>, checked: boolean) => boolean;
 }, string, {
     mergeLast: boolean;
+    checkStrictly: boolean;
+    showCheckbox: boolean;
     nodeWidth: string;
-}, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
-    $slots: import("./horizontal-tree.api").HorizontalTreeSlots<any>;
-}) & import("vue").Plugin;
+}, {}, string, import("vue").SlotsType<import("./horizontal-tree.api").HorizontalTreeSlots>, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & import("vue").Plugin;
 export { _HorizontalTree as HorizontalTree };
 export default _HorizontalTree;

package/components/horizontal-tree/index.js

@@ -1,5 +1,6 @@
 import { withInstall } from '../utils.js';
-import stdin_default$1 from './horizontal-tree.vue.js';
+import stdin_default$1 from './horizontal-tree.js';
+export { horizontalTreeEmits, horizontalTreeProps, horizontalTreeSlots } from './horizontal-tree.api.js';
 
 const _HorizontalTree = withInstall(stdin_default$1);
 var stdin_default = _HorizontalTree;

package/components/index.js

@@ -78,6 +78,7 @@ export { defaultFormListProps, formListEmits, formListExposeKeys, formListProps,
 export { defaultMapSizeColNumber, formQueryContextSymbol, formQueryEmits, formQueryProps, formQuerySlots } from './form-query/form-query.api.js';
 export { highlightProps, highlightSlots } from './highlight/highlight.api.js';
 export { default as hljs } from 'highlight.js/lib/core';
+export { horizontalTreeEmits, horizontalTreeProps, horizontalTreeSlots } from './horizontal-tree/horizontal-tree.api.js';
 export { addIconifyIcon, iconifyIconsSets } from './iconify-icon/iconify-icon.js';
 export { imageCardEmits, imageCardProps, imageCardSlots } from './image-card/image-card.api.js';
 export { defaultInputNumberRangeProps } from './input-number-range/input-number-range.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cosey",
-  "version": "0.6.29",
+  "version": "0.6.31",
   "description": "基于 Vue3 + vite 的后台管理系统框架",
   "type": "module",
   "main": "index.js",

package/components/horizontal-tree/horizontal-tree.vue.d.ts

@@ -1,27 +0,0 @@
-import { type HorizontalTreeProps, type HorizontalTreeSlots } from './horizontal-tree.api';
-type __VLS_Props = HorizontalTreeProps;
-type __VLS_Slots = HorizontalTreeSlots;
-declare const __VLS_component: import("vue").DefineComponent<__VLS_Props, {
-    getCheckedNodes: () => any[];
-    setCheckedNodes: (nodes: any[]) => void;
-    getCheckedKeys: () => (string | number)[];
-    setCheckedKeys: (keys: (string | number)[]) => void;
-    setChecked: (key: string | number, checked: boolean) => void;
-    getHalfCheckedNodes: () => any[];
-    getHalfCheckedKeys: () => (string | number)[];
-    getNode: (key: string | number) => any;
-}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
-    "check-change": (node: any, checked: boolean) => any;
-}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
-    "onCheck-change"?: ((node: any, checked: boolean) => any) | undefined;
-}>, {
-    mergeLast: boolean;
-    nodeWidth: string;
-}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
-declare const _default: __VLS_WithSlots<typeof __VLS_component, __VLS_Slots>;
-export default _default;
-type __VLS_WithSlots<T, S> = T & {
-    new (): {
-        $slots: S;
-    };
-};

package/components/horizontal-tree/horizontal-tree.vue.js

@@ -1,284 +0,0 @@
-import { defineComponent, computed, watch, resolveComponent, createElementBlock, openBlock, normalizeStyle, normalizeClass, unref, toDisplayString, createCommentVNode, createElementVNode, createVNode, withCtx, createTextVNode, Fragment, renderList, createBlock, renderSlot } from 'vue';
-import stdin_default$1 from './horizontal-tree.style.js';
-import { useTreeCheck } from '../../hooks/useTreeCheck.js';
-import { mapTree, extraTreeToTable, walkTree } from '../../utils/tree.js';
-import { useComponentConfig } from '../config-provider/config-provider.api.js';
-import { useLocale } from '../../hooks/useLocale.js';
-import { isString } from '../../utils/is.js';
-
-const _hoisted_1 = {
-  key: 1
-};
-const _hoisted_2 = {
-  key: 0
-};
-const _hoisted_3 = ["colspan"];
-const _hoisted_4 = ["colspan", "rowspan"];
-const _hoisted_5 = {
-  key: 1
-};
-var stdin_default = /* @__PURE__ */defineComponent({
-  ...{
-    name: "CoHorizontalTree"
-  },
-  __name: "horizontal-tree",
-  props: {
-    data: {
-      type: Array,
-      required: false
-    },
-    props: {
-      type: Object,
-      required: false
-    },
-    nodeKey: {
-      type: String,
-      required: false
-    },
-    nodeWidth: {
-      type: String,
-      required: false,
-      default: "120px"
-    },
-    mergeLast: {
-      type: Boolean,
-      required: false,
-      default: true
-    },
-    showCheckbox: {
-      type: Boolean,
-      required: false
-    },
-    checkStrictly: {
-      type: Boolean,
-      required: false
-    }
-  },
-  emits: ["check-change"],
-  setup(__props, {
-    expose: __expose,
-    emit: __emit
-  }) {
-    const props = __props;
-    const emit = __emit;
-    const {
-      prefixCls
-    } = useComponentConfig("horizontal-tree", props);
-    const {
-      hashId
-    } = stdin_default$1(prefixCls);
-    const {
-      t
-    } = useLocale();
-    const propNames = computed(() => {
-      return Object.assign({
-        children: "children",
-        label: "label",
-        disabled: "disabled",
-        class: "class"
-      }, props.props);
-    });
-    const {
-      rootNode,
-      tree: checkableTree,
-      checkAllValue,
-      checkAllIndeterminate,
-      onCheckAllChange,
-      initialize,
-      setCheckedByNode
-    } = useTreeCheck({
-      mergeLast: props.mergeLast,
-      childrenKey: propNames.value.children,
-      checkStrictly: props.checkStrictly
-    });
-    const tree = computed(() => {
-      return mapTree(props.data || [], node => node);
-    });
-    watch(tree, () => {
-      initialize(tree.value);
-    }, {
-      immediate: true
-    });
-    const tableTree = computed(() => {
-      return extraTreeToTable(checkableTree.value, props.mergeLast);
-    });
-    const maxLevel = computed(() => Math.max(...tableTree.value.map(([item]) => item.reverseLevel)));
-    const getDisabled = node => {
-      return isString(propNames.value.disabled) ? node[propNames.value.disabled] : node[propNames.value.disabled(props.data, node)];
-    };
-    const getNodeClass = node => {
-      return isString(propNames.value.class) ? node[propNames.value.class] : node[propNames.value.class(props.data, node)];
-    };
-    const onCheckChange = (node, checked) => {
-      setCheckedByNode(node, checked);
-      emit("check-change", node.data, checked);
-    };
-    const getCheckedNodes = () => {
-      const nodes = [];
-      walkTree(checkableTree.value, "children", node => {
-        if (node.checkedStatus === "checked") {
-          nodes.push(node.data);
-        }
-      });
-      return nodes;
-    };
-    const setCheckedKeys = keys => {
-      const nodes = [];
-      walkTree(checkableTree.value, "children", node => {
-        const id = node.data[props.nodeKey];
-        if (keys.includes(id)) {
-          nodes.push(node);
-        }
-      });
-      setCheckedByNode(rootNode, false);
-      nodes.forEach(node => {
-        setCheckedByNode(node, true);
-      });
-    };
-    const getCheckedKeys = () => {
-      const keys = [];
-      walkTree(checkableTree.value, "children", node => {
-        if (node.checkedStatus === "checked") {
-          const key = node.data[props.nodeKey];
-          keys.push(key);
-        }
-      });
-      return keys;
-    };
-    const setCheckedNodes = nodes => {
-      const keys = nodes.map(node => node[props.nodeKey]);
-      setCheckedKeys(keys);
-    };
-    const setChecked = (key, checked) => {
-      walkTree(checkableTree.value, "children", node => {
-        if (node.data[props.nodeKey] === key) {
-          setCheckedByNode(node, checked);
-          return true;
-        }
-      });
-    };
-    const getHalfCheckedNodes = () => {
-      const nodes = [];
-      walkTree(checkableTree.value, "children", node => {
-        if (node.checkedStatus === "indeterminate") {
-          nodes.push(node.data);
-        }
-      });
-      return nodes;
-    };
-    const getHalfCheckedKeys = () => {
-      const nodes = getHalfCheckedNodes();
-      return nodes.map(node => node[props.nodeKey]);
-    };
-    const getNode = key => {
-      let _node;
-      walkTree(checkableTree.value, "children", node => {
-        if (node.data[props.nodeKey] === key) {
-          _node = node.data;
-          return true;
-        }
-      });
-      return _node;
-    };
-    __expose({
-      getCheckedNodes,
-      setCheckedNodes,
-      setCheckedKeys,
-      getCheckedKeys,
-      setChecked,
-      getHalfCheckedNodes,
-      getHalfCheckedKeys,
-      getNode
-    });
-    return (_ctx, _cache) => {
-      const _component_el_checkbox = resolveComponent("el-checkbox");
-      return openBlock(), createElementBlock("div", {
-        class: normalizeClass([unref(hashId), unref(prefixCls)]),
-        style: normalizeStyle({
-          "--node-width": _ctx.nodeWidth
-        })
-      }, [tableTree.value.length === 0 ? (openBlock(), createElementBlock("div", {
-        key: 0,
-        class: normalizeClass(`${unref(prefixCls)}-empty`)
-      }, toDisplayString(unref(t)("co.common.noData")), 3
-      /* TEXT, CLASS */)) : (openBlock(), createElementBlock("table", _hoisted_1, [_ctx.showCheckbox && !_ctx.checkStrictly ? (openBlock(), createElementBlock("thead", _hoisted_2, [createElementVNode("tr", null, [createElementVNode("td", {
-        colspan: maxLevel.value
-      }, [createElementVNode("div", {
-        class: normalizeClass(`${unref(prefixCls)}-node`)
-      }, [createVNode(_component_el_checkbox, {
-        "model-value": unref(checkAllValue),
-        indeterminate: unref(checkAllIndeterminate),
-        onChange: unref(onCheckAllChange)
-      }, {
-        default: withCtx(() => [createTextVNode(toDisplayString(unref(t)("co.common.checkAll")), 1
-        /* TEXT */)]),
-        _: 1
-        /* STABLE */
-      }, 8, ["model-value", "indeterminate", "onChange"])], 2
-      /* CLASS */)], 8, _hoisted_3)])])) : createCommentVNode("v-if", true), createElementVNode("tbody", null, [(openBlock(true), createElementBlock(Fragment, null, renderList(tableTree.value, (row, i) => {
-        return openBlock(), createElementBlock("tr", {
-          key: i
-        }, [(openBlock(true), createElementBlock(Fragment, null, renderList(row, (node, j) => {
-          return openBlock(), createElementBlock("td", {
-            key: j,
-            colspan: node.reverseLevel === 1 ? maxLevel.value - node.level + 1 : 1,
-            rowspan: node.leafCount
-          }, [node.reverseLevel !== 1 || !_ctx.mergeLast ? (openBlock(), createElementBlock("div", {
-            key: 0,
-            class: normalizeClass(`${unref(prefixCls)}-node`)
-          }, [_ctx.showCheckbox ? (openBlock(), createBlock(_component_el_checkbox, {
-            key: 0,
-            disabled: getDisabled(node.data),
-            "model-value": node.checkedStatus === "checked",
-            indeterminate: node.checkedStatus === "indeterminate",
-            onChange: value => onCheckChange(node, !!value)
-          }, {
-            default: withCtx(() => [createElementVNode("span", {
-              class: normalizeClass(getNodeClass(node.data))
-            }, [renderSlot(_ctx.$slots, "node", {}, () => [createTextVNode(toDisplayString(node.data[propNames.value.label]), 1
-            /* TEXT */)])], 2
-            /* CLASS */)]),
-            _: 2
-            /* DYNAMIC */
-          }, 1032, ["disabled", "model-value", "indeterminate", "onChange"])) : (openBlock(), createElementBlock("span", {
-            key: 1,
-            class: normalizeClass(getNodeClass(node.data))
-          }, [renderSlot(_ctx.$slots, "node", {}, () => [createTextVNode(toDisplayString(node.data[propNames.value.label]), 1
-          /* TEXT */)])], 2
-          /* CLASS */))], 2
-          /* CLASS */)) : (openBlock(), createElementBlock("div", _hoisted_5, [(openBlock(true), createElementBlock(Fragment, null, renderList(node.parent.children, (_node, k) => {
-            return openBlock(), createElementBlock("div", {
-              key: k,
-              class: normalizeClass(`${unref(prefixCls)}-node`)
-            }, [_ctx.showCheckbox ? (openBlock(), createBlock(_component_el_checkbox, {
-              key: 0,
-              disabled: getDisabled(node.data),
-              "model-value": _node.checkedStatus === "checked",
-              indeterminate: _node.checkedStatus === "indeterminate",
-              onChange: value => onCheckChange(_node, !!value)
-            }, {
-              default: withCtx(() => [renderSlot(_ctx.$slots, "node", {}, () => [createElementVNode("span", {
-                class: normalizeClass(getNodeClass(_node.data))
-              }, toDisplayString(_node.data[propNames.value.label]), 3
-              /* TEXT, CLASS */)])]),
-              _: 2
-              /* DYNAMIC */
-            }, 1032, ["disabled", "model-value", "indeterminate", "onChange"])) : renderSlot(_ctx.$slots, "node", {
-              key: 1
-            }, () => [createElementVNode("span", {
-              class: normalizeClass(getNodeClass(_node.data))
-            }, toDisplayString(_node.data[propNames.value.label]), 3
-            /* TEXT, CLASS */)])], 2
-            /* CLASS */);
-          }), 128
-          /* KEYED_FRAGMENT */))]))], 8, _hoisted_4);
-        }), 128
-        /* KEYED_FRAGMENT */))]);
-      }), 128
-      /* KEYED_FRAGMENT */))])]))], 6
-      /* CLASS, STYLE */);
-    };
-  }
-});
-
-export { stdin_default as default };