@gct-paas/core-web 0.1.4-dev.10 → 0.1.4-dev.12

package/es/modules/global-modal/src/components/ModalFooter.vue.d.ts

@@ -122,8 +122,8 @@ declare const __VLS_component: import('vue').DefineComponent<import('vue').Extra
         type: NumberConstructor;
     };
 }>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
-    ok: (...args: any[]) => void;
     cancel: (...args: any[]) => void;
+    ok: (...args: any[]) => void;
 }, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
     visible: {
         type: BooleanConstructor;
@@ -237,29 +237,29 @@ declare const __VLS_component: import('vue').DefineComponent<import('vue').Extra
         type: NumberConstructor;
     };
 }>> & Readonly<{
-    onOk?: ((...args: any[]) => any) | undefined;
     onCancel?: ((...args: any[]) => any) | undefined;
+    onOk?: ((...args: any[]) => any) | undefined;
 }>, {
     visible: boolean;
-    scrollTop: boolean;
+    mask: boolean;
+    loading: boolean;
     draggable: boolean;
+    scrollTop: boolean;
+    confirmLoading: boolean;
+    closable: boolean;
     centered: boolean;
-    cancelText: string;
     okText: string;
+    okType: import('ant-design-vue/es/button').ButtonType;
+    cancelText: string;
+    maskClosable: boolean;
+    destroyOnClose: boolean;
+    keyboard: boolean;
     defaultFullscreen: boolean;
     canFullscreen: boolean;
     wrapperFooterOffset: number;
     useWrapper: boolean;
-    loading: boolean;
     showCancelBtn: boolean;
     showOkBtn: boolean;
-    closable: boolean;
-    confirmLoading: boolean;
-    destroyOnClose: boolean;
-    mask: boolean;
-    maskClosable: boolean;
-    keyboard: boolean;
-    okType: import('ant-design-vue/es/button').ButtonType;
 }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, HTMLDivElement>;
 declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
 export default _default;

package/es/modules/global-modal/src/components/ModalFooter.vue.mjs

@@ -1,44 +1,5 @@
-import { defineComponent, openBlock, createElementBlock, renderSlot, createBlock, unref, mergeProps, withCtx, createTextVNode, toDisplayString, createCommentVNode } from 'vue';
-import { Button } from 'ant-design-vue';
-import { basicProps } from '../props.mjs';
-import { t } from '@gct-paas/core';
-
-const _sfc_main = /* @__PURE__ */ defineComponent({
-  __name: "ModalFooter",
-  props: basicProps,
-  emits: ["ok", "cancel"],
-  setup(__props, { emit: __emit }) {
-    const emit = __emit;
-    function handleOk(e) {
-      emit("ok", e);
-    }
-    function handleCancel(e) {
-      emit("cancel", e);
-    }
-    return (_ctx, _cache) => {
-      return openBlock(), createElementBlock("div", null, [
-        renderSlot(_ctx.$slots, "insertFooter"),
-        _ctx.showCancelBtn ? (openBlock(), createBlock(unref(Button), mergeProps({ key: 0 }, _ctx.cancelButtonProps, { onClick: handleCancel }), {
-          default: withCtx(() => [
-            createTextVNode(toDisplayString(unref(t)(_ctx.cancelText)), 1)
-          ]),
-          _: 1
-        }, 16)) : createCommentVNode("", true),
-        renderSlot(_ctx.$slots, "centerFooter"),
-        _ctx.showOkBtn ? (openBlock(), createBlock(unref(Button), mergeProps({
-          key: 1,
-          type: _ctx.okType,
-          loading: _ctx.confirmLoading
-        }, _ctx.okButtonProps, { onClick: handleOk }), {
-          default: withCtx(() => [
-            createTextVNode(toDisplayString(unref(t)(_ctx.okText)), 1)
-          ]),
-          _: 1
-        }, 16, ["type", "loading"])) : createCommentVNode("", true),
-        renderSlot(_ctx.$slots, "appendFooter")
-      ]);
-    };
-  }
-});
-
-export { _sfc_main as default };
+import ModalFooter_vue_vue_type_script_setup_true_name_BasicModalFooter_lang_default from "./ModalFooter.vue_vue_type_script_setup_true_name_BasicModalFooter_lang.mjs";
+//#region src/modules/global-modal/src/components/ModalFooter.vue
+var ModalFooter_default = ModalFooter_vue_vue_type_script_setup_true_name_BasicModalFooter_lang_default;
+//#endregion
+export { ModalFooter_default as default };

package/es/modules/global-modal/src/components/ModalFooter.vue_vue_type_script_setup_true_name_BasicModalFooter_lang.mjs

@@ -0,0 +1,40 @@
+import { basicProps } from "../props.mjs";
+import { createBlock, createCommentVNode, createElementBlock, createTextVNode, defineComponent, mergeProps, openBlock, renderSlot, toDisplayString, unref, withCtx } from "vue";
+import { t } from "@gct-paas/core";
+import { Button } from "ant-design-vue";
+//#region src/modules/global-modal/src/components/ModalFooter.vue?vue&type=script&setup=true&name=BasicModalFooter&lang.ts
+var ModalFooter_vue_vue_type_script_setup_true_name_BasicModalFooter_lang_default = /* @__PURE__ */ defineComponent({
+	__name: "ModalFooter",
+	props: basicProps,
+	emits: ["ok", "cancel"],
+	setup(__props, { emit: __emit }) {
+		const emit = __emit;
+		function handleOk(e) {
+			emit("ok", e);
+		}
+		function handleCancel(e) {
+			emit("cancel", e);
+		}
+		return (_ctx, _cache) => {
+			return openBlock(), createElementBlock("div", null, [
+				renderSlot(_ctx.$slots, "insertFooter"),
+				_ctx.showCancelBtn ? (openBlock(), createBlock(unref(Button), mergeProps({ key: 0 }, _ctx.cancelButtonProps, { onClick: handleCancel }), {
+					default: withCtx(() => [createTextVNode(toDisplayString(unref(t)(_ctx.cancelText)), 1)]),
+					_: 1
+				}, 16)) : createCommentVNode("", true),
+				renderSlot(_ctx.$slots, "centerFooter"),
+				_ctx.showOkBtn ? (openBlock(), createBlock(unref(Button), mergeProps({
+					key: 1,
+					type: _ctx.okType,
+					loading: _ctx.confirmLoading
+				}, _ctx.okButtonProps, { onClick: handleOk }), {
+					default: withCtx(() => [createTextVNode(toDisplayString(unref(t)(_ctx.okText)), 1)]),
+					_: 1
+				}, 16, ["type", "loading"])) : createCommentVNode("", true),
+				renderSlot(_ctx.$slots, "appendFooter")
+			]);
+		};
+	}
+});
+//#endregion
+export { ModalFooter_vue_vue_type_script_setup_true_name_BasicModalFooter_lang_default as default };

package/es/modules/global-modal/src/components/ModalHeader.vue.mjs

@@ -1,11 +1,11 @@
-import _sfc_main from './ModalHeader.vue2.mjs';
-import { openBlock, createElementBlock, toDisplayString } from 'vue';
-import _export_sfc from '../../../../_virtual/_plugin-vue_export-helper.mjs';
-
-const _hoisted_1 = ["help-message"];
+import _plugin_vue_export_helper_default from "../../../../_virtual/_plugin-vue_export-helper.mjs";
+import ModalHeader_vue_vue_type_script_lang_default from "./ModalHeader.vue_vue_type_script_lang.mjs";
+import { createElementBlock, openBlock, toDisplayString } from "vue";
+//#region src/modules/global-modal/src/components/ModalHeader.vue
+var _hoisted_1 = ["help-message"];
 function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
-  return openBlock(), createElementBlock("div", { "help-message": _ctx.helpMessage }, toDisplayString(_ctx.title), 9, _hoisted_1);
+	return openBlock(), createElementBlock("div", { "help-message": _ctx.helpMessage }, toDisplayString(_ctx.title), 9, _hoisted_1);
 }
-const ModalHeader = /* @__PURE__ */ _export_sfc(_sfc_main, [["render", _sfc_render]]);
-
-export { ModalHeader as default };
+var ModalHeader_default = /* @__PURE__ */ _plugin_vue_export_helper_default(ModalHeader_vue_vue_type_script_lang_default, [["render", _sfc_render]]);
+//#endregion
+export { ModalHeader_default as default };

package/es/modules/global-modal/src/components/ModalHeader.vue_vue_type_script_lang.mjs

@@ -0,0 +1,11 @@
+import { defineComponent } from "vue";
+//#region src/modules/global-modal/src/components/ModalHeader.vue?vue&type=script&lang.ts
+var ModalHeader_vue_vue_type_script_lang_default = defineComponent({
+	name: "BasicModalHeader",
+	props: {
+		helpMessage: { type: [String, Array] },
+		title: { type: String }
+	}
+});
+//#endregion
+export { ModalHeader_vue_vue_type_script_lang_default as default };

package/es/modules/global-modal/src/components/ModalWrapper.vue.d.ts

@@ -84,9 +84,9 @@ declare const _default: import('vue').DefineComponent<import('vue').ExtractPropT
     "onExt-height"?: ((...args: any[]) => any) | undefined;
 }>, {
     visible: boolean;
+    loading: boolean;
     minHeight: number;
     useWrapper: boolean;
-    loading: boolean;
     footerOffset: number;
     modalHeaderHeight: number;
     modalFooterHeight: number;

package/es/modules/global-modal/src/components/ModalWrapper.vue.mjs

@@ -1,26 +1,20 @@
-import _sfc_main from './ModalWrapper.vue2.mjs';
-import { resolveComponent, resolveDirective, openBlock, createBlock, withCtx, withDirectives, createElementBlock, normalizeStyle, renderSlot } from 'vue';
-import _export_sfc from '../../../../_virtual/_plugin-vue_export-helper.mjs';
-
-const _hoisted_1 = ["loading-tip"];
+import _plugin_vue_export_helper_default from "../../../../_virtual/_plugin-vue_export-helper.mjs";
+import ModalWrapper_vue_vue_type_script_lang_default from "./ModalWrapper.vue_vue_type_script_lang.mjs";
+import { createBlock, createElementBlock, normalizeStyle, openBlock, renderSlot, resolveComponent, resolveDirective, withCtx, withDirectives } from "vue";
+//#region src/modules/global-modal/src/components/ModalWrapper.vue
+var _hoisted_1 = ["loading-tip"];
 function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
-  const _component_overlayScrollbars_component = resolveComponent("overlayScrollbars-component");
-  const _directive_target_loading = resolveDirective("target-loading");
-  return openBlock(), createBlock(_component_overlayScrollbars_component, { ref: "wrapperRef" }, {
-    default: withCtx(() => [
-      withDirectives((openBlock(), createElementBlock("div", {
-        ref: "spinRef",
-        style: normalizeStyle(_ctx.spinStyle),
-        "loading-tip": _ctx.loadingTip
-      }, [
-        renderSlot(_ctx.$slots, "default")
-      ], 12, _hoisted_1)), [
-        [_directive_target_loading, _ctx.loading]
-      ])
-    ]),
-    _: 3
-  }, 512);
+	const _component_overlayScrollbars_component = resolveComponent("overlayScrollbars-component");
+	const _directive_target_loading = resolveDirective("target-loading");
+	return openBlock(), createBlock(_component_overlayScrollbars_component, { ref: "wrapperRef" }, {
+		default: withCtx(() => [withDirectives((openBlock(), createElementBlock("div", {
+			ref: "spinRef",
+			style: normalizeStyle(_ctx.spinStyle),
+			"loading-tip": _ctx.loadingTip
+		}, [renderSlot(_ctx.$slots, "default")], 12, _hoisted_1)), [[_directive_target_loading, _ctx.loading]])]),
+		_: 3
+	}, 512);
 }
-const ModalWrapper = /* @__PURE__ */ _export_sfc(_sfc_main, [["render", _sfc_render]]);
-
-export { ModalWrapper as default };
+var ModalWrapper_default = /* @__PURE__ */ _plugin_vue_export_helper_default(ModalWrapper_vue_vue_type_script_lang_default, [["render", _sfc_render]]);
+//#endregion
+export { ModalWrapper_default as default };

package/es/modules/global-modal/src/components/ModalWrapper.vue_vue_type_script_lang.mjs

@@ -0,0 +1,126 @@
+import { createModalContext } from "../hooks/useModalContext.mjs";
+import { computed, defineComponent, nextTick, onMounted, onUnmounted, ref, unref, watch, watchEffect } from "vue";
+import { useMutationObserver, useWindowSize } from "@vueuse/core";
+var ModalWrapper_vue_vue_type_script_lang_default = defineComponent({
+	name: "ModalWrapper",
+	inheritAttrs: false,
+	props: {
+		loading: { type: Boolean },
+		useWrapper: {
+			type: Boolean,
+			default: true
+		},
+		modalHeaderHeight: {
+			type: Number,
+			default: 57
+		},
+		modalFooterHeight: {
+			type: Number,
+			default: 74
+		},
+		minHeight: {
+			type: Number,
+			default: 320
+		},
+		height: { type: Number },
+		footerOffset: {
+			type: Number,
+			default: 0
+		},
+		visible: { type: Boolean },
+		fullScreen: { type: Boolean },
+		loadingTip: { type: String }
+	},
+	emits: ["height-change", "ext-height"],
+	setup(props, { emit }) {
+		const wrapperRef = ref();
+		const spinRef = ref(null);
+		const realHeightRef = ref(0);
+		const minRealHeightRef = ref(0);
+		let realHeight = 0;
+		let stopElResizeFn = () => {};
+		const spinStyle = ref();
+		const { width, height } = useWindowSize();
+		watch([height, width], () => {
+			setModalHeight();
+		});
+		useMutationObserver(spinRef, () => {
+			setModalHeight();
+		}, {
+			attributes: true,
+			subtree: true
+		});
+		createModalContext({ redoModalHeight: setModalHeight });
+		const scrollHeight = computed(() => {
+			const modalheight = window.innerHeight * .88 - 120;
+			return { height: `${props.height ? modalheight > props.height - 120 ? props.height - 120 : modalheight : props.height}px` };
+		});
+		watchEffect(() => {
+			props.useWrapper && setModalHeight();
+		});
+		watch(() => props.fullScreen, (v) => {
+			setModalHeight();
+			if (!v) realHeightRef.value = minRealHeightRef.value;
+			else minRealHeightRef.value = realHeightRef.value;
+		});
+		new ResizeObserver((entries) => {
+			for (let entry of entries) {
+				const modalheight = entry.contentRect.height * .88 - 152;
+				spinStyle.value = {
+					height: `${props.height ? modalheight > props.height - 152 ? props.height - 152 : modalheight : props.height}px`,
+					minHeight: `${props.minHeight - 152}px`,
+					[props.fullScreen ? "height" : "maxHeight"]: `${unref(realHeightRef)}px`,
+					maxHeight: `calc(88vh - 152px)`
+				};
+			}
+		}).observe(document.documentElement);
+		onMounted(() => {
+			const { modalHeaderHeight, modalFooterHeight } = props;
+			emit("ext-height", modalHeaderHeight + modalFooterHeight);
+		});
+		onUnmounted(() => {
+			stopElResizeFn && stopElResizeFn();
+		});
+		async function scrollTop() {
+			nextTick(() => {
+				if (wrapperRef.value) wrapperRef.value.getElement()?.scrollTo(0, 0);
+			});
+		}
+		async function setModalHeight() {
+			if (!props.visible) return;
+			if (!wrapperRef.value) return;
+			const bodyDom = wrapperRef.value?.getElement()?.parentElement;
+			if (!bodyDom) return;
+			bodyDom.style.padding = "0";
+			await nextTick();
+			try {
+				const modalDom = bodyDom.parentElement && bodyDom.parentElement.parentElement;
+				if (!modalDom) return;
+				const modalRect = getComputedStyle(modalDom).top;
+				const modalTop = Number.parseInt(modalRect);
+				let maxHeight = window.innerHeight - modalTop * 2 + (props.footerOffset || 0) - props.modalFooterHeight - props.modalHeaderHeight;
+				if (modalTop < 40) maxHeight -= 26;
+				await nextTick();
+				const spinEl = unref(spinRef);
+				if (!spinEl) return;
+				await nextTick();
+				realHeight = spinEl.scrollHeight;
+				if (props.fullScreen) realHeightRef.value = window.innerHeight - props.modalFooterHeight - props.modalHeaderHeight - 28;
+				else realHeightRef.value = props.height ? props.height : realHeight > maxHeight ? maxHeight : realHeight;
+				emit("height-change", unref(realHeightRef));
+			} catch (error) {
+				console.error(error);
+			}
+		}
+		return {
+			wrapperRef,
+			spinRef,
+			spinStyle,
+			scrollTop,
+			setModalHeight,
+			scrollHeight
+		};
+	}
+});
+//#endregion
+export { ModalWrapper_vue_vue_type_script_lang_default as default };

package/es/modules/global-modal/src/hooks/useModal.mjs

@@ -1,120 +1,106 @@
-import { reactive, ref, computed, unref, getCurrentInstance, watchEffect, nextTick, onUnmounted, toRaw } from 'vue';
-import { isFunction, isEqual } from 'lodash-es';
-import { tryOnUnmounted } from '@vueuse/core';
-
-const dataTransfer = reactive({});
-const visibleData = reactive({});
+import { computed, getCurrentInstance, nextTick, onUnmounted, reactive, ref, toRaw, unref, watchEffect } from "vue";
+import { isEqual, isFunction } from "lodash-es";
+import { tryOnUnmounted } from "@vueuse/core";
+//#region src/modules/global-modal/src/hooks/useModal.ts
+var dataTransfer = reactive({});
+var visibleData = reactive({});
+/**
+* @description: Applicable to independent modal and call outside
+*/
 function useModal() {
-  const modal = ref(null);
-  const loaded = ref(false);
-  const uid = ref("");
-  function register(modalMethod, uuid) {
-    if (!getCurrentInstance()) {
-      throw new Error(
-        "useModal() can only be used inside setup() or functional components!"
-      );
-    }
-    uid.value = uuid || "";
-    onUnmounted(() => {
-      modal.value = null;
-      loaded.value = false;
-      dataTransfer[unref(uid)] = null;
-    });
-    if (unref(loaded) && modalMethod === unref(modal)) return;
-    modal.value = modalMethod;
-    loaded.value = true;
-    modalMethod.emitVisible = (visible, uid2) => {
-      visibleData[uid2] = visible;
-    };
-  }
-  const getInstance = () => {
-    const instance = unref(modal);
-    if (!instance) {
-      throw new Error("useModal instance is undefined!");
-    }
-    return instance;
-  };
-  const methods = {
-    setModalProps: (props) => {
-      getInstance()?.setModalProps(props);
-    },
-    getVisible: computed(() => {
-      return visibleData[~~unref(uid)];
-    }),
-    redoModalHeight: () => {
-      getInstance()?.redoModalHeight?.();
-    },
-    openModal: (visible = true, data, openOnSet = true) => {
-      getInstance()?.setModalProps({
-        visible
-      });
-      const id = unref(uid);
-      if (openOnSet) {
-        dataTransfer[id] = null;
-        dataTransfer[id] = toRaw(data);
-        return;
-      }
-      const equal = isEqual(toRaw(dataTransfer[id]), toRaw(data));
-      if (!equal) {
-        dataTransfer[id] = toRaw(data);
-      }
-    },
-    closeModal: () => {
-      getInstance()?.setModalProps({ visible: false });
-    }
-  };
-  return [register, methods];
+	const modal = ref(null);
+	const loaded = ref(false);
+	const uid = ref("");
+	function register(modalMethod, uuid) {
+		if (!getCurrentInstance()) throw new Error("useModal() can only be used inside setup() or functional components!");
+		uid.value = uuid || "";
+		onUnmounted(() => {
+			modal.value = null;
+			loaded.value = false;
+			dataTransfer[unref(uid)] = null;
+		});
+		if (unref(loaded) && modalMethod === unref(modal)) return;
+		modal.value = modalMethod;
+		loaded.value = true;
+		modalMethod.emitVisible = (visible, uid) => {
+			visibleData[uid] = visible;
+		};
+	}
+	const getInstance = () => {
+		const instance = unref(modal);
+		if (!instance) throw new Error("useModal instance is undefined!");
+		return instance;
+	};
+	return [register, {
+		setModalProps: (props) => {
+			getInstance()?.setModalProps(props);
+		},
+		getVisible: computed(() => {
+			return visibleData[~~unref(uid)];
+		}),
+		redoModalHeight: () => {
+			getInstance()?.redoModalHeight?.();
+		},
+		openModal: (visible = true, data, openOnSet = true) => {
+			getInstance()?.setModalProps({ visible });
+			const id = unref(uid);
+			if (openOnSet) {
+				dataTransfer[id] = null;
+				dataTransfer[id] = toRaw(data);
+				return;
+			}
+			if (!isEqual(toRaw(dataTransfer[id]), toRaw(data))) dataTransfer[id] = toRaw(data);
+		},
+		closeModal: () => {
+			getInstance()?.setModalProps({ visible: false });
+		}
+	}];
 }
-const useModalInner = (callbackFn) => {
-  const modalInstanceRef = ref(null);
-  const currentInstance = getCurrentInstance();
-  const uidRef = ref("");
-  const getInstance = () => {
-    const instance = unref(modalInstanceRef);
-    if (!instance) {
-      throw new Error("useModalInner instance is undefined!");
-    }
-    return instance;
-  };
-  const register = (modalInstance, uuid) => {
-    tryOnUnmounted(() => {
-      modalInstanceRef.value = null;
-    });
-    uidRef.value = uuid || "";
-    modalInstanceRef.value = modalInstance;
-    currentInstance?.emit("register", modalInstance, uuid);
-  };
-  watchEffect(() => {
-    const data = dataTransfer[unref(uidRef)];
-    if (!callbackFn || !isFunction(callbackFn)) return;
-    nextTick(() => {
-      callbackFn(data);
-    });
-  });
-  return [
-    register,
-    {
-      changeLoading: (loading = true) => {
-        getInstance()?.setModalProps({ loading });
-      },
-      getVisible: computed(() => {
-        return visibleData[~~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?.();
-      }
-    }
-  ];
+var useModalInner = (callbackFn) => {
+	const modalInstanceRef = ref(null);
+	const currentInstance = getCurrentInstance();
+	const uidRef = ref("");
+	const getInstance = () => {
+		const instance = unref(modalInstanceRef);
+		if (!instance) throw new Error("useModalInner instance is undefined!");
+		return instance;
+	};
+	const register = (modalInstance, uuid) => {
+		tryOnUnmounted(() => {
+			modalInstanceRef.value = null;
+		});
+		uidRef.value = uuid || "";
+		modalInstanceRef.value = modalInstance;
+		currentInstance?.emit("register", modalInstance, uuid);
+	};
+	watchEffect(() => {
+		const data = dataTransfer[unref(uidRef)];
+		if (!callbackFn || !isFunction(callbackFn)) return;
+		nextTick(() => {
+			callbackFn(data);
+		});
+	});
+	return [register, {
+		changeLoading: (loading = true) => {
+			getInstance()?.setModalProps({ loading });
+		},
+		getVisible: computed(() => {
+			return visibleData[~~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?.();
+		}
+	}];
 };
-
+//#endregion
 export { useModal, useModalInner };

package/es/modules/global-modal/src/hooks/useModalContext.mjs

@@ -1,11 +1,11 @@
-import { provide, inject } from 'vue';
-
-const key = /* @__PURE__ */ Symbol();
+import { inject, provide } from "vue";
+//#region src/modules/global-modal/src/hooks/useModalContext.ts
+var key = Symbol();
 function createModalContext(context) {
-  return provide(key, context);
+	return provide(key, context);
 }
 function useModalContext() {
-  return inject(key);
+	return inject(key);
 }
-
+//#endregion
 export { createModalContext, useModalContext };