@xn-lib/component 0.0.20 → 0.0.22

package/dist/types/cascader/CascaderMenu.vue.d.ts

@@ -0,0 +1,45 @@
+import type { TreeNode } from './types';
+interface Props {
+    show: boolean;
+    menuModel: TreeNode[][];
+    onFocus: (e: FocusEvent) => void;
+    onBlur: (e: FocusEvent) => void;
+    onKeydown: (e: KeyboardEvent) => void;
+    onMousedown: (e: MouseEvent) => void;
+    getColumnStyle?: (detail: {
+        level: number;
+    }) => string | Record<string, any>;
+    virtualScroll?: boolean;
+    optionHeight?: number;
+}
+declare var __VLS_20: {
+    option: import("./types").CascaderOption;
+    checked: any;
+}, __VLS_36: {
+    option: import("./types").CascaderOption;
+    checked: any;
+}, __VLS_38: {}, __VLS_45: {};
+type __VLS_Slots = {} & {
+    label?: (props: typeof __VLS_20) => any;
+} & {
+    label?: (props: typeof __VLS_36) => any;
+} & {
+    empty?: (props: typeof __VLS_38) => any;
+} & {
+    action?: (props: typeof __VLS_45) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<Props, {
+    scroll: (depth: number, index: number, elSize: number) => void;
+    showErrorMessage: (label: string) => void;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<Props> & Readonly<{}>, {
+    virtualScroll: boolean;
+    optionHeight: number;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/types/cascader/CascaderOption.vue.d.ts

@@ -0,0 +1,20 @@
+import type { TreeNode } from './types';
+interface Props {
+    tmNode: TreeNode;
+}
+declare var __VLS_9: {
+    option: import("./types").CascaderOption;
+    checked: any;
+};
+type __VLS_Slots = {} & {
+    label?: (props: typeof __VLS_9) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/types/cascader/CascaderSelectMenu.vue.d.ts

@@ -0,0 +1,38 @@
+import type { TreeNode, CascaderValue, Filter } from './types';
+interface Props {
+    show: boolean;
+    pattern: string;
+    multiple: boolean;
+    tmNodes: TreeNode[];
+    filter?: Filter;
+    labelField: string;
+    separator: string;
+    value: CascaderValue | null;
+    virtualScroll?: boolean;
+    optionHeight?: number;
+}
+declare function prev(): void;
+declare function next(): void;
+declare function enter(): boolean;
+declare var __VLS_31: {}, __VLS_69: {};
+type __VLS_Slots = {} & {
+    'not-found'?: (props: typeof __VLS_31) => any;
+} & {
+    'not-found'?: (props: typeof __VLS_69) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<Props, {
+    prev: typeof prev;
+    next: typeof next;
+    enter: typeof enter;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<Props> & Readonly<{}>, {
+    virtualScroll: boolean;
+    optionHeight: number;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/types/cascader/index.d.ts

@@ -0,0 +1,6 @@
+import type { Plugin } from 'vue';
+import type { CascaderInst } from './types';
+import CascaderComponent from './index.vue';
+declare const Cascader: typeof CascaderComponent & Plugin;
+export default Cascader;
+export type { CascaderInst as XnCascaderInstance };

package/dist/types/cascader/index.vue.d.ts

@@ -0,0 +1,90 @@
+import type { CascaderOption, CascaderValue, ExpandTrigger, CheckStrategy, Filter, OnLoad, CascaderInst } from './types';
+interface Props {
+    modelValue?: CascaderValue | null;
+    options?: CascaderOption[];
+    placeholder?: string;
+    disabled?: boolean;
+    clearable?: boolean;
+    filterable?: boolean;
+    multiple?: boolean;
+    size?: 'large' | 'default' | 'small';
+    expandTrigger?: ExpandTrigger;
+    separator?: string;
+    showPath?: boolean;
+    cascade?: boolean;
+    checkStrategy?: CheckStrategy;
+    remote?: boolean;
+    onLoad?: OnLoad;
+    filter?: Filter;
+    valueField?: string;
+    labelField?: string;
+    childrenField?: string;
+    disabledField?: string;
+    maxTagCount?: number;
+    popperClass?: string;
+    getColumnStyle?: (detail: {
+        level: number;
+    }) => string | Record<string, any>;
+    clearFilterAfterSelect?: boolean;
+    virtualScroll?: boolean;
+    optionHeight?: number;
+    showCheckbox?: boolean;
+    emitPath?: boolean;
+}
+declare var __VLS_27: {}, __VLS_38: {
+    option: CascaderOption;
+    checked: any;
+}, __VLS_41: {}, __VLS_44: {};
+type __VLS_Slots = {} & {
+    'not-found'?: (props: typeof __VLS_27) => any;
+} & {
+    label?: (props: typeof __VLS_38) => any;
+} & {
+    empty?: (props: typeof __VLS_41) => any;
+} & {
+    action?: (props: typeof __VLS_44) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<Props, CascaderInst, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:modelValue": (value: CascaderValue | null) => any;
+    change: (value: CascaderValue | null, option: CascaderOption | (CascaderOption | null)[] | null, path: CascaderOption[] | (CascaderOption[] | null)[] | null) => any;
+    blur: (e: FocusEvent) => any;
+    focus: (e: FocusEvent) => any;
+}, string, import("vue").PublicProps, Readonly<Props> & Readonly<{
+    "onUpdate:modelValue"?: ((value: CascaderValue | null) => any) | undefined;
+    onChange?: ((value: CascaderValue | null, option: CascaderOption | (CascaderOption | null)[] | null, path: CascaderOption[] | (CascaderOption[] | null)[] | null) => any) | undefined;
+    onBlur?: ((e: FocusEvent) => any) | undefined;
+    onFocus?: ((e: FocusEvent) => any) | undefined;
+}>, {
+    disabled: boolean;
+    modelValue: CascaderValue | null;
+    size: "large" | "default" | "small";
+    showCheckbox: boolean;
+    placeholder: string;
+    virtualScroll: boolean;
+    optionHeight: number;
+    multiple: boolean;
+    labelField: string;
+    separator: string;
+    options: CascaderOption[];
+    clearable: boolean;
+    filterable: boolean;
+    expandTrigger: ExpandTrigger;
+    showPath: boolean;
+    cascade: boolean;
+    checkStrategy: CheckStrategy;
+    remote: boolean;
+    valueField: string;
+    childrenField: string;
+    disabledField: string;
+    maxTagCount: number;
+    clearFilterAfterSelect: boolean;
+    emitPath: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/types/cascader/props.d.ts

@@ -0,0 +1,119 @@
+import type { ExtractPropTypes, PropType } from 'vue';
+import type { CascaderOption, CascaderValue, ExpandTrigger, CheckStrategy, Filter, OnLoad } from './types';
+export declare const cascaderProps: {
+    readonly modelValue: {
+        readonly type: PropType<CascaderValue | null>;
+        readonly default: null;
+    };
+    readonly options: {
+        readonly type: PropType<CascaderOption[]>;
+        readonly default: () => never[];
+    };
+    readonly placeholder: {
+        readonly type: StringConstructor;
+        readonly default: "请选择";
+    };
+    readonly disabled: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
+    };
+    readonly clearable: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
+    };
+    readonly filterable: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
+    };
+    readonly multiple: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
+    };
+    readonly size: {
+        readonly type: PropType<"large" | "default" | "small">;
+        readonly default: "default";
+    };
+    readonly expandTrigger: {
+        readonly type: PropType<ExpandTrigger>;
+        readonly default: "click";
+    };
+    readonly separator: {
+        readonly type: StringConstructor;
+        readonly default: " / ";
+    };
+    readonly showPath: {
+        readonly type: BooleanConstructor;
+        readonly default: true;
+    };
+    readonly cascade: {
+        readonly type: BooleanConstructor;
+        readonly default: true;
+    };
+    readonly checkStrategy: {
+        readonly type: PropType<CheckStrategy>;
+        readonly default: "all";
+    };
+    readonly remote: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
+    };
+    readonly onLoad: {
+        readonly type: PropType<OnLoad>;
+        readonly default: undefined;
+    };
+    readonly filter: {
+        readonly type: PropType<Filter>;
+        readonly default: undefined;
+    };
+    readonly valueField: {
+        readonly type: StringConstructor;
+        readonly default: "value";
+    };
+    readonly labelField: {
+        readonly type: StringConstructor;
+        readonly default: "label";
+    };
+    readonly childrenField: {
+        readonly type: StringConstructor;
+        readonly default: "children";
+    };
+    readonly disabledField: {
+        readonly type: StringConstructor;
+        readonly default: "disabled";
+    };
+    readonly maxTagCount: {
+        readonly type: NumberConstructor;
+        readonly default: 1;
+    };
+    readonly popperClass: {
+        readonly type: StringConstructor;
+        readonly default: "";
+    };
+    readonly getColumnStyle: {
+        readonly type: PropType<(detail: {
+            level: number;
+        }) => string | Record<string, any>>;
+        readonly default: undefined;
+    };
+    readonly clearFilterAfterSelect: {
+        readonly type: BooleanConstructor;
+        readonly default: true;
+    };
+    readonly virtualScroll: {
+        readonly type: BooleanConstructor;
+        readonly default: true;
+    };
+    readonly optionHeight: {
+        readonly type: NumberConstructor;
+        readonly default: 34;
+    };
+    readonly showCheckbox: {
+        readonly type: BooleanConstructor;
+        readonly default: undefined;
+    };
+    readonly emitPath: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
+    };
+};
+export type CascaderProps = ExtractPropTypes<typeof cascaderProps>;

package/dist/types/cascader/types.d.ts

@@ -0,0 +1,69 @@
+export type ValueAtom = string | number;
+export type CascaderValue = ValueAtom | ValueAtom[] | ValueAtom[][];
+export type Key = ValueAtom;
+export interface CascaderOption {
+    label?: string;
+    value?: ValueAtom;
+    disabled?: boolean;
+    children?: CascaderOption[];
+    [key: string]: unknown;
+}
+export type ExpandTrigger = 'hover' | 'click';
+export type CheckStrategy = 'all' | 'parent' | 'child';
+export type Filter = (pattern: string, option: CascaderOption, path: CascaderOption[]) => boolean;
+export type OnLoad = (option: CascaderOption) => Promise<void>;
+export type OnUpdateValue = (value: CascaderValue | null, option: CascaderOption | null | Array<CascaderOption | null>, path: Array<CascaderOption[] | null> | CascaderOption[] | null) => void;
+export interface TreeNode {
+    key: Key;
+    rawNode: CascaderOption;
+    level: number;
+    index: number;
+    isLeaf: boolean;
+    isGroup: boolean;
+    ignored: boolean;
+    disabled: boolean;
+    shallowLoaded: boolean;
+    parent: TreeNode | null;
+    children?: TreeNode[];
+    siblings: TreeNode[];
+}
+export interface CascaderInst {
+    focus: () => void;
+    blur: () => void;
+    getCheckedData: () => {
+        keys: Key[];
+        options: Array<CascaderOption | null>;
+    };
+    getIndeterminateData: () => {
+        keys: Key[];
+        options: Array<CascaderOption | null>;
+    };
+}
+export interface CascaderContext {
+    mergedValue: CascaderValue | null;
+    checkedKeys: Key[];
+    indeterminateKeys: Key[];
+    hoverKeyPath: Key[];
+    keyboardKey: Key | null;
+    hoverKey: Key | null;
+    loadingKeySet: Set<Key>;
+    multiple: boolean;
+    cascade: boolean;
+    checkStrategy: CheckStrategy;
+    expandTrigger: ExpandTrigger;
+    remote: boolean;
+    showCheckbox: boolean;
+    labelField: string;
+    valueField: string;
+    childrenField: string;
+    disabledField: string;
+    onLoad?: OnLoad;
+    updateHoverKey: (key: Key | null) => void;
+    updateKeyboardKey: (key: Key | null) => void;
+    addLoadingKey: (key: Key) => void;
+    deleteLoadingKey: (key: Key) => void;
+    doCheck: (key: Key) => boolean;
+    doUncheck: (key: Key) => void;
+    closeMenu: (returnFocus?: boolean) => void;
+    clearPattern: () => void;
+}

package/dist/types/cascader/utils.d.ts

@@ -0,0 +1,53 @@
+import type { CascaderOption, TreeNode, Key, CheckStrategy } from './types';
+export declare function createTreeMate(options: CascaderOption[], config: {
+    getKey: (node: CascaderOption) => Key;
+    getChildren: (node: CascaderOption) => CascaderOption[] | undefined;
+    getDisabled: (node: CascaderOption) => boolean;
+}): {
+    treeNodes: TreeNode[];
+    getNode: (key: Key) => TreeNode | null;
+    getPath: (key: Key | null) => {
+        treeNodePath: TreeNode[];
+        keyPath: Key[];
+        treeNode: TreeNode | null;
+    };
+    getCheckedKeys: (keys: Key[], options: {
+        cascade: boolean;
+        checkStrategy: CheckStrategy;
+        allowNotLoaded?: boolean;
+    }) => {
+        checkedKeys: Key[];
+        indeterminateKeys: Key[];
+    };
+    check: (key: Key, checkedKeys: Key[], options: {
+        cascade: boolean;
+        checkStrategy: CheckStrategy;
+        allowNotLoaded?: boolean;
+    }) => {
+        checkedKeys: Key[];
+    };
+    uncheck: (key: Key, checkedKeys: Key[], options: {
+        cascade: boolean;
+        checkStrategy: CheckStrategy;
+        allowNotLoaded?: boolean;
+    }) => {
+        checkedKeys: Key[];
+    };
+    getPrev: (key: Key, options: {
+        loop: boolean;
+    }) => TreeNode | null;
+    getNext: (key: Key, options: {
+        loop: boolean;
+    }) => TreeNode | null;
+    getChild: (key: Key) => TreeNode | null;
+    getParent: (key: Key) => TreeNode | null;
+    getFirstAvailableNode: () => TreeNode | null;
+};
+export declare function getRawNodePath(tmNodes: TreeNode[] | undefined): CascaderOption[] | null;
+export declare function getPathLabel(node: TreeNode | null, separator: string, labelField: string): string;
+export declare function createSelectOptions(tmNodes: TreeNode[], checkStrategyIsChild: boolean, labelField: string, separator: string): Array<{
+    label: string;
+    value: Key;
+    rawNode: CascaderOption;
+    path: CascaderOption[];
+}>;

package/dist/types/index.d.ts

@@ -0,0 +1,13 @@
+import type { Plugin } from 'vue';
+import type { Component } from 'vue';
+import XnCascader from './cascader/index';
+import XnTag from './tag/index';
+export { XnCascader, XnTag };
+export declare const components: Record<string, Component>;
+export type { CascaderProps } from './cascader/props';
+export type { TagProps } from './tag/props';
+export * from './types';
+export * from './cascader/types';
+export * from './tag/types';
+declare const plugin: Plugin;
+export default plugin;

package/dist/types/tag/index.d.ts

@@ -0,0 +1,6 @@
+import type { Plugin } from 'vue';
+import type { TagInst } from './types.ts';
+import TagComponent from './index.vue';
+declare const Tag: typeof TagComponent & Plugin;
+export default Tag;
+export type { TagInst as XnTagInstance };

package/dist/types/tag/index.vue.d.ts

@@ -0,0 +1,123 @@
+declare var __VLS_1: {}, __VLS_3: {}, __VLS_5: {};
+type __VLS_Slots = {} & {
+    prefix?: (props: typeof __VLS_1) => any;
+} & {
+    default?: (props: typeof __VLS_3) => any;
+} & {
+    suffix?: (props: typeof __VLS_5) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    readonly type: {
+        readonly type: import("vue").PropType<import("..").DefaultSize>;
+        readonly default: "default";
+    };
+    readonly color: {
+        readonly type: StringConstructor;
+        readonly default: undefined;
+    };
+    readonly bgColor: {
+        readonly type: StringConstructor;
+        readonly default: undefined;
+    };
+    readonly size: {
+        readonly type: import("vue").PropType<import("..").DefaultType>;
+        readonly default: "default";
+    };
+    readonly dot: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
+    };
+    readonly dotColor: {
+        readonly type: StringConstructor;
+        readonly default: undefined;
+    };
+    readonly icon: {
+        readonly type: StringConstructor;
+        readonly default: undefined;
+    };
+    readonly plain: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
+    };
+    readonly round: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
+    };
+    readonly closable: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
+    };
+    readonly border: {
+        readonly type: BooleanConstructor;
+        readonly default: true;
+    };
+}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    close: () => any;
+}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    readonly type: {
+        readonly type: import("vue").PropType<import("..").DefaultSize>;
+        readonly default: "default";
+    };
+    readonly color: {
+        readonly type: StringConstructor;
+        readonly default: undefined;
+    };
+    readonly bgColor: {
+        readonly type: StringConstructor;
+        readonly default: undefined;
+    };
+    readonly size: {
+        readonly type: import("vue").PropType<import("..").DefaultType>;
+        readonly default: "default";
+    };
+    readonly dot: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
+    };
+    readonly dotColor: {
+        readonly type: StringConstructor;
+        readonly default: undefined;
+    };
+    readonly icon: {
+        readonly type: StringConstructor;
+        readonly default: undefined;
+    };
+    readonly plain: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
+    };
+    readonly round: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
+    };
+    readonly closable: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
+    };
+    readonly border: {
+        readonly type: BooleanConstructor;
+        readonly default: true;
+    };
+}>> & Readonly<{
+    onClose?: (() => any) | undefined;
+}>, {
+    readonly border: boolean;
+    readonly size: import("..").DefaultType;
+    readonly type: import("..").DefaultSize;
+    readonly color: string;
+    readonly bgColor: string;
+    readonly dot: boolean;
+    readonly dotColor: string;
+    readonly icon: string;
+    readonly plain: boolean;
+    readonly round: boolean;
+    readonly closable: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/types/tag/props.d.ts

@@ -0,0 +1,49 @@
+import type { PropType, ExtractPropTypes } from 'vue';
+import type { DefaultSize, DefaultType } from '../types';
+export declare const tagProps: {
+    readonly type: {
+        readonly type: PropType<DefaultSize>;
+        readonly default: "default";
+    };
+    readonly color: {
+        readonly type: StringConstructor;
+        readonly default: undefined;
+    };
+    readonly bgColor: {
+        readonly type: StringConstructor;
+        readonly default: undefined;
+    };
+    readonly size: {
+        readonly type: PropType<DefaultType>;
+        readonly default: "default";
+    };
+    readonly dot: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
+    };
+    readonly dotColor: {
+        readonly type: StringConstructor;
+        readonly default: undefined;
+    };
+    readonly icon: {
+        readonly type: StringConstructor;
+        readonly default: undefined;
+    };
+    readonly plain: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
+    };
+    readonly round: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
+    };
+    readonly closable: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
+    };
+    readonly border: {
+        readonly type: BooleanConstructor;
+        readonly default: true;
+    };
+};
+export type TagProps = Readonly<ExtractPropTypes<typeof tagProps>>;

package/dist/types/tag/types.d.ts

@@ -0,0 +1,17 @@
+import type { DefaultSize, DefaultType } from '../types';
+export interface TagProps {
+    type?: DefaultType;
+    color?: string;
+    bgColor?: string;
+    size?: DefaultSize;
+    dot?: boolean;
+    dotColor?: string;
+    icon?: string;
+    plain?: boolean;
+    round?: boolean;
+    closable?: boolean;
+    border?: boolean;
+}
+export interface TagInst {
+    close: () => void;
+}

package/dist/types/types/index.d.ts

@@ -0,0 +1,2 @@
+export type DefaultType = 'success' | 'info' | 'warning' | 'danger' | 'primary' | 'default';
+export type DefaultSize = 'small' | 'default' | 'large';

package/package.json

@@ -1,7 +1,7 @@
 {
   "private": false,
   "name": "@xn-lib/component",
-  "version": "0.0.20",
+  "version": "0.0.22",
   "description": "",
   "main": "./dist/index.umd.js",
   "module": "./dist/index.mjs",
@@ -27,7 +27,7 @@
   ],
   "repository": {
     "type": "git",
-    "url": "https://github.com/zjwmmx/mmx-ui"
+    "url": "http://git.wonchuan.top/frontend/xiaoniu/xiaoniu-package"
   },
   "keywords": [],
   "license": "ISC",