@aplus-frontend/ui 0.0.12 → 0.0.14

package/es/src/editable-table/form-item.vue.d.ts

@@ -0,0 +1,304 @@
+import { EditableColumnType, EditableTableFormItemProps } from './interface';
+import { DefineComponent, ComponentOptionsMixin, PublicProps, ExtractPropTypes, PropType, CSSProperties, HTMLAttributes } from 'vue';
+import { SpinSize } from 'ant-design-vue/es/spin/Spin';
+import { VueTypeValidableDef, VueTypeDef } from '../../node_modules/vue-types';
+import { TablePaginationConfig } from 'ant-design-vue';
+import { TableLayout, GetRowKey } from 'ant-design-vue/es/vc-table/interface';
+import { SortOrder } from 'ant-design-vue/es/table/interface';
+import { TriggerType } from 'ant-design-vue/es/tooltip/abstractTooltipProps';
+import { TooltipPlacement, AdjustOverflow } from 'ant-design-vue/es/tooltip';
+import { LiteralUnion } from 'ant-design-vue/es/_util/type';
+import { PresetColorType } from 'ant-design-vue/es/_util/colors';
+import { AlignType, BuildInPlacements } from 'ant-design-vue/es/vc-trigger/interface';
+import { ColSize } from 'ant-design-vue/es/grid';
+import { FormLabelAlign } from 'ant-design-vue/es/form/interface';
+import { RuleObject } from 'ant-design-vue/es/form';
+
+type EditableTableFormItemSlots = {
+    default: any;
+    emptyText?: any;
+    expandIcon?: any;
+    title?: any;
+    footer?: any;
+    summary?: any;
+    expandedRowRender?: any;
+    expandColumnTitle?: any;
+    customFilterIcon?: any;
+    customFilterDropdown?: any;
+    headerCell?: (props: {
+        title: any;
+        column: EditableColumnType;
+    }) => void;
+};
+declare function add(defaultValue?: any): void;
+declare function remove(index: number): void;
+declare function getRowsData(): any[];
+declare function getRowData(index: number): any;
+declare function setRowData(index: number, payload: any): void;
+declare const _default: __VLS_WithTemplateSlots< DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<EditableTableFormItemProps<any>>, {
+    bordered: boolean;
+    childrenColumnName: string;
+    defaultExpandAllRows: boolean;
+    expandFixed: boolean;
+    expandRowByClick: boolean;
+    indentSize: number;
+    rowKey: string;
+    showExpandColumn: boolean;
+    showHeader: boolean;
+    showSorterTooltip: boolean;
+    size: string;
+    sortDirections: () => string[];
+    pagination: boolean;
+    loading: undefined;
+    tableLayout: string;
+    formItem: () => {};
+}>, {
+    add: typeof add;
+    remove: typeof remove;
+    getRowData: typeof getRowData;
+    getRowsData: typeof getRowsData;
+    setRowData: typeof setRowData;
+}, unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly< ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<EditableTableFormItemProps<any>>, {
+    bordered: boolean;
+    childrenColumnName: string;
+    defaultExpandAllRows: boolean;
+    expandFixed: boolean;
+    expandRowByClick: boolean;
+    indentSize: number;
+    rowKey: string;
+    showExpandColumn: boolean;
+    showHeader: boolean;
+    showSorterTooltip: boolean;
+    size: string;
+    sortDirections: () => string[];
+    pagination: boolean;
+    loading: undefined;
+    tableLayout: string;
+    formItem: () => {};
+}>>>, {
+    loading: boolean | Partial< ExtractPropTypes<{
+        prefixCls: StringConstructor;
+        spinning: {
+            type: BooleanConstructor;
+            default: any;
+        };
+        size: PropType<SpinSize>;
+        wrapperClassName: StringConstructor;
+        tip: VueTypeValidableDef<any>;
+        delay: NumberConstructor;
+        indicator: VueTypeValidableDef<any>;
+    }>>;
+    size: "small" | "middle" | "large";
+    pagination: false | TablePaginationConfig;
+    bordered: boolean;
+    tableLayout: TableLayout;
+    rowKey: string | GetRowKey<any>;
+    sortDirections: SortOrder[];
+    showSorterTooltip: boolean | Partial< ExtractPropTypes<{
+        title: VueTypeValidableDef<any>;
+        trigger: PropType< TriggerType | TriggerType[]>;
+        open: {
+            type: BooleanConstructor;
+            default: any;
+        };
+        visible: {
+            type: BooleanConstructor;
+            default: any;
+        };
+        placement: PropType<TooltipPlacement>;
+        color: PropType<LiteralUnion<PresetColorType>>;
+        transitionName: StringConstructor;
+        overlayStyle: {
+            type: PropType<CSSProperties>;
+            default: CSSProperties;
+        };
+        overlayInnerStyle: {
+            type: PropType<CSSProperties>;
+            default: CSSProperties;
+        };
+        overlayClassName: StringConstructor;
+        openClassName: StringConstructor;
+        prefixCls: StringConstructor;
+        mouseEnterDelay: NumberConstructor;
+        mouseLeaveDelay: NumberConstructor;
+        getPopupContainer: PropType<(triggerNode: HTMLElement) => HTMLElement>;
+        arrowPointAtCenter: {
+            type: BooleanConstructor;
+            default: any;
+        };
+        arrow: {
+            type: PropType<boolean | {
+                pointAtCenter?: boolean | undefined;
+            }>;
+            default: boolean | {
+                pointAtCenter?: boolean | undefined;
+            };
+        };
+        autoAdjustOverflow: {
+            type: PropType<boolean | AdjustOverflow>;
+            default: boolean | AdjustOverflow;
+        };
+        destroyTooltipOnHide: {
+            type: BooleanConstructor;
+            default: any;
+        };
+        align: {
+            type: PropType<AlignType>;
+            default: AlignType;
+        };
+        builtinPlacements: {
+            type: PropType<BuildInPlacements>;
+            default: BuildInPlacements;
+        };
+        children: ArrayConstructor;
+        onVisibleChange: PropType<(vis: boolean) => void>;
+        'onUpdate:visible': PropType<(vis: boolean) => void>;
+        onOpenChange: PropType<(vis: boolean) => void>;
+        'onUpdate:open': PropType<(vis: boolean) => void>;
+    }>>;
+    showHeader: boolean;
+    expandFixed: boolean | "left" | "right";
+    expandRowByClick: boolean;
+    defaultExpandAllRows: boolean;
+    indentSize: number;
+    showExpandColumn: boolean;
+    childrenColumnName: string;
+    formItem: Partial<Omit<Partial< ExtractPropTypes<{
+        htmlFor: StringConstructor;
+        prefixCls: StringConstructor;
+        label: VueTypeValidableDef<any>;
+        help: VueTypeValidableDef<any>;
+        extra: VueTypeValidableDef<any>;
+        labelCol: {
+            type: PropType<Partial< ExtractPropTypes<{
+                span: (StringConstructor | NumberConstructor)[];
+                order: (StringConstructor | NumberConstructor)[];
+                offset: (StringConstructor | NumberConstructor)[];
+                push: (StringConstructor | NumberConstructor)[];
+                pull: (StringConstructor | NumberConstructor)[];
+                xs: {
+                    type: PropType<string | number | ColSize>;
+                    default: string | number | ColSize;
+                };
+                sm: {
+                    type: PropType<string | number | ColSize>;
+                    default: string | number | ColSize;
+                };
+                md: {
+                    type: PropType<string | number | ColSize>;
+                    default: string | number | ColSize;
+                };
+                lg: {
+                    type: PropType<string | number | ColSize>;
+                    default: string | number | ColSize;
+                };
+                xl: {
+                    type: PropType<string | number | ColSize>;
+                    default: string | number | ColSize;
+                };
+                xxl: {
+                    type: PropType<string | number | ColSize>;
+                    default: string | number | ColSize;
+                };
+                prefixCls: StringConstructor;
+                flex: (StringConstructor | NumberConstructor)[];
+            }>> & HTMLAttributes>;
+        };
+        wrapperCol: {
+            type: PropType<Partial< ExtractPropTypes<{
+                span: (StringConstructor | NumberConstructor)[];
+                order: (StringConstructor | NumberConstructor)[];
+                offset: (StringConstructor | NumberConstructor)[];
+                push: (StringConstructor | NumberConstructor)[];
+                pull: (StringConstructor | NumberConstructor)[];
+                xs: {
+                    type: PropType<string | number | ColSize>;
+                    default: string | number | ColSize;
+                };
+                sm: {
+                    type: PropType<string | number | ColSize>;
+                    default: string | number | ColSize;
+                };
+                md: {
+                    type: PropType<string | number | ColSize>;
+                    default: string | number | ColSize;
+                };
+                lg: {
+                    type: PropType<string | number | ColSize>;
+                    default: string | number | ColSize;
+                };
+                xl: {
+                    type: PropType<string | number | ColSize>;
+                    default: string | number | ColSize;
+                };
+                xxl: {
+                    type: PropType<string | number | ColSize>;
+                    default: string | number | ColSize;
+                };
+                prefixCls: StringConstructor;
+                flex: (StringConstructor | NumberConstructor)[];
+            }>> & HTMLAttributes>;
+        };
+        hasFeedback: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        colon: {
+            type: BooleanConstructor;
+            default: any;
+        };
+        labelAlign: PropType<FormLabelAlign>;
+        prop: {
+            type: PropType<string | number | (string | number)[]>;
+        };
+        name: {
+            type: PropType<string | number | (string | number)[]>;
+        };
+        rules: PropType< RuleObject | RuleObject[]>;
+        autoLink: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        required: {
+            type: BooleanConstructor;
+            default: any;
+        };
+        validateFirst: {
+            type: BooleanConstructor;
+            default: any;
+        };
+        validateStatus: VueTypeDef<string>;
+        validateTrigger: {
+            type: PropType<string | string[]>;
+        };
+        messageVariables: {
+            type: PropType<Record<string, string>>;
+        };
+        hidden: BooleanConstructor;
+        noStyle: BooleanConstructor;
+        tooltip: StringConstructor;
+    }>>, "label" | "name">>;
+}, {}>, Readonly<EditableTableFormItemSlots> & EditableTableFormItemSlots>;
+export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToRuntimeProps<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithDefaults<P, D> = {
+    [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_Prettify<P[K] & {
+        default: D[K];
+    }> : P[K];
+};
+type __VLS_Prettify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/es/src/editable-table/form-item.vue.mjs

@@ -0,0 +1,189 @@
+import { defineComponent as P, ref as L, unref as o, useSlots as V, watch as j, openBlock as f, createBlock as z, mergeProps as c, withCtx as i, createVNode as _, createSlots as O, createElementBlock as T, Fragment as K, createElementVNode as x, normalizeClass as q, toDisplayString as A, createCommentVNode as G, renderList as H, renderSlot as M, normalizeProps as W, guardReactiveProps as U } from "vue";
+import { Table as $ } from "ant-design-vue";
+import { ApForm as C } from "../ap-form/index.mjs";
+import { cloneDeep as g, omit as J } from "lodash-unified";
+import "../config-provider/index.mjs";
+import { useInjectForm as Q } from "../ap-form/context.mjs";
+import "./style/index.css";
+import { isDef as X } from "../utils/index.mjs";
+import Y from "./hooks/use-get-columns.mjs";
+import { useNamespace as Z } from "../config-provider/hooks/use-namespace.mjs";
+import { useGlobalConfig as I } from "../config-provider/hooks/use-global-config.mjs";
+const pe = /* @__PURE__ */ P({
+  name: "EditableTableInner",
+  __name: "form-item",
+  props: {
+    dropdownPrefixCls: {},
+    pagination: {
+      type: [Boolean, Object],
+      default: !1
+    },
+    loading: {
+      type: [Boolean, Object],
+      default: void 0
+    },
+    size: {
+      default: "middle"
+    },
+    bordered: {
+      type: Boolean,
+      default: !1
+    },
+    locale: {},
+    onChange: {},
+    onResizeColumn: {},
+    rowSelection: {},
+    getPopupContainer: {},
+    scroll: {},
+    sortDirections: {
+      default: () => ["ascend", "descend"]
+    },
+    showSorterTooltip: {
+      type: [Boolean, Object],
+      default: !0
+    },
+    prefixCls: {},
+    rowKey: {
+      default: "key"
+    },
+    tableLayout: {
+      default: "fixed"
+    },
+    rowClassName: {},
+    title: {},
+    footer: {},
+    id: {},
+    showHeader: {
+      type: Boolean,
+      default: !0
+    },
+    components: {},
+    customRow: {},
+    customHeaderRow: {},
+    direction: {},
+    expandFixed: {
+      type: [String, Boolean],
+      default: !1
+    },
+    expandColumnWidth: {},
+    expandedRowKeys: {},
+    defaultExpandedRowKeys: {},
+    expandedRowRender: {},
+    expandRowByClick: {
+      type: Boolean,
+      default: !1
+    },
+    expandIcon: {},
+    onExpand: {},
+    onExpandedRowsChange: {},
+    defaultExpandAllRows: {
+      type: Boolean,
+      default: !1
+    },
+    indentSize: {
+      default: 15
+    },
+    expandIconColumnIndex: {},
+    showExpandColumn: {
+      type: Boolean,
+      default: !0
+    },
+    expandedRowClassName: {},
+    childrenColumnName: {
+      default: "children"
+    },
+    rowExpandable: {},
+    sticky: {
+      type: [Boolean, Object]
+    },
+    transformCellText: {},
+    columns: {},
+    value: {},
+    defaultValue: {},
+    "onUpdate:value": {},
+    maxLength: {},
+    onFieldChange: {},
+    label: {},
+    name: {},
+    formItem: {
+      default: () => ({})
+    }
+  },
+  setup(h, {
+    expose: w
+  }) {
+    var p;
+    const n = h, {
+      formInstance: t,
+      model: b
+    } = Q(), d = L(((p = o(b)) == null ? void 0 : p[n.name]) || []), y = V(), R = C.useWatch(n.name);
+    j(() => R.value, (a) => {
+      var l;
+      d.value = a, (l = n.onChange) == null || l.call(n, a);
+    });
+    const {
+      b: u,
+      em: B
+    } = Z("editable-table"), D = I("uiMode", "aplus"), E = Y(n);
+    function F(a) {
+      var e, r;
+      const l = ((e = o(d)) == null ? void 0 : e.length) || 0;
+      X(n.maxLength) && l >= n.maxLength || (r = t == null ? void 0 : t.setFieldValue) == null || r.call(t, n.name, [...o(d) || [], a || {}]);
+    }
+    function v(a) {
+      var e;
+      const l = g(o(d) || []);
+      l.splice(a, 1), (e = t == null ? void 0 : t.setFieldValue) == null || e.call(t, n.name, [...l]);
+    }
+    function S() {
+      return o(d);
+    }
+    function k(a) {
+      var l;
+      return (l = o(d)) == null ? void 0 : l[a];
+    }
+    function N(a, l) {
+      var r;
+      const e = g(o(d));
+      e[a] && (e[a] = {
+        ...e[a],
+        ...l
+      }, (r = t == null ? void 0 : t.setFieldValue) == null || r.call(t, n.name, [...e]));
+    }
+    return w({
+      add: F,
+      remove: v,
+      getRowData: k,
+      getRowsData: S,
+      setRowData: N
+    }), (a, l) => (f(), z(o(C).FormItem, c(a.formItem, {
+      name: a.name,
+      label: a.label
+    }), {
+      default: i(() => [_(o($), c(o(J)(n, ["name", "maxLength"]), {
+        class: [o(u)(), o(D) === "admin" ? o(u)("admin") : null],
+        columns: o(E),
+        "data-source": d.value
+      }), O({
+        headerCell: i(({
+          column: e
+        }) => {
+          var r, s, m;
+          return [(r = e == null ? void 0 : e.fieldProps) != null && r.required || (m = (s = e == null ? void 0 : e.fieldProps) == null ? void 0 : s.rules) != null && m.length ? (f(), T(K, {
+            key: 0
+          }, [x("span", {
+            class: q(o(B)("header-cell", "required"))
+          }, "*", 2), x("span", null, A(e.title), 1)], 64)) : G("", !0)];
+        }),
+        _: 2
+      }, [H(y, (e, r) => ({
+        name: r,
+        fn: i((s) => [M(a.$slots, r, W(U(s || {})))])
+      }))]), 1040, ["class", "columns", "data-source"])]),
+      _: 3
+    }, 16, ["name", "label"]));
+  }
+});
+export {
+  pe as default
+};

package/es/src/editable-table/form-item.vue2.mjs

@@ -0,0 +1,4 @@
+import f from "./form-item.vue.mjs";
+export {
+  f as default
+};

package/es/src/editable-table/hooks/use-get-columns.d.ts

@@ -0,0 +1,5 @@
+import { EditableTableFormItemProps, EditableTableProps, EditableColumnType } from '../interface';
+import { ComputedRef } from 'vue';
+
+declare const useGetColumns: (props: EditableTableProps | EditableTableFormItemProps) => ComputedRef< EditableColumnType<any, any>[]>;
+export default useGetColumns;

package/es/src/editable-table/hooks/use-get-columns.mjs

@@ -0,0 +1,76 @@
+import { computed as x, createVNode as d, mergeProps as g } from "vue";
+import { isFunction as C } from "lodash-unified";
+import { getEditableComponent as T } from "../utils.mjs";
+import { updateFormProps as h, getFieldProps as F, getPlaceholder as R, getTableRenderProps as I } from "../../ap-table/utils.mjs";
+import "../../config-provider/index.mjs";
+import { apTableRenderItemMap as v, noRenderAsFormItemValueList as L } from "../../ap-table/constants.mjs";
+import { Typography as M } from "ant-design-vue";
+import { useLocale as N } from "../../config-provider/hooks/use-locale.mjs";
+const q = (a) => {
+  const {
+    t: u
+  } = N(), i = x(() => {
+    let n = a.columns;
+    return n ? (n = n.map((e) => ({
+      ...e,
+      customRender({
+        value: o,
+        ...l
+      }) {
+        if (e.customRender)
+          return e.customRender({
+            value: o,
+            ...l,
+            column: e
+          });
+        {
+          if (C(e.editable) ? e.editable(l.text, l.record, l.index) : !!e.editable) {
+            const m = T(e.valueType), t = h(e, F(e.fieldProps, {
+              value: o,
+              ...l
+            })), r = {};
+            a.onFieldChange && (r[`onUpdate:${t.valuePropName || "value"}`] = (y) => {
+              var c;
+              return (c = a.onFieldChange) == null ? void 0 : c.call(a, l.index, e.dataIndex, y);
+            });
+            const b = {
+              name: [a.name, l.index, e.dataIndex],
+              ...t || {},
+              // 格式化placeholder
+              placeholder: R(u, e.valueType, t == null ? void 0 : t.placeholder),
+              field: {
+                style: "width: 100%",
+                ...(t == null ? void 0 : t.field) || {},
+                ...r
+              }
+            };
+            return d(m, b, null);
+          }
+          const s = v[e.valueType], f = I(e, {
+            value: o,
+            ...l
+          });
+          return p(e, o, d(s, g(f, {
+            mode: "read"
+          }), null));
+        }
+      }
+    })), n) : [];
+  });
+  function p(n, e, o) {
+    return L.includes(n.valueType) ? o : n.copyable || n.ellipsis ? d(M.Text, {
+      copyable: n.copyable ? {
+        text: e,
+        tooltip: !1
+      } : !1,
+      ellipsis: n.ellipsis ? {
+        tooltip: e
+      } : !1,
+      content: o
+    }, null) : o;
+  }
+  return i;
+};
+export {
+  q as default
+};

package/es/src/editable-table/index.d.ts

@@ -0,0 +1,5 @@
+import { default as EditableTable } from './index.vue';
+import { default as EditableTableFormItem } from './form-item.vue';
+
+export * from './interface';
+export { EditableTable, EditableTableFormItem };

package/es/src/editable-table/index.mjs

@@ -0,0 +1,3 @@
+import "./index.vue2.mjs";
+import "./form-item.vue2.mjs";
+import "./interface.mjs";