import { defineComponent, shallowRef, watch, onBeforeUnmount, watchEffect, createVNode } from 'vue';
import '../../../utils/index.mjs';
import Content from './Content.mjs';
import { dialogPropTypes } from './IDialogPropTypes.mjs';
import Mask from './Mask.mjs';
import { getUUID, getMotionName } from './util.mjs';
import { initDefaultProps } from '../../../utils/vue/initDefaultProps.mjs';
import { contains } from '../../../utils/dom/contains.mjs';
import { KeyCode } from '../../../utils/KeyCode.mjs';
import { pickAttrs } from '../../../utils/lang/pickAttrs.mjs';
import { classNames } from '../../../utils/dom/class.mjs';
import { omit } from '../../../utils/lang/omit.mjs';

var Dialog = /* @__PURE__ */ defineComponent({
  compatConfig: {
    MODE: 3
  },
  name: "VcDialog",
  inheritAttrs: false,
  props: initDefaultProps({
    ...dialogPropTypes(),
    getOpenCount: Function,
    scrollLocker: Object
  }, {
    mask: true,
    visible: false,
    keyboard: true,
    closable: true,
    maskClosable: true,
    destroyOnClose: false,
    prefixCls: "rc-dialog",
    getOpenCount: () => null,
    focusTriggerAfterClose: true
  }),
  setup(props, {
    attrs,
    slots
  }) {
    const lastOutSideActiveElementRef = shallowRef();
    const wrapperRef = shallowRef();
    const contentRef = shallowRef();
    const animatedVisible = shallowRef(props.visible);
    const ariaIdRef = shallowRef(`vcDialogTitle${getUUID()}`);
    const onDialogVisibleChanged = (newVisible) => {
      var _a, _b;
      if (newVisible) {
        if (!contains(wrapperRef.value, document.activeElement)) {
          lastOutSideActiveElementRef.value = document.activeElement;
          (_a = contentRef.value) == null ? void 0 : _a.focus();
        }
      } else {
        const preAnimatedVisible = animatedVisible.value;
        animatedVisible.value = false;
        if (props.mask && lastOutSideActiveElementRef.value && props.focusTriggerAfterClose) {
          try {
            lastOutSideActiveElementRef.value.focus({
              preventScroll: true
            });
          } catch (e) {
          }
          lastOutSideActiveElementRef.value = null;
        }
        if (preAnimatedVisible)
          (_b = props.afterClose) == null ? void 0 : _b.call(props);
      }
    };
    const onInternalClose = (e) => {
      var _a;
      (_a = props.onClose) == null ? void 0 : _a.call(props, e);
    };
    const contentClickRef = shallowRef(false);
    const contentTimeoutRef = shallowRef();
    const onContentMouseDown = () => {
      clearTimeout(contentTimeoutRef.value);
      contentClickRef.value = true;
    };
    const onContentMouseUp = () => {
      contentTimeoutRef.value = setTimeout(() => {
        contentClickRef.value = false;
      });
    };
    const onWrapperClick = (e) => {
      if (!props.maskClosable)
        return null;
      if (contentClickRef.value)
        contentClickRef.value = false;
      else if (wrapperRef.value === e.target)
        onInternalClose(e);
    };
    const onWrapperKeyDown = (e) => {
      if (props.keyboard && e.keyCode === KeyCode.ESC) {
        e.stopPropagation();
        onInternalClose(e);
        return;
      }
      if (props.visible) {
        if (e.keyCode === KeyCode.TAB)
          contentRef.value.changeActive(!e.shiftKey);
      }
    };
    watch(() => props.visible, () => {
      if (props.visible)
        animatedVisible.value = true;
    }, {
      flush: "post"
    });
    onBeforeUnmount(() => {
      var _a;
      clearTimeout(contentTimeoutRef.value);
      (_a = props.scrollLocker) == null ? void 0 : _a.unLock();
    });
    watchEffect(() => {
      var _a, _b;
      (_a = props.scrollLocker) == null ? void 0 : _a.unLock();
      if (animatedVisible.value)
        (_b = props.scrollLocker) == null ? void 0 : _b.lock();
    });
    return () => {
      const {
        prefixCls,
        mask,
        visible,
        maskTransitionName,
        maskAnimation,
        zIndex,
        wrapClassName,
        rootClassName,
        wrapStyle,
        closable,
        maskProps,
        maskStyle,
        transitionName,
        animation,
        wrapProps,
        title = slots.title
      } = props;
      const {
        style,
        class: className
      } = attrs;
      return createVNode("div", {
        "class": [`${prefixCls}-root`, rootClassName],
        ...pickAttrs(props, {
          data: true
        })
      }, [createVNode(Mask, {
        "prefixCls": prefixCls,
        "visible": mask && visible,
        "motionName": getMotionName(prefixCls, maskTransitionName, maskAnimation),
        "style": {
          zIndex,
          ...maskStyle
        },
        "maskProps": maskProps
      }, null), createVNode("div", {
        "tabIndex": -1,
        "onKeydown": onWrapperKeyDown,
        "class": classNames(`${prefixCls}-wrap`, wrapClassName),
        "ref": wrapperRef,
        "onClick": onWrapperClick,
        "role": "dialog",
        "aria-labelledby": title ? ariaIdRef.value : null,
        "style": {
          zIndex,
          ...wrapStyle,
          display: !animatedVisible.value ? "none" : null
        },
        ...wrapProps
      }, [createVNode(Content, {
        ...omit(props, ["scrollLocker"]),
        "style": style,
        "class": className,
        "onMousedown": onContentMouseDown,
        "onMouseup": onContentMouseUp,
        "ref": contentRef,
        "closable": closable,
        "ariaId": ariaIdRef.value,
        "prefixCls": prefixCls,
        "visible": visible,
        "onClose": onInternalClose,
        "onVisibleChanged": onDialogVisibleChanged,
        "motionName": getMotionName(prefixCls, transitionName, animation)
      }, slots)])]);
    };
  }
});

export { Dialog as default };
//# sourceMappingURL=Dialog.mjs.map
