yanzhen-design-vue/es/components/contacts/src/hook/use-contacts-confirm-models.mjs

import { ref, computed, getCurrentInstance, unref, onUnmounted } from "vue";
import { createWatcher, useDynamicProps } from "@yanzhen-libs/utils-vue";
import { flattenDeep, isFunction, cloneDeep, isArray } from "lodash-es";
import { contactsModelValueProps } from "./use-contacts-model-value.mjs";
function useContactsConfirmModels(_props) {
  var _a;
  const open = ref((_props == null ? void 0 : _props.modalOpen) ?? false);
  const disabled = computed(() => {
    return _props.disabled ?? false;
  });
  const self = (_a = getCurrentInstance()) == null ? void 0 : _a.proxy;
  const watcher = createWatcher();
  const dynamicProp = useDynamicProps();
  const contactsProp = Object.keys(contactsModelValueProps());
  const keys = contactsProp.filter((prop) => {
    switch (true) {
      case (prop.startsWith("onUpdate:") && prop !== "onUpdate:value"):
        return true;
    }
    return dynamicProp.includes(prop);
  });
  const record = ref({});
  const oldRecord = ref({});
  const emitsRecord = ref({});
  const emits = {};
  const models = {};
  function handleSetPropValue(prop, value, immediate = false) {
    if (!immediate && unref(open)) {
      handleImmediateSetPropValue(prop, value, false);
      return;
    }
    const updateFn = flattenDeep([unref(emitsRecord)[`onUpdate:${prop}`]]).filter(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) {
    unref(record)[prop] = clone && typeof value === "object" ? cloneDeep(value) : value;
  }
  function handleImmediateSetOldPropValue(prop, value, clone = true) {
    unref(oldRecord)[prop] = clone && typeof value === "object" ? 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:", "");
        unref(emitsRecord)[prop] = value;
        emits[prop] = (...args) => {
          handleSetPropValue(modelProp, ...args);
        };
        watcher.set(prop, {
          source: () => _props[prop],
          handler(value2) {
            unref(emitsRecord)[prop] = value2;
          },
          debounce: 0,
          deep: true,
          immediate: true
        });
      } else {
        handleImmediateSetPropValue(prop, value);
        watcher.set(prop, {
          source: () => _props[prop],
          handler(value2) {
            if (!unref(open)) {
              handleImmediateSetPropValue(prop, value2);
            }
          },
          debounce: 0,
          deep: true,
          immediate: true
        });
        models[prop] = computed({
          get() {
            return unref(record)[prop];
          },
          set(value2) {
            handleSetPropValue(prop, value2);
          }
        });
      }
    }
  }
  handleVModels();
  watcher.set("open", {
    source: () => 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
  });
  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 = unref(record)[prop];
        if (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 = unref(record);
    for (const prop of Object.keys(models)) {
      handleSetPropValue(prop, props[prop], true);
    }
    return unref(record);
  }
  function handleReset() {
    const props = unref(oldRecord);
    for (const [prop] of Object.entries(models)) {
      handleSetPropValue(prop, props[prop]);
    }
    return unref(record);
  }
  const methods = {
    delete: handleDelete,
    reset: handleReset,
    send: handleSend,
    update: handleUpdate
  };
  return {
    open,
    disabled,
    models,
    emits,
    props: record,
    ...methods
  };
}
export {
  useContactsConfirmModels
};