@qin-ui/antd-vue-pro 2.0.15 → 2.0.18

package/es/antd-vue-pro.css

@@ -1,13 +1,13 @@
-.pro-table_search-form[data-v-0bb2bc70] .ant-form-item {
+.pro-table_search-form[data-v-41da0f82] .ant-form-item {
   margin: 0;
 }
-.pro-table_search-form_expand-toggle-button[data-v-0bb2bc70] {
+.pro-table_search-form_expand-toggle-button[data-v-41da0f82] {
   display: flex;
   align-items: center;
   padding: 0;
   padding-left: 4px;
 }
-.pro-table_search-form .transition[data-v-0bb2bc70] {
+.pro-table_search-form .transition[data-v-41da0f82] {
   transition: all 0.25s;
 }
 .pro-table_search-form-container[data-v-c385cd54] {
@@ -18,41 +18,41 @@
   flex: 1;
   padding: 24px 24px 0;
 }
-.pro-table_size-control_button[data-v-0df8d4ae] {
+.pro-table_size-control_button[data-v-db17998d] {
   display: flex;
   align-items: center;
   padding-right: 12px;
   padding-left: 12px;
 }
-.pro-table_size-control_button[data-v-0df8d4ae] svg {
+.pro-table_size-control_button[data-v-db17998d] svg {
   transform: scale(1.3);
 }
-.pro-table_column-control_button[data-v-49bb3de5] {
+.pro-table_column-control_button[data-v-d503f78a] {
   display: flex;
   align-items: center;
   padding-right: 12px;
   padding-left: 12px;
 }
-.pro-table_column-control_button[data-v-49bb3de5] svg {
+.pro-table_column-control_button[data-v-d503f78a] svg {
   transform: scale(1.2, 1.4);
 }
-.pro-table_header[data-v-54982423] {
+.pro-table_header[data-v-291baca6] {
   display: flex;
   align-items: center;
   justify-content: flex-end;
 }
-.pro-table_header[data-v-54982423]:empty {
+.pro-table_header[data-v-291baca6]:empty {
   display: none;
 }
-.pro-table_header + .pro-table_header_content[data-v-54982423] {
+.pro-table_header + .pro-table_header_content[data-v-291baca6] {
   margin-top: 16px;
 }
-.pro-table_header_button-bar[data-v-54982423] {
+.pro-table_header_button-bar[data-v-291baca6] {
   flex: 1;
 }
-.pro-table_header_toolbar[data-v-54982423] {
+.pro-table_header_toolbar[data-v-291baca6] {
   margin-left: 12px;
 }
-.pro-table[data-v-54982423] .ant-pagination .ant-pagination-total-text {
+.pro-table[data-v-291baca6] .ant-pagination .ant-pagination-total-text {
   flex: 1;
 }

package/es/component-provider/index-BeGPcKnM.js

@@ -0,0 +1,511 @@
+import { inject, camelize, reactive, provide, ref, toValue, defineComponent, renderSlot } from "vue";
+import { i as isPlainObject, c as cloneDeep, s as set, g as get, p as pick, t as toPath } from "../vendor/utils/lodash-es-p6jau26B.js";
+const getPopupContainer = (triggerNode) => triggerNode.closest(".ant-form");
+const INJECT_CONFIG = {
+  "pro-table": {
+    injectionKey: Symbol(""),
+    default: {
+      pagination: {
+        showTotal: (total) => `共 ${total} 条`,
+        showSizeChanger: true,
+        pageSizeOptions: ["10", "20", "30", "40", "50", "100"],
+        showQuickJumper: true
+      },
+      searchFormConfig: {
+        layout: "grid",
+        expand: { minExpandRows: 2, expandStatus: false }
+      },
+      control: true,
+      addIndexColumn: true
+    }
+  },
+  "pro-form": {
+    injectionKey: Symbol(""),
+    default: { grid: { gutter: { xs: 8, sm: 16, md: 16, lg: 24 } } }
+  },
+  "pro-form-item": {
+    injectionKey: Symbol(""),
+    default: { validateFirst: true, span: 8 }
+  },
+  // field
+  input: {
+    injectionKey: Symbol(""),
+    default: { maxlength: 100, allowClear: true, placeholder: "请输入" }
+  },
+  textarea: {
+    injectionKey: Symbol(""),
+    default: {
+      maxlength: 200,
+      autoSize: { minRows: 3, maxRows: 6 },
+      showCount: true,
+      allowClear: true,
+      placeholder: "请输入"
+    }
+  },
+  "input-password": {
+    injectionKey: Symbol(""),
+    default: { maxlength: 100, allowClear: true, placeholder: "请输入" }
+  },
+  "input-search": {
+    injectionKey: Symbol(""),
+    default: {}
+  },
+  "input-number": {
+    injectionKey: Symbol(""),
+    default: {
+      max: 10 ** 15 - 1,
+      min: -1000000000000001,
+      controls: false,
+      placeholder: "请输入",
+      style: { width: "100%" }
+    }
+  },
+  select: {
+    injectionKey: Symbol(""),
+    default: { allowClear: true, placeholder: "请选择", getPopupContainer }
+  },
+  cascader: {
+    injectionKey: Symbol(""),
+    default: { allowClear: true, placeholder: "请选择", getPopupContainer }
+  },
+  "date-picker": {
+    injectionKey: Symbol(""),
+    default: { allowClear: true, getPopupContainer, style: { width: "100%" } }
+  },
+  "date-picker.date": {
+    injectionKey: Symbol(""),
+    default: { allowClear: true, getPopupContainer, style: { width: "100%" } }
+  },
+  "date-picker.week": {
+    injectionKey: Symbol(""),
+    default: { allowClear: true, getPopupContainer, style: { width: "100%" } }
+  },
+  "date-picker.month": {
+    injectionKey: Symbol(""),
+    default: { allowClear: true, getPopupContainer, style: { width: "100%" } }
+  },
+  "date-picker.year": {
+    injectionKey: Symbol(""),
+    default: { allowClear: true, getPopupContainer, style: { width: "100%" } }
+  },
+  "date-picker.quarter": {
+    injectionKey: Symbol(""),
+    default: { allowClear: true, getPopupContainer, style: { width: "100%" } }
+  },
+  "range-picker": {
+    injectionKey: Symbol(""),
+    default: { allowClear: true, getPopupContainer, style: { width: "100%" } }
+  },
+  "time-picker": {
+    injectionKey: Symbol(""),
+    default: { allowClear: true, getPopupContainer, style: { width: "100%" } }
+  },
+  "checkbox-group": {
+    injectionKey: Symbol(""),
+    default: {}
+  },
+  "radio-group": {
+    injectionKey: Symbol(""),
+    default: {}
+  },
+  switch: {
+    injectionKey: Symbol(""),
+    default: { modelName: "checked" }
+  },
+  slider: {
+    injectionKey: Symbol(""),
+    default: {}
+  },
+  "tree-select": {
+    injectionKey: Symbol(""),
+    default: {}
+  },
+  transfer: {
+    injectionKey: Symbol(""),
+    default: {}
+  }
+};
+const InjectionFormKey = Symbol("form");
+const InjectionPathKey = Symbol("path");
+function getObject(val) {
+  return isPlainObject(val) ? val : {};
+}
+function camelizeProperties(obj) {
+  return Object.fromEntries(
+    Object.entries(obj).map(([key, value]) => [camelize(key), value])
+  );
+}
+const useFields = (initFields) => {
+  const fields = ref([]);
+  fields.value = initFields || [];
+  const _map = /* @__PURE__ */ new Map();
+  const cacheMatch = (pathStr, updater) => {
+    var _a;
+    const fieldPath = _map.get(pathStr) || [];
+    if (fieldPath.length === 0) return false;
+    const fieldIndex = fieldPath[fieldPath.length - 1];
+    const parentField = fieldPath.length === 1 ? fields.value : get(fields.value, fieldPath.slice(0, -2));
+    const field = (_a = parentField == null ? void 0 : parentField.fields) == null ? void 0 : _a[fieldIndex];
+    const _path = toPath((field == null ? void 0 : field.name) ?? (field == null ? void 0 : field.path)).join(".");
+    if (_path === pathStr) {
+      updater({ field, fieldIndex, parentField });
+      return true;
+    }
+    return false;
+  };
+  const updaterMatch = (path, updater, options = {}) => {
+    if (!path) return;
+    const pathStr = typeof path === "function" ? "" : toPath(path).join(".");
+    const { all = typeof path === "function" } = options;
+    if (pathStr && _map.has(pathStr) && !all) {
+      const bool = cacheMatch(pathStr, updater);
+      if (bool) return;
+    }
+    const queue = fields.value.map((field, i) => ({
+      field,
+      fieldPath: [i],
+      parentField: { fields: fields.value }
+    }));
+    while (queue.length) {
+      const { field, fieldPath, parentField } = queue.shift();
+      let matched = false;
+      const _path = toPath(field.name ?? field.path).join(".");
+      if (_path) _map.set(_path, fieldPath);
+      if (typeof path === "function") {
+        matched = path(field);
+      } else if (_path) {
+        matched = pathStr === _path;
+      }
+      if (matched) {
+        const fieldIndex = fieldPath[fieldPath.length - 1];
+        updater({ field, fieldIndex, parentField });
+        if (!all) return;
+      }
+      if (Array.isArray(field.fields)) {
+        field.fields.forEach((f, i) => {
+          queue.push({
+            field: f,
+            fieldPath: [...fieldPath, "fields", i],
+            parentField: field
+          });
+        });
+      }
+    }
+  };
+  function getField(path, options) {
+    if (!path) return void 0;
+    const res = [];
+    updaterMatch(
+      path,
+      ({ field }) => {
+        res.push(field);
+      },
+      options
+    );
+    return (options == null ? void 0 : options.all) ? res : res[0];
+  }
+  function setField(path, field, options) {
+    if (!path) return;
+    const { updateType = "merge", ...rest } = options || {};
+    updaterMatch(
+      path,
+      ({ field: preField, fieldIndex, parentField }) => {
+        let value = field;
+        if (typeof field === "function") {
+          value = field(preField);
+        }
+        if (!value) return;
+        if (updateType === "rewrite") {
+          parentField.fields[fieldIndex] = value;
+        } else {
+          Object.assign(preField, value);
+        }
+      },
+      rest
+    );
+  }
+  function deleteField(path, options) {
+    if (!path) return;
+    updaterMatch(
+      path,
+      ({ fieldIndex, parentField }) => {
+        parentField.fields.splice(fieldIndex, 1);
+      },
+      options
+    );
+  }
+  function addFields(path, newFields, options, placement) {
+    if (newFields.length === 0) return;
+    if (path) {
+      updaterMatch(
+        path,
+        ({ fieldIndex, parentField }) => {
+          const index = placement === "after" ? fieldIndex + 1 : fieldIndex;
+          parentField.fields.splice(index, 0, ...newFields);
+        },
+        options
+      );
+    } else if (placement === "after") {
+      fields.value.push(...newFields);
+    } else {
+      fields.value.unshift(...newFields);
+    }
+  }
+  function appendField(path, field, options) {
+    const newFields = Array.isArray(field) ? field : [field];
+    addFields(path, newFields, options, "after");
+  }
+  function prependField(path, field, options) {
+    const newFields = Array.isArray(field) ? field : [field];
+    addFields(path, newFields, options, "before");
+  }
+  function getParentField(path, options) {
+    if (!path) return void 0;
+    const res = [];
+    updaterMatch(
+      path,
+      ({ parentField }) => {
+        res.push(parentField);
+      },
+      options
+    );
+    return (options == null ? void 0 : options.all) ? res : res[0];
+  }
+  return {
+    fields,
+    getField,
+    setField,
+    deleteField,
+    appendField,
+    prependField,
+    getParentField
+  };
+};
+const InjectionFormDataKey = Symbol("form-data");
+const useFormData = (initFormData) => {
+  if (!initFormData) {
+    const injectFormDataStore = inject(InjectionFormDataKey, void 0);
+    if (injectFormDataStore) return injectFormDataStore;
+  }
+  const formData = reactive(initFormData ?? {});
+  function getFormData(path) {
+    if (!path) return void 0;
+    return get(formData, path);
+  }
+  function setFormData(...args) {
+    let path;
+    let value;
+    if (args.length >= 2) {
+      [path, value] = args;
+      if (!path) return;
+    } else {
+      [value] = args;
+    }
+    if (path) {
+      if (typeof value === "function") {
+        const preValue = getFormData(path);
+        value = value(preValue);
+      }
+      set(formData, path, value);
+    } else {
+      if (typeof value === "function") {
+        const preValue = formData;
+        value = value(preValue);
+      }
+      if (!isPlainObject(value)) return;
+      Object.keys(formData).forEach((key) => {
+        delete formData[key];
+      });
+      Object.assign(formData, value);
+    }
+  }
+  const formDataStore = { formData, getFormData, setFormData };
+  provide(InjectionFormDataKey, formDataStore);
+  return formDataStore;
+};
+const useFormRef = () => {
+  const formRef = ref();
+  const setFormRef = (inst) => {
+    formRef.value = inst;
+  };
+  return { formRef, setFormRef };
+};
+function useForm(...args) {
+  let initFormData = {}, initFields = [], root = true;
+  if (args.length === 1) {
+    root = args[0];
+  } else if (args.length >= 2) {
+    initFormData = args[0];
+    initFields = args[1];
+    root = args[2] ?? root;
+  }
+  if (!root) {
+    const injectForm = inject(InjectionFormKey);
+    if (injectForm) return injectForm;
+  }
+  return {
+    ...useFormData(initFormData),
+    ...useFields(initFields),
+    ...useFormRef()
+  };
+}
+const getDefaultPageParam = () => ({
+  current: 1,
+  pageSize: 10,
+  total: 0
+});
+const pageParamProperty = ["current", "pageSize", "total"];
+const useTable = (params) => {
+  const {
+    columns: initColumns = [],
+    dataSource: initDataSource = [],
+    pageParam: initPageParam = getDefaultPageParam(),
+    searchParam: initSearchParam = {},
+    searchFields: initSearchFields = []
+  } = params;
+  const _initSearchParam = cloneDeep(toValue(initSearchParam));
+  const columns = ref([]);
+  columns.value = initColumns;
+  const dataSource = ref(initDataSource);
+  const pageParam = reactive(initPageParam);
+  const setPageParam = (pa) => {
+    let newPageParam = pa;
+    if (typeof pa === "function") {
+      newPageParam = pa(pageParam);
+    }
+    Object.assign(pageParam, pick(newPageParam, pageParamProperty));
+  };
+  const searchForm = useForm(initSearchParam, initSearchFields, true);
+  const resetQueryParams = () => {
+    Object.assign(pageParam, getDefaultPageParam());
+    searchForm.setFormData(cloneDeep(_initSearchParam));
+  };
+  const updaterMatch = (key, updater, options = {}) => {
+    if (!key) return;
+    const { all = typeof key === "function" } = options;
+    for (let i = 0; i < columns.value.length; i++) {
+      const columnItem = columns.value[i];
+      let matched = false;
+      if (typeof key === "function") {
+        matched = key(columnItem);
+      } else if (columnItem.key) {
+        matched = columnItem.key === key;
+      } else if (columnItem.dataIndex) {
+        const dataIndexKey = Array.isArray(columnItem.dataIndex) ? columnItem.dataIndex.join(".") : columnItem.dataIndex;
+        matched = dataIndexKey === key;
+      } else {
+        matched = key === i;
+      }
+      if (matched) {
+        updater({
+          column: columnItem,
+          columnIndex: i,
+          group: columns.value
+        });
+        if (!all) return;
+      }
+    }
+  };
+  const setColumn = (key, column, options) => {
+    if (!key || !column) return;
+    const { updateType = "merge", ...rest } = options || {};
+    updaterMatch(
+      key,
+      ({ column: preColumn, columnIndex, group }) => {
+        let value = column;
+        if (typeof column === "function") {
+          value = column(preColumn);
+        }
+        if (!value) return;
+        if (updateType === "rewrite") {
+          group[columnIndex] = value;
+        } else {
+          Object.assign(preColumn, value);
+        }
+      },
+      rest
+    );
+  };
+  function deleteColumn(path, options) {
+    if (!path) return;
+    updaterMatch(
+      path,
+      ({ columnIndex, group }) => {
+        group.splice(columnIndex, 1);
+      },
+      options
+    );
+  }
+  function addColumns(path, newColumns, options, placement) {
+    if (newColumns.length === 0) return;
+    if (path) {
+      updaterMatch(
+        path,
+        ({ columnIndex, group }) => {
+          const index = placement === "after" ? columnIndex + 1 : columnIndex;
+          group.splice(index, 0, ...newColumns);
+        },
+        options
+      );
+    } else if (placement === "after") {
+      columns.value.push(...newColumns);
+    } else {
+      columns.value.unshift(...newColumns);
+    }
+  }
+  function appendColumn(path, column, options) {
+    const newColumns = Array.isArray(column) ? column : [column];
+    addColumns(path, newColumns, options, "after");
+  }
+  function prependColumn(path, column, options) {
+    const newColumns = Array.isArray(column) ? column : [column];
+    addColumns(path, newColumns, options, "before");
+  }
+  return {
+    columns,
+    dataSource,
+    pageParam,
+    searchForm,
+    setColumn,
+    deleteColumn,
+    appendColumn,
+    prependColumn,
+    setPageParam,
+    resetQueryParams
+  };
+};
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  ...{
+    inheritAttrs: false
+  },
+  __name: "index",
+  props: {
+    componentVars: {}
+  },
+  setup(__props) {
+    const props = __props;
+    if (props.componentVars) {
+      Object.entries(props.componentVars).forEach(([key, val]) => {
+        const config = INJECT_CONFIG[key];
+        if (!config) return;
+        provide(config.injectionKey, { ...config.default, ...getObject(val) });
+      });
+    }
+    return (_ctx, _cache) => {
+      return renderSlot(_ctx.$slots, "default");
+    };
+  }
+});
+export {
+  InjectionFormKey as I,
+  _sfc_main as _,
+  INJECT_CONFIG as a,
+  InjectionPathKey as b,
+  camelizeProperties as c,
+  useFields as d,
+  useFormRef as e,
+  useFormData as f,
+  getObject as g,
+  useTable as h,
+  useForm as u
+};

package/es/component-provider/index.js

@@ -1,5 +1,5 @@
-import { I, _ } from "./index-D8NF18a1.js";
+import { a, _ } from "./index-BeGPcKnM.js";
 export {
-  I as INJECT_CONFIG,
+  a as INJECT_CONFIG,
   _ as default
 };