@vue-ui-kit/ant 1.9.4 → 2.0.0

package/dist/index.d.ts

@@ -1,6 +1,8 @@
 import { App } from 'vue';
 import { default as PForm } from './packages/components/PForm.vue';
 import { default as PGrid } from './packages/components/PGrid.vue';
+import { default as PCanvasTable } from './packages/components/PCanvasTable.vue';
+import { default as PCanvasGrid } from './packages/components/PCanvasGrid.vue';
 import { default as PFormGroup } from './packages/components/PFormGroup.vue';
 import { default as PGroupBlock } from './packages/components/PGroupBlock.vue';
 import { default as PromisePicker } from './packages/components/PromisePicker.vue';
@@ -10,15 +12,12 @@ import { setUIKitConfig, getUIKitConfig, resetUIKitConfig, UIKitConfig } from '.
 declare function setup(config?: Partial<UIKitConfig>): void;
 declare const _default: {
     install(app: App): void;
-    addFormatter: (formatter: Record<string, (a: import('./Declarations/antProxy').CellFuncArg, ...args: any[]) => any>) => void;
-    addRender: (name: string, { renderItemContent, renderDefault, }: {
-        renderItemContent?: (options: import('./declarations/antProxy').RenderOptions, params: import('./declarations/antProxy').RenderFormParams, defaultHandler: Recordable) => any;
-        renderDefault?: (options: import('./declarations/antProxy').RenderOptions, params: import('./declarations/antProxy').RenderTableParams, defaultHandler: Recordable) => any;
-    }) => void;
+    addFormatter: (formatter: Record<string, (a: import('./declarations/antProxy').CellFuncArg, ...args: any[]) => any>) => void;
+    addRender: (name: string, { renderItemContent, renderDefault, renderEdit }: import('./packages/store/renderStore').RenderWorkshop) => void;
     setup: typeof setup;
 };
 export default _default;
 export * from './declarations/antProxy';
 export * from './packages/utils/core';
 export { setup, setUIKitConfig, getUIKitConfig, resetUIKitConfig, type UIKitConfig };
-export { PForm, PGrid, PFormGroup, PGroupBlock, PromisePicker, addFormatter, addRender };
+export { PForm, PGrid, PCanvasTable, PCanvasGrid, PFormGroup, PGroupBlock, PromisePicker, addFormatter, addRender, };

package/dist/packages/components/PCanvasGrid.vue.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import('vue').DefineComponent<{}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, HTMLDivElement>;
+export default _default;

package/dist/packages/components/PCanvasTable.vue.d.ts

@@ -0,0 +1,134 @@
+import { default as Cell } from 'e-virt-table/dist/lib/Cell';
+import { default as EVirtTable, Column as EVirtColumn, FormatterMethod } from 'e-virt-table';
+import { CanvasTableProps } from '../../declarations/antProxy';
+declare const _default: <T extends Recordable = Recordable, B extends Recordable = Recordable>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: __VLS_PrettifyLocal<Pick<Partial<{}> & Omit<{
+        readonly onChange?: ((value: any[]) => any) | undefined;
+        readonly onReady?: ((value: EVirtTable) => any) | undefined;
+    } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, never>, "onChange" | "onReady"> & CanvasTableProps<T, B> & Partial<{}>> & import('vue').PublicProps;
+    expose(exposed: import('vue').ShallowUnwrapRef<{}>): void;
+    attrs: any;
+    slots: Partial<Record<string, (_: {
+        cell: Cell | import('e-virt-table/dist/lib/CellHeader').default;
+        formatter?: FormatterMethod;
+        formatterFooter?: FormatterMethod;
+        hoverIconName?: string;
+        operation: boolean;
+        align: import('e-virt-table').Align;
+        verticalAlign: import('e-virt-table').VerticalAlign;
+        fixed?: import('e-virt-table').Fixed;
+        type: import('e-virt-table').Type | "";
+        editorType: string;
+        editorProps: any;
+        cellType: import('e-virt-table').CellType;
+        level: number;
+        colspan: number;
+        rowspan: number;
+        mergeRow: boolean;
+        mergeCol: boolean;
+        relationRowKeys: string[];
+        relationColKeys: string[];
+        key: string;
+        column: EVirtColumn;
+        rowIndex: number;
+        colIndex: number;
+        rowKey: string;
+        row: any;
+        value: any;
+        render: import('e-virt-table').Render;
+        renderFooter: import('e-virt-table').Render;
+        style: any;
+        rules: import('e-virt-table/dist/lib/Validator').Rules | import('e-virt-table/dist/lib/Validator').Rule;
+        message: string;
+        text: string;
+        displayText: string;
+        visibleWidth: number;
+        visibleHeight: number;
+        isHasChanged: boolean;
+        drawX: number;
+        drawY: number;
+        drawCellBgColor: string;
+        drawCellSkyBgColor: string;
+        drawTextColor: string;
+        drawTextX: number;
+        drawTextY: number;
+        drawImageX: number;
+        drawImageY: number;
+        drawImageWidth: number;
+        drawImageHeight: number;
+        drawImageName: string;
+        drawImageSource?: HTMLImageElement;
+        ellipsis: boolean;
+        rowExpand: boolean;
+        rowHasChildren: boolean;
+        overflowTooltipShow: boolean;
+        selectorCellValueType: import('e-virt-table').SelectorCellValueType;
+        overflowTooltipMaxWidth: number;
+        overflowTooltipPlacement: import('e-virt-table').OverflowTooltipPlacement;
+        ctx: import('e-virt-table/dist/lib/Context').default;
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    } | {
+        cell: Cell | import('e-virt-table/dist/lib/CellHeader').default;
+        align: import('e-virt-table').Align;
+        verticalAlign: import('e-virt-table').VerticalAlign;
+        fixed?: import('e-virt-table').Fixed;
+        minWidth?: number;
+        maxWidth?: number;
+        widthFillDisable: boolean;
+        type: import('e-virt-table').Type | "";
+        operation: boolean;
+        editorType: string;
+        level: number;
+        text: string;
+        displayText: string;
+        colspan: number;
+        rowspan: number;
+        row: any;
+        key: string;
+        required: boolean;
+        readonly: boolean;
+        ellipsis: boolean;
+        overflowTooltipShow: boolean;
+        children: EVirtColumn[];
+        column: EVirtColumn;
+        colIndex: number;
+        rowKey: string;
+        rules?: import('e-virt-table/dist/lib/Validator').Rules | import('e-virt-table/dist/lib/Validator').Rule;
+        hasChildren: boolean;
+        render: import('e-virt-table').Render;
+        style: Partial<CSSStyleDeclaration>;
+        drawX: number;
+        drawY: number;
+        visibleWidth: number;
+        visibleHeight: number;
+        drawCellBgColor: string;
+        drawTextColor: string;
+        drawImageX: number;
+        drawImageY: number;
+        drawImageWidth: number;
+        drawImageHeight: number;
+        drawImageName: string;
+        drawImageSource: HTMLImageElement | undefined;
+        ctx: import('e-virt-table/dist/lib/Context').default;
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+        cellType: import('e-virt-table').CellType;
+    }) => any>> & {
+        empty?(_: {}): any;
+    };
+    emit: {
+        (e: "change", value: any[]): void;
+        (e: "ready", value: EVirtTable): void;
+    };
+}>) => import('vue').VNode & {
+    __ctx?: Awaited<typeof __VLS_setup>;
+};
+export default _default;
+type __VLS_PrettifyLocal<T> = {
+    [K in keyof T]: T[K];
+} & {};

package/dist/packages/components/PForm.vue.d.ts

@@ -1,28 +1,22 @@
 import { PFormProps } from '../../declarations/antProxy';
-declare const _default: <F = Recordable<any>>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_Prettify<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
-    props: __VLS_Prettify<Pick<Partial<{}> & Omit<{
+declare const _default: <F extends Recordable = Recordable>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: __VLS_PrettifyLocal<Pick<Partial<{}> & Omit<{
         readonly onReset?: ((...args: any[]) => any) | undefined;
         readonly onApply?: ((...args: any[]) => any) | undefined;
-    } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & Readonly<{}> & Readonly<{
-        onReset?: ((...args: any[]) => any) | undefined;
-        onApply?: ((...args: any[]) => any) | undefined;
-    }>, never>, "onReset" | "onApply"> & (PFormProps<F> & {
+    } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, never>, "onReset" | "onApply"> & (PFormProps<F> & {
         data: F;
-    })> & import('vue').PublicProps;
+    }) & Partial<{}>> & import('vue').PublicProps;
     expose(exposed: import('vue').ShallowUnwrapRef<{
         reset: () => void;
         $form: import('vue').ComputedRef<any>;
     }>): void;
     attrs: any;
-    slots: ReturnType<() => {}>;
-    emit: ((event: "reset" | "apply", ...args: any[]) => void) & {};
-}>) => import('vue').VNode<import('vue').RendererNode, import('vue').RendererElement, {
-    [key: string]: any;
-}> & {
+    slots: {};
+    emit: (event: "reset" | "apply", ...args: any[]) => void;
+}>) => import('vue').VNode & {
     __ctx?: Awaited<typeof __VLS_setup>;
 };
 export default _default;
-
-type __VLS_Prettify<T> = {
+type __VLS_PrettifyLocal<T> = {
     [K in keyof T]: T[K];
 } & {};

package/dist/packages/components/PFormCol.vue.d.ts

@@ -1,28 +1,23 @@
 import { PFormItemProps } from '../../declarations/antProxy';
-declare const _default: <T extends Recordable = Recordable<any>>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_Prettify<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
-    props: __VLS_Prettify<Pick<Partial<{}> & Omit<{
+declare const _default: <T extends Recordable = Recordable>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: __VLS_PrettifyLocal<Pick<Partial<{}> & Omit<{
         readonly onTrigger?: ((cusFields?: string | string[] | undefined) => any) | undefined;
         readonly onReset?: (() => any) | undefined;
-    } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & Readonly<{}> & Readonly<{
-        onTrigger?: ((cusFields?: string | string[] | undefined) => any) | undefined;
-        onReset?: (() => any) | undefined;
-    }>, never>, "onReset" | "onTrigger"> & {
+    } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, never>, "onReset" | "onTrigger"> & {
         item: PFormItemProps<T>;
         formData: T;
-    }> & import('vue').PublicProps;
+    } & Partial<{}>> & import('vue').PublicProps;
     expose(exposed: import('vue').ShallowUnwrapRef<{}>): void;
     attrs: any;
-    slots: ReturnType<() => {}>;
+    slots: {};
     emit: {
         (e: "trigger", cusFields?: string | string[]): void;
         (e: "reset"): void;
-    } & {};
-}>) => import('vue').VNode<import('vue').RendererNode, import('vue').RendererElement, {
-    [key: string]: any;
-}> & {
+    };
+}>) => import('vue').VNode & {
     __ctx?: Awaited<typeof __VLS_setup>;
 };
 export default _default;
-type __VLS_Prettify<T> = {
+type __VLS_PrettifyLocal<T> = {
     [K in keyof T]: T[K];
 } & {};

package/dist/packages/components/PFormGroup.vue.d.ts

@@ -1,12 +1,14 @@
 import { PFormGroupProps } from '../../declarations/antProxy';
-declare const _default: <F = Recordable<any>>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_Prettify<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
-    props: __VLS_Prettify<Pick<Partial<{}> & Omit<{
-        readonly "onUpdate:modelValue"?: ((modelValue: any) => any) | undefined;
-    } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & Readonly<{}> & Readonly<{
-        "onUpdate:modelValue"?: ((modelValue: any) => any) | undefined;
-    }>, never>, "onUpdate:modelValue"> & ({
-        modelValue?: any;
-    } & PFormGroupProps<F>)> & import('vue').PublicProps;
+declare const _default: <F extends Recordable = Recordable>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: __VLS_PrettifyLocal<Pick<Partial<{}> & Omit<{
+        readonly "onUpdate:modelValue"?: ((value: Partial<F & {
+            __index: number;
+        }>[]) => any) | undefined;
+    } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, never>, "onUpdate:modelValue"> & ({
+        modelValue?: Partial<F & {
+            __index: number;
+        }>[];
+    } & PFormGroupProps<F>) & Partial<{}>> & import('vue').PublicProps;
     expose(exposed: import('vue').ShallowUnwrapRef<{
         activeKey: import('vue').ComputedRef<number>;
         setActiveKey: (key: number) => void;
@@ -15,18 +17,16 @@ declare const _default: <F = Recordable<any>>(__VLS_props: NonNullable<Awaited<t
         validateFields: (__index: number, fields: string[], ignoreTabError?: boolean) => Promise<void>;
     }>): void;
     attrs: any;
-    slots: ReturnType<() => {
+    slots: {
         rightExtra?(_: {}): any;
-    }>;
-    emit: {
-        'update:modelValue': [modelValue: any];
     };
-}>) => import('vue').VNode<import('vue').RendererNode, import('vue').RendererElement, {
-    [key: string]: any;
-}> & {
+    emit: (evt: "update:modelValue", value: Partial<F & {
+        __index: number;
+    }>[]) => void;
+}>) => import('vue').VNode & {
     __ctx?: Awaited<typeof __VLS_setup>;
 };
 export default _default;
-type __VLS_Prettify<T> = {
+type __VLS_PrettifyLocal<T> = {
     [K in keyof T]: T[K];
 } & {};

package/dist/packages/components/PGrid.vue.d.ts

@@ -1,6 +1,6 @@
 import { PGridProps } from '../../declarations/antProxy';
-declare const _default: <D = Recordable<any>, F = Recordable<any>>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_Prettify<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
-    props: __VLS_Prettify<Pick<Partial<{}> & Omit<{
+declare const _default: <D extends Recordable = Recordable, F extends Recordable = Recordable>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: __VLS_PrettifyLocal<Pick<Partial<{}> & Omit<{
         readonly onPick?: ((data: {
             row: D;
             field: string;
@@ -18,25 +18,7 @@ declare const _default: <D = Recordable<any>, F = Recordable<any>>(__VLS_props:
             records: D[];
         }) => any) | undefined;
         readonly onResetQuery?: (() => any) | undefined;
-    } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & Readonly<{}> & Readonly<{
-        onPick?: ((data: {
-            row: D;
-            field: string;
-        }) => any) | undefined;
-        onToolbarButtonClick?: ((data: {
-            data: D[];
-            code: string;
-            selectedKeys: Array<string | number>;
-            records: D[];
-        }) => any) | undefined;
-        onToolbarToolClick?: ((data: {
-            data: D[];
-            code: string;
-            selectedKeys: Array<string | number>;
-            records: D[];
-        }) => any) | undefined;
-        onResetQuery?: (() => any) | undefined;
-    }>, never>, "onPick" | "onToolbarButtonClick" | "onToolbarToolClick" | "onResetQuery"> & PGridProps<D, F>> & import('vue').PublicProps;
+    } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, never>, "onPick" | "onToolbarButtonClick" | "onToolbarToolClick" | "onResetQuery"> & PGridProps<D, F> & Partial<{}>> & import('vue').PublicProps;
     expose(exposed: import('vue').ShallowUnwrapRef<{
         commitProxy: {
             query: (this: any, ...args: any[]) => any;
@@ -54,7 +36,7 @@ declare const _default: <D = Recordable<any>, F = Recordable<any>>(__VLS_props:
         resizeTable: () => void;
     }>): void;
     attrs: any;
-    slots: ReturnType<() => {}>;
+    slots: {};
     emit: {
         (event: "toolbarButtonClick", data: {
             data: D[];
@@ -73,13 +55,11 @@ declare const _default: <D = Recordable<any>, F = Recordable<any>>(__VLS_props:
             field: string;
         }): void;
         (event: "resetQuery"): void;
-    } & {};
-}>) => import('vue').VNode<import('vue').RendererNode, import('vue').RendererElement, {
-    [key: string]: any;
-}> & {
+    };
+}>) => import('vue').VNode & {
     __ctx?: Awaited<typeof __VLS_setup>;
 };
 export default _default;
-type __VLS_Prettify<T> = {
+type __VLS_PrettifyLocal<T> = {
     [K in keyof T]: T[K];
 } & {};

package/dist/packages/components/PGroupBlock.vue.d.ts

@@ -1,18 +1,16 @@
 import { PBlockProps } from '../../declarations/antProxy';
-declare const _default: <F = Recordable<any>>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_Prettify<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
-    props: __VLS_Prettify<Pick<Partial<{}> & Omit<{} & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & Readonly<{}> & Readonly<{}>, never>, never> & PBlockProps<F>> & import('vue').PublicProps;
+declare const _default: <F extends Recordable = Recordable>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: __VLS_PrettifyLocal<Pick<Partial<{}> & Omit<{} & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, never>, never> & PBlockProps<F> & Partial<{}>> & import('vue').PublicProps;
     expose(exposed: import('vue').ShallowUnwrapRef<{
         $form: import('vue').ComputedRef<Recordable<any> | undefined>;
     }>): void;
     attrs: any;
-    slots: ReturnType<() => {}>;
+    slots: {};
     emit: {};
-}>) => import('vue').VNode<import('vue').RendererNode, import('vue').RendererElement, {
-    [key: string]: any;
-}> & {
+}>) => import('vue').VNode & {
     __ctx?: Awaited<typeof __VLS_setup>;
 };
 export default _default;
-type __VLS_Prettify<T> = {
+type __VLS_PrettifyLocal<T> = {
     [K in keyof T]: T[K];
 } & {};

package/dist/packages/components/PromisePicker.vue.d.ts

@@ -1,6 +1,6 @@
 import { PGridInstance, PromisePickerProps } from '../../declarations/antProxy';
-declare const _default: <D = Recordable<any>, F = Recordable<any>>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_Prettify<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
-    props: __VLS_Prettify<Pick<Partial<{}> & Omit<{} & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & Readonly<{}> & Readonly<{}>, never>, never> & PromisePickerProps<D, F>> & import('vue').PublicProps;
+declare const _default: <D extends Recordable = Recordable, F extends Recordable = Recordable>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: __VLS_PrettifyLocal<Pick<Partial<{}> & Omit<{} & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, never>, never> & PromisePickerProps<D, F> & Partial<{}>> & import('vue').PublicProps;
     expose(exposed: import('vue').ShallowUnwrapRef<{
         pick: () => Promise<D[] | {
             row: D;
@@ -14,14 +14,12 @@ declare const _default: <D = Recordable<any>, F = Recordable<any>>(__VLS_props:
         hide: () => void;
     }>): void;
     attrs: any;
-    slots: ReturnType<() => {}>;
+    slots: {};
     emit: {};
-}>) => import('vue').VNode<import('vue').RendererNode, import('vue').RendererElement, {
-    [key: string]: any;
-}> & {
+}>) => import('vue').VNode & {
     __ctx?: Awaited<typeof __VLS_setup>;
 };
 export default _default;
-type __VLS_Prettify<T> = {
+type __VLS_PrettifyLocal<T> = {
     [K in keyof T]: T[K];
 } & {};

package/dist/packages/components/RenderEditCell.d.ts

@@ -0,0 +1,10 @@
+declare const _default: import('vue').DefineSetupFnComponent<{
+    cellRender: any;
+    renderTableParams: any;
+}, "blur"[], {}, {
+    cellRender: any;
+    renderTableParams: any;
+} & {
+    onBlur?: ((...args: any[]) => any) | undefined;
+}, import('vue').PublicProps>;
+export default _default;

package/dist/packages/renders/TableInput.vue.d.ts

@@ -1,8 +1,7 @@
-import { PropType } from 'vue';
 import { TableProps } from 'ant-design-vue';
 import { ColumnProps } from '../../declarations/antProxy';
-declare const _default: <D = Recordable<any>>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_Prettify<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
-    props: __VLS_Prettify<Pick<Partial<{
+declare const _default: <D extends Recordable = Recordable>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: __VLS_PrettifyLocal<Pick<Partial<{
         tableConfig: TableProps<any>;
         modelValue: D[];
         editColumns: ColumnProps<Recordable<any>>[];
@@ -12,33 +11,15 @@ declare const _default: <D = Recordable<any>>(__VLS_props: NonNullable<Awaited<t
         readonly editColumns: ColumnProps<Recordable<any>>[];
         readonly onTrigger?: ((...args: any[]) => any) | undefined;
         readonly "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
-    } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & Readonly<import('vue').ExtractPropTypes<{
-        modelValue: {
-            type: PropType<D[]>;
-            default: () => never[];
-        };
-        tableConfig: {
-            type: PropType<TableProps>;
-            default: () => {};
-        };
-        editColumns: {
-            type: PropType<ColumnProps[]>;
-            default: () => never[];
-        };
-    }>> & Readonly<{
-        onTrigger?: ((...args: any[]) => any) | undefined;
-        "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
-    }>, "tableConfig" | "modelValue" | "editColumns">, "onTrigger" | "onUpdate:modelValue" | ("tableConfig" | "modelValue" | "editColumns")> & {}> & import('vue').PublicProps;
+    } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, "tableConfig" | "modelValue" | "editColumns">, "onTrigger" | "onUpdate:modelValue" | ("tableConfig" | "modelValue" | "editColumns")> & {} & Partial<{}>> & import('vue').PublicProps;
     expose(exposed: import('vue').ShallowUnwrapRef<{}>): void;
     attrs: any;
-    slots: ReturnType<() => {}>;
-    emit: ((event: "trigger" | "update:modelValue", ...args: any[]) => void) & {};
-}>) => import('vue').VNode<import('vue').RendererNode, import('vue').RendererElement, {
-    [key: string]: any;
-}> & {
+    slots: {};
+    emit: (event: "trigger" | "update:modelValue", ...args: any[]) => void;
+}>) => import('vue').VNode & {
     __ctx?: Awaited<typeof __VLS_setup>;
 };
 export default _default;
-type __VLS_Prettify<T> = {
+type __VLS_PrettifyLocal<T> = {
     [K in keyof T]: T[K];
 } & {};

package/dist/packages/store/renderStore.d.ts

@@ -1,64 +1,16 @@
 import { RenderFormParams, RenderOptions, RenderTableParams } from '../../declarations/antProxy';
-export declare const addRender: (name: string, { renderItemContent, renderDefault, }: {
+import { Ref } from 'vue';
+export interface RenderWorkshop {
     renderItemContent?: (options: RenderOptions, params: RenderFormParams, defaultHandler: Recordable) => any;
     renderDefault?: (options: RenderOptions, params: RenderTableParams, defaultHandler: Recordable) => any;
-}) => void;
+    renderEdit?: (model: Ref<any>, options: RenderOptions, params: RenderTableParams, emit?: (e: 'blur', value: any) => void) => any;
+}
+interface RenderFactory {
+    [key: string]: RenderWorkshop;
+}
+export declare const addRender: (name: string, { renderItemContent, renderDefault, renderEdit }: RenderWorkshop) => void;
 declare const _default: {
-    renders: {
-        $button: {
-            renderItemContent({ props, events }: RenderOptions, { data, field }: RenderFormParams, defaultHandler: {
-                [key: string]: (...args: any[]) => any;
-            }): import("vue/jsx-runtime").JSX.Element;
-            renderDefault({ props, events }: RenderOptions, { row, field }: RenderTableParams, defaultHandler: {
-                [key: string]: (...args: any[]) => any;
-            }): import("vue/jsx-runtime").JSX.Element;
-        };
-        $buttons: {
-            renderItemContent({ props, children }: RenderOptions, { data, field }: RenderFormParams, defaultHandler: {
-                [key: string]: (...args: any[]) => any;
-            }): import("vue/jsx-runtime").JSX.Element;
-            renderDefault({ props, children }: RenderOptions, { data, row, field }: RenderTableParams, defaultHandler: {
-                [key: string]: (...args: any[]) => any;
-            }): import("vue/jsx-runtime").JSX.Element;
-        };
-        ButtonTree: {
-            renderDefault({ children, props }: {
-                children?: never[] | undefined;
-                props?: Recordable<any> | undefined;
-            }, params: RenderTableParams): import("vue/jsx-runtime").JSX.Element;
-        };
-        $radio: {
-            renderItemContent({ props, events, options }: RenderOptions, { data, field }: RenderFormParams): import("vue/jsx-runtime").JSX.Element | null;
-            renderDefault({ props, options }: RenderOptions, { row, field }: RenderTableParams): import("vue/jsx-runtime").JSX.Element | null;
-        };
-        $autoComplete: {
-            renderItemContent({ props, events }: RenderOptions, { data, field }: RenderFormParams): import("vue/jsx-runtime").JSX.Element | null;
-        };
-        $switch: {
-            renderItemContent({ props, events }: RenderOptions, { data, field }: RenderFormParams): import("vue/jsx-runtime").JSX.Element | null;
-        };
-        $checkbox: {
-            renderItemContent({ props, options, events }: RenderOptions, { data, field }: RenderFormParams): import("vue/jsx-runtime").JSX.Element | null;
-            renderDefault({ props, options }: RenderOptions, { row, field }: RenderTableParams): import("vue/jsx-runtime").JSX.Element | null;
-        };
-        $paragraph: {
-            renderDefault({ props }: RenderOptions, { row, field }: RenderTableParams): import("vue/jsx-runtime").JSX.Element | null;
-        };
-        $tableInput: {
-            renderItemContent({ props, handleTrigger }: RenderOptions, { data, field }: RenderFormParams): import("vue/jsx-runtime").JSX.Element | null;
-        };
-        PercentInput: {
-            renderItemContent({ props, attrs }: RenderOptions, { data, field }: RenderFormParams): import("vue/jsx-runtime").JSX.Element | null;
-            renderDefault({ props, attrs }: RenderOptions, { row, field }: RenderTableParams): (import("vue/jsx-runtime").JSX.Element | null)[] | null;
-        };
-        TreeSelect: {
-            renderItemContent({ props }: RenderOptions, { data, field }: RenderFormParams): import("vue/jsx-runtime").JSX.Element | null;
-            renderDefault({ props }: RenderOptions, { row, field }: RenderTableParams): import("vue/jsx-runtime").JSX.Element | null;
-        };
-    };
-    addRender: (name: string, { renderItemContent, renderDefault, }: {
-        renderItemContent?: (options: RenderOptions, params: RenderFormParams, defaultHandler: Recordable) => any;
-        renderDefault?: (options: RenderOptions, params: RenderTableParams, defaultHandler: Recordable) => any;
-    }) => void;
+    renders: RenderFactory;
+    addRender: (name: string, { renderItemContent, renderDefault, renderEdit }: RenderWorkshop) => void;
 };
 export default _default;

package/dist/packages/utils/AFormatters.d.ts

@@ -1,16 +1,6 @@
-import { CellFuncArg, ColumnProps } from '../../declarations/antProxy';
-export declare const antFormatters: {
-    toString: ({ cellValue }: {
-        cellValue: any;
-    }) => any;
-    formatByOptions: ({ cellValue }: {
-        cellValue: any;
-    }, options: IOption[], separator?: string) => string;
-    formatSex: ({ cellValue }: {
-        cellValue: any;
-    }) => "-" | "男" | "女";
-};
-export declare const renderAntFormat: <D = Recordable<any>>(formatter: string | [string, ...Array<any>] | ((arg: CellFuncArg<D>) => any), { record, index, column, field, }: {
+import { CellFuncArg, ColumnProps, PFormatter } from '../../declarations/antProxy';
+export declare const antFormatters: PFormatter;
+export declare const renderAntFormat: <D extends Recordable = Recordable>(formatter: string | [string, ...Array<any>] | ((arg: CellFuncArg<D>) => any), { record, index, column, field, }: {
     record: D;
     index: number;
     field?: string;

package/dist/packages/utils/treeHelper.d.ts

@@ -2,18 +2,18 @@ interface TreeConfig {
     children?: string;
 }
 export declare const eachTree: <T extends Recordable>(treeData: ((T | (T & {
-    children?: (T & any)[] | undefined;
+    children?: (T & /*elided*/ any)[] | undefined;
 })) & {
     children?: ((T | (T & {
-        children?: (T & any)[] | undefined;
-    })) & any)[] | undefined;
+        children?: (T & /*elided*/ any)[] | undefined;
+    })) & /*elided*/ any)[] | undefined;
 })[], iterate: (item: T | (T & {
-    children?: (T & any)[] | undefined;
+    children?: (T & /*elided*/ any)[] | undefined;
 }) | ((T | (T & {
-    children?: (T & any)[] | undefined;
+    children?: (T & /*elided*/ any)[] | undefined;
 })) & {
     children?: ((T | (T & {
-        children?: (T & any)[] | undefined;
-    })) & any)[] | undefined;
+        children?: (T & /*elided*/ any)[] | undefined;
+    })) & /*elided*/ any)[] | undefined;
 })) => any, options?: TreeConfig, context?: any) => any;
 export {};