@qin-ui/vant-pro 1.0.0

package/es/core/index-D-2iAH6o.js

@@ -0,0 +1,236 @@
+import { camelize, inject, reactive, provide, ref } from "vue";
+import { i as isPlainObject, s as set, g as get, t as toPath } from "../vendor/utils/lodash-es-DN4QDiDm.js";
+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()
+  };
+}
+export {
+  InjectionFormKey as I,
+  InjectionPathKey as a,
+  useFields as b,
+  camelizeProperties as c,
+  useFormRef as d,
+  useFormData as e,
+  getObject as g,
+  useForm as u
+};