vue-admin-core/lib/hooks/__shared__/useCorePopup.js

A Component Library for Vue 3

'use strict';

var vue = require('vue');
var elementPlus = require('element-plus');
var shared = require('@formily/shared');
require('../../formily/__builtins__/index.js');
require('../../formily/index.js');
var xeUtils = require('xe-utils');
var utils = require('../../formily/__builtins__/shared/utils.js');
var loading = require('../../formily/__builtins__/shared/loading.js');
var index = require('../../formily/form-button-group/src/index.js');
var resolveComponent = require('../../formily/__builtins__/shared/resolve-component.js');

function _isSlot(s) {
  return typeof s === "function" || Object.prototype.toString.call(s) === "[object Object]" && !vue.isVNode(s);
}
const isPopupTitle = (props) => {
  return shared.isNum(props) || shared.isStr(props) || shared.isBool(props) || utils.isValidElement(props) || shared.isFn(props) || vue.isVNode(props);
};
const getPopupProps = (props) => {
  if (isPopupTitle(props)) {
    return {
      title: props
    };
  } else {
    return props;
  }
};
function useCorePopup(title, PopupComponent, content) {
  const visible = vue.ref(false);
  const okLoading = vue.ref(false);
  const cancelLoading = vue.ref(false);
  const resetLoading = vue.ref(false);
  let openMiddlewares = [];
  let confirmMiddlewares = [];
  let cancelMiddlewares = [];
  let resetMiddlewares = [];
  const dialogProps = vue.ref(getPopupProps(title));
  const initPopupProps = {
    ...dialogProps.value
  };
  vue.watch(visible, (value) => {
    if (!value) {
      openMiddlewares = [];
      confirmMiddlewares = [];
      cancelMiddlewares = [];
      resetMiddlewares = [];
    }
  });
  const dialog = {
    forOpen: (middleware) => {
      if (shared.isFn(middleware)) {
        openMiddlewares.push(middleware);
      }
      return dialog;
    },
    forConfirm: (middleware) => {
      if (shared.isFn(middleware)) {
        confirmMiddlewares.push(middleware);
      }
      return dialog;
    },
    forCancel: (middleware) => {
      if (shared.isFn(middleware)) {
        cancelMiddlewares.push(middleware);
      }
      return dialog;
    },
    forReset: (middleware) => {
      if (shared.isFn(middleware)) {
        resetMiddlewares.push(middleware);
      }
      return dialog;
    },
    reject: async (props) => {
      cancelLoading.value = true;
      const flag = await loading.loading(dialogProps.value.loadingText, () => shared.applyMiddleware(props, cancelMiddlewares));
      cancelLoading.value = false;
      if (dialogProps.value.onCancel) {
        dialogProps.value.onCancel(Boolean(flag), () => {
          dialog.close();
        });
      } else {
        if (xeUtils.isBoolean(flag) && flag === false)
          return;
        dialog.close();
      }
    },
    resolve: async (props) => {
      var _a, _b;
      okLoading.value = true;
      const flag = await shared.applyMiddleware(props, confirmMiddlewares);
      okLoading.value = false;
      if (dialogProps.value.onOK) {
        (_b = (_a = dialogProps.value) == null ? void 0 : _a.onOK) == null ? void 0 : _b.call(_a, Boolean(flag), () => {
          dialog.close();
        });
      } else {
        if (xeUtils.isBoolean(flag) && flag === false)
          return;
        dialog.close();
      }
    },
    reset: async (props) => {
      resetLoading.value = true;
      await shared.applyMiddleware(props, resetMiddlewares);
      resetLoading.value = false;
    },
    beforeOpen: async (props) => {
      const result = await loading.loading(dialogProps.value.loadingText, () => shared.applyMiddleware(props, openMiddlewares));
      return result;
    },
    open: async (props) => {
      const result = await dialog.beforeOpen();
      dialogProps.value = {
        ...initPopupProps,
        ...props ? getPopupProps(props) : {}
      };
      visible.value = true;
      return result;
    },
    close: () => {
      visible.value = false;
    }
  };
  const Footer = vue.defineComponent({
    name: "PopupFooter",
    setup() {
      return () => {
        const {
          cancelButtonProps,
          cancelText,
          okButtonProps,
          okText,
          addonAfter,
          addonBefore,
          addonCenter,
          cancelButtonHidden,
          okButtonHidden
        } = dialogProps.value;
        return vue.createVNode(index.FormButtonGroup, {
          "align": "right"
        }, {
          default: () => [addonBefore, !cancelButtonHidden && vue.createVNode(elementPlus.ElButton, vue.mergeProps(cancelButtonProps, {
            "loading": cancelLoading.value,
            "onClick": (e) => {
              dialog.reject();
            }
          }), {
            default: () => [cancelText || "\u53D6\u6D88"]
          }), addonCenter, !okButtonHidden && vue.createVNode(elementPlus.ElButton, vue.mergeProps({
            "type": "primary"
          }, okButtonProps, {
            "loading": okLoading.value,
            "onClick": (e) => {
              dialog.resolve();
            }
          }), {
            default: () => [okText || "\u786E\u5B9A"]
          }), addonAfter]
        });
      };
    }
  });
  const ContextHolder = vue.defineComponent({
    name: "PopupContextHolder",
    setup() {
      return () => {
        const {
          footer = true,
          title: title2,
          ...reset
        } = dialogProps.value;
        let curestTitle = title2;
        const _slots = {
          default: () => resolveComponent.resolveComponent(content)
        };
        if (typeof title2 !== "string") {
          _slots.header = () => resolveComponent.resolveComponent(title2);
          curestTitle = "";
        }
        if (shared.isBool(footer) && footer) {
          _slots.footer = () => resolveComponent.resolveComponent(vue.createVNode(Footer, dialogProps.value, null));
        }
        if (shared.isFn(footer) || utils.isValidElement(footer)) {
          _slots.footer = resolveComponent.resolveComponent(footer);
        }
        return vue.createVNode(PopupComponent, vue.mergeProps(reset, {
          "title": curestTitle,
          "modelValue": visible.value,
          "onUpdate:modelValue": (v) => visible.value = v
        }), _isSlot(_slots) ? _slots : {
          default: () => [_slots]
        });
      };
    }
  });
  return [dialog, ContextHolder];
}

exports.getPopupProps = getPopupProps;
exports.isPopupTitle = isPopupTitle;
exports.useCorePopup = useCorePopup;
//# sourceMappingURL=useCorePopup.js.map