feat: initial commit - Phase 1 & 2 core features

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

@@ -0,0 +1,17 @@
+import { SFCWithInstall } from "../../utils/vue/typescript.js";
+import "../../utils/index.js";
+import { Alignment, FixedDir, SortOrder } from "./src/constants.js";
+import { Column, Columns, SortBy, SortState, TableV2CustomizedHeaderSlotParam } from "./src/types.js";
+import { RowEventHandler, RowEventHandlerParams, RowEventHandlers, RowExpandHandler, RowExpandParams, RowHeightChangeHandler, RowHeightChangedParams, RowHoverHandler, RowHoverParams, TableV2RowProps, TableV2RowPropsPublic, tableV2RowProps } from "./src/row.js";
+import { ColumnResizeHandler, ColumnSortHandler, ColumnSortParams, ExpandedRowsChangeHandler, ExtraCellPropGetter, ExtractHeaderCellPropGetter, ExtractHeaderPropGetter, ExtractRowPropGetter, HeaderClassNameGetter, RowClassNameGetter, TableV2Props, TableV2PropsPublic, tableV2Props } from "./src/table.js";
+import { TableV2, TableV2Instance } from "./src/table-v2.js";
+import { AutoResizer } from "./src/components/auto-resizer.js";
+import { AutoResizerProps, AutoResizerPropsPublic, autoResizerProps } from "./src/auto-resizer.js";
+import { placeholderSign } from "./src/private.js";
+import { HeaderCellSlotProps } from "./src/renderers/header-cell.js";
+
+//#region ../../packages/components/table-v2/index.d.ts
+declare const ElTableV2: SFCWithInstall<typeof TableV2>;
+declare const ElAutoResizer: SFCWithInstall<typeof AutoResizer>;
+//#endregion
+export { AutoResizerProps, AutoResizerPropsPublic, type Column, ColumnResizeHandler, ColumnSortHandler, ColumnSortParams, type Columns, ElAutoResizer, ElTableV2, ExpandedRowsChangeHandler, ExtraCellPropGetter, ExtractHeaderCellPropGetter, ExtractHeaderPropGetter, ExtractRowPropGetter, type HeaderCellSlotProps, HeaderClassNameGetter, RowClassNameGetter, RowEventHandler, RowEventHandlerParams, RowEventHandlers, RowExpandHandler, RowExpandParams, RowHeightChangeHandler, RowHeightChangedParams, RowHoverHandler, RowHoverParams, type SortBy, type SortState, TableV2, Alignment as TableV2Alignment, type TableV2CustomizedHeaderSlotParam, FixedDir as TableV2FixedDir, type TableV2Instance, placeholderSign as TableV2Placeholder, TableV2Props, TableV2PropsPublic, TableV2RowProps, TableV2RowPropsPublic, SortOrder as TableV2SortOrder, autoResizerProps, tableV2Props, tableV2RowProps };

frontend/node_modules/element-plus/es/components/table-v2/index.mjs

@@ -0,0 +1,16 @@
+import { withInstall } from "../../utils/vue/install.mjs";
+import { Alignment, FixedDir, SortOrder } from "./src/constants.mjs";
+import { placeholderSign } from "./src/private.mjs";
+import { tableV2RowProps } from "./src/row.mjs";
+import { tableV2Props } from "./src/table.mjs";
+import TableV2 from "./src/table-v2.mjs";
+import { autoResizerProps } from "./src/auto-resizer.mjs";
+import AutoResizer from "./src/components/auto-resizer.mjs";
+
+//#region ../../packages/components/table-v2/index.ts
+const ElTableV2 = withInstall(TableV2);
+const ElAutoResizer = withInstall(AutoResizer);
+
+//#endregion
+export { ElAutoResizer, ElTableV2, TableV2, Alignment as TableV2Alignment, FixedDir as TableV2FixedDir, placeholderSign as TableV2Placeholder, SortOrder as TableV2SortOrder, autoResizerProps, tableV2Props, tableV2RowProps };
+//# sourceMappingURL=index.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":[],"sources":["../../../../../packages/components/table-v2/index.ts"],"sourcesContent":["import { withInstall } from '@element-plus/utils'\nimport TableV2 from './src/table-v2'\nimport AutoResizer from './src/components/auto-resizer'\n\nimport type { SFCWithInstall } from '@element-plus/utils'\n\nexport {\n  Alignment as TableV2Alignment,\n  FixedDir as TableV2FixedDir,\n  SortOrder as TableV2SortOrder,\n} from './src/constants'\nexport { default as TableV2 } from './src/table-v2'\nexport * from './src/auto-resizer'\nexport { placeholderSign as TableV2Placeholder } from './src/private'\n\nexport const ElTableV2: SFCWithInstall<typeof TableV2> = withInstall(TableV2)\nexport const ElAutoResizer: SFCWithInstall<typeof AutoResizer> =\n  withInstall(AutoResizer)\n\nexport type {\n  Column,\n  Columns,\n  SortBy,\n  SortState,\n  TableV2CustomizedHeaderSlotParam,\n} from './src/types'\nexport type { TableV2Instance } from './src/table-v2'\nexport * from './src/table'\nexport * from './src/row'\n\nexport type { HeaderCellSlotProps } from './src/renderers/header-cell'\n"],"mappings":";;;;;;;;;;AAeA,MAAa,YAA4C,YAAY,QAAQ;AAC7E,MAAa,gBACX,YAAY,YAAY"}

frontend/node_modules/element-plus/es/components/table-v2/src/auto-resizer.d.ts

@@ -0,0 +1,22 @@
+import * as vue from "vue";
+import { ExtractPropTypes, ExtractPublicPropTypes } from "vue";
+
+//#region ../../packages/components/table-v2/src/auto-resizer.d.ts
+type AutoResizeHandler = (event: {
+  height: number;
+  width: number;
+}) => void;
+declare const autoResizerProps: {
+  readonly disableWidth: BooleanConstructor;
+  readonly disableHeight: BooleanConstructor;
+  readonly onResize: {
+    readonly type: vue.PropType<AutoResizeHandler>;
+    readonly required: false;
+    readonly validator: ((val: unknown) => boolean) | undefined;
+    __epPropKey: true;
+  };
+};
+type AutoResizerProps = ExtractPropTypes<typeof autoResizerProps>;
+type AutoResizerPropsPublic = ExtractPublicPropTypes<typeof autoResizerProps>;
+//#endregion
+export { AutoResizerProps, AutoResizerPropsPublic, autoResizerProps };

frontend/node_modules/element-plus/es/components/table-v2/src/auto-resizer.mjs

@@ -0,0 +1,12 @@
+import { buildProps, definePropType } from "../../../utils/vue/props/runtime.mjs";
+
+//#region ../../packages/components/table-v2/src/auto-resizer.ts
+const autoResizerProps = buildProps({
+	disableWidth: Boolean,
+	disableHeight: Boolean,
+	onResize: { type: definePropType(Function) }
+});
+
+//#endregion
+export { autoResizerProps };
+//# sourceMappingURL=auto-resizer.mjs.map

frontend/node_modules/element-plus/es/components/table-v2/src/auto-resizer.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"auto-resizer.mjs","names":[],"sources":["../../../../../../packages/components/table-v2/src/auto-resizer.ts"],"sourcesContent":["import { buildProps, definePropType } from '@element-plus/utils'\n\nimport type { ExtractPropTypes, ExtractPublicPropTypes } from 'vue'\n\ntype AutoResizeHandler = (event: { height: number; width: number }) => void\n\nexport const autoResizerProps = buildProps({\n  disableWidth: Boolean,\n  disableHeight: Boolean,\n  onResize: {\n    type: definePropType<AutoResizeHandler>(Function),\n  },\n} as const)\n\nexport type AutoResizerProps = ExtractPropTypes<typeof autoResizerProps>\nexport type AutoResizerPropsPublic = ExtractPublicPropTypes<\n  typeof autoResizerProps\n>\n"],"mappings":";;;AAMA,MAAa,mBAAmB,WAAW;CACzC,cAAc;CACd,eAAe;CACf,UAAU,EACR,MAAM,eAAkC,SAAS,EAClD;CACF,CAAU"}

frontend/node_modules/element-plus/es/components/table-v2/src/cell.d.ts

@@ -0,0 +1,39 @@
+import { EpPropMergeType } from "../../../utils/vue/props/types.js";
+import "../../../utils/index.js";
+import { AnyColumn } from "./common.js";
+import * as vue from "vue";
+import { ExtractPropTypes, ExtractPublicPropTypes, StyleValue } from "vue";
+
+//#region ../../packages/components/table-v2/src/cell.d.ts
+declare const tableV2CellProps: {
+  readonly class: StringConstructor;
+  readonly cellData: {
+    readonly type: vue.PropType<any>;
+    readonly required: false;
+    readonly validator: ((val: unknown) => boolean) | undefined;
+    __epPropKey: true;
+  };
+  readonly column: {
+    readonly type: vue.PropType<AnyColumn>;
+    readonly required: false;
+    readonly validator: ((val: unknown) => boolean) | undefined;
+    __epPropKey: true;
+  };
+  readonly columnIndex: NumberConstructor;
+  readonly style: {
+    readonly type: vue.PropType<EpPropMergeType<(new (...args: any[]) => string | false | vue.CSSProperties | StyleValue[]) | (() => StyleValue) | (((new (...args: any[]) => string | false | vue.CSSProperties | StyleValue[]) | (() => StyleValue)) | null)[], unknown, unknown>>;
+    readonly required: false;
+    readonly validator: ((val: unknown) => boolean) | undefined;
+    __epPropKey: true;
+  };
+  readonly rowData: {
+    readonly type: vue.PropType<any>;
+    readonly required: false;
+    readonly validator: ((val: unknown) => boolean) | undefined;
+    __epPropKey: true;
+  };
+  readonly rowIndex: NumberConstructor;
+};
+type TableV2CellProps = ExtractPropTypes<typeof tableV2CellProps>;
+//#endregion
+export { TableV2CellProps };

frontend/node_modules/element-plus/es/components/table-v2/src/cell.mjs

@@ -0,0 +1,26 @@
+import { buildProps, definePropType } from "../../../utils/vue/props/runtime.mjs";
+import { column } from "./common.mjs";
+
+//#region ../../packages/components/table-v2/src/cell.ts
+const tableV2CellProps = buildProps({
+	class: String,
+	cellData: { type: definePropType([
+		String,
+		Boolean,
+		Number,
+		Object
+	]) },
+	column,
+	columnIndex: Number,
+	style: { type: definePropType([
+		String,
+		Array,
+		Object
+	]) },
+	rowData: { type: definePropType(Object) },
+	rowIndex: Number
+});
+
+//#endregion
+export { tableV2CellProps };
+//# sourceMappingURL=cell.mjs.map

frontend/node_modules/element-plus/es/components/table-v2/src/cell.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"cell.mjs","names":[],"sources":["../../../../../../packages/components/table-v2/src/cell.ts"],"sourcesContent":["import { buildProps, definePropType } from '@element-plus/utils'\nimport { column } from './common'\n\nimport type { ExtractPropTypes, ExtractPublicPropTypes, StyleValue } from 'vue'\n\nexport const tableV2CellProps = buildProps({\n  class: String,\n  cellData: {\n    type: definePropType<any>([String, Boolean, Number, Object]),\n  },\n  column,\n  columnIndex: Number,\n  style: {\n    type: definePropType<StyleValue>([String, Array, Object]),\n  },\n  rowData: {\n    type: definePropType<any>(Object),\n  },\n  rowIndex: Number,\n} as const)\n\nexport type TableV2CellProps = ExtractPropTypes<typeof tableV2CellProps>\nexport type TableV2CellPropsPublic = ExtractPublicPropTypes<\n  typeof tableV2CellProps\n>\n"],"mappings":";;;;AAKA,MAAa,mBAAmB,WAAW;CACzC,OAAO;CACP,UAAU,EACR,MAAM,eAAoB;EAAC;EAAQ;EAAS;EAAQ;EAAO,CAAC,EAC7D;CACD;CACA,aAAa;CACb,OAAO,EACL,MAAM,eAA2B;EAAC;EAAQ;EAAO;EAAO,CAAC,EAC1D;CACD,SAAS,EACP,MAAM,eAAoB,OAAO,EAClC;CACD,UAAU;CACX,CAAU"}

frontend/node_modules/element-plus/es/components/table-v2/src/common.d.ts

@@ -0,0 +1,7 @@
+import { Column } from "./types.js";
+import { CSSProperties } from "vue";
+
+//#region ../../packages/components/table-v2/src/common.d.ts
+type AnyColumn = Column<any>;
+//#endregion
+export { AnyColumn };

frontend/node_modules/element-plus/es/components/table-v2/src/common.mjs

@@ -0,0 +1,45 @@
+import { definePropType } from "../../../utils/vue/props/runtime.mjs";
+import { mutable } from "../../../utils/typescript.mjs";
+
+//#region ../../packages/components/table-v2/src/common.ts
+/**
+* @Note even though we can use `string[] | string` as the type but for
+* convenience here we only use `string` as the acceptable value here.
+*/
+const classType = String;
+const columns = {
+	type: definePropType(Array),
+	required: true
+};
+const column = { type: definePropType(Object) };
+const fixedDataType = { type: definePropType(Array) };
+const dataType = {
+	...fixedDataType,
+	required: true
+};
+const expandColumnKey = String;
+const expandKeys = {
+	type: definePropType(Array),
+	default: () => mutable([])
+};
+const requiredNumber = {
+	type: Number,
+	required: true
+};
+const rowKey = {
+	type: definePropType([
+		String,
+		Number,
+		Symbol
+	]),
+	default: "id"
+};
+/**
+* @note even though we can use `StyleValue` but that would be difficult for us to mapping them,
+* so we only use `CSSProperties` as the acceptable value here.
+*/
+const styleType = { type: definePropType(Object) };
+
+//#endregion
+export { classType, column, columns, dataType, expandColumnKey, expandKeys, fixedDataType, requiredNumber, rowKey, styleType };
+//# sourceMappingURL=common.mjs.map

frontend/node_modules/element-plus/es/components/table-v2/src/common.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"common.mjs","names":[],"sources":["../../../../../../packages/components/table-v2/src/common.ts"],"sourcesContent":["import { definePropType, mutable } from '@element-plus/utils'\n\nimport type { CSSProperties } from 'vue'\nimport type { Column, KeyType } from './types'\n\nexport type AnyColumn = Column<any>\n\n/**\n * @Note even though we can use `string[] | string` as the type but for\n * convenience here we only use `string` as the acceptable value here.\n */\nexport const classType = String\n\nexport const columns = {\n  type: definePropType<AnyColumn[]>(Array),\n  required: true,\n} as const\n\nexport const column = {\n  type: definePropType<AnyColumn>(Object),\n} as const\n\nexport const fixedDataType = {\n  type: definePropType<any[]>(Array),\n} as const\n\nexport const dataType = {\n  ...fixedDataType,\n  required: true,\n} as const\n\nexport const expandColumnKey = String\n\nexport const expandKeys = {\n  type: definePropType<KeyType[]>(Array),\n  default: () => mutable([]),\n} as const\n\nexport const requiredNumber = {\n  type: Number,\n  required: true,\n} as const\n\nexport const rowKey = {\n  type: definePropType<KeyType>([String, Number, Symbol]),\n  default: 'id',\n} as const\n\n/**\n * @note even though we can use `StyleValue` but that would be difficult for us to mapping them,\n * so we only use `CSSProperties` as the acceptable value here.\n */\nexport const styleType = {\n  type: definePropType<CSSProperties>(Object),\n}\n"],"mappings":";;;;;;;;AAWA,MAAa,YAAY;AAEzB,MAAa,UAAU;CACrB,MAAM,eAA4B,MAAM;CACxC,UAAU;CACX;AAED,MAAa,SAAS,EACpB,MAAM,eAA0B,OAAO,EACxC;AAED,MAAa,gBAAgB,EAC3B,MAAM,eAAsB,MAAM,EACnC;AAED,MAAa,WAAW;CACtB,GAAG;CACH,UAAU;CACX;AAED,MAAa,kBAAkB;AAE/B,MAAa,aAAa;CACxB,MAAM,eAA0B,MAAM;CACtC,eAAe,QAAQ,EAAE,CAAC;CAC3B;AAED,MAAa,iBAAiB;CAC5B,MAAM;CACN,UAAU;CACX;AAED,MAAa,SAAS;CACpB,MAAM,eAAwB;EAAC;EAAQ;EAAQ;EAAO,CAAC;CACvD,SAAS;CACV;;;;;AAMD,MAAa,YAAY,EACvB,MAAM,eAA8B,OAAO,EAC5C"}

frontend/node_modules/element-plus/es/components/table-v2/src/components/auto-resizer.d.ts

@@ -0,0 +1,34 @@
+import * as vue from "vue";
+import * as vue_jsx_runtime0 from "vue/jsx-runtime";
+
+//#region ../../packages/components/table-v2/src/components/auto-resizer.d.ts
+declare const AutoResizer: vue.DefineComponent<vue.ExtractPropTypes<{
+  readonly disableWidth: BooleanConstructor;
+  readonly disableHeight: BooleanConstructor;
+  readonly onResize: {
+    readonly type: vue.PropType<(event: {
+      height: number;
+      width: number;
+    }) => void>;
+    readonly required: false;
+    readonly validator: ((val: unknown) => boolean) | undefined;
+    __epPropKey: true;
+  };
+}>, () => vue_jsx_runtime0.JSX.Element, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+  readonly disableWidth: BooleanConstructor;
+  readonly disableHeight: BooleanConstructor;
+  readonly onResize: {
+    readonly type: vue.PropType<(event: {
+      height: number;
+      width: number;
+    }) => void>;
+    readonly required: false;
+    readonly validator: ((val: unknown) => boolean) | undefined;
+    __epPropKey: true;
+  };
+}>> & Readonly<{}>, {
+  readonly disableWidth: boolean;
+  readonly disableHeight: boolean;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+//#endregion
+export { AutoResizer };

frontend/node_modules/element-plus/es/components/table-v2/src/components/auto-resizer.mjs

@@ -0,0 +1,32 @@
+import { useNamespace } from "../../../../hooks/use-namespace/index.mjs";
+import { useAutoResize } from "../composables/use-auto-resize.mjs";
+import { autoResizerProps } from "../auto-resizer.mjs";
+import { createVNode, defineComponent } from "vue";
+
+//#region ../../packages/components/table-v2/src/components/auto-resizer.tsx
+const AutoResizer = /* @__PURE__ */ defineComponent({
+	name: "ElAutoResizer",
+	props: autoResizerProps,
+	setup(props, { slots }) {
+		const ns = useNamespace("auto-resizer");
+		const { height, width, sizer } = useAutoResize(props);
+		const style = {
+			width: "100%",
+			height: "100%"
+		};
+		return () => {
+			return createVNode("div", {
+				"ref": sizer,
+				"class": ns.b(),
+				"style": style
+			}, [slots.default?.({
+				height: height.value,
+				width: width.value
+			})]);
+		};
+	}
+});
+
+//#endregion
+export { AutoResizer as default };
+//# sourceMappingURL=auto-resizer.mjs.map

frontend/node_modules/element-plus/es/components/table-v2/src/components/auto-resizer.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"auto-resizer.mjs","names":["defineComponent","createVNode","_createVNode","useNamespace","autoResizerProps","useAutoResize","AutoResizer","name","props","setup","slots","ns","height","width","sizer","style","b","default","value"],"sources":["../../../../../../../packages/components/table-v2/src/components/auto-resizer.tsx"],"sourcesContent":["import { defineComponent } from 'vue'\nimport { useNamespace } from '@element-plus/hooks'\nimport { autoResizerProps } from '../auto-resizer'\nimport { useAutoResize } from '../composables'\n\nconst AutoResizer = defineComponent({\n  name: 'ElAutoResizer',\n  props: autoResizerProps,\n  setup(props, { slots }) {\n    const ns = useNamespace('auto-resizer')\n    const { height, width, sizer } = useAutoResize(props)\n    const style = {\n      width: '100%',\n      height: '100%',\n    }\n\n    return () => {\n      return (\n        <div ref={sizer} class={ns.b()} style={style}>\n          {slots.default?.({\n            height: height.value,\n            width: width.value,\n          })}\n        </div>\n      )\n    }\n  },\n})\n\nexport default AutoResizer\n"],"mappings":";;;;;;AAKA,MAAMM,cAAcN,gCAAgB;CAClCO,MAAM;CACNC,OAAOJ;CACPK,MAAMD,OAAO,EAAEE,SAAS;EACtB,MAAMC,KAAKR,aAAa,eAAe;EACvC,MAAM,EAAES,QAAQC,OAAOC,UAAUT,cAAcG,MAAM;EACrD,MAAMO,QAAQ;GACZF,OAAO;GACPD,QAAQ;GACT;AAED,eAAa;AACX,UAAAV,YAAA,OAAA;IAAA,OACYY;IAAK,SAASH,GAAGK,GAAG;IAAA,SAASD;IAAK,EAAA,CACzCL,MAAMO,UAAU;IACfL,QAAQA,OAAOM;IACfL,OAAOA,MAAMK;IACd,CAAC,CAAA,CAAA;;;CAKX,CAAC"}

frontend/node_modules/element-plus/es/components/table-v2/src/components/cell.d.ts

@@ -0,0 +1,7 @@
+import { TableV2CellProps } from "../cell.js";
+import { FunctionalComponent } from "vue";
+
+//#region ../../packages/components/table-v2/src/components/cell.d.ts
+declare const TableV2Cell: FunctionalComponent<TableV2CellProps>;
+//#endregion
+export { TableV2Cell };

frontend/node_modules/element-plus/es/components/table-v2/src/components/cell.mjs

@@ -0,0 +1,19 @@
+import { createVNode, renderSlot } from "vue";
+
+//#region ../../packages/components/table-v2/src/components/cell.tsx
+const TableV2Cell = (props, { slots }) => {
+	const { cellData, style } = props;
+	const displayText = cellData?.toString?.() || "";
+	const defaultSlot = renderSlot(slots, "default", props, () => [displayText]);
+	return createVNode("div", {
+		"class": props.class,
+		"title": displayText,
+		"style": style
+	}, [defaultSlot]);
+};
+TableV2Cell.displayName = "ElTableV2Cell";
+TableV2Cell.inheritAttrs = false;
+
+//#endregion
+export { TableV2Cell as default };
+//# sourceMappingURL=cell.mjs.map

frontend/node_modules/element-plus/es/components/table-v2/src/components/cell.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"cell.mjs","names":["renderSlot","createVNode","_createVNode","TableV2Cell","props","slots","cellData","style","displayText","toString","defaultSlot","class","displayName","inheritAttrs"],"sources":["../../../../../../../packages/components/table-v2/src/components/cell.tsx"],"sourcesContent":["import { renderSlot } from 'vue'\n\nimport type { FunctionalComponent } from 'vue'\nimport type { TableV2CellProps } from '../cell'\n\nconst TableV2Cell: FunctionalComponent<TableV2CellProps> = (\n  props: TableV2CellProps,\n  { slots }\n) => {\n  const { cellData, style } = props\n  const displayText = cellData?.toString?.() || ''\n  const defaultSlot = renderSlot(slots, 'default', props, () => [displayText])\n  return (\n    <div class={props.class} title={displayText} style={style}>\n      {defaultSlot}\n    </div>\n  )\n}\n\nTableV2Cell.displayName = 'ElTableV2Cell'\nTableV2Cell.inheritAttrs = false\n\nexport default TableV2Cell\n"],"mappings":";;;AAKA,MAAMG,eACJC,OACA,EAAEC,YACC;CACH,MAAM,EAAEC,UAAUC,UAAUH;CAC5B,MAAMI,cAAcF,UAAUG,YAAY,IAAI;CAC9C,MAAMC,cAAcV,WAAWK,OAAO,WAAWD,aAAa,CAACI,YAAY,CAAC;AAC5E,QAAAN,YAAA,OAAA;EAAA,SACcE,MAAMO;EAAK,SAASH;EAAW,SAASD;EAAK,EAAA,CACtDG,YAAW,CAAA;;AAKlBP,YAAYS,cAAc;AAC1BT,YAAYU,eAAe"}

frontend/node_modules/element-plus/es/components/table-v2/src/components/expand-icon.d.ts

@@ -0,0 +1,18 @@
+import { TableV2RowCellRenderParam } from "./row.js";
+import { StyleValue } from "vue";
+import * as vue_jsx_runtime0 from "vue/jsx-runtime";
+
+//#region ../../packages/components/table-v2/src/components/expand-icon.d.ts
+declare const ExpandIcon: {
+  (props: TableV2RowCellRenderParam["expandIconProps"] & {
+    class?: string | string[];
+    style: StyleValue;
+    ariaLabel?: string;
+    size: number;
+    expanded: boolean;
+    expandable: boolean;
+  }): vue_jsx_runtime0.JSX.Element;
+  inheritAttrs: boolean;
+};
+//#endregion
+export { ExpandIcon };

frontend/node_modules/element-plus/es/components/table-v2/src/components/expand-icon.mjs

@@ -0,0 +1,22 @@
+import { ElIcon } from "../../../icon/index.mjs";
+import { ArrowRight } from "@element-plus/icons-vue";
+import { createVNode, mergeProps } from "vue";
+
+//#region ../../packages/components/table-v2/src/components/expand-icon.tsx
+const ExpandIcon = (props) => {
+	const { expanded, expandable, onExpand, style, size, ariaLabel } = props;
+	return createVNode("button", mergeProps({
+		onClick: expandable ? () => onExpand(!expanded) : void 0,
+		ariaLabel,
+		ariaExpanded: expanded,
+		class: props.class
+	}, { "type": "button" }), [createVNode(ElIcon, {
+		"size": size,
+		"style": style
+	}, { default: () => [createVNode(ArrowRight, null, null)] })]);
+};
+ExpandIcon.inheritAttrs = false;
+
+//#endregion
+export { ExpandIcon as default };
+//# sourceMappingURL=expand-icon.mjs.map

frontend/node_modules/element-plus/es/components/table-v2/src/components/expand-icon.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"expand-icon.mjs","names":["ElIcon","ArrowRight","ExpandIcon","props","expanded","expandable","onExpand","style","size","ariaLabel","expandIconProps","onClick","undefined","ariaExpanded","class","_createVNode","_mergeProps","default","inheritAttrs"],"sources":["../../../../../../../packages/components/table-v2/src/components/expand-icon.tsx"],"sourcesContent":["import ElIcon from '@element-plus/components/icon'\nimport { ArrowRight } from '@element-plus/icons-vue'\n\nimport type { StyleValue } from 'vue'\nimport type { TableV2RowCellRenderParam } from './row'\n\nconst ExpandIcon = (\n  props: TableV2RowCellRenderParam['expandIconProps'] & {\n    class?: string | string[]\n    style: StyleValue\n    ariaLabel?: string\n    size: number\n    expanded: boolean\n    expandable: boolean\n  }\n) => {\n  const { expanded, expandable, onExpand, style, size, ariaLabel } = props\n\n  const expandIconProps = {\n    onClick: expandable ? () => onExpand(!expanded) : undefined,\n    ariaLabel,\n    ariaExpanded: expanded,\n    class: props.class,\n  } as any\n\n  return (\n    <button {...expandIconProps} type=\"button\">\n      <ElIcon size={size} style={style}>\n        <ArrowRight />\n      </ElIcon>\n    </button>\n  )\n}\n\nExpandIcon.inheritAttrs = false\n\nexport default ExpandIcon\n\nexport type ExpandIconInstance = ReturnType<typeof ExpandIcon>\n"],"mappings":";;;;;AAMA,MAAME,cACJC,UAQG;CACH,MAAM,EAAEC,UAAUC,YAAYC,UAAUC,OAAOC,MAAMC,cAAcN;AASnE,QAAAY,YAAA,UAAAC,WAPwB;EACtBL,SAASN,mBAAmBC,SAAS,CAACF,SAAS,GAAGQ;EAClDH;EACAI,cAAcT;EACdU,OAAOX,MAAMW;EACP,EAGqB,EAAA,QAAA,UAAA,CAAA,EAAA,CAAAC,YAAAf,QAAA;EAAA,QACXQ;EAAI,SAASD;EAAK,EAAA,EAAAU,eAAA,CAAAF,YAAAd,YAAA,MAAA,KAAA,CAAA,EAAA,CAAA,CAAA,CAAA;;AAOtCC,WAAWgB,eAAe"}

frontend/node_modules/element-plus/es/components/table-v2/src/components/header-cell.d.ts

@@ -0,0 +1,7 @@
+import { TableV2HeaderCell } from "../header-cell.js";
+import { FunctionalComponent } from "vue";
+
+//#region ../../packages/components/table-v2/src/components/header-cell.d.ts
+declare const HeaderCell: FunctionalComponent<TableV2HeaderCell>;
+//#endregion
+export { HeaderCell };

frontend/node_modules/element-plus/es/components/table-v2/src/components/header-cell.mjs

@@ -0,0 +1,13 @@
+import { createVNode, renderSlot } from "vue";
+
+//#region ../../packages/components/table-v2/src/components/header-cell.tsx
+const HeaderCell = (props, { slots }) => renderSlot(slots, "default", props, () => [createVNode("div", {
+	"class": props.class,
+	"title": props.column?.title
+}, [props.column?.title])]);
+HeaderCell.displayName = "ElTableV2HeaderCell";
+HeaderCell.inheritAttrs = false;
+
+//#endregion
+export { HeaderCell as default };
+//# sourceMappingURL=header-cell.mjs.map

frontend/node_modules/element-plus/es/components/table-v2/src/components/header-cell.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"header-cell.mjs","names":["renderSlot","createVNode","_createVNode","HeaderCell","props","slots","class","column","title","displayName","inheritAttrs"],"sources":["../../../../../../../packages/components/table-v2/src/components/header-cell.tsx"],"sourcesContent":["import { renderSlot } from 'vue'\n\nimport type { FunctionalComponent } from 'vue'\nimport type { TableV2HeaderCell } from '../header-cell'\n\nconst HeaderCell: FunctionalComponent<TableV2HeaderCell> = (props, { slots }) =>\n  renderSlot(slots, 'default', props, () => [\n    <div class={props.class} title={props.column?.title}>\n      {props.column?.title}\n    </div>,\n  ])\n\nHeaderCell.displayName = 'ElTableV2HeaderCell'\nHeaderCell.inheritAttrs = false\n\nexport default HeaderCell\n"],"mappings":";;;AAKA,MAAMG,cAAsDC,OAAO,EAAEC,YACnEL,WAAWK,OAAO,WAAWD,aAAa,CAAAF,YAAA,OAAA;CAAA,SAC5BE,MAAME;CAAK,SAASF,MAAMG,QAAQC;CAAK,EAAA,CAChDJ,MAAMG,QAAQC,MAAK,CAAA,CAEvB,CAAC;AAEJL,WAAWM,cAAc;AACzBN,WAAWO,eAAe"}

frontend/node_modules/element-plus/es/components/table-v2/src/components/header-row.d.ts

@@ -0,0 +1,65 @@
+import { ColumnCellsType, KeyType } from "../types.js";
+import { AnyColumn } from "../common.js";
+import { TableV2HeaderRowProps } from "../header-row.js";
+import * as vue from "vue";
+import { CSSProperties } from "vue";
+import * as vue_jsx_runtime0 from "vue/jsx-runtime";
+
+//#region ../../packages/components/table-v2/src/components/header-row.d.ts
+declare const TableV2HeaderRow: vue.DefineComponent<vue.ExtractPropTypes<{
+  readonly class: StringConstructor;
+  readonly columns: {
+    readonly type: vue.PropType<AnyColumn[]>;
+    readonly required: true;
+    readonly validator: ((val: unknown) => boolean) | undefined;
+    __epPropKey: true;
+  };
+  readonly columnsStyles: {
+    readonly type: vue.PropType<Record<KeyType, CSSProperties>>;
+    readonly required: true;
+    readonly validator: ((val: unknown) => boolean) | undefined;
+    __epPropKey: true;
+  };
+  readonly headerIndex: NumberConstructor;
+  readonly style: {
+    readonly type: vue.PropType<CSSProperties>;
+    readonly required: false;
+    readonly validator: ((val: unknown) => boolean) | undefined;
+    __epPropKey: true;
+  };
+}>, () => vue_jsx_runtime0.JSX.Element, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+  readonly class: StringConstructor;
+  readonly columns: {
+    readonly type: vue.PropType<AnyColumn[]>;
+    readonly required: true;
+    readonly validator: ((val: unknown) => boolean) | undefined;
+    __epPropKey: true;
+  };
+  readonly columnsStyles: {
+    readonly type: vue.PropType<Record<KeyType, CSSProperties>>;
+    readonly required: true;
+    readonly validator: ((val: unknown) => boolean) | undefined;
+    __epPropKey: true;
+  };
+  readonly headerIndex: NumberConstructor;
+  readonly style: {
+    readonly type: vue.PropType<CSSProperties>;
+    readonly required: false;
+    readonly validator: ((val: unknown) => boolean) | undefined;
+    __epPropKey: true;
+  };
+}>> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+type TableV2HeaderRowCellRendererParams = {
+  columns: TableV2HeaderRowProps['columns'];
+  column: TableV2HeaderRowProps['columns'][number];
+  columnIndex: number;
+  headerIndex: number;
+  style: CSSProperties;
+};
+type TableV2HeaderRowRendererParams = {
+  cells: ColumnCellsType;
+  columns: TableV2HeaderRowProps['columns'];
+  headerIndex: number;
+};
+//#endregion
+export { TableV2HeaderRow, TableV2HeaderRowCellRendererParams, TableV2HeaderRowRendererParams };

frontend/node_modules/element-plus/es/components/table-v2/src/components/header-row.mjs

@@ -0,0 +1,40 @@
+import { isArray } from "../../../../utils/types.mjs";
+import { tableV2HeaderRowProps } from "../header-row.mjs";
+import { createVNode, defineComponent } from "vue";
+
+//#region ../../packages/components/table-v2/src/components/header-row.tsx
+const TableV2HeaderRow = /* @__PURE__ */ defineComponent({
+	name: "ElTableV2HeaderRow",
+	props: tableV2HeaderRowProps,
+	setup(props, { slots }) {
+		return () => {
+			const { columns, columnsStyles, headerIndex, style } = props;
+			let Cells = columns.map((column, columnIndex) => {
+				return slots.cell({
+					columns,
+					column,
+					columnIndex,
+					headerIndex,
+					style: columnsStyles[column.key]
+				});
+			});
+			if (slots.header) Cells = slots.header({
+				cells: Cells.map((node) => {
+					if (isArray(node) && node.length === 1) return node[0];
+					return node;
+				}),
+				columns,
+				headerIndex
+			});
+			return createVNode("div", {
+				"class": props.class,
+				"style": style,
+				"role": "row"
+			}, [Cells]);
+		};
+	}
+});
+
+//#endregion
+export { TableV2HeaderRow as default };
+//# sourceMappingURL=header-row.mjs.map

frontend/node_modules/element-plus/es/components/table-v2/src/components/header-row.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"header-row.mjs","names":["defineComponent","createVNode","_createVNode","isArray","tableV2HeaderRowProps","TableV2HeaderRow","name","props","setup","slots","columns","columnsStyles","headerIndex","style","Cells","map","column","columnIndex","cell","key","header","cells","node","length","class"],"sources":["../../../../../../../packages/components/table-v2/src/components/header-row.tsx"],"sourcesContent":["import { defineComponent } from 'vue'\nimport { isArray } from '@element-plus/utils'\nimport { tableV2HeaderRowProps } from '../header-row'\n\nimport type { CSSProperties } from 'vue'\nimport type { ColumnCellsType } from '../types'\nimport type { TableV2HeaderRowProps } from '../header-row'\n\nconst TableV2HeaderRow = defineComponent({\n  name: 'ElTableV2HeaderRow',\n  props: tableV2HeaderRowProps,\n  setup(props, { slots }) {\n    return () => {\n      const { columns, columnsStyles, headerIndex, style } = props\n      let Cells: ColumnCellsType = columns.map((column, columnIndex) => {\n        return slots.cell!({\n          columns,\n          column,\n          columnIndex,\n          headerIndex,\n          style: columnsStyles[column.key!],\n        })\n      })\n\n      if (slots.header) {\n        Cells = slots.header({\n          cells: Cells.map((node) => {\n            if (isArray(node) && node.length === 1) {\n              return node[0]\n            }\n            return node\n          }),\n          columns,\n          headerIndex,\n        })\n      }\n\n      return (\n        <div class={props.class} style={style} role=\"row\">\n          {Cells}\n        </div>\n      )\n    }\n  },\n})\n\nexport default TableV2HeaderRow\n\nexport type TableV2HeaderRowCellRendererParams = {\n  columns: TableV2HeaderRowProps['columns']\n  column: TableV2HeaderRowProps['columns'][number]\n  columnIndex: number\n  headerIndex: number\n  style: CSSProperties\n}\n\nexport type TableV2HeaderRowRendererParams = {\n  cells: ColumnCellsType\n  columns: TableV2HeaderRowProps['columns']\n  headerIndex: number\n}\n"],"mappings":";;;;;AAQA,MAAMK,mBAAmBL,gCAAgB;CACvCM,MAAM;CACNC,OAAOH;CACPI,MAAMD,OAAO,EAAEE,SAAS;AACtB,eAAa;GACX,MAAM,EAAEC,SAASC,eAAeC,aAAaC,UAAUN;GACvD,IAAIO,QAAyBJ,QAAQK,KAAKC,QAAQC,gBAAgB;AAChE,WAAOR,MAAMS,KAAM;KACjBR;KACAM;KACAC;KACAL;KACAC,OAAOF,cAAcK,OAAOG;KAC7B,CAAC;KACF;AAEF,OAAIV,MAAMW,OACRN,SAAQL,MAAMW,OAAO;IACnBC,OAAOP,MAAMC,KAAKO,SAAS;AACzB,SAAInB,QAAQmB,KAAK,IAAIA,KAAKC,WAAW,EACnC,QAAOD,KAAK;AAEd,YAAOA;MACP;IACFZ;IACAE;IACD,CAAC;AAGJ,UAAAV,YAAA,OAAA;IAAA,SACcK,MAAMiB;IAAK,SAASX;IAAK,QAAA;IAAA,EAAA,CAClCC,MAAK,CAAA;;;CAKf,CAAC"}

frontend/node_modules/element-plus/es/components/table-v2/src/components/header.d.ts

@@ -0,0 +1,109 @@
+import { EpPropFinalized, EpPropMergeType } from "../../../../utils/vue/props/types.js";
+import "../../../../utils/index.js";
+import { AnyColumn } from "../common.js";
+import { TableV2HeaderProps } from "../header.js";
+import { UseColumnsReturn } from "../composables/use-columns.js";
+import * as vue from "vue";
+import { CSSProperties, UnwrapRef } from "vue";
+import * as vue_jsx_runtime0 from "vue/jsx-runtime";
+
+//#region ../../packages/components/table-v2/src/components/header.d.ts
+declare const TableV2Header: vue.DefineComponent<vue.ExtractPropTypes<{
+  readonly class: StringConstructor;
+  readonly columns: {
+    readonly type: vue.PropType<AnyColumn[]>;
+    readonly required: true;
+    readonly validator: ((val: unknown) => boolean) | undefined;
+    __epPropKey: true;
+  };
+  readonly fixedHeaderData: {
+    readonly type: vue.PropType<any[]>;
+    readonly required: false;
+    readonly validator: ((val: unknown) => boolean) | undefined;
+    __epPropKey: true;
+  };
+  readonly headerData: {
+    readonly type: vue.PropType<any[]>;
+    readonly required: true;
+    readonly validator: ((val: unknown) => boolean) | undefined;
+    __epPropKey: true;
+  };
+  readonly headerHeight: EpPropFinalized<(new (...args: any[]) => number | number[]) | (() => number | number[]) | (((new (...args: any[]) => number | number[]) | (() => number | number[])) | null)[], unknown, unknown, 50, boolean>;
+  readonly rowWidth: {
+    readonly type: vue.PropType<number>;
+    readonly required: true;
+    readonly validator: ((val: unknown) => boolean) | undefined;
+    __epPropKey: true;
+  };
+  readonly rowHeight: EpPropFinalized<NumberConstructor, unknown, unknown, 50, boolean>;
+  readonly height: {
+    readonly type: vue.PropType<number>;
+    readonly required: true;
+    readonly validator: ((val: unknown) => boolean) | undefined;
+    __epPropKey: true;
+  };
+  readonly width: {
+    readonly type: vue.PropType<number>;
+    readonly required: true;
+    readonly validator: ((val: unknown) => boolean) | undefined;
+    __epPropKey: true;
+  };
+}>, () => vue_jsx_runtime0.JSX.Element | undefined, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+  readonly class: StringConstructor;
+  readonly columns: {
+    readonly type: vue.PropType<AnyColumn[]>;
+    readonly required: true;
+    readonly validator: ((val: unknown) => boolean) | undefined;
+    __epPropKey: true;
+  };
+  readonly fixedHeaderData: {
+    readonly type: vue.PropType<any[]>;
+    readonly required: false;
+    readonly validator: ((val: unknown) => boolean) | undefined;
+    __epPropKey: true;
+  };
+  readonly headerData: {
+    readonly type: vue.PropType<any[]>;
+    readonly required: true;
+    readonly validator: ((val: unknown) => boolean) | undefined;
+    __epPropKey: true;
+  };
+  readonly headerHeight: EpPropFinalized<(new (...args: any[]) => number | number[]) | (() => number | number[]) | (((new (...args: any[]) => number | number[]) | (() => number | number[])) | null)[], unknown, unknown, 50, boolean>;
+  readonly rowWidth: {
+    readonly type: vue.PropType<number>;
+    readonly required: true;
+    readonly validator: ((val: unknown) => boolean) | undefined;
+    __epPropKey: true;
+  };
+  readonly rowHeight: EpPropFinalized<NumberConstructor, unknown, unknown, 50, boolean>;
+  readonly height: {
+    readonly type: vue.PropType<number>;
+    readonly required: true;
+    readonly validator: ((val: unknown) => boolean) | undefined;
+    __epPropKey: true;
+  };
+  readonly width: {
+    readonly type: vue.PropType<number>;
+    readonly required: true;
+    readonly validator: ((val: unknown) => boolean) | undefined;
+    __epPropKey: true;
+  };
+}>> & Readonly<{}>, {
+  readonly headerHeight: EpPropMergeType<(new (...args: any[]) => number | number[]) | (() => number | number[]) | (((new (...args: any[]) => number | number[]) | (() => number | number[])) | null)[], unknown, unknown>;
+  readonly rowHeight: number;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+type TableV2HeaderInstance = InstanceType<typeof TableV2Header> & {
+  /**
+   * @description scroll to position based on the provided value
+   */
+  scrollToLeft: (left?: number) => void;
+};
+type TableV2HeaderRendererParams = {
+  class: string;
+  columns: TableV2HeaderProps['columns'];
+  columnsStyles: UnwrapRef<UseColumnsReturn['columnsStyles']>;
+  headerIndex: number;
+  style: CSSProperties;
+};
+//#endregion
+export { TableV2Header, TableV2HeaderInstance, TableV2HeaderRendererParams };

frontend/node_modules/element-plus/es/components/table-v2/src/components/header.mjs

@@ -0,0 +1,85 @@
+import { ensureArray } from "../../../../utils/arrays.mjs";
+import { useNamespace } from "../../../../hooks/use-namespace/index.mjs";
+import { enforceUnit } from "../utils.mjs";
+import { TABLE_V2_GRID_INJECTION_KEY } from "../tokens.mjs";
+import { tableV2HeaderProps } from "../header.mjs";
+import { computed, createVNode, defineComponent, inject, nextTick, onUpdated, ref, unref } from "vue";
+
+//#region ../../packages/components/table-v2/src/components/header.tsx
+const TableV2Header = /* @__PURE__ */ defineComponent({
+	name: "ElTableV2Header",
+	props: tableV2HeaderProps,
+	setup(props, { slots, expose }) {
+		const ns = useNamespace("table-v2");
+		const scrollLeftInfo = inject(TABLE_V2_GRID_INJECTION_KEY);
+		const headerRef = ref();
+		const headerStyle = computed(() => enforceUnit({
+			width: props.width,
+			height: props.height
+		}));
+		const rowStyle = computed(() => enforceUnit({
+			width: props.rowWidth,
+			height: props.height
+		}));
+		const headerHeights = computed(() => ensureArray(unref(props.headerHeight)));
+		const scrollToLeft = (left) => {
+			const headerEl = unref(headerRef);
+			nextTick(() => {
+				headerEl?.scroll && headerEl.scroll({ left });
+			});
+		};
+		const renderFixedRows = () => {
+			const fixedRowClassName = ns.e("fixed-header-row");
+			const { columns, fixedHeaderData, rowHeight } = props;
+			return fixedHeaderData?.map((fixedRowData, fixedRowIndex) => {
+				const style = enforceUnit({
+					height: rowHeight,
+					width: "100%"
+				});
+				return slots.fixed?.({
+					class: fixedRowClassName,
+					columns,
+					rowData: fixedRowData,
+					rowIndex: -(fixedRowIndex + 1),
+					style
+				});
+			});
+		};
+		const renderDynamicRows = () => {
+			const dynamicRowClassName = ns.e("dynamic-header-row");
+			const { columns } = props;
+			return unref(headerHeights).map((rowHeight, rowIndex) => {
+				const style = enforceUnit({
+					width: "100%",
+					height: rowHeight
+				});
+				return slots.dynamic?.({
+					class: dynamicRowClassName,
+					columns,
+					headerIndex: rowIndex,
+					style
+				});
+			});
+		};
+		onUpdated(() => {
+			if (scrollLeftInfo?.value) scrollToLeft(scrollLeftInfo.value);
+		});
+		expose({ scrollToLeft });
+		return () => {
+			if (props.height <= 0) return;
+			return createVNode("div", {
+				"ref": headerRef,
+				"class": props.class,
+				"style": unref(headerStyle),
+				"role": "rowgroup"
+			}, [createVNode("div", {
+				"style": unref(rowStyle),
+				"class": ns.e("header")
+			}, [renderDynamicRows(), renderFixedRows()])]);
+		};
+	}
+});
+
+//#endregion
+export { TableV2Header as default };
+//# sourceMappingURL=header.mjs.map

frontend/node_modules/element-plus/es/components/table-v2/src/components/index.d.ts

@@ -0,0 +1,8 @@
+import { TableV2Cell } from "./cell.js";
+import { HeaderCell } from "./header-cell.js";
+import { TableV2HeaderRow, TableV2HeaderRowCellRendererParams, TableV2HeaderRowRendererParams } from "./header-row.js";
+import { TableV2Header, TableV2HeaderInstance, TableV2HeaderRendererParams } from "./header.js";
+import { TableV2Row, TableV2RowCellRenderParam, TableV2RowSlotProps } from "./row.js";
+import { SortIcon } from "./sort-icon.js";
+import { ExpandIcon } from "./expand-icon.js";
+export { ExpandIcon, TableV2Header as Header, HeaderCell, TableV2HeaderRow as HeaderRow, TableV2Row as Row, SortIcon, TableV2Cell as TableCell, type TableV2HeaderInstance, type TableV2HeaderRendererParams, type TableV2HeaderRowCellRendererParams, type TableV2HeaderRowRendererParams, type TableV2RowCellRenderParam, type TableV2RowSlotProps };

frontend/node_modules/element-plus/es/components/table-v2/src/components/index.mjs

@@ -0,0 +1,9 @@
+import TableV2Cell from "./cell.mjs";
+import HeaderCell from "./header-cell.mjs";
+import TableV2HeaderRow from "./header-row.mjs";
+import TableV2Header from "./header.mjs";
+import TableV2Row from "./row.mjs";
+import SortIcon from "./sort-icon.mjs";
+import ExpandIcon from "./expand-icon.mjs";
+
+export { ExpandIcon, TableV2Header as Header, HeaderCell, TableV2HeaderRow as HeaderRow, TableV2Row as Row, SortIcon, TableV2Cell as TableCell };

frontend/node_modules/element-plus/es/components/table-v2/src/components/row.d.ts

@@ -0,0 +1,175 @@
+import { EpPropFinalized, EpPropMergeType } from "../../../../utils/vue/props/types.js";
+import "../../../../utils/index.js";
+import { KeyType } from "../types.js";
+import { AnyColumn } from "../common.js";
+import { RowEventHandlers, RowExpandHandler, RowHeightChangeHandler, RowHoverHandler, TableV2RowProps } from "../row.js";
+import * as vue from "vue";
+import { CSSProperties, VNode } from "vue";
+import * as vue_jsx_runtime0 from "vue/jsx-runtime";
+
+//#region ../../packages/components/table-v2/src/components/row.d.ts
+declare const TableV2Row: vue.DefineComponent<vue.ExtractPropTypes<{
+  readonly class: StringConstructor;
+  readonly columns: {
+    readonly type: vue.PropType<AnyColumn[]>;
+    readonly required: true;
+    readonly validator: ((val: unknown) => boolean) | undefined;
+    __epPropKey: true;
+  };
+  readonly columnsStyles: {
+    readonly type: vue.PropType<Record<KeyType, CSSProperties>>;
+    readonly required: true;
+    readonly validator: ((val: unknown) => boolean) | undefined;
+    __epPropKey: true;
+  };
+  readonly depth: NumberConstructor;
+  readonly expandColumnKey: StringConstructor;
+  readonly estimatedRowHeight: {
+    readonly default: undefined;
+    readonly type: vue.PropType<number>;
+    readonly required: false;
+    readonly validator: ((val: unknown) => boolean) | undefined;
+    readonly __epPropKey: true;
+  };
+  readonly isScrolling: BooleanConstructor;
+  readonly onRowExpand: {
+    readonly type: vue.PropType<RowExpandHandler>;
+    readonly required: false;
+    readonly validator: ((val: unknown) => boolean) | undefined;
+    __epPropKey: true;
+  };
+  readonly onRowHover: {
+    readonly type: vue.PropType<RowHoverHandler>;
+    readonly required: false;
+    readonly validator: ((val: unknown) => boolean) | undefined;
+    __epPropKey: true;
+  };
+  readonly onRowHeightChange: {
+    readonly type: vue.PropType<RowHeightChangeHandler>;
+    readonly required: false;
+    readonly validator: ((val: unknown) => boolean) | undefined;
+    __epPropKey: true;
+  };
+  readonly rowData: {
+    readonly type: vue.PropType<any>;
+    readonly required: true;
+    readonly validator: ((val: unknown) => boolean) | undefined;
+    __epPropKey: true;
+  };
+  readonly rowEventHandlers: {
+    readonly type: vue.PropType<RowEventHandlers>;
+    readonly required: false;
+    readonly validator: ((val: unknown) => boolean) | undefined;
+    __epPropKey: true;
+  };
+  readonly rowIndex: {
+    readonly type: vue.PropType<number>;
+    readonly required: true;
+    readonly validator: ((val: unknown) => boolean) | undefined;
+    __epPropKey: true;
+  };
+  readonly rowKey: EpPropFinalized<(new (...args: any[]) => string | number | symbol) | (() => KeyType) | (((new (...args: any[]) => string | number | symbol) | (() => KeyType)) | null)[], unknown, unknown, "id", boolean>;
+  readonly style: {
+    readonly type: vue.PropType<CSSProperties>;
+    readonly required: false;
+    readonly validator: ((val: unknown) => boolean) | undefined;
+    __epPropKey: true;
+  };
+}>, () => vue_jsx_runtime0.JSX.Element, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+  readonly class: StringConstructor;
+  readonly columns: {
+    readonly type: vue.PropType<AnyColumn[]>;
+    readonly required: true;
+    readonly validator: ((val: unknown) => boolean) | undefined;
+    __epPropKey: true;
+  };
+  readonly columnsStyles: {
+    readonly type: vue.PropType<Record<KeyType, CSSProperties>>;
+    readonly required: true;
+    readonly validator: ((val: unknown) => boolean) | undefined;
+    __epPropKey: true;
+  };
+  readonly depth: NumberConstructor;
+  readonly expandColumnKey: StringConstructor;
+  readonly estimatedRowHeight: {
+    readonly default: undefined;
+    readonly type: vue.PropType<number>;
+    readonly required: false;
+    readonly validator: ((val: unknown) => boolean) | undefined;
+    readonly __epPropKey: true;
+  };
+  readonly isScrolling: BooleanConstructor;
+  readonly onRowExpand: {
+    readonly type: vue.PropType<RowExpandHandler>;
+    readonly required: false;
+    readonly validator: ((val: unknown) => boolean) | undefined;
+    __epPropKey: true;
+  };
+  readonly onRowHover: {
+    readonly type: vue.PropType<RowHoverHandler>;
+    readonly required: false;
+    readonly validator: ((val: unknown) => boolean) | undefined;
+    __epPropKey: true;
+  };
+  readonly onRowHeightChange: {
+    readonly type: vue.PropType<RowHeightChangeHandler>;
+    readonly required: false;
+    readonly validator: ((val: unknown) => boolean) | undefined;
+    __epPropKey: true;
+  };
+  readonly rowData: {
+    readonly type: vue.PropType<any>;
+    readonly required: true;
+    readonly validator: ((val: unknown) => boolean) | undefined;
+    __epPropKey: true;
+  };
+  readonly rowEventHandlers: {
+    readonly type: vue.PropType<RowEventHandlers>;
+    readonly required: false;
+    readonly validator: ((val: unknown) => boolean) | undefined;
+    __epPropKey: true;
+  };
+  readonly rowIndex: {
+    readonly type: vue.PropType<number>;
+    readonly required: true;
+    readonly validator: ((val: unknown) => boolean) | undefined;
+    __epPropKey: true;
+  };
+  readonly rowKey: EpPropFinalized<(new (...args: any[]) => string | number | symbol) | (() => KeyType) | (((new (...args: any[]) => string | number | symbol) | (() => KeyType)) | null)[], unknown, unknown, "id", boolean>;
+  readonly style: {
+    readonly type: vue.PropType<CSSProperties>;
+    readonly required: false;
+    readonly validator: ((val: unknown) => boolean) | undefined;
+    __epPropKey: true;
+  };
+}>> & Readonly<{}>, {
+  readonly rowKey: EpPropMergeType<(new (...args: any[]) => string | number | symbol) | (() => KeyType) | (((new (...args: any[]) => string | number | symbol) | (() => KeyType)) | null)[], unknown, unknown>;
+  readonly estimatedRowHeight: number;
+  readonly isScrolling: boolean;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+type TableV2RowCellRenderParam = {
+  column: TableV2RowProps['columns'][number];
+  columns: TableV2RowProps['columns'];
+  columnIndex: number;
+  depth: number;
+  style: CSSProperties;
+  rowData: any;
+  rowIndex: number;
+  isScrolling: boolean;
+  expandIconProps?: {
+    rowData: any;
+    rowIndex: number;
+    onExpand: (expand: boolean) => void;
+  };
+};
+type TableV2RowSlotProps = {
+  cells: VNode[];
+  columns: TableV2RowProps['columns'];
+  depth: number;
+  style: TableV2RowProps['style'];
+  rowData: any;
+  rowIndex: number;
+  isScrolling: boolean;
+};
+//#endregion
+export { TableV2Row, TableV2RowCellRenderParam, TableV2RowSlotProps };

frontend/node_modules/element-plus/es/components/table-v2/src/components/row.mjs

@@ -0,0 +1,149 @@
+import { isArray, isFunction, isNumber } from "../../../../utils/types.mjs";
+import { placeholderSign } from "../private.mjs";
+import { TableV2InjectionKey } from "../tokens.mjs";
+import { tableV2RowProps } from "../row.mjs";
+import { computed, createVNode, defineComponent, inject, mergeProps, nextTick, onMounted, ref, unref } from "vue";
+
+//#region ../../packages/components/table-v2/src/components/row.tsx
+const useTableRow = (props) => {
+	const { isScrolling } = inject(TableV2InjectionKey);
+	const measured = ref(false);
+	const rowRef = ref();
+	const measurable = computed(() => {
+		return isNumber(props.estimatedRowHeight) && props.rowIndex >= 0;
+	});
+	const doMeasure = (isInit = false) => {
+		const $rowRef = unref(rowRef);
+		if (!$rowRef) return;
+		const { columns, onRowHeightChange, rowKey, rowIndex, style } = props;
+		const { height } = $rowRef.getBoundingClientRect();
+		measured.value = true;
+		nextTick(() => {
+			if (isInit || height !== Number.parseInt(style.height)) {
+				const firstColumn = columns[0];
+				const isPlaceholder = firstColumn?.placeholderSign === placeholderSign;
+				onRowHeightChange?.({
+					rowKey,
+					height,
+					rowIndex
+				}, firstColumn && !isPlaceholder && firstColumn.fixed);
+			}
+		});
+	};
+	const eventHandlers = computed(() => {
+		const { rowData, rowIndex, rowKey, onRowHover } = props;
+		const handlers = props.rowEventHandlers || {};
+		const eventHandlers = {};
+		Object.entries(handlers).forEach(([eventName, handler]) => {
+			if (isFunction(handler)) eventHandlers[eventName] = (event) => {
+				handler({
+					event,
+					rowData,
+					rowIndex,
+					rowKey
+				});
+			};
+		});
+		if (onRowHover) [{
+			name: "onMouseleave",
+			hovered: false
+		}, {
+			name: "onMouseenter",
+			hovered: true
+		}].forEach(({ name, hovered }) => {
+			const existedHandler = eventHandlers[name];
+			eventHandlers[name] = (event) => {
+				onRowHover({
+					event,
+					hovered,
+					rowData,
+					rowIndex,
+					rowKey
+				});
+				existedHandler?.(event);
+			};
+		});
+		return eventHandlers;
+	});
+	const onExpand = (expanded) => {
+		const { onRowExpand, rowData, rowIndex, rowKey } = props;
+		onRowExpand?.({
+			expanded,
+			rowData,
+			rowIndex,
+			rowKey
+		});
+	};
+	onMounted(() => {
+		if (unref(measurable)) doMeasure(true);
+	});
+	return {
+		isScrolling,
+		measurable,
+		measured,
+		rowRef,
+		eventHandlers,
+		onExpand
+	};
+};
+const TableV2Row = /* @__PURE__ */ defineComponent({
+	name: "ElTableV2TableRow",
+	props: tableV2RowProps,
+	setup(props, { expose, slots, attrs }) {
+		const { eventHandlers, isScrolling, measurable, measured, rowRef, onExpand } = useTableRow(props);
+		expose({ onExpand });
+		return () => {
+			const { columns, columnsStyles, expandColumnKey, depth, rowData, rowIndex, style } = props;
+			let ColumnCells = columns.map((column, columnIndex) => {
+				const expandable = isArray(rowData.children) && rowData.children.length > 0 && column.key === expandColumnKey;
+				return slots.cell({
+					column,
+					columns,
+					columnIndex,
+					depth,
+					style: columnsStyles[column.key],
+					rowData,
+					rowIndex,
+					isScrolling: unref(isScrolling),
+					expandIconProps: expandable ? {
+						rowData,
+						rowIndex,
+						onExpand
+					} : void 0
+				});
+			});
+			if (slots.row) ColumnCells = slots.row({
+				cells: ColumnCells.map((node) => {
+					if (isArray(node) && node.length === 1) return node[0];
+					return node;
+				}),
+				style,
+				columns,
+				depth,
+				rowData,
+				rowIndex,
+				isScrolling: unref(isScrolling)
+			});
+			if (unref(measurable)) {
+				const { height, ...exceptHeightStyle } = style || {};
+				const _measured = unref(measured);
+				return createVNode("div", mergeProps({
+					"ref": rowRef,
+					"class": props.class,
+					"style": _measured ? style : exceptHeightStyle,
+					"role": "row"
+				}, attrs, unref(eventHandlers)), [ColumnCells]);
+			}
+			return createVNode("div", mergeProps(attrs, {
+				"ref": rowRef,
+				"class": props.class,
+				"style": style,
+				"role": "row"
+			}, unref(eventHandlers)), [ColumnCells]);
+		};
+	}
+});
+
+//#endregion
+export { TableV2Row as default };
+//# sourceMappingURL=row.mjs.map

frontend/node_modules/element-plus/es/components/table-v2/src/components/sort-icon.d.ts

@@ -0,0 +1,12 @@
+import { SortOrder } from "../constants.js";
+import { FunctionalComponent } from "vue";
+
+//#region ../../packages/components/table-v2/src/components/sort-icon.d.ts
+type SortIconProps = {
+  sortOrder: SortOrder;
+  ariaLabel?: string;
+  class?: JSX.IntrinsicAttributes['class'];
+};
+declare const SortIcon: FunctionalComponent<SortIconProps>;
+//#endregion
+export { SortIcon };

frontend/node_modules/element-plus/es/components/table-v2/src/components/sort-icon.mjs

@@ -0,0 +1,18 @@
+import { ElIcon } from "../../../icon/index.mjs";
+import { SortOrder } from "../constants.mjs";
+import { SortDown, SortUp } from "@element-plus/icons-vue";
+import { createVNode } from "vue";
+
+//#region ../../packages/components/table-v2/src/components/sort-icon.tsx
+const SortIcon = (props) => {
+	const { sortOrder } = props;
+	return createVNode("button", {
+		"type": "button",
+		"aria-label": props.ariaLabel,
+		"class": props.class
+	}, [createVNode(ElIcon, { "size": 14 }, { default: () => [sortOrder === SortOrder.ASC ? createVNode(SortUp, null, null) : createVNode(SortDown, null, null)] })]);
+};
+
+//#endregion
+export { SortIcon as default };
+//# sourceMappingURL=sort-icon.mjs.map

frontend/node_modules/element-plus/es/components/table-v2/src/components/sort-icon.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"sort-icon.mjs","names":["ElIcon","SortDown","SortUp","SortOrder","SortIcon","props","sortOrder","_createVNode","ariaLabel","class","default","ASC"],"sources":["../../../../../../../packages/components/table-v2/src/components/sort-icon.tsx"],"sourcesContent":["import ElIcon from '@element-plus/components/icon'\nimport { SortDown, SortUp } from '@element-plus/icons-vue'\nimport { SortOrder } from '../constants'\n\nimport type { FunctionalComponent } from 'vue'\n\nexport type SortIconProps = {\n  sortOrder: SortOrder\n  ariaLabel?: string\n  class?: JSX.IntrinsicAttributes['class']\n}\n\nconst SortIcon: FunctionalComponent<SortIconProps> = (props) => {\n  const { sortOrder } = props\n\n  return (\n    <button type=\"button\" aria-label={props.ariaLabel} class={props.class}>\n      <ElIcon size={14}>\n        {sortOrder === SortOrder.ASC ? <SortUp /> : <SortDown />}\n      </ElIcon>\n    </button>\n  )\n}\n\nexport default SortIcon\n"],"mappings":";;;;;;AAYA,MAAMI,YAAgDC,UAAU;CAC9D,MAAM,EAAEC,cAAcD;AAEtB,QAAAE,YAAA,UAAA;EAAA,QAAA;EAAA,cACoCF,MAAMG;EAAS,SAASH,MAAMI;EAAK,EAAA,CAAAF,YAAAP,QAAA,EAAA,QACrD,IAAE,EAAA,EAAAU,eAAA,CACbJ,cAAcH,UAAUQ,MAAGJ,YAAAL,QAAA,MAAA,KAAA,GAAAK,YAAAN,UAAA,MAAA,KAA4B,CAAA,EAAA,CAAA,CAAA,CAAA"}

frontend/node_modules/element-plus/es/components/table-v2/src/composables/index.d.ts

@@ -0,0 +1,8 @@
+import { Alignment } from "../../../virtual-list/src/types.js";
+import { ScrollPos, useScrollbar } from "./use-scrollbar.js";
+import { UseColumnsReturn, useColumns } from "./use-columns.js";
+import { UseRowReturn, useRow } from "./use-row.js";
+import { UseDataReturn, useData } from "./use-data.js";
+import { UseStyleReturn, useStyles } from "./use-styles.js";
+import { useAutoResize } from "./use-auto-resize.js";
+export { ScrollPos, Alignment as ScrollStrategy, UseColumnsReturn, UseDataReturn, UseRowReturn, UseStyleReturn, useAutoResize, useColumns, useData, useRow, useScrollbar, useStyles };

frontend/node_modules/element-plus/es/components/table-v2/src/composables/index.mjs

@@ -0,0 +1,8 @@
+import { useColumns } from "./use-columns.mjs";
+import { useScrollbar } from "./use-scrollbar.mjs";
+import { useRow } from "./use-row.mjs";
+import { useData } from "./use-data.mjs";
+import { useStyles } from "./use-styles.mjs";
+import { useAutoResize } from "./use-auto-resize.mjs";
+
+export { useAutoResize, useColumns, useData, useRow, useScrollbar, useStyles };

frontend/node_modules/element-plus/es/components/table-v2/src/composables/use-auto-resize.d.ts

@@ -0,0 +1,11 @@
+import { AutoResizerProps } from "../auto-resizer.js";
+import * as vue from "vue";
+
+//#region ../../packages/components/table-v2/src/composables/use-auto-resize.d.ts
+declare const useAutoResize: (props: AutoResizerProps) => {
+  sizer: vue.Ref<HTMLElement | undefined, HTMLElement | undefined>;
+  width: vue.Ref<number, number>;
+  height: vue.Ref<number, number>;
+};
+//#endregion
+export { useAutoResize };

frontend/node_modules/element-plus/es/components/table-v2/src/composables/use-auto-resize.mjs

@@ -0,0 +1,40 @@
+import { useResizeObserver } from "@vueuse/core";
+import { onBeforeUnmount, onMounted, ref, watch } from "vue";
+
+//#region ../../packages/components/table-v2/src/composables/use-auto-resize.ts
+const useAutoResize = (props) => {
+	const sizer = ref();
+	const width$ = ref(0);
+	const height$ = ref(0);
+	let resizerStopper;
+	onMounted(() => {
+		resizerStopper = useResizeObserver(sizer, ([entry]) => {
+			const { width, height } = entry.contentRect;
+			const { paddingLeft, paddingRight, paddingTop, paddingBottom } = getComputedStyle(entry.target);
+			const left = Number.parseInt(paddingLeft) || 0;
+			const right = Number.parseInt(paddingRight) || 0;
+			const top = Number.parseInt(paddingTop) || 0;
+			const bottom = Number.parseInt(paddingBottom) || 0;
+			width$.value = width - left - right;
+			height$.value = height - top - bottom;
+		}).stop;
+	});
+	onBeforeUnmount(() => {
+		resizerStopper?.();
+	});
+	watch([width$, height$], ([width, height]) => {
+		props.onResize?.({
+			width,
+			height
+		});
+	});
+	return {
+		sizer,
+		width: width$,
+		height: height$
+	};
+};
+
+//#endregion
+export { useAutoResize };
+//# sourceMappingURL=use-auto-resize.mjs.map

frontend/node_modules/element-plus/es/components/table-v2/src/composables/use-auto-resize.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-auto-resize.mjs","names":[],"sources":["../../../../../../../packages/components/table-v2/src/composables/use-auto-resize.ts"],"sourcesContent":["import { onBeforeUnmount, onMounted, ref, watch } from 'vue'\nimport { useResizeObserver } from '@vueuse/core'\n\nimport type { AutoResizerProps } from '../auto-resizer'\n\nconst useAutoResize = (props: AutoResizerProps) => {\n  const sizer = ref<HTMLElement>()\n  const width$ = ref(0)\n  const height$ = ref(0)\n\n  let resizerStopper: ReturnType<typeof useResizeObserver>['stop']\n  onMounted(() => {\n    resizerStopper = useResizeObserver(sizer, ([entry]) => {\n      const { width, height } = entry.contentRect\n      const { paddingLeft, paddingRight, paddingTop, paddingBottom } =\n        getComputedStyle(entry.target)\n\n      const left = Number.parseInt(paddingLeft) || 0\n      const right = Number.parseInt(paddingRight) || 0\n      const top = Number.parseInt(paddingTop) || 0\n      const bottom = Number.parseInt(paddingBottom) || 0\n\n      width$.value = width - left - right\n      height$.value = height - top - bottom\n    }).stop\n  })\n\n  onBeforeUnmount(() => {\n    resizerStopper?.()\n  })\n\n  watch([width$, height$], ([width, height]) => {\n    props.onResize?.({\n      width,\n      height,\n    })\n  })\n\n  return {\n    sizer,\n    width: width$,\n    height: height$,\n  }\n}\n\nexport { useAutoResize }\n"],"mappings":";;;;AAKA,MAAM,iBAAiB,UAA4B;CACjD,MAAM,QAAQ,KAAkB;CAChC,MAAM,SAAS,IAAI,EAAE;CACrB,MAAM,UAAU,IAAI,EAAE;CAEtB,IAAI;AACJ,iBAAgB;AACd,mBAAiB,kBAAkB,QAAQ,CAAC,WAAW;GACrD,MAAM,EAAE,OAAO,WAAW,MAAM;GAChC,MAAM,EAAE,aAAa,cAAc,YAAY,kBAC7C,iBAAiB,MAAM,OAAO;GAEhC,MAAM,OAAO,OAAO,SAAS,YAAY,IAAI;GAC7C,MAAM,QAAQ,OAAO,SAAS,aAAa,IAAI;GAC/C,MAAM,MAAM,OAAO,SAAS,WAAW,IAAI;GAC3C,MAAM,SAAS,OAAO,SAAS,cAAc,IAAI;AAEjD,UAAO,QAAQ,QAAQ,OAAO;AAC9B,WAAQ,QAAQ,SAAS,MAAM;IAC/B,CAAC;GACH;AAEF,uBAAsB;AACpB,oBAAkB;GAClB;AAEF,OAAM,CAAC,QAAQ,QAAQ,GAAG,CAAC,OAAO,YAAY;AAC5C,QAAM,WAAW;GACf;GACA;GACD,CAAC;GACF;AAEF,QAAO;EACL;EACA,OAAO;EACP,QAAQ;EACT"}

frontend/node_modules/element-plus/es/components/table-v2/src/composables/use-columns.d.ts

@@ -0,0 +1,132 @@
+import { Alignment, AnyColumns, CellRenderer, ClassNameGetter, Column, FixedDirection, HeaderCellRenderer, HeaderClassGetter, KeyType } from "../types.js";
+import { TableV2Props } from "../table.js";
+import * as vue from "vue";
+import { CSSProperties, Ref } from "vue";
+
+//#region ../../packages/components/table-v2/src/composables/use-columns.d.ts
+declare function useColumns(props: TableV2Props, columns: Ref<AnyColumns>, fixed: Ref<boolean>): {
+  columns: vue.ComputedRef<{
+    key: KeyType;
+    align?: Alignment;
+    class?: string | ClassNameGetter<any> | undefined;
+    dataKey?: KeyType;
+    fixed?: true | FixedDirection;
+    flexGrow?: CSSProperties["flexGrow"];
+    flexShrink?: CSSProperties["flexShrink"];
+    title?: string;
+    hidden?: boolean;
+    headerClass?: string | HeaderClassGetter<any> | undefined;
+    maxWidth?: number;
+    minWidth?: number;
+    style?: CSSProperties;
+    sortable?: boolean;
+    width: number;
+    cellRenderer?: CellRenderer<any> | undefined;
+    headerCellRenderer?: HeaderCellRenderer<any> | undefined;
+  }[]>;
+  columnsStyles: vue.ComputedRef<Record<KeyType, CSSProperties>>;
+  columnsTotalWidth: vue.ComputedRef<number>;
+  fixedColumnsOnLeft: vue.ComputedRef<{
+    key: KeyType;
+    align?: Alignment;
+    class?: string | ClassNameGetter<any> | undefined;
+    dataKey?: KeyType;
+    fixed?: true | FixedDirection;
+    flexGrow?: CSSProperties["flexGrow"];
+    flexShrink?: CSSProperties["flexShrink"];
+    title?: string;
+    hidden?: boolean;
+    headerClass?: string | HeaderClassGetter<any> | undefined;
+    maxWidth?: number;
+    minWidth?: number;
+    style?: CSSProperties;
+    sortable?: boolean;
+    width: number;
+    cellRenderer?: CellRenderer<any> | undefined;
+    headerCellRenderer?: HeaderCellRenderer<any> | undefined;
+  }[]>;
+  fixedColumnsOnRight: vue.ComputedRef<{
+    key: KeyType;
+    align?: Alignment;
+    class?: string | ClassNameGetter<any> | undefined;
+    dataKey?: KeyType;
+    fixed?: true | FixedDirection;
+    flexGrow?: CSSProperties["flexGrow"];
+    flexShrink?: CSSProperties["flexShrink"];
+    title?: string;
+    hidden?: boolean;
+    headerClass?: string | HeaderClassGetter<any> | undefined;
+    maxWidth?: number;
+    minWidth?: number;
+    style?: CSSProperties;
+    sortable?: boolean;
+    width: number;
+    cellRenderer?: CellRenderer<any> | undefined;
+    headerCellRenderer?: HeaderCellRenderer<any> | undefined;
+  }[]>;
+  hasFixedColumns: vue.ComputedRef<number>;
+  mainColumns: vue.ComputedRef<AnyColumns>;
+  normalColumns: vue.ComputedRef<{
+    key: KeyType;
+    align?: Alignment;
+    class?: string | ClassNameGetter<any> | undefined;
+    dataKey?: KeyType;
+    fixed?: true | FixedDirection;
+    flexGrow?: CSSProperties["flexGrow"];
+    flexShrink?: CSSProperties["flexShrink"];
+    title?: string;
+    hidden?: boolean;
+    headerClass?: string | HeaderClassGetter<any> | undefined;
+    maxWidth?: number;
+    minWidth?: number;
+    style?: CSSProperties;
+    sortable?: boolean;
+    width: number;
+    cellRenderer?: CellRenderer<any> | undefined;
+    headerCellRenderer?: HeaderCellRenderer<any> | undefined;
+  }[]>;
+  visibleColumns: vue.ComputedRef<{
+    key: KeyType;
+    align?: Alignment;
+    class?: string | ClassNameGetter<any> | undefined;
+    dataKey?: KeyType;
+    fixed?: true | FixedDirection;
+    flexGrow?: CSSProperties["flexGrow"];
+    flexShrink?: CSSProperties["flexShrink"];
+    title?: string;
+    hidden?: boolean;
+    headerClass?: string | HeaderClassGetter<any> | undefined;
+    maxWidth?: number;
+    minWidth?: number;
+    style?: CSSProperties;
+    sortable?: boolean;
+    width: number;
+    cellRenderer?: CellRenderer<any> | undefined;
+    headerCellRenderer?: HeaderCellRenderer<any> | undefined;
+  }[]>;
+  getColumn: (key: KeyType) => {
+    key: KeyType;
+    align?: Alignment;
+    class?: string | ClassNameGetter<any> | undefined;
+    dataKey?: KeyType;
+    fixed?: true | FixedDirection;
+    flexGrow?: CSSProperties["flexGrow"];
+    flexShrink?: CSSProperties["flexShrink"];
+    title?: string;
+    hidden?: boolean;
+    headerClass?: string | HeaderClassGetter<any> | undefined;
+    maxWidth?: number;
+    minWidth?: number;
+    style?: CSSProperties;
+    sortable?: boolean;
+    width: number;
+    cellRenderer?: CellRenderer<any> | undefined;
+    headerCellRenderer?: HeaderCellRenderer<any> | undefined;
+  } | undefined;
+  getColumnStyle: (key: KeyType) => CSSProperties;
+  updateColumnWidth: (column: Column<any>, width: number) => void;
+  onColumnSorted: (e: MouseEvent) => void;
+};
+type UseColumnsReturn = ReturnType<typeof useColumns>;
+//#endregion
+export { UseColumnsReturn, useColumns };

frontend/node_modules/element-plus/es/components/table-v2/src/composables/use-columns.mjs

@@ -0,0 +1,91 @@
+import { isObject } from "../../../../utils/types.mjs";
+import { SortOrder, oppositeOrderMap } from "../constants.mjs";
+import { placeholderSign } from "../private.mjs";
+import { calcColumnStyle } from "./utils.mjs";
+import { computed, unref } from "vue";
+
+//#region ../../packages/components/table-v2/src/composables/use-columns.ts
+function useColumns(props, columns, fixed) {
+	const _columns = computed(() => unref(columns).map((column, index) => ({
+		...column,
+		key: column.key ?? column.dataKey ?? index
+	})));
+	const visibleColumns = computed(() => {
+		return unref(_columns).filter((column) => !column.hidden);
+	});
+	const fixedColumnsOnLeft = computed(() => unref(visibleColumns).filter((column) => column.fixed === "left" || column.fixed === true));
+	const fixedColumnsOnRight = computed(() => unref(visibleColumns).filter((column) => column.fixed === "right"));
+	const normalColumns = computed(() => unref(visibleColumns).filter((column) => !column.fixed));
+	const mainColumns = computed(() => {
+		const ret = [];
+		unref(fixedColumnsOnLeft).forEach((column) => {
+			ret.push({
+				...column,
+				placeholderSign
+			});
+		});
+		unref(normalColumns).forEach((column) => {
+			ret.push(column);
+		});
+		unref(fixedColumnsOnRight).forEach((column) => {
+			ret.push({
+				...column,
+				placeholderSign
+			});
+		});
+		return ret;
+	});
+	const hasFixedColumns = computed(() => {
+		return unref(fixedColumnsOnLeft).length || unref(fixedColumnsOnRight).length;
+	});
+	const columnsStyles = computed(() => {
+		return unref(_columns).reduce((style, column) => {
+			style[column.key] = calcColumnStyle(column, unref(fixed), props.fixed);
+			return style;
+		}, {});
+	});
+	const columnsTotalWidth = computed(() => {
+		return unref(visibleColumns).reduce((width, column) => width + column.width, 0);
+	});
+	const getColumn = (key) => {
+		return unref(_columns).find((column) => column.key === key);
+	};
+	const getColumnStyle = (key) => {
+		return unref(columnsStyles)[key];
+	};
+	const updateColumnWidth = (column, width) => {
+		column.width = width;
+	};
+	function onColumnSorted(e) {
+		const { key } = e.currentTarget.dataset;
+		if (!key) return;
+		const { sortState, sortBy } = props;
+		let order = SortOrder.ASC;
+		if (isObject(sortState)) order = oppositeOrderMap[sortState[key]];
+		else order = oppositeOrderMap[sortBy.order];
+		props.onColumnSort?.({
+			column: getColumn(key),
+			key,
+			order
+		});
+	}
+	return {
+		columns: _columns,
+		columnsStyles,
+		columnsTotalWidth,
+		fixedColumnsOnLeft,
+		fixedColumnsOnRight,
+		hasFixedColumns,
+		mainColumns,
+		normalColumns,
+		visibleColumns,
+		getColumn,
+		getColumnStyle,
+		updateColumnWidth,
+		onColumnSorted
+	};
+}
+
+//#endregion
+export { useColumns };
+//# sourceMappingURL=use-columns.mjs.map

frontend/node_modules/element-plus/es/components/table-v2/src/composables/use-data.d.ts

@@ -0,0 +1,22 @@
+import { KeyType } from "../types.js";
+import { TableV2Props } from "../table.js";
+import { UseRowReturn } from "./use-row.js";
+import * as vue from "vue";
+
+//#region ../../packages/components/table-v2/src/composables/use-data.d.ts
+type UseDataProps = {
+  expandedRowKeys: UseRowReturn['expandedRowKeys'];
+  lastRenderedRowIndex: UseRowReturn['lastRenderedRowIndex'];
+  resetAfterIndex: UseRowReturn['resetAfterIndex'];
+};
+declare const useData: (props: TableV2Props, {
+  expandedRowKeys,
+  lastRenderedRowIndex,
+  resetAfterIndex
+}: UseDataProps) => {
+  data: vue.ComputedRef<any[]>;
+  depthMap: vue.Ref<Record<KeyType, number>, Record<KeyType, number>>;
+};
+type UseDataReturn = ReturnType<typeof useData>;
+//#endregion
+export { UseDataReturn, useData };

frontend/node_modules/element-plus/es/components/table-v2/src/composables/use-data.mjs

@@ -0,0 +1,46 @@
+import { isArray } from "../../../../utils/types.mjs";
+import { computed, ref, unref, watch } from "vue";
+
+//#region ../../packages/components/table-v2/src/composables/use-data.ts
+const useData = (props, { expandedRowKeys, lastRenderedRowIndex, resetAfterIndex }) => {
+	const depthMap = ref({});
+	const flattenedData = computed(() => {
+		const depths = {};
+		const { data, rowKey } = props;
+		const _expandedRowKeys = unref(expandedRowKeys);
+		if (!_expandedRowKeys || !_expandedRowKeys.length) return data;
+		const array = [];
+		const keysSet = /* @__PURE__ */ new Set();
+		_expandedRowKeys.forEach((x) => keysSet.add(x));
+		let copy = data.slice();
+		copy.forEach((x) => depths[x[rowKey]] = 0);
+		while (copy.length > 0) {
+			const item = copy.shift();
+			array.push(item);
+			if (keysSet.has(item[rowKey]) && isArray(item.children) && item.children.length > 0) {
+				copy = [...item.children, ...copy];
+				item.children.forEach((child) => depths[child[rowKey]] = depths[item[rowKey]] + 1);
+			}
+		}
+		depthMap.value = depths;
+		return array;
+	});
+	const data = computed(() => {
+		const { data, expandColumnKey } = props;
+		return expandColumnKey ? unref(flattenedData) : data;
+	});
+	watch(data, (val, prev) => {
+		if (val !== prev) {
+			lastRenderedRowIndex.value = -1;
+			resetAfterIndex(0, true);
+		}
+	});
+	return {
+		data,
+		depthMap
+	};
+};
+
+//#endregion
+export { useData };
+//# sourceMappingURL=use-data.mjs.map

frontend/node_modules/element-plus/es/components/table-v2/src/composables/use-data.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-data.mjs","names":[],"sources":["../../../../../../../packages/components/table-v2/src/composables/use-data.ts"],"sourcesContent":["import { computed, ref, unref, watch } from 'vue'\nimport { isArray } from '@element-plus/utils'\n\nimport type { TableV2Props } from '../table'\nimport type { KeyType } from '../types'\nimport type { UseRowReturn } from './use-row'\n\ntype UseDataProps = {\n  expandedRowKeys: UseRowReturn['expandedRowKeys']\n  lastRenderedRowIndex: UseRowReturn['lastRenderedRowIndex']\n  resetAfterIndex: UseRowReturn['resetAfterIndex']\n}\n\nexport const useData = (\n  props: TableV2Props,\n  { expandedRowKeys, lastRenderedRowIndex, resetAfterIndex }: UseDataProps\n) => {\n  const depthMap = ref<Record<KeyType, number>>({})\n\n  const flattenedData = computed(() => {\n    const depths: Record<KeyType, number> = {}\n    const { data, rowKey } = props\n\n    const _expandedRowKeys = unref(expandedRowKeys)\n\n    if (!_expandedRowKeys || !_expandedRowKeys.length) return data\n\n    const array: any[] = []\n    const keysSet = new Set()\n    _expandedRowKeys.forEach((x) => keysSet.add(x))\n\n    let copy: any[] = data.slice()\n    copy.forEach((x) => (depths[x[rowKey]] = 0))\n    while (copy.length > 0) {\n      const item = copy.shift()!\n\n      array.push(item)\n      if (\n        keysSet.has(item[rowKey]) &&\n        isArray(item.children) &&\n        item.children.length > 0\n      ) {\n        copy = [...item.children, ...copy]\n        item.children.forEach(\n          (child: any) => (depths[child[rowKey]] = depths[item[rowKey]] + 1)\n        )\n      }\n    }\n\n    depthMap.value = depths\n    return array\n  })\n\n  const data = computed(() => {\n    const { data, expandColumnKey } = props\n    return expandColumnKey ? unref(flattenedData) : data\n  })\n\n  watch(data, (val, prev) => {\n    if (val !== prev) {\n      lastRenderedRowIndex.value = -1\n      resetAfterIndex(0, true)\n    }\n  })\n\n  return {\n    data,\n    depthMap,\n  }\n}\n\nexport type UseDataReturn = ReturnType<typeof useData>\n"],"mappings":";;;;AAaA,MAAa,WACX,OACA,EAAE,iBAAiB,sBAAsB,sBACtC;CACH,MAAM,WAAW,IAA6B,EAAE,CAAC;CAEjD,MAAM,gBAAgB,eAAe;EACnC,MAAM,SAAkC,EAAE;EAC1C,MAAM,EAAE,MAAM,WAAW;EAEzB,MAAM,mBAAmB,MAAM,gBAAgB;AAE/C,MAAI,CAAC,oBAAoB,CAAC,iBAAiB,OAAQ,QAAO;EAE1D,MAAM,QAAe,EAAE;EACvB,MAAM,0BAAU,IAAI,KAAK;AACzB,mBAAiB,SAAS,MAAM,QAAQ,IAAI,EAAE,CAAC;EAE/C,IAAI,OAAc,KAAK,OAAO;AAC9B,OAAK,SAAS,MAAO,OAAO,EAAE,WAAW,EAAG;AAC5C,SAAO,KAAK,SAAS,GAAG;GACtB,MAAM,OAAO,KAAK,OAAO;AAEzB,SAAM,KAAK,KAAK;AAChB,OACE,QAAQ,IAAI,KAAK,QAAQ,IACzB,QAAQ,KAAK,SAAS,IACtB,KAAK,SAAS,SAAS,GACvB;AACA,WAAO,CAAC,GAAG,KAAK,UAAU,GAAG,KAAK;AAClC,SAAK,SAAS,SACX,UAAgB,OAAO,MAAM,WAAW,OAAO,KAAK,WAAW,EACjE;;;AAIL,WAAS,QAAQ;AACjB,SAAO;GACP;CAEF,MAAM,OAAO,eAAe;EAC1B,MAAM,EAAE,MAAM,oBAAoB;AAClC,SAAO,kBAAkB,MAAM,cAAc,GAAG;GAChD;AAEF,OAAM,OAAO,KAAK,SAAS;AACzB,MAAI,QAAQ,MAAM;AAChB,wBAAqB,QAAQ;AAC7B,mBAAgB,GAAG,KAAK;;GAE1B;AAEF,QAAO;EACL;EACA;EACD"}

frontend/node_modules/element-plus/es/components/table-v2/src/composables/use-row.d.ts

@@ -0,0 +1,55 @@
+import { UseNamespaceReturn } from "../../../../hooks/use-namespace/index.js";
+import "../../../../hooks/index.js";
+import { FixedDirection, KeyType } from "../types.js";
+import { RowExpandParams, RowHeightChangedParams, RowHoverParams } from "../row.js";
+import { onRowRenderedParams } from "../grid.js";
+import { TableV2Props } from "../table.js";
+import { TableGridInstance } from "../table-grid.js";
+import * as vue from "vue";
+import { ComponentInternalInstance, Ref, ShallowRef } from "vue";
+
+//#region ../../packages/components/table-v2/src/composables/use-row.d.ts
+type Heights = Record<KeyType, number>;
+type GridInstanceRef = Ref<TableGridInstance | undefined>;
+type UseRowProps = {
+  mainTableRef: GridInstanceRef;
+  leftTableRef: GridInstanceRef;
+  rightTableRef: GridInstanceRef;
+  tableInstance: ComponentInternalInstance;
+  ns: UseNamespaceReturn;
+  isScrolling: ShallowRef<boolean>;
+};
+declare const useRow: (props: TableV2Props, {
+  mainTableRef,
+  leftTableRef,
+  rightTableRef,
+  tableInstance,
+  ns,
+  isScrolling
+}: UseRowProps) => {
+  expandedRowKeys: Ref<KeyType[], KeyType[]>;
+  lastRenderedRowIndex: Ref<number, number>;
+  isDynamic: vue.ComputedRef<boolean>;
+  isResetting: ShallowRef<boolean, boolean>;
+  rowHeights: Ref<Heights, Heights>;
+  resetAfterIndex: (index: number, forceUpdate?: boolean) => void;
+  onRowExpanded: ({
+    expanded,
+    rowData,
+    rowIndex,
+    rowKey
+  }: RowExpandParams) => void;
+  onRowHovered: ({
+    hovered,
+    rowKey
+  }: RowHoverParams) => void;
+  onRowsRendered: (params: onRowRenderedParams) => void;
+  onRowHeightChange: ({
+    rowKey,
+    height,
+    rowIndex
+  }: RowHeightChangedParams, fixedDir: FixedDirection) => void;
+};
+type UseRowReturn = ReturnType<typeof useRow>;
+//#endregion
+export { UseRowReturn, useRow };

frontend/node_modules/element-plus/es/components/table-v2/src/composables/use-row.mjs

@@ -0,0 +1,113 @@
+import { isNumber } from "../../../../utils/types.mjs";
+import { FixedDir } from "../constants.mjs";
+import { debounce } from "lodash-unified";
+import { computed, getCurrentInstance, nextTick, ref, shallowRef, unref } from "vue";
+
+//#region ../../packages/components/table-v2/src/composables/use-row.ts
+const useRow = (props, { mainTableRef, leftTableRef, rightTableRef, tableInstance, ns, isScrolling }) => {
+	const vm = getCurrentInstance();
+	const { emit } = vm;
+	const isResetting = shallowRef(false);
+	const expandedRowKeys = ref(props.defaultExpandedRowKeys || []);
+	const lastRenderedRowIndex = ref(-1);
+	const resetIndex = shallowRef(null);
+	const rowHeights = ref({});
+	const pendingRowHeights = ref({});
+	const leftTableHeights = shallowRef({});
+	const mainTableHeights = shallowRef({});
+	const rightTableHeights = shallowRef({});
+	const isDynamic = computed(() => isNumber(props.estimatedRowHeight));
+	function onRowsRendered(params) {
+		props.onRowsRendered?.(params);
+		if (params.rowCacheEnd > unref(lastRenderedRowIndex)) lastRenderedRowIndex.value = params.rowCacheEnd;
+	}
+	function onRowHovered({ hovered, rowKey }) {
+		if (isScrolling.value) return;
+		tableInstance.vnode.el.querySelectorAll(`[rowkey="${String(rowKey)}"]`).forEach((row) => {
+			if (hovered) row.classList.add(ns.is("hovered"));
+			else row.classList.remove(ns.is("hovered"));
+		});
+	}
+	function onRowExpanded({ expanded, rowData, rowIndex, rowKey }) {
+		const _expandedRowKeys = [...unref(expandedRowKeys)];
+		const currentKeyIndex = _expandedRowKeys.indexOf(rowKey);
+		if (expanded) {
+			if (currentKeyIndex === -1) _expandedRowKeys.push(rowKey);
+		} else if (currentKeyIndex > -1) _expandedRowKeys.splice(currentKeyIndex, 1);
+		expandedRowKeys.value = _expandedRowKeys;
+		emit("update:expandedRowKeys", _expandedRowKeys);
+		props.onRowExpand?.({
+			expanded,
+			rowData,
+			rowIndex,
+			rowKey
+		});
+		props.onExpandedRowsChange?.(_expandedRowKeys);
+		if (tableInstance.vnode.el.querySelector(`.${ns.is("hovered")}[rowkey="${String(rowKey)}"]`)) nextTick(() => onRowHovered({
+			hovered: true,
+			rowKey
+		}));
+	}
+	const flushingRowHeights = debounce(() => {
+		isResetting.value = true;
+		rowHeights.value = {
+			...unref(rowHeights),
+			...unref(pendingRowHeights)
+		};
+		resetAfterIndex(unref(resetIndex), false);
+		pendingRowHeights.value = {};
+		resetIndex.value = null;
+		mainTableRef.value?.forceUpdate();
+		leftTableRef.value?.forceUpdate();
+		rightTableRef.value?.forceUpdate();
+		vm.proxy?.$forceUpdate();
+		isResetting.value = false;
+	}, 0);
+	function resetAfterIndex(index, forceUpdate = false) {
+		if (!unref(isDynamic)) return;
+		[
+			mainTableRef,
+			leftTableRef,
+			rightTableRef
+		].forEach((tableRef) => {
+			const table = unref(tableRef);
+			if (table) table.resetAfterRowIndex(index, forceUpdate);
+		});
+	}
+	function resetHeights(rowKey, height, rowIdx) {
+		const resetIdx = unref(resetIndex);
+		if (resetIdx === null) resetIndex.value = rowIdx;
+		else if (resetIdx > rowIdx) resetIndex.value = rowIdx;
+		pendingRowHeights.value[rowKey] = height;
+	}
+	function onRowHeightChange({ rowKey, height, rowIndex }, fixedDir) {
+		if (!fixedDir) mainTableHeights.value[rowKey] = height;
+		else if (fixedDir === FixedDir.RIGHT) rightTableHeights.value[rowKey] = height;
+		else leftTableHeights.value[rowKey] = height;
+		const maximumHeight = Math.max(...[
+			leftTableHeights,
+			rightTableHeights,
+			mainTableHeights
+		].map((records) => records.value[rowKey] || 0));
+		if (unref(rowHeights)[rowKey] !== maximumHeight) {
+			resetHeights(rowKey, maximumHeight, rowIndex);
+			flushingRowHeights();
+		}
+	}
+	return {
+		expandedRowKeys,
+		lastRenderedRowIndex,
+		isDynamic,
+		isResetting,
+		rowHeights,
+		resetAfterIndex,
+		onRowExpanded,
+		onRowHovered,
+		onRowsRendered,
+		onRowHeightChange
+	};
+};
+
+//#endregion
+export { useRow };
+//# sourceMappingURL=use-row.mjs.map

frontend/node_modules/element-plus/es/components/table-v2/src/composables/use-scrollbar.d.ts

@@ -0,0 +1,42 @@
+import { Alignment } from "../../../virtual-list/src/types.js";
+import "../../../virtual-list/index.js";
+import { TableV2Props } from "../table.js";
+import { TableGridInstance } from "../table-grid.js";
+import { Ref } from "vue";
+
+//#region ../../packages/components/table-v2/src/composables/use-scrollbar.d.ts
+type ScrollPos = {
+  scrollLeft: number;
+  scrollTop: number;
+};
+type GridInstanceRef = Ref<TableGridInstance | undefined>;
+type UseScrollBarProps = {
+  mainTableRef: GridInstanceRef;
+  leftTableRef: GridInstanceRef;
+  rightTableRef: GridInstanceRef;
+  onMaybeEndReached: () => void;
+};
+declare const useScrollbar: (props: TableV2Props, {
+  mainTableRef,
+  leftTableRef,
+  rightTableRef,
+  onMaybeEndReached
+}: UseScrollBarProps) => {
+  scrollPos: Ref<{
+    scrollLeft: number;
+    scrollTop: number;
+  }, ScrollPos | {
+    scrollLeft: number;
+    scrollTop: number;
+  }>;
+  scrollTo: (params: ScrollPos) => void;
+  scrollToLeft: (scrollLeft: number) => void;
+  scrollToTop: (scrollTop: number) => void;
+  scrollToRow: (row: number, strategy?: Alignment) => void;
+  onScroll: (params: ScrollPos) => void;
+  onVerticalScroll: ({
+    scrollTop
+  }: ScrollPos) => void;
+};
+//#endregion
+export { ScrollPos, useScrollbar };

frontend/node_modules/element-plus/es/components/table-v2/src/composables/use-scrollbar.mjs

@@ -0,0 +1,54 @@
+import { ref, unref, watch } from "vue";
+
+//#region ../../packages/components/table-v2/src/composables/use-scrollbar.ts
+const useScrollbar = (props, { mainTableRef, leftTableRef, rightTableRef, onMaybeEndReached }) => {
+	const scrollPos = ref({
+		scrollLeft: 0,
+		scrollTop: 0
+	});
+	function doScroll(params) {
+		const { scrollTop } = params;
+		mainTableRef.value?.scrollTo(params);
+		leftTableRef.value?.scrollToTop(scrollTop);
+		rightTableRef.value?.scrollToTop(scrollTop);
+	}
+	function scrollTo(params) {
+		scrollPos.value = params;
+		doScroll(params);
+	}
+	function scrollToTop(scrollTop) {
+		scrollPos.value.scrollTop = scrollTop;
+		doScroll(unref(scrollPos));
+	}
+	function scrollToLeft(scrollLeft) {
+		scrollPos.value.scrollLeft = scrollLeft;
+		mainTableRef.value?.scrollTo?.(unref(scrollPos));
+	}
+	function onScroll(params) {
+		scrollTo(params);
+		props.onScroll?.(params);
+	}
+	function onVerticalScroll({ scrollTop }) {
+		const { scrollTop: currentScrollTop } = unref(scrollPos);
+		if (scrollTop !== currentScrollTop) scrollToTop(scrollTop);
+	}
+	function scrollToRow(row, strategy = "auto") {
+		mainTableRef.value?.scrollToRow(row, strategy);
+	}
+	watch(() => unref(scrollPos).scrollTop, (cur, prev) => {
+		if (cur > prev) onMaybeEndReached();
+	});
+	return {
+		scrollPos,
+		scrollTo,
+		scrollToLeft,
+		scrollToTop,
+		scrollToRow,
+		onScroll,
+		onVerticalScroll
+	};
+};
+
+//#endregion
+export { useScrollbar };
+//# sourceMappingURL=use-scrollbar.mjs.map

frontend/node_modules/element-plus/es/components/table-v2/src/composables/use-scrollbar.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-scrollbar.mjs","names":[],"sources":["../../../../../../../packages/components/table-v2/src/composables/use-scrollbar.ts"],"sourcesContent":["import { ref, unref, watch } from 'vue'\n\nimport type { Ref } from 'vue'\nimport type { Alignment as ScrollStrategy } from '@element-plus/components/virtual-list'\nimport type { TableV2Props } from '../table'\nimport type { TableGridInstance } from '../table-grid'\n\nexport type ScrollPos = { scrollLeft: number; scrollTop: number }\ntype GridInstanceRef = Ref<TableGridInstance | undefined>\n\ntype UseScrollBarProps = {\n  mainTableRef: GridInstanceRef\n  leftTableRef: GridInstanceRef\n  rightTableRef: GridInstanceRef\n\n  onMaybeEndReached: () => void\n}\n\nexport type { ScrollStrategy }\n\nexport const useScrollbar = (\n  props: TableV2Props,\n  {\n    mainTableRef,\n    leftTableRef,\n    rightTableRef,\n    onMaybeEndReached,\n  }: UseScrollBarProps\n) => {\n  const scrollPos = ref<ScrollPos>({ scrollLeft: 0, scrollTop: 0 })\n\n  function doScroll(params: ScrollPos) {\n    const { scrollTop } = params\n\n    mainTableRef.value?.scrollTo(params)\n    leftTableRef.value?.scrollToTop(scrollTop)\n    rightTableRef.value?.scrollToTop(scrollTop)\n  }\n\n  // methods\n  function scrollTo(params: ScrollPos) {\n    scrollPos.value = params\n\n    doScroll(params)\n  }\n\n  function scrollToTop(scrollTop: number) {\n    scrollPos.value.scrollTop = scrollTop\n\n    doScroll(unref(scrollPos))\n  }\n\n  function scrollToLeft(scrollLeft: number) {\n    scrollPos.value.scrollLeft = scrollLeft\n\n    mainTableRef.value?.scrollTo?.(unref(scrollPos))\n  }\n\n  function onScroll(params: ScrollPos) {\n    scrollTo(params)\n    props.onScroll?.(params)\n  }\n\n  function onVerticalScroll({ scrollTop }: ScrollPos) {\n    const { scrollTop: currentScrollTop } = unref(scrollPos)\n    if (scrollTop !== currentScrollTop) scrollToTop(scrollTop)\n  }\n\n  function scrollToRow(row: number, strategy: ScrollStrategy = 'auto') {\n    mainTableRef.value?.scrollToRow(row, strategy)\n  }\n\n  // When scrollTop changes, maybe reaching the bottom\n  watch(\n    () => unref(scrollPos).scrollTop,\n    (cur, prev) => {\n      if (cur > prev) onMaybeEndReached()\n    }\n  )\n\n  return {\n    scrollPos,\n\n    scrollTo,\n    scrollToLeft,\n    scrollToTop,\n    scrollToRow,\n    onScroll,\n    onVerticalScroll,\n  }\n}\n"],"mappings":";;;AAoBA,MAAa,gBACX,OACA,EACE,cACA,cACA,eACA,wBAEC;CACH,MAAM,YAAY,IAAe;EAAE,YAAY;EAAG,WAAW;EAAG,CAAC;CAEjE,SAAS,SAAS,QAAmB;EACnC,MAAM,EAAE,cAAc;AAEtB,eAAa,OAAO,SAAS,OAAO;AACpC,eAAa,OAAO,YAAY,UAAU;AAC1C,gBAAc,OAAO,YAAY,UAAU;;CAI7C,SAAS,SAAS,QAAmB;AACnC,YAAU,QAAQ;AAElB,WAAS,OAAO;;CAGlB,SAAS,YAAY,WAAmB;AACtC,YAAU,MAAM,YAAY;AAE5B,WAAS,MAAM,UAAU,CAAC;;CAG5B,SAAS,aAAa,YAAoB;AACxC,YAAU,MAAM,aAAa;AAE7B,eAAa,OAAO,WAAW,MAAM,UAAU,CAAC;;CAGlD,SAAS,SAAS,QAAmB;AACnC,WAAS,OAAO;AAChB,QAAM,WAAW,OAAO;;CAG1B,SAAS,iBAAiB,EAAE,aAAwB;EAClD,MAAM,EAAE,WAAW,qBAAqB,MAAM,UAAU;AACxD,MAAI,cAAc,iBAAkB,aAAY,UAAU;;CAG5D,SAAS,YAAY,KAAa,WAA2B,QAAQ;AACnE,eAAa,OAAO,YAAY,KAAK,SAAS;;AAIhD,aACQ,MAAM,UAAU,CAAC,YACtB,KAAK,SAAS;AACb,MAAI,MAAM,KAAM,oBAAmB;GAEtC;AAED,QAAO;EACL;EAEA;EACA;EACA;EACA;EACA;EACA;EACD"}

frontend/node_modules/element-plus/es/components/table-v2/src/composables/use-styles.d.ts

@@ -0,0 +1,31 @@
+import { TableV2Props } from "../table.js";
+import { UseColumnsReturn } from "./use-columns.js";
+import { CSSProperties, ComputedRef } from "vue";
+
+//#region ../../packages/components/table-v2/src/composables/use-styles.d.ts
+type UseStyleProps = {
+  columnsTotalWidth: UseColumnsReturn['columnsTotalWidth'];
+  fixedColumnsOnLeft: UseColumnsReturn['fixedColumnsOnLeft'];
+  fixedColumnsOnRight: UseColumnsReturn['fixedColumnsOnRight'];
+  rowsHeight: ComputedRef<number>;
+};
+declare const useStyles: (props: TableV2Props, {
+  columnsTotalWidth,
+  rowsHeight,
+  fixedColumnsOnLeft,
+  fixedColumnsOnRight
+}: UseStyleProps) => {
+  bodyWidth: ComputedRef<number>;
+  fixedTableHeight: ComputedRef<number>;
+  mainTableHeight: ComputedRef<number>;
+  leftTableWidth: ComputedRef<number>;
+  rightTableWidth: ComputedRef<number>;
+  windowHeight: ComputedRef<number>;
+  footerHeight: ComputedRef<CSSProperties>;
+  emptyStyle: ComputedRef<CSSProperties>;
+  rootStyle: ComputedRef<CSSProperties>;
+  headerHeight: ComputedRef<number>;
+};
+type UseStyleReturn = ReturnType<typeof useStyles>;
+//#endregion
+export { UseStyleReturn, useStyles };

frontend/node_modules/element-plus/es/components/table-v2/src/composables/use-styles.mjs

@@ -0,0 +1,68 @@
+import { isNumber } from "../../../../utils/types.mjs";
+import { addUnit } from "../../../../utils/dom/style.mjs";
+import { enforceUnit, sum } from "../utils.mjs";
+import { computed, unref } from "vue";
+
+//#region ../../packages/components/table-v2/src/composables/use-styles.ts
+const useStyles = (props, { columnsTotalWidth, rowsHeight, fixedColumnsOnLeft, fixedColumnsOnRight }) => {
+	const bodyWidth = computed(() => {
+		const { fixed, width, vScrollbarSize } = props;
+		const ret = width - vScrollbarSize;
+		return fixed ? Math.max(Math.round(unref(columnsTotalWidth)), ret) : ret;
+	});
+	const mainTableHeight = computed(() => {
+		const { height = 0, maxHeight = 0, footerHeight, hScrollbarSize } = props;
+		if (maxHeight > 0) {
+			const _fixedRowsHeight = unref(fixedRowsHeight);
+			const _rowsHeight = unref(rowsHeight);
+			const total = unref(headerHeight) + _fixedRowsHeight + _rowsHeight + hScrollbarSize;
+			return Math.min(total, maxHeight - footerHeight);
+		}
+		return height - footerHeight;
+	});
+	const fixedTableHeight = computed(() => {
+		const { maxHeight } = props;
+		const tableHeight = unref(mainTableHeight);
+		if (isNumber(maxHeight) && maxHeight > 0) return tableHeight;
+		const totalHeight = unref(rowsHeight) + unref(headerHeight) + unref(fixedRowsHeight);
+		return Math.min(tableHeight, totalHeight);
+	});
+	const mapColumn = (column) => column.width;
+	const leftTableWidth = computed(() => sum(unref(fixedColumnsOnLeft).map(mapColumn)));
+	const rightTableWidth = computed(() => sum(unref(fixedColumnsOnRight).map(mapColumn)));
+	const headerHeight = computed(() => sum(props.headerHeight));
+	const fixedRowsHeight = computed(() => {
+		return (props.fixedData?.length || 0) * props.rowHeight;
+	});
+	const windowHeight = computed(() => {
+		return unref(mainTableHeight) - unref(headerHeight) - unref(fixedRowsHeight);
+	});
+	const rootStyle = computed(() => {
+		const { style = {}, height, width } = props;
+		return enforceUnit({
+			...style,
+			height,
+			width
+		});
+	});
+	return {
+		bodyWidth,
+		fixedTableHeight,
+		mainTableHeight,
+		leftTableWidth,
+		rightTableWidth,
+		windowHeight,
+		footerHeight: computed(() => enforceUnit({ height: props.footerHeight })),
+		emptyStyle: computed(() => ({
+			top: addUnit(unref(headerHeight)),
+			bottom: addUnit(props.footerHeight),
+			width: addUnit(props.width)
+		})),
+		rootStyle,
+		headerHeight
+	};
+};
+
+//#endregion
+export { useStyles };
+//# sourceMappingURL=use-styles.mjs.map

frontend/node_modules/element-plus/es/components/table-v2/src/composables/use-styles.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-styles.mjs","names":[],"sources":["../../../../../../../packages/components/table-v2/src/composables/use-styles.ts"],"sourcesContent":["import { computed, unref } from 'vue'\nimport { addUnit, isNumber } from '@element-plus/utils'\nimport { enforceUnit, sum } from '../utils'\n\nimport type { CSSProperties, ComputedRef } from 'vue'\nimport type { TableV2Props } from '../table'\nimport type { UseColumnsReturn } from './use-columns'\n\ntype UseStyleProps = {\n  columnsTotalWidth: UseColumnsReturn['columnsTotalWidth']\n  fixedColumnsOnLeft: UseColumnsReturn['fixedColumnsOnLeft']\n  fixedColumnsOnRight: UseColumnsReturn['fixedColumnsOnRight']\n  rowsHeight: ComputedRef<number>\n}\n\nexport const useStyles = (\n  props: TableV2Props,\n  {\n    columnsTotalWidth,\n    rowsHeight,\n    fixedColumnsOnLeft,\n    fixedColumnsOnRight,\n  }: UseStyleProps\n) => {\n  const bodyWidth = computed(() => {\n    const { fixed, width, vScrollbarSize } = props\n    const ret = width - vScrollbarSize\n    return fixed ? Math.max(Math.round(unref(columnsTotalWidth)), ret) : ret\n  })\n\n  const mainTableHeight = computed(() => {\n    const { height = 0, maxHeight = 0, footerHeight, hScrollbarSize } = props\n\n    if (maxHeight > 0) {\n      const _fixedRowsHeight = unref(fixedRowsHeight)\n      const _rowsHeight = unref(rowsHeight)\n      const _headerHeight = unref(headerHeight)\n      const total =\n        _headerHeight + _fixedRowsHeight + _rowsHeight + hScrollbarSize\n\n      return Math.min(total, maxHeight - footerHeight)\n    }\n\n    return height - footerHeight\n  })\n\n  const fixedTableHeight = computed(() => {\n    const { maxHeight } = props\n    const tableHeight = unref(mainTableHeight)\n    if (isNumber(maxHeight) && maxHeight > 0) return tableHeight\n\n    const totalHeight =\n      unref(rowsHeight) + unref(headerHeight) + unref(fixedRowsHeight)\n\n    return Math.min(tableHeight, totalHeight)\n  })\n\n  const mapColumn = (column: TableV2Props['columns'][number]) => column.width\n\n  const leftTableWidth = computed(() =>\n    sum(unref(fixedColumnsOnLeft).map(mapColumn))\n  )\n\n  const rightTableWidth = computed(() =>\n    sum(unref(fixedColumnsOnRight).map(mapColumn))\n  )\n\n  const headerHeight = computed(() => sum(props.headerHeight))\n\n  const fixedRowsHeight = computed(() => {\n    return (props.fixedData?.length || 0) * props.rowHeight\n  })\n\n  const windowHeight = computed(() => {\n    return unref(mainTableHeight) - unref(headerHeight) - unref(fixedRowsHeight)\n  })\n\n  const rootStyle = computed<CSSProperties>(() => {\n    const { style = {}, height, width } = props\n    return enforceUnit({\n      ...style,\n      height,\n      width,\n    })\n  })\n\n  const footerHeight = computed(() =>\n    enforceUnit({ height: props.footerHeight })\n  )\n\n  const emptyStyle = computed<CSSProperties>(() => ({\n    top: addUnit(unref(headerHeight)),\n    bottom: addUnit(props.footerHeight),\n    width: addUnit(props.width),\n  }))\n\n  return {\n    bodyWidth,\n    fixedTableHeight,\n    mainTableHeight,\n    leftTableWidth,\n    rightTableWidth,\n    windowHeight,\n    footerHeight,\n    emptyStyle,\n    rootStyle,\n    headerHeight,\n  }\n}\n\nexport type UseStyleReturn = ReturnType<typeof useStyles>\n"],"mappings":";;;;;;AAeA,MAAa,aACX,OACA,EACE,mBACA,YACA,oBACA,0BAEC;CACH,MAAM,YAAY,eAAe;EAC/B,MAAM,EAAE,OAAO,OAAO,mBAAmB;EACzC,MAAM,MAAM,QAAQ;AACpB,SAAO,QAAQ,KAAK,IAAI,KAAK,MAAM,MAAM,kBAAkB,CAAC,EAAE,IAAI,GAAG;GACrE;CAEF,MAAM,kBAAkB,eAAe;EACrC,MAAM,EAAE,SAAS,GAAG,YAAY,GAAG,cAAc,mBAAmB;AAEpE,MAAI,YAAY,GAAG;GACjB,MAAM,mBAAmB,MAAM,gBAAgB;GAC/C,MAAM,cAAc,MAAM,WAAW;GAErC,MAAM,QADgB,MAAM,aAAa,GAEvB,mBAAmB,cAAc;AAEnD,UAAO,KAAK,IAAI,OAAO,YAAY,aAAa;;AAGlD,SAAO,SAAS;GAChB;CAEF,MAAM,mBAAmB,eAAe;EACtC,MAAM,EAAE,cAAc;EACtB,MAAM,cAAc,MAAM,gBAAgB;AAC1C,MAAI,SAAS,UAAU,IAAI,YAAY,EAAG,QAAO;EAEjD,MAAM,cACJ,MAAM,WAAW,GAAG,MAAM,aAAa,GAAG,MAAM,gBAAgB;AAElE,SAAO,KAAK,IAAI,aAAa,YAAY;GACzC;CAEF,MAAM,aAAa,WAA4C,OAAO;CAEtE,MAAM,iBAAiB,eACrB,IAAI,MAAM,mBAAmB,CAAC,IAAI,UAAU,CAAC,CAC9C;CAED,MAAM,kBAAkB,eACtB,IAAI,MAAM,oBAAoB,CAAC,IAAI,UAAU,CAAC,CAC/C;CAED,MAAM,eAAe,eAAe,IAAI,MAAM,aAAa,CAAC;CAE5D,MAAM,kBAAkB,eAAe;AACrC,UAAQ,MAAM,WAAW,UAAU,KAAK,MAAM;GAC9C;CAEF,MAAM,eAAe,eAAe;AAClC,SAAO,MAAM,gBAAgB,GAAG,MAAM,aAAa,GAAG,MAAM,gBAAgB;GAC5E;CAEF,MAAM,YAAY,eAA8B;EAC9C,MAAM,EAAE,QAAQ,EAAE,EAAE,QAAQ,UAAU;AACtC,SAAO,YAAY;GACjB,GAAG;GACH;GACA;GACD,CAAC;GACF;AAYF,QAAO;EACL;EACA;EACA;EACA;EACA;EACA;EACA,cAjBmB,eACnB,YAAY,EAAE,QAAQ,MAAM,cAAc,CAAC,CAC5C;EAgBC,YAdiB,gBAA+B;GAChD,KAAK,QAAQ,MAAM,aAAa,CAAC;GACjC,QAAQ,QAAQ,MAAM,aAAa;GACnC,OAAO,QAAQ,MAAM,MAAM;GAC5B,EAAE;EAWD;EACA;EACD"}

frontend/node_modules/element-plus/es/components/table-v2/src/composables/utils.mjs

@@ -0,0 +1,26 @@
+//#region ../../packages/components/table-v2/src/composables/utils.ts
+const calcColumnStyle = (column, fixedColumn, fixed) => {
+	const flex = {
+		flexGrow: 0,
+		flexShrink: 0,
+		...fixed ? {} : {
+			flexGrow: column.flexGrow ?? 0,
+			flexShrink: column.flexShrink ?? 1
+		}
+	};
+	const style = {
+		...column.style ?? {},
+		...flex,
+		flexBasis: "auto",
+		width: column.width
+	};
+	if (!fixedColumn) {
+		if (column.maxWidth) style.maxWidth = column.maxWidth;
+		if (column.minWidth) style.minWidth = column.minWidth;
+	}
+	return style;
+};
+
+//#endregion
+export { calcColumnStyle };
+//# sourceMappingURL=utils.mjs.map

frontend/node_modules/element-plus/es/components/table-v2/src/composables/utils.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.mjs","names":[],"sources":["../../../../../../../packages/components/table-v2/src/composables/utils.ts"],"sourcesContent":["import type { CSSProperties } from 'vue'\nimport type { AnyColumns } from '../types'\n\nexport const calcColumnStyle = (\n  column: AnyColumns[number],\n  fixedColumn: boolean,\n  fixed: boolean\n): CSSProperties => {\n  const flex = {\n    flexGrow: 0,\n    flexShrink: 0,\n    ...(fixed\n      ? {}\n      : {\n          flexGrow: column.flexGrow ?? 0,\n          flexShrink: column.flexShrink ?? 1,\n        }),\n  }\n\n  const style = {\n    ...(column.style ?? {}),\n    ...flex,\n    flexBasis: 'auto',\n    width: column.width,\n  }\n\n  if (!fixedColumn) {\n    if (column.maxWidth) style.maxWidth = column.maxWidth\n    if (column.minWidth) style.minWidth = column.minWidth\n  }\n\n  return style\n}\n"],"mappings":";AAGA,MAAa,mBACX,QACA,aACA,UACkB;CAClB,MAAM,OAAO;EACX,UAAU;EACV,YAAY;EACZ,GAAI,QACA,EAAE,GACF;GACE,UAAU,OAAO,YAAY;GAC7B,YAAY,OAAO,cAAc;GAClC;EACN;CAED,MAAM,QAAQ;EACZ,GAAI,OAAO,SAAS,EAAE;EACtB,GAAG;EACH,WAAW;EACX,OAAO,OAAO;EACf;AAED,KAAI,CAAC,aAAa;AAChB,MAAI,OAAO,SAAU,OAAM,WAAW,OAAO;AAC7C,MAAI,OAAO,SAAU,OAAM,WAAW,OAAO;;AAG/C,QAAO"}

frontend/node_modules/element-plus/es/components/table-v2/src/constants.d.ts

@@ -0,0 +1,16 @@
+//#region ../../packages/components/table-v2/src/constants.d.ts
+declare enum SortOrder {
+  ASC = "asc",
+  DESC = "desc"
+}
+declare enum Alignment {
+  LEFT = "left",
+  CENTER = "center",
+  RIGHT = "right"
+}
+declare enum FixedDir {
+  LEFT = "left",
+  RIGHT = "right"
+}
+//#endregion
+export { Alignment, FixedDir, SortOrder };

frontend/node_modules/element-plus/es/components/table-v2/src/constants.mjs

@@ -0,0 +1,26 @@
+//#region ../../packages/components/table-v2/src/constants.ts
+let SortOrder = /* @__PURE__ */ function(SortOrder) {
+	SortOrder["ASC"] = "asc";
+	SortOrder["DESC"] = "desc";
+	return SortOrder;
+}({});
+let Alignment = /* @__PURE__ */ function(Alignment) {
+	Alignment["LEFT"] = "left";
+	Alignment["CENTER"] = "center";
+	Alignment["RIGHT"] = "right";
+	return Alignment;
+}({});
+let FixedDir = /* @__PURE__ */ function(FixedDir) {
+	FixedDir["LEFT"] = "left";
+	FixedDir["RIGHT"] = "right";
+	return FixedDir;
+}({});
+const oppositeOrderMap = {
+	[SortOrder.ASC]: SortOrder.DESC,
+	[SortOrder.DESC]: SortOrder.ASC
+};
+const sortOrders = [SortOrder.ASC, SortOrder.DESC];
+
+//#endregion
+export { Alignment, FixedDir, SortOrder, oppositeOrderMap, sortOrders };
+//# sourceMappingURL=constants.mjs.map

frontend/node_modules/element-plus/es/components/table-v2/src/constants.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.mjs","names":[],"sources":["../../../../../../packages/components/table-v2/src/constants.ts"],"sourcesContent":["export enum SortOrder {\n  ASC = 'asc',\n  DESC = 'desc',\n}\n\nexport enum Alignment {\n  LEFT = 'left',\n  CENTER = 'center',\n  RIGHT = 'right',\n}\n\nexport enum FixedDir {\n  LEFT = 'left',\n  RIGHT = 'right',\n}\n\nexport const oppositeOrderMap = {\n  [SortOrder.ASC]: SortOrder.DESC,\n  [SortOrder.DESC]: SortOrder.ASC,\n}\n\nexport const sortOrders = [SortOrder.ASC, SortOrder.DESC] as const\n"],"mappings":";AAAA,IAAY,YAAL;AACL;AACA;;KACD;AAED,IAAY,YAAL;AACL;AACA;AACA;;KACD;AAED,IAAY,WAAL;AACL;AACA;;KACD;AAED,MAAa,mBAAmB;EAC7B,UAAU,MAAM,UAAU;EAC1B,UAAU,OAAO,UAAU;CAC7B;AAED,MAAa,aAAa,CAAC,UAAU,KAAK,UAAU,KAAK"}

frontend/node_modules/element-plus/es/components/table-v2/src/grid.d.ts

@@ -0,0 +1,15 @@
+import "../../../utils/index.js";
+import "../../virtual-list/index.js";
+import "./types.js";
+import "./common.js";
+import { ExtractPropTypes, ExtractPublicPropTypes } from "vue";
+
+//#region ../../packages/components/table-v2/src/grid.d.ts
+type onRowRenderedParams = {
+  rowCacheStart: number;
+  rowCacheEnd: number;
+  rowVisibleStart: number;
+  rowVisibleEnd: number;
+};
+//#endregion
+export { onRowRenderedParams };

frontend/node_modules/element-plus/es/components/table-v2/src/grid.mjs

@@ -0,0 +1,38 @@
+import { buildProps, definePropType } from "../../../utils/vue/props/runtime.mjs";
+import { virtualizedGridProps, virtualizedListProps } from "../../virtual-list/src/props.mjs";
+import { classType, columns, dataType, fixedDataType, requiredNumber, styleType } from "./common.mjs";
+import { tableV2RowProps } from "./row.mjs";
+import { tableV2HeaderProps } from "./header.mjs";
+
+//#region ../../packages/components/table-v2/src/grid.ts
+const tableV2GridProps = buildProps({
+	columns,
+	data: dataType,
+	fixedData: fixedDataType,
+	estimatedRowHeight: tableV2RowProps.estimatedRowHeight,
+	width: requiredNumber,
+	height: requiredNumber,
+	headerWidth: requiredNumber,
+	headerHeight: tableV2HeaderProps.headerHeight,
+	bodyWidth: requiredNumber,
+	rowHeight: requiredNumber,
+	cache: virtualizedListProps.cache,
+	useIsScrolling: Boolean,
+	scrollbarAlwaysOn: virtualizedGridProps.scrollbarAlwaysOn,
+	scrollbarStartGap: virtualizedGridProps.scrollbarStartGap,
+	scrollbarEndGap: virtualizedGridProps.scrollbarEndGap,
+	class: classType,
+	style: styleType,
+	containerStyle: styleType,
+	getRowHeight: {
+		type: definePropType(Function),
+		required: true
+	},
+	rowKey: tableV2RowProps.rowKey,
+	onRowsRendered: { type: definePropType(Function) },
+	onScroll: { type: definePropType(Function) }
+});
+
+//#endregion
+export { tableV2GridProps };
+//# sourceMappingURL=grid.mjs.map

frontend/node_modules/element-plus/es/components/table-v2/src/grid.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"grid.mjs","names":[],"sources":["../../../../../../packages/components/table-v2/src/grid.ts"],"sourcesContent":["import { buildProps, definePropType } from '@element-plus/utils'\nimport {\n  virtualizedGridProps,\n  virtualizedListProps,\n} from '@element-plus/components/virtual-list'\nimport {\n  classType,\n  columns,\n  dataType,\n  fixedDataType,\n  requiredNumber,\n  styleType,\n} from './common'\nimport { tableV2HeaderProps } from './header'\nimport { tableV2RowProps } from './row'\n\nimport type { ExtractPropTypes, ExtractPublicPropTypes } from 'vue'\nimport type { ItemSize } from '@element-plus/components/virtual-list'\n\nexport type onRowRenderedParams = {\n  rowCacheStart: number\n  rowCacheEnd: number\n  rowVisibleStart: number\n  rowVisibleEnd: number\n}\n\nexport const tableV2GridProps = buildProps({\n  columns,\n  data: dataType,\n  fixedData: fixedDataType,\n  estimatedRowHeight: tableV2RowProps.estimatedRowHeight,\n\n  /**\n   * Size related attributes\n   */\n  width: requiredNumber,\n  height: requiredNumber,\n\n  headerWidth: requiredNumber,\n  headerHeight: tableV2HeaderProps.headerHeight,\n\n  bodyWidth: requiredNumber,\n  rowHeight: requiredNumber,\n\n  /**\n   * Special attributes\n   */\n  cache: virtualizedListProps.cache,\n  useIsScrolling: Boolean,\n  scrollbarAlwaysOn: virtualizedGridProps.scrollbarAlwaysOn,\n  scrollbarStartGap: virtualizedGridProps.scrollbarStartGap,\n  scrollbarEndGap: virtualizedGridProps.scrollbarEndGap,\n\n  /**\n   * CSS attributes\n   */\n  class: classType,\n  style: styleType,\n  containerStyle: styleType,\n\n  getRowHeight: {\n    type: definePropType<ItemSize>(Function),\n    required: true,\n  },\n  rowKey: tableV2RowProps.rowKey,\n\n  /**\n   * Event handlers\n   */\n  onRowsRendered: {\n    type: definePropType<(params: onRowRenderedParams) => void>(Function),\n  },\n  onScroll: {\n    type: definePropType<(...args: any[]) => void>(Function),\n  },\n} as const)\n\nexport type TableV2GridProps = ExtractPropTypes<typeof tableV2GridProps>\nexport type TableV2GridPropsPublic = ExtractPublicPropTypes<\n  typeof tableV2GridProps\n>\n"],"mappings":";;;;;;;AA0BA,MAAa,mBAAmB,WAAW;CACzC;CACA,MAAM;CACN,WAAW;CACX,oBAAoB,gBAAgB;CAKpC,OAAO;CACP,QAAQ;CAER,aAAa;CACb,cAAc,mBAAmB;CAEjC,WAAW;CACX,WAAW;CAKX,OAAO,qBAAqB;CAC5B,gBAAgB;CAChB,mBAAmB,qBAAqB;CACxC,mBAAmB,qBAAqB;CACxC,iBAAiB,qBAAqB;CAKtC,OAAO;CACP,OAAO;CACP,gBAAgB;CAEhB,cAAc;EACZ,MAAM,eAAyB,SAAS;EACxC,UAAU;EACX;CACD,QAAQ,gBAAgB;CAKxB,gBAAgB,EACd,MAAM,eAAsD,SAAS,EACtE;CACD,UAAU,EACR,MAAM,eAAyC,SAAS,EACzD;CACF,CAAU"}

frontend/node_modules/element-plus/es/components/table-v2/src/header-cell.d.ts

@@ -0,0 +1,18 @@
+import { AnyColumn } from "./common.js";
+import * as vue from "vue";
+import { ExtractPropTypes, ExtractPublicPropTypes } from "vue";
+
+//#region ../../packages/components/table-v2/src/header-cell.d.ts
+declare const tableV2HeaderCell: {
+  class: StringConstructor;
+  columnIndex: NumberConstructor;
+  column: {
+    readonly type: vue.PropType<AnyColumn>;
+    readonly required: false;
+    readonly validator: ((val: unknown) => boolean) | undefined;
+    __epPropKey: true;
+  };
+};
+type TableV2HeaderCell = ExtractPropTypes<typeof tableV2HeaderCell>;
+//#endregion
+export { TableV2HeaderCell };

frontend/node_modules/element-plus/es/components/table-v2/src/header-cell.mjs

@@ -0,0 +1,13 @@
+import { buildProps } from "../../../utils/vue/props/runtime.mjs";
+import { classType, column } from "./common.mjs";
+
+//#region ../../packages/components/table-v2/src/header-cell.ts
+const tableV2HeaderCell = buildProps({
+	class: classType,
+	columnIndex: Number,
+	column
+});
+
+//#endregion
+export { tableV2HeaderCell };
+//# sourceMappingURL=header-cell.mjs.map

frontend/node_modules/element-plus/es/components/table-v2/src/header-cell.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"header-cell.mjs","names":[],"sources":["../../../../../../packages/components/table-v2/src/header-cell.ts"],"sourcesContent":["import { buildProps } from '@element-plus/utils'\nimport { classType, column } from './common'\n\nimport type { ExtractPropTypes, ExtractPublicPropTypes } from 'vue'\n\nexport const tableV2HeaderCell = buildProps({\n  class: classType,\n  columnIndex: Number,\n  column,\n})\n\nexport type TableV2HeaderCell = ExtractPropTypes<typeof tableV2HeaderCell>\nexport type TableV2HeaderCellPublic = ExtractPublicPropTypes<\n  typeof tableV2HeaderCell\n>\n"],"mappings":";;;;AAKA,MAAa,oBAAoB,WAAW;CAC1C,OAAO;CACP,aAAa;CACb;CACD,CAAC"}

frontend/node_modules/element-plus/es/components/table-v2/src/header-row.d.ts

@@ -0,0 +1,31 @@
+import { KeyType } from "./types.js";
+import { AnyColumn } from "./common.js";
+import * as vue from "vue";
+import { CSSProperties, ExtractPropTypes, ExtractPublicPropTypes } from "vue";
+
+//#region ../../packages/components/table-v2/src/header-row.d.ts
+declare const tableV2HeaderRowProps: {
+  readonly class: StringConstructor;
+  readonly columns: {
+    readonly type: vue.PropType<AnyColumn[]>;
+    readonly required: true;
+    readonly validator: ((val: unknown) => boolean) | undefined;
+    __epPropKey: true;
+  };
+  readonly columnsStyles: {
+    readonly type: vue.PropType<Record<KeyType, CSSProperties>>;
+    readonly required: true;
+    readonly validator: ((val: unknown) => boolean) | undefined;
+    __epPropKey: true;
+  };
+  readonly headerIndex: NumberConstructor;
+  readonly style: {
+    readonly type: vue.PropType<CSSProperties>;
+    readonly required: false;
+    readonly validator: ((val: unknown) => boolean) | undefined;
+    __epPropKey: true;
+  };
+};
+type TableV2HeaderRowProps = ExtractPropTypes<typeof tableV2HeaderRowProps>;
+//#endregion
+export { TableV2HeaderRowProps };

frontend/node_modules/element-plus/es/components/table-v2/src/header-row.mjs

@@ -0,0 +1,18 @@
+import { buildProps, definePropType } from "../../../utils/vue/props/runtime.mjs";
+import { columns } from "./common.mjs";
+
+//#region ../../packages/components/table-v2/src/header-row.ts
+const tableV2HeaderRowProps = buildProps({
+	class: String,
+	columns,
+	columnsStyles: {
+		type: definePropType(Object),
+		required: true
+	},
+	headerIndex: Number,
+	style: { type: definePropType(Object) }
+});
+
+//#endregion
+export { tableV2HeaderRowProps };
+//# sourceMappingURL=header-row.mjs.map

frontend/node_modules/element-plus/es/components/table-v2/src/header-row.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"header-row.mjs","names":[],"sources":["../../../../../../packages/components/table-v2/src/header-row.ts"],"sourcesContent":["import { buildProps, definePropType } from '@element-plus/utils'\nimport { columns } from './common'\n\nimport type {\n  CSSProperties,\n  ExtractPropTypes,\n  ExtractPublicPropTypes,\n} from 'vue'\nimport type { KeyType } from './types'\n\nexport const tableV2HeaderRowProps = buildProps({\n  class: String,\n  columns,\n  columnsStyles: {\n    type: definePropType<Record<KeyType, CSSProperties>>(Object),\n    required: true,\n  },\n  headerIndex: Number,\n  style: { type: definePropType<CSSProperties>(Object) },\n} as const)\n\nexport type TableV2HeaderRowProps = ExtractPropTypes<\n  typeof tableV2HeaderRowProps\n>\nexport type TableV2HeaderRowPropsPublic = ExtractPublicPropTypes<\n  typeof tableV2HeaderRowProps\n>\n"],"mappings":";;;;AAUA,MAAa,wBAAwB,WAAW;CAC9C,OAAO;CACP;CACA,eAAe;EACb,MAAM,eAA+C,OAAO;EAC5D,UAAU;EACX;CACD,aAAa;CACb,OAAO,EAAE,MAAM,eAA8B,OAAO,EAAE;CACvD,CAAU"}

frontend/node_modules/element-plus/es/components/table-v2/src/header.d.ts

@@ -0,0 +1,51 @@
+import { EpPropFinalized } from "../../../utils/vue/props/types.js";
+import "../../../utils/index.js";
+import { AnyColumn } from "./common.js";
+import * as vue from "vue";
+import { ExtractPropTypes, ExtractPublicPropTypes } from "vue";
+
+//#region ../../packages/components/table-v2/src/header.d.ts
+declare const tableV2HeaderProps: {
+  readonly class: StringConstructor;
+  readonly columns: {
+    readonly type: vue.PropType<AnyColumn[]>;
+    readonly required: true;
+    readonly validator: ((val: unknown) => boolean) | undefined;
+    __epPropKey: true;
+  };
+  readonly fixedHeaderData: {
+    readonly type: vue.PropType<any[]>;
+    readonly required: false;
+    readonly validator: ((val: unknown) => boolean) | undefined;
+    __epPropKey: true;
+  };
+  readonly headerData: {
+    readonly type: vue.PropType<any[]>;
+    readonly required: true;
+    readonly validator: ((val: unknown) => boolean) | undefined;
+    __epPropKey: true;
+  };
+  readonly headerHeight: EpPropFinalized<(new (...args: any[]) => number | number[]) | (() => number | number[]) | (((new (...args: any[]) => number | number[]) | (() => number | number[])) | null)[], unknown, unknown, 50, boolean>;
+  readonly rowWidth: {
+    readonly type: vue.PropType<number>;
+    readonly required: true;
+    readonly validator: ((val: unknown) => boolean) | undefined;
+    __epPropKey: true;
+  };
+  readonly rowHeight: EpPropFinalized<NumberConstructor, unknown, unknown, 50, boolean>;
+  readonly height: {
+    readonly type: vue.PropType<number>;
+    readonly required: true;
+    readonly validator: ((val: unknown) => boolean) | undefined;
+    __epPropKey: true;
+  };
+  readonly width: {
+    readonly type: vue.PropType<number>;
+    readonly required: true;
+    readonly validator: ((val: unknown) => boolean) | undefined;
+    __epPropKey: true;
+  };
+};
+type TableV2HeaderProps = ExtractPropTypes<typeof tableV2HeaderProps>;
+//#endregion
+export { TableV2HeaderProps };

frontend/node_modules/element-plus/es/components/table-v2/src/header.mjs

@@ -0,0 +1,32 @@
+import { buildProps, definePropType } from "../../../utils/vue/props/runtime.mjs";
+import { columns } from "./common.mjs";
+
+//#region ../../packages/components/table-v2/src/header.ts
+const requiredNumberType = {
+	type: Number,
+	required: true
+};
+const tableV2HeaderProps = buildProps({
+	class: String,
+	columns,
+	fixedHeaderData: { type: definePropType(Array) },
+	headerData: {
+		type: definePropType(Array),
+		required: true
+	},
+	headerHeight: {
+		type: definePropType([Number, Array]),
+		default: 50
+	},
+	rowWidth: requiredNumberType,
+	rowHeight: {
+		type: Number,
+		default: 50
+	},
+	height: requiredNumberType,
+	width: requiredNumberType
+});
+
+//#endregion
+export { tableV2HeaderProps };
+//# sourceMappingURL=header.mjs.map

frontend/node_modules/element-plus/es/components/table-v2/src/header.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"header.mjs","names":[],"sources":["../../../../../../packages/components/table-v2/src/header.ts"],"sourcesContent":["import { buildProps, definePropType } from '@element-plus/utils'\nimport { columns } from './common'\n\nimport type { ExtractPropTypes, ExtractPublicPropTypes } from 'vue'\n\nconst requiredNumberType = {\n  type: Number,\n  required: true,\n} as const\n\nexport const tableV2HeaderProps = buildProps({\n  class: String,\n  columns,\n  fixedHeaderData: {\n    type: definePropType<any[]>(Array),\n  },\n  headerData: {\n    type: definePropType<any[]>(Array),\n    required: true,\n  },\n  headerHeight: {\n    type: definePropType<number | number[]>([Number, Array]),\n    default: 50,\n  },\n  rowWidth: requiredNumberType,\n  rowHeight: {\n    type: Number,\n    default: 50,\n  },\n  height: requiredNumberType,\n  width: requiredNumberType,\n} as const)\n\nexport type TableV2HeaderProps = ExtractPropTypes<typeof tableV2HeaderProps>\nexport type TableV2HeaderPropsPublic = ExtractPublicPropTypes<\n  typeof tableV2HeaderProps\n>\n"],"mappings":";;;;AAKA,MAAM,qBAAqB;CACzB,MAAM;CACN,UAAU;CACX;AAED,MAAa,qBAAqB,WAAW;CAC3C,OAAO;CACP;CACA,iBAAiB,EACf,MAAM,eAAsB,MAAM,EACnC;CACD,YAAY;EACV,MAAM,eAAsB,MAAM;EAClC,UAAU;EACX;CACD,cAAc;EACZ,MAAM,eAAkC,CAAC,QAAQ,MAAM,CAAC;EACxD,SAAS;EACV;CACD,UAAU;CACV,WAAW;EACT,MAAM;EACN,SAAS;EACV;CACD,QAAQ;CACR,OAAO;CACR,CAAU"}

frontend/node_modules/element-plus/es/components/table-v2/src/private.d.ts

@@ -0,0 +1,4 @@
+//#region ../../packages/components/table-v2/src/private.d.ts
+declare const placeholderSign: unique symbol;
+//#endregion
+export { placeholderSign };

frontend/node_modules/element-plus/es/components/table-v2/src/private.mjs

@@ -0,0 +1,6 @@
+//#region ../../packages/components/table-v2/src/private.ts
+const placeholderSign = Symbol("placeholder");
+
+//#endregion
+export { placeholderSign };
+//# sourceMappingURL=private.mjs.map

frontend/node_modules/element-plus/es/components/table-v2/src/private.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"private.mjs","names":[],"sources":["../../../../../../packages/components/table-v2/src/private.ts"],"sourcesContent":["export const placeholderSign = Symbol('placeholder')\n"],"mappings":";AAAA,MAAa,kBAAkB,OAAO,cAAc"}

frontend/node_modules/element-plus/es/components/table-v2/src/renderers/cell.mjs

@@ -0,0 +1,73 @@
+import { isFunction, isObject } from "../../../../utils/types.mjs";
+import { Alignment } from "../constants.mjs";
+import { placeholderSign } from "../private.mjs";
+import { componentToSlot, enforceUnit, tryCall } from "../utils.mjs";
+import TableV2Cell from "../components/cell.mjs";
+import ExpandIcon from "../components/expand-icon.mjs";
+import { get } from "lodash-unified";
+import { createVNode, mergeProps, renderSlot } from "vue";
+
+//#region ../../packages/components/table-v2/src/renderers/cell.tsx
+const CellRenderer = ({ columns, column, columnIndex, depth, expandIconProps, isScrolling, rowData, rowIndex, style, expandedRowKeys, ns, t, cellProps: _cellProps, expandColumnKey, indentSize, iconSize, rowKey }, { slots }) => {
+	const cellStyle = enforceUnit(style);
+	if (column.placeholderSign === placeholderSign) return createVNode("div", {
+		"class": ns.em("row-cell", "placeholder"),
+		"style": cellStyle
+	}, null);
+	const { cellRenderer, dataKey, dataGetter } = column;
+	const cellData = isFunction(dataGetter) ? dataGetter({
+		columns,
+		column,
+		columnIndex,
+		rowData,
+		rowIndex
+	}) : get(rowData, dataKey ?? "");
+	const extraCellProps = tryCall(_cellProps, {
+		cellData,
+		columns,
+		column,
+		columnIndex,
+		rowIndex,
+		rowData
+	});
+	const cellProps = {
+		class: ns.e("cell-text"),
+		columns,
+		column,
+		columnIndex,
+		cellData,
+		isScrolling,
+		rowData,
+		rowIndex
+	};
+	const columnCellRenderer = componentToSlot(cellRenderer);
+	const Cell = columnCellRenderer ? columnCellRenderer(cellProps) : renderSlot(slots, "default", cellProps, () => [createVNode(TableV2Cell, cellProps, null)]);
+	const kls = [
+		ns.e("row-cell"),
+		column.class,
+		column.align === Alignment.CENTER && ns.is("align-center"),
+		column.align === Alignment.RIGHT && ns.is("align-right")
+	];
+	const expandable = rowIndex >= 0 && expandColumnKey && column.key === expandColumnKey;
+	const expanded = rowIndex >= 0 && expandedRowKeys.includes(rowData[rowKey]);
+	let IconOrPlaceholder;
+	const iconStyle = `margin-inline-start: ${depth * indentSize}px;`;
+	if (expandable) if (isObject(expandIconProps)) IconOrPlaceholder = createVNode(ExpandIcon, mergeProps(expandIconProps, {
+		"class": [ns.e("expand-icon"), ns.is("expanded", expanded)],
+		"size": iconSize,
+		"expanded": expanded,
+		"ariaLabel": t(expanded ? "el.table.collapseRowLabel" : "el.table.expandRowLabel"),
+		"style": iconStyle,
+		"expandable": true
+	}), null);
+	else IconOrPlaceholder = createVNode("div", { "style": [iconStyle, `width: ${iconSize}px; height: ${iconSize}px;`].join(" ") }, null);
+	return createVNode("div", mergeProps({
+		"class": kls,
+		"style": cellStyle
+	}, extraCellProps, { "role": "cell" }), [IconOrPlaceholder, Cell]);
+};
+CellRenderer.inheritAttrs = false;
+
+//#endregion
+export { CellRenderer as default };
+//# sourceMappingURL=cell.mjs.map

frontend/node_modules/element-plus/es/components/table-v2/src/renderers/empty.mjs

@@ -0,0 +1,16 @@
+import { ElEmpty } from "../../../empty/index.mjs";
+import { createVNode, renderSlot } from "vue";
+
+//#region ../../packages/components/table-v2/src/renderers/empty.tsx
+const Footer = (props, { slots }) => {
+	const defaultSlot = renderSlot(slots, "default", {}, () => [createVNode(ElEmpty, null, null)]);
+	return createVNode("div", {
+		"class": props.class,
+		"style": props.style
+	}, [defaultSlot]);
+};
+Footer.displayName = "ElTableV2Empty";
+
+//#endregion
+export { Footer as default };
+//# sourceMappingURL=empty.mjs.map

frontend/node_modules/element-plus/es/components/table-v2/src/renderers/empty.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"empty.mjs","names":["renderSlot","createVNode","_createVNode","ElEmpty","Footer","props","slots","defaultSlot","class","style","displayName"],"sources":["../../../../../../../packages/components/table-v2/src/renderers/empty.tsx"],"sourcesContent":["import { renderSlot } from 'vue'\nimport ElEmpty from '@element-plus/components/empty'\n\nimport type { CSSProperties, FunctionalComponent } from 'vue'\n\ntype EmptyRendererProps = {\n  class?: JSX.IntrinsicAttributes['class']\n  style?: CSSProperties\n}\n\nconst Footer: FunctionalComponent<EmptyRendererProps> = (props, { slots }) => {\n  const defaultSlot = renderSlot(slots, 'default', {}, () => [<ElEmpty />])\n  return (\n    <div class={props.class} style={props.style}>\n      {defaultSlot}\n    </div>\n  )\n}\n\nFooter.displayName = 'ElTableV2Empty'\n\nexport default Footer\n"],"mappings":";;;;AAUA,MAAMI,UAAmDC,OAAO,EAAEC,YAAY;CAC5E,MAAMC,cAAcP,WAAWM,OAAO,WAAW,EAAE,QAAQ,CAAAJ,YAAAC,SAAA,MAAA,KAAA,CAAa,CAAC;AACzE,QAAAD,YAAA,OAAA;EAAA,SACcG,MAAMG;EAAK,SAASH,MAAMI;EAAK,EAAA,CACxCF,YAAW,CAAA;;AAKlBH,OAAOM,cAAc"}

frontend/node_modules/element-plus/es/components/table-v2/src/renderers/footer.mjs

@@ -0,0 +1,14 @@
+import { createVNode } from "vue";
+
+//#region ../../packages/components/table-v2/src/renderers/footer.tsx
+const Footer = (props, { slots }) => {
+	return createVNode("div", {
+		"class": props.class,
+		"style": props.style
+	}, [slots.default?.()]);
+};
+Footer.displayName = "ElTableV2Footer";
+
+//#endregion
+export { Footer as default };
+//# sourceMappingURL=footer.mjs.map

frontend/node_modules/element-plus/es/components/table-v2/src/renderers/footer.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"footer.mjs","names":["Footer","props","slots","_createVNode","class","style","default","displayName"],"sources":["../../../../../../../packages/components/table-v2/src/renderers/footer.tsx"],"sourcesContent":["import type { CSSProperties, FunctionalComponent } from 'vue'\n\ntype FooterRendererProps = {\n  class?: JSX.IntrinsicAttributes['class']\n  style: CSSProperties\n}\n\nconst Footer: FunctionalComponent<FooterRendererProps> = (props, { slots }) => {\n  return (\n    <div class={props.class} style={props.style}>\n      {slots.default?.()}\n    </div>\n  )\n}\n\nFooter.displayName = 'ElTableV2Footer'\n\nexport default Footer\n"],"mappings":";;;AAOA,MAAMA,UAAoDC,OAAO,EAAEC,YAAY;AAC7E,QAAAC,YAAA,OAAA;EAAA,SACcF,MAAMG;EAAK,SAASH,MAAMI;EAAK,EAAA,CACxCH,MAAMI,WAAW,CAAA,CAAA;;AAKxBN,OAAOO,cAAc"}

frontend/node_modules/element-plus/es/components/table-v2/src/renderers/header-cell.d.ts

@@ -0,0 +1,19 @@
+import { Translator } from "../../../../hooks/use-locale/index.js";
+import { UseNamespaceReturn } from "../../../../hooks/use-namespace/index.js";
+import "../../../../hooks/index.js";
+import { TableV2Props } from "../table.js";
+import { TableV2HeaderRowCellRendererParams } from "../components/header-row.js";
+import "../components/index.js";
+import { UseTableReturn } from "../use-table.js";
+import { FunctionalComponent, UnwrapNestedRefs } from "vue";
+
+//#region ../../packages/components/table-v2/src/renderers/header-cell.d.ts
+type HeaderCellRendererProps = TableV2HeaderRowCellRendererParams & UnwrapNestedRefs<Pick<UseTableReturn, 'onColumnSorted'>> & Pick<TableV2Props, 'sortBy' | 'sortState' | 'headerCellProps'> & {
+  ns: UseNamespaceReturn;
+  t: Translator;
+};
+type HeaderCellSlotProps = HeaderCellRendererProps & {
+  class: string;
+};
+//#endregion
+export { HeaderCellSlotProps };

frontend/node_modules/element-plus/es/components/table-v2/src/renderers/header-cell.mjs

@@ -0,0 +1,65 @@
+import { Alignment, SortOrder, oppositeOrderMap } from "../constants.mjs";
+import { placeholderSign } from "../private.mjs";
+import { componentToSlot, enforceUnit, tryCall } from "../utils.mjs";
+import HeaderCell from "../components/header-cell.mjs";
+import SortIcon from "../components/sort-icon.mjs";
+import { createVNode, mergeProps, renderSlot } from "vue";
+
+//#region ../../packages/components/table-v2/src/renderers/header-cell.tsx
+const HeaderCellRenderer = (props, { slots }) => {
+	const { column, ns, t, style, onColumnSorted } = props;
+	const cellStyle = enforceUnit(style);
+	if (column.placeholderSign === placeholderSign) return createVNode("div", {
+		"class": ns.em("header-row-cell", "placeholder"),
+		"style": cellStyle
+	}, null);
+	const { headerCellRenderer, headerClass, sortable } = column;
+	/**
+	* render Cell children
+	*/
+	const cellProps = {
+		...props,
+		class: ns.e("header-cell-text")
+	};
+	const columnCellRenderer = componentToSlot(headerCellRenderer);
+	const Cell = columnCellRenderer ? columnCellRenderer(cellProps) : renderSlot(slots, "default", cellProps, () => [createVNode(HeaderCell, cellProps, null)]);
+	/**
+	* Render cell container and sort indicator
+	*/
+	const { sortBy, sortState, headerCellProps } = props;
+	let sorting, sortOrder, ariaSort;
+	if (sortState) {
+		const order = sortState[column.key];
+		sorting = Boolean(oppositeOrderMap[order]);
+		sortOrder = sorting ? order : SortOrder.ASC;
+	} else {
+		sorting = column.key === sortBy.key;
+		sortOrder = sorting ? sortBy.order : SortOrder.ASC;
+	}
+	if (sortOrder === SortOrder.ASC) ariaSort = "ascending";
+	else if (sortOrder === SortOrder.DESC) ariaSort = "descending";
+	else ariaSort = void 0;
+	const cellKls = [
+		ns.e("header-cell"),
+		tryCall(headerClass, props, ""),
+		column.align === Alignment.CENTER && ns.is("align-center"),
+		column.align === Alignment.RIGHT && ns.is("align-right"),
+		sortable && ns.is("sortable")
+	];
+	return createVNode("div", mergeProps({
+		...tryCall(headerCellProps, props),
+		onClick: column.sortable ? onColumnSorted : void 0,
+		ariaSort: sortable ? ariaSort : void 0,
+		class: cellKls,
+		style: cellStyle,
+		["data-key"]: column.key
+	}, { "role": "columnheader" }), [Cell, sortable && createVNode(SortIcon, {
+		"class": [ns.e("sort-icon"), sorting && ns.is("sorting")],
+		"sortOrder": sortOrder,
+		"ariaLabel": t("el.table.sortLabel", { column: column.title || "" })
+	}, null)]);
+};
+
+//#endregion
+export { HeaderCellRenderer as default };
+//# sourceMappingURL=header-cell.mjs.map

frontend/node_modules/element-plus/es/components/table-v2/src/renderers/header.mjs

@@ -0,0 +1,31 @@
+import { tryCall } from "../utils.mjs";
+import TableV2HeaderRow from "../components/header-row.mjs";
+import { createVNode, isVNode } from "vue";
+
+//#region ../../packages/components/table-v2/src/renderers/header.tsx
+function _isSlot(s) {
+	return typeof s === "function" || Object.prototype.toString.call(s) === "[object Object]" && !isVNode(s);
+}
+const HeaderRenderer = ({ columns, columnsStyles, headerIndex, style, headerClass, headerProps, ns }, { slots }) => {
+	const param = {
+		columns,
+		headerIndex
+	};
+	const kls = [
+		ns.e("header-row"),
+		tryCall(headerClass, param, ""),
+		ns.is("customized", Boolean(slots.header))
+	];
+	return createVNode(TableV2HeaderRow, {
+		...tryCall(headerProps, param),
+		columnsStyles,
+		class: kls,
+		columns,
+		headerIndex,
+		style
+	}, _isSlot(slots) ? slots : { default: () => [slots] });
+};
+
+//#endregion
+export { HeaderRenderer as default };
+//# sourceMappingURL=header.mjs.map

frontend/node_modules/element-plus/es/components/table-v2/src/renderers/header.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"header.mjs","names":["HeaderRow","tryCall","_isSlot","s","Object","prototype","toString","call","_isVNode","HeaderRenderer","columns","columnsStyles","headerIndex","style","headerClass","headerProps","ns","slots","param","kls","e","is","Boolean","header","extraProps","class","_createVNode","default"],"sources":["../../../../../../../packages/components/table-v2/src/renderers/header.tsx"],"sourcesContent":["import { HeaderRow } from '../components'\nimport { tryCall } from '../utils'\n\nimport type { FunctionalComponent } from 'vue'\nimport type { UseNamespaceReturn } from '@element-plus/hooks'\nimport type { TableV2HeaderRendererParams } from '../components'\nimport type { TableV2Props } from '../table'\n\ntype HeaderRendererProps = TableV2HeaderRendererParams &\n  Pick<TableV2Props, 'headerClass' | 'headerProps'> & {\n    ns: UseNamespaceReturn\n  }\n\nconst HeaderRenderer: FunctionalComponent<HeaderRendererProps> = (\n  {\n    columns,\n    columnsStyles,\n    headerIndex,\n    style,\n    // derived from root\n    headerClass,\n    headerProps,\n\n    ns,\n  },\n  { slots }\n) => {\n  const param = { columns, headerIndex }\n\n  const kls = [\n    ns.e('header-row'),\n    tryCall(headerClass, param, ''),\n    ns.is('customized', Boolean(slots.header)),\n  ]\n\n  const extraProps = {\n    ...tryCall(headerProps, param),\n    columnsStyles,\n    class: kls,\n    columns,\n    headerIndex,\n    style,\n  }\n\n  return <HeaderRow {...extraProps}>{slots}</HeaderRow>\n}\n\nexport default HeaderRenderer\n"],"mappings":";;;;;AACkC,SAAAE,QAAAC,GAAA;AAAA,QAAA,OAAAA,MAAA,cAAAC,OAAAC,UAAAC,SAAAC,KAAAJ,EAAA,KAAA,qBAAA,CAAAK,QAAAL,EAAA;;AAYlC,MAAMM,kBACJ,EACEC,SACAC,eACAC,aACAC,OAEAC,aACAC,aAEAC,MAEF,EAAEC,YACC;CACH,MAAMC,QAAQ;EAAER;EAASE;EAAa;CAEtC,MAAMO,MAAM;EACVH,GAAGI,EAAE,aAAa;EAClBnB,QAAQa,aAAaI,OAAO,GAAG;EAC/BF,GAAGK,GAAG,cAAcC,QAAQL,MAAMM,OAAO,CAAC;EAC3C;AAWD,QAAAG,YAAA1B,kBATmB;EACjB,GAAGC,QAAQc,aAAaG,MAAM;EAC9BP;EACAc,OAAON;EACPT;EACAE;EACAC;EACD,EAE+BX,QAAGe,MAAK,GAALA,QAAK,EAAAU,eAAA,CAALV,MAAK,EAAA,CAAA"}

frontend/node_modules/element-plus/es/components/table-v2/src/renderers/left-table.mjs

@@ -0,0 +1,16 @@
+import TableGrid from "../table-grid.mjs";
+import { createVNode, isVNode, mergeProps } from "vue";
+
+//#region ../../packages/components/table-v2/src/renderers/left-table.tsx
+function _isSlot(s) {
+	return typeof s === "function" || Object.prototype.toString.call(s) === "[object Object]" && !isVNode(s);
+}
+const LeftTable = (props, { slots }) => {
+	if (!props.columns.length) return;
+	const { leftTableRef, ...rest } = props;
+	return createVNode(TableGrid, mergeProps({ "ref": leftTableRef }, rest), _isSlot(slots) ? slots : { default: () => [slots] });
+};
+
+//#endregion
+export { LeftTable as default };
+//# sourceMappingURL=left-table.mjs.map

frontend/node_modules/element-plus/es/components/table-v2/src/renderers/left-table.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"left-table.mjs","names":["Table","_isSlot","s","Object","prototype","toString","call","_isVNode","LeftTable","props","slots","columns","length","leftTableRef","rest","_createVNode","_mergeProps","default"],"sources":["../../../../../../../packages/components/table-v2/src/renderers/left-table.tsx"],"sourcesContent":["import Table from '../table-grid'\n\nimport type { FunctionalComponent, Ref } from 'vue'\nimport type { TableV2GridProps } from '../grid'\nimport type { TableGridInstance } from '../table-grid'\n\ntype LeftTableProps = TableV2GridProps & {\n  leftTableRef: Ref<TableGridInstance | undefined>\n}\n\nconst LeftTable: FunctionalComponent<LeftTableProps> = (props, { slots }) => {\n  if (!props.columns.length) return\n\n  const { leftTableRef, ...rest } = props\n\n  return (\n    <Table ref={leftTableRef} {...rest}>\n      {slots}\n    </Table>\n  )\n}\n\nexport default LeftTable\n"],"mappings":";;;;AAAiC,SAAAC,QAAAC,GAAA;AAAA,QAAA,OAAAA,MAAA,cAAAC,OAAAC,UAAAC,SAAAC,KAAAJ,EAAA,KAAA,qBAAA,CAAAK,QAAAL,EAAA;;AAUjC,MAAMM,aAAkDC,OAAO,EAAEC,YAAY;AAC3E,KAAI,CAACD,MAAME,QAAQC,OAAQ;CAE3B,MAAM,EAAEC,cAAc,GAAGC,SAASL;AAElC,QAAAM,YAAAf,WAAAgB,WAAA,EAAA,OACcH,cAAY,EAAMC,KAAI,EAAAb,QAC/BS,MAAK,GAALA,QAAK,EAAAO,eAAA,CAALP,MAAK,EAAA,CAAA"}

frontend/node_modules/element-plus/es/components/table-v2/src/renderers/main-table.mjs

@@ -0,0 +1,15 @@
+import TableGrid from "../table-grid.mjs";
+import { createVNode, isVNode, mergeProps } from "vue";
+
+//#region ../../packages/components/table-v2/src/renderers/main-table.tsx
+function _isSlot(s) {
+	return typeof s === "function" || Object.prototype.toString.call(s) === "[object Object]" && !isVNode(s);
+}
+const MainTable = (props, { slots }) => {
+	const { mainTableRef, ...rest } = props;
+	return createVNode(TableGrid, mergeProps({ "ref": mainTableRef }, rest), _isSlot(slots) ? slots : { default: () => [slots] });
+};
+
+//#endregion
+export { MainTable as default };
+//# sourceMappingURL=main-table.mjs.map

frontend/node_modules/element-plus/es/components/table-v2/src/renderers/main-table.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"main-table.mjs","names":["Table","_isSlot","s","Object","prototype","toString","call","_isVNode","MainTable","props","slots","mainTableRef","rest","_createVNode","_mergeProps","default"],"sources":["../../../../../../../packages/components/table-v2/src/renderers/main-table.tsx"],"sourcesContent":["import Table from '../table-grid'\n\nimport type { FunctionalComponent, Ref } from 'vue'\nimport type { TableV2GridProps } from '../grid'\nimport type { TableGridInstance } from '../table-grid'\n\nexport type MainTableRendererProps = TableV2GridProps & {\n  mainTableRef: Ref<TableGridInstance | undefined>\n}\n\nconst MainTable: FunctionalComponent<MainTableRendererProps> = (\n  props: MainTableRendererProps,\n  { slots }\n) => {\n  const { mainTableRef, ...rest } = props\n  return (\n    <Table ref={mainTableRef} {...rest}>\n      {slots}\n    </Table>\n  )\n}\n\nexport default MainTable\n"],"mappings":";;;;AAAiC,SAAAC,QAAAC,GAAA;AAAA,QAAA,OAAAA,MAAA,cAAAC,OAAAC,UAAAC,SAAAC,KAAAJ,EAAA,KAAA,qBAAA,CAAAK,QAAAL,EAAA;;AAUjC,MAAMM,aACJC,OACA,EAAEC,YACC;CACH,MAAM,EAAEC,cAAc,GAAGC,SAASH;AAClC,QAAAI,YAAAb,WAAAc,WAAA,EAAA,OACcH,cAAY,EAAMC,KAAI,EAAAX,QAC/BS,MAAK,GAALA,QAAK,EAAAK,eAAA,CAALL,MAAK,EAAA,CAAA"}

frontend/node_modules/element-plus/es/components/table-v2/src/renderers/overlay.mjs

@@ -0,0 +1,14 @@
+import { createVNode } from "vue";
+
+//#region ../../packages/components/table-v2/src/renderers/overlay.tsx
+const Overlay = (props, { slots }) => {
+	return createVNode("div", {
+		"class": props.class,
+		"style": props.style
+	}, [slots.default?.()]);
+};
+Overlay.displayName = "ElTableV2Overlay";
+
+//#endregion
+export { Overlay as default };
+//# sourceMappingURL=overlay.mjs.map

frontend/node_modules/element-plus/es/components/table-v2/src/renderers/overlay.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"overlay.mjs","names":["Overlay","props","slots","_createVNode","class","style","default","displayName"],"sources":["../../../../../../../packages/components/table-v2/src/renderers/overlay.tsx"],"sourcesContent":["import type { SimpleFunctionalComponent } from '../types'\n\nconst Overlay: SimpleFunctionalComponent = (props, { slots }) => {\n  return (\n    <div class={props.class} style={props.style}>\n      {slots.default?.()}\n    </div>\n  )\n}\n\nOverlay.displayName = 'ElTableV2Overlay'\n\nexport default Overlay\n"],"mappings":";;;AAEA,MAAMA,WAAsCC,OAAO,EAAEC,YAAY;AAC/D,QAAAC,YAAA,OAAA;EAAA,SACcF,MAAMG;EAAK,SAASH,MAAMI;EAAK,EAAA,CACxCH,MAAMI,WAAW,CAAA,CAAA;;AAKxBN,QAAQO,cAAc"}

frontend/node_modules/element-plus/es/components/table-v2/src/renderers/right-table.mjs

@@ -0,0 +1,16 @@
+import TableGrid from "../table-grid.mjs";
+import { createVNode, isVNode, mergeProps } from "vue";
+
+//#region ../../packages/components/table-v2/src/renderers/right-table.tsx
+function _isSlot(s) {
+	return typeof s === "function" || Object.prototype.toString.call(s) === "[object Object]" && !isVNode(s);
+}
+const RightTable = (props, { slots }) => {
+	if (!props.columns.length) return;
+	const { rightTableRef, ...rest } = props;
+	return createVNode(TableGrid, mergeProps({ "ref": rightTableRef }, rest), _isSlot(slots) ? slots : { default: () => [slots] });
+};
+
+//#endregion
+export { RightTable as default };
+//# sourceMappingURL=right-table.mjs.map

frontend/node_modules/element-plus/es/components/table-v2/src/renderers/right-table.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"right-table.mjs","names":["Table","_isSlot","s","Object","prototype","toString","call","_isVNode","RightTable","props","slots","columns","length","rightTableRef","rest","_createVNode","_mergeProps","default"],"sources":["../../../../../../../packages/components/table-v2/src/renderers/right-table.tsx"],"sourcesContent":["import Table from '../table-grid'\n\nimport type { FunctionalComponent, Ref } from 'vue'\nimport type { TableV2GridProps } from '../grid'\nimport type { TableGridInstance } from '../table-grid'\n\ntype RightTableProps = TableV2GridProps & {\n  rightTableRef: Ref<TableGridInstance | undefined>\n}\n\nconst RightTable: FunctionalComponent<RightTableProps> = (props, { slots }) => {\n  if (!props.columns.length) return\n\n  const { rightTableRef, ...rest } = props\n\n  return (\n    <Table ref={rightTableRef} {...rest}>\n      {slots}\n    </Table>\n  )\n}\n\nexport default RightTable\n"],"mappings":";;;;AAAiC,SAAAC,QAAAC,GAAA;AAAA,QAAA,OAAAA,MAAA,cAAAC,OAAAC,UAAAC,SAAAC,KAAAJ,EAAA,KAAA,qBAAA,CAAAK,QAAAL,EAAA;;AAUjC,MAAMM,cAAoDC,OAAO,EAAEC,YAAY;AAC7E,KAAI,CAACD,MAAME,QAAQC,OAAQ;CAE3B,MAAM,EAAEC,eAAe,GAAGC,SAASL;AAEnC,QAAAM,YAAAf,WAAAgB,WAAA,EAAA,OACcH,eAAa,EAAMC,KAAI,EAAAb,QAChCS,MAAK,GAALA,QAAK,EAAAO,eAAA,CAALP,MAAK,EAAA,CAAA"}

frontend/node_modules/element-plus/es/components/table-v2/src/renderers/row.mjs

@@ -0,0 +1,77 @@
+import { tryCall } from "../utils.mjs";
+import TableV2Row from "../components/row.mjs";
+import { createVNode, isVNode, mergeProps } from "vue";
+
+//#region ../../packages/components/table-v2/src/renderers/row.tsx
+function _isSlot(s) {
+	return typeof s === "function" || Object.prototype.toString.call(s) === "[object Object]" && !isVNode(s);
+}
+const RowRenderer = (props, { slots }) => {
+	const { columns, columnsStyles, depthMap, expandColumnKey, expandedRowKeys, estimatedRowHeight, hasFixedColumns, rowData, rowIndex, style, isScrolling, rowProps, rowClass, rowKey, rowEventHandlers, ns, onRowHovered, onRowExpanded } = props;
+	const rowKls = tryCall(rowClass, {
+		columns,
+		rowData,
+		rowIndex
+	}, "");
+	const additionalProps = tryCall(rowProps, {
+		columns,
+		rowData,
+		rowIndex
+	});
+	const _rowKey = rowData[rowKey];
+	const depth = depthMap[_rowKey] || 0;
+	const canExpand = Boolean(expandColumnKey);
+	const isFixedRow = rowIndex < 0;
+	const kls = [
+		ns.e("row"),
+		rowKls,
+		ns.is("expanded", canExpand && expandedRowKeys.includes(_rowKey)),
+		ns.is("fixed", !depth && isFixedRow),
+		ns.is("customized", Boolean(slots.row)),
+		{ [ns.e(`row-depth-${depth}`)]: canExpand && rowIndex >= 0 }
+	];
+	const onRowHover = hasFixedColumns ? onRowHovered : void 0;
+	const _rowProps = {
+		...additionalProps,
+		columns,
+		columnsStyles,
+		class: kls,
+		depth,
+		expandColumnKey,
+		estimatedRowHeight: isFixedRow ? void 0 : estimatedRowHeight,
+		isScrolling,
+		rowIndex,
+		rowData,
+		rowKey: _rowKey,
+		rowEventHandlers,
+		style
+	};
+	const handlerMouseEnter = (e) => {
+		onRowHover?.({
+			hovered: true,
+			rowKey: _rowKey,
+			event: e,
+			rowData,
+			rowIndex
+		});
+	};
+	const handlerMouseLeave = (e) => {
+		onRowHover?.({
+			hovered: false,
+			rowKey: _rowKey,
+			event: e,
+			rowData,
+			rowIndex
+		});
+	};
+	return createVNode(TableV2Row, mergeProps(_rowProps, {
+		"onRowExpand": onRowExpanded,
+		"onMouseenter": handlerMouseEnter,
+		"onMouseleave": handlerMouseLeave,
+		"rowkey": _rowKey
+	}), _isSlot(slots) ? slots : { default: () => [slots] });
+};
+
+//#endregion
+export { RowRenderer as default };
+//# sourceMappingURL=row.mjs.map

frontend/node_modules/element-plus/es/components/table-v2/src/row.d.ts

@@ -0,0 +1,109 @@
+import { EpPropFinalized } from "../../../utils/vue/props/types.js";
+import "../../../utils/index.js";
+import { FixedDirection, KeyType, RowCommonParams } from "./types.js";
+import { AnyColumn } from "./common.js";
+import * as vue from "vue";
+import { CSSProperties, ExtractPropTypes, ExtractPublicPropTypes } from "vue";
+
+//#region ../../packages/components/table-v2/src/row.d.ts
+type RowExpandParams = {
+  expanded: boolean;
+  rowKey: KeyType;
+} & RowCommonParams;
+type RowHoverParams = {
+  event?: MouseEvent;
+  hovered: boolean;
+  rowKey: KeyType;
+} & Partial<RowCommonParams>;
+type RowEventHandlerParams = {
+  rowKey: KeyType;
+  event: Event;
+} & RowCommonParams;
+type RowHeightChangedParams = {
+  rowKey: KeyType;
+  height: number;
+  rowIndex: number;
+};
+type RowExpandHandler = (params: RowExpandParams) => void;
+type RowHoverHandler = (params: RowHoverParams) => void;
+type RowEventHandler = (params: RowEventHandlerParams) => void;
+type RowHeightChangeHandler = (row: RowHeightChangedParams, fixedDirection: boolean | FixedDirection | undefined) => void;
+type RowEventHandlers = {
+  onClick?: RowEventHandler;
+  onContextmenu?: RowEventHandler;
+  onDblclick?: RowEventHandler;
+  onMouseenter?: RowEventHandler;
+  onMouseleave?: RowEventHandler;
+};
+declare const tableV2RowProps: {
+  readonly class: StringConstructor;
+  readonly columns: {
+    readonly type: vue.PropType<AnyColumn[]>;
+    readonly required: true;
+    readonly validator: ((val: unknown) => boolean) | undefined;
+    __epPropKey: true;
+  };
+  readonly columnsStyles: {
+    readonly type: vue.PropType<Record<KeyType, CSSProperties>>;
+    readonly required: true;
+    readonly validator: ((val: unknown) => boolean) | undefined;
+    __epPropKey: true;
+  };
+  readonly depth: NumberConstructor;
+  readonly expandColumnKey: StringConstructor;
+  readonly estimatedRowHeight: {
+    readonly default: undefined;
+    readonly type: vue.PropType<number>;
+    readonly required: false;
+    readonly validator: ((val: unknown) => boolean) | undefined;
+    readonly __epPropKey: true;
+  };
+  readonly isScrolling: BooleanConstructor;
+  readonly onRowExpand: {
+    readonly type: vue.PropType<RowExpandHandler>;
+    readonly required: false;
+    readonly validator: ((val: unknown) => boolean) | undefined;
+    __epPropKey: true;
+  };
+  readonly onRowHover: {
+    readonly type: vue.PropType<RowHoverHandler>;
+    readonly required: false;
+    readonly validator: ((val: unknown) => boolean) | undefined;
+    __epPropKey: true;
+  };
+  readonly onRowHeightChange: {
+    readonly type: vue.PropType<RowHeightChangeHandler>;
+    readonly required: false;
+    readonly validator: ((val: unknown) => boolean) | undefined;
+    __epPropKey: true;
+  };
+  readonly rowData: {
+    readonly type: vue.PropType<any>;
+    readonly required: true;
+    readonly validator: ((val: unknown) => boolean) | undefined;
+    __epPropKey: true;
+  };
+  readonly rowEventHandlers: {
+    readonly type: vue.PropType<RowEventHandlers>;
+    readonly required: false;
+    readonly validator: ((val: unknown) => boolean) | undefined;
+    __epPropKey: true;
+  };
+  readonly rowIndex: {
+    readonly type: vue.PropType<number>;
+    readonly required: true;
+    readonly validator: ((val: unknown) => boolean) | undefined;
+    __epPropKey: true;
+  };
+  readonly rowKey: EpPropFinalized<(new (...args: any[]) => string | number | symbol) | (() => KeyType) | (((new (...args: any[]) => string | number | symbol) | (() => KeyType)) | null)[], unknown, unknown, "id", boolean>;
+  readonly style: {
+    readonly type: vue.PropType<CSSProperties>;
+    readonly required: false;
+    readonly validator: ((val: unknown) => boolean) | undefined;
+    __epPropKey: true;
+  };
+};
+type TableV2RowProps = ExtractPropTypes<typeof tableV2RowProps>;
+type TableV2RowPropsPublic = ExtractPublicPropTypes<typeof tableV2RowProps>;
+//#endregion
+export { RowEventHandler, RowEventHandlerParams, RowEventHandlers, RowExpandHandler, RowExpandParams, RowHeightChangeHandler, RowHeightChangedParams, RowHoverHandler, RowHoverParams, TableV2RowProps, TableV2RowPropsPublic, tableV2RowProps };