tav-ui/lib/packages/components/drawer/src/useDrawer2.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');
var uuid = require('../../../utils/uuid2.js');

const isProdMode = () => true;
const dataTransferRef = vue.reactive({});
const visibleData = vue.reactive({});
function useDrawer() {
  if (!vue.getCurrentInstance()) {
    throw new Error("useDrawer() can only be used inside setup() or functional components!");
  }
  const drawer = vue.ref(null);
  const loaded = vue.ref(false);
  const uid = vue.ref("");
  function register(drawerInstance, uuid$1) {
    isProdMode() && core.tryOnUnmounted(() => {
      drawer.value = null;
      loaded.value = null;
      dataTransferRef[vue.unref(uid)] = null;
    });
    if (vue.unref(loaded) && isProdMode() && drawerInstance === vue.unref(drawer)) {
      return;
    }
    uid.value = uuid$1 ?? uuid.buildUUID();
    drawer.value = drawerInstance;
    loaded.value = true;
    drawerInstance.emitVisible = (visible, uid2) => {
      visibleData[uid2] = visible;
    };
  }
  const getInstance = () => {
    const instance = vue.unref(drawer);
    if (!instance) {
      log.error("useDrawer instance is undefined!");
    }
    return instance;
  };
  const methods = {
    setDrawerProps: (props) => {
      getInstance()?.setDrawerProps(props);
    },
    getVisible: vue.computed(() => {
      return visibleData[~~vue.unref(uid)];
    }),
    openDrawer: (visible = true, data, openOnSet = true) => {
      getInstance()?.setDrawerProps({
        visible
      });
      if (!data)
        return;
      if (openOnSet) {
        dataTransferRef[vue.unref(uid)] = null;
        dataTransferRef[vue.unref(uid)] = vue.toRaw(data);
        return;
      }
      const equal = lodashEs.isEqual(vue.toRaw(dataTransferRef[vue.unref(uid)]), vue.toRaw(data));
      if (!equal) {
        dataTransferRef[vue.unref(uid)] = vue.toRaw(data);
      }
    },
    closeDrawer: () => {
      getInstance()?.setDrawerProps({ visible: false });
    }
  };
  return [register, methods];
}
const useDrawerInner = (callbackFn) => {
  const drawerInstanceRef = vue.ref(null);
  const currentInstance = vue.getCurrentInstance();
  const uidRef = vue.ref("");
  if (!vue.getCurrentInstance()) {
    throw new Error("useDrawerInner() can only be used inside setup() or functional components!");
  }
  const getInstance = () => {
    const instance = vue.unref(drawerInstanceRef);
    if (!instance) {
      log.error("useDrawerInner instance is undefined!");
      return;
    }
    return instance;
  };
  const register = (modalInstance, uuid$1) => {
    isProdMode() && core.tryOnUnmounted(() => {
      drawerInstanceRef.value = null;
    });
    uidRef.value = uuid$1 ?? uuid.buildUUID();
    drawerInstanceRef.value = modalInstance;
    currentInstance?.emit("register", modalInstance, uuid$1);
  };
  vue.watchEffect(() => {
    const data = dataTransferRef[vue.unref(uidRef)];
    if (!data)
      return;
    if (!callbackFn || !is.isFunction(callbackFn))
      return;
    vue.nextTick(() => {
      callbackFn(data);
    });
  });
  return [
    register,
    {
      changeLoading: (loading = true) => {
        getInstance()?.setDrawerProps({ loading });
      },
      changeOkLoading: (loading = true) => {
        getInstance()?.setDrawerProps({ confirmLoading: loading });
      },
      getVisible: vue.computed(() => {
        return visibleData[~~vue.unref(uidRef)];
      }),
      closeDrawer: () => {
        getInstance()?.setDrawerProps({ visible: false });
      },
      setDrawerProps: (props) => {
        getInstance()?.setDrawerProps(props);
      }
    }
  ];
};

exports.useDrawer = useDrawer;
exports.useDrawerInner = useDrawerInner;
//# sourceMappingURL=useDrawer2.js.map