tav-ui/lib/packages/components/modal/src/hooks/useModal2.js

Tav UI

'use strict';

Object.defineProperty(exports, '__esModule', { value: true });

var vue = require('vue');
var core = require('@vueuse/core');
var lodashEs = require('lodash-es');
var is = require('../../../../utils/is2.js');
var log = require('../../../../utils/log2.js');

const dataTransfer = vue.reactive({});
const isProdMode = () => true;
const visibleData = vue.reactive({});
function useModal() {
  const modal = vue.ref(null);
  const loaded = vue.ref(false);
  const uid = vue.ref("");
  function register(modalMethod, uuid) {
    if (!vue.getCurrentInstance())
      throw new Error("useModal() can only be used inside setup() or functional components!");
    uid.value = uuid;
    isProdMode() && vue.onUnmounted(() => {
      modal.value = null;
      loaded.value = false;
      dataTransfer[vue.unref(uid)] = null;
    });
    if (vue.unref(loaded) && isProdMode() && modalMethod === vue.unref(modal))
      return;
    modal.value = modalMethod;
    loaded.value = true;
    modalMethod.emitVisible = (visible, uid2) => {
      visibleData[uid2] = visible;
    };
  }
  const getInstance = () => {
    const instance = vue.unref(modal);
    if (!instance)
      log.error("useModal instance is undefined!");
    return instance;
  };
  const methods = {
    setModalProps: (props) => {
      getInstance()?.setModalProps(props);
    },
    getVisible: vue.computed(() => {
      return visibleData[~~vue.unref(uid)];
    }),
    redoModalHeight: () => {
      getInstance()?.redoModalHeight?.();
    },
    redoThumbHeight: () => {
      getInstance()?.redoThumbHeight?.();
    },
    openModal: (visible = true, data, openOnSet = true) => {
      getInstance()?.setModalProps({
        visible
      });
      if (!data)
        return;
      const id = vue.unref(uid);
      if (openOnSet) {
        dataTransfer[id] = null;
        dataTransfer[id] = vue.toRaw(data);
        return;
      }
      const equal = lodashEs.isEqual(vue.toRaw(dataTransfer[id]), vue.toRaw(data));
      if (!equal)
        dataTransfer[id] = vue.toRaw(data);
    },
    closeModal: () => {
      getInstance()?.setModalProps({ visible: false });
    }
  };
  return [register, methods];
}
const useModalInner = (callbackFn) => {
  const modalInstanceRef = vue.ref(null);
  const currentInstance = vue.getCurrentInstance();
  const uidRef = vue.ref("");
  const getInstance = () => {
    const instance = vue.unref(modalInstanceRef);
    if (!instance)
      log.error("useModalInner instance is undefined!");
    return instance;
  };
  const register = (modalInstance, uuid) => {
    isProdMode() && core.tryOnUnmounted(() => {
      modalInstanceRef.value = null;
    });
    uidRef.value = uuid;
    modalInstanceRef.value = modalInstance;
    currentInstance?.emit("register", modalInstance, uuid);
  };
  vue.watchEffect(() => {
    const data = dataTransfer[vue.unref(uidRef)];
    if (!data)
      return;
    if (!callbackFn || !is.isFunction(callbackFn))
      return;
    vue.nextTick(() => {
      callbackFn(data);
    });
  });
  return [
    register,
    {
      changeLoading: (loading = true) => {
        getInstance()?.setModalProps({ loading });
      },
      getVisible: vue.computed(() => {
        return visibleData[~~vue.unref(uidRef)];
      }),
      changeOkLoading: (loading = true) => {
        getInstance()?.setModalProps({ confirmLoading: loading });
      },
      closeModal: () => {
        getInstance()?.setModalProps({ visible: false });
      },
      setModalProps: (props) => {
        getInstance()?.setModalProps(props);
      },
      redoModalHeight: () => {
        const callRedo = getInstance()?.redoModalHeight;
        callRedo && callRedo();
      },
      redoThumbHeight() {
        getInstance()?.redoThumbHeight?.();
      }
    }
  ];
};

exports.useModal = useModal;
exports.useModalInner = useModalInner;
//# sourceMappingURL=useModal2.js.map