knt-shared 1.0.0

package/dist/index.cjs.js

@@ -0,0 +1,734 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const vue = require("vue");
+const webVue = require("@arco-design/web-vue");
+const componentMap = /* @__PURE__ */ new Map();
+componentMap.set("Input", webVue.Input);
+componentMap.set("InputNumber", webVue.InputNumber);
+componentMap.set("InputPassword", webVue.InputPassword);
+componentMap.set("Textarea", webVue.Textarea);
+componentMap.set("AutoComplete", webVue.AutoComplete);
+componentMap.set("Select", webVue.Select);
+componentMap.set("Radio", webVue.Radio);
+componentMap.set("RadioGroup", webVue.RadioGroup);
+componentMap.set("Checkbox", webVue.Checkbox);
+componentMap.set("CheckboxGroup", webVue.CheckboxGroup);
+componentMap.set("Cascader", webVue.Cascader);
+componentMap.set("TreeSelect", webVue.TreeSelect);
+componentMap.set("DatePicker", webVue.DatePicker);
+componentMap.set("TimePicker", webVue.TimePicker);
+componentMap.set("RangePicker", webVue.RangePicker);
+componentMap.set("Switch", webVue.Switch);
+componentMap.set("Slider", webVue.Slider);
+componentMap.set("Rate", webVue.Rate);
+componentMap.set("Upload", webVue.Upload);
+componentMap.set("Mention", webVue.Mention);
+componentMap.set("Transfer", webVue.Transfer);
+function registerComponent(name, component) {
+  componentMap.set(name, component);
+}
+function getComponent(name) {
+  if (typeof name === "string") {
+    return componentMap.get(name);
+  }
+  return name;
+}
+const componentsNeedPlaceholder = /* @__PURE__ */ new Set([
+  "Input",
+  "InputPassword",
+  "Textarea",
+  "AutoComplete"
+]);
+const componentsNeedSelectPlaceholder = /* @__PURE__ */ new Set([
+  "Select",
+  "DatePicker",
+  "TimePicker",
+  "RangePicker",
+  "Cascader",
+  "TreeSelect"
+]);
+function getPlaceholder(component, label) {
+  if (componentsNeedPlaceholder.has(component)) {
+    return `请输入${label}`;
+  }
+  if (componentsNeedSelectPlaceholder.has(component)) {
+    return `请选择${label}`;
+  }
+  return "";
+}
+const _sfc_main = /* @__PURE__ */ vue.defineComponent({
+  ...{
+    name: "BasicForm",
+    inheritAttrs: false
+  },
+  __name: "BasicForm",
+  props: {
+    schemas: { default: () => [] },
+    layout: { default: "horizontal" },
+    size: {},
+    disabled: { type: Boolean, default: false },
+    labelAlign: { default: "right" },
+    autoLabelWidth: { type: Boolean },
+    labelWidth: {},
+    labelColProps: {},
+    wrapperColProps: {},
+    baseColProps: { default: () => ({ span: 24 }) },
+    baseFormItemProps: {},
+    actionColOptions: { default: () => ({ span: 24 }) },
+    autoSetPlaceHolder: { type: Boolean, default: true },
+    showSubmitButton: { type: Boolean, default: true },
+    showResetButton: { type: Boolean, default: true },
+    submitButtonText: { default: "提交" },
+    resetButtonText: { default: "重置" },
+    showActionButtons: { type: Boolean, default: true }
+  },
+  emits: ["register", "submit", "reset", "validate"],
+  setup(__props, { expose: __expose, emit: __emit }) {
+    const props = __props;
+    const emit = __emit;
+    const formRef = vue.ref();
+    const formModel = vue.reactive({});
+    const submitLoading = vue.ref(false);
+    const internalSchemas = vue.ref([]);
+    const dynamicProps = vue.ref({});
+    const getProps = vue.computed(() => {
+      return { ...props, ...dynamicProps.value };
+    });
+    const getBindValue = vue.computed(() => {
+      const propsData = vue.unref(getProps);
+      return {
+        layout: propsData.layout,
+        size: propsData.size,
+        disabled: propsData.disabled,
+        labelAlign: propsData.labelAlign,
+        autoLabelWidth: propsData.autoLabelWidth,
+        labelWidth: propsData.labelWidth,
+        labelColProps: propsData.labelColProps,
+        wrapperColProps: propsData.wrapperColProps
+      };
+    });
+    const getRow = vue.computed(() => {
+      return {
+        gutter: 24
+      };
+    });
+    const getActionProps = vue.computed(() => {
+      const propsData = vue.unref(getProps);
+      return {
+        showActionButtons: propsData.showActionButtons !== false,
+        showSubmitButton: propsData.showSubmitButton !== false,
+        showResetButton: propsData.showResetButton !== false,
+        submitButtonText: propsData.submitButtonText || "提交",
+        resetButtonText: propsData.resetButtonText || "重置",
+        actionColOptions: propsData.actionColOptions || { span: 24 }
+      };
+    });
+    const initFormModel = () => {
+      if (!props.schemas) return;
+      props.schemas.forEach((schema) => {
+        if (schema.defaultValue !== void 0) {
+          formModel[schema.field] = schema.defaultValue;
+        }
+      });
+    };
+    const getVisibleSchemas = () => {
+      const schemas = internalSchemas.value.length > 0 ? internalSchemas.value : props.schemas || [];
+      return schemas.filter((schema) => {
+        if (schema.show === void 0) return true;
+        if (typeof schema.show === "boolean") return schema.show;
+        return schema.show(formModel);
+      });
+    };
+    const getColProps = (schema) => {
+      const propsData = vue.unref(getProps);
+      return schema.colProps || propsData.baseColProps || { span: 24 };
+    };
+    const getFormItemBindValue = (schema) => {
+      const propsData = vue.unref(getProps);
+      let disabled = propsData.disabled;
+      if (schema.disabled !== void 0) {
+        disabled = typeof schema.disabled === "boolean" ? schema.disabled : schema.disabled(formModel);
+      }
+      return {
+        field: schema.field,
+        label: schema.label,
+        labelColProps: schema.labelColProps || propsData.labelColProps,
+        wrapperColProps: schema.wrapperColProps || propsData.wrapperColProps,
+        rules: schema.rules,
+        disabled,
+        help: schema.help,
+        extra: schema.extra,
+        required: schema.required,
+        ...propsData.baseFormItemProps || {},
+        ...schema.formItemProps || {}
+      };
+    };
+    const getPlaceholderText = (schema) => {
+      var _a;
+      const propsData = vue.unref(getProps);
+      if ((_a = schema.componentProps) == null ? void 0 : _a.placeholder) {
+        return schema.componentProps.placeholder;
+      }
+      if (!propsData.autoSetPlaceHolder) {
+        return "";
+      }
+      const componentType = typeof schema.component === "string" ? schema.component : "";
+      return getPlaceholder(componentType, schema.label);
+    };
+    const handleSubmit = async (values) => {
+      var _a;
+      try {
+        submitLoading.value = true;
+        const errors = await ((_a = formRef.value) == null ? void 0 : _a.validate());
+        if (!errors) {
+          emit("submit", values);
+        }
+      } finally {
+        submitLoading.value = false;
+      }
+    };
+    const handleReset = () => {
+      var _a;
+      (_a = formRef.value) == null ? void 0 : _a.resetFields();
+      emit("reset");
+    };
+    const getFieldsValue = () => {
+      return { ...formModel };
+    };
+    const setFieldsValue = (values) => {
+      Object.keys(values).forEach((key) => {
+        if (key in formModel) {
+          formModel[key] = values[key];
+        }
+      });
+    };
+    const resetFields = () => {
+      var _a;
+      (_a = formRef.value) == null ? void 0 : _a.resetFields();
+    };
+    const validate = async () => {
+      var _a;
+      return (_a = formRef.value) == null ? void 0 : _a.validate();
+    };
+    const clearValidate = (field) => {
+      var _a;
+      (_a = formRef.value) == null ? void 0 : _a.clearValidate(field);
+    };
+    const updateSchema = (schema) => {
+      const schemas = Array.isArray(schema) ? schema : [schema];
+      schemas.forEach((item) => {
+        const index = internalSchemas.value.findIndex((s) => s.field === item.field);
+        if (index !== -1) {
+          internalSchemas.value[index] = { ...internalSchemas.value[index], ...item };
+        }
+      });
+    };
+    const removeSchema = (field) => {
+      const fields = Array.isArray(field) ? field : [field];
+      fields.forEach((f) => {
+        const index = internalSchemas.value.findIndex((s) => s.field === f);
+        if (index !== -1) {
+          internalSchemas.value.splice(index, 1);
+          delete formModel[f];
+        }
+      });
+    };
+    const getSchema = (field) => {
+      const schemas = internalSchemas.value.length > 0 ? internalSchemas.value : props.schemas || [];
+      if (!field) return schemas;
+      return schemas.find((s) => s.field === field);
+    };
+    const resetSchema = (schemas) => {
+      internalSchemas.value = [...schemas];
+      initFormModel();
+    };
+    const setProps = (formProps) => {
+      dynamicProps.value = { ...dynamicProps.value, ...formProps };
+      if (formProps.schemas && Array.isArray(formProps.schemas)) {
+        internalSchemas.value = [...formProps.schemas];
+        initFormModel();
+      }
+    };
+    const scrollToField = (name, options) => {
+      vue.nextTick(() => {
+        const element = document.querySelector(`[data-field="${name}"]`);
+        if (element) {
+          element.scrollIntoView(options);
+        }
+      });
+    };
+    __expose({
+      formRef,
+      formModel,
+      handleSubmit,
+      getVisibleSchemas,
+      getColProps,
+      getFormItemBindValue,
+      getPlaceholderText,
+      getFieldsValue,
+      setFieldsValue,
+      resetFields,
+      validate,
+      clearValidate,
+      updateSchema,
+      removeSchema,
+      getSchema,
+      resetSchema,
+      setProps,
+      scrollToField
+    });
+    const stopSchemasWatch = vue.watch(
+      () => props.schemas,
+      (newSchemas) => {
+        if (newSchemas) {
+          internalSchemas.value = [...newSchemas];
+          initFormModel();
+        }
+      },
+      { immediate: true, deep: true }
+    );
+    vue.onMounted(() => {
+      vue.nextTick(() => {
+        emit("register", {
+          formRef,
+          formModel,
+          getFieldsValue,
+          setFieldsValue,
+          resetFields,
+          validate,
+          clearValidate,
+          updateSchema,
+          removeSchema,
+          getSchema,
+          resetSchema,
+          setProps,
+          scrollToField,
+          handleSubmit
+        });
+      });
+    });
+    vue.onBeforeUnmount(() => {
+      stopSchemasWatch();
+      Object.keys(formModel).forEach((key) => {
+        delete formModel[key];
+      });
+      internalSchemas.value = [];
+      dynamicProps.value = {};
+    });
+    return (_ctx, _cache) => {
+      const _component_a_form_item = vue.resolveComponent("a-form-item");
+      const _component_a_col = vue.resolveComponent("a-col");
+      const _component_a_button = vue.resolveComponent("a-button");
+      const _component_a_space = vue.resolveComponent("a-space");
+      const _component_a_row = vue.resolveComponent("a-row");
+      const _component_a_form = vue.resolveComponent("a-form");
+      return vue.openBlock(), vue.createBlock(_component_a_form, vue.mergeProps({
+        ref_key: "formRef",
+        ref: formRef
+      }, getBindValue.value, {
+        model: formModel,
+        onSubmit: handleSubmit
+      }), {
+        default: vue.withCtx(() => [
+          vue.createVNode(_component_a_row, vue.normalizeProps(vue.guardReactiveProps(getRow.value)), {
+            default: vue.withCtx(() => [
+              (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(getVisibleSchemas(), (schema) => {
+                return vue.openBlock(), vue.createBlock(_component_a_col, vue.mergeProps({
+                  key: schema.key || schema.field,
+                  ref_for: true
+                }, getColProps(schema)), {
+                  default: vue.withCtx(() => [
+                    schema.render ? (vue.openBlock(), vue.createBlock(vue.resolveDynamicComponent(schema.render(schema, formModel)), { key: 0 })) : (vue.openBlock(), vue.createBlock(_component_a_form_item, vue.mergeProps({
+                      key: 1,
+                      ref_for: true
+                    }, getFormItemBindValue(schema)), {
+                      default: vue.withCtx(() => [
+                        schema.renderComponentContent ? (vue.openBlock(), vue.createBlock(vue.resolveDynamicComponent(schema.renderComponentContent(schema, formModel)), { key: 0 })) : (vue.openBlock(), vue.createBlock(vue.resolveDynamicComponent(vue.unref(getComponent)(schema.component)), vue.mergeProps({
+                          key: 1,
+                          modelValue: formModel[schema.field],
+                          "onUpdate:modelValue": ($event) => formModel[schema.field] = $event,
+                          placeholder: getPlaceholderText(schema)
+                        }, { ref_for: true }, schema.componentProps), null, 16, ["modelValue", "onUpdate:modelValue", "placeholder"]))
+                      ]),
+                      _: 2
+                    }, 1040))
+                  ]),
+                  _: 2
+                }, 1040);
+              }), 128)),
+              getActionProps.value.showActionButtons ? (vue.openBlock(), vue.createBlock(_component_a_col, vue.normalizeProps(vue.mergeProps({ key: 0 }, getActionProps.value.actionColOptions)), {
+                default: vue.withCtx(() => [
+                  vue.createVNode(_component_a_form_item, null, {
+                    default: vue.withCtx(() => [
+                      vue.createVNode(_component_a_space, null, {
+                        default: vue.withCtx(() => [
+                          getActionProps.value.showSubmitButton ? (vue.openBlock(), vue.createBlock(_component_a_button, {
+                            key: 0,
+                            type: "primary",
+                            "html-type": "submit",
+                            loading: submitLoading.value
+                          }, {
+                            default: vue.withCtx(() => [
+                              vue.createTextVNode(vue.toDisplayString(getActionProps.value.submitButtonText), 1)
+                            ]),
+                            _: 1
+                          }, 8, ["loading"])) : vue.createCommentVNode("", true),
+                          getActionProps.value.showResetButton ? (vue.openBlock(), vue.createBlock(_component_a_button, {
+                            key: 1,
+                            onClick: handleReset
+                          }, {
+                            default: vue.withCtx(() => [
+                              vue.createTextVNode(vue.toDisplayString(getActionProps.value.resetButtonText), 1)
+                            ]),
+                            _: 1
+                          })) : vue.createCommentVNode("", true),
+                          vue.renderSlot(_ctx.$slots, "actions")
+                        ]),
+                        _: 3
+                      })
+                    ]),
+                    _: 3
+                  })
+                ]),
+                _: 3
+              }, 16)) : vue.createCommentVNode("", true)
+            ]),
+            _: 3
+          }, 16)
+        ]),
+        _: 3
+      }, 16, ["model"]);
+    };
+  }
+});
+function useForm(options = {}) {
+  const formRef = vue.ref(null);
+  const formModel = vue.reactive({});
+  const loadedRef = vue.ref(false);
+  const propsRef = vue.ref({});
+  const initFormModel = () => {
+    var _a, _b;
+    const schemas = vue.unref(((_b = (_a = formRef.value) == null ? void 0 : _a.getSchema) == null ? void 0 : _b.call(_a)) || options.schemas || []);
+    schemas.forEach((schema) => {
+      if (schema.defaultValue !== void 0) {
+        formModel[schema.field] = schema.defaultValue;
+      }
+    });
+  };
+  const register = async (formInstance) => {
+    await vue.nextTick();
+    formRef.value = formInstance;
+    loadedRef.value = true;
+    if (options && Object.keys(options).length > 0) {
+      await setProps(options);
+    }
+    initFormModel();
+  };
+  const getForm = () => {
+    const form = vue.unref(formRef);
+    if (!form) {
+      console.error("表单实例尚未注册，请确保组件已挂载并正确使用 @register");
+    }
+    return form;
+  };
+  const getFieldsValue = () => {
+    const form = getForm();
+    if (!form) return {};
+    if (form.getFieldsValue) {
+      return form.getFieldsValue();
+    }
+    return { ...formModel };
+  };
+  const setFieldsValue = async (values) => {
+    const form = getForm();
+    if (!form) return;
+    if (form.setFieldsValue) {
+      await form.setFieldsValue(values);
+    } else {
+      Object.keys(values).forEach((key) => {
+        formModel[key] = values[key];
+      });
+    }
+  };
+  const resetFields = async () => {
+    var _a;
+    const form = getForm();
+    if (!form) return;
+    if (form.resetFields) {
+      await form.resetFields();
+    } else if ((_a = form.formRef) == null ? void 0 : _a.value) {
+      await form.formRef.value.resetFields();
+    }
+  };
+  const validate = async (nameList) => {
+    var _a;
+    const form = getForm();
+    if (!form) return Promise.reject("表单实例不存在");
+    if (form.validate) {
+      return await form.validate(nameList);
+    } else if ((_a = form.formRef) == null ? void 0 : _a.value) {
+      return await form.formRef.value.validate(nameList);
+    }
+    return Promise.resolve(void 0);
+  };
+  const validateFields = async (nameList) => {
+    return await validate(nameList);
+  };
+  const clearValidate = async (field) => {
+    var _a;
+    const form = getForm();
+    if (!form) return;
+    if (form.clearValidate) {
+      await form.clearValidate(field);
+    } else if ((_a = form.formRef) == null ? void 0 : _a.value) {
+      await form.formRef.value.clearValidate(field);
+    }
+  };
+  const submit = async () => {
+    const form = getForm();
+    if (!form) return;
+    if (form.handleSubmit) {
+      return await form.handleSubmit();
+    }
+    await validate();
+    return getFieldsValue();
+  };
+  const updateSchema = async (schema) => {
+    const form = getForm();
+    if (!form) return;
+    const schemaList = Array.isArray(schema) ? schema : [schema];
+    if (form.updateSchema) {
+      await form.updateSchema(schemaList);
+    }
+  };
+  const resetSchema = async (schemas) => {
+    const form = getForm();
+    if (!form) return;
+    if (form.resetSchema) {
+      await form.resetSchema(schemas);
+    }
+  };
+  const removeSchemaByField = async (field) => {
+    const form = getForm();
+    if (!form) return;
+    const fields = Array.isArray(field) ? field : [field];
+    if (form.removeSchema) {
+      await form.removeSchema(fields);
+    }
+    fields.forEach((f) => {
+      if (f in formModel) {
+        delete formModel[f];
+      }
+    });
+  };
+  const appendSchemaByField = async (schema, prefixField, first = false) => {
+    var _a;
+    const form = getForm();
+    if (!form) return;
+    const schemas = ((_a = form.getSchema) == null ? void 0 : _a.call(form)) || [];
+    const schemaList = Array.isArray(schema) ? schema : [schema];
+    if (prefixField) {
+      const index = schemas.findIndex((s) => s.field === prefixField);
+      if (index !== -1) {
+        const insertIndex = first ? index : index + 1;
+        schemas.splice(insertIndex, 0, ...schemaList);
+      }
+    } else {
+      if (first) {
+        schemas.unshift(...schemaList);
+      } else {
+        schemas.push(...schemaList);
+      }
+    }
+    if (form.updateSchema) {
+      await form.updateSchema(schemas);
+    }
+    schemaList.forEach((s) => {
+      if (s.defaultValue !== void 0) {
+        formModel[s.field] = s.defaultValue;
+      }
+    });
+  };
+  const getSchema = (field) => {
+    const form = getForm();
+    if (!form) return void 0;
+    if (form.getSchema) {
+      return form.getSchema(field);
+    }
+    return void 0;
+  };
+  const setProps = async (formProps) => {
+    propsRef.value = { ...propsRef.value, ...formProps };
+    const form = getForm();
+    if (!form) {
+      return;
+    }
+    if (form.setProps) {
+      await form.setProps(formProps);
+    }
+  };
+  const scrollToField = async (name, options2) => {
+    const form = getForm();
+    if (!form) return;
+    if (form.scrollToField) {
+      await form.scrollToField(name, options2);
+    }
+  };
+  const formMethods = {
+    getFieldsValue,
+    setFieldsValue,
+    resetFields,
+    validate,
+    validateFields,
+    clearValidate,
+    submit,
+    updateSchema,
+    resetSchema,
+    removeSchemaByField,
+    appendSchemaByField,
+    getSchema,
+    setProps,
+    scrollToField,
+    formModel,
+    formRef,
+    getForm
+  };
+  return [register, formMethods];
+}
+function createFormSchema(schemas) {
+  return schemas.map((schema, index) => ({
+    key: schema.key || `${schema.field}_${index}`,
+    ...schema
+  }));
+}
+function mergeFormSchemas(...schemas) {
+  return schemas.flat();
+}
+function formatDate(date, format = "YYYY-MM-DD HH:mm:ss") {
+  const d = typeof date === "number" ? new Date(date) : date;
+  const year = d.getFullYear();
+  const month = String(d.getMonth() + 1).padStart(2, "0");
+  const day = String(d.getDate()).padStart(2, "0");
+  const hours = String(d.getHours()).padStart(2, "0");
+  const minutes = String(d.getMinutes()).padStart(2, "0");
+  const seconds = String(d.getSeconds()).padStart(2, "0");
+  return format.replace("YYYY", String(year)).replace("MM", month).replace("DD", day).replace("HH", hours).replace("mm", minutes).replace("ss", seconds);
+}
+function formatNumber(num) {
+  return num.toLocaleString("zh-CN");
+}
+function formatFileSize(bytes) {
+  if (bytes === 0) return "0 B";
+  const k = 1024;
+  const sizes = ["B", "KB", "MB", "GB", "TB"];
+  const i = Math.floor(Math.log(bytes) / Math.log(k));
+  return `${parseFloat((bytes / Math.pow(k, i)).toFixed(2))} ${sizes[i]}`;
+}
+function isValidEmail(email) {
+  const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+  return emailRegex.test(email);
+}
+function isValidPhone(phone) {
+  const phoneRegex = /^1[3-9]\d{9}$/;
+  return phoneRegex.test(phone);
+}
+function isValidUrl(url) {
+  try {
+    new URL(url);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function isValidIdCard(idCard) {
+  const idCardRegex = /^[1-9]\d{5}(18|19|20)\d{2}(0[1-9]|1[0-2])(0[1-9]|[12]\d|3[01])\d{3}[\dXx]$/;
+  return idCardRegex.test(idCard);
+}
+function useDebounce(value, delay = 300) {
+  const debouncedValue = vue.ref(value.value);
+  let timer = null;
+  const updateValue = (newValue) => {
+    if (timer) {
+      clearTimeout(timer);
+    }
+    timer = setTimeout(() => {
+      debouncedValue.value = newValue;
+    }, delay);
+  };
+  vue.watch(
+    value,
+    (newValue) => {
+      updateValue(newValue);
+    },
+    { immediate: true }
+  );
+  vue.onBeforeUnmount(() => {
+    if (timer) {
+      clearTimeout(timer);
+    }
+  });
+  return debouncedValue;
+}
+function useLocalStorage(key, initialValue) {
+  let initialStoredValue;
+  try {
+    const item = window.localStorage.getItem(key);
+    initialStoredValue = item ? JSON.parse(item) : initialValue;
+  } catch (error) {
+    console.error(`Error reading localStorage key "${key}":`, error);
+    initialStoredValue = initialValue;
+  }
+  const storedValue = vue.ref(initialStoredValue);
+  const setValue = (value) => {
+    try {
+      const valueToStore = value instanceof Function ? value(storedValue.value) : value;
+      storedValue.value = valueToStore;
+      window.localStorage.setItem(key, JSON.stringify(valueToStore));
+    } catch (error) {
+      console.error(`Error setting localStorage key "${key}":`, error);
+    }
+  };
+  vue.watch(
+    storedValue,
+    (newValue) => {
+      try {
+        window.localStorage.setItem(key, JSON.stringify(newValue));
+      } catch (error) {
+        console.error(`Error syncing localStorage key "${key}":`, error);
+      }
+    },
+    { deep: true }
+  );
+  return [storedValue, setValue];
+}
+function useToggle(initialValue = false) {
+  const value = vue.ref(initialValue);
+  const toggle = () => {
+    value.value = !value.value;
+  };
+  const setTrue = () => {
+    value.value = true;
+  };
+  const setFalse = () => {
+    value.value = false;
+  };
+  return [value, toggle, setTrue, setFalse];
+}
+exports.BasicForm = _sfc_main;
+exports.componentMap = componentMap;
+exports.createFormSchema = createFormSchema;
+exports.formatDate = formatDate;
+exports.formatFileSize = formatFileSize;
+exports.formatNumber = formatNumber;
+exports.getComponent = getComponent;
+exports.isValidEmail = isValidEmail;
+exports.isValidIdCard = isValidIdCard;
+exports.isValidPhone = isValidPhone;
+exports.isValidUrl = isValidUrl;
+exports.mergeFormSchemas = mergeFormSchemas;
+exports.registerComponent = registerComponent;
+exports.useDebounce = useDebounce;
+exports.useForm = useForm;
+exports.useLocalStorage = useLocalStorage;
+exports.useToggle = useToggle;
+//# sourceMappingURL=index.cjs.js.map