@funcho/ui 1.0.0

package/dist/cjs/node_modules/.pnpm/element-plus@2.13.1_patch_hash_ced11f8511a7bfaac0aa406d84db594ed486bf3fc0839b47dbe1220b_eeafcc9acb73a92d66a934304ea2d16a/node_modules/element-plus/es/components/dialog/src/dialog2.js

@@ -0,0 +1,198 @@
+'use strict';
+
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: 'Module' } });
+
+const vue = require('vue');
+const index$3 = require('../../overlay/index.js');
+const focusTrap = require('../../focus-trap/src/focus-trap.js');
+const index$2 = require('../../teleport/index.js');
+const dialogContent2 = require('./dialog-content2.js');
+const constants = require('./constants.js');
+const dialog = require('./dialog.js');
+const useDialog = require('./use-dialog.js');
+const pluginVue_exportHelper = require('../../../_virtual/plugin-vue_export-helper.js');
+const index = require('../../../hooks/use-deprecated/index.js');
+const index$1 = require('../../../hooks/use-namespace/index.js');
+const index$4 = require('../../../hooks/use-same-target/index.js');
+
+const _hoisted_1 = ["aria-label", "aria-labelledby", "aria-describedby"];
+const _sfc_main = vue.defineComponent({
+  ...{
+    name: "ElDialog",
+    inheritAttrs: false
+  },
+  __name: "dialog",
+  props: dialog.dialogProps,
+  emits: dialog.dialogEmits,
+  setup(__props, { expose: __expose }) {
+    const props = __props;
+    const slots = vue.useSlots();
+    index.useDeprecated(
+      {
+        scope: "el-dialog",
+        from: "the title slot",
+        replacement: "the header slot",
+        version: "3.0.0",
+        ref: "https://element-plus.org/en-US/component/dialog.html#slots"
+      },
+      vue.computed(() => !!slots.title)
+    );
+    const ns = index$1.useNamespace("dialog");
+    const dialogRef = vue.ref();
+    const headerRef = vue.ref();
+    const dialogContentRef = vue.ref();
+    const {
+      visible,
+      titleId,
+      bodyId,
+      style,
+      overlayDialogStyle,
+      rendered,
+      transitionConfig,
+      zIndex,
+      _draggable,
+      _alignCenter,
+      _overflow,
+      handleClose,
+      onModalClick,
+      onOpenAutoFocus,
+      onCloseAutoFocus,
+      onCloseRequested,
+      onFocusoutPrevented,
+      closing
+    } = useDialog.useDialog(props, dialogRef);
+    vue.provide(constants.dialogInjectionKey, {
+      dialogRef,
+      headerRef,
+      bodyId,
+      ns,
+      rendered,
+      style
+    });
+    const overlayEvent = index$4.useSameTarget(onModalClick);
+    const penetrable = vue.computed(
+      () => props.modalPenetrable && !props.modal && !props.fullscreen
+    );
+    const resetPosition = () => {
+      var _a;
+      (_a = dialogContentRef.value) == null ? void 0 : _a.resetPosition();
+    };
+    __expose({
+      visible,
+      dialogContentRef,
+      resetPosition,
+      handleClose
+    });
+    return (_ctx, _cache) => {
+      return vue.openBlock(), vue.createBlock(vue.unref(index$2.ElTeleport), {
+        to: _ctx.appendTo,
+        disabled: _ctx.appendTo !== "body" ? false : !_ctx.appendToBody
+      }, {
+        default: vue.withCtx(() => [
+          vue.createVNode(
+            vue.Transition,
+            vue.mergeProps(vue.unref(transitionConfig), { persisted: "" }),
+            {
+              default: vue.withCtx(() => {
+                var _a;
+                return [
+                  vue.withDirectives(vue.createVNode(vue.unref(index$3.ElOverlay), {
+                    "custom-mask-event": "",
+                    mask: _ctx.modal,
+                    "overlay-class": [
+                      (_a = _ctx.modalClass) != null ? _a : "",
+                      `${vue.unref(ns).namespace.value}-modal-dialog`,
+                      vue.unref(ns).is("penetrable", penetrable.value)
+                    ],
+                    "z-index": vue.unref(zIndex)
+                  }, {
+                    default: vue.withCtx(() => [
+                      vue.createElementVNode("div", {
+                        role: "dialog",
+                        "aria-modal": "true",
+                        "aria-label": _ctx.title || void 0,
+                        "aria-labelledby": !_ctx.title ? vue.unref(titleId) : void 0,
+                        "aria-describedby": vue.unref(bodyId),
+                        class: vue.normalizeClass([
+                          `${vue.unref(ns).namespace.value}-overlay-dialog`,
+                          vue.unref(ns).is("closing", vue.unref(closing))
+                        ]),
+                        style: vue.normalizeStyle(vue.unref(overlayDialogStyle)),
+                        onClick: _cache[0] || (_cache[0] = (...args) => vue.unref(overlayEvent).onClick && vue.unref(overlayEvent).onClick(...args)),
+                        onMousedown: _cache[1] || (_cache[1] = (...args) => vue.unref(overlayEvent).onMousedown && vue.unref(overlayEvent).onMousedown(...args)),
+                        onMouseup: _cache[2] || (_cache[2] = (...args) => vue.unref(overlayEvent).onMouseup && vue.unref(overlayEvent).onMouseup(...args))
+                      }, [
+                        vue.createVNode(vue.unref(focusTrap.default), {
+                          loop: "",
+                          trapped: vue.unref(visible),
+                          "focus-start-el": "container",
+                          onFocusAfterTrapped: vue.unref(onOpenAutoFocus),
+                          onFocusAfterReleased: vue.unref(onCloseAutoFocus),
+                          onFocusoutPrevented: vue.unref(onFocusoutPrevented),
+                          onReleaseRequested: vue.unref(onCloseRequested)
+                        }, {
+                          default: vue.withCtx(() => [
+                            vue.unref(rendered) ? (vue.openBlock(), vue.createBlock(dialogContent2.default, vue.mergeProps({
+                              key: 0,
+                              ref_key: "dialogContentRef",
+                              ref: dialogContentRef
+                            }, _ctx.$attrs, {
+                              center: _ctx.center,
+                              "align-center": vue.unref(_alignCenter),
+                              "close-icon": _ctx.closeIcon,
+                              draggable: vue.unref(_draggable),
+                              overflow: vue.unref(_overflow),
+                              fullscreen: _ctx.fullscreen,
+                              "header-class": _ctx.headerClass,
+                              "body-class": _ctx.bodyClass,
+                              "footer-class": _ctx.footerClass,
+                              "show-close": _ctx.showClose,
+                              title: _ctx.title,
+                              "aria-level": _ctx.headerAriaLevel,
+                              onClose: vue.unref(handleClose)
+                            }), vue.createSlots({
+                              header: vue.withCtx(() => [
+                                !_ctx.$slots.title ? vue.renderSlot(_ctx.$slots, "header", {
+                                  key: 0,
+                                  close: vue.unref(handleClose),
+                                  titleId: vue.unref(titleId),
+                                  titleClass: vue.unref(ns).e("title")
+                                }) : vue.renderSlot(_ctx.$slots, "title", { key: 1 })
+                              ]),
+                              default: vue.withCtx(() => [
+                                vue.renderSlot(_ctx.$slots, "default")
+                              ]),
+                              _: 2
+                            }, [
+                              _ctx.$slots.footer ? {
+                                name: "footer",
+                                fn: vue.withCtx(() => [
+                                  vue.renderSlot(_ctx.$slots, "footer")
+                                ]),
+                                key: "0"
+                              } : void 0
+                            ]), 1040, ["center", "align-center", "close-icon", "draggable", "overflow", "fullscreen", "header-class", "body-class", "footer-class", "show-close", "title", "aria-level", "onClose"])) : vue.createCommentVNode("v-if", true)
+                          ]),
+                          _: 3
+                        }, 8, ["trapped", "onFocusAfterTrapped", "onFocusAfterReleased", "onFocusoutPrevented", "onReleaseRequested"])
+                      ], 46, _hoisted_1)
+                    ]),
+                    _: 3
+                  }, 8, ["mask", "overlay-class", "z-index"]), [
+                    [vue.vShow, vue.unref(visible)]
+                  ])
+                ];
+              }),
+              _: 3
+            },
+            16
+          )
+        ]),
+        _: 3
+      }, 8, ["to", "disabled"]);
+    };
+  }
+});
+var Dialog = /* @__PURE__ */ pluginVue_exportHelper.default(_sfc_main, [["__file", "/home/runner/work/element-plus/element-plus/packages/components/dialog/src/dialog.vue"]]);
+
+exports.default = Dialog;

package/dist/cjs/node_modules/.pnpm/element-plus@2.13.1_patch_hash_ced11f8511a7bfaac0aa406d84db594ed486bf3fc0839b47dbe1220b_eeafcc9acb73a92d66a934304ea2d16a/node_modules/element-plus/es/components/dialog/src/use-dialog.js

@@ -0,0 +1,278 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const vue = require('vue');
+const constants = require('./constants.js');
+const index$3 = require('../../../hooks/use-lockscreen/index.js');
+const index = require('../../../hooks/use-z-index/index.js');
+const index$1 = require('../../../hooks/use-id/index.js');
+const useGlobalConfig = require('../../config-provider/src/hooks/use-global-config.js');
+const index$2 = require('../../../hooks/use-namespace/index.js');
+const style = require('../../../utils/dom/style.js');
+const shared_esmBundler = require('../../../../../../../@vue_shared@3.5.22/node_modules/@vue/shared/dist/shared.esm-bundler.js');
+const error = require('../../../utils/error.js');
+const event = require('../../../constants/event.js');
+const index$4 = require('../../../../../../../@vueuse_shared@10.11.1_vue@3.5.22_typescript@5.9.3_/node_modules/@vueuse/shared/index.js');
+
+const COMPONENT_NAME = "ElDialog";
+const useDialog = (props, targetRef) => {
+  var _a;
+  const instance = vue.getCurrentInstance();
+  const emit = instance.emit;
+  const { nextZIndex } = index.useZIndex();
+  let lastPosition = "";
+  const titleId = index$1.useId();
+  const bodyId = index$1.useId();
+  const visible = vue.ref(false);
+  const closed = vue.ref(false);
+  const rendered = vue.ref(false);
+  const zIndex = vue.ref((_a = props.zIndex) != null ? _a : nextZIndex());
+  const closing = vue.ref(false);
+  let openTimer = void 0;
+  let closeTimer = void 0;
+  const config = useGlobalConfig.useGlobalConfig();
+  const namespace = vue.computed(() => {
+    var _a2, _b;
+    return (_b = (_a2 = config.value) == null ? void 0 : _a2.namespace) != null ? _b : index$2.defaultNamespace;
+  });
+  const globalConfig = vue.computed(() => {
+    var _a2;
+    return (_a2 = config.value) == null ? void 0 : _a2.dialog;
+  });
+  const style$1 = vue.computed(() => {
+    const style2 = {};
+    const varPrefix = `--${namespace.value}-dialog`;
+    if (!props.fullscreen) {
+      if (props.top) {
+        style2[`${varPrefix}-margin-top`] = props.top;
+      }
+      const width = style.addUnit(props.width);
+      if (width) {
+        style2[`${varPrefix}-width`] = width;
+      }
+    }
+    return style2;
+  });
+  const _draggable = vue.computed(
+    () => {
+      var _a2, _b, _c;
+      return ((_c = (_b = props.draggable) != null ? _b : (_a2 = globalConfig.value) == null ? void 0 : _a2.draggable) != null ? _c : false) && !props.fullscreen;
+    }
+  );
+  const _alignCenter = vue.computed(
+    () => {
+      var _a2, _b, _c;
+      return (_c = (_b = props.alignCenter) != null ? _b : (_a2 = globalConfig.value) == null ? void 0 : _a2.alignCenter) != null ? _c : false;
+    }
+  );
+  const _overflow = vue.computed(
+    () => {
+      var _a2, _b, _c;
+      return (_c = (_b = props.overflow) != null ? _b : (_a2 = globalConfig.value) == null ? void 0 : _a2.overflow) != null ? _c : false;
+    }
+  );
+  const overlayDialogStyle = vue.computed(() => {
+    if (_alignCenter.value) {
+      return { display: "flex" };
+    }
+    return {};
+  });
+  const transitionConfig = vue.computed(() => {
+    var _a2, _b, _c;
+    const transition = (_c = (_b = props.transition) != null ? _b : (_a2 = globalConfig.value) == null ? void 0 : _a2.transition) != null ? _c : constants.DEFAULT_DIALOG_TRANSITION;
+    const baseConfig = {
+      name: transition,
+      onAfterEnter: afterEnter,
+      onBeforeLeave: beforeLeave,
+      onAfterLeave: afterLeave
+    };
+    if (shared_esmBundler.isObject(transition)) {
+      const config2 = { ...transition };
+      const _mergeHook = (userHook, defaultHook) => {
+        return (el) => {
+          if (shared_esmBundler.isArray(userHook)) {
+            userHook.forEach((fn) => {
+              if (shared_esmBundler.isFunction(fn))
+                fn(el);
+            });
+          } else if (shared_esmBundler.isFunction(userHook)) {
+            userHook(el);
+          }
+          defaultHook();
+        };
+      };
+      config2.onAfterEnter = _mergeHook(config2.onAfterEnter, afterEnter);
+      config2.onBeforeLeave = _mergeHook(config2.onBeforeLeave, beforeLeave);
+      config2.onAfterLeave = _mergeHook(config2.onAfterLeave, afterLeave);
+      if (!config2.name) {
+        config2.name = constants.DEFAULT_DIALOG_TRANSITION;
+        error.debugWarn(
+          COMPONENT_NAME,
+          `transition.name is missing when using object syntax, fallback to '${constants.DEFAULT_DIALOG_TRANSITION}'`
+        );
+      }
+      return config2;
+    }
+    return baseConfig;
+  });
+  function afterEnter() {
+    emit("opened");
+  }
+  function afterLeave() {
+    emit("closed");
+    emit(event.UPDATE_MODEL_EVENT, false);
+    if (props.destroyOnClose) {
+      rendered.value = false;
+    }
+    closing.value = false;
+  }
+  function beforeLeave() {
+    closing.value = true;
+    emit("close");
+  }
+  function open() {
+    closeTimer == null ? void 0 : closeTimer();
+    openTimer == null ? void 0 : openTimer();
+    if (props.openDelay && props.openDelay > 0) {
+      ({ stop: openTimer } = index$4.useTimeoutFn(() => doOpen(), props.openDelay));
+    } else {
+      doOpen();
+    }
+  }
+  function close() {
+    openTimer == null ? void 0 : openTimer();
+    closeTimer == null ? void 0 : closeTimer();
+    if (props.closeDelay && props.closeDelay > 0) {
+      ({ stop: closeTimer } = index$4.useTimeoutFn(() => doClose(), props.closeDelay));
+    } else {
+      doClose();
+    }
+  }
+  function handleClose() {
+    function hide(shouldCancel) {
+      if (shouldCancel)
+        return;
+      closed.value = true;
+      visible.value = false;
+    }
+    if (props.beforeClose) {
+      props.beforeClose(hide);
+    } else {
+      close();
+    }
+  }
+  function onModalClick() {
+    if (props.closeOnClickModal) {
+      handleClose();
+    }
+  }
+  function doOpen() {
+    if (!index$4.isClient)
+      return;
+    visible.value = true;
+  }
+  function doClose() {
+    visible.value = false;
+  }
+  function onOpenAutoFocus() {
+    emit("openAutoFocus");
+  }
+  function onCloseAutoFocus() {
+    emit("closeAutoFocus");
+  }
+  function onFocusoutPrevented(event) {
+    var _a2;
+    if (((_a2 = event.detail) == null ? void 0 : _a2.focusReason) === "pointer") {
+      event.preventDefault();
+    }
+  }
+  if (props.lockScroll) {
+    index$3.useLockscreen(visible);
+  }
+  function onCloseRequested() {
+    if (props.closeOnPressEscape) {
+      handleClose();
+    }
+  }
+  vue.watch(
+    () => props.zIndex,
+    () => {
+      var _a2;
+      zIndex.value = (_a2 = props.zIndex) != null ? _a2 : nextZIndex();
+    }
+  );
+  vue.watch(
+    () => props.modelValue,
+    (val) => {
+      var _a2;
+      if (val) {
+        closed.value = false;
+        closing.value = false;
+        open();
+        rendered.value = true;
+        zIndex.value = (_a2 = props.zIndex) != null ? _a2 : nextZIndex();
+        vue.nextTick(() => {
+          emit("open");
+          if (targetRef.value) {
+            targetRef.value.parentElement.scrollTop = 0;
+            targetRef.value.parentElement.scrollLeft = 0;
+            targetRef.value.scrollTop = 0;
+          }
+        });
+      } else {
+        if (visible.value) {
+          close();
+        }
+      }
+    }
+  );
+  vue.watch(
+    () => props.fullscreen,
+    (val) => {
+      if (!targetRef.value)
+        return;
+      if (val) {
+        lastPosition = targetRef.value.style.transform;
+        targetRef.value.style.transform = "";
+      } else {
+        targetRef.value.style.transform = lastPosition;
+      }
+    }
+  );
+  vue.onMounted(() => {
+    if (props.modelValue) {
+      visible.value = true;
+      rendered.value = true;
+      open();
+    }
+  });
+  return {
+    afterEnter,
+    afterLeave,
+    beforeLeave,
+    handleClose,
+    onModalClick,
+    close,
+    doClose,
+    onOpenAutoFocus,
+    onCloseAutoFocus,
+    onCloseRequested,
+    onFocusoutPrevented,
+    titleId,
+    bodyId,
+    closed,
+    style: style$1,
+    overlayDialogStyle,
+    rendered,
+    visible,
+    zIndex,
+    transitionConfig,
+    _draggable,
+    _alignCenter,
+    _overflow,
+    closing
+  };
+};
+
+exports.useDialog = useDialog;