feat: initial commit - Phase 1 & 2 core features

frontend/node_modules/element-plus/lib/components/tabs/index.d.ts

@@ -0,0 +1,16 @@
+import { SFCWithInstall } from "../../utils/vue/typescript.js";
+import "../../utils/index.js";
+import { _default } from "./src/tab-pane.vue.js";
+import { TabPaneInstance, TabPaneProps, TabPanePropsPublic, tabPaneProps } from "./src/tab-pane.js";
+import { TabPaneName, TabsPaneContext, TabsRootContext, tabsRootContextKey } from "./src/constants.js";
+import { TabBarInstance, TabBarProps, TabBarPropsPublic, tabBarProps } from "./src/tab-bar.js";
+import { TabNavEmits, TabNavInstance, TabNavProps, TabNavPropsPublic, tabNavEmits, tabNavProps } from "./src/tab-nav.js";
+import { Tabs, TabsEmits, TabsInstance, TabsPanes, TabsProps, TabsPropsPublic, tabsEmits, tabsProps } from "./src/tabs.js";
+
+//#region ../../packages/components/tabs/index.d.ts
+declare const ElTabs: SFCWithInstall<typeof Tabs> & {
+  TabPane: typeof _default;
+};
+declare const ElTabPane: SFCWithInstall<typeof _default>;
+//#endregion
+export { ElTabPane, ElTabs, ElTabs as default, TabBarInstance, TabBarProps, TabBarPropsPublic, TabNavEmits, TabNavInstance, TabNavProps, TabNavPropsPublic, TabPaneInstance, TabPaneName, TabPaneProps, TabPanePropsPublic, TabsEmits, TabsInstance, TabsPaneContext, TabsPanes, TabsProps, TabsPropsPublic, TabsRootContext, tabBarProps, tabNavEmits, tabNavProps, tabPaneProps, tabsEmits, tabsProps, tabsRootContextKey };

frontend/node_modules/element-plus/lib/components/tabs/index.js

@@ -0,0 +1,25 @@
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: 'Module' } });
+const require_install = require('../../utils/vue/install.js');
+const require_constants = require('./src/constants.js');
+const require_tab_bar = require('./src/tab-bar.js');
+const require_tab_nav = require('./src/tab-nav.js');
+const require_tabs = require('./src/tabs.js');
+const require_tab_pane = require('./src/tab-pane.js');
+const require_tab_pane$1 = require('./src/tab-pane2.js');
+
+//#region ../../packages/components/tabs/index.ts
+const ElTabs = require_install.withInstall(require_tabs.default, { TabPane: require_tab_pane$1.default });
+const ElTabPane = require_install.withNoopInstall(require_tab_pane$1.default);
+
+//#endregion
+exports.ElTabPane = ElTabPane;
+exports.ElTabs = ElTabs;
+exports.default = ElTabs;
+exports.tabBarProps = require_tab_bar.tabBarProps;
+exports.tabNavEmits = require_tab_nav.tabNavEmits;
+exports.tabNavProps = require_tab_nav.tabNavProps;
+exports.tabPaneProps = require_tab_pane.tabPaneProps;
+exports.tabsEmits = require_tabs.tabsEmits;
+exports.tabsProps = require_tabs.tabsProps;
+exports.tabsRootContextKey = require_constants.tabsRootContextKey;
+//# sourceMappingURL=index.js.map

frontend/node_modules/element-plus/lib/components/tabs/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":["withInstall","Tabs","withNoopInstall","TabPane"],"sources":["../../../../../packages/components/tabs/index.ts"],"sourcesContent":["import { withInstall, withNoopInstall } from '@element-plus/utils'\nimport Tabs from './src/tabs'\nimport TabPane from './src/tab-pane.vue'\n\nimport type { SFCWithInstall } from '@element-plus/utils'\n\nexport const ElTabs: SFCWithInstall<typeof Tabs> & {\n  TabPane: typeof TabPane\n} = withInstall(Tabs, {\n  TabPane,\n})\nexport const ElTabPane: SFCWithInstall<typeof TabPane> =\n  withNoopInstall(TabPane)\nexport default ElTabs\n\nexport * from './src/tabs'\nexport * from './src/tab-bar'\nexport * from './src/tab-nav'\nexport * from './src/tab-pane'\nexport * from './src/constants'\n"],"mappings":";;;;;;;;;;AAMA,MAAa,SAETA,4BAAYC,sBAAM,EACpB,qCACD,CAAC;AACF,MAAa,YACXC,gCAAgBC,2BAAQ"}

frontend/node_modules/element-plus/lib/components/tabs/src/constants.d.ts

@@ -0,0 +1,28 @@
+import { TabPaneProps } from "./tab-pane.js";
+import { TabNavInstance } from "./tab-nav.js";
+import { TabsProps } from "./tabs.js";
+import { ComputedRef, InjectionKey, Ref, Slots, UnwrapRef, VNode } from "vue";
+
+//#region ../../packages/components/tabs/src/constants.d.ts
+type TabPaneName = string | number;
+type TabsPaneContext = UnwrapRef<{
+  uid: number;
+  getVnode: () => VNode;
+  slots: Slots;
+  props: TabPaneProps;
+  paneName: ComputedRef<TabPaneName | undefined>;
+  active: ComputedRef<boolean>;
+  index: Ref<string | undefined>;
+  isClosable: ComputedRef<boolean>;
+  isFocusInsidePane: () => boolean | undefined;
+}>;
+interface TabsRootContext {
+  props: TabsProps;
+  currentName: Ref<TabPaneName>;
+  registerPane: (pane: TabsPaneContext) => void;
+  unregisterPane: (pane: TabsPaneContext) => void;
+  nav$: Ref<TabNavInstance | undefined>;
+}
+declare const tabsRootContextKey: InjectionKey<TabsRootContext>;
+//#endregion
+export { TabPaneName, TabsPaneContext, TabsRootContext, tabsRootContextKey };

frontend/node_modules/element-plus/lib/components/tabs/src/constants.js

@@ -0,0 +1,8 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+//#region ../../packages/components/tabs/src/constants.ts
+const tabsRootContextKey = Symbol("tabsRootContextKey");
+
+//#endregion
+exports.tabsRootContextKey = tabsRootContextKey;
+//# sourceMappingURL=constants.js.map

frontend/node_modules/element-plus/lib/components/tabs/src/constants.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.js","names":[],"sources":["../../../../../../packages/components/tabs/src/constants.ts"],"sourcesContent":["import type {\n  ComputedRef,\n  InjectionKey,\n  Ref,\n  Slots,\n  UnwrapRef,\n  VNode,\n} from 'vue'\nimport type { TabsProps } from './tabs'\nimport type { TabPaneProps } from './tab-pane'\nimport type { TabNavInstance } from './tab-nav'\n\nexport type TabPaneName = string | number\n\nexport type TabsPaneContext = UnwrapRef<{\n  uid: number\n  getVnode: () => VNode\n  slots: Slots\n  props: TabPaneProps\n  paneName: ComputedRef<TabPaneName | undefined>\n  active: ComputedRef<boolean>\n  index: Ref<string | undefined>\n  isClosable: ComputedRef<boolean>\n  isFocusInsidePane: () => boolean | undefined\n}>\n\nexport interface TabsRootContext {\n  props: TabsProps\n  currentName: Ref<TabPaneName>\n  registerPane: (pane: TabsPaneContext) => void\n  unregisterPane: (pane: TabsPaneContext) => void\n  nav$: Ref<TabNavInstance | undefined>\n}\n\nexport const tabsRootContextKey: InjectionKey<TabsRootContext> =\n  Symbol('tabsRootContextKey')\n"],"mappings":";;;AAkCA,MAAa,qBACX,OAAO,qBAAqB"}

frontend/node_modules/element-plus/lib/components/tabs/src/tab-bar.d.ts

@@ -0,0 +1,105 @@
+import { EpPropFinalized } from "../../../utils/vue/props/types.js";
+import { Mutable } from "../../../utils/typescript.js";
+import "../../../utils/index.js";
+import { TabPaneName, TabsPaneContext } from "./constants.js";
+import { _default } from "./tab-bar.vue.js";
+import * as vue from "vue";
+import { ExtractPublicPropTypes } from "vue";
+
+//#region ../../packages/components/tabs/src/tab-bar.d.ts
+/**
+ * @deprecated Removed after 3.0.0, Use `TabBarProps` instead.
+ */
+declare const tabBarProps: {
+  readonly tabs: EpPropFinalized<(new (...args: any[]) => {
+    uid: number;
+    getVnode: () => vue.VNode;
+    slots: vue.Slots;
+    props: {
+      label?: string | undefined;
+      name?: (string | number) | undefined;
+      closable?: boolean | undefined;
+      disabled?: boolean | undefined;
+      lazy?: boolean | undefined;
+    };
+    paneName: TabPaneName | undefined;
+    active: boolean;
+    index: string | undefined;
+    isClosable: boolean;
+    isFocusInsidePane: () => boolean | undefined;
+  }[]) | (() => {
+    uid: number;
+    getVnode: () => vue.VNode;
+    slots: vue.Slots;
+    props: {
+      label?: string | undefined;
+      name?: (string | number) | undefined;
+      closable?: boolean | undefined;
+      disabled?: boolean | undefined;
+      lazy?: boolean | undefined;
+    };
+    paneName: TabPaneName | undefined;
+    active: boolean;
+    index: string | undefined;
+    isClosable: boolean;
+    isFocusInsidePane: () => boolean | undefined;
+  }[]) | (((new (...args: any[]) => {
+    uid: number;
+    getVnode: () => vue.VNode;
+    slots: vue.Slots;
+    props: {
+      label?: string | undefined;
+      name?: (string | number) | undefined;
+      closable?: boolean | undefined;
+      disabled?: boolean | undefined;
+      lazy?: boolean | undefined;
+    };
+    paneName: TabPaneName | undefined;
+    active: boolean;
+    index: string | undefined;
+    isClosable: boolean;
+    isFocusInsidePane: () => boolean | undefined;
+  }[]) | (() => {
+    uid: number;
+    getVnode: () => vue.VNode;
+    slots: vue.Slots;
+    props: {
+      label?: string | undefined;
+      name?: (string | number) | undefined;
+      closable?: boolean | undefined;
+      disabled?: boolean | undefined;
+      lazy?: boolean | undefined;
+    };
+    paneName: TabPaneName | undefined;
+    active: boolean;
+    index: string | undefined;
+    isClosable: boolean;
+    isFocusInsidePane: () => boolean | undefined;
+  }[])) | null)[], unknown, unknown, () => [], boolean>;
+  readonly tabRefs: EpPropFinalized<(new (...args: any[]) => {
+    [key: string]: HTMLDivElement;
+    [key: number]: HTMLDivElement;
+  }) | (() => {
+    [key: string]: HTMLDivElement;
+    [key: number]: HTMLDivElement;
+  }) | (((new (...args: any[]) => {
+    [key: string]: HTMLDivElement;
+    [key: number]: HTMLDivElement;
+  }) | (() => {
+    [key: string]: HTMLDivElement;
+    [key: number]: HTMLDivElement;
+  })) | null)[], unknown, unknown, () => Mutable<{}>, boolean>;
+};
+type TabBarProps = {
+  tabs?: TabsPaneContext[];
+  tabRefs?: {
+    [key: TabPaneName]: HTMLDivElement;
+  };
+};
+/**
+ * @deprecated Removed after 3.0.0, Use `TabBarProps` instead.
+ */
+type TabBarPropsPublic = ExtractPublicPropTypes<typeof tabBarProps>;
+type TabBarInstance = InstanceType<typeof _default> & unknown;
+//#endregion
+export { TabBarInstance, TabBarProps, TabBarPropsPublic, tabBarProps };

frontend/node_modules/element-plus/lib/components/tabs/src/tab-bar.js

@@ -0,0 +1,22 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_runtime = require('../../../utils/vue/props/runtime.js');
+const require_typescript = require('../../../utils/typescript.js');
+
+//#region ../../packages/components/tabs/src/tab-bar.ts
+/**
+* @deprecated Removed after 3.0.0, Use `TabBarProps` instead.
+*/
+const tabBarProps = require_runtime.buildProps({
+	tabs: {
+		type: require_runtime.definePropType(Array),
+		default: () => require_typescript.mutable([])
+	},
+	tabRefs: {
+		type: require_runtime.definePropType(Object),
+		default: () => require_typescript.mutable({})
+	}
+});
+
+//#endregion
+exports.tabBarProps = tabBarProps;
+//# sourceMappingURL=tab-bar.js.map

frontend/node_modules/element-plus/lib/components/tabs/src/tab-bar.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tab-bar.js","names":["buildProps","definePropType","mutable"],"sources":["../../../../../../packages/components/tabs/src/tab-bar.ts"],"sourcesContent":["import { buildProps, definePropType, mutable } from '@element-plus/utils'\n\nimport type { ExtractPublicPropTypes } from 'vue'\nimport type { TabPaneName, TabsPaneContext } from './constants'\nimport type TabBar from './tab-bar.vue'\n\n/**\n * @deprecated Removed after 3.0.0, Use `TabBarProps` instead.\n */\nexport const tabBarProps = buildProps({\n  tabs: {\n    type: definePropType<TabsPaneContext[]>(Array),\n    default: () => mutable([] as const),\n  },\n  tabRefs: {\n    type: definePropType<{ [key: TabPaneName]: HTMLDivElement }>(Object),\n    default: () => mutable({} as const),\n  },\n} as const)\n\nexport type TabBarProps = {\n  tabs?: TabsPaneContext[]\n  tabRefs?: { [key: TabPaneName]: HTMLDivElement }\n}\n\n/**\n * @deprecated Removed after 3.0.0, Use `TabBarProps` instead.\n */\nexport type TabBarPropsPublic = ExtractPublicPropTypes<typeof tabBarProps>\nexport type TabBarInstance = InstanceType<typeof TabBar> & unknown\n"],"mappings":";;;;;;;;AASA,MAAa,cAAcA,2BAAW;CACpC,MAAM;EACJ,MAAMC,+BAAkC,MAAM;EAC9C,eAAeC,2BAAQ,EAAE,CAAU;EACpC;CACD,SAAS;EACP,MAAMD,+BAAuD,OAAO;EACpE,eAAeC,2BAAQ,EAAE,CAAU;EACpC;CACF,CAAU"}

frontend/node_modules/element-plus/lib/components/tabs/src/tab-bar.vue.d.ts

@@ -0,0 +1,18 @@
+import { TabPaneName, TabsPaneContext } from "./constants.js";
+import { TabBarProps } from "./tab-bar.js";
+import * as vue from "vue";
+import { CSSProperties } from "vue";
+
+//#region ../../packages/components/tabs/src/tab-bar.vue.d.ts
+declare const __VLS_export: vue.DefineComponent<TabBarProps, {
+  /** @description tab root html element */ref: vue.Ref<HTMLDivElement | undefined, HTMLDivElement | undefined>; /** @description method to manually update tab bar style, return the updated style */
+  update: () => CSSProperties;
+}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<TabBarProps> & Readonly<{}>, {
+  tabs: TabsPaneContext[];
+  tabRefs: {
+    [key: TabPaneName]: HTMLDivElement;
+  };
+}, {}, {}, {}, string, vue.ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+//#endregion
+export { _default };

frontend/node_modules/element-plus/lib/components/tabs/src/tab-bar.vue_vue_type_script_setup_true_lang.js

@@ -0,0 +1,94 @@
+const require_runtime = require('../../../_virtual/_rolldown/runtime.js');
+const require_types = require('../../../utils/types.js');
+const require_strings = require('../../../utils/strings.js');
+const require_error = require('../../../utils/error.js');
+const require_index = require('../../../hooks/use-namespace/index.js');
+const require_constants = require('./constants.js');
+const require_tab_bar = require('./tab-bar.js');
+let _vueuse_core = require("@vueuse/core");
+let vue = require("vue");
+
+//#region ../../packages/components/tabs/src/tab-bar.vue?vue&type=script&setup=true&lang.ts
+const COMPONENT_NAME = "ElTabBar";
+var tab_bar_vue_vue_type_script_setup_true_lang_default = /* @__PURE__ */ (0, vue.defineComponent)({
+	name: COMPONENT_NAME,
+	__name: "tab-bar",
+	props: require_tab_bar.tabBarProps,
+	setup(__props, { expose: __expose }) {
+		const props = __props;
+		const rootTabs = (0, vue.inject)(require_constants.tabsRootContextKey);
+		if (!rootTabs) require_error.throwError(COMPONENT_NAME, "<el-tabs><el-tab-bar /></el-tabs>");
+		const ns = require_index.useNamespace("tabs");
+		const barRef = (0, vue.ref)();
+		const barStyle = (0, vue.ref)();
+		/**
+		* when defaultValue is not set, the bar is always shown.
+		*
+		* when defaultValue is set, the bar will be hidden until style is calculated
+		* to avoid the bar showing in the wrong position on initial render.
+		*/
+		const renderActiveBar = (0, vue.computed)(() => require_types.isUndefined(rootTabs.props.defaultValue) || Boolean(barStyle.value?.transform));
+		const getBarStyle = () => {
+			let offset = 0;
+			let tabSize = 0;
+			const sizeName = ["top", "bottom"].includes(rootTabs.props.tabPosition) ? "width" : "height";
+			const sizeDir = sizeName === "width" ? "x" : "y";
+			const position = sizeDir === "x" ? "left" : "top";
+			props.tabs.every((tab) => {
+				if (require_types.isUndefined(tab.paneName)) return false;
+				const $el = props.tabRefs[tab.paneName];
+				if (!$el) return false;
+				if (!tab.active) return true;
+				offset = $el[`offset${require_strings.capitalize(position)}`];
+				tabSize = $el[`client${require_strings.capitalize(sizeName)}`];
+				const tabStyles = window.getComputedStyle($el);
+				if (sizeName === "width") {
+					tabSize -= Number.parseFloat(tabStyles.paddingLeft) + Number.parseFloat(tabStyles.paddingRight);
+					offset += Number.parseFloat(tabStyles.paddingLeft);
+				}
+				return false;
+			});
+			return {
+				[sizeName]: `${tabSize}px`,
+				transform: `translate${require_strings.capitalize(sizeDir)}(${offset}px)`
+			};
+		};
+		const update = () => barStyle.value = getBarStyle();
+		const tabObservers = [];
+		const observerTabs = () => {
+			tabObservers.forEach((observer) => observer.stop());
+			tabObservers.length = 0;
+			Object.values(props.tabRefs).forEach((tab) => {
+				tabObservers.push((0, _vueuse_core.useResizeObserver)(tab, update));
+			});
+		};
+		(0, vue.watch)(() => props.tabs, async () => {
+			await (0, vue.nextTick)();
+			update();
+			observerTabs();
+		}, { immediate: true });
+		const barObserver = (0, _vueuse_core.useResizeObserver)(barRef, () => update());
+		(0, vue.onBeforeUnmount)(() => {
+			tabObservers.forEach((observer) => observer.stop());
+			tabObservers.length = 0;
+			barObserver.stop();
+		});
+		__expose({
+			ref: barRef,
+			update
+		});
+		return (_ctx, _cache) => {
+			return renderActiveBar.value ? ((0, vue.openBlock)(), (0, vue.createElementBlock)("div", {
+				key: 0,
+				ref_key: "barRef",
+				ref: barRef,
+				class: (0, vue.normalizeClass)([(0, vue.unref)(ns).e("active-bar"), (0, vue.unref)(ns).is((0, vue.unref)(rootTabs).props.tabPosition)]),
+				style: (0, vue.normalizeStyle)(barStyle.value)
+			}, null, 6)) : (0, vue.createCommentVNode)("v-if", true);
+		};
+	}
+});
+
+//#endregion
+exports.default = tab_bar_vue_vue_type_script_setup_true_lang_default;
+//# sourceMappingURL=tab-bar.vue_vue_type_script_setup_true_lang.js.map

frontend/node_modules/element-plus/lib/components/tabs/src/tab-bar.vue_vue_type_script_setup_true_lang.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tab-bar.vue_vue_type_script_setup_true_lang.js","names":[],"sources":["../../../../../../packages/components/tabs/src/tab-bar.vue"],"sourcesContent":["<template>\n  <div\n    v-if=\"renderActiveBar\"\n    ref=\"barRef\"\n    :class=\"[ns.e('active-bar'), ns.is(rootTabs!.props.tabPosition)]\"\n    :style=\"barStyle\"\n  />\n</template>\n\n<script lang=\"ts\" setup>\nimport { computed, inject, nextTick, onBeforeUnmount, ref, watch } from 'vue'\nimport { useResizeObserver } from '@vueuse/core'\nimport { capitalize, isUndefined, throwError } from '@element-plus/utils'\nimport { useNamespace } from '@element-plus/hooks'\nimport { tabsRootContextKey } from './constants'\n\nimport type { TabBarProps } from './tab-bar'\nimport type { CSSProperties } from 'vue'\n\nconst COMPONENT_NAME = 'ElTabBar'\ndefineOptions({\n  name: COMPONENT_NAME,\n})\nconst props = withDefaults(defineProps<TabBarProps>(), {\n  tabs: () => [],\n  tabRefs: () => ({}),\n})\n\nconst rootTabs = inject(tabsRootContextKey)\nif (!rootTabs) throwError(COMPONENT_NAME, '<el-tabs><el-tab-bar /></el-tabs>')\n\nconst ns = useNamespace('tabs')\n\nconst barRef = ref<HTMLDivElement>()\nconst barStyle = ref<CSSProperties>()\n/**\n * when defaultValue is not set, the bar is always shown.\n *\n * when defaultValue is set, the bar will be hidden until style is calculated\n * to avoid the bar showing in the wrong position on initial render.\n */\nconst renderActiveBar = computed(\n  () =>\n    isUndefined(rootTabs.props.defaultValue) ||\n    Boolean(barStyle.value?.transform)\n)\n\nconst getBarStyle = (): CSSProperties => {\n  let offset = 0\n  let tabSize = 0\n\n  const sizeName = ['top', 'bottom'].includes(rootTabs.props.tabPosition)\n    ? 'width'\n    : 'height'\n  const sizeDir = sizeName === 'width' ? 'x' : 'y'\n  const position = sizeDir === 'x' ? 'left' : 'top'\n\n  props.tabs.every((tab) => {\n    if (isUndefined(tab.paneName)) return false\n    const $el = props.tabRefs[tab.paneName]\n    if (!$el) return false\n\n    if (!tab.active) {\n      return true\n    }\n\n    offset = $el[`offset${capitalize(position)}`]\n    tabSize = $el[`client${capitalize(sizeName)}`]\n\n    const tabStyles = window.getComputedStyle($el)\n\n    if (sizeName === 'width') {\n      tabSize -=\n        Number.parseFloat(tabStyles.paddingLeft) +\n        Number.parseFloat(tabStyles.paddingRight)\n      offset += Number.parseFloat(tabStyles.paddingLeft)\n    }\n    return false\n  })\n\n  return {\n    [sizeName]: `${tabSize}px`,\n    transform: `translate${capitalize(sizeDir)}(${offset}px)`,\n  }\n}\n\nconst update = () => (barStyle.value = getBarStyle())\n\nconst tabObservers = [] as ReturnType<typeof useResizeObserver>[]\nconst observerTabs = () => {\n  tabObservers.forEach((observer) => observer.stop())\n  tabObservers.length = 0\n\n  Object.values(props.tabRefs).forEach((tab) => {\n    tabObservers.push(useResizeObserver(tab, update))\n  })\n}\n\nwatch(\n  () => props.tabs,\n  async () => {\n    await nextTick()\n    update()\n\n    observerTabs()\n  },\n  { immediate: true }\n)\nconst barObserver = useResizeObserver(barRef, () => update())\n\nonBeforeUnmount(() => {\n  tabObservers.forEach((observer) => observer.stop())\n  tabObservers.length = 0\n  barObserver.stop()\n})\n\ndefineExpose({\n  /** @description tab root html element */\n  ref: barRef,\n  /** @description method to manually update tab bar style, return the updated style */\n  update,\n})\n</script>\n"],"mappings":";;;;;;;;;;;AAmBA,MAAM,iBAAiB;;;;;;EAIvB,MAAM,QAAQ;EAKd,MAAM,2BAAkB,qCAAkB;AAC1C,MAAI,CAAC,SAAU,0BAAW,gBAAgB,oCAAmC;EAE7E,MAAM,KAAK,2BAAa,OAAM;EAE9B,MAAM,uBAA6B;EACnC,MAAM,yBAA8B;;;;;;;EAOpC,MAAM,0CAEF,0BAAY,SAAS,MAAM,aAAa,IACxC,QAAQ,SAAS,OAAO,UAAS,CACrC;EAEA,MAAM,oBAAmC;GACvC,IAAI,SAAS;GACb,IAAI,UAAU;GAEd,MAAM,WAAW,CAAC,OAAO,SAAS,CAAC,SAAS,SAAS,MAAM,YAAW,GAClE,UACA;GACJ,MAAM,UAAU,aAAa,UAAU,MAAM;GAC7C,MAAM,WAAW,YAAY,MAAM,SAAS;AAE5C,SAAM,KAAK,OAAO,QAAQ;AACxB,QAAI,0BAAY,IAAI,SAAS,CAAE,QAAO;IACtC,MAAM,MAAM,MAAM,QAAQ,IAAI;AAC9B,QAAI,CAAC,IAAK,QAAO;AAEjB,QAAI,CAAC,IAAI,OACP,QAAO;AAGT,aAAS,IAAI,SAAS,2BAAW,SAAS;AAC1C,cAAU,IAAI,SAAS,2BAAW,SAAS;IAE3C,MAAM,YAAY,OAAO,iBAAiB,IAAG;AAE7C,QAAI,aAAa,SAAS;AACxB,gBACE,OAAO,WAAW,UAAU,YAAY,GACxC,OAAO,WAAW,UAAU,aAAY;AAC1C,eAAU,OAAO,WAAW,UAAU,YAAW;;AAEnD,WAAO;KACR;AAED,UAAO;KACJ,WAAW,GAAG,QAAQ;IACvB,WAAW,YAAY,2BAAW,QAAQ,CAAC,GAAG,OAAO;IACvD;;EAGF,MAAM,eAAgB,SAAS,QAAQ,aAAa;EAEpD,MAAM,eAAe,EAAE;EACvB,MAAM,qBAAqB;AACzB,gBAAa,SAAS,aAAa,SAAS,MAAM,CAAA;AAClD,gBAAa,SAAS;AAEtB,UAAO,OAAO,MAAM,QAAQ,CAAC,SAAS,QAAQ;AAC5C,iBAAa,yCAAuB,KAAK,OAAO,CAAA;KACjD;;AAGH,uBACQ,MAAM,MACZ,YAAY;AACV,4BAAe;AACf,WAAO;AAEP,iBAAa;KAEf,EAAE,WAAW,MAAK,CACpB;EACA,MAAM,kDAAgC,cAAc,QAAQ,CAAA;AAE5D,iCAAsB;AACpB,gBAAa,SAAS,aAAa,SAAS,MAAM,CAAA;AAClD,gBAAa,SAAS;AACtB,eAAY,MAAK;IAClB;AAED,WAAa;GAEX,KAAK;GAEL;GACD,CAAA;;UAvHS,gBAAA,2DAIN,OAAA;;aAHI;IAAJ,KAAI;IACH,+BAAK,gBAAG,GAAE,CAAC,EAAC,aAAA,iBAAgB,GAAE,CAAC,kBAAG,SAAQ,CAAE,MAAM,YAAW,CAAA,CAAA;IAC7D,+BAAO,SAAA,MAAQ"}

frontend/node_modules/element-plus/lib/components/tabs/src/tab-bar2.js

@@ -0,0 +1,9 @@
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: 'Module' } });
+const require_tab_bar_vue_vue_type_script_setup_true_lang = require('./tab-bar.vue_vue_type_script_setup_true_lang.js');
+
+//#region ../../packages/components/tabs/src/tab-bar.vue
+var tab_bar_default = require_tab_bar_vue_vue_type_script_setup_true_lang.default;
+
+//#endregion
+exports.default = tab_bar_default;
+//# sourceMappingURL=tab-bar2.js.map

frontend/node_modules/element-plus/lib/components/tabs/src/tab-bar2.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tab-bar2.js","names":[],"sources":["../../../../../../packages/components/tabs/src/tab-bar.vue"],"sourcesContent":["<template>\n  <div\n    v-if=\"renderActiveBar\"\n    ref=\"barRef\"\n    :class=\"[ns.e('active-bar'), ns.is(rootTabs!.props.tabPosition)]\"\n    :style=\"barStyle\"\n  />\n</template>\n\n<script lang=\"ts\" setup>\nimport { computed, inject, nextTick, onBeforeUnmount, ref, watch } from 'vue'\nimport { useResizeObserver } from '@vueuse/core'\nimport { capitalize, isUndefined, throwError } from '@element-plus/utils'\nimport { useNamespace } from '@element-plus/hooks'\nimport { tabsRootContextKey } from './constants'\n\nimport type { TabBarProps } from './tab-bar'\nimport type { CSSProperties } from 'vue'\n\nconst COMPONENT_NAME = 'ElTabBar'\ndefineOptions({\n  name: COMPONENT_NAME,\n})\nconst props = withDefaults(defineProps<TabBarProps>(), {\n  tabs: () => [],\n  tabRefs: () => ({}),\n})\n\nconst rootTabs = inject(tabsRootContextKey)\nif (!rootTabs) throwError(COMPONENT_NAME, '<el-tabs><el-tab-bar /></el-tabs>')\n\nconst ns = useNamespace('tabs')\n\nconst barRef = ref<HTMLDivElement>()\nconst barStyle = ref<CSSProperties>()\n/**\n * when defaultValue is not set, the bar is always shown.\n *\n * when defaultValue is set, the bar will be hidden until style is calculated\n * to avoid the bar showing in the wrong position on initial render.\n */\nconst renderActiveBar = computed(\n  () =>\n    isUndefined(rootTabs.props.defaultValue) ||\n    Boolean(barStyle.value?.transform)\n)\n\nconst getBarStyle = (): CSSProperties => {\n  let offset = 0\n  let tabSize = 0\n\n  const sizeName = ['top', 'bottom'].includes(rootTabs.props.tabPosition)\n    ? 'width'\n    : 'height'\n  const sizeDir = sizeName === 'width' ? 'x' : 'y'\n  const position = sizeDir === 'x' ? 'left' : 'top'\n\n  props.tabs.every((tab) => {\n    if (isUndefined(tab.paneName)) return false\n    const $el = props.tabRefs[tab.paneName]\n    if (!$el) return false\n\n    if (!tab.active) {\n      return true\n    }\n\n    offset = $el[`offset${capitalize(position)}`]\n    tabSize = $el[`client${capitalize(sizeName)}`]\n\n    const tabStyles = window.getComputedStyle($el)\n\n    if (sizeName === 'width') {\n      tabSize -=\n        Number.parseFloat(tabStyles.paddingLeft) +\n        Number.parseFloat(tabStyles.paddingRight)\n      offset += Number.parseFloat(tabStyles.paddingLeft)\n    }\n    return false\n  })\n\n  return {\n    [sizeName]: `${tabSize}px`,\n    transform: `translate${capitalize(sizeDir)}(${offset}px)`,\n  }\n}\n\nconst update = () => (barStyle.value = getBarStyle())\n\nconst tabObservers = [] as ReturnType<typeof useResizeObserver>[]\nconst observerTabs = () => {\n  tabObservers.forEach((observer) => observer.stop())\n  tabObservers.length = 0\n\n  Object.values(props.tabRefs).forEach((tab) => {\n    tabObservers.push(useResizeObserver(tab, update))\n  })\n}\n\nwatch(\n  () => props.tabs,\n  async () => {\n    await nextTick()\n    update()\n\n    observerTabs()\n  },\n  { immediate: true }\n)\nconst barObserver = useResizeObserver(barRef, () => update())\n\nonBeforeUnmount(() => {\n  tabObservers.forEach((observer) => observer.stop())\n  tabObservers.length = 0\n  barObserver.stop()\n})\n\ndefineExpose({\n  /** @description tab root html element */\n  ref: barRef,\n  /** @description method to manually update tab bar style, return the updated style */\n  update,\n})\n</script>\n"],"mappings":""}

frontend/node_modules/element-plus/lib/components/tabs/src/tab-nav.d.ts

@@ -0,0 +1,302 @@
+import { EpPropFinalized, EpPropMergeType } from "../../../utils/vue/props/types.js";
+import "../../../utils/index.js";
+import { TabPaneName, TabsPaneContext } from "./constants.js";
+import { TabBarInstance } from "./tab-bar.js";
+import * as vue from "vue";
+import { ExtractPropTypes, ExtractPublicPropTypes } from "vue";
+import * as vue_jsx_runtime0 from "vue/jsx-runtime";
+
+//#region ../../packages/components/tabs/src/tab-nav.d.ts
+declare const tabNavProps: {
+  readonly panes: EpPropFinalized<(new (...args: any[]) => {
+    uid: number;
+    getVnode: () => vue.VNode;
+    slots: vue.Slots;
+    props: {
+      label?: string | undefined;
+      name?: (string | number) | undefined;
+      closable?: boolean | undefined;
+      disabled?: boolean | undefined;
+      lazy?: boolean | undefined;
+    };
+    paneName: TabPaneName | undefined;
+    active: boolean;
+    index: string | undefined;
+    isClosable: boolean;
+    isFocusInsidePane: () => boolean | undefined;
+  }[]) | (() => {
+    uid: number;
+    getVnode: () => vue.VNode;
+    slots: vue.Slots;
+    props: {
+      label?: string | undefined;
+      name?: (string | number) | undefined;
+      closable?: boolean | undefined;
+      disabled?: boolean | undefined;
+      lazy?: boolean | undefined;
+    };
+    paneName: TabPaneName | undefined;
+    active: boolean;
+    index: string | undefined;
+    isClosable: boolean;
+    isFocusInsidePane: () => boolean | undefined;
+  }[]) | (((new (...args: any[]) => {
+    uid: number;
+    getVnode: () => vue.VNode;
+    slots: vue.Slots;
+    props: {
+      label?: string | undefined;
+      name?: (string | number) | undefined;
+      closable?: boolean | undefined;
+      disabled?: boolean | undefined;
+      lazy?: boolean | undefined;
+    };
+    paneName: TabPaneName | undefined;
+    active: boolean;
+    index: string | undefined;
+    isClosable: boolean;
+    isFocusInsidePane: () => boolean | undefined;
+  }[]) | (() => {
+    uid: number;
+    getVnode: () => vue.VNode;
+    slots: vue.Slots;
+    props: {
+      label?: string | undefined;
+      name?: (string | number) | undefined;
+      closable?: boolean | undefined;
+      disabled?: boolean | undefined;
+      lazy?: boolean | undefined;
+    };
+    paneName: TabPaneName | undefined;
+    active: boolean;
+    index: string | undefined;
+    isClosable: boolean;
+    isFocusInsidePane: () => boolean | undefined;
+  }[])) | null)[], unknown, unknown, () => [], boolean>;
+  readonly currentName: EpPropFinalized<readonly [StringConstructor, NumberConstructor], unknown, unknown, "", boolean>;
+  readonly editable: BooleanConstructor;
+  readonly type: EpPropFinalized<StringConstructor, "" | "card" | "border-card", unknown, "", boolean>;
+  readonly stretch: BooleanConstructor;
+  readonly tabindex: EpPropFinalized<readonly [StringConstructor, NumberConstructor], unknown, unknown, undefined, boolean>;
+};
+declare const tabNavEmits: {
+  tabClick: (tab: TabsPaneContext, tabName: TabPaneName, ev: Event) => boolean;
+  tabRemove: (tab: TabsPaneContext, ev: Event) => boolean;
+};
+type TabNavProps = ExtractPropTypes<typeof tabNavProps>;
+type TabNavPropsPublic = ExtractPublicPropTypes<typeof tabNavProps>;
+type TabNavEmits = typeof tabNavEmits;
+declare const TabNav: vue.DefineComponent<ExtractPropTypes<{
+  readonly panes: EpPropFinalized<(new (...args: any[]) => {
+    uid: number;
+    getVnode: () => vue.VNode;
+    slots: vue.Slots;
+    props: {
+      label?: string | undefined;
+      name?: (string | number) | undefined;
+      closable?: boolean | undefined;
+      disabled?: boolean | undefined;
+      lazy?: boolean | undefined;
+    };
+    paneName: TabPaneName | undefined;
+    active: boolean;
+    index: string | undefined;
+    isClosable: boolean;
+    isFocusInsidePane: () => boolean | undefined;
+  }[]) | (() => {
+    uid: number;
+    getVnode: () => vue.VNode;
+    slots: vue.Slots;
+    props: {
+      label?: string | undefined;
+      name?: (string | number) | undefined;
+      closable?: boolean | undefined;
+      disabled?: boolean | undefined;
+      lazy?: boolean | undefined;
+    };
+    paneName: TabPaneName | undefined;
+    active: boolean;
+    index: string | undefined;
+    isClosable: boolean;
+    isFocusInsidePane: () => boolean | undefined;
+  }[]) | (((new (...args: any[]) => {
+    uid: number;
+    getVnode: () => vue.VNode;
+    slots: vue.Slots;
+    props: {
+      label?: string | undefined;
+      name?: (string | number) | undefined;
+      closable?: boolean | undefined;
+      disabled?: boolean | undefined;
+      lazy?: boolean | undefined;
+    };
+    paneName: TabPaneName | undefined;
+    active: boolean;
+    index: string | undefined;
+    isClosable: boolean;
+    isFocusInsidePane: () => boolean | undefined;
+  }[]) | (() => {
+    uid: number;
+    getVnode: () => vue.VNode;
+    slots: vue.Slots;
+    props: {
+      label?: string | undefined;
+      name?: (string | number) | undefined;
+      closable?: boolean | undefined;
+      disabled?: boolean | undefined;
+      lazy?: boolean | undefined;
+    };
+    paneName: TabPaneName | undefined;
+    active: boolean;
+    index: string | undefined;
+    isClosable: boolean;
+    isFocusInsidePane: () => boolean | undefined;
+  }[])) | null)[], unknown, unknown, () => [], boolean>;
+  readonly currentName: EpPropFinalized<readonly [StringConstructor, NumberConstructor], unknown, unknown, "", boolean>;
+  readonly editable: BooleanConstructor;
+  readonly type: EpPropFinalized<StringConstructor, "" | "card" | "border-card", unknown, "", boolean>;
+  readonly stretch: BooleanConstructor;
+  readonly tabindex: EpPropFinalized<readonly [StringConstructor, NumberConstructor], unknown, unknown, undefined, boolean>;
+}>, () => vue_jsx_runtime0.JSX.Element, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
+  tabClick: (tab: TabsPaneContext, tabName: TabPaneName, ev: Event) => boolean;
+  tabRemove: (tab: TabsPaneContext, ev: Event) => boolean;
+}, string, vue.PublicProps, Readonly<ExtractPropTypes<{
+  readonly panes: EpPropFinalized<(new (...args: any[]) => {
+    uid: number;
+    getVnode: () => vue.VNode;
+    slots: vue.Slots;
+    props: {
+      label?: string | undefined;
+      name?: (string | number) | undefined;
+      closable?: boolean | undefined;
+      disabled?: boolean | undefined;
+      lazy?: boolean | undefined;
+    };
+    paneName: TabPaneName | undefined;
+    active: boolean;
+    index: string | undefined;
+    isClosable: boolean;
+    isFocusInsidePane: () => boolean | undefined;
+  }[]) | (() => {
+    uid: number;
+    getVnode: () => vue.VNode;
+    slots: vue.Slots;
+    props: {
+      label?: string | undefined;
+      name?: (string | number) | undefined;
+      closable?: boolean | undefined;
+      disabled?: boolean | undefined;
+      lazy?: boolean | undefined;
+    };
+    paneName: TabPaneName | undefined;
+    active: boolean;
+    index: string | undefined;
+    isClosable: boolean;
+    isFocusInsidePane: () => boolean | undefined;
+  }[]) | (((new (...args: any[]) => {
+    uid: number;
+    getVnode: () => vue.VNode;
+    slots: vue.Slots;
+    props: {
+      label?: string | undefined;
+      name?: (string | number) | undefined;
+      closable?: boolean | undefined;
+      disabled?: boolean | undefined;
+      lazy?: boolean | undefined;
+    };
+    paneName: TabPaneName | undefined;
+    active: boolean;
+    index: string | undefined;
+    isClosable: boolean;
+    isFocusInsidePane: () => boolean | undefined;
+  }[]) | (() => {
+    uid: number;
+    getVnode: () => vue.VNode;
+    slots: vue.Slots;
+    props: {
+      label?: string | undefined;
+      name?: (string | number) | undefined;
+      closable?: boolean | undefined;
+      disabled?: boolean | undefined;
+      lazy?: boolean | undefined;
+    };
+    paneName: TabPaneName | undefined;
+    active: boolean;
+    index: string | undefined;
+    isClosable: boolean;
+    isFocusInsidePane: () => boolean | undefined;
+  }[])) | null)[], unknown, unknown, () => [], boolean>;
+  readonly currentName: EpPropFinalized<readonly [StringConstructor, NumberConstructor], unknown, unknown, "", boolean>;
+  readonly editable: BooleanConstructor;
+  readonly type: EpPropFinalized<StringConstructor, "" | "card" | "border-card", unknown, "", boolean>;
+  readonly stretch: BooleanConstructor;
+  readonly tabindex: EpPropFinalized<readonly [StringConstructor, NumberConstructor], unknown, unknown, undefined, boolean>;
+}>> & Readonly<{
+  onTabClick?: ((tab: {
+    uid: number;
+    getVnode: () => vue.VNode;
+    slots: vue.Slots;
+    props: {
+      label?: string | undefined;
+      name?: (string | number) | undefined;
+      closable?: boolean | undefined;
+      disabled?: boolean | undefined;
+      lazy?: boolean | undefined;
+    };
+    paneName: TabPaneName | undefined;
+    active: boolean;
+    index: string | undefined;
+    isClosable: boolean;
+    isFocusInsidePane: () => boolean | undefined;
+  }, tabName: TabPaneName, ev: Event) => any) | undefined;
+  onTabRemove?: ((tab: {
+    uid: number;
+    getVnode: () => vue.VNode;
+    slots: vue.Slots;
+    props: {
+      label?: string | undefined;
+      name?: (string | number) | undefined;
+      closable?: boolean | undefined;
+      disabled?: boolean | undefined;
+      lazy?: boolean | undefined;
+    };
+    paneName: TabPaneName | undefined;
+    active: boolean;
+    index: string | undefined;
+    isClosable: boolean;
+    isFocusInsidePane: () => boolean | undefined;
+  }, ev: Event) => any) | undefined;
+}>, {
+  readonly type: EpPropMergeType<StringConstructor, "" | "card" | "border-card", unknown>;
+  readonly tabindex: EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
+  readonly stretch: boolean;
+  readonly editable: boolean;
+  readonly panes: {
+    uid: number;
+    getVnode: () => vue.VNode;
+    slots: vue.Slots;
+    props: {
+      label?: string | undefined;
+      name?: (string | number) | undefined;
+      closable?: boolean | undefined;
+      disabled?: boolean | undefined;
+      lazy?: boolean | undefined;
+    };
+    paneName: TabPaneName | undefined;
+    active: boolean;
+    index: string | undefined;
+    isClosable: boolean;
+    isFocusInsidePane: () => boolean | undefined;
+  }[];
+  readonly currentName: EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+type TabNavInstance = InstanceType<typeof TabNav> & {
+  scrollToActiveTab: () => Promise<void>;
+  removeFocus: () => void;
+  focusActiveTab: () => void;
+  scheduleRender: () => void;
+  tabListRef: HTMLDivElement | undefined;
+  tabBarRef: TabBarInstance | undefined;
+};
+//#endregion
+export { TabNavEmits, TabNavInstance, TabNavProps, TabNavPropsPublic, tabNavEmits, tabNavProps };

frontend/node_modules/element-plus/lib/components/tabs/src/tab-nav.js

@@ -0,0 +1,294 @@
+const require_runtime = require('../../../_virtual/_rolldown/runtime.js');
+const require_aria = require('../../../constants/aria.js');
+const require_event = require('../../../utils/dom/event.js');
+const require_raf = require('../../../utils/raf.js');
+const require_error = require('../../../utils/error.js');
+const require_runtime$1 = require('../../../utils/vue/props/runtime.js');
+const require_typescript = require('../../../utils/typescript.js');
+const require_numbers = require('../../../utils/numbers.js');
+const require_index = require('../../../hooks/use-namespace/index.js');
+const require_index$1 = require('../../icon/index.js');
+const require_use_wheel = require('../../virtual-list/src/hooks/use-wheel.js');
+const require_constants = require('./constants.js');
+const require_tab_bar = require('./tab-bar2.js');
+let _vueuse_core = require("@vueuse/core");
+let lodash_unified = require("lodash-unified");
+let _element_plus_icons_vue = require("@element-plus/icons-vue");
+let vue = require("vue");
+
+//#region ../../packages/components/tabs/src/tab-nav.tsx
+const tabNavProps = require_runtime$1.buildProps({
+	panes: {
+		type: require_runtime$1.definePropType(Array),
+		default: () => require_typescript.mutable([])
+	},
+	currentName: {
+		type: [String, Number],
+		default: ""
+	},
+	editable: Boolean,
+	type: {
+		type: String,
+		values: [
+			"card",
+			"border-card",
+			""
+		],
+		default: ""
+	},
+	stretch: Boolean,
+	tabindex: {
+		type: [String, Number],
+		default: void 0
+	}
+});
+const tabNavEmits = {
+	tabClick: (tab, tabName, ev) => ev instanceof Event,
+	tabRemove: (tab, ev) => ev instanceof Event
+};
+const COMPONENT_NAME = "ElTabNav";
+const TabNav = /* @__PURE__ */ (0, vue.defineComponent)({
+	name: COMPONENT_NAME,
+	props: tabNavProps,
+	emits: tabNavEmits,
+	setup(props, { expose, emit }) {
+		const rootTabs = (0, vue.inject)(require_constants.tabsRootContextKey);
+		if (!rootTabs) require_error.throwError(COMPONENT_NAME, `<el-tabs><tab-nav /></el-tabs>`);
+		const ns = require_index.useNamespace("tabs");
+		const visibility = (0, _vueuse_core.useDocumentVisibility)();
+		const focused = (0, _vueuse_core.useWindowFocus)();
+		const navScroll$ = (0, vue.ref)();
+		const nav$ = (0, vue.ref)();
+		const el$ = (0, vue.ref)();
+		const tabRefsMap = (0, vue.ref)({});
+		const tabBarRef = (0, vue.ref)();
+		const scrollable = (0, vue.ref)(false);
+		const navOffset = (0, vue.ref)(0);
+		const isFocus = (0, vue.ref)(false);
+		const focusable = (0, vue.ref)(true);
+		const isWheelScrolling = (0, vue.ref)(false);
+		const tracker = (0, vue.shallowRef)();
+		const isHorizontal = (0, vue.computed)(() => ["top", "bottom"].includes(rootTabs.props.tabPosition));
+		const sizeName = (0, vue.computed)(() => isHorizontal.value ? "width" : "height");
+		const navStyle = (0, vue.computed)(() => {
+			const dir = sizeName.value === "width" ? "X" : "Y";
+			return {
+				transition: isWheelScrolling.value ? "none" : void 0,
+				transform: `translate${dir}(-${navOffset.value}px)`
+			};
+		});
+		const { width: navContainerWidth, height: navContainerHeight } = (0, _vueuse_core.useElementSize)(navScroll$);
+		const { width: navWidth, height: navHeight } = (0, _vueuse_core.useElementSize)(nav$, {
+			width: 0,
+			height: 0
+		}, { box: "border-box" });
+		const navContainerSize = (0, vue.computed)(() => isHorizontal.value ? navContainerWidth.value : navContainerHeight.value);
+		const navSize = (0, vue.computed)(() => isHorizontal.value ? navWidth.value : navHeight.value);
+		const { onWheel } = require_use_wheel.default({
+			atStartEdge: (0, vue.computed)(() => navOffset.value <= 0),
+			atEndEdge: (0, vue.computed)(() => navSize.value - navOffset.value <= navContainerSize.value),
+			layout: (0, vue.computed)(() => isHorizontal.value ? "horizontal" : "vertical")
+		}, (offset) => {
+			navOffset.value = (0, lodash_unified.clamp)(navOffset.value + offset, 0, navSize.value - navContainerSize.value);
+		});
+		const handleWheel = (event) => {
+			isWheelScrolling.value = true;
+			onWheel(event);
+			require_raf.rAF(() => {
+				isWheelScrolling.value = false;
+			});
+		};
+		const scrollPrev = () => {
+			if (!navScroll$.value) return;
+			const containerSize = navScroll$.value.getBoundingClientRect()[sizeName.value];
+			const currentOffset = navOffset.value;
+			if (!currentOffset) return;
+			navOffset.value = currentOffset > containerSize ? currentOffset - containerSize : 0;
+		};
+		const scrollNext = () => {
+			if (!navScroll$.value || !nav$.value) return;
+			const navSize = nav$.value.getBoundingClientRect()[sizeName.value];
+			const containerSize = navScroll$.value.getBoundingClientRect()[sizeName.value];
+			const currentOffset = navOffset.value;
+			if (!require_numbers.isGreaterThan(navSize - currentOffset, containerSize)) return;
+			navOffset.value = navSize - currentOffset > containerSize * 2 ? currentOffset + containerSize : navSize - containerSize;
+		};
+		const scrollToActiveTab = async () => {
+			const nav = nav$.value;
+			if (!scrollable.value || !el$.value || !navScroll$.value || !nav) return;
+			await (0, vue.nextTick)();
+			const activeTab = tabRefsMap.value[props.currentName];
+			if (!activeTab) return;
+			const navScroll = navScroll$.value;
+			const activeTabBounding = activeTab.getBoundingClientRect();
+			const navScrollBounding = navScroll.getBoundingClientRect();
+			const navScrollLeft = navScrollBounding.left + 1;
+			const navScrollRight = navScrollBounding.right - 1;
+			const navBounding = nav.getBoundingClientRect();
+			const maxOffset = isHorizontal.value ? navBounding.width - navScrollBounding.width : navBounding.height - navScrollBounding.height;
+			const currentOffset = navOffset.value;
+			let newOffset = currentOffset;
+			if (isHorizontal.value) {
+				if (activeTabBounding.left < navScrollLeft) newOffset = currentOffset - (navScrollLeft - activeTabBounding.left);
+				if (activeTabBounding.right > navScrollRight) newOffset = currentOffset + activeTabBounding.right - navScrollRight;
+			} else {
+				if (activeTabBounding.top < navScrollBounding.top) newOffset = currentOffset - (navScrollBounding.top - activeTabBounding.top);
+				if (activeTabBounding.bottom > navScrollBounding.bottom) newOffset = currentOffset + (activeTabBounding.bottom - navScrollBounding.bottom);
+			}
+			newOffset = Math.max(newOffset, 0);
+			navOffset.value = Math.min(newOffset, maxOffset);
+		};
+		const update = () => {
+			if (!nav$.value || !navScroll$.value) return;
+			props.stretch && tabBarRef.value?.update();
+			const navSize = nav$.value.getBoundingClientRect()[sizeName.value];
+			const containerSize = navScroll$.value.getBoundingClientRect()[sizeName.value];
+			const currentOffset = navOffset.value;
+			if (containerSize < navSize) {
+				scrollable.value = scrollable.value || {};
+				scrollable.value.prev = currentOffset;
+				scrollable.value.next = require_numbers.isGreaterThan(navSize, currentOffset + containerSize);
+				if (require_numbers.isGreaterThan(containerSize, navSize - currentOffset)) navOffset.value = navSize - containerSize;
+			} else {
+				scrollable.value = false;
+				if (currentOffset > 0) navOffset.value = 0;
+			}
+		};
+		const changeTab = (event) => {
+			const code = require_event.getEventCode(event);
+			let step = 0;
+			switch (code) {
+				case require_aria.EVENT_CODE.left:
+				case require_aria.EVENT_CODE.up:
+					step = -1;
+					break;
+				case require_aria.EVENT_CODE.right:
+				case require_aria.EVENT_CODE.down:
+					step = 1;
+					break;
+				default: return;
+			}
+			const tabList = Array.from(event.currentTarget.querySelectorAll("[role=tab]:not(.is-disabled)"));
+			let nextIndex = tabList.indexOf(event.target) + step;
+			if (nextIndex < 0) nextIndex = tabList.length - 1;
+			else if (nextIndex >= tabList.length) nextIndex = 0;
+			tabList[nextIndex].focus({ preventScroll: true });
+			tabList[nextIndex].click();
+			setFocus();
+		};
+		const setFocus = () => {
+			if (focusable.value) isFocus.value = true;
+		};
+		const removeFocus = () => isFocus.value = false;
+		const setRefs = (el, key) => {
+			tabRefsMap.value[key] = el;
+		};
+		const focusActiveTab = async () => {
+			await (0, vue.nextTick)();
+			tabRefsMap.value[props.currentName]?.focus({ preventScroll: true });
+		};
+		(0, vue.watch)(visibility, (visibility) => {
+			if (visibility === "hidden") focusable.value = false;
+			else if (visibility === "visible") setTimeout(() => focusable.value = true, 50);
+		});
+		(0, vue.watch)(focused, (focused) => {
+			if (focused) setTimeout(() => focusable.value = true, 50);
+			else focusable.value = false;
+		});
+		(0, _vueuse_core.useResizeObserver)(el$, () => {
+			require_raf.rAF(update);
+		});
+		(0, vue.onMounted)(() => setTimeout(() => scrollToActiveTab(), 0));
+		(0, vue.onUpdated)(() => update());
+		expose({
+			scrollToActiveTab,
+			removeFocus,
+			focusActiveTab,
+			tabListRef: nav$,
+			tabBarRef,
+			scheduleRender: () => (0, vue.triggerRef)(tracker)
+		});
+		return () => {
+			const scrollBtn = scrollable.value ? [(0, vue.createVNode)("span", {
+				"class": [ns.e("nav-prev"), ns.is("disabled", !scrollable.value.prev)],
+				"onClick": scrollPrev
+			}, [(0, vue.createVNode)(require_index$1.ElIcon, null, { default: () => [(0, vue.createVNode)(_element_plus_icons_vue.ArrowLeft, null, null)] })]), (0, vue.createVNode)("span", {
+				"class": [ns.e("nav-next"), ns.is("disabled", !scrollable.value.next)],
+				"onClick": scrollNext
+			}, [(0, vue.createVNode)(require_index$1.ElIcon, null, { default: () => [(0, vue.createVNode)(_element_plus_icons_vue.ArrowRight, null, null)] })])] : null;
+			const tabs = props.panes.map((pane, index) => {
+				const uid = pane.uid;
+				const disabled = pane.props.disabled;
+				const tabName = pane.props.name ?? pane.index ?? `${index}`;
+				const closable = !disabled && (pane.isClosable || pane.props.closable !== false && props.editable);
+				pane.index = `${index}`;
+				const btnClose = closable ? (0, vue.createVNode)(require_index$1.ElIcon, {
+					"class": "is-icon-close",
+					"onClick": (ev) => emit("tabRemove", pane, ev)
+				}, { default: () => [(0, vue.createVNode)(_element_plus_icons_vue.Close, null, null)] }) : null;
+				const tabLabelContent = pane.slots.label?.() || pane.props.label;
+				const tabindex = !disabled && pane.active ? props.tabindex ?? rootTabs.props.tabindex : -1;
+				return (0, vue.createVNode)("div", {
+					"ref": (el) => setRefs(el, tabName),
+					"class": [
+						ns.e("item"),
+						ns.is(rootTabs.props.tabPosition),
+						ns.is("active", pane.active),
+						ns.is("disabled", disabled),
+						ns.is("closable", closable),
+						ns.is("focus", isFocus.value)
+					],
+					"id": `tab-${tabName}`,
+					"key": `tab-${uid}`,
+					"aria-controls": `pane-${tabName}`,
+					"role": "tab",
+					"aria-selected": pane.active,
+					"tabindex": tabindex,
+					"onFocus": () => setFocus(),
+					"onBlur": () => removeFocus(),
+					"onClick": (ev) => {
+						removeFocus();
+						emit("tabClick", pane, tabName, ev);
+					},
+					"onKeydown": (ev) => {
+						const code = require_event.getEventCode(ev);
+						if (closable && (code === require_aria.EVENT_CODE.delete || code === require_aria.EVENT_CODE.backspace)) emit("tabRemove", pane, ev);
+					}
+				}, [...[tabLabelContent, btnClose]]);
+			});
+			tracker.value;
+			return (0, vue.createVNode)("div", {
+				"ref": el$,
+				"class": [
+					ns.e("nav-wrap"),
+					ns.is("scrollable", !!scrollable.value),
+					ns.is(rootTabs.props.tabPosition)
+				]
+			}, [scrollBtn, (0, vue.createVNode)("div", {
+				"class": ns.e("nav-scroll"),
+				"ref": navScroll$
+			}, [props.panes.length > 0 ? (0, vue.createVNode)("div", {
+				"class": [
+					ns.e("nav"),
+					ns.is(rootTabs.props.tabPosition),
+					ns.is("stretch", props.stretch && ["top", "bottom"].includes(rootTabs.props.tabPosition))
+				],
+				"ref": nav$,
+				"style": navStyle.value,
+				"role": "tablist",
+				"onKeydown": changeTab,
+				"onWheel": handleWheel
+			}, [...[!props.type ? (0, vue.createVNode)(require_tab_bar.default, {
+				"ref": tabBarRef,
+				"tabs": [...props.panes],
+				"tabRefs": tabRefsMap.value
+			}, null) : null, tabs]]) : null])]);
+		};
+	}
+});
+
+//#endregion
+exports.default = TabNav;
+exports.tabNavEmits = tabNavEmits;
+exports.tabNavProps = tabNavProps;
+//# sourceMappingURL=tab-nav.js.map

frontend/node_modules/element-plus/lib/components/tabs/src/tab-pane.d.ts

@@ -0,0 +1,51 @@
+import { EpPropFinalized, EpPropMergeType } from "../../../utils/vue/props/types.js";
+import "../../../utils/index.js";
+import { _default } from "./tab-pane.vue.js";
+import * as vue from "vue";
+import { ExtractPublicPropTypes } from "vue";
+
+//#region ../../packages/components/tabs/src/tab-pane.d.ts
+/**
+ * @deprecated Removed after 3.0.0, Use `TabPaneProps` instead.
+ */
+declare const tabPaneProps: {
+  readonly label: EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+  readonly name: {
+    readonly type: vue.PropType<EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>>;
+    readonly required: false;
+    readonly validator: ((val: unknown) => boolean) | undefined;
+    __epPropKey: true;
+  };
+  readonly closable: EpPropFinalized<BooleanConstructor, unknown, unknown, undefined, boolean>;
+  readonly disabled: BooleanConstructor;
+  readonly lazy: BooleanConstructor;
+};
+type TabPaneProps = {
+  /**
+   * @description title of the tab
+   */
+  label?: string;
+  /**
+   * @description identifier corresponding to the name of Tabs, representing the alias of the tab-pane, the default is ordinal number of the tab-pane in the sequence, e.g. the first tab-pane is '0'
+   */
+  name?: string | number;
+  /**
+   * @description whether Tab is closable
+   */
+  closable?: boolean;
+  /**
+   * @description whether Tab is disabled
+   */
+  disabled?: boolean;
+  /**
+   * @description whether Tab is lazily rendered
+   */
+  lazy?: boolean;
+};
+/**
+ * @deprecated Removed after 3.0.0, Use `TabPaneProps` instead.
+ */
+type TabPanePropsPublic = ExtractPublicPropTypes<typeof tabPaneProps>;
+type TabPaneInstance = InstanceType<typeof _default> & unknown;
+//#endregion
+export { TabPaneInstance, TabPaneProps, TabPanePropsPublic, tabPaneProps };

frontend/node_modules/element-plus/lib/components/tabs/src/tab-pane.js

@@ -0,0 +1,24 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_runtime = require('../../../utils/vue/props/runtime.js');
+
+//#region ../../packages/components/tabs/src/tab-pane.ts
+/**
+* @deprecated Removed after 3.0.0, Use `TabPaneProps` instead.
+*/
+const tabPaneProps = require_runtime.buildProps({
+	label: {
+		type: String,
+		default: ""
+	},
+	name: { type: [String, Number] },
+	closable: {
+		type: Boolean,
+		default: void 0
+	},
+	disabled: Boolean,
+	lazy: Boolean
+});
+
+//#endregion
+exports.tabPaneProps = tabPaneProps;
+//# sourceMappingURL=tab-pane.js.map

frontend/node_modules/element-plus/lib/components/tabs/src/tab-pane.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tab-pane.js","names":["buildProps"],"sources":["../../../../../../packages/components/tabs/src/tab-pane.ts"],"sourcesContent":["import { buildProps } from '@element-plus/utils'\n\nimport type { ExtractPublicPropTypes } from 'vue'\nimport type TabPane from './tab-pane.vue'\n\n/**\n * @deprecated Removed after 3.0.0, Use `TabPaneProps` instead.\n */\nexport const tabPaneProps = buildProps({\n  /**\n   * @description title of the tab\n   */\n  label: {\n    type: String,\n    default: '',\n  },\n  /**\n   * @description identifier corresponding to the name of Tabs, representing the alias of the tab-pane, the default is ordinal number of the tab-pane in the sequence, e.g. the first tab-pane is '0'\n   */\n  name: {\n    type: [String, Number],\n  },\n  /**\n   * @description whether Tab is closable\n   */\n  closable: {\n    type: Boolean,\n    default: undefined,\n  },\n  /**\n   * @description whether Tab is disabled\n   */\n  disabled: Boolean,\n  /**\n   * @description whether Tab is lazily rendered\n   */\n  lazy: Boolean,\n} as const)\n\nexport type TabPaneProps = {\n  /**\n   * @description title of the tab\n   */\n  label?: string\n  /**\n   * @description identifier corresponding to the name of Tabs, representing the alias of the tab-pane, the default is ordinal number of the tab-pane in the sequence, e.g. the first tab-pane is '0'\n   */\n  name?: string | number\n  /**\n   * @description whether Tab is closable\n   */\n  closable?: boolean\n  /**\n   * @description whether Tab is disabled\n   */\n  disabled?: boolean\n  /**\n   * @description whether Tab is lazily rendered\n   */\n  lazy?: boolean\n}\n\n/**\n * @deprecated Removed after 3.0.0, Use `TabPaneProps` instead.\n */\nexport type TabPanePropsPublic = ExtractPublicPropTypes<typeof tabPaneProps>\n\nexport type TabPaneInstance = InstanceType<typeof TabPane> & unknown\n"],"mappings":";;;;;;;AAQA,MAAa,eAAeA,2BAAW;CAIrC,OAAO;EACL,MAAM;EACN,SAAS;EACV;CAID,MAAM,EACJ,MAAM,CAAC,QAAQ,OAAO,EACvB;CAID,UAAU;EACR,MAAM;EACN,SAAS;EACV;CAID,UAAU;CAIV,MAAM;CACP,CAAU"}

frontend/node_modules/element-plus/lib/components/tabs/src/tab-pane.vue.d.ts

@@ -0,0 +1,21 @@
+import { TabPaneProps } from "./tab-pane.js";
+import * as vue from "vue";
+
+//#region ../../packages/components/tabs/src/tab-pane.vue.d.ts
+declare var __VLS_1: {};
+type __VLS_Slots = {} & {
+  default?: (props: typeof __VLS_1) => any;
+};
+declare const __VLS_base: vue.DefineComponent<TabPaneProps, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<TabPaneProps> & Readonly<{}>, {
+  closable: boolean;
+  label: string;
+}, {}, {}, {}, 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/lib/components/tabs/src/tab-pane.vue_vue_type_script_setup_true_lang.js

@@ -0,0 +1,74 @@
+const require_runtime = require('../../../_virtual/_rolldown/runtime.js');
+const require_error = require('../../../utils/error.js');
+const require_index = require('../../../hooks/use-namespace/index.js');
+const require_constants = require('./constants.js');
+const require_tab_pane = require('./tab-pane.js');
+let vue = require("vue");
+
+//#region ../../packages/components/tabs/src/tab-pane.vue?vue&type=script&setup=true&lang.ts
+const _hoisted_1 = [
+	"id",
+	"aria-hidden",
+	"aria-labelledby"
+];
+const COMPONENT_NAME = "ElTabPane";
+var tab_pane_vue_vue_type_script_setup_true_lang_default = /* @__PURE__ */ (0, vue.defineComponent)({
+	name: COMPONENT_NAME,
+	__name: "tab-pane",
+	props: require_tab_pane.tabPaneProps,
+	setup(__props) {
+		const props = __props;
+		const instance = (0, vue.getCurrentInstance)();
+		const slots = (0, vue.useSlots)();
+		const tabsRoot = (0, vue.inject)(require_constants.tabsRootContextKey);
+		if (!tabsRoot) require_error.throwError(COMPONENT_NAME, "usage: <el-tabs><el-tab-pane /></el-tabs/>");
+		const ns = require_index.useNamespace("tab-pane");
+		const paneRef = (0, vue.ref)();
+		const index = (0, vue.ref)();
+		const isClosable = (0, vue.computed)(() => props.closable ?? tabsRoot.props.closable);
+		const active = (0, vue.computed)(() => tabsRoot.currentName.value === (props.name ?? index.value));
+		const loaded = (0, vue.ref)(active.value);
+		const paneName = (0, vue.computed)(() => props.name ?? index.value);
+		const shouldBeRender = (0, vue.computed)(() => !props.lazy || loaded.value || active.value);
+		const isFocusInsidePane = () => {
+			return paneRef.value?.contains(document.activeElement);
+		};
+		(0, vue.watch)(active, (val) => {
+			if (val) loaded.value = true;
+		});
+		const pane = (0, vue.reactive)({
+			uid: instance.uid,
+			getVnode: () => instance.vnode,
+			slots,
+			props,
+			paneName,
+			active,
+			index,
+			isClosable,
+			isFocusInsidePane
+		});
+		tabsRoot.registerPane(pane);
+		(0, vue.onBeforeUnmount)(() => {
+			tabsRoot.unregisterPane(pane);
+		});
+		(0, vue.onBeforeUpdate)(() => {
+			if (slots.label) tabsRoot.nav$.value?.scheduleRender();
+		});
+		return (_ctx, _cache) => {
+			return shouldBeRender.value ? (0, vue.withDirectives)(((0, vue.openBlock)(), (0, vue.createElementBlock)("div", {
+				key: 0,
+				id: `pane-${paneName.value}`,
+				ref_key: "paneRef",
+				ref: paneRef,
+				class: (0, vue.normalizeClass)((0, vue.unref)(ns).b()),
+				role: "tabpanel",
+				"aria-hidden": !active.value,
+				"aria-labelledby": `tab-${paneName.value}`
+			}, [(0, vue.renderSlot)(_ctx.$slots, "default")], 10, _hoisted_1)), [[vue.vShow, active.value]]) : (0, vue.createCommentVNode)("v-if", true);
+		};
+	}
+});
+
+//#endregion
+exports.default = tab_pane_vue_vue_type_script_setup_true_lang_default;
+//# sourceMappingURL=tab-pane.vue_vue_type_script_setup_true_lang.js.map

frontend/node_modules/element-plus/lib/components/tabs/src/tab-pane.vue_vue_type_script_setup_true_lang.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tab-pane.vue_vue_type_script_setup_true_lang.js","names":[],"sources":["../../../../../../packages/components/tabs/src/tab-pane.vue"],"sourcesContent":["<template>\n  <div\n    v-if=\"shouldBeRender\"\n    v-show=\"active\"\n    :id=\"`pane-${paneName}`\"\n    ref=\"paneRef\"\n    :class=\"ns.b()\"\n    role=\"tabpanel\"\n    :aria-hidden=\"!active\"\n    :aria-labelledby=\"`tab-${paneName}`\"\n  >\n    <slot />\n  </div>\n</template>\n\n<script lang=\"ts\" setup>\nimport {\n  computed,\n  getCurrentInstance,\n  inject,\n  onBeforeUnmount,\n  onBeforeUpdate,\n  reactive,\n  ref,\n  useSlots,\n  watch,\n} from 'vue'\nimport { throwError } from '@element-plus/utils'\nimport { useNamespace } from '@element-plus/hooks'\nimport { tabsRootContextKey } from './constants'\n\nimport type { TabPaneProps } from './tab-pane'\n\nconst COMPONENT_NAME = 'ElTabPane'\ndefineOptions({\n  name: COMPONENT_NAME,\n})\nconst props = withDefaults(defineProps<TabPaneProps>(), {\n  label: '',\n  closable: undefined,\n})\n\nconst instance = getCurrentInstance()!\nconst slots = useSlots()\n\nconst tabsRoot = inject(tabsRootContextKey)\nif (!tabsRoot)\n  throwError(COMPONENT_NAME, 'usage: <el-tabs><el-tab-pane /></el-tabs/>')\n\nconst ns = useNamespace('tab-pane')\n\nconst paneRef = ref<HTMLDivElement>()\nconst index = ref<string>()\nconst isClosable = computed(() => props.closable ?? tabsRoot.props.closable)\nconst active = computed(\n  () => tabsRoot.currentName.value === (props.name ?? index.value)\n)\nconst loaded = ref(active.value)\nconst paneName = computed(() => props.name ?? index.value)\nconst shouldBeRender = computed(\n  () => !props.lazy || loaded.value || active.value\n)\n\nconst isFocusInsidePane = () => {\n  return paneRef.value?.contains(document.activeElement)\n}\n\nwatch(active, (val) => {\n  if (val) loaded.value = true\n})\n\nconst pane = reactive({\n  uid: instance.uid,\n  getVnode: () => instance.vnode,\n  slots,\n  props,\n  paneName,\n  active,\n  index,\n  isClosable,\n  isFocusInsidePane,\n})\n\ntabsRoot.registerPane(pane)\n\nonBeforeUnmount(() => {\n  tabsRoot.unregisterPane(pane)\n})\n\nonBeforeUpdate(() => {\n  if (slots.label) tabsRoot.nav$.value?.scheduleRender()\n})\n</script>\n"],"mappings":";;;;;;;;;;;;;AAiCA,MAAM,iBAAiB;;;;;;EAIvB,MAAM,QAAQ;EAKd,MAAM,wCAA+B;EACrC,MAAM,2BAAiB;EAEvB,MAAM,2BAAkB,qCAAkB;AAC1C,MAAI,CAAC,SACH,0BAAW,gBAAgB,6CAA4C;EAEzE,MAAM,KAAK,2BAAa,WAAU;EAElC,MAAM,wBAA8B;EACpC,MAAM,sBAAoB;EAC1B,MAAM,qCAA4B,MAAM,YAAY,SAAS,MAAM,SAAQ;EAC3E,MAAM,iCACE,SAAS,YAAY,WAAW,MAAM,QAAQ,MAAM,OAC5D;EACA,MAAM,sBAAa,OAAO,MAAK;EAC/B,MAAM,mCAA0B,MAAM,QAAQ,MAAM,MAAK;EACzD,MAAM,yCACE,CAAC,MAAM,QAAQ,OAAO,SAAS,OAAO,MAC9C;EAEA,MAAM,0BAA0B;AAC9B,UAAO,QAAQ,OAAO,SAAS,SAAS,cAAa;;AAGvD,iBAAM,SAAS,QAAQ;AACrB,OAAI,IAAK,QAAO,QAAQ;IACzB;EAED,MAAM,yBAAgB;GACpB,KAAK,SAAS;GACd,gBAAgB,SAAS;GACzB;GACA;GACA;GACA;GACA;GACA;GACA;GACD,CAAA;AAED,WAAS,aAAa,KAAI;AAE1B,iCAAsB;AACpB,YAAS,eAAe,KAAI;IAC7B;AAED,gCAAqB;AACnB,OAAI,MAAM,MAAO,UAAS,KAAK,OAAO,gBAAe;IACtD;;UAzFS,eAAA,mFAUF,OAAA;;IARH,IAAE,QAAU,SAAA;aACT;IAAJ,KAAI;IACH,8CAAO,GAAE,CAAC,GAAC,CAAA;IACZ,MAAK;IACJ,eAAW,CAAG,OAAA;IACd,mBAAe,OAAS,SAAA;2BAEjB,KAAA,QAAA,UAAA,kCARA,OAAA,MAAM"}

frontend/node_modules/element-plus/lib/components/tabs/src/tab-pane2.js

@@ -0,0 +1,9 @@
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: 'Module' } });
+const require_tab_pane_vue_vue_type_script_setup_true_lang = require('./tab-pane.vue_vue_type_script_setup_true_lang.js');
+
+//#region ../../packages/components/tabs/src/tab-pane.vue
+var tab_pane_default = require_tab_pane_vue_vue_type_script_setup_true_lang.default;
+
+//#endregion
+exports.default = tab_pane_default;
+//# sourceMappingURL=tab-pane2.js.map

frontend/node_modules/element-plus/lib/components/tabs/src/tab-pane2.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tab-pane2.js","names":[],"sources":["../../../../../../packages/components/tabs/src/tab-pane.vue"],"sourcesContent":["<template>\n  <div\n    v-if=\"shouldBeRender\"\n    v-show=\"active\"\n    :id=\"`pane-${paneName}`\"\n    ref=\"paneRef\"\n    :class=\"ns.b()\"\n    role=\"tabpanel\"\n    :aria-hidden=\"!active\"\n    :aria-labelledby=\"`tab-${paneName}`\"\n  >\n    <slot />\n  </div>\n</template>\n\n<script lang=\"ts\" setup>\nimport {\n  computed,\n  getCurrentInstance,\n  inject,\n  onBeforeUnmount,\n  onBeforeUpdate,\n  reactive,\n  ref,\n  useSlots,\n  watch,\n} from 'vue'\nimport { throwError } from '@element-plus/utils'\nimport { useNamespace } from '@element-plus/hooks'\nimport { tabsRootContextKey } from './constants'\n\nimport type { TabPaneProps } from './tab-pane'\n\nconst COMPONENT_NAME = 'ElTabPane'\ndefineOptions({\n  name: COMPONENT_NAME,\n})\nconst props = withDefaults(defineProps<TabPaneProps>(), {\n  label: '',\n  closable: undefined,\n})\n\nconst instance = getCurrentInstance()!\nconst slots = useSlots()\n\nconst tabsRoot = inject(tabsRootContextKey)\nif (!tabsRoot)\n  throwError(COMPONENT_NAME, 'usage: <el-tabs><el-tab-pane /></el-tabs/>')\n\nconst ns = useNamespace('tab-pane')\n\nconst paneRef = ref<HTMLDivElement>()\nconst index = ref<string>()\nconst isClosable = computed(() => props.closable ?? tabsRoot.props.closable)\nconst active = computed(\n  () => tabsRoot.currentName.value === (props.name ?? index.value)\n)\nconst loaded = ref(active.value)\nconst paneName = computed(() => props.name ?? index.value)\nconst shouldBeRender = computed(\n  () => !props.lazy || loaded.value || active.value\n)\n\nconst isFocusInsidePane = () => {\n  return paneRef.value?.contains(document.activeElement)\n}\n\nwatch(active, (val) => {\n  if (val) loaded.value = true\n})\n\nconst pane = reactive({\n  uid: instance.uid,\n  getVnode: () => instance.vnode,\n  slots,\n  props,\n  paneName,\n  active,\n  index,\n  isClosable,\n  isFocusInsidePane,\n})\n\ntabsRoot.registerPane(pane)\n\nonBeforeUnmount(() => {\n  tabsRoot.unregisterPane(pane)\n})\n\nonBeforeUpdate(() => {\n  if (slots.label) tabsRoot.nav$.value?.scheduleRender()\n})\n</script>\n"],"mappings":""}

frontend/node_modules/element-plus/lib/components/tabs/src/tabs.d.ts

@@ -0,0 +1,156 @@
+import { EpPropFinalized, EpPropMergeType } from "../../../utils/vue/props/types.js";
+import { Awaitable } from "../../../utils/typescript.js";
+import "../../../utils/index.js";
+import { TabPaneName, TabsPaneContext } from "./constants.js";
+import { TabNavInstance } from "./tab-nav.js";
+import * as vue from "vue";
+import { ExtractPropTypes, ExtractPublicPropTypes, VNode } from "vue";
+import * as vue_jsx_runtime0 from "vue/jsx-runtime";
+
+//#region ../../packages/components/tabs/src/tabs.d.ts
+declare const tabsProps: {
+  readonly type: EpPropFinalized<StringConstructor, "" | "card" | "border-card", unknown, "", boolean>;
+  readonly closable: BooleanConstructor;
+  readonly addable: BooleanConstructor;
+  readonly modelValue: {
+    readonly type: vue.PropType<EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>>;
+    readonly required: false;
+    readonly validator: ((val: unknown) => boolean) | undefined;
+    __epPropKey: true;
+  };
+  readonly defaultValue: {
+    readonly type: vue.PropType<EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>>;
+    readonly required: false;
+    readonly validator: ((val: unknown) => boolean) | undefined;
+    __epPropKey: true;
+  };
+  readonly editable: BooleanConstructor;
+  readonly tabPosition: EpPropFinalized<StringConstructor, "top" | "bottom" | "left" | "right", unknown, "top", boolean>;
+  readonly beforeLeave: EpPropFinalized<(new (...args: any[]) => (newName: TabPaneName, oldName: TabPaneName) => Awaitable<void | boolean>) | (() => (newName: TabPaneName, oldName: TabPaneName) => Awaitable<void | boolean>) | {
+    (): (newName: TabPaneName, oldName: TabPaneName) => Awaitable<void | boolean>;
+    new (): any;
+    readonly prototype: any;
+  } | (((new (...args: any[]) => (newName: TabPaneName, oldName: TabPaneName) => Awaitable<void | boolean>) | (() => (newName: TabPaneName, oldName: TabPaneName) => Awaitable<void | boolean>) | {
+    (): (newName: TabPaneName, oldName: TabPaneName) => Awaitable<void | boolean>;
+    new (): any;
+    readonly prototype: any;
+  }) | null)[], unknown, unknown, () => true, boolean>;
+  readonly stretch: BooleanConstructor;
+  readonly tabindex: EpPropFinalized<readonly [StringConstructor, NumberConstructor], unknown, unknown, 0, boolean>;
+};
+type TabsProps = ExtractPropTypes<typeof tabsProps>;
+type TabsPropsPublic = ExtractPublicPropTypes<typeof tabsProps>;
+declare const tabsEmits: {
+  "update:modelValue": (name: TabPaneName) => name is string | number;
+  tabClick: (pane: TabsPaneContext, ev: Event) => boolean;
+  tabChange: (name: TabPaneName) => name is string | number;
+  edit: (paneName: TabPaneName | undefined, action: "remove" | "add") => boolean;
+  tabRemove: (name: TabPaneName) => name is string | number;
+  tabAdd: () => boolean;
+};
+type TabsEmits = typeof tabsEmits;
+type TabsPanes = Record<number, TabsPaneContext>;
+declare const Tabs: vue.DefineComponent<ExtractPropTypes<{
+  readonly type: EpPropFinalized<StringConstructor, "" | "card" | "border-card", unknown, "", boolean>;
+  readonly closable: BooleanConstructor;
+  readonly addable: BooleanConstructor;
+  readonly modelValue: {
+    readonly type: vue.PropType<EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>>;
+    readonly required: false;
+    readonly validator: ((val: unknown) => boolean) | undefined;
+    __epPropKey: true;
+  };
+  readonly defaultValue: {
+    readonly type: vue.PropType<EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>>;
+    readonly required: false;
+    readonly validator: ((val: unknown) => boolean) | undefined;
+    __epPropKey: true;
+  };
+  readonly editable: BooleanConstructor;
+  readonly tabPosition: EpPropFinalized<StringConstructor, "top" | "bottom" | "left" | "right", unknown, "top", boolean>;
+  readonly beforeLeave: EpPropFinalized<(new (...args: any[]) => (newName: TabPaneName, oldName: TabPaneName) => Awaitable<void | boolean>) | (() => (newName: TabPaneName, oldName: TabPaneName) => Awaitable<void | boolean>) | {
+    (): (newName: TabPaneName, oldName: TabPaneName) => Awaitable<void | boolean>;
+    new (): any;
+    readonly prototype: any;
+  } | (((new (...args: any[]) => (newName: TabPaneName, oldName: TabPaneName) => Awaitable<void | boolean>) | (() => (newName: TabPaneName, oldName: TabPaneName) => Awaitable<void | boolean>) | {
+    (): (newName: TabPaneName, oldName: TabPaneName) => Awaitable<void | boolean>;
+    new (): any;
+    readonly prototype: any;
+  }) | null)[], unknown, unknown, () => true, boolean>;
+  readonly stretch: BooleanConstructor;
+  readonly tabindex: EpPropFinalized<readonly [StringConstructor, NumberConstructor], unknown, unknown, 0, boolean>;
+}>, () => vue_jsx_runtime0.JSX.Element, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
+  "update:modelValue": (name: TabPaneName) => name is string | number;
+  tabClick: (pane: TabsPaneContext, ev: Event) => boolean;
+  tabChange: (name: TabPaneName) => name is string | number;
+  edit: (paneName: TabPaneName | undefined, action: "remove" | "add") => boolean;
+  tabRemove: (name: TabPaneName) => name is string | number;
+  tabAdd: () => boolean;
+}, string, vue.PublicProps, Readonly<ExtractPropTypes<{
+  readonly type: EpPropFinalized<StringConstructor, "" | "card" | "border-card", unknown, "", boolean>;
+  readonly closable: BooleanConstructor;
+  readonly addable: BooleanConstructor;
+  readonly modelValue: {
+    readonly type: vue.PropType<EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>>;
+    readonly required: false;
+    readonly validator: ((val: unknown) => boolean) | undefined;
+    __epPropKey: true;
+  };
+  readonly defaultValue: {
+    readonly type: vue.PropType<EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>>;
+    readonly required: false;
+    readonly validator: ((val: unknown) => boolean) | undefined;
+    __epPropKey: true;
+  };
+  readonly editable: BooleanConstructor;
+  readonly tabPosition: EpPropFinalized<StringConstructor, "top" | "bottom" | "left" | "right", unknown, "top", boolean>;
+  readonly beforeLeave: EpPropFinalized<(new (...args: any[]) => (newName: TabPaneName, oldName: TabPaneName) => Awaitable<void | boolean>) | (() => (newName: TabPaneName, oldName: TabPaneName) => Awaitable<void | boolean>) | {
+    (): (newName: TabPaneName, oldName: TabPaneName) => Awaitable<void | boolean>;
+    new (): any;
+    readonly prototype: any;
+  } | (((new (...args: any[]) => (newName: TabPaneName, oldName: TabPaneName) => Awaitable<void | boolean>) | (() => (newName: TabPaneName, oldName: TabPaneName) => Awaitable<void | boolean>) | {
+    (): (newName: TabPaneName, oldName: TabPaneName) => Awaitable<void | boolean>;
+    new (): any;
+    readonly prototype: any;
+  }) | null)[], unknown, unknown, () => true, boolean>;
+  readonly stretch: BooleanConstructor;
+  readonly tabindex: EpPropFinalized<readonly [StringConstructor, NumberConstructor], unknown, unknown, 0, boolean>;
+}>> & Readonly<{
+  "onUpdate:modelValue"?: ((name: TabPaneName) => any) | undefined;
+  onTabClick?: ((pane: {
+    uid: number;
+    getVnode: () => VNode;
+    slots: vue.Slots;
+    props: {
+      label?: string | undefined;
+      name?: (string | number) | undefined;
+      closable?: boolean | undefined;
+      disabled?: boolean | undefined;
+      lazy?: boolean | undefined;
+    };
+    paneName: TabPaneName | undefined;
+    active: boolean;
+    index: string | undefined;
+    isClosable: boolean;
+    isFocusInsidePane: () => boolean | undefined;
+  }, ev: Event) => any) | undefined;
+  onTabChange?: ((name: TabPaneName) => any) | undefined;
+  onEdit?: ((paneName: TabPaneName | undefined, action: "remove" | "add") => any) | undefined;
+  onTabRemove?: ((name: TabPaneName) => any) | undefined;
+  onTabAdd?: (() => any) | undefined;
+}>, {
+  readonly type: EpPropMergeType<StringConstructor, "" | "card" | "border-card", unknown>;
+  readonly closable: boolean;
+  readonly tabindex: EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
+  readonly stretch: boolean;
+  readonly editable: boolean;
+  readonly tabPosition: EpPropMergeType<StringConstructor, "top" | "bottom" | "left" | "right", unknown>;
+  readonly beforeLeave: (newName: TabPaneName, oldName: TabPaneName) => Awaitable<void | boolean>;
+  readonly addable: boolean;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+type TabsInstance = InstanceType<typeof Tabs> & {
+  currentName: TabPaneName;
+  tabNavRef: TabNavInstance | undefined;
+};
+//#endregion
+export { Tabs, TabsEmits, TabsInstance, TabsPanes, TabsProps, TabsPropsPublic, tabsEmits, tabsProps };

frontend/node_modules/element-plus/lib/components/tabs/src/tabs.js

@@ -0,0 +1,181 @@
+const require_runtime = require('../../../_virtual/_rolldown/runtime.js');
+const require_aria = require('../../../constants/aria.js');
+const require_event = require('../../../constants/event.js');
+const require_event$1 = require('../../../utils/dom/event.js');
+const require_types = require('../../../utils/types.js');
+const require_runtime$1 = require('../../../utils/vue/props/runtime.js');
+const require_index = require('../../../hooks/use-namespace/index.js');
+const require_index$1 = require('../../../hooks/use-ordered-children/index.js');
+const require_index$2 = require('../../icon/index.js');
+const require_constants = require('./constants.js');
+const require_tab_nav = require('./tab-nav.js');
+let lodash_unified = require("lodash-unified");
+let _element_plus_icons_vue = require("@element-plus/icons-vue");
+let vue = require("vue");
+let _vue_shared = require("@vue/shared");
+
+//#region ../../packages/components/tabs/src/tabs.tsx
+const tabsProps = require_runtime$1.buildProps({
+	type: {
+		type: String,
+		values: [
+			"card",
+			"border-card",
+			""
+		],
+		default: ""
+	},
+	closable: Boolean,
+	addable: Boolean,
+	modelValue: { type: [String, Number] },
+	defaultValue: { type: [String, Number] },
+	editable: Boolean,
+	tabPosition: {
+		type: String,
+		values: [
+			"top",
+			"right",
+			"bottom",
+			"left"
+		],
+		default: "top"
+	},
+	beforeLeave: {
+		type: require_runtime$1.definePropType(Function),
+		default: () => true
+	},
+	stretch: Boolean,
+	tabindex: {
+		type: [String, Number],
+		default: 0
+	}
+});
+const isPaneName = (value) => (0, _vue_shared.isString)(value) || require_types.isNumber(value);
+const tabsEmits = {
+	[require_event.UPDATE_MODEL_EVENT]: (name) => isPaneName(name),
+	tabClick: (pane, ev) => ev instanceof Event,
+	tabChange: (name) => isPaneName(name),
+	edit: (paneName, action) => ["remove", "add"].includes(action),
+	tabRemove: (name) => isPaneName(name),
+	tabAdd: () => true
+};
+const Tabs = /* @__PURE__ */ (0, vue.defineComponent)({
+	name: "ElTabs",
+	props: tabsProps,
+	emits: tabsEmits,
+	setup(props, { emit, slots, expose }) {
+		const ns = require_index.useNamespace("tabs");
+		const isVertical = (0, vue.computed)(() => ["left", "right"].includes(props.tabPosition));
+		const { children: panes, addChild: registerPane, removeChild: unregisterPane, ChildrenSorter: PanesSorter } = require_index$1.useOrderedChildren((0, vue.getCurrentInstance)(), "ElTabPane");
+		const nav$ = (0, vue.ref)();
+		const currentName = (0, vue.ref)((require_types.isUndefined(props.modelValue) ? props.defaultValue : props.modelValue) ?? "0");
+		const setCurrentName = async (value, trigger = false) => {
+			if (currentName.value === value || require_types.isUndefined(value)) return;
+			try {
+				let canLeave;
+				if (props.beforeLeave) {
+					const result = props.beforeLeave(value, currentName.value);
+					canLeave = result instanceof Promise ? await result : result;
+				} else canLeave = true;
+				if (canLeave !== false) {
+					const isFocusInsidePane = panes.value.find((item) => item.paneName === currentName.value)?.isFocusInsidePane();
+					currentName.value = value;
+					if (trigger) {
+						emit(require_event.UPDATE_MODEL_EVENT, value);
+						emit("tabChange", value);
+					}
+					nav$.value?.removeFocus?.();
+					if (isFocusInsidePane) nav$.value?.focusActiveTab();
+				}
+			} catch {}
+		};
+		const handleTabClick = (tab, tabName, event) => {
+			if (tab.props.disabled) return;
+			emit("tabClick", tab, event);
+			setCurrentName(tabName, true);
+		};
+		const handleTabRemove = (pane, ev) => {
+			if (pane.props.disabled || require_types.isUndefined(pane.props.name)) return;
+			ev.stopPropagation();
+			emit("edit", pane.props.name, "remove");
+			emit("tabRemove", pane.props.name);
+		};
+		const handleTabAdd = () => {
+			emit("edit", void 0, "add");
+			emit("tabAdd");
+		};
+		const handleKeydown = (event) => {
+			const code = require_event$1.getEventCode(event);
+			if ([require_aria.EVENT_CODE.enter, require_aria.EVENT_CODE.numpadEnter].includes(code)) handleTabAdd();
+		};
+		const swapChildren = (vnode) => {
+			const actualFirstChild = vnode.el.firstChild;
+			const firstChild = ["bottom", "right"].includes(props.tabPosition) ? vnode.children[0].el : vnode.children[1].el;
+			if (actualFirstChild !== firstChild) actualFirstChild.before(firstChild);
+		};
+		(0, vue.watch)(() => props.modelValue, (modelValue) => setCurrentName(modelValue));
+		(0, vue.watch)(currentName, async () => {
+			await (0, vue.nextTick)();
+			nav$.value?.scrollToActiveTab();
+		});
+		(0, vue.provide)(require_constants.tabsRootContextKey, {
+			props,
+			currentName,
+			registerPane,
+			unregisterPane,
+			nav$
+		});
+		expose({
+			currentName,
+			get tabNavRef() {
+				return (0, lodash_unified.omit)(nav$.value, ["scheduleRender"]);
+			}
+		});
+		return () => {
+			const addSlot = slots["add-icon"];
+			const newButton = props.editable || props.addable ? (0, vue.createVNode)("div", {
+				"class": [ns.e("new-tab"), isVertical.value && ns.e("new-tab-vertical")],
+				"tabindex": props.tabindex,
+				"onClick": handleTabAdd,
+				"onKeydown": handleKeydown
+			}, [addSlot ? (0, vue.renderSlot)(slots, "add-icon") : (0, vue.createVNode)(require_index$2.ElIcon, { "class": ns.is("icon-plus") }, { default: () => [(0, vue.createVNode)(_element_plus_icons_vue.Plus, null, null)] })]) : null;
+			const tabNav = () => (0, vue.createVNode)(require_tab_nav.default, {
+				"ref": nav$,
+				"currentName": currentName.value,
+				"editable": props.editable,
+				"type": props.type,
+				"panes": panes.value,
+				"stretch": props.stretch,
+				"onTabClick": handleTabClick,
+				"onTabRemove": handleTabRemove
+			}, null);
+			const header = (0, vue.createVNode)("div", { "class": [
+				ns.e("header"),
+				isVertical.value && ns.e("header-vertical"),
+				ns.is(props.tabPosition)
+			] }, [(0, vue.createVNode)(PanesSorter, null, {
+				default: tabNav,
+				$stable: true
+			}), newButton]);
+			const panels = (0, vue.createVNode)("div", { "class": ns.e("content") }, [(0, vue.renderSlot)(slots, "default")]);
+			return (0, vue.createVNode)("div", {
+				"class": [
+					ns.b(),
+					ns.m(props.tabPosition),
+					{
+						[ns.m("card")]: props.type === "card",
+						[ns.m("border-card")]: props.type === "border-card"
+					}
+				],
+				"onVnodeMounted": swapChildren,
+				"onVnodeUpdated": swapChildren
+			}, [panels, header]);
+		};
+	}
+});
+
+//#endregion
+exports.default = Tabs;
+exports.tabsEmits = tabsEmits;
+exports.tabsProps = tabsProps;
+//# sourceMappingURL=tabs.js.map

frontend/node_modules/element-plus/lib/components/tabs/style/css.js

@@ -0,0 +1,3 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+require('../../base/style/css.js');
+require("element-plus/theme-chalk/el-tabs.css");

frontend/node_modules/element-plus/lib/components/tabs/style/index.js

@@ -0,0 +1,3 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+require('../../base/style/index.js');
+require("element-plus/theme-chalk/src/tabs.scss");