feat: initial commit - Phase 1 & 2 core features

frontend/node_modules/element-plus/es/components/message/index.d.ts

@@ -0,0 +1,8 @@
+import { SFCInstallWithContext } from "../../utils/vue/typescript.js";
+import "../../utils/index.js";
+import { MESSAGE_DEFAULT_PLACEMENT, Message, MessageConfigContext, MessageEmits, MessageFn, MessageHandler, MessageInstance, MessageOptions, MessageOptionsWithType, MessageParams, MessageParamsNormalized, MessageParamsWithType, MessagePlacement, MessageProps, MessagePropsPublic, MessageType, MessageTypedFn, messageDefaults, messageEmits, messagePlacement, messageProps, messageType, messageTypes } from "./src/message.js";
+
+//#region ../../packages/components/message/index.d.ts
+declare const ElMessage: SFCInstallWithContext<Message>;
+//#endregion
+export { ElMessage, ElMessage as default, MESSAGE_DEFAULT_PLACEMENT, Message, MessageConfigContext, MessageEmits, MessageFn, MessageHandler, MessageInstance, MessageOptions, MessageOptionsWithType, MessageParams, MessageParamsNormalized, MessageParamsWithType, MessagePlacement, MessageProps, MessagePropsPublic, MessageType, MessageTypedFn, messageDefaults, messageEmits, messagePlacement, messageProps, messageType, messageTypes };

frontend/node_modules/element-plus/es/components/message/index.mjs

@@ -0,0 +1,10 @@
+import { withInstallFunction } from "../../utils/vue/install.mjs";
+import { MESSAGE_DEFAULT_PLACEMENT, messageDefaults, messageEmits, messagePlacement, messageProps, messageTypes } from "./src/message.mjs";
+import message from "./src/method.mjs";
+
+//#region ../../packages/components/message/index.ts
+const ElMessage = withInstallFunction(message, "$message");
+
+//#endregion
+export { ElMessage, ElMessage as default, MESSAGE_DEFAULT_PLACEMENT, messageDefaults, messageEmits, messagePlacement, messageProps, messageTypes };
+//# sourceMappingURL=index.mjs.map

frontend/node_modules/element-plus/es/components/message/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":["Message"],"sources":["../../../../../packages/components/message/index.ts"],"sourcesContent":["import { withInstallFunction } from '@element-plus/utils'\nimport Message from './src/method'\n\nexport const ElMessage = withInstallFunction(Message, '$message')\nexport default ElMessage\n\nexport * from './src/message'\n"],"mappings":";;;;;AAGA,MAAa,YAAY,oBAAoBA,SAAS,WAAW"}

frontend/node_modules/element-plus/es/components/message/src/instance.mjs

@@ -0,0 +1,31 @@
+import { shallowReactive } from "vue";
+
+//#region ../../packages/components/message/src/instance.ts
+const placementInstances = shallowReactive({});
+const getOrCreatePlacementInstances = (placement) => {
+	if (!placementInstances[placement]) placementInstances[placement] = shallowReactive([]);
+	return placementInstances[placement];
+};
+const getInstance = (id, placement) => {
+	const instances = placementInstances[placement] || [];
+	const idx = instances.findIndex((instance) => instance.id === id);
+	const current = instances[idx];
+	let prev;
+	if (idx > 0) prev = instances[idx - 1];
+	return {
+		current,
+		prev
+	};
+};
+const getLastOffset = (id, placement) => {
+	const { prev } = getInstance(id, placement);
+	if (!prev) return 0;
+	return prev.vm.exposed.bottom.value;
+};
+const getOffsetOrSpace = (id, offset, placement) => {
+	return (placementInstances[placement] || []).findIndex((instance) => instance.id === id) > 0 ? 16 : offset;
+};
+
+//#endregion
+export { getInstance, getLastOffset, getOffsetOrSpace, getOrCreatePlacementInstances, placementInstances };
+//# sourceMappingURL=instance.mjs.map

frontend/node_modules/element-plus/es/components/message/src/instance.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"instance.mjs","names":[],"sources":["../../../../../../packages/components/message/src/instance.ts"],"sourcesContent":["import { shallowReactive } from 'vue'\n\nimport type { ComponentInternalInstance, VNode } from 'vue'\nimport type { Mutable } from '@element-plus/utils'\nimport type { MessageHandler, MessagePlacement, MessageProps } from './message'\n\nexport type MessageContext = {\n  id: string\n  vnode: VNode\n  handler: MessageHandler\n  vm: ComponentInternalInstance\n  props: Mutable<MessageProps>\n}\n\nexport const placementInstances = shallowReactive(\n  {} as Record<MessagePlacement, MessageContext[]>\n)\n\nexport const getOrCreatePlacementInstances = (placement: MessagePlacement) => {\n  if (!placementInstances[placement]) {\n    placementInstances[placement] = shallowReactive([])\n  }\n  return placementInstances[placement]\n}\n\nexport const getInstance = (id: string, placement: MessagePlacement) => {\n  const instances = placementInstances[placement] || []\n  const idx = instances.findIndex((instance) => instance.id === id)\n  const current = instances[idx]\n  let prev: MessageContext | undefined\n  if (idx > 0) {\n    prev = instances[idx - 1]\n  }\n  return { current, prev }\n}\n\nexport const getLastOffset = (\n  id: string,\n  placement: MessagePlacement\n): number => {\n  const { prev } = getInstance(id, placement)\n  if (!prev) return 0\n  return prev.vm.exposed!.bottom.value\n}\n\nexport const getOffsetOrSpace = (\n  id: string,\n  offset: number,\n  placement: MessagePlacement\n) => {\n  const instances = placementInstances[placement] || []\n  const idx = instances.findIndex((instance) => instance.id === id)\n  return idx > 0 ? 16 : offset\n}\n"],"mappings":";;;AAcA,MAAa,qBAAqB,gBAChC,EAAE,CACH;AAED,MAAa,iCAAiC,cAAgC;AAC5E,KAAI,CAAC,mBAAmB,WACtB,oBAAmB,aAAa,gBAAgB,EAAE,CAAC;AAErD,QAAO,mBAAmB;;AAG5B,MAAa,eAAe,IAAY,cAAgC;CACtE,MAAM,YAAY,mBAAmB,cAAc,EAAE;CACrD,MAAM,MAAM,UAAU,WAAW,aAAa,SAAS,OAAO,GAAG;CACjE,MAAM,UAAU,UAAU;CAC1B,IAAI;AACJ,KAAI,MAAM,EACR,QAAO,UAAU,MAAM;AAEzB,QAAO;EAAE;EAAS;EAAM;;AAG1B,MAAa,iBACX,IACA,cACW;CACX,MAAM,EAAE,SAAS,YAAY,IAAI,UAAU;AAC3C,KAAI,CAAC,KAAM,QAAO;AAClB,QAAO,KAAK,GAAG,QAAS,OAAO;;AAGjC,MAAa,oBACX,IACA,QACA,cACG;AAGH,SAFkB,mBAAmB,cAAc,EAAE,EAC/B,WAAW,aAAa,SAAS,OAAO,GAAG,GACpD,IAAI,KAAK"}

frontend/node_modules/element-plus/es/components/message/src/message.d.ts

@@ -0,0 +1,183 @@
+import { IconPropType } from "../../../utils/vue/icon.js";
+import { EpPropFinalized } from "../../../utils/vue/props/types.js";
+import { Mutable } from "../../../utils/typescript.js";
+import "../../../utils/index.js";
+import { _default } from "./message.vue.js";
+import * as vue from "vue";
+import { AppContext, ExtractPublicPropTypes, VNode } from "vue";
+
+//#region ../../packages/components/message/src/message.d.ts
+interface MessageProps {
+  /**
+   * @description custom class name for Message
+   */
+  customClass?: string;
+  /**
+   * @description whether `message` is treated as HTML string
+   */
+  dangerouslyUseHTMLString?: boolean;
+  /**
+   * @description display duration, millisecond. If set to 0, it will not turn off automatically
+   */
+  duration?: number;
+  /**
+   * @description custom icon component, overrides `type`
+   */
+  icon?: IconPropType;
+  /**
+   * @description message dom id
+   */
+  id?: string;
+  /**
+   * @description message text
+   */
+  message?: string | VNode | (() => VNode);
+  /**
+   * @description callback function when closed with the message instance as the parameter
+   */
+  onClose?: () => void;
+  /**
+   * @description whether to show a close button
+   */
+  showClose?: boolean;
+  /**
+   * @description message type
+   */
+  type?: MessageType;
+  /**
+   * @description whether message is plain
+   */
+  plain?: boolean;
+  /**
+   * @description set the distance to the top of viewport
+   */
+  offset?: number;
+  /**
+   * @description message placement position
+   */
+  placement?: MessagePlacement;
+  /**
+   * @description message element zIndex value
+   */
+  zIndex?: number;
+  /**
+   * @description merge messages with the same content, type of VNode message is not supported
+   */
+  grouping?: boolean;
+  /**
+   * @description The number of repetitions, similar to badge, is used as the initial number when used with `grouping`
+   */
+  repeatNum?: number;
+}
+declare const messageTypes: readonly ["primary", "success", "info", "warning", "error"];
+declare const messagePlacement: readonly ["top", "top-left", "top-right", "bottom", "bottom-left", "bottom-right"];
+declare const MESSAGE_DEFAULT_PLACEMENT = "top";
+type MessageType = (typeof messageTypes)[number];
+type MessagePlacement = (typeof messagePlacement)[number];
+/** @deprecated please use `MessageType` instead */
+type messageType = MessageType;
+interface MessageConfigContext {
+  max?: number;
+  grouping?: boolean;
+  duration?: number;
+  offset?: number;
+  showClose?: boolean;
+  plain?: boolean;
+  placement?: string;
+}
+declare const messageDefaults: Mutable<{
+  readonly customClass: "";
+  readonly dangerouslyUseHTMLString: false;
+  readonly duration: 3000;
+  readonly icon: undefined;
+  readonly id: "";
+  readonly message: "";
+  readonly onClose: undefined;
+  readonly showClose: false;
+  readonly type: "info";
+  readonly plain: false;
+  readonly offset: 16;
+  readonly placement: undefined;
+  readonly zIndex: 0;
+  readonly grouping: false;
+  readonly repeatNum: 1;
+  readonly appendTo: HTMLElement;
+}>;
+/**
+ * @deprecated Removed after 3.0.0, Use `MessageProps` instead.
+ */
+declare const messageProps: {
+  readonly customClass: EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+  readonly dangerouslyUseHTMLString: EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
+  readonly duration: EpPropFinalized<NumberConstructor, unknown, unknown, 3000, boolean>;
+  readonly icon: EpPropFinalized<(new (...args: any[]) => (string | vue.Component) & {}) | (() => string | vue.Component) | (((new (...args: any[]) => (string | vue.Component) & {}) | (() => string | vue.Component)) | null)[], unknown, unknown, undefined, boolean>;
+  readonly id: EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+  readonly message: EpPropFinalized<(new (...args: any[]) => string | VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+  }> | (() => VNode)) | (() => string | VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+  }> | (() => VNode)) | (((new (...args: any[]) => string | VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+  }> | (() => VNode)) | (() => string | VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+  }> | (() => VNode))) | null)[], unknown, unknown, "", boolean>;
+  readonly onClose: EpPropFinalized<(new (...args: any[]) => () => void) | (() => () => void) | {
+    (): () => void;
+    new (): any;
+    readonly prototype: any;
+  } | (((new (...args: any[]) => () => void) | (() => () => void) | {
+    (): () => void;
+    new (): any;
+    readonly prototype: any;
+  }) | null)[], unknown, unknown, undefined, boolean>;
+  readonly showClose: EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
+  readonly type: EpPropFinalized<StringConstructor, "error" | "info" | "primary" | "success" | "warning", unknown, "info", boolean>;
+  readonly plain: EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
+  readonly offset: EpPropFinalized<NumberConstructor, unknown, unknown, 16, boolean>;
+  readonly placement: EpPropFinalized<StringConstructor, "top" | "bottom" | "top-left" | "top-right" | "bottom-left" | "bottom-right", unknown, undefined, boolean>;
+  readonly zIndex: EpPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;
+  readonly grouping: EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
+  readonly repeatNum: EpPropFinalized<NumberConstructor, unknown, unknown, 1, boolean>;
+};
+/**
+ * @deprecated Removed after 3.0.0, Use `MessageProps` instead.
+ */
+type MessagePropsPublic = ExtractPublicPropTypes<typeof messageProps>;
+declare const messageEmits: {
+  destroy: () => boolean;
+};
+type MessageEmits = typeof messageEmits;
+type MessageInstance = InstanceType<typeof _default> & unknown;
+type MessageOptions = Partial<Mutable<Omit<MessageProps, 'id'> & {
+  appendTo?: HTMLElement | string;
+}>>;
+type MessageParams = MessageOptions | MessageOptions['message'];
+type MessageParamsNormalized = Omit<MessageProps, 'id'> & {
+  /**
+   * @description set the root element for the message, default to `document.body`
+   */
+  appendTo: HTMLElement;
+};
+type MessageOptionsWithType = Omit<MessageOptions, 'type'>;
+type MessageParamsWithType = MessageOptionsWithType | MessageOptions['message'];
+interface MessageHandler {
+  /**
+   * @description close the Message
+   */
+  close: () => void;
+}
+type MessageFn = {
+  (options?: MessageParams, appContext?: null | AppContext): MessageHandler;
+  closeAll(type?: MessageType): void;
+  closeAllByPlacement(position: MessagePlacement): void;
+};
+type MessageTypedFn = (options?: MessageParamsWithType, appContext?: null | AppContext) => MessageHandler;
+type Message = MessageFn & {
+  primary: MessageTypedFn;
+  success: MessageTypedFn;
+  warning: MessageTypedFn;
+  info: MessageTypedFn;
+  error: MessageTypedFn;
+};
+//#endregion
+export { MESSAGE_DEFAULT_PLACEMENT, Message, MessageConfigContext, MessageEmits, MessageFn, MessageHandler, MessageInstance, MessageOptions, MessageOptionsWithType, MessageParams, MessageParamsNormalized, MessageParamsWithType, MessagePlacement, MessageProps, MessagePropsPublic, MessageType, MessageTypedFn, messageDefaults, messageEmits, messagePlacement, messageProps, messageType, messageTypes };

frontend/node_modules/element-plus/es/components/message/src/message.mjs

@@ -0,0 +1,116 @@
+import { isClient } from "../../../utils/browser.mjs";
+import { buildProps, definePropType } from "../../../utils/vue/props/runtime.mjs";
+import { iconPropType } from "../../../utils/vue/icon.mjs";
+import { mutable } from "../../../utils/typescript.mjs";
+
+//#region ../../packages/components/message/src/message.ts
+const messageTypes = [
+	"primary",
+	"success",
+	"info",
+	"warning",
+	"error"
+];
+const messagePlacement = [
+	"top",
+	"top-left",
+	"top-right",
+	"bottom",
+	"bottom-left",
+	"bottom-right"
+];
+const MESSAGE_DEFAULT_PLACEMENT = "top";
+const messageDefaults = mutable({
+	customClass: "",
+	dangerouslyUseHTMLString: false,
+	duration: 3e3,
+	icon: void 0,
+	id: "",
+	message: "",
+	onClose: void 0,
+	showClose: false,
+	type: "info",
+	plain: false,
+	offset: 16,
+	placement: void 0,
+	zIndex: 0,
+	grouping: false,
+	repeatNum: 1,
+	appendTo: isClient ? document.body : void 0
+});
+/**
+* @deprecated Removed after 3.0.0, Use `MessageProps` instead.
+*/
+const messageProps = buildProps({
+	customClass: {
+		type: String,
+		default: messageDefaults.customClass
+	},
+	dangerouslyUseHTMLString: {
+		type: Boolean,
+		default: messageDefaults.dangerouslyUseHTMLString
+	},
+	duration: {
+		type: Number,
+		default: messageDefaults.duration
+	},
+	icon: {
+		type: iconPropType,
+		default: messageDefaults.icon
+	},
+	id: {
+		type: String,
+		default: messageDefaults.id
+	},
+	message: {
+		type: definePropType([
+			String,
+			Object,
+			Function
+		]),
+		default: messageDefaults.message
+	},
+	onClose: {
+		type: definePropType(Function),
+		default: messageDefaults.onClose
+	},
+	showClose: {
+		type: Boolean,
+		default: messageDefaults.showClose
+	},
+	type: {
+		type: String,
+		values: messageTypes,
+		default: messageDefaults.type
+	},
+	plain: {
+		type: Boolean,
+		default: messageDefaults.plain
+	},
+	offset: {
+		type: Number,
+		default: messageDefaults.offset
+	},
+	placement: {
+		type: String,
+		values: messagePlacement,
+		default: messageDefaults.placement
+	},
+	zIndex: {
+		type: Number,
+		default: messageDefaults.zIndex
+	},
+	grouping: {
+		type: Boolean,
+		default: messageDefaults.grouping
+	},
+	repeatNum: {
+		type: Number,
+		default: messageDefaults.repeatNum
+	}
+});
+const messageEmits = { destroy: () => true };
+
+//#endregion
+export { MESSAGE_DEFAULT_PLACEMENT, messageDefaults, messageEmits, messagePlacement, messageProps, messageTypes };
+//# sourceMappingURL=message.mjs.map

frontend/node_modules/element-plus/es/components/message/src/message.vue.d.ts

@@ -0,0 +1,45 @@
+import { IconPropType } from "../../../utils/vue/icon.js";
+import "../../../utils/index.js";
+import { MessagePlacement, MessageProps, MessageType } from "./message.js";
+import * as vue from "vue";
+
+//#region ../../packages/components/message/src/message.vue.d.ts
+declare function close(): void;
+declare var __VLS_27: {};
+type __VLS_Slots = {} & {
+  default?: (props: typeof __VLS_27) => any;
+};
+declare const __VLS_base: vue.DefineComponent<MessageProps, {
+  visible: vue.Ref<boolean, boolean>;
+  bottom: vue.ComputedRef<number>;
+  close: typeof close;
+}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
+  destroy: () => void;
+}, string, vue.PublicProps, Readonly<MessageProps> & Readonly<{
+  onDestroy?: (() => any) | undefined;
+}>, {
+  zIndex: number;
+  offset: number;
+  type: MessageType;
+  onClose: () => void;
+  id: string;
+  icon: IconPropType;
+  placement: MessagePlacement;
+  plain: boolean;
+  message: string | vue.VNode | (() => vue.VNode);
+  showClose: boolean;
+  duration: number;
+  customClass: string;
+  dangerouslyUseHTMLString: boolean;
+  grouping: boolean;
+  repeatNum: number;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+type __VLS_WithSlots<T, S> = T & {
+  new (): {
+    $slots: S;
+  };
+};
+//#endregion
+export { _default };

frontend/node_modules/element-plus/es/components/message/src/message.vue_vue_type_script_setup_true_lang.mjs

@@ -0,0 +1,159 @@
+import { EVENT_CODE } from "../../../constants/aria.mjs";
+import { getEventCode } from "../../../utils/dom/event.mjs";
+import { TypeComponents, TypeComponentsMap } from "../../../utils/vue/icon.mjs";
+import { ElIcon } from "../../icon/index.mjs";
+import { ElBadge } from "../../badge/index.mjs";
+import { useGlobalComponentSettings } from "../../config-provider/src/hooks/use-global-config.mjs";
+import { MESSAGE_DEFAULT_PLACEMENT, messageEmits, messageProps } from "./message.mjs";
+import { getLastOffset, getOffsetOrSpace } from "./instance.mjs";
+import { useEventListener, useResizeObserver, useTimeoutFn } from "@vueuse/core";
+import { Fragment, Transition, computed, createBlock, createCommentVNode, createElementBlock, createElementVNode, createVNode, defineComponent, nextTick, normalizeClass, normalizeStyle, onMounted, openBlock, ref, renderSlot, resolveDynamicComponent, toDisplayString, unref, vShow, watch, withCtx, withDirectives, withModifiers } from "vue";
+
+//#region ../../packages/components/message/src/message.vue?vue&type=script&setup=true&lang.ts
+const _hoisted_1 = ["id"];
+const _hoisted_2 = ["innerHTML"];
+var message_vue_vue_type_script_setup_true_lang_default = /* @__PURE__ */ defineComponent({
+	name: "ElMessage",
+	__name: "message",
+	props: messageProps,
+	emits: messageEmits,
+	setup(__props, { expose: __expose, emit: __emit }) {
+		const { Close } = TypeComponents;
+		const props = __props;
+		const emit = __emit;
+		const isStartTransition = ref(false);
+		const { ns, zIndex } = useGlobalComponentSettings("message");
+		const { currentZIndex, nextZIndex } = zIndex;
+		const messageRef = ref();
+		const visible = ref(false);
+		const height = ref(0);
+		let stopTimer = void 0;
+		const badgeType = computed(() => props.type ? props.type === "error" ? "danger" : props.type : "info");
+		const typeClass = computed(() => {
+			const type = props.type;
+			return { [ns.bm("icon", type)]: type && TypeComponentsMap[type] };
+		});
+		const iconComponent = computed(() => props.icon || TypeComponentsMap[props.type] || "");
+		const placement = computed(() => props.placement || MESSAGE_DEFAULT_PLACEMENT);
+		const lastOffset = computed(() => getLastOffset(props.id, placement.value));
+		const offset = computed(() => {
+			return Math.max(getOffsetOrSpace(props.id, props.offset, placement.value) + lastOffset.value, props.offset);
+		});
+		const bottom = computed(() => height.value + offset.value);
+		const horizontalClass = computed(() => {
+			if (placement.value.includes("left")) return ns.is("left");
+			if (placement.value.includes("right")) return ns.is("right");
+			return ns.is("center");
+		});
+		const verticalProperty = computed(() => placement.value.startsWith("top") ? "top" : "bottom");
+		const customStyle = computed(() => ({
+			[verticalProperty.value]: `${offset.value}px`,
+			zIndex: currentZIndex.value
+		}));
+		function startTimer() {
+			if (props.duration === 0) return;
+			({stop: stopTimer} = useTimeoutFn(() => {
+				close();
+			}, props.duration));
+		}
+		function clearTimer() {
+			stopTimer?.();
+		}
+		function close() {
+			visible.value = false;
+			nextTick(() => {
+				if (!isStartTransition.value) {
+					props.onClose?.();
+					emit("destroy");
+				}
+			});
+		}
+		function keydown(event) {
+			if (getEventCode(event) === EVENT_CODE.esc) close();
+		}
+		onMounted(() => {
+			startTimer();
+			nextZIndex();
+			visible.value = true;
+		});
+		watch(() => props.repeatNum, () => {
+			clearTimer();
+			startTimer();
+		});
+		useEventListener(document, "keydown", keydown);
+		useResizeObserver(messageRef, () => {
+			height.value = messageRef.value.getBoundingClientRect().height;
+		});
+		__expose({
+			visible,
+			bottom,
+			close
+		});
+		return (_ctx, _cache) => {
+			return openBlock(), createBlock(Transition, {
+				name: unref(ns).b("fade"),
+				onBeforeEnter: _cache[0] || (_cache[0] = ($event) => isStartTransition.value = true),
+				onBeforeLeave: __props.onClose,
+				onAfterLeave: _cache[1] || (_cache[1] = ($event) => _ctx.$emit("destroy")),
+				persisted: ""
+			}, {
+				default: withCtx(() => [withDirectives(createElementVNode("div", {
+					id: __props.id,
+					ref_key: "messageRef",
+					ref: messageRef,
+					class: normalizeClass([
+						unref(ns).b(),
+						{ [unref(ns).m(__props.type)]: __props.type },
+						unref(ns).is("closable", __props.showClose),
+						unref(ns).is("plain", __props.plain),
+						unref(ns).is("bottom", verticalProperty.value === "bottom"),
+						horizontalClass.value,
+						__props.customClass
+					]),
+					style: normalizeStyle(customStyle.value),
+					role: "alert",
+					onMouseenter: clearTimer,
+					onMouseleave: startTimer
+				}, [
+					__props.repeatNum > 1 ? (openBlock(), createBlock(unref(ElBadge), {
+						key: 0,
+						value: __props.repeatNum,
+						type: badgeType.value,
+						class: normalizeClass(unref(ns).e("badge"))
+					}, null, 8, [
+						"value",
+						"type",
+						"class"
+					])) : createCommentVNode("v-if", true),
+					iconComponent.value ? (openBlock(), createBlock(unref(ElIcon), {
+						key: 1,
+						class: normalizeClass([unref(ns).e("icon"), typeClass.value])
+					}, {
+						default: withCtx(() => [(openBlock(), createBlock(resolveDynamicComponent(iconComponent.value)))]),
+						_: 1
+					}, 8, ["class"])) : createCommentVNode("v-if", true),
+					renderSlot(_ctx.$slots, "default", {}, () => [!__props.dangerouslyUseHTMLString ? (openBlock(), createElementBlock("p", {
+						key: 0,
+						class: normalizeClass(unref(ns).e("content"))
+					}, toDisplayString(__props.message), 3)) : (openBlock(), createElementBlock(Fragment, { key: 1 }, [createCommentVNode(" Caution here, message could've been compromised, never use user's input as message "), createElementVNode("p", {
+						class: normalizeClass(unref(ns).e("content")),
+						innerHTML: __props.message
+					}, null, 10, _hoisted_2)], 2112))]),
+					__props.showClose ? (openBlock(), createBlock(unref(ElIcon), {
+						key: 2,
+						class: normalizeClass(unref(ns).e("closeBtn")),
+						onClick: withModifiers(close, ["stop"])
+					}, {
+						default: withCtx(() => [createVNode(unref(Close))]),
+						_: 1
+					}, 8, ["class"])) : createCommentVNode("v-if", true)
+				], 46, _hoisted_1), [[vShow, visible.value]])]),
+				_: 3
+			}, 8, ["name", "onBeforeLeave"]);
+		};
+	}
+});
+
+//#endregion
+export { message_vue_vue_type_script_setup_true_lang_default as default };
+//# sourceMappingURL=message.vue_vue_type_script_setup_true_lang.mjs.map

frontend/node_modules/element-plus/es/components/message/src/message2.mjs

@@ -0,0 +1,8 @@
+import message_vue_vue_type_script_setup_true_lang_default from "./message.vue_vue_type_script_setup_true_lang.mjs";
+
+//#region ../../packages/components/message/src/message.vue
+var message_default = message_vue_vue_type_script_setup_true_lang_default;
+
+//#endregion
+export { message_default as default };
+//# sourceMappingURL=message2.mjs.map

frontend/node_modules/element-plus/es/components/message/src/method.mjs

@@ -0,0 +1,127 @@
+import { isClient } from "../../../utils/browser.mjs";
+import { isBoolean, isElement, isFunction, isNumber, isString } from "../../../utils/types.mjs";
+import { hasOwn } from "../../../utils/objects.mjs";
+import { debugWarn } from "../../../utils/error.mjs";
+import { messageConfig } from "../../config-provider/src/config-provider.mjs";
+import { MESSAGE_DEFAULT_PLACEMENT, messageDefaults, messagePlacement, messageTypes } from "./message.mjs";
+import { getOrCreatePlacementInstances, placementInstances } from "./instance.mjs";
+import message_default from "./message2.mjs";
+import { createVNode, isVNode, render } from "vue";
+
+//#region ../../packages/components/message/src/method.ts
+let seed = 1;
+const normalizeAppendTo = (normalized) => {
+	if (!normalized.appendTo) normalized.appendTo = document.body;
+	else if (isString(normalized.appendTo)) {
+		let appendTo = document.querySelector(normalized.appendTo);
+		if (!isElement(appendTo)) {
+			debugWarn("ElMessage", "the appendTo option is not an HTMLElement. Falling back to document.body.");
+			appendTo = document.body;
+		}
+		normalized.appendTo = appendTo;
+	}
+};
+const normalizePlacement = (normalized) => {
+	if (!normalized.placement && isString(messageConfig.placement) && messageConfig.placement) normalized.placement = messageConfig.placement;
+	if (!normalized.placement) normalized.placement = MESSAGE_DEFAULT_PLACEMENT;
+	if (!messagePlacement.includes(normalized.placement)) {
+		debugWarn("ElMessage", `Invalid placement: ${normalized.placement}. Falling back to '${MESSAGE_DEFAULT_PLACEMENT}'.`);
+		normalized.placement = MESSAGE_DEFAULT_PLACEMENT;
+	}
+};
+const normalizeOptions = (params) => {
+	const options = !params || isString(params) || isVNode(params) || isFunction(params) ? { message: params } : params;
+	const normalized = {
+		...messageDefaults,
+		...options
+	};
+	normalizeAppendTo(normalized);
+	normalizePlacement(normalized);
+	if (isBoolean(messageConfig.grouping) && !normalized.grouping) normalized.grouping = messageConfig.grouping;
+	if (isNumber(messageConfig.duration) && normalized.duration === 3e3) normalized.duration = messageConfig.duration;
+	if (isNumber(messageConfig.offset) && normalized.offset === 16) normalized.offset = messageConfig.offset;
+	if (isBoolean(messageConfig.showClose) && !normalized.showClose) normalized.showClose = messageConfig.showClose;
+	if (isBoolean(messageConfig.plain) && !normalized.plain) normalized.plain = messageConfig.plain;
+	return normalized;
+};
+const closeMessage = (instance) => {
+	const instances = placementInstances[instance.props.placement || MESSAGE_DEFAULT_PLACEMENT];
+	const idx = instances.indexOf(instance);
+	if (idx === -1) return;
+	instances.splice(idx, 1);
+	const { handler } = instance;
+	handler.close();
+};
+const createMessage = ({ appendTo, ...options }, context) => {
+	const id = `message_${seed++}`;
+	const userOnClose = options.onClose;
+	const container = document.createElement("div");
+	const props = {
+		...options,
+		id,
+		onClose: () => {
+			userOnClose?.();
+			closeMessage(instance);
+		},
+		onDestroy: () => {
+			render(null, container);
+		}
+	};
+	const vnode = createVNode(message_default, props, isFunction(props.message) || isVNode(props.message) ? { default: isFunction(props.message) ? props.message : () => props.message } : null);
+	vnode.appContext = context || message._context;
+	render(vnode, container);
+	appendTo.appendChild(container.firstElementChild);
+	const vm = vnode.component;
+	const instance = {
+		id,
+		vnode,
+		vm,
+		handler: { close: () => {
+			vm.exposed.close();
+		} },
+		props: vnode.component.props
+	};
+	return instance;
+};
+const message = (options = {}, context) => {
+	if (!isClient) return { close: () => void 0 };
+	const normalized = normalizeOptions(options);
+	const instances = getOrCreatePlacementInstances(normalized.placement || MESSAGE_DEFAULT_PLACEMENT);
+	if (normalized.grouping && instances.length) {
+		const instance = instances.find(({ vnode: vm }) => vm.props?.message === normalized.message);
+		if (instance) {
+			instance.props.repeatNum += 1;
+			instance.props.type = normalized.type;
+			return instance.handler;
+		}
+	}
+	if (isNumber(messageConfig.max) && instances.length >= messageConfig.max) return { close: () => void 0 };
+	const instance = createMessage(normalized, context);
+	instances.push(instance);
+	return instance.handler;
+};
+messageTypes.forEach((type) => {
+	message[type] = (options = {}, appContext) => {
+		return message({
+			...normalizeOptions(options),
+			type
+		}, appContext);
+	};
+});
+function closeAll(type) {
+	for (const placement in placementInstances) if (hasOwn(placementInstances, placement)) {
+		const instances = [...placementInstances[placement]];
+		for (const instance of instances) if (!type || type === instance.props.type) instance.handler.close();
+	}
+}
+function closeAllByPlacement(placement) {
+	if (!placementInstances[placement]) return;
+	[...placementInstances[placement]].forEach((instance) => instance.handler.close());
+}
+message.closeAll = closeAll;
+message.closeAllByPlacement = closeAllByPlacement;
+message._context = null;
+
+//#endregion
+export { closeAll, closeAllByPlacement, message as default };
+//# sourceMappingURL=method.mjs.map

frontend/node_modules/element-plus/es/components/message/style/css.mjs

@@ -0,0 +1,3 @@
+import "../../base/style/css.mjs";
+import "../../badge/style/css.mjs";
+import "element-plus/theme-chalk/el-message.css";

frontend/node_modules/element-plus/es/components/message/style/index.mjs

@@ -0,0 +1,3 @@
+import "../../base/style/index.mjs";
+import "../../badge/style/index.mjs";
+import "element-plus/theme-chalk/src/message.scss";