yanzhen-design-vue/lib/components/contacts/src/hook/use-contacts-confirm-models.cjs

"use strict";
Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
const vue = require("vue");
const utilsVue = require("@yanzhen-libs/utils-vue");
const lodashEs = require("lodash-es");
const useContactsModelValue = require("./use-contacts-model-value.cjs");
function useContactsConfirmModels(_props) {
  var _a;
  const open = vue.ref((_props == null ? void 0 : _props.modalOpen) ?? false);
  const disabled = vue.computed(() => {
    return _props.disabled ?? false;
  });
  const self = (_a = vue.getCurrentInstance()) == null ? void 0 : _a.proxy;
  const watcher = utilsVue.createWatcher();
  const dynamicProp = utilsVue.useDynamicProps();
  const contactsProp = Object.keys(useContactsModelValue.contactsModelValueProps());
  const keys = contactsProp.filter((prop) => {
    switch (true) {
      case (prop.startsWith("onUpdate:") && prop !== "onUpdate:value"):
        return true;
    }
    return dynamicProp.includes(prop);
  });
  const record = vue.ref({});
  const oldRecord = vue.ref({});
  const emitsRecord = vue.ref({});
  const emits = {};
  const models = {};
  function handleSetPropValue(prop, value, immediate = false) {
    if (!immediate && vue.unref(open)) {
      handleImmediateSetPropValue(prop, value, false);
      return;
    }
    const updateFn = lodashEs.flattenDeep([vue.unref(emitsRecord)[`onUpdate:${prop}`]]).filter(lodashEs.isFunction);
    if (updateFn.length > 0) {
      for (const fun of updateFn) {
        fun(value);
      }
    } else {
      self == null ? void 0 : self.$emit(prop, value);
    }
    handleImmediateSetPropValue(prop, value);
  }
  function handleImmediateSetPropValue(prop, value, clone = true) {
    vue.unref(record)[prop] = clone && typeof value === "object" ? lodashEs.cloneDeep(value) : value;
  }
  function handleImmediateSetOldPropValue(prop, value, clone = true) {
    vue.unref(oldRecord)[prop] = clone && typeof value === "object" ? lodashEs.cloneDeep(value) : value;
  }
  function handleVModels() {
    record.value = {};
    oldRecord.value = {};
    for (const prop of keys) {
      const value = _props[prop];
      if (prop.startsWith("onUpdate:")) {
        const modelProp = prop.replace("onUpdate:", "");
        vue.unref(emitsRecord)[prop] = value;
        emits[prop] = (...args) => {
          handleSetPropValue(modelProp, ...args);
        };
        watcher.set(prop, {
          source: () => _props[prop],
          handler(value2) {
            vue.unref(emitsRecord)[prop] = value2;
          },
          debounce: 0,
          deep: true,
          immediate: true
        });
      } else {
        handleImmediateSetPropValue(prop, value);
        watcher.set(prop, {
          source: () => _props[prop],
          handler(value2) {
            if (!vue.unref(open)) {
              handleImmediateSetPropValue(prop, value2);
            }
          },
          debounce: 0,
          deep: true,
          immediate: true
        });
        models[prop] = vue.computed({
          get() {
            return vue.unref(record)[prop];
          },
          set(value2) {
            handleSetPropValue(prop, value2);
          }
        });
      }
    }
  }
  handleVModels();
  watcher.set("open", {
    source: () => vue.unref(open),
    handler(open2) {
      if (open2 === false) {
        handleVModels();
      }
      for (const [prop] of Object.entries(models)) {
        handleImmediateSetOldPropValue(prop, _props[prop]);
      }
    },
    deep: true,
    debounce: 50,
    immediate: true
  });
  vue.onUnmounted(() => {
    watcher.stop();
  });
  function handleUpdate() {
    record.value = {};
    oldRecord.value = {};
    for (const [prop] of Object.entries(models)) {
      handleImmediateSetPropValue(prop, _props[prop]);
      handleImmediateSetOldPropValue(prop, _props[prop]);
    }
  }
  function handleDelete(item, _index) {
    if (item) {
      for (const prop of Object.keys(models)) {
        const values = vue.unref(record)[prop];
        if (lodashEs.isArray(values)) {
          handleSetPropValue(
            prop,
            values.filter((value) => item.value !== value),
            true
          );
        } else if (values === item.value) {
          handleSetPropValue(prop, void 0, true);
        }
      }
    } else {
      record.value = {};
      handleSend();
    }
  }
  function handleSend() {
    const props = vue.unref(record);
    for (const prop of Object.keys(models)) {
      handleSetPropValue(prop, props[prop], true);
    }
    return vue.unref(record);
  }
  function handleReset() {
    const props = vue.unref(oldRecord);
    for (const [prop] of Object.entries(models)) {
      handleSetPropValue(prop, props[prop]);
    }
    return vue.unref(record);
  }
  const methods = {
    delete: handleDelete,
    reset: handleReset,
    send: handleSend,
    update: handleUpdate
  };
  return {
    open,
    disabled,
    models,
    emits,
    props: record,
    ...methods
  };
}
exports.useContactsConfirmModels = useContactsConfirmModels;