init

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

@@ -0,0 +1,18 @@
+import type { ExtractPropTypes, __ExtractPublicPropTypes } from 'vue';
+type AutoResizeHandler = (event: {
+    height: number;
+    width: number;
+}) => void;
+export declare const autoResizerProps: {
+    readonly disableWidth: BooleanConstructor;
+    readonly disableHeight: BooleanConstructor;
+    readonly onResize: {
+        readonly type: import("vue").PropType<AutoResizeHandler>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+};
+export type AutoResizerProps = ExtractPropTypes<typeof autoResizerProps>;
+export type AutoResizerPropsPublic = __ExtractPublicPropTypes<typeof autoResizerProps>;
+export {};

node_modules/element-plus/lib/components/table-v2/src/auto-resizer.js

@@ -0,0 +1,16 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var runtime = require('../../../utils/vue/props/runtime.js');
+
+const autoResizerProps = runtime.buildProps({
+  disableWidth: Boolean,
+  disableHeight: Boolean,
+  onResize: {
+    type: runtime.definePropType(Function)
+  }
+});
+
+exports.autoResizerProps = autoResizerProps;
+//# sourceMappingURL=auto-resizer.js.map

node_modules/element-plus/lib/components/table-v2/src/auto-resizer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"auto-resizer.js","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"],"names":["buildProps","definePropType"],"mappings":";;;;;;AACY,MAAC,gBAAgB,GAAGA,kBAAU,CAAC;AAC3C,EAAE,YAAY,EAAE,OAAO;AACvB,EAAE,aAAa,EAAE,OAAO;AACxB,EAAE,QAAQ,EAAE;AACZ,IAAI,IAAI,EAAEC,sBAAc,CAAC,QAAQ,CAAC;AAClC,GAAG;AACH,CAAC;;;;"}

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

@@ -0,0 +1,32 @@
+import type { ExtractPropTypes, StyleValue, __ExtractPublicPropTypes } from 'vue';
+export declare const tableV2CellProps: {
+    readonly class: StringConstructor;
+    readonly cellData: {
+        readonly type: import("vue").PropType<any>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly column: {
+        readonly type: import("vue").PropType<import("./common").AnyColumn>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly columnIndex: NumberConstructor;
+    readonly style: {
+        readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => string | import("vue").CSSProperties | StyleValue[]) | (() => StyleValue) | ((new (...args: any[]) => string | import("vue").CSSProperties | StyleValue[]) | (() => StyleValue))[], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly rowData: {
+        readonly type: import("vue").PropType<any>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly rowIndex: NumberConstructor;
+};
+export type TableV2CellProps = ExtractPropTypes<typeof tableV2CellProps>;
+export type TableV2CellPropsPublic = __ExtractPublicPropTypes<typeof tableV2CellProps>;

node_modules/element-plus/lib/components/table-v2/src/cell.js

@@ -0,0 +1,25 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var common = require('./common.js');
+var runtime = require('../../../utils/vue/props/runtime.js');
+
+const tableV2CellProps = runtime.buildProps({
+  class: String,
+  cellData: {
+    type: runtime.definePropType([String, Boolean, Number, Object])
+  },
+  column: common.column,
+  columnIndex: Number,
+  style: {
+    type: runtime.definePropType([String, Array, Object])
+  },
+  rowData: {
+    type: runtime.definePropType(Object)
+  },
+  rowIndex: Number
+});
+
+exports.tableV2CellProps = tableV2CellProps;
+//# sourceMappingURL=cell.js.map

node_modules/element-plus/lib/components/table-v2/src/cell.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cell.js","sources":["../../../../../../packages/components/table-v2/src/cell.ts"],"sourcesContent":["import { buildProps, definePropType } from '@element-plus/utils'\nimport { column } from './common'\n\nimport type {\n  ExtractPropTypes,\n  StyleValue,\n  __ExtractPublicPropTypes,\n} 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"],"names":["buildProps","definePropType","column"],"mappings":";;;;;;;AAEY,MAAC,gBAAgB,GAAGA,kBAAU,CAAC;AAC3C,EAAE,KAAK,EAAE,MAAM;AACf,EAAE,QAAQ,EAAE;AACZ,IAAI,IAAI,EAAEC,sBAAc,CAAC,CAAC,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;AAC3D,GAAG;AACH,UAAEC,aAAM;AACR,EAAE,WAAW,EAAE,MAAM;AACrB,EAAE,KAAK,EAAE;AACT,IAAI,IAAI,EAAED,sBAAc,CAAC,CAAC,MAAM,EAAE,KAAK,EAAE,MAAM,CAAC,CAAC;AACjD,GAAG;AACH,EAAE,OAAO,EAAE;AACX,IAAI,IAAI,EAAEA,sBAAc,CAAC,MAAM,CAAC;AAChC,GAAG;AACH,EAAE,QAAQ,EAAE,MAAM;AAClB,CAAC;;;;"}

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

@@ -0,0 +1,42 @@
+import type { CSSProperties } from 'vue';
+import type { Column, KeyType } from './types';
+export type AnyColumn = Column<any>;
+/**
+ * @Note even though we can use `string[] | string` as the type but for
+ * convenience here we only use `string` as the acceptable value here.
+ */
+export declare const classType: StringConstructor;
+export declare const columns: {
+    readonly type: import("vue").PropType<AnyColumn[]>;
+    readonly required: true;
+};
+export declare const column: {
+    readonly type: import("vue").PropType<AnyColumn>;
+};
+export declare const fixedDataType: {
+    readonly type: import("vue").PropType<any[]>;
+};
+export declare const dataType: {
+    readonly required: true;
+    readonly type: import("vue").PropType<any[]>;
+};
+export declare const expandColumnKey: StringConstructor;
+export declare const expandKeys: {
+    readonly type: import("vue").PropType<KeyType[]>;
+    readonly default: () => never[];
+};
+export declare const requiredNumber: {
+    readonly type: NumberConstructor;
+    readonly required: true;
+};
+export declare const rowKey: {
+    readonly type: import("vue").PropType<KeyType>;
+    readonly 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.
+ */
+export declare const styleType: {
+    type: import("vue").PropType<CSSProperties>;
+};

node_modules/element-plus/lib/components/table-v2/src/common.js

@@ -0,0 +1,50 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var runtime = require('../../../utils/vue/props/runtime.js');
+var typescript = require('../../../utils/typescript.js');
+
+const classType = String;
+const columns = {
+  type: runtime.definePropType(Array),
+  required: true
+};
+const column = {
+  type: runtime.definePropType(Object)
+};
+const fixedDataType = {
+  type: runtime.definePropType(Array)
+};
+const dataType = {
+  ...fixedDataType,
+  required: true
+};
+const expandColumnKey = String;
+const expandKeys = {
+  type: runtime.definePropType(Array),
+  default: () => typescript.mutable([])
+};
+const requiredNumber = {
+  type: Number,
+  required: true
+};
+const rowKey = {
+  type: runtime.definePropType([String, Number, Symbol]),
+  default: "id"
+};
+const styleType = {
+  type: runtime.definePropType(Object)
+};
+
+exports.classType = classType;
+exports.column = column;
+exports.columns = columns;
+exports.dataType = dataType;
+exports.expandColumnKey = expandColumnKey;
+exports.expandKeys = expandKeys;
+exports.fixedDataType = fixedDataType;
+exports.requiredNumber = requiredNumber;
+exports.rowKey = rowKey;
+exports.styleType = styleType;
+//# sourceMappingURL=common.js.map

node_modules/element-plus/lib/components/table-v2/src/common.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"common.js","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"],"names":["definePropType","mutable"],"mappings":";;;;;;;AACY,MAAC,SAAS,GAAG,OAAO;AACpB,MAAC,OAAO,GAAG;AACvB,EAAE,IAAI,EAAEA,sBAAc,CAAC,KAAK,CAAC;AAC7B,EAAE,QAAQ,EAAE,IAAI;AAChB,EAAE;AACU,MAAC,MAAM,GAAG;AACtB,EAAE,IAAI,EAAEA,sBAAc,CAAC,MAAM,CAAC;AAC9B,EAAE;AACU,MAAC,aAAa,GAAG;AAC7B,EAAE,IAAI,EAAEA,sBAAc,CAAC,KAAK,CAAC;AAC7B,EAAE;AACU,MAAC,QAAQ,GAAG;AACxB,EAAE,GAAG,aAAa;AAClB,EAAE,QAAQ,EAAE,IAAI;AAChB,EAAE;AACU,MAAC,eAAe,GAAG,OAAO;AAC1B,MAAC,UAAU,GAAG;AAC1B,EAAE,IAAI,EAAEA,sBAAc,CAAC,KAAK,CAAC;AAC7B,EAAE,OAAO,EAAE,MAAMC,kBAAO,CAAC,EAAE,CAAC;AAC5B,EAAE;AACU,MAAC,cAAc,GAAG;AAC9B,EAAE,IAAI,EAAE,MAAM;AACd,EAAE,QAAQ,EAAE,IAAI;AAChB,EAAE;AACU,MAAC,MAAM,GAAG;AACtB,EAAE,IAAI,EAAED,sBAAc,CAAC,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;AAChD,EAAE,OAAO,EAAE,IAAI;AACf,EAAE;AACU,MAAC,SAAS,GAAG;AACzB,EAAE,IAAI,EAAEA,sBAAc,CAAC,MAAM,CAAC;AAC9B;;;;;;;;;;;;;"}

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

@@ -0,0 +1,29 @@
+declare const AutoResizer: import("vue").DefineComponent<{
+    readonly disableWidth: BooleanConstructor;
+    readonly disableHeight: BooleanConstructor;
+    readonly onResize: {
+        readonly type: import("vue").PropType<(event: {
+            height: number;
+            width: number;
+        }) => void>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+}, () => JSX.Element, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    readonly disableWidth: BooleanConstructor;
+    readonly disableHeight: BooleanConstructor;
+    readonly onResize: {
+        readonly type: import("vue").PropType<(event: {
+            height: number;
+            width: number;
+        }) => void>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+}>>, {
+    readonly disableWidth: boolean;
+    readonly disableHeight: boolean;
+}>;
+export default AutoResizer;

node_modules/element-plus/lib/components/table-v2/src/components/auto-resizer.js

@@ -0,0 +1,42 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var vue = require('vue');
+var autoResizer = require('../auto-resizer.js');
+var useAutoResize = require('../composables/use-auto-resize.js');
+var index = require('../../../../hooks/use-namespace/index.js');
+
+const AutoResizer = vue.defineComponent({
+  name: "ElAutoResizer",
+  props: autoResizer.autoResizerProps,
+  setup(props, {
+    slots
+  }) {
+    const ns = index.useNamespace("auto-resizer");
+    const {
+      height,
+      width,
+      sizer
+    } = useAutoResize.useAutoResize(props);
+    const style = {
+      width: "100%",
+      height: "100%"
+    };
+    return () => {
+      var _a;
+      return vue.createVNode("div", {
+        "ref": sizer,
+        "class": ns.b(),
+        "style": style
+      }, [(_a = slots.default) == null ? void 0 : _a.call(slots, {
+        height: height.value,
+        width: width.value
+      })]);
+    };
+  }
+});
+var AutoResizer$1 = AutoResizer;
+
+exports["default"] = AutoResizer$1;
+//# sourceMappingURL=auto-resizer.js.map

node_modules/element-plus/lib/components/table-v2/src/components/auto-resizer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"auto-resizer.js","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"],"names":["AutoResizer","defineComponent","name","props","autoResizerProps","slots","useNamespace","ns","height","width","sizer","useAutoResize","_createVNode","b","style","default","value"],"mappings":";;;;;;;;;AAKA,MAAMA,WAAW,GAAGC,mBAAe,CAAC;AAClCC,EAAAA,IAAI,EAAE,eAD4B;AAElCC,EAAAA,KAAK,EAAEC,4BAF2B;;IAG7B;AAAUC,GAAAA,EAAAA;AAAF,IAAW,MAAA,EAAA,GAAAC,kBAAA,CAAA,cAAA,CAAA,CAAA;AACtB,IAAA,MAAMC;MACA,MAAA;MAAEC,KAAF;MAAUC,KAAV;AAAiBC,KAAAA,GAAAA,2BAAAA,CAAAA,KAAAA,CAAAA,CAAAA;IAAjB,MAA2BC,KAAAA,GAAAA;AACjC,MAAA,aAAc;AACZF,MAAAA,QADY,MAAA;AAEZD,KAAAA,CAAAA;IAFY,OAAd,MAAA;AAKA,MAAA,IAAA,EAAa,CAAA;AACX,MAAA,OAAAI,eAAA,CAAA,KAAA,EAAA;AAAA,QAAA,KAAA,EACYF,KADZ;QAAA,OAC0BH,EAAAA,EAAE,CAACM,CAAH,EAD1B;QAAA,OACyCC,EAAAA,KAAAA;OACpCT,EAAAA,CAAAA,CAAAA,EAAAA,GAAMU,KAAAA,CAAAA,OAAU,KAAA,IAAA,GAAA,KAAA,CAAA,GAAA,EAAA,CAAA,IAAA,CAAA,KAAA,EAAA;QACfP,MAAM,EAAEA,MAAM,CAACQ,KADA;QAEfP,KAAK,EAAEA,KAAK,CAACO,KAAAA;AAFE,OAAhB,CAFL,CAAA,CAAA,CAAA;KADF,CAAA;AAUD,GAAA;;AArBiC,oBAApC,WAAA;;;;"}

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

@@ -0,0 +1,4 @@
+import type { FunctionalComponent } from 'vue';
+import type { TableV2CellProps } from '../cell';
+declare const TableV2Cell: FunctionalComponent<TableV2CellProps>;
+export default TableV2Cell;

node_modules/element-plus/lib/components/table-v2/src/components/cell.js

@@ -0,0 +1,28 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var vue = require('vue');
+
+const TableV2Cell = (props, {
+  slots
+}) => {
+  var _a;
+  const {
+    cellData,
+    style
+  } = props;
+  const displayText = ((_a = cellData == null ? void 0 : cellData.toString) == null ? void 0 : _a.call(cellData)) || "";
+  const defaultSlot = vue.renderSlot(slots, "default", props, () => [displayText]);
+  return vue.createVNode("div", {
+    "class": props.class,
+    "title": displayText,
+    "style": style
+  }, [defaultSlot]);
+};
+TableV2Cell.displayName = "ElTableV2Cell";
+TableV2Cell.inheritAttrs = false;
+var TableCell = TableV2Cell;
+
+exports["default"] = TableCell;
+//# sourceMappingURL=cell.js.map

node_modules/element-plus/lib/components/table-v2/src/components/cell.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cell.js","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"],"names":["slots","cellData","style","props","displayText","toString","defaultSlot","renderSlot","_createVNode","class","TableV2Cell","displayName"],"mappings":";;;;;;;AAKA,EAAA,KAAwD;AAEpDA,CAAAA,KAAAA;AAAF,EACG,IAAA,EAAA,CAAA;EACH,MAAM;IAAEC,QAAF;AAAYC,IAAAA,KAAAA;AAAZ,GAAA,GAAsBC,KAA5B,CAAA;AACA,EAAA,MAAMC,WAAW,GAAGH,CAAAA,CAAAA,EAAAA,GAAAA,QAAUI,WAAgB,KAA9C,CAAA,GAAA,QAAA,CAAA,QAAA,KAAA,IAAA,GAAA,KAAA,CAAA,GAAA,EAAA,CAAA,IAAA,CAAA,QAAA,CAAA,KAAA,EAAA,CAAA;AACA,EAAA,MAAMC,WAAW,GAAGC,cAAU,CAACP,KAAD,EAAQ,SAAR,EAAmBG,KAAnB,EAA0B,MAAM,CAACC,WAAD,CAAhC,CAA9B,CAAA;AACA,EAAA,OAAAI,eAAA,CAAA,KAAA,EAAA;IAAA,OACcL,EAAAA,KAAK,CAACM,KADpB;AAAA,IAAA,OAAA,EACkCL,WADlC;IAAA,OACsDF,EAAAA,KAAAA;AADtD,GAAA,EAAA,CAEKI,WAFL,CAAA,CAAA,CAAA;AAKD,CAZD,CAAA;;AAcAI,WAAW,CAACC,YAAZ,GAAA,KAAA,CAAA;AACAD,gBAAA,WAAA;;;;"}

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

@@ -0,0 +1,11 @@
+import type { StyleValue } from 'vue';
+import type { TableV2RowCellRenderParam } from './row';
+declare const ExpandIcon: (props: TableV2RowCellRenderParam["expandIconProps"] & {
+    class?: string | string[];
+    style: StyleValue;
+    size: number;
+    expanded: boolean;
+    expandable: boolean;
+}) => JSX.Element;
+export default ExpandIcon;
+export type ExpandIconInstance = ReturnType<typeof ExpandIcon>;

node_modules/element-plus/lib/components/table-v2/src/components/expand-icon.js

@@ -0,0 +1,31 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var vue = require('vue');
+var index = require('../../../icon/index.js');
+var iconsVue = require('@element-plus/icons-vue');
+
+const ExpandIcon = (props) => {
+  const {
+    expanded,
+    expandable,
+    onExpand,
+    style,
+    size
+  } = props;
+  const expandIconProps = {
+    onClick: expandable ? () => onExpand(!expanded) : void 0,
+    class: props.class
+  };
+  return vue.createVNode(index.ElIcon, vue.mergeProps(expandIconProps, {
+    "size": size,
+    "style": style
+  }), {
+    default: () => [vue.createVNode(iconsVue.ArrowRight, null, null)]
+  });
+};
+var ExpandIcon$1 = ExpandIcon;
+
+exports["default"] = ExpandIcon$1;
+//# sourceMappingURL=expand-icon.js.map

node_modules/element-plus/lib/components/table-v2/src/components/expand-icon.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"expand-icon.js","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    size: number\n    expanded: boolean\n    expandable: boolean\n  }\n) => {\n  const { expanded, expandable, onExpand, style, size } = props\n\n  const expandIconProps = {\n    onClick: expandable ? () => onExpand(!expanded) : undefined,\n    class: props.class,\n  } as any\n\n  return (\n    <ElIcon {...expandIconProps} size={size} style={style}>\n      <ArrowRight />\n    </ElIcon>\n  )\n}\n\nexport default ExpandIcon\n\nexport type ExpandIconInstance = ReturnType<typeof ExpandIcon>\n"],"names":["ExpandIcon","expanded","expandable","onExpand","style","size","onClick","class","_createVNode","ElIcon","_mergeProps","ArrowRight"],"mappings":";;;;;;;;;AAMA,EAAMA,MAAAA;IASE,QAAA;IAAEC,UAAF;IAAYC,QAAZ;IAAwBC,KAAxB;IAAkCC,IAAlC;AAAyCC,GAAAA,GAAAA,KAAAA,CAAAA;AAAzC,EAAA,MAAN,eAAA,GAAA;AAEA,IAAA,mBAAqB,GAAG,MAAA,QAAA,CAAA,CAAA,QAAA,CAAA,GAAA,KAAA,CAAA;IACtBC,KAAO,EAAA,KAAY,CAAA,KAAA;IACnBC;EAFsB,OAAxBC,eAAA,CAAAC,YAAA,EAAAC,cAAA,CAAA,eAAA,EAAA;AAKA,IAAA,MAAA,EAAA,IAAA;AAAA,IAAA,OAAA,EAAA,KAAA;IAAA,EACkDN;AADlD,IAAA,OAAA,EAAA,MAAA,CAAAI,eAAA,CAAAG,mBAAA,EAAA,IAAA,EAAA,IAAA,CAAA,CAAA;AAAA,GAAA,CAAA,CAAA;AAAA,CAAA,CAAA;AAKD,mBArBD,UAAA;;;;"}

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

@@ -0,0 +1,4 @@
+import type { FunctionalComponent } from 'vue';
+import type { TableV2HeaderCell } from '../header-cell';
+declare const HeaderCell: FunctionalComponent<TableV2HeaderCell>;
+export default HeaderCell;

node_modules/element-plus/lib/components/table-v2/src/components/header-cell.js

@@ -0,0 +1,21 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var vue = require('vue');
+
+const HeaderCell = (props, {
+  slots
+}) => vue.renderSlot(slots, "default", props, () => {
+  var _a, _b;
+  return [vue.createVNode("div", {
+    "class": props.class,
+    "title": (_a = props.column) == null ? void 0 : _a.title
+  }, [(_b = props.column) == null ? void 0 : _b.title])];
+});
+HeaderCell.displayName = "ElTableV2HeaderCell";
+HeaderCell.inheritAttrs = false;
+var HeaderCell$1 = HeaderCell;
+
+exports["default"] = HeaderCell$1;
+//# sourceMappingURL=header-cell.js.map

node_modules/element-plus/lib/components/table-v2/src/components/header-cell.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"header-cell.js","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"],"names":["slots","renderSlot","props","column","title","HeaderCell","inheritAttrs"],"mappings":";;;;;;;AAKA,EAAA,KAAwD;AAAaA,CAAAA,KAAAA,cAAAA,CAAAA,KAAAA,EAAAA,SAAAA,EAAAA,KAAAA,EAAAA,MAAAA;AAAF,EAAR,IACzDC;EAA0C,OAC5BC,CAAAA,eAD4B,CAAA,KAAA,EAAA;IACRA,OAAAA,EAAAA,KAAMC,CAAAA,KAAQC;AADN,IAErCF,OAAMC,EAAAA,CAAAA,EAAN,GAAcC,YAHrB,KAAA,IAAA,GAAA,KAAA,CAAA,GAAA,EAAA,CAAA,KAAA;;AAOAC,CAAU,CAAA,CAAA;AACVA,UAAU,CAACC,WAAX,GAAA,qBAAA,CAAA;AAEA,UAAA,CAAA,YAAA,GAAA,KAAA,CAAA;;;;;"}

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

@@ -0,0 +1,59 @@
+import type { CSSProperties } from 'vue';
+import type { ColumnCellsType } from '../types';
+import type { TableV2HeaderRowProps } from '../header-row';
+declare const TableV2HeaderRow: import("vue").DefineComponent<{
+    readonly class: StringConstructor;
+    readonly columns: {
+        readonly type: import("vue").PropType<import("../common").AnyColumn[]>;
+        readonly required: true;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly columnsStyles: {
+        readonly type: import("vue").PropType<Record<import("../types").KeyType, CSSProperties>>;
+        readonly required: true;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly headerIndex: NumberConstructor;
+    readonly style: {
+        readonly type: import("vue").PropType<CSSProperties>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+}, () => JSX.Element, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    readonly class: StringConstructor;
+    readonly columns: {
+        readonly type: import("vue").PropType<import("../common").AnyColumn[]>;
+        readonly required: true;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly columnsStyles: {
+        readonly type: import("vue").PropType<Record<import("../types").KeyType, CSSProperties>>;
+        readonly required: true;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly headerIndex: NumberConstructor;
+    readonly style: {
+        readonly type: import("vue").PropType<CSSProperties>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+}>>, {}>;
+export default TableV2HeaderRow;
+export type TableV2HeaderRowCellRendererParams = {
+    columns: TableV2HeaderRowProps['columns'];
+    column: TableV2HeaderRowProps['columns'][number];
+    columnIndex: number;
+    headerIndex: number;
+    style: CSSProperties;
+};
+export type TableV2HeaderRowRendererParams = {
+    cells: ColumnCellsType;
+    columns: TableV2HeaderRowProps['columns'];
+    headerIndex: number;
+};

node_modules/element-plus/lib/components/table-v2/src/components/header-row.js

@@ -0,0 +1,54 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var vue = require('vue');
+var headerRow = require('../header-row.js');
+var shared = require('@vue/shared');
+
+const TableV2HeaderRow = vue.defineComponent({
+  name: "ElTableV2HeaderRow",
+  props: headerRow.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 (shared.isArray(node) && node.length === 1) {
+              return node[0];
+            }
+            return node;
+          }),
+          columns,
+          headerIndex
+        });
+      }
+      return vue.createVNode("div", {
+        "class": props.class,
+        "style": style,
+        "role": "row"
+      }, [Cells]);
+    };
+  }
+});
+var HeaderRow = TableV2HeaderRow;
+
+exports["default"] = HeaderRow;
+//# sourceMappingURL=header-row.js.map

node_modules/element-plus/lib/components/table-v2/src/components/header-row.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"header-row.js","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"],"names":["TableV2HeaderRow","defineComponent","name","props","tableV2HeaderRowProps","slots","columns","columnsStyles","headerIndex","style","Cells","map","column","columnIndex","header","cells","node","isArray"],"mappings":";;;;;;;;AAQA,MAAMA,gBAAgB,GAAGC,mBAAe,CAAC;AACvCC,EAAAA,IAAI,EAAE,oBADiC;AAEvCC,EAAAA,KAAK,EAAEC,+BAFgC;;IAGlC;AAAUC,GAAAA,EAAAA;AAAF,IAAW,OAAA,MAAA;AACtB,MAAA,MAAa;QACL,OAAA;QAAEC,aAAF;QAAWC,WAAX;QAA0BC,KAA1B;AAAuCC,OAAAA,GAAAA,KAAAA,CAAAA;AAAvC,MAAA,IAAiDN,KAAvD,GAAA,OAAA,CAAA,GAAA,CAAA,CAAA,MAAA,EAAA,WAAA,KAAA;QACIO,OAAsB,KAAGJ,CAAAA,IAAO,CAACK;UAC5BN,OAAAA;UACLC,MADiB;UAEjBM,WAFiB;UAGjBC,WAHiB;UAIjBL,KAJiB,EAAA,aAAA,CAAA,MAAA,CAAA,GAAA,CAAA;AAKjBC,SAAAA,CAAAA,CAAAA;AALiB,OAAA,CAAA,CAAZ;AAOR,MAAA,IARD,KAAA,CAAA,MAAA,EAAA;;UAUIJ,KAAK,EAACS,KAAV,CAAkB,GAAA,CAAA,CAAA,IAAA,KAAA;AAChBJ,YAAAA,IAAQL,cAAMS,CAAAA,IAAN,CAAa,IAAA,IAAA,CAAA,MAAA,KAAA,CAAA,EAAA;AACnBC,cAAAA,OAAY,IAAL,CAAA,CAAWC;aACZC;mBACKD,IAAAA,CAAAA;AACR,WAAA,CAAA;;AACD,UAAA,WAAA;AACD,SAAA,CAAA,CALM;;AAOPR,MAAAA,OAAAA,eAAAA,CAAAA,KAAAA,EAAAA;AARmB,QAAA,OAArB,EAAA,KAAA,CAAA,KAAA;AAUD,QAAA,OAAA,EAAA,KAAA;;AAED,OAAA,EAAA,CAAA,KAAA,CAAA,CAAA,CAAA;;AAAA,GAAA;;AAAA,gBAAA,gBAAA;;;;"}

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

@@ -0,0 +1,105 @@
+import type { CSSProperties, UnwrapRef } from 'vue';
+import type { TableV2HeaderProps } from '../header';
+import type { UseColumnsReturn } from '../composables/use-columns';
+declare const TableV2Header: import("vue").DefineComponent<{
+    readonly class: StringConstructor;
+    readonly columns: {
+        readonly type: import("vue").PropType<import("../common").AnyColumn[]>;
+        readonly required: true;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly fixedHeaderData: {
+        readonly type: import("vue").PropType<any[]>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly headerData: {
+        readonly type: import("vue").PropType<any[]>;
+        readonly required: true;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly headerHeight: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => number | number[]) | (() => number | number[]) | ((new (...args: any[]) => number | number[]) | (() => number | number[]))[], unknown, unknown, 50, boolean>;
+    readonly rowWidth: {
+        readonly type: import("vue").PropType<number>;
+        readonly required: true;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly rowHeight: import("element-plus/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 50, boolean>;
+    readonly height: {
+        readonly type: import("vue").PropType<number>;
+        readonly required: true;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly width: {
+        readonly type: import("vue").PropType<number>;
+        readonly required: true;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+}, () => JSX.Element | undefined, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    readonly class: StringConstructor;
+    readonly columns: {
+        readonly type: import("vue").PropType<import("../common").AnyColumn[]>;
+        readonly required: true;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly fixedHeaderData: {
+        readonly type: import("vue").PropType<any[]>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly headerData: {
+        readonly type: import("vue").PropType<any[]>;
+        readonly required: true;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly headerHeight: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => number | number[]) | (() => number | number[]) | ((new (...args: any[]) => number | number[]) | (() => number | number[]))[], unknown, unknown, 50, boolean>;
+    readonly rowWidth: {
+        readonly type: import("vue").PropType<number>;
+        readonly required: true;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly rowHeight: import("element-plus/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 50, boolean>;
+    readonly height: {
+        readonly type: import("vue").PropType<number>;
+        readonly required: true;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly width: {
+        readonly type: import("vue").PropType<number>;
+        readonly required: true;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+}>>, {
+    readonly rowHeight: number;
+    readonly headerHeight: import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => number | number[]) | (() => number | number[]) | ((new (...args: any[]) => number | number[]) | (() => number | number[]))[], unknown, unknown>;
+}>;
+export default TableV2Header;
+export type TableV2HeaderInstance = InstanceType<typeof TableV2Header> & {
+    /**
+     * @description scroll to position based on the provided value
+     */
+    scrollToLeft: (left?: number) => void;
+};
+export type TableV2HeaderRendererParams = {
+    class: string;
+    columns: TableV2HeaderProps['columns'];
+    columnsStyles: UnwrapRef<UseColumnsReturn['columnsStyles']>;
+    headerIndex: number;
+    style: CSSProperties;
+};
+export type TableV2HeaderRowRendererParams = {
+    rowData: any;
+    rowIndex: number;
+} & Omit<TableV2HeaderRendererParams, 'headerIndex'>;

node_modules/element-plus/lib/components/table-v2/src/components/header.js

@@ -0,0 +1,107 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var vue = require('vue');
+var header = require('../header.js');
+var utils = require('../utils.js');
+var tokens = require('../tokens.js');
+var index = require('../../../../hooks/use-namespace/index.js');
+var lodashUnified = require('lodash-unified');
+
+const COMPONENT_NAME = "ElTableV2Header";
+const TableV2Header = vue.defineComponent({
+  name: COMPONENT_NAME,
+  props: header.tableV2HeaderProps,
+  setup(props, {
+    slots,
+    expose
+  }) {
+    const ns = index.useNamespace("table-v2");
+    const scrollLeftInfo = vue.inject(tokens.TABLE_V2_GRID_INJECTION_KEY);
+    const headerRef = vue.ref();
+    const headerStyle = vue.computed(() => utils.enforceUnit({
+      width: props.width,
+      height: props.height
+    }));
+    const rowStyle = vue.computed(() => utils.enforceUnit({
+      width: props.rowWidth,
+      height: props.height
+    }));
+    const headerHeights = vue.computed(() => lodashUnified.castArray(vue.unref(props.headerHeight)));
+    const scrollToLeft = (left) => {
+      const headerEl = vue.unref(headerRef);
+      vue.nextTick(() => {
+        (headerEl == null ? void 0 : headerEl.scroll) && headerEl.scroll({
+          left
+        });
+      });
+    };
+    const renderFixedRows = () => {
+      const fixedRowClassName = ns.e("fixed-header-row");
+      const {
+        columns,
+        fixedHeaderData,
+        rowHeight
+      } = props;
+      return fixedHeaderData == null ? void 0 : fixedHeaderData.map((fixedRowData, fixedRowIndex) => {
+        var _a;
+        const style = utils.enforceUnit({
+          height: rowHeight,
+          width: "100%"
+        });
+        return (_a = slots.fixed) == null ? void 0 : _a.call(slots, {
+          class: fixedRowClassName,
+          columns,
+          rowData: fixedRowData,
+          rowIndex: -(fixedRowIndex + 1),
+          style
+        });
+      });
+    };
+    const renderDynamicRows = () => {
+      const dynamicRowClassName = ns.e("dynamic-header-row");
+      const {
+        columns
+      } = props;
+      return vue.unref(headerHeights).map((rowHeight, rowIndex) => {
+        var _a;
+        const style = utils.enforceUnit({
+          width: "100%",
+          height: rowHeight
+        });
+        return (_a = slots.dynamic) == null ? void 0 : _a.call(slots, {
+          class: dynamicRowClassName,
+          columns,
+          headerIndex: rowIndex,
+          style
+        });
+      });
+    };
+    vue.onUpdated(() => {
+      if (scrollLeftInfo == null ? void 0 : scrollLeftInfo.value) {
+        scrollToLeft(scrollLeftInfo.value);
+      }
+    });
+    expose({
+      scrollToLeft
+    });
+    return () => {
+      if (props.height <= 0)
+        return;
+      return vue.createVNode("div", {
+        "ref": headerRef,
+        "class": props.class,
+        "style": vue.unref(headerStyle),
+        "role": "rowgroup"
+      }, [vue.createVNode("div", {
+        "style": vue.unref(rowStyle),
+        "class": ns.e("header")
+      }, [renderDynamicRows(), renderFixedRows()])]);
+    };
+  }
+});
+var Header = TableV2Header;
+
+exports["default"] = Header;
+//# sourceMappingURL=header.js.map

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

@@ -0,0 +1,10 @@
+export { default as TableCell } from './cell';
+export { default as HeaderCell } from './header-cell';
+export { default as HeaderRow } from './header-row';
+export { default as Header } from './header';
+export { default as Row } from './row';
+export { default as SortIcon } from './sort-icon';
+export { default as ExpandIcon } from './expand-icon';
+export type { TableV2HeaderRowCellRendererParams, TableV2HeaderRowRendererParams, } from './header-row';
+export type { TableV2RowCellRenderParam } from './row';
+export type { TableV2HeaderRendererParams, TableV2HeaderInstance, } from './header';

node_modules/element-plus/lib/components/table-v2/src/components/index.js

@@ -0,0 +1,22 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var cell = require('./cell.js');
+var headerCell = require('./header-cell.js');
+var headerRow = require('./header-row.js');
+var header = require('./header.js');
+var row = require('./row.js');
+var sortIcon = require('./sort-icon.js');
+var expandIcon = require('./expand-icon.js');
+
+
+
+exports.TableCell = cell["default"];
+exports.HeaderCell = headerCell["default"];
+exports.HeaderRow = headerRow["default"];
+exports.Header = header["default"];
+exports.Row = row["default"];
+exports.SortIcon = sortIcon["default"];
+exports.ExpandIcon = expandIcon["default"];
+//# sourceMappingURL=index.js.map

node_modules/element-plus/lib/components/table-v2/src/components/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;"}

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

@@ -0,0 +1,157 @@
+import type { CSSProperties } from 'vue';
+import type { RowEventHandlers, TableV2RowProps } from '../row';
+declare const TableV2Row: import("vue").DefineComponent<{
+    readonly class: StringConstructor;
+    readonly columns: {
+        readonly type: import("vue").PropType<import("../common").AnyColumn[]>;
+        readonly required: true;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly columnsStyles: {
+        readonly type: import("vue").PropType<Record<import("../types").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: import("vue").PropType<number>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        readonly __epPropKey: true;
+    };
+    readonly isScrolling: BooleanConstructor;
+    readonly onRowExpand: {
+        readonly type: import("vue").PropType<import("../row").RowExpandHandler>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly onRowHover: {
+        readonly type: import("vue").PropType<import("../row").RowHoverHandler>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly onRowHeightChange: {
+        readonly type: import("vue").PropType<import("../row").RowHeightChangeHandler>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly rowData: {
+        readonly type: import("vue").PropType<any>;
+        readonly required: true;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly rowEventHandlers: {
+        readonly type: import("vue").PropType<RowEventHandlers>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly rowIndex: {
+        readonly type: import("vue").PropType<number>;
+        readonly required: true;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly rowKey: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => string | number | symbol) | (() => import("../types").KeyType) | ((new (...args: any[]) => string | number | symbol) | (() => import("../types").KeyType))[], unknown, unknown, "id", boolean>;
+    readonly style: {
+        readonly type: import("vue").PropType<CSSProperties>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+}, () => JSX.Element, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    readonly class: StringConstructor;
+    readonly columns: {
+        readonly type: import("vue").PropType<import("../common").AnyColumn[]>;
+        readonly required: true;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly columnsStyles: {
+        readonly type: import("vue").PropType<Record<import("../types").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: import("vue").PropType<number>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        readonly __epPropKey: true;
+    };
+    readonly isScrolling: BooleanConstructor;
+    readonly onRowExpand: {
+        readonly type: import("vue").PropType<import("../row").RowExpandHandler>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly onRowHover: {
+        readonly type: import("vue").PropType<import("../row").RowHoverHandler>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly onRowHeightChange: {
+        readonly type: import("vue").PropType<import("../row").RowHeightChangeHandler>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly rowData: {
+        readonly type: import("vue").PropType<any>;
+        readonly required: true;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly rowEventHandlers: {
+        readonly type: import("vue").PropType<RowEventHandlers>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly rowIndex: {
+        readonly type: import("vue").PropType<number>;
+        readonly required: true;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly rowKey: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => string | number | symbol) | (() => import("../types").KeyType) | ((new (...args: any[]) => string | number | symbol) | (() => import("../types").KeyType))[], unknown, unknown, "id", boolean>;
+    readonly style: {
+        readonly type: import("vue").PropType<CSSProperties>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+}>>, {
+    readonly rowKey: import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => string | number | symbol) | (() => import("../types").KeyType) | ((new (...args: any[]) => string | number | symbol) | (() => import("../types").KeyType))[], unknown, unknown>;
+    readonly estimatedRowHeight: number;
+    readonly isScrolling: boolean;
+}>;
+export default TableV2Row;
+export 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;
+    };
+};

node_modules/element-plus/lib/components/table-v2/src/components/row.js

@@ -0,0 +1,212 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var vue = require('vue');
+var row = require('../row.js');
+var tokens = require('../tokens.js');
+var _private = require('../private.js');
+var shared = require('@vue/shared');
+var types = require('../../../../utils/types.js');
+
+const useTableRow = (props) => {
+  const {
+    isScrolling
+  } = vue.inject(tokens.TableV2InjectionKey);
+  const measured = vue.ref(false);
+  const rowRef = vue.ref();
+  const measurable = vue.computed(() => {
+    return types.isNumber(props.estimatedRowHeight) && props.rowIndex >= 0;
+  });
+  const doMeasure = (isInit = false) => {
+    const $rowRef = vue.unref(rowRef);
+    if (!$rowRef)
+      return;
+    const {
+      columns,
+      onRowHeightChange,
+      rowKey,
+      rowIndex,
+      style
+    } = props;
+    const {
+      height
+    } = $rowRef.getBoundingClientRect();
+    measured.value = true;
+    vue.nextTick(() => {
+      if (isInit || height !== Number.parseInt(style.height)) {
+        const firstColumn = columns[0];
+        const isPlaceholder = (firstColumn == null ? void 0 : firstColumn.placeholderSign) === _private.placeholderSign;
+        onRowHeightChange == null ? void 0 : onRowHeightChange({
+          rowKey,
+          height,
+          rowIndex
+        }, firstColumn && !isPlaceholder && firstColumn.fixed);
+      }
+    });
+  };
+  const eventHandlers = vue.computed(() => {
+    const {
+      rowData,
+      rowIndex,
+      rowKey,
+      onRowHover
+    } = props;
+    const handlers = props.rowEventHandlers || {};
+    const eventHandlers2 = {};
+    Object.entries(handlers).forEach(([eventName, handler]) => {
+      if (shared.isFunction(handler)) {
+        eventHandlers2[eventName] = (event) => {
+          handler({
+            event,
+            rowData,
+            rowIndex,
+            rowKey
+          });
+        };
+      }
+    });
+    if (onRowHover) {
+      [{
+        name: "onMouseleave",
+        hovered: false
+      }, {
+        name: "onMouseenter",
+        hovered: true
+      }].forEach(({
+        name,
+        hovered
+      }) => {
+        const existedHandler = eventHandlers2[name];
+        eventHandlers2[name] = (event) => {
+          onRowHover({
+            event,
+            hovered,
+            rowData,
+            rowIndex,
+            rowKey
+          });
+          existedHandler == null ? void 0 : existedHandler(event);
+        };
+      });
+    }
+    return eventHandlers2;
+  });
+  const onExpand = (expanded) => {
+    const {
+      onRowExpand,
+      rowData,
+      rowIndex,
+      rowKey
+    } = props;
+    onRowExpand == null ? void 0 : onRowExpand({
+      expanded,
+      rowData,
+      rowIndex,
+      rowKey
+    });
+  };
+  vue.onMounted(() => {
+    if (vue.unref(measurable)) {
+      doMeasure(true);
+    }
+  });
+  return {
+    isScrolling,
+    measurable,
+    measured,
+    rowRef,
+    eventHandlers,
+    onExpand
+  };
+};
+const COMPONENT_NAME = "ElTableV2TableRow";
+const TableV2Row = vue.defineComponent({
+  name: COMPONENT_NAME,
+  props: row.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 = shared.isArray(rowData.children) && rowData.children.length > 0 && column.key === expandColumnKey;
+        return slots.cell({
+          column,
+          columns,
+          columnIndex,
+          depth,
+          style: columnsStyles[column.key],
+          rowData,
+          rowIndex,
+          isScrolling: vue.unref(isScrolling),
+          expandIconProps: expandable ? {
+            rowData,
+            rowIndex,
+            onExpand
+          } : void 0
+        });
+      });
+      if (slots.row) {
+        ColumnCells = slots.row({
+          cells: ColumnCells.map((node) => {
+            if (shared.isArray(node) && node.length === 1) {
+              return node[0];
+            }
+            return node;
+          }),
+          style,
+          columns,
+          depth,
+          rowData,
+          rowIndex,
+          isScrolling: vue.unref(isScrolling)
+        });
+      }
+      if (vue.unref(measurable)) {
+        const {
+          height,
+          ...exceptHeightStyle
+        } = style || {};
+        const _measured = vue.unref(measured);
+        return vue.createVNode("div", vue.mergeProps({
+          "ref": rowRef,
+          "class": props.class,
+          "style": _measured ? style : exceptHeightStyle,
+          "role": "row"
+        }, attrs, vue.unref(eventHandlers)), [ColumnCells]);
+      }
+      return vue.createVNode("div", vue.mergeProps(attrs, {
+        "ref": rowRef,
+        "class": props.class,
+        "style": style,
+        "role": "row"
+      }, vue.unref(eventHandlers)), [ColumnCells]);
+    };
+  }
+});
+var Row = TableV2Row;
+
+exports["default"] = Row;
+//# sourceMappingURL=row.js.map

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

@@ -0,0 +1,8 @@
+import { SortOrder } from '../constants';
+import type { FunctionalComponent } from 'vue';
+export type SortIconProps = {
+    sortOrder: SortOrder;
+    class?: JSX.IntrinsicAttributes['class'];
+};
+declare const SortIcon: FunctionalComponent<SortIconProps>;
+export default SortIcon;

node_modules/element-plus/lib/components/table-v2/src/components/sort-icon.js

@@ -0,0 +1,24 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var vue = require('vue');
+var index = require('../../../icon/index.js');
+var iconsVue = require('@element-plus/icons-vue');
+var constants = require('../constants.js');
+
+const SortIcon = (props) => {
+  const {
+    sortOrder
+  } = props;
+  return vue.createVNode(index.ElIcon, {
+    "size": 14,
+    "class": props.class
+  }, {
+    default: () => [sortOrder === constants.SortOrder.ASC ? vue.createVNode(iconsVue.SortUp, null, null) : vue.createVNode(iconsVue.SortDown, null, null)]
+  });
+};
+var SortIcon$1 = SortIcon;
+
+exports["default"] = SortIcon$1;
+//# sourceMappingURL=sort-icon.js.map

node_modules/element-plus/lib/components/table-v2/src/components/sort-icon.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sort-icon.js","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  class?: JSX.IntrinsicAttributes['class']\n}\n\nconst SortIcon: FunctionalComponent<SortIconProps> = (props) => {\n  const { sortOrder } = props\n\n  return (\n    <ElIcon size={14} class={props.class}>\n      {sortOrder === SortOrder.ASC ? <SortUp /> : <SortDown />}\n    </ElIcon>\n  )\n}\n\nexport default SortIcon\n"],"names":["SortIcon","sortOrder","_createVNode","ElIcon","SortOrder","SortUp","SortDown"],"mappings":";;;;;;;;;;AAWA,EAAMA,MAAAA;IACE,SAAA;AAAEC,GAAAA,GAAAA,KAAAA,CAAAA;AAAF,EAAA,OAANC,eAAA,CAAAC,YAAA,EAAA;AAEA,IAAA,MAAA,EAAA,EAAA;AAAA,IAAA,OAAA,EAAA,KAAA,CAAA,KAAA;AAAA,GAAA,EAAA;AAAA,IAAA,OAAA,EAAA,MAAA,CAAA,SAAA,KAAAC,mBAAA,CAAA,GAAA,GAAAF,eAAA,CAAAG,eAAA,EAAA,IAAA,EAAA,IAAA,CAAA,GAAAH,eAAA,CAAAI,iBAAA,EAAA,IAAA,EAAA,IAAA,CAAA,CAAA;AAAA,GAAA,CAAA,CAAA;AAAA,CAAA,CAAA;AAKD,iBARD,QAAA;;;;"}

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

@@ -0,0 +1,6 @@
+export * from './use-columns';
+export * from './use-scrollbar';
+export * from './use-row';
+export * from './use-data';
+export * from './use-styles';
+export * from './use-auto-resize';

node_modules/element-plus/lib/components/table-v2/src/composables/index.js

@@ -0,0 +1,20 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var useColumns = require('./use-columns.js');
+var useScrollbar = require('./use-scrollbar.js');
+var useRow = require('./use-row.js');
+var useData = require('./use-data.js');
+var useStyles = require('./use-styles.js');
+var useAutoResize = require('./use-auto-resize.js');
+
+
+
+exports.useColumns = useColumns.useColumns;
+exports.useScrollbar = useScrollbar.useScrollbar;
+exports.useRow = useRow.useRow;
+exports.useData = useData.useData;
+exports.useStyles = useStyles.useStyles;
+exports.useAutoResize = useAutoResize.useAutoResize;
+//# sourceMappingURL=index.js.map

node_modules/element-plus/lib/components/table-v2/src/composables/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;"}

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

@@ -0,0 +1,7 @@
+import type { AutoResizerProps } from '../auto-resizer';
+declare const useAutoResize: (props: AutoResizerProps) => {
+    sizer: import("vue").Ref<HTMLElement | undefined>;
+    width: import("vue").Ref<number>;
+    height: import("vue").Ref<number>;
+};
+export { useAutoResize };

node_modules/element-plus/lib/components/table-v2/src/composables/use-auto-resize.js

@@ -0,0 +1,43 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var vue = require('vue');
+var core = require('@vueuse/core');
+
+const useAutoResize = (props) => {
+  const sizer = vue.ref();
+  const width$ = vue.ref(0);
+  const height$ = vue.ref(0);
+  let resizerStopper;
+  vue.onMounted(() => {
+    resizerStopper = core.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;
+  });
+  vue.onBeforeUnmount(() => {
+    resizerStopper == null ? void 0 : resizerStopper();
+  });
+  vue.watch([width$, height$], ([width, height]) => {
+    var _a;
+    (_a = props.onResize) == null ? void 0 : _a.call(props, {
+      width,
+      height
+    });
+  });
+  return {
+    sizer,
+    width: width$,
+    height: height$
+  };
+};
+
+exports.useAutoResize = useAutoResize;
+//# sourceMappingURL=use-auto-resize.js.map

node_modules/element-plus/lib/components/table-v2/src/composables/use-auto-resize.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-auto-resize.js","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"],"names":["ref","onMounted","useResizeObserver","onBeforeUnmount","watch"],"mappings":";;;;;;;AAEK,MAAC,aAAa,GAAG,CAAC,KAAK,KAAK;AACjC,EAAE,MAAM,KAAK,GAAGA,OAAG,EAAE,CAAC;AACtB,EAAE,MAAM,MAAM,GAAGA,OAAG,CAAC,CAAC,CAAC,CAAC;AACxB,EAAE,MAAM,OAAO,GAAGA,OAAG,CAAC,CAAC,CAAC,CAAC;AACzB,EAAE,IAAI,cAAc,CAAC;AACrB,EAAEC,aAAS,CAAC,MAAM;AAClB,IAAI,cAAc,GAAGC,sBAAiB,CAAC,KAAK,EAAE,CAAC,CAAC,KAAK,CAAC,KAAK;AAC3D,MAAM,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,KAAK,CAAC,WAAW,CAAC;AAClD,MAAM,MAAM,EAAE,WAAW,EAAE,YAAY,EAAE,UAAU,EAAE,aAAa,EAAE,GAAG,gBAAgB,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC;AACtG,MAAM,MAAM,IAAI,GAAG,MAAM,CAAC,QAAQ,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC;AACrD,MAAM,MAAM,KAAK,GAAG,MAAM,CAAC,QAAQ,CAAC,YAAY,CAAC,IAAI,CAAC,CAAC;AACvD,MAAM,MAAM,GAAG,GAAG,MAAM,CAAC,QAAQ,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC;AACnD,MAAM,MAAM,MAAM,GAAG,MAAM,CAAC,QAAQ,CAAC,aAAa,CAAC,IAAI,CAAC,CAAC;AACzD,MAAM,MAAM,CAAC,KAAK,GAAG,KAAK,GAAG,IAAI,GAAG,KAAK,CAAC;AAC1C,MAAM,OAAO,CAAC,KAAK,GAAG,MAAM,GAAG,GAAG,GAAG,MAAM,CAAC;AAC5C,KAAK,CAAC,CAAC,IAAI,CAAC;AACZ,GAAG,CAAC,CAAC;AACL,EAAEC,mBAAe,CAAC,MAAM;AACxB,IAAI,cAAc,IAAI,IAAI,GAAG,KAAK,CAAC,GAAG,cAAc,EAAE,CAAC;AACvD,GAAG,CAAC,CAAC;AACL,EAAEC,SAAK,CAAC,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,CAAC,CAAC,KAAK,EAAE,MAAM,CAAC,KAAK;AAChD,IAAI,IAAI,EAAE,CAAC;AACX,IAAI,CAAC,EAAE,GAAG,KAAK,CAAC,QAAQ,KAAK,IAAI,GAAG,KAAK,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,KAAK,EAAE;AAC5D,MAAM,KAAK;AACX,MAAM,MAAM;AACZ,KAAK,CAAC,CAAC;AACP,GAAG,CAAC,CAAC;AACL,EAAE,OAAO;AACT,IAAI,KAAK;AACT,IAAI,KAAK,EAAE,MAAM;AACjB,IAAI,MAAM,EAAE,OAAO;AACnB,GAAG,CAAC;AACJ;;;;"}

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

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

node_modules/element-plus/lib/components/table-v2/src/composables/use-columns.js

@@ -0,0 +1,97 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var vue = require('vue');
+var constants = require('../constants.js');
+var _private = require('../private.js');
+var utils = require('./utils.js');
+var shared = require('@vue/shared');
+
+function useColumns(props, columns, fixed) {
+  const _columns = vue.computed(() => vue.unref(columns).map((column, index) => {
+    var _a, _b;
+    return {
+      ...column,
+      key: (_b = (_a = column.key) != null ? _a : column.dataKey) != null ? _b : index
+    };
+  }));
+  const visibleColumns = vue.computed(() => {
+    return vue.unref(_columns).filter((column) => !column.hidden);
+  });
+  const fixedColumnsOnLeft = vue.computed(() => vue.unref(visibleColumns).filter((column) => column.fixed === "left" || column.fixed === true));
+  const fixedColumnsOnRight = vue.computed(() => vue.unref(visibleColumns).filter((column) => column.fixed === "right"));
+  const normalColumns = vue.computed(() => vue.unref(visibleColumns).filter((column) => !column.fixed));
+  const mainColumns = vue.computed(() => {
+    const ret = [];
+    vue.unref(fixedColumnsOnLeft).forEach((column) => {
+      ret.push({
+        ...column,
+        placeholderSign: _private.placeholderSign
+      });
+    });
+    vue.unref(normalColumns).forEach((column) => {
+      ret.push(column);
+    });
+    vue.unref(fixedColumnsOnRight).forEach((column) => {
+      ret.push({
+        ...column,
+        placeholderSign: _private.placeholderSign
+      });
+    });
+    return ret;
+  });
+  const hasFixedColumns = vue.computed(() => {
+    return vue.unref(fixedColumnsOnLeft).length || vue.unref(fixedColumnsOnRight).length;
+  });
+  const columnsStyles = vue.computed(() => {
+    return vue.unref(_columns).reduce((style, column) => {
+      style[column.key] = utils.calcColumnStyle(column, vue.unref(fixed), props.fixed);
+      return style;
+    }, {});
+  });
+  const columnsTotalWidth = vue.computed(() => {
+    return vue.unref(visibleColumns).reduce((width, column) => width + column.width, 0);
+  });
+  const getColumn = (key) => {
+    return vue.unref(_columns).find((column) => column.key === key);
+  };
+  const getColumnStyle = (key) => {
+    return vue.unref(columnsStyles)[key];
+  };
+  const updateColumnWidth = (column, width) => {
+    column.width = width;
+  };
+  function onColumnSorted(e) {
+    var _a;
+    const { key } = e.currentTarget.dataset;
+    if (!key)
+      return;
+    const { sortState, sortBy } = props;
+    let order = constants.SortOrder.ASC;
+    if (shared.isObject(sortState)) {
+      order = constants.oppositeOrderMap[sortState[key]];
+    } else {
+      order = constants.oppositeOrderMap[sortBy.order];
+    }
+    (_a = props.onColumnSort) == null ? void 0 : _a.call(props, { column: getColumn(key), key, order });
+  }
+  return {
+    columns: _columns,
+    columnsStyles,
+    columnsTotalWidth,
+    fixedColumnsOnLeft,
+    fixedColumnsOnRight,
+    hasFixedColumns,
+    mainColumns,
+    normalColumns,
+    visibleColumns,
+    getColumn,
+    getColumnStyle,
+    updateColumnWidth,
+    onColumnSorted
+  };
+}
+
+exports.useColumns = useColumns;
+//# sourceMappingURL=use-columns.js.map

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

@@ -0,0 +1,14 @@
+import type { TableV2Props } from '../table';
+import type { KeyType } from '../types';
+import type { UseRowReturn } from './use-row';
+type UseDataProps = {
+    expandedRowKeys: UseRowReturn['expandedRowKeys'];
+    lastRenderedRowIndex: UseRowReturn['lastRenderedRowIndex'];
+    resetAfterIndex: UseRowReturn['resetAfterIndex'];
+};
+export declare const useData: (props: TableV2Props, { expandedRowKeys, lastRenderedRowIndex, resetAfterIndex }: UseDataProps) => {
+    data: import("vue").ComputedRef<any[]>;
+    depthMap: import("vue").Ref<Record<KeyType, number>>;
+};
+export type UseDataReturn = ReturnType<typeof useData>;
+export {};

node_modules/element-plus/lib/components/table-v2/src/composables/use-data.js

@@ -0,0 +1,49 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var vue = require('vue');
+var shared = require('@vue/shared');
+
+const useData = (props, { expandedRowKeys, lastRenderedRowIndex, resetAfterIndex }) => {
+  const depthMap = vue.ref({});
+  const flattenedData = vue.computed(() => {
+    const depths = {};
+    const { data: data2, rowKey } = props;
+    const _expandedRowKeys = vue.unref(expandedRowKeys);
+    if (!_expandedRowKeys || !_expandedRowKeys.length)
+      return data2;
+    const array = [];
+    const keysSet = /* @__PURE__ */ new Set();
+    _expandedRowKeys.forEach((x) => keysSet.add(x));
+    let copy = data2.slice();
+    copy.forEach((x) => depths[x[rowKey]] = 0);
+    while (copy.length > 0) {
+      const item = copy.shift();
+      array.push(item);
+      if (keysSet.has(item[rowKey]) && shared.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 = vue.computed(() => {
+    const { data: data2, expandColumnKey } = props;
+    return expandColumnKey ? vue.unref(flattenedData) : data2;
+  });
+  vue.watch(data, (val, prev) => {
+    if (val !== prev) {
+      lastRenderedRowIndex.value = -1;
+      resetAfterIndex(0, true);
+    }
+  });
+  return {
+    data,
+    depthMap
+  };
+};
+
+exports.useData = useData;
+//# sourceMappingURL=use-data.js.map

node_modules/element-plus/lib/components/table-v2/src/composables/use-data.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-data.js","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"],"names":["ref","computed","unref","isArray","watch"],"mappings":";;;;;;;AAEY,MAAC,OAAO,GAAG,CAAC,KAAK,EAAE,EAAE,eAAe,EAAE,oBAAoB,EAAE,eAAe,EAAE,KAAK;AAC9F,EAAE,MAAM,QAAQ,GAAGA,OAAG,CAAC,EAAE,CAAC,CAAC;AAC3B,EAAE,MAAM,aAAa,GAAGC,YAAQ,CAAC,MAAM;AACvC,IAAI,MAAM,MAAM,GAAG,EAAE,CAAC;AACtB,IAAI,MAAM,EAAE,IAAI,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,KAAK,CAAC;AAC1C,IAAI,MAAM,gBAAgB,GAAGC,SAAK,CAAC,eAAe,CAAC,CAAC;AACpD,IAAI,IAAI,CAAC,gBAAgB,IAAI,CAAC,gBAAgB,CAAC,MAAM;AACrD,MAAM,OAAO,KAAK,CAAC;AACnB,IAAI,MAAM,KAAK,GAAG,EAAE,CAAC;AACrB,IAAI,MAAM,OAAO,mBAAmB,IAAI,GAAG,EAAE,CAAC;AAC9C,IAAI,gBAAgB,CAAC,OAAO,CAAC,CAAC,CAAC,KAAK,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;AACpD,IAAI,IAAI,IAAI,GAAG,KAAK,CAAC,KAAK,EAAE,CAAC;AAC7B,IAAI,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,KAAK,MAAM,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;AAC/C,IAAI,OAAO,IAAI,CAAC,MAAM,GAAG,CAAC,EAAE;AAC5B,MAAM,MAAM,IAAI,GAAG,IAAI,CAAC,KAAK,EAAE,CAAC;AAChC,MAAM,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;AACvB,MAAM,IAAI,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,IAAIC,cAAO,CAAC,IAAI,CAAC,QAAQ,CAAC,IAAI,IAAI,CAAC,QAAQ,CAAC,MAAM,GAAG,CAAC,EAAE;AAC3F,QAAQ,IAAI,GAAG,CAAC,GAAG,IAAI,CAAC,QAAQ,EAAE,GAAG,IAAI,CAAC,CAAC;AAC3C,QAAQ,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC,KAAK,KAAK,MAAM,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,GAAG,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;AAC3F,OAAO;AACP,KAAK;AACL,IAAI,QAAQ,CAAC,KAAK,GAAG,MAAM,CAAC;AAC5B,IAAI,OAAO,KAAK,CAAC;AACjB,GAAG,CAAC,CAAC;AACL,EAAE,MAAM,IAAI,GAAGF,YAAQ,CAAC,MAAM;AAC9B,IAAI,MAAM,EAAE,IAAI,EAAE,KAAK,EAAE,eAAe,EAAE,GAAG,KAAK,CAAC;AACnD,IAAI,OAAO,eAAe,GAAGC,SAAK,CAAC,aAAa,CAAC,GAAG,KAAK,CAAC;AAC1D,GAAG,CAAC,CAAC;AACL,EAAEE,SAAK,CAAC,IAAI,EAAE,CAAC,GAAG,EAAE,IAAI,KAAK;AAC7B,IAAI,IAAI,GAAG,KAAK,IAAI,EAAE;AACtB,MAAM,oBAAoB,CAAC,KAAK,GAAG,CAAC,CAAC,CAAC;AACtC,MAAM,eAAe,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC;AAC/B,KAAK;AACL,GAAG,CAAC,CAAC;AACL,EAAE,OAAO;AACT,IAAI,IAAI;AACR,IAAI,QAAQ;AACZ,GAAG,CAAC;AACJ;;;;"}

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

@@ -0,0 +1,31 @@
+import type { ComponentInternalInstance, Ref, ShallowRef } from 'vue';
+import type { TableV2Props } from '../table';
+import type { RowExpandParams, RowHeightChangedParams, RowHoverParams } from '../row';
+import type { FixedDirection, KeyType } from '../types';
+import type { onRowRenderedParams } from '../grid';
+import type { TableGridInstance } from '../table-grid';
+import type { UseNamespaceReturn } from 'element-plus/es/hooks';
+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>;
+};
+export declare const useRow: (props: TableV2Props, { mainTableRef, leftTableRef, rightTableRef, tableInstance, ns, isScrolling, }: UseRowProps) => {
+    expandedRowKeys: Ref<KeyType[]>;
+    lastRenderedRowIndex: Ref<number>;
+    isDynamic: import("vue").ComputedRef<boolean>;
+    isResetting: ShallowRef<boolean>;
+    rowHeights: Ref<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;
+};
+export type UseRowReturn = ReturnType<typeof useRow>;
+export {};

node_modules/element-plus/lib/components/table-v2/src/composables/use-row.js

@@ -0,0 +1,146 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var vue = require('vue');
+var lodashUnified = require('lodash-unified');
+var constants = require('../constants.js');
+var types = require('../../../../utils/types.js');
+
+const useRow = (props, {
+  mainTableRef,
+  leftTableRef,
+  rightTableRef,
+  tableInstance,
+  ns,
+  isScrolling
+}) => {
+  const vm = vue.getCurrentInstance();
+  const { emit } = vm;
+  const isResetting = vue.shallowRef(false);
+  const expandedRowKeys = vue.ref(props.defaultExpandedRowKeys || []);
+  const lastRenderedRowIndex = vue.ref(-1);
+  const resetIndex = vue.shallowRef(null);
+  const rowHeights = vue.ref({});
+  const pendingRowHeights = vue.ref({});
+  const leftTableHeights = vue.shallowRef({});
+  const mainTableHeights = vue.shallowRef({});
+  const rightTableHeights = vue.shallowRef({});
+  const isDynamic = vue.computed(() => types.isNumber(props.estimatedRowHeight));
+  function onRowsRendered(params) {
+    var _a;
+    (_a = props.onRowsRendered) == null ? void 0 : _a.call(props, params);
+    if (params.rowCacheEnd > vue.unref(lastRenderedRowIndex)) {
+      lastRenderedRowIndex.value = params.rowCacheEnd;
+    }
+  }
+  function onRowHovered({ hovered, rowKey }) {
+    if (isScrolling.value) {
+      return;
+    }
+    const tableRoot = tableInstance.vnode.el;
+    const rows = tableRoot.querySelectorAll(`[rowkey="${String(rowKey)}"]`);
+    rows.forEach((row) => {
+      if (hovered) {
+        row.classList.add(ns.is("hovered"));
+      } else {
+        row.classList.remove(ns.is("hovered"));
+      }
+    });
+  }
+  function onRowExpanded({
+    expanded,
+    rowData,
+    rowIndex,
+    rowKey
+  }) {
+    var _a, _b;
+    const _expandedRowKeys = [...vue.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);
+    (_a = props.onRowExpand) == null ? void 0 : _a.call(props, {
+      expanded,
+      rowData,
+      rowIndex,
+      rowKey
+    });
+    (_b = props.onExpandedRowsChange) == null ? void 0 : _b.call(props, _expandedRowKeys);
+    const tableRoot = tableInstance.vnode.el;
+    const hoverRow = tableRoot.querySelector(`.${ns.is("hovered")}[rowkey="${String(rowKey)}"]`);
+    if (hoverRow) {
+      vue.nextTick(() => onRowHovered({ hovered: true, rowKey }));
+    }
+  }
+  const flushingRowHeights = lodashUnified.debounce(() => {
+    var _a, _b, _c, _d;
+    isResetting.value = true;
+    rowHeights.value = { ...vue.unref(rowHeights), ...vue.unref(pendingRowHeights) };
+    resetAfterIndex(vue.unref(resetIndex), false);
+    pendingRowHeights.value = {};
+    resetIndex.value = null;
+    (_a = mainTableRef.value) == null ? void 0 : _a.forceUpdate();
+    (_b = leftTableRef.value) == null ? void 0 : _b.forceUpdate();
+    (_c = rightTableRef.value) == null ? void 0 : _c.forceUpdate();
+    (_d = vm.proxy) == null ? void 0 : _d.$forceUpdate();
+    isResetting.value = false;
+  }, 0);
+  function resetAfterIndex(index, forceUpdate = false) {
+    if (!vue.unref(isDynamic))
+      return;
+    [mainTableRef, leftTableRef, rightTableRef].forEach((tableRef) => {
+      const table = vue.unref(tableRef);
+      if (table)
+        table.resetAfterRowIndex(index, forceUpdate);
+    });
+  }
+  function resetHeights(rowKey, height, rowIdx) {
+    const resetIdx = vue.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 === constants.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 (vue.unref(rowHeights)[rowKey] !== maximumHeight) {
+      resetHeights(rowKey, maximumHeight, rowIndex);
+      flushingRowHeights();
+    }
+  }
+  return {
+    expandedRowKeys,
+    lastRenderedRowIndex,
+    isDynamic,
+    isResetting,
+    rowHeights,
+    resetAfterIndex,
+    onRowExpanded,
+    onRowHovered,
+    onRowsRendered,
+    onRowHeightChange
+  };
+};
+
+exports.useRow = useRow;
+//# sourceMappingURL=use-row.js.map

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

@@ -0,0 +1,28 @@
+import type { Ref } from 'vue';
+import type { Alignment as ScrollStrategy } from 'element-plus/es/components/virtual-list';
+import type { TableV2Props } from '../table';
+import type { TableGridInstance } from '../table-grid';
+export type ScrollPos = {
+    scrollLeft: number;
+    scrollTop: number;
+};
+type GridInstanceRef = Ref<TableGridInstance | undefined>;
+type UseScrollBarProps = {
+    mainTableRef: GridInstanceRef;
+    leftTableRef: GridInstanceRef;
+    rightTableRef: GridInstanceRef;
+    onMaybeEndReached: () => void;
+};
+export type { ScrollStrategy };
+export declare const useScrollbar: (props: TableV2Props, { mainTableRef, leftTableRef, rightTableRef, onMaybeEndReached, }: UseScrollBarProps) => {
+    scrollPos: Ref<{
+        scrollLeft: number;
+        scrollTop: number;
+    }>;
+    scrollTo: (params: ScrollPos) => void;
+    scrollToLeft: (scrollLeft: number) => void;
+    scrollToTop: (scrollTop: number) => void;
+    scrollToRow: (row: number, strategy?: ScrollStrategy) => void;
+    onScroll: (params: ScrollPos) => void;
+    onVerticalScroll: ({ scrollTop }: ScrollPos) => void;
+};

node_modules/element-plus/lib/components/table-v2/src/composables/use-scrollbar.js

@@ -0,0 +1,64 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var vue = require('vue');
+
+const useScrollbar = (props, {
+  mainTableRef,
+  leftTableRef,
+  rightTableRef,
+  onMaybeEndReached
+}) => {
+  const scrollPos = vue.ref({ scrollLeft: 0, scrollTop: 0 });
+  function doScroll(params) {
+    var _a, _b, _c;
+    const { scrollTop } = params;
+    (_a = mainTableRef.value) == null ? void 0 : _a.scrollTo(params);
+    (_b = leftTableRef.value) == null ? void 0 : _b.scrollToTop(scrollTop);
+    (_c = rightTableRef.value) == null ? void 0 : _c.scrollToTop(scrollTop);
+  }
+  function scrollTo(params) {
+    scrollPos.value = params;
+    doScroll(params);
+  }
+  function scrollToTop(scrollTop) {
+    scrollPos.value.scrollTop = scrollTop;
+    doScroll(vue.unref(scrollPos));
+  }
+  function scrollToLeft(scrollLeft) {
+    var _a, _b;
+    scrollPos.value.scrollLeft = scrollLeft;
+    (_b = (_a = mainTableRef.value) == null ? void 0 : _a.scrollTo) == null ? void 0 : _b.call(_a, vue.unref(scrollPos));
+  }
+  function onScroll(params) {
+    var _a;
+    scrollTo(params);
+    (_a = props.onScroll) == null ? void 0 : _a.call(props, params);
+  }
+  function onVerticalScroll({ scrollTop }) {
+    const { scrollTop: currentScrollTop } = vue.unref(scrollPos);
+    if (scrollTop !== currentScrollTop)
+      scrollToTop(scrollTop);
+  }
+  function scrollToRow(row, strategy = "auto") {
+    var _a;
+    (_a = mainTableRef.value) == null ? void 0 : _a.scrollToRow(row, strategy);
+  }
+  vue.watch(() => vue.unref(scrollPos).scrollTop, (cur, prev) => {
+    if (cur > prev)
+      onMaybeEndReached();
+  });
+  return {
+    scrollPos,
+    scrollTo,
+    scrollToLeft,
+    scrollToTop,
+    scrollToRow,
+    onScroll,
+    onVerticalScroll
+  };
+};
+
+exports.useScrollbar = useScrollbar;
+//# sourceMappingURL=use-scrollbar.js.map

node_modules/element-plus/lib/components/table-v2/src/composables/use-scrollbar.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-scrollbar.js","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"],"names":["ref","unref","watch"],"mappings":";;;;;;AACY,MAAC,YAAY,GAAG,CAAC,KAAK,EAAE;AACpC,EAAE,YAAY;AACd,EAAE,YAAY;AACd,EAAE,aAAa;AACf,EAAE,iBAAiB;AACnB,CAAC,KAAK;AACN,EAAE,MAAM,SAAS,GAAGA,OAAG,CAAC,EAAE,UAAU,EAAE,CAAC,EAAE,SAAS,EAAE,CAAC,EAAE,CAAC,CAAC;AACzD,EAAE,SAAS,QAAQ,CAAC,MAAM,EAAE;AAC5B,IAAI,IAAI,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC;AACnB,IAAI,MAAM,EAAE,SAAS,EAAE,GAAG,MAAM,CAAC;AACjC,IAAI,CAAC,EAAE,GAAG,YAAY,CAAC,KAAK,KAAK,IAAI,GAAG,KAAK,CAAC,GAAG,EAAE,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC;AACrE,IAAI,CAAC,EAAE,GAAG,YAAY,CAAC,KAAK,KAAK,IAAI,GAAG,KAAK,CAAC,GAAG,EAAE,CAAC,WAAW,CAAC,SAAS,CAAC,CAAC;AAC3E,IAAI,CAAC,EAAE,GAAG,aAAa,CAAC,KAAK,KAAK,IAAI,GAAG,KAAK,CAAC,GAAG,EAAE,CAAC,WAAW,CAAC,SAAS,CAAC,CAAC;AAC5E,GAAG;AACH,EAAE,SAAS,QAAQ,CAAC,MAAM,EAAE;AAC5B,IAAI,SAAS,CAAC,KAAK,GAAG,MAAM,CAAC;AAC7B,IAAI,QAAQ,CAAC,MAAM,CAAC,CAAC;AACrB,GAAG;AACH,EAAE,SAAS,WAAW,CAAC,SAAS,EAAE;AAClC,IAAI,SAAS,CAAC,KAAK,CAAC,SAAS,GAAG,SAAS,CAAC;AAC1C,IAAI,QAAQ,CAACC,SAAK,CAAC,SAAS,CAAC,CAAC,CAAC;AAC/B,GAAG;AACH,EAAE,SAAS,YAAY,CAAC,UAAU,EAAE;AACpC,IAAI,IAAI,EAAE,EAAE,EAAE,CAAC;AACf,IAAI,SAAS,CAAC,KAAK,CAAC,UAAU,GAAG,UAAU,CAAC;AAC5C,IAAI,CAAC,EAAE,GAAG,CAAC,EAAE,GAAG,YAAY,CAAC,KAAK,KAAK,IAAI,GAAG,KAAK,CAAC,GAAG,EAAE,CAAC,QAAQ,KAAK,IAAI,GAAG,KAAK,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,EAAE,EAAEA,SAAK,CAAC,SAAS,CAAC,CAAC,CAAC;AACrH,GAAG;AACH,EAAE,SAAS,QAAQ,CAAC,MAAM,EAAE;AAC5B,IAAI,IAAI,EAAE,CAAC;AACX,IAAI,QAAQ,CAAC,MAAM,CAAC,CAAC;AACrB,IAAI,CAAC,EAAE,GAAG,KAAK,CAAC,QAAQ,KAAK,IAAI,GAAG,KAAK,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC;AACpE,GAAG;AACH,EAAE,SAAS,gBAAgB,CAAC,EAAE,SAAS,EAAE,EAAE;AAC3C,IAAI,MAAM,EAAE,SAAS,EAAE,gBAAgB,EAAE,GAAGA,SAAK,CAAC,SAAS,CAAC,CAAC;AAC7D,IAAI,IAAI,SAAS,KAAK,gBAAgB;AACtC,MAAM,WAAW,CAAC,SAAS,CAAC,CAAC;AAC7B,GAAG;AACH,EAAE,SAAS,WAAW,CAAC,GAAG,EAAE,QAAQ,GAAG,MAAM,EAAE;AAC/C,IAAI,IAAI,EAAE,CAAC;AACX,IAAI,CAAC,EAAE,GAAG,YAAY,CAAC,KAAK,KAAK,IAAI,GAAG,KAAK,CAAC,GAAG,EAAE,CAAC,WAAW,CAAC,GAAG,EAAE,QAAQ,CAAC,CAAC;AAC/E,GAAG;AACH,EAAEC,SAAK,CAAC,MAAMD,SAAK,CAAC,SAAS,CAAC,CAAC,SAAS,EAAE,CAAC,GAAG,EAAE,IAAI,KAAK;AACzD,IAAI,IAAI,GAAG,GAAG,IAAI;AAClB,MAAM,iBAAiB,EAAE,CAAC;AAC1B,GAAG,CAAC,CAAC;AACL,EAAE,OAAO;AACT,IAAI,SAAS;AACb,IAAI,QAAQ;AACZ,IAAI,YAAY;AAChB,IAAI,WAAW;AACf,IAAI,WAAW;AACf,IAAI,QAAQ;AACZ,IAAI,gBAAgB;AACpB,GAAG,CAAC;AACJ;;;;"}

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

@@ -0,0 +1,23 @@
+import type { CSSProperties, ComputedRef } from 'vue';
+import type { TableV2Props } from '../table';
+import type { UseColumnsReturn } from './use-columns';
+type UseStyleProps = {
+    columnsTotalWidth: UseColumnsReturn['columnsTotalWidth'];
+    fixedColumnsOnLeft: UseColumnsReturn['fixedColumnsOnLeft'];
+    fixedColumnsOnRight: UseColumnsReturn['fixedColumnsOnRight'];
+    rowsHeight: ComputedRef<number>;
+};
+export 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>;
+};
+export type UseStyleReturn = ReturnType<typeof useStyles>;
+export {};

node_modules/element-plus/lib/components/table-v2/src/composables/use-styles.js

@@ -0,0 +1,80 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var vue = require('vue');
+var utils = require('../utils.js');
+var types = require('../../../../utils/types.js');
+var style = require('../../../../utils/dom/style.js');
+
+const useStyles = (props, {
+  columnsTotalWidth,
+  rowsHeight,
+  fixedColumnsOnLeft,
+  fixedColumnsOnRight
+}) => {
+  const bodyWidth = vue.computed(() => {
+    const { fixed, width, vScrollbarSize } = props;
+    const ret = width - vScrollbarSize;
+    return fixed ? Math.max(Math.round(vue.unref(columnsTotalWidth)), ret) : ret;
+  });
+  const mainTableHeight = vue.computed(() => {
+    const { height = 0, maxHeight = 0, footerHeight: footerHeight2, hScrollbarSize } = props;
+    if (maxHeight > 0) {
+      const _fixedRowsHeight = vue.unref(fixedRowsHeight);
+      const _rowsHeight = vue.unref(rowsHeight);
+      const _headerHeight = vue.unref(headerHeight);
+      const total = _headerHeight + _fixedRowsHeight + _rowsHeight + hScrollbarSize;
+      return Math.min(total, maxHeight - footerHeight2);
+    }
+    return height - footerHeight2;
+  });
+  const fixedTableHeight = vue.computed(() => {
+    const { maxHeight } = props;
+    const tableHeight = vue.unref(mainTableHeight);
+    if (types.isNumber(maxHeight) && maxHeight > 0)
+      return tableHeight;
+    const totalHeight = vue.unref(rowsHeight) + vue.unref(headerHeight) + vue.unref(fixedRowsHeight);
+    return Math.min(tableHeight, totalHeight);
+  });
+  const mapColumn = (column) => column.width;
+  const leftTableWidth = vue.computed(() => utils.sum(vue.unref(fixedColumnsOnLeft).map(mapColumn)));
+  const rightTableWidth = vue.computed(() => utils.sum(vue.unref(fixedColumnsOnRight).map(mapColumn)));
+  const headerHeight = vue.computed(() => utils.sum(props.headerHeight));
+  const fixedRowsHeight = vue.computed(() => {
+    var _a;
+    return (((_a = props.fixedData) == null ? void 0 : _a.length) || 0) * props.rowHeight;
+  });
+  const windowHeight = vue.computed(() => {
+    return vue.unref(mainTableHeight) - vue.unref(headerHeight) - vue.unref(fixedRowsHeight);
+  });
+  const rootStyle = vue.computed(() => {
+    const { style = {}, height, width } = props;
+    return utils.enforceUnit({
+      ...style,
+      height,
+      width
+    });
+  });
+  const footerHeight = vue.computed(() => utils.enforceUnit({ height: props.footerHeight }));
+  const emptyStyle = vue.computed(() => ({
+    top: style.addUnit(vue.unref(headerHeight)),
+    bottom: style.addUnit(props.footerHeight),
+    width: style.addUnit(props.width)
+  }));
+  return {
+    bodyWidth,
+    fixedTableHeight,
+    mainTableHeight,
+    leftTableWidth,
+    rightTableWidth,
+    windowHeight,
+    footerHeight,
+    emptyStyle,
+    rootStyle,
+    headerHeight
+  };
+};
+
+exports.useStyles = useStyles;
+//# sourceMappingURL=use-styles.js.map

node_modules/element-plus/lib/components/table-v2/src/composables/utils.d.ts

@@ -0,0 +1,3 @@
+import type { CSSProperties } from 'vue';
+import type { AnyColumns } from '../types';
+export declare const calcColumnStyle: (column: AnyColumns[number], fixedColumn: boolean, fixed: boolean) => CSSProperties;

node_modules/element-plus/lib/components/table-v2/src/composables/utils.js

@@ -0,0 +1,34 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+const calcColumnStyle = (column, fixedColumn, fixed) => {
+  var _a;
+  const flex = {
+    flexGrow: 0,
+    flexShrink: 0,
+    ...fixed ? {} : {
+      flexGrow: column.flexGrow || 0,
+      flexShrink: column.flexShrink || 1
+    }
+  };
+  if (!fixed) {
+    flex.flexShrink = 1;
+  }
+  const style = {
+    ...(_a = column.style) != null ? _a : {},
+    ...flex,
+    flexBasis: "auto",
+    width: column.width
+  };
+  if (!fixedColumn) {
+    if (column.maxWidth)
+      style.maxWidth = column.maxWidth;
+    if (column.minWidth)
+      style.minWidth = column.minWidth;
+  }
+  return style;
+};
+
+exports.calcColumnStyle = calcColumnStyle;
+//# sourceMappingURL=utils.js.map

node_modules/element-plus/lib/components/table-v2/src/composables/utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.js","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  if (!fixed) {\n    flex.flexShrink = 1\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"],"names":[],"mappings":";;;;AAAY,MAAC,eAAe,GAAG,CAAC,MAAM,EAAE,WAAW,EAAE,KAAK,KAAK;AAC/D,EAAE,IAAI,EAAE,CAAC;AACT,EAAE,MAAM,IAAI,GAAG;AACf,IAAI,QAAQ,EAAE,CAAC;AACf,IAAI,UAAU,EAAE,CAAC;AACjB,IAAI,GAAG,KAAK,GAAG,EAAE,GAAG;AACpB,MAAM,QAAQ,EAAE,MAAM,CAAC,QAAQ,IAAI,CAAC;AACpC,MAAM,UAAU,EAAE,MAAM,CAAC,UAAU,IAAI,CAAC;AACxC,KAAK;AACL,GAAG,CAAC;AACJ,EAAE,IAAI,CAAC,KAAK,EAAE;AACd,IAAI,IAAI,CAAC,UAAU,GAAG,CAAC,CAAC;AACxB,GAAG;AACH,EAAE,MAAM,KAAK,GAAG;AAChB,IAAI,GAAG,CAAC,EAAE,GAAG,MAAM,CAAC,KAAK,KAAK,IAAI,GAAG,EAAE,GAAG,EAAE;AAC5C,IAAI,GAAG,IAAI;AACX,IAAI,SAAS,EAAE,MAAM;AACrB,IAAI,KAAK,EAAE,MAAM,CAAC,KAAK;AACvB,GAAG,CAAC;AACJ,EAAE,IAAI,CAAC,WAAW,EAAE;AACpB,IAAI,IAAI,MAAM,CAAC,QAAQ;AACvB,MAAM,KAAK,CAAC,QAAQ,GAAG,MAAM,CAAC,QAAQ,CAAC;AACvC,IAAI,IAAI,MAAM,CAAC,QAAQ;AACvB,MAAM,KAAK,CAAC,QAAQ,GAAG,MAAM,CAAC,QAAQ,CAAC;AACvC,GAAG;AACH,EAAE,OAAO,KAAK,CAAC;AACf;;;;"}

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

@@ -0,0 +1,18 @@
+export declare enum SortOrder {
+    ASC = "asc",
+    DESC = "desc"
+}
+export declare enum Alignment {
+    LEFT = "left",
+    CENTER = "center",
+    RIGHT = "right"
+}
+export declare enum FixedDir {
+    LEFT = "left",
+    RIGHT = "right"
+}
+export declare const oppositeOrderMap: {
+    asc: SortOrder;
+    desc: SortOrder;
+};
+export declare const sortOrders: readonly [SortOrder.ASC, SortOrder.DESC];

node_modules/element-plus/lib/components/table-v2/src/constants.js

@@ -0,0 +1,32 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var SortOrder = /* @__PURE__ */ ((SortOrder2) => {
+  SortOrder2["ASC"] = "asc";
+  SortOrder2["DESC"] = "desc";
+  return SortOrder2;
+})(SortOrder || {});
+var Alignment = /* @__PURE__ */ ((Alignment2) => {
+  Alignment2["LEFT"] = "left";
+  Alignment2["CENTER"] = "center";
+  Alignment2["RIGHT"] = "right";
+  return Alignment2;
+})(Alignment || {});
+var FixedDir = /* @__PURE__ */ ((FixedDir2) => {
+  FixedDir2["LEFT"] = "left";
+  FixedDir2["RIGHT"] = "right";
+  return FixedDir2;
+})(FixedDir || {});
+const oppositeOrderMap = {
+  ["asc" /* ASC */]: "desc" /* DESC */,
+  ["desc" /* DESC */]: "asc" /* ASC */
+};
+const sortOrders = ["asc" /* ASC */, "desc" /* DESC */];
+
+exports.Alignment = Alignment;
+exports.FixedDir = FixedDir;
+exports.SortOrder = SortOrder;
+exports.oppositeOrderMap = oppositeOrderMap;
+exports.sortOrders = sortOrders;
+//# sourceMappingURL=constants.js.map

node_modules/element-plus/lib/components/table-v2/src/constants.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.js","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"],"names":[],"mappings":";;;;AAAU,IAAC,SAAS,mBAAmB,CAAC,CAAC,UAAU,KAAK;AACxD,EAAE,UAAU,CAAC,KAAK,CAAC,GAAG,KAAK,CAAC;AAC5B,EAAE,UAAU,CAAC,MAAM,CAAC,GAAG,MAAM,CAAC;AAC9B,EAAE,OAAO,UAAU,CAAC;AACpB,CAAC,EAAE,SAAS,IAAI,EAAE,EAAE;AACV,IAAC,SAAS,mBAAmB,CAAC,CAAC,UAAU,KAAK;AACxD,EAAE,UAAU,CAAC,MAAM,CAAC,GAAG,MAAM,CAAC;AAC9B,EAAE,UAAU,CAAC,QAAQ,CAAC,GAAG,QAAQ,CAAC;AAClC,EAAE,UAAU,CAAC,OAAO,CAAC,GAAG,OAAO,CAAC;AAChC,EAAE,OAAO,UAAU,CAAC;AACpB,CAAC,EAAE,SAAS,IAAI,EAAE,EAAE;AACV,IAAC,QAAQ,mBAAmB,CAAC,CAAC,SAAS,KAAK;AACtD,EAAE,SAAS,CAAC,MAAM,CAAC,GAAG,MAAM,CAAC;AAC7B,EAAE,SAAS,CAAC,OAAO,CAAC,GAAG,OAAO,CAAC;AAC/B,EAAE,OAAO,SAAS,CAAC;AACnB,CAAC,EAAE,QAAQ,IAAI,EAAE,EAAE;AACP,MAAC,gBAAgB,GAAG;AAChC,EAAE,CAAC,KAAK,aAAa,MAAM;AAC3B,EAAE,CAAC,MAAM,cAAc,KAAK;AAC5B,EAAE;AACU,MAAC,UAAU,GAAG,CAAC,KAAK,YAAY,MAAM;;;;;;;;"}

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

@@ -0,0 +1,105 @@
+import type { ExtractPropTypes, __ExtractPublicPropTypes } from 'vue';
+import type { ItemSize } from 'element-plus/es/components/virtual-list';
+export type onRowRenderedParams = {
+    rowCacheStart: number;
+    rowCacheEnd: number;
+    rowVisibleStart: number;
+    rowVisibleEnd: number;
+};
+export declare const tableV2GridProps: {
+    readonly columns: {
+        readonly type: import("vue").PropType<import("./common").AnyColumn[]>;
+        readonly required: true;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly data: {
+        readonly type: import("vue").PropType<any[]>;
+        readonly required: true;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly fixedData: {
+        readonly type: import("vue").PropType<any[]>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly estimatedRowHeight: {
+        readonly default: undefined;
+        readonly type: import("vue").PropType<number>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        readonly __epPropKey: true;
+    };
+    readonly width: {
+        readonly type: import("vue").PropType<number>;
+        readonly required: true;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly height: {
+        readonly type: import("vue").PropType<number>;
+        readonly required: true;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly headerWidth: {
+        readonly type: import("vue").PropType<number>;
+        readonly required: true;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly headerHeight: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => number | number[]) | (() => number | number[]) | ((new (...args: any[]) => number | number[]) | (() => number | number[]))[], unknown, unknown, 50, boolean>;
+    readonly bodyWidth: {
+        readonly type: import("vue").PropType<number>;
+        readonly required: true;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly rowHeight: {
+        readonly type: import("vue").PropType<number>;
+        readonly required: true;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly cache: import("element-plus/es/utils").EpPropFinalized<NumberConstructor, never, never, 2, false>;
+    readonly useIsScrolling: BooleanConstructor;
+    readonly scrollbarAlwaysOn: BooleanConstructor;
+    readonly scrollbarStartGap: import("element-plus/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;
+    readonly scrollbarEndGap: import("element-plus/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 2, boolean>;
+    readonly class: StringConstructor;
+    readonly style: {
+        readonly type: import("vue").PropType<import("vue").CSSProperties>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly containerStyle: {
+        readonly type: import("vue").PropType<import("vue").CSSProperties>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly getRowHeight: {
+        readonly type: import("vue").PropType<ItemSize>;
+        readonly required: true;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly rowKey: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => string | number | symbol) | (() => import("./types").KeyType) | ((new (...args: any[]) => string | number | symbol) | (() => import("./types").KeyType))[], unknown, unknown, "id", boolean>;
+    readonly onRowsRendered: {
+        readonly type: import("vue").PropType<(params: onRowRenderedParams) => void>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly onScroll: {
+        readonly type: import("vue").PropType<(...args: any[]) => void>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+};
+export type TableV2GridProps = ExtractPropTypes<typeof tableV2GridProps>;
+export type TableV2GridPropsPublic = __ExtractPublicPropTypes<typeof tableV2GridProps>;

node_modules/element-plus/lib/components/table-v2/src/grid.js

@@ -0,0 +1,44 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var common = require('./common.js');
+var header = require('./header.js');
+var row = require('./row.js');
+var props = require('../../virtual-list/src/props.js');
+var runtime = require('../../../utils/vue/props/runtime.js');
+
+const tableV2GridProps = runtime.buildProps({
+  columns: common.columns,
+  data: common.dataType,
+  fixedData: common.fixedDataType,
+  estimatedRowHeight: row.tableV2RowProps.estimatedRowHeight,
+  width: common.requiredNumber,
+  height: common.requiredNumber,
+  headerWidth: common.requiredNumber,
+  headerHeight: header.tableV2HeaderProps.headerHeight,
+  bodyWidth: common.requiredNumber,
+  rowHeight: common.requiredNumber,
+  cache: props.virtualizedListProps.cache,
+  useIsScrolling: Boolean,
+  scrollbarAlwaysOn: props.virtualizedGridProps.scrollbarAlwaysOn,
+  scrollbarStartGap: props.virtualizedGridProps.scrollbarStartGap,
+  scrollbarEndGap: props.virtualizedGridProps.scrollbarEndGap,
+  class: common.classType,
+  style: common.styleType,
+  containerStyle: common.styleType,
+  getRowHeight: {
+    type: runtime.definePropType(Function),
+    required: true
+  },
+  rowKey: row.tableV2RowProps.rowKey,
+  onRowsRendered: {
+    type: runtime.definePropType(Function)
+  },
+  onScroll: {
+    type: runtime.definePropType(Function)
+  }
+});
+
+exports.tableV2GridProps = tableV2GridProps;
+//# sourceMappingURL=grid.js.map

node_modules/element-plus/lib/components/table-v2/src/grid.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"grid.js","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"],"names":["buildProps","columns","dataType","fixedDataType","tableV2RowProps","requiredNumber","tableV2HeaderProps","virtualizedListProps","virtualizedGridProps","classType","styleType","definePropType"],"mappings":";;;;;;;;;;AAeY,MAAC,gBAAgB,GAAGA,kBAAU,CAAC;AAC3C,WAAEC,cAAO;AACT,EAAE,IAAI,EAAEC,eAAQ;AAChB,EAAE,SAAS,EAAEC,oBAAa;AAC1B,EAAE,kBAAkB,EAAEC,mBAAe,CAAC,kBAAkB;AACxD,EAAE,KAAK,EAAEC,qBAAc;AACvB,EAAE,MAAM,EAAEA,qBAAc;AACxB,EAAE,WAAW,EAAEA,qBAAc;AAC7B,EAAE,YAAY,EAAEC,yBAAkB,CAAC,YAAY;AAC/C,EAAE,SAAS,EAAED,qBAAc;AAC3B,EAAE,SAAS,EAAEA,qBAAc;AAC3B,EAAE,KAAK,EAAEE,0BAAoB,CAAC,KAAK;AACnC,EAAE,cAAc,EAAE,OAAO;AACzB,EAAE,iBAAiB,EAAEC,0BAAoB,CAAC,iBAAiB;AAC3D,EAAE,iBAAiB,EAAEA,0BAAoB,CAAC,iBAAiB;AAC3D,EAAE,eAAe,EAAEA,0BAAoB,CAAC,eAAe;AACvD,EAAE,KAAK,EAAEC,gBAAS;AAClB,EAAE,KAAK,EAAEC,gBAAS;AAClB,EAAE,cAAc,EAAEA,gBAAS;AAC3B,EAAE,YAAY,EAAE;AAChB,IAAI,IAAI,EAAEC,sBAAc,CAAC,QAAQ,CAAC;AAClC,IAAI,QAAQ,EAAE,IAAI;AAClB,GAAG;AACH,EAAE,MAAM,EAAEP,mBAAe,CAAC,MAAM;AAChC,EAAE,cAAc,EAAE;AAClB,IAAI,IAAI,EAAEO,sBAAc,CAAC,QAAQ,CAAC;AAClC,GAAG;AACH,EAAE,QAAQ,EAAE;AACZ,IAAI,IAAI,EAAEA,sBAAc,CAAC,QAAQ,CAAC;AAClC,GAAG;AACH,CAAC;;;;"}

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

@@ -0,0 +1,13 @@
+import type { ExtractPropTypes, __ExtractPublicPropTypes } from 'vue';
+export declare const tableV2HeaderCell: {
+    class: StringConstructor;
+    columnIndex: NumberConstructor;
+    column: {
+        readonly type: import("vue").PropType<import("./common").AnyColumn>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+};
+export type TableV2HeaderCell = ExtractPropTypes<typeof tableV2HeaderCell>;
+export type TableV2HeaderCellPublic = __ExtractPublicPropTypes<typeof tableV2HeaderCell>;

node_modules/element-plus/lib/components/table-v2/src/header-cell.js

@@ -0,0 +1,15 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var common = require('./common.js');
+var runtime = require('../../../utils/vue/props/runtime.js');
+
+const tableV2HeaderCell = runtime.buildProps({
+  class: common.classType,
+  columnIndex: Number,
+  column: common.column
+});
+
+exports.tableV2HeaderCell = tableV2HeaderCell;
+//# sourceMappingURL=header-cell.js.map

node_modules/element-plus/lib/components/table-v2/src/header-cell.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"header-cell.js","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"],"names":["buildProps","classType","column"],"mappings":";;;;;;;AAEY,MAAC,iBAAiB,GAAGA,kBAAU,CAAC;AAC5C,EAAE,KAAK,EAAEC,gBAAS;AAClB,EAAE,WAAW,EAAE,MAAM;AACrB,UAAEC,aAAM;AACR,CAAC;;;;"}

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

@@ -0,0 +1,26 @@
+import type { CSSProperties, ExtractPropTypes, __ExtractPublicPropTypes } from 'vue';
+import type { KeyType } from './types';
+export declare const tableV2HeaderRowProps: {
+    readonly class: StringConstructor;
+    readonly columns: {
+        readonly type: import("vue").PropType<import("./common").AnyColumn[]>;
+        readonly required: true;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly columnsStyles: {
+        readonly type: import("vue").PropType<Record<KeyType, CSSProperties>>;
+        readonly required: true;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly headerIndex: NumberConstructor;
+    readonly style: {
+        readonly type: import("vue").PropType<CSSProperties>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+};
+export type TableV2HeaderRowProps = ExtractPropTypes<typeof tableV2HeaderRowProps>;
+export type TableV2HeaderRowPropsPublic = __ExtractPublicPropTypes<typeof tableV2HeaderRowProps>;

node_modules/element-plus/lib/components/table-v2/src/header-row.js

@@ -0,0 +1,20 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var common = require('./common.js');
+var runtime = require('../../../utils/vue/props/runtime.js');
+
+const tableV2HeaderRowProps = runtime.buildProps({
+  class: String,
+  columns: common.columns,
+  columnsStyles: {
+    type: runtime.definePropType(Object),
+    required: true
+  },
+  headerIndex: Number,
+  style: { type: runtime.definePropType(Object) }
+});
+
+exports.tableV2HeaderRowProps = tableV2HeaderRowProps;
+//# sourceMappingURL=header-row.js.map

node_modules/element-plus/lib/components/table-v2/src/header-row.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"header-row.js","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"],"names":["buildProps","columns","definePropType"],"mappings":";;;;;;;AAEY,MAAC,qBAAqB,GAAGA,kBAAU,CAAC;AAChD,EAAE,KAAK,EAAE,MAAM;AACf,WAAEC,cAAO;AACT,EAAE,aAAa,EAAE;AACjB,IAAI,IAAI,EAAEC,sBAAc,CAAC,MAAM,CAAC;AAChC,IAAI,QAAQ,EAAE,IAAI;AAClB,GAAG;AACH,EAAE,WAAW,EAAE,MAAM;AACrB,EAAE,KAAK,EAAE,EAAE,IAAI,EAAEA,sBAAc,CAAC,MAAM,CAAC,EAAE;AACzC,CAAC;;;;"}

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

@@ -0,0 +1,44 @@
+import type { ExtractPropTypes, __ExtractPublicPropTypes } from 'vue';
+export declare const tableV2HeaderProps: {
+    readonly class: StringConstructor;
+    readonly columns: {
+        readonly type: import("vue").PropType<import("./common").AnyColumn[]>;
+        readonly required: true;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly fixedHeaderData: {
+        readonly type: import("vue").PropType<any[]>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly headerData: {
+        readonly type: import("vue").PropType<any[]>;
+        readonly required: true;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly headerHeight: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => number | number[]) | (() => number | number[]) | ((new (...args: any[]) => number | number[]) | (() => number | number[]))[], unknown, unknown, 50, boolean>;
+    readonly rowWidth: {
+        readonly type: import("vue").PropType<number>;
+        readonly required: true;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly rowHeight: import("element-plus/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 50, boolean>;
+    readonly height: {
+        readonly type: import("vue").PropType<number>;
+        readonly required: true;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly width: {
+        readonly type: import("vue").PropType<number>;
+        readonly required: true;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+};
+export type TableV2HeaderProps = ExtractPropTypes<typeof tableV2HeaderProps>;
+export type TableV2HeaderPropsPublic = __ExtractPublicPropTypes<typeof tableV2HeaderProps>;

node_modules/element-plus/lib/components/table-v2/src/header.js

@@ -0,0 +1,36 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var common = require('./common.js');
+var runtime = require('../../../utils/vue/props/runtime.js');
+
+const requiredNumberType = {
+  type: Number,
+  required: true
+};
+const tableV2HeaderProps = runtime.buildProps({
+  class: String,
+  columns: common.columns,
+  fixedHeaderData: {
+    type: runtime.definePropType(Array)
+  },
+  headerData: {
+    type: runtime.definePropType(Array),
+    required: true
+  },
+  headerHeight: {
+    type: runtime.definePropType([Number, Array]),
+    default: 50
+  },
+  rowWidth: requiredNumberType,
+  rowHeight: {
+    type: Number,
+    default: 50
+  },
+  height: requiredNumberType,
+  width: requiredNumberType
+});
+
+exports.tableV2HeaderProps = tableV2HeaderProps;
+//# sourceMappingURL=header.js.map

node_modules/element-plus/lib/components/table-v2/src/header.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"header.js","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"],"names":["buildProps","columns","definePropType"],"mappings":";;;;;;;AAEA,MAAM,kBAAkB,GAAG;AAC3B,EAAE,IAAI,EAAE,MAAM;AACd,EAAE,QAAQ,EAAE,IAAI;AAChB,CAAC,CAAC;AACU,MAAC,kBAAkB,GAAGA,kBAAU,CAAC;AAC7C,EAAE,KAAK,EAAE,MAAM;AACf,WAAEC,cAAO;AACT,EAAE,eAAe,EAAE;AACnB,IAAI,IAAI,EAAEC,sBAAc,CAAC,KAAK,CAAC;AAC/B,GAAG;AACH,EAAE,UAAU,EAAE;AACd,IAAI,IAAI,EAAEA,sBAAc,CAAC,KAAK,CAAC;AAC/B,IAAI,QAAQ,EAAE,IAAI;AAClB,GAAG;AACH,EAAE,YAAY,EAAE;AAChB,IAAI,IAAI,EAAEA,sBAAc,CAAC,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC;AACzC,IAAI,OAAO,EAAE,EAAE;AACf,GAAG;AACH,EAAE,QAAQ,EAAE,kBAAkB;AAC9B,EAAE,SAAS,EAAE;AACb,IAAI,IAAI,EAAE,MAAM;AAChB,IAAI,OAAO,EAAE,EAAE;AACf,GAAG;AACH,EAAE,MAAM,EAAE,kBAAkB;AAC5B,EAAE,KAAK,EAAE,kBAAkB;AAC3B,CAAC;;;;"}

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

@@ -0,0 +1 @@
+export declare const placeholderSign: unique symbol;

node_modules/element-plus/lib/components/table-v2/src/private.js

@@ -0,0 +1,8 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+const placeholderSign = Symbol("placeholder");
+
+exports.placeholderSign = placeholderSign;
+//# sourceMappingURL=private.js.map

node_modules/element-plus/lib/components/table-v2/src/private.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"private.js","sources":["../../../../../../packages/components/table-v2/src/private.ts"],"sourcesContent":["export const placeholderSign = Symbol('placeholder')\n"],"names":[],"mappings":";;;;AAAY,MAAC,eAAe,GAAG,MAAM,CAAC,aAAa;;;;"}

node_modules/element-plus/lib/components/table-v2/src/renderers/cell.d.ts

@@ -0,0 +1,10 @@
+import type { FunctionalComponent, UnwrapNestedRefs } from 'vue';
+import type { TableV2RowCellRenderParam } from '../components';
+import type { UseNamespaceReturn } from 'element-plus/es/hooks';
+import type { UseTableReturn } from '../use-table';
+import type { TableV2Props } from '../table';
+type CellRendererProps = TableV2RowCellRenderParam & Pick<TableV2Props, 'cellProps' | 'expandColumnKey' | 'indentSize' | 'iconSize' | 'rowKey'> & UnwrapNestedRefs<Pick<UseTableReturn, 'expandedRowKeys'>> & {
+    ns: UseNamespaceReturn;
+};
+declare const CellRenderer: FunctionalComponent<CellRendererProps>;
+export default CellRenderer;

node_modules/element-plus/lib/components/table-v2/src/renderers/cell.js

@@ -0,0 +1,104 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var vue = require('vue');
+var lodashUnified = require('lodash-unified');
+var constants = require('../constants.js');
+var _private = require('../private.js');
+var utils = require('../utils.js');
+var cell = require('../components/cell.js');
+var expandIcon = require('../components/expand-icon.js');
+var shared = require('@vue/shared');
+
+const CellRenderer = ({
+  columns,
+  column,
+  columnIndex,
+  depth,
+  expandIconProps,
+  isScrolling,
+  rowData,
+  rowIndex,
+  style,
+  expandedRowKeys,
+  ns,
+  cellProps: _cellProps,
+  expandColumnKey,
+  indentSize,
+  iconSize,
+  rowKey
+}, {
+  slots
+}) => {
+  const cellStyle = utils.enforceUnit(style);
+  if (column.placeholderSign === _private.placeholderSign) {
+    return vue.createVNode("div", {
+      "class": ns.em("row-cell", "placeholder"),
+      "style": cellStyle
+    }, null);
+  }
+  const {
+    cellRenderer,
+    dataKey,
+    dataGetter
+  } = column;
+  const cellData = shared.isFunction(dataGetter) ? dataGetter({
+    columns,
+    column,
+    columnIndex,
+    rowData,
+    rowIndex
+  }) : lodashUnified.get(rowData, dataKey != null ? dataKey : "");
+  const extraCellProps = utils.tryCall(_cellProps, {
+    cellData,
+    columns,
+    column,
+    columnIndex,
+    rowIndex,
+    rowData
+  });
+  const cellProps = {
+    class: ns.e("cell-text"),
+    columns,
+    column,
+    columnIndex,
+    cellData,
+    isScrolling,
+    rowData,
+    rowIndex
+  };
+  const columnCellRenderer = utils.componentToSlot(cellRenderer);
+  const Cell = columnCellRenderer ? columnCellRenderer(cellProps) : vue.renderSlot(slots, "default", cellProps, () => [vue.createVNode(cell["default"], cellProps, null)]);
+  const kls = [ns.e("row-cell"), column.class, column.align === constants.Alignment.CENTER && ns.is("align-center"), column.align === constants.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 (shared.isObject(expandIconProps)) {
+      IconOrPlaceholder = vue.createVNode(expandIcon["default"], vue.mergeProps(expandIconProps, {
+        "class": [ns.e("expand-icon"), ns.is("expanded", expanded)],
+        "size": iconSize,
+        "expanded": expanded,
+        "style": iconStyle,
+        "expandable": true
+      }), null);
+    } else {
+      IconOrPlaceholder = vue.createVNode("div", {
+        "style": [iconStyle, `width: ${iconSize}px; height: ${iconSize}px;`].join(" ")
+      }, null);
+    }
+  }
+  return vue.createVNode("div", vue.mergeProps({
+    "class": kls,
+    "style": cellStyle
+  }, extraCellProps, {
+    "role": "cell"
+  }), [IconOrPlaceholder, Cell]);
+};
+CellRenderer.inheritAttrs = false;
+var Cell = CellRenderer;
+
+exports["default"] = Cell;
+//# sourceMappingURL=cell.js.map

node_modules/element-plus/lib/components/table-v2/src/renderers/empty.d.ts

@@ -0,0 +1,7 @@
+import type { CSSProperties, FunctionalComponent } from 'vue';
+type EmptyRendererProps = {
+    class?: JSX.IntrinsicAttributes['class'];
+    style?: CSSProperties;
+};
+declare const Footer: FunctionalComponent<EmptyRendererProps>;
+export default Footer;

node_modules/element-plus/lib/components/table-v2/src/renderers/empty.js

@@ -0,0 +1,21 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var vue = require('vue');
+var index = require('../../../empty/index.js');
+
+const Footer = (props, {
+  slots
+}) => {
+  const defaultSlot = vue.renderSlot(slots, "default", {}, () => [vue.createVNode(index.ElEmpty, null, null)]);
+  return vue.createVNode("div", {
+    "class": props.class,
+    "style": props.style
+  }, [defaultSlot]);
+};
+Footer.displayName = "ElTableV2Empty";
+var Empty = Footer;
+
+exports["default"] = Empty;
+//# sourceMappingURL=empty.js.map

node_modules/element-plus/lib/components/table-v2/src/renderers/empty.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"empty.js","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"],"names":["slots","renderSlot","_createVNode","ElEmpty","props","class","style"],"mappings":";;;;;;;;AAUA,EAAA,KAAqD;AAAaA,CAAAA,KAAAA;AAAF,EAAc,MAAA,WAAA,GAAAC,cAAA,CAAA,KAAA,EAAA,SAAA,EAAA,EAAA,EAAA,MAAA,CAAAC,eAAA,CAAAC,aAAA,EAAA,IAAA,EAAA,IAAA,CAAA,CAAA,CAAA,CAAA;AAC5E,EAAA,OAAiBD,eAAA,CAAGD,KAAU,EAAA;AAC9B,IAAA,OAAA,EAAA,KAAA,CAAA,KAAA;IAAA,OACcG,EAAAA,KAAK,CAACC,KADpB;AAAA,GAAA,EAAA,CAAA,YACuC,CAACC,CAAAA;AADxC,CAAA,CAAA;AAKD,MAPD,CAAA,WAAA,GAAA,gBAAA,CAAA;;;;;"}

node_modules/element-plus/lib/components/table-v2/src/renderers/footer.d.ts

@@ -0,0 +1,7 @@
+import type { CSSProperties, FunctionalComponent } from 'vue';
+type FooterRendererProps = {
+    class?: JSX.IntrinsicAttributes['class'];
+    style: CSSProperties;
+};
+declare const Footer: FunctionalComponent<FooterRendererProps>;
+export default Footer;

node_modules/element-plus/lib/components/table-v2/src/renderers/footer.js

@@ -0,0 +1,20 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var vue = require('vue');
+
+const Footer = (props, {
+  slots
+}) => {
+  var _a;
+  return vue.createVNode("div", {
+    "class": props.class,
+    "style": props.style
+  }, [(_a = slots.default) == null ? void 0 : _a.call(slots)]);
+};
+Footer.displayName = "ElTableV2Footer";
+var Footer$1 = Footer;
+
+exports["default"] = Footer$1;
+//# sourceMappingURL=footer.js.map

node_modules/element-plus/lib/components/table-v2/src/renderers/footer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"footer.js","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"],"names":["slots","_createVNode","props","class","style","default","Footer"],"mappings":";;;;;;;AAOA,EAAA,KAAsD;AAAaA,CAAAA,KAAAA;AAAF,EAAc,IAAA,EAAA,CAAA;AAC7E,EAAA,OAAAC,eAAA,CAAA,KAAA,EAAA;IAAA,OACcC,EAAAA,KAAK,CAACC,KADpB;AAAA,IAAA,OAAA,EACkCD,KAAK,CAACE,KAAAA;GACnCJ,EAAAA,CAAAA,CAAAA,EAAAA,GAAMK,KAAAA,CAAAA,OAFX,KAAA,IAAA,GAAA,KAAA,CAAA,GAAA,EAAA,CAAA,IAAA,CAAA,KAAA,CAAA,CAAA,CAAA,CAAA;AAKD,CAND,CAAA;;AAQAC,eAAA,MAAqB;;;;"}

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

@@ -0,0 +1,13 @@
+import type { FunctionalComponent, UnwrapNestedRefs } from 'vue';
+import type { UseNamespaceReturn } from 'element-plus/es/hooks';
+import type { TableV2HeaderRowCellRendererParams } from '../components';
+import type { UseTableReturn } from '../use-table';
+import type { TableV2Props } from '../table';
+export type HeaderCellRendererProps = TableV2HeaderRowCellRendererParams & UnwrapNestedRefs<Pick<UseTableReturn, 'onColumnSorted'>> & Pick<TableV2Props, 'sortBy' | 'sortState' | 'headerCellProps'> & {
+    ns: UseNamespaceReturn;
+};
+declare const HeaderCellRenderer: FunctionalComponent<HeaderCellRendererProps>;
+export default HeaderCellRenderer;
+export type HeaderCellSlotProps = HeaderCellRendererProps & {
+    class: string;
+};

node_modules/element-plus/lib/components/table-v2/src/renderers/header-cell.js

@@ -0,0 +1,71 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var vue = require('vue');
+var constants = require('../constants.js');
+var _private = require('../private.js');
+var utils = require('../utils.js');
+var headerCell = require('../components/header-cell.js');
+var sortIcon = require('../components/sort-icon.js');
+
+const HeaderCellRenderer = (props, {
+  slots
+}) => {
+  const {
+    column,
+    ns,
+    style,
+    onColumnSorted
+  } = props;
+  const cellStyle = utils.enforceUnit(style);
+  if (column.placeholderSign === _private.placeholderSign) {
+    return vue.createVNode("div", {
+      "class": ns.em("header-row-cell", "placeholder"),
+      "style": cellStyle
+    }, null);
+  }
+  const {
+    headerCellRenderer,
+    headerClass,
+    sortable
+  } = column;
+  const cellProps = {
+    ...props,
+    class: ns.e("header-cell-text")
+  };
+  const columnCellRenderer = utils.componentToSlot(headerCellRenderer);
+  const Cell = columnCellRenderer ? columnCellRenderer(cellProps) : vue.renderSlot(slots, "default", cellProps, () => [vue.createVNode(headerCell["default"], cellProps, null)]);
+  const {
+    sortBy,
+    sortState,
+    headerCellProps
+  } = props;
+  let sorting, sortOrder;
+  if (sortState) {
+    const order = sortState[column.key];
+    sorting = Boolean(constants.oppositeOrderMap[order]);
+    sortOrder = sorting ? order : constants.SortOrder.ASC;
+  } else {
+    sorting = column.key === sortBy.key;
+    sortOrder = sorting ? sortBy.order : constants.SortOrder.ASC;
+  }
+  const cellKls = [ns.e("header-cell"), utils.tryCall(headerClass, props, ""), column.align === constants.Alignment.CENTER && ns.is("align-center"), column.align === constants.Alignment.RIGHT && ns.is("align-right"), sortable && ns.is("sortable")];
+  const cellWrapperProps = {
+    ...utils.tryCall(headerCellProps, props),
+    onClick: column.sortable ? onColumnSorted : void 0,
+    class: cellKls,
+    style: cellStyle,
+    ["data-key"]: column.key
+  };
+  return vue.createVNode("div", vue.mergeProps(cellWrapperProps, {
+    "role": "columnheader"
+  }), [Cell, sortable && vue.createVNode(sortIcon["default"], {
+    "class": [ns.e("sort-icon"), sorting && ns.is("sorting")],
+    "sortOrder": sortOrder
+  }, null)]);
+};
+var HeaderCell = HeaderCellRenderer;
+
+exports["default"] = HeaderCell;
+//# sourceMappingURL=header-cell.js.map

node_modules/element-plus/lib/components/table-v2/src/renderers/header.d.ts

@@ -0,0 +1,9 @@
+import type { FunctionalComponent } from 'vue';
+import type { UseNamespaceReturn } from 'element-plus/es/hooks';
+import type { TableV2HeaderRendererParams } from '../components';
+import type { TableV2Props } from '../table';
+type HeaderRendererProps = TableV2HeaderRendererParams & Pick<TableV2Props, 'headerClass' | 'headerProps'> & {
+    ns: UseNamespaceReturn;
+};
+declare const HeaderRenderer: FunctionalComponent<HeaderRendererProps>;
+export default HeaderRenderer;

node_modules/element-plus/lib/components/table-v2/src/renderers/header.js

@@ -0,0 +1,45 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var vue = require('vue');
+var utils = require('../utils.js');
+var headerRow = require('../components/header-row.js');
+
+function _isSlot(s) {
+  return typeof s === "function" || Object.prototype.toString.call(s) === "[object Object]" && !vue.isVNode(s);
+}
+const HeaderRenderer = ({
+  columns,
+  columnsStyles,
+  headerIndex,
+  style,
+  headerClass,
+  headerProps,
+  ns
+}, {
+  slots
+}) => {
+  const param = {
+    columns,
+    headerIndex
+  };
+  const kls = [ns.e("header-row"), utils.tryCall(headerClass, param, ""), {
+    [ns.is("customized")]: Boolean(slots.header)
+  }];
+  const extraProps = {
+    ...utils.tryCall(headerProps, param),
+    columnsStyles,
+    class: kls,
+    columns,
+    headerIndex,
+    style
+  };
+  return vue.createVNode(headerRow["default"], extraProps, _isSlot(slots) ? slots : {
+    default: () => [slots]
+  });
+};
+var Header = HeaderRenderer;
+
+exports["default"] = Header;
+//# sourceMappingURL=header.js.map

node_modules/element-plus/lib/components/table-v2/src/renderers/header.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"header.js","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    {\n      // [ns.is('resizing')]: Boolean(resizingKey),\n      [ns.is('customized')]: Boolean(slots.header),\n    },\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"],"names":["HeaderRenderer","columns","columnsStyles","headerIndex","style","headerProps","ns","slots","tryCall","kls","e","extraProps","class","_createVNode","HeaderRow"],"mappings":";;;;;;;;;;;;;AAaA,EAAMA,aAAAA;EAEFC,WADF;EAEEC,KAFF;EAGEC,WAHF;EAIEC,WAJF;AAKE,EAAA,EAAA;GALF;EAOEC,KAPF;AASEC,CAAAA,KAAAA;AATF,EAWA,MAAA,KAAA,GAAA;AAAEC,IAAAA,OAAAA;AAAF,IACG,WAAA;AACH,GAAA,CAAA;QAAc,GAAA,GAAA,CAAA,EAAA,CAAA,CAAA,CAAA,YAAA,CAAA,EAAAC,aAAA,CAAA,WAAA,EAAA,KAAA,EAAA,EAAA,CAAA,EAAA;AAAWL,IAAAA,CAAAA,EAAAA,CAAAA,EAAAA,CAAAA,YAAAA,CAAAA,GAAAA,OAAAA,CAAAA,KAAAA,CAAAA,MAAAA,CAAAA;GAAzB,CAAA,CAAA;AAEA,EAAA,MAAMM,UACDC,GAAH;AAGE,IAAA,GAAAF,aAAA,CAAA,WAAA,EAAA,KAAA,CAAA;IACA,aAAO;AAFT,IAHF,KAAA,EAAA,GAAA;IASMG,OAAAA;IAEJT,WAFiB;AAGjBU,IAAAA,KAAK;IACLX;SAJiBY,eAAA,CAAAC,oBAAA,EAAA,UAAA,EAAA,OAAA,CAAA,KAAA,CAAA,GAAA,KAAA,GAAA;AAMjBV,IAAAA,OAAAA,EAAAA,MAAAA,CAAAA,KAAAA,CAAAA;GANF,CAAA,CAAA;AASA,CAAA,CAAA;AAAA,aAAA,cAAA;;;;"}

node_modules/element-plus/lib/components/table-v2/src/renderers/left-table.d.ts

@@ -0,0 +1,8 @@
+import type { FunctionalComponent, Ref } from 'vue';
+import type { TableV2GridProps } from '../grid';
+import type { TableGridInstance } from '../table-grid';
+type LeftTableProps = TableV2GridProps & {
+    leftTableRef: Ref<TableGridInstance | undefined>;
+};
+declare const LeftTable: FunctionalComponent<LeftTableProps>;
+export default LeftTable;

node_modules/element-plus/lib/components/table-v2/src/renderers/left-table.js

@@ -0,0 +1,29 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var vue = require('vue');
+var tableGrid = require('../table-grid.js');
+
+function _isSlot(s) {
+  return typeof s === "function" || Object.prototype.toString.call(s) === "[object Object]" && !vue.isVNode(s);
+}
+const LeftTable = (props, {
+  slots
+}) => {
+  if (!props.columns.length)
+    return;
+  const {
+    leftTableRef,
+    ...rest
+  } = props;
+  return vue.createVNode(tableGrid["default"], vue.mergeProps({
+    "ref": leftTableRef
+  }, rest), _isSlot(slots) ? slots : {
+    default: () => [slots]
+  });
+};
+var LeftTable$1 = LeftTable;
+
+exports["default"] = LeftTable$1;
+//# sourceMappingURL=left-table.js.map

node_modules/element-plus/lib/components/table-v2/src/renderers/left-table.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"left-table.js","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"],"names":["LeftTable","slots","leftTableRef","rest","_createVNode","Table","_mergeProps"],"mappings":";;;;;;;;;;;;AAUA,CAAA,KAAMA;AAA2DC,EAAAA,IAAAA,CAAAA,KAAAA,CAAAA,OAAAA,CAAAA,MAAAA;AAAF,IAAc,OAAA;AAC3E,EAAA,MAAU;IAEJ,YAAA;IAAEC,GAAF,IAAA;MAAmBC,KAAAA,CAAAA;AAAnB,EAAA,OAANC,eAAA,CAAAC,oBAAA,EAAAC,cAAA,CAAA;AAEA,IAAA,KAAA,EAAA,YAAA;KACcJ,IAAAA,CAAAA,EAAAA,OAAAA,CAAAA,KAAAA,CAAAA,GAAAA,KAAAA,GAAAA;AADd,IAAA,OAAA,EAAA,MAAA,CAEKD,KAFL,CAAA;AAAA,GAAA,CAAA,CAAA;AAAA,CAAA,CAAA;AAKD,kBAVD,SAAA;;;;"}

node_modules/element-plus/lib/components/table-v2/src/renderers/main-table.d.ts

@@ -0,0 +1,8 @@
+import type { FunctionalComponent, Ref } from 'vue';
+import type { TableV2GridProps } from '../grid';
+import type { TableGridInstance } from '../table-grid';
+export type MainTableRendererProps = TableV2GridProps & {
+    mainTableRef: Ref<TableGridInstance | undefined>;
+};
+declare const MainTable: FunctionalComponent<MainTableRendererProps>;
+export default MainTable;

node_modules/element-plus/lib/components/table-v2/src/renderers/main-table.js

@@ -0,0 +1,27 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var vue = require('vue');
+var tableGrid = require('../table-grid.js');
+
+function _isSlot(s) {
+  return typeof s === "function" || Object.prototype.toString.call(s) === "[object Object]" && !vue.isVNode(s);
+}
+const MainTable = (props, {
+  slots
+}) => {
+  const {
+    mainTableRef,
+    ...rest
+  } = props;
+  return vue.createVNode(tableGrid["default"], vue.mergeProps({
+    "ref": mainTableRef
+  }, rest), _isSlot(slots) ? slots : {
+    default: () => [slots]
+  });
+};
+var MainTable$1 = MainTable;
+
+exports["default"] = MainTable$1;
+//# sourceMappingURL=main-table.js.map

node_modules/element-plus/lib/components/table-v2/src/renderers/main-table.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"main-table.js","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"],"names":["MainTable","slots","rest","mainTableRef"],"mappings":";;;;;;;;;;;;AAUA,CAAA,KAAMA;AAEFC,EAAAA,MAAAA;AAAF,IACG,YAAA;IACG,GAAA,IAAA;MAAA,KAAA,CAAA;SAAmBC,eAAAA,CAAAA,oBAAAA,EAAAA,cAAAA,CAAAA;AAAnB,IAAA,KAAN,EAAA,YAAA;AACA,GAAA,EAAA,IAAA,CAAA,EAAA,OAAA,CAAA,KAAA,CAAA,GAAA,KAAA,GAAA;IAAA,OACcC,EAAAA,MAAAA,CAAAA,KAAAA,CAAAA;AADd,GAAA,CAAA,CACgCD;AADhC,CAAA,CAAA;AAAA,kBAAA,SAAA;;;;"}

node_modules/element-plus/lib/components/table-v2/src/renderers/overlay.d.ts

@@ -0,0 +1,3 @@
+import type { SimpleFunctionalComponent } from '../types';
+declare const Overlay: SimpleFunctionalComponent;
+export default Overlay;