ep-craft 0.1.32 → 0.1.34

package/dist/components/table/src/table-column/defaults.d.ts

@@ -0,0 +1,348 @@
+import type { ComponentInternalInstance, PropType, Ref, VNode } from 'vue';
+import type { DefaultRow, Table, TableSortOrder } from '../table/defaults';
+import type { TableOverflowTooltipFormatter, TableOverflowTooltipOptions } from '../util';
+import type { Store } from '../store';
+type CI<T extends DefaultRow> = {
+    column: TableColumnCtx<T>;
+    $index: number;
+    store: Store<T>;
+    _self: any;
+};
+type Filters = {
+    text: string;
+    value: string;
+}[];
+type FilterMethods<T extends DefaultRow> = (value: string, row: T, column: TableColumnCtx<T>) => void;
+type ValueOf<T> = T[keyof T];
+type TableColumnCtx<T extends DefaultRow = DefaultRow> = {
+    id: string;
+    realWidth: number | null;
+    type: string;
+    label: string;
+    className: string;
+    labelClassName: string;
+    property: string;
+    prop: string;
+    width?: string | number;
+    minWidth: string | number;
+    renderHeader: (data: CI<T>) => VNode;
+    sortable: boolean | string;
+    sortMethod: (a: T, b: T) => number;
+    sortBy: string | ((row: T, index: number, array?: T[]) => string) | string[];
+    resizable: boolean;
+    columnKey: string;
+    rawColumnKey: string;
+    align: string;
+    headerAlign: string;
+    showOverflowTooltip?: boolean | TableOverflowTooltipOptions;
+    tooltipFormatter?: TableOverflowTooltipFormatter<T>;
+    fixed: boolean | string;
+    formatter: (row: T, column: TableColumnCtx<T>, cellValue: any, index: number) => VNode | string;
+    selectable: (row: T, index: number) => boolean;
+    reserveSelection: boolean;
+    filterMethod: FilterMethods<T>;
+    filteredValue: string[];
+    filters: Filters;
+    filterPlacement: string;
+    filterMultiple: boolean;
+    filterClassName: string;
+    index: number | ((index: number) => number);
+    sortOrders: (TableSortOrder | null)[];
+    renderCell: (data: any) => VNode | VNode[];
+    colSpan: number;
+    rowSpan: number;
+    children?: TableColumnCtx<T>[];
+    level: number;
+    filterable: boolean | FilterMethods<T> | Filters;
+    order: TableSortOrder | null;
+    isColumnGroup: boolean;
+    isSubColumn: boolean;
+    columns: TableColumnCtx<T>[];
+    getColumnIndex: () => number;
+    no: number;
+    filterOpened?: boolean;
+    renderFilterIcon?: (scope: any) => VNode;
+    renderExpand?: (scope: any) => VNode;
+};
+interface TableColumn<T extends DefaultRow> extends ComponentInternalInstance {
+    vnode: {
+        vParent: TableColumn<T> | Table<T>;
+    } & VNode;
+    vParent: TableColumn<T> | Table<T>;
+    columnId: string;
+    columnConfig: Ref<Partial<TableColumnCtx<T>>>;
+}
+interface TableColumnProps<T extends DefaultRow = DefaultRow> {
+    /**
+     * @description type of the column. If set to `selection`, the column will display checkbox. If set to `index`, the column will display index of the row (staring from 1). If set to `expand`, the column will display expand icon
+     */
+    type?: string;
+    /**
+     * @description column label
+     */
+    label?: string;
+    /**
+     * @description class name of cells in the column
+     */
+    className?: string;
+    /**
+     * @description class name of the label of this column
+     */
+    labelClassName?: string;
+    /**
+     * @description
+     */
+    property?: string;
+    /**
+     * @description field name. You can also use its alias: `property`
+     */
+    prop?: string;
+    /**
+     * @description column width
+     */
+    width?: string | number;
+    /**
+     * @description column minimum width. Columns with `width` has a fixed width, while columns with `min-width` has a width that is distributed in proportion
+     */
+    minWidth?: string | number;
+    /**
+     * @description render function for table header of this column
+     */
+    renderHeader?: TableColumnCtx<T>['renderHeader'];
+    /**
+     * @description whether column can be sorted. Remote sorting can be done by setting this attribute to 'custom' and listening to the `sort-change` event of Table
+     */
+    sortable?: boolean | string;
+    /**
+     * @description sorting method, works when `sortable` is `true`. Should return a number, just like Array.sort
+     */
+    sortMethod?: TableColumnCtx<T>['sortMethod'];
+    /**
+     * @description specify which property to sort by, works when `sortable` is `true` and `sort-method` is `undefined`. If set to an Array, the column will sequentially sort by the next property if the previous one is equal
+     */
+    sortBy?: TableColumnCtx<T>['sortBy'];
+    /**
+     * @description whether column width can be resized, works when `border` of `el-table` is `true`
+     */
+    resizable?: boolean;
+    /**
+     * @description column's key. If you need to use the filter-change event, you need this attribute to identify which column is being filtered
+     */
+    columnKey?: string;
+    /**
+     * @description alignment, the value should be 'left' \/ 'center' \/ 'right'
+     */
+    align?: string;
+    /**
+     * @description alignment of the table header. If omitted, the value of the above `align` attribute will be applied, the value should be 'left' \/ 'center' \/ 'right'
+     */
+    headerAlign?: string;
+    /**
+     * @description whether to hide extra content and show them in a tooltip when hovering on the cell
+     */
+    showOverflowTooltip?: TableColumnCtx<T>['showOverflowTooltip'];
+    /**
+     * @description function that formats cell tooltip content, works when `show-overflow-tooltip` is `true`
+     */
+    tooltipFormatter?: TableColumnCtx<T>['tooltipFormatter'];
+    /**
+     * @description whether column is fixed at left / right. Will be fixed at left if `true`
+     */
+    fixed?: boolean | string;
+    /**
+     * @description function that formats cell content
+     */
+    formatter?: TableColumnCtx<T>['formatter'];
+    /**
+     * @description function that determines if a certain row can be selected, works when `type` is 'selection'
+     */
+    selectable?: TableColumnCtx<T>['selectable'];
+    /**
+     * @description whether to reserve selection after data refreshing, works when `type` is 'selection'. Note that `row-key` is required for this to work
+     */
+    reserveSelection?: boolean;
+    /**
+     * @description data filtering method. If `filter-multiple` is on, this method will be called multiple times for each row, and a row will display if one of the calls returns `true`
+     */
+    filterMethod?: TableColumnCtx<T>['filterMethod'];
+    /**
+     * @description filter value for selected data, might be useful when table header is rendered with `render-header`
+     */
+    filteredValue?: TableColumnCtx<T>['filteredValue'];
+    /**
+     * @description an array of data filtering options. For each element in this array, `text` and `value` are required
+     */
+    filters?: TableColumnCtx<T>['filters'];
+    /**
+     * @description placement for the filter dropdown
+     */
+    filterPlacement?: string;
+    /**
+     * @description whether data filtering supports multiple options
+     */
+    filterMultiple?: boolean;
+    /**
+     * @description className for the filter dropdown
+     */
+    filterClassName?: string;
+    /**
+     * @description customize indices for each row, works on columns with `type=index`
+     */
+    index?: TableColumnCtx<T>['index'];
+    /**
+     * @description the order of the sorting strategies used when sorting the data, works when `sortable` is `true`. Accepts an array, as the user clicks on the header, the column is sorted in order of the elements in the array
+     */
+    sortOrders?: TableColumnCtx<T>['sortOrders'];
+}
+export type { Filters, FilterMethods, TableColumnCtx, TableColumn, TableColumnProps, ValueOf, };
+/**
+ * @deprecated Removed after 3.0.0, Use `TableColumnProps` instead.
+ */
+export declare const tableColumnProps: {
+    /**
+     * @description type of the column. If set to `selection`, the column will display checkbox. If set to `index`, the column will display index of the row (staring from 1). If set to `expand`, the column will display expand icon
+     */
+    type: {
+        type: StringConstructor;
+        default: string;
+    };
+    /**
+     * @description column label
+     */
+    label: StringConstructor;
+    /**
+     * @description class name of cells in the column
+     */
+    className: StringConstructor;
+    /**
+     * @description class name of the label of this column
+     */
+    labelClassName: StringConstructor;
+    /**
+     * @description
+     */
+    property: StringConstructor;
+    /**
+     * @description field name. You can also use its alias: `property`
+     */
+    prop: StringConstructor;
+    /**
+     * @description column width
+     */
+    width: {
+        type: (NumberConstructor | StringConstructor)[];
+        default: string;
+    };
+    /**
+     * @description column minimum width. Columns with `width` has a fixed width, while columns with `min-width` has a width that is distributed in proportion
+     */
+    minWidth: {
+        type: (NumberConstructor | StringConstructor)[];
+        default: string;
+    };
+    /**
+     * @description render function for table header of this column
+     */
+    renderHeader: PropType<TableColumnCtx<any>["renderHeader"]>;
+    /**
+     * @description whether column can be sorted. Remote sorting can be done by setting this attribute to 'custom' and listening to the `sort-change` event of Table
+     */
+    sortable: {
+        type: (BooleanConstructor | StringConstructor)[];
+        default: boolean;
+    };
+    /**
+     * @description sorting method, works when `sortable` is `true`. Should return a number, just like Array.sort
+     */
+    sortMethod: PropType<TableColumnCtx<any>["sortMethod"]>;
+    /**
+     * @description specify which property to sort by, works when `sortable` is `true` and `sort-method` is `undefined`. If set to an Array, the column will sequentially sort by the next property if the previous one is equal
+     */
+    sortBy: PropType<TableColumnCtx<any>["sortBy"]>;
+    /**
+     * @description whether column width can be resized, works when `border` of `el-table` is `true`
+     */
+    resizable: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    /**
+     * @description column's key. If you need to use the filter-change event, you need this attribute to identify which column is being filtered
+     */
+    columnKey: StringConstructor;
+    /**
+     * @description alignment, the value should be 'left' \/ 'center' \/ 'right'
+     */
+    align: StringConstructor;
+    /**
+     * @description alignment of the table header. If omitted, the value of the above `align` attribute will be applied, the value should be 'left' \/ 'center' \/ 'right'
+     */
+    headerAlign: StringConstructor;
+    /**
+     * @description whether to hide extra content and show them in a tooltip when hovering on the cell
+     */
+    showOverflowTooltip: {
+        type: PropType<TableColumnCtx<any>["showOverflowTooltip"]>;
+        default: undefined;
+    };
+    /**
+     * @description function that formats cell tooltip content, works when `show-overflow-tooltip` is `true`
+     */
+    tooltipFormatter: PropType<TableColumnCtx<any>["tooltipFormatter"]>;
+    /**
+     * @description whether column is fixed at left / right. Will be fixed at left if `true`
+     */
+    fixed: (BooleanConstructor | StringConstructor)[];
+    /**
+     * @description function that formats cell content
+     */
+    formatter: PropType<TableColumnCtx<any>["formatter"]>;
+    /**
+     * @description function that determines if a certain row can be selected, works when `type` is 'selection'
+     */
+    selectable: PropType<TableColumnCtx<any>["selectable"]>;
+    /**
+     * @description whether to reserve selection after data refreshing, works when `type` is 'selection'. Note that `row-key` is required for this to work
+     */
+    reserveSelection: BooleanConstructor;
+    /**
+     * @description data filtering method. If `filter-multiple` is on, this method will be called multiple times for each row, and a row will display if one of the calls returns `true`
+     */
+    filterMethod: PropType<TableColumnCtx<any>["filterMethod"]>;
+    /**
+     * @description filter value for selected data, might be useful when table header is rendered with `render-header`
+     */
+    filteredValue: PropType<TableColumnCtx<any>["filteredValue"]>;
+    /**
+     * @description an array of data filtering options. For each element in this array, `text` and `value` are required
+     */
+    filters: PropType<TableColumnCtx<any>["filters"]>;
+    /**
+     * @description placement for the filter dropdown
+     */
+    filterPlacement: StringConstructor;
+    /**
+     * @description whether data filtering supports multiple options
+     */
+    filterMultiple: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    /**
+     * @description className for the filter dropdown
+     */
+    filterClassName: StringConstructor;
+    /**
+     * @description customize indices for each row, works on columns with `type=index`
+     */
+    index: PropType<TableColumnCtx<any>["index"]>;
+    /**
+     * @description the order of the sorting strategies used when sorting the data, works when `sortable` is `true`. Accepts an array, as the user clicks on the header, the column is sorted in order of the elements in the array
+     */
+    sortOrders: {
+        type: PropType<TableColumnCtx<any>["sortOrders"]>;
+        default: () => (string | null)[];
+        validator: (val: TableColumnCtx<any>["sortOrders"]) => boolean;
+    };
+};
+export default tableColumnProps;

package/dist/components/table/src/table-column/defaults.js

@@ -0,0 +1,152 @@
+const r = {
+  /**
+   * @description type of the column. If set to `selection`, the column will display checkbox. If set to `index`, the column will display index of the row (staring from 1). If set to `expand`, the column will display expand icon
+   */
+  type: {
+    type: String,
+    default: "default"
+  },
+  /**
+   * @description column label
+   */
+  label: String,
+  /**
+   * @description class name of cells in the column
+   */
+  className: String,
+  /**
+   * @description class name of the label of this column
+   */
+  labelClassName: String,
+  /**
+   * @description
+   */
+  property: String,
+  /**
+   * @description field name. You can also use its alias: `property`
+   */
+  prop: String,
+  /**
+   * @description column width
+   */
+  width: {
+    type: [String, Number],
+    default: ""
+  },
+  /**
+   * @description column minimum width. Columns with `width` has a fixed width, while columns with `min-width` has a width that is distributed in proportion
+   */
+  minWidth: {
+    type: [String, Number],
+    default: ""
+  },
+  /**
+   * @description render function for table header of this column
+   */
+  renderHeader: Function,
+  /**
+   * @description whether column can be sorted. Remote sorting can be done by setting this attribute to 'custom' and listening to the `sort-change` event of Table
+   */
+  sortable: {
+    type: [Boolean, String],
+    default: !1
+  },
+  /**
+   * @description sorting method, works when `sortable` is `true`. Should return a number, just like Array.sort
+   */
+  sortMethod: Function,
+  /**
+   * @description specify which property to sort by, works when `sortable` is `true` and `sort-method` is `undefined`. If set to an Array, the column will sequentially sort by the next property if the previous one is equal
+   */
+  sortBy: [String, Function, Array],
+  /**
+   * @description whether column width can be resized, works when `border` of `el-table` is `true`
+   */
+  resizable: {
+    type: Boolean,
+    default: !0
+  },
+  /**
+   * @description column's key. If you need to use the filter-change event, you need this attribute to identify which column is being filtered
+   */
+  columnKey: String,
+  /**
+   * @description alignment, the value should be 'left' \/ 'center' \/ 'right'
+   */
+  align: String,
+  /**
+   * @description alignment of the table header. If omitted, the value of the above `align` attribute will be applied, the value should be 'left' \/ 'center' \/ 'right'
+   */
+  headerAlign: String,
+  /**
+   * @description whether to hide extra content and show them in a tooltip when hovering on the cell
+   */
+  showOverflowTooltip: {
+    type: [Boolean, Object],
+    default: void 0
+  },
+  /**
+   * @description function that formats cell tooltip content, works when `show-overflow-tooltip` is `true`
+   */
+  tooltipFormatter: Function,
+  /**
+   * @description whether column is fixed at left / right. Will be fixed at left if `true`
+   */
+  fixed: [Boolean, String],
+  /**
+   * @description function that formats cell content
+   */
+  formatter: Function,
+  /**
+   * @description function that determines if a certain row can be selected, works when `type` is 'selection'
+   */
+  selectable: Function,
+  /**
+   * @description whether to reserve selection after data refreshing, works when `type` is 'selection'. Note that `row-key` is required for this to work
+   */
+  reserveSelection: Boolean,
+  /**
+   * @description data filtering method. If `filter-multiple` is on, this method will be called multiple times for each row, and a row will display if one of the calls returns `true`
+   */
+  filterMethod: Function,
+  /**
+   * @description filter value for selected data, might be useful when table header is rendered with `render-header`
+   */
+  filteredValue: Array,
+  /**
+   * @description an array of data filtering options. For each element in this array, `text` and `value` are required
+   */
+  filters: Array,
+  /**
+   * @description placement for the filter dropdown
+   */
+  filterPlacement: String,
+  /**
+   * @description whether data filtering supports multiple options
+   */
+  filterMultiple: {
+    type: Boolean,
+    default: !0
+  },
+  /**
+   * @description className for the filter dropdown
+   */
+  filterClassName: String,
+  /**
+   * @description customize indices for each row, works on columns with `type=index`
+   */
+  index: [Number, Function],
+  /**
+   * @description the order of the sorting strategies used when sorting the data, works when `sortable` is `true`. Accepts an array, as the user clicks on the header, the column is sorted in order of the elements in the array
+   */
+  sortOrders: {
+    type: Array,
+    default: () => ["ascending", "descending", null],
+    validator: (e) => e.every(
+      (t) => ["ascending", "descending", null].includes(t)
+    )
+  }
+};
+export {
+  r as tableColumnProps
+};

package/dist/components/table/src/table-column/index.d.ts

@@ -0,0 +1,2 @@
+import ElTableColumn from './index.vue';
+export default ElTableColumn;

package/dist/components/table/src/table-column/index.vue.d.ts

@@ -0,0 +1,32 @@
+import type { TableColumnCtx, TableColumnProps } from './defaults';
+import type { DefaultRow } from '../table/defaults';
+declare const _default: <T extends DefaultRow = DefaultRow>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: __VLS_PrettifyLocal<Pick<Partial<{}> & Omit<{} & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, never>, never> & TableColumnProps<T> & Partial<{}>> & import("vue").PublicProps;
+    expose(exposed: import("vue").ShallowUnwrapRef<{}>): void;
+    attrs: any;
+    slots: {
+        default?: (props: {
+            row: T;
+            column: TableColumnCtx<T>;
+            $index: number;
+        }) => any;
+        header?: (props: {
+            column: TableColumnCtx<T>;
+            $index: number;
+        }) => any;
+        expand?: (props: {
+            expanded: boolean;
+            expandable: boolean;
+        }) => any;
+        'filter-icon'?: (props: {
+            filterOpened: boolean;
+        }) => any;
+    };
+    emit: {};
+}>) => import("vue").VNode & {
+    __ctx?: Awaited<typeof __VLS_setup>;
+};
+export default _default;
+type __VLS_PrettifyLocal<T> = {
+    [K in keyof T]: T[K];
+} & {};

package/dist/components/table/src/table-column/index.vue.js

@@ -0,0 +1,161 @@
+import { defineComponent as k, useSlots as H, getCurrentInstance as K, ref as R, computed as V, onBeforeMount as z, onMounted as D, onBeforeUnmount as G, openBlock as U, createBlock as j, Fragment as $, h as x } from "vue";
+import "../../../config-provider/index.js";
+import { isUndefined as I } from "../../../../utils/types.js";
+import "lodash-unified";
+import "@vueuse/core";
+import { isArray as w, isString as q } from "@vue/shared";
+import "@element-plus/icons-vue";
+import { cellStarts as J } from "../config.js";
+import { createTableColumnId as L, mergeOptions as Q, compose as X } from "../util.js";
+import Y from "./watcher-helper.js";
+import Z from "./render-helper.js";
+import { useGlobalConfig as ee } from "../../../config-provider/src/hooks/use-global-config.js";
+const Ce = /* @__PURE__ */ k({
+  // 上游为 'ElTableColumn'；本仓自持组件统一以 Ep* 命名（见文件头注释第 1 处差异）。
+  name: "EpTableColumn",
+  __name: "index",
+  props: {
+    type: { default: "default" },
+    label: {},
+    className: {},
+    labelClassName: {},
+    property: {},
+    prop: {},
+    width: { default: "" },
+    minWidth: { default: "" },
+    renderHeader: {},
+    sortable: { type: [Boolean, String], default: !1 },
+    sortMethod: {},
+    sortBy: {},
+    resizable: { type: Boolean, default: !0 },
+    columnKey: {},
+    align: {},
+    headerAlign: {},
+    showOverflowTooltip: { type: [Boolean, Object], default: void 0 },
+    tooltipFormatter: {},
+    fixed: { type: [Boolean, String] },
+    formatter: {},
+    selectable: {},
+    reserveSelection: { type: Boolean },
+    filterMethod: {},
+    filteredValue: {},
+    filters: {},
+    filterPlacement: {},
+    filterMultiple: { type: Boolean, default: !0 },
+    filterClassName: {},
+    index: {},
+    sortOrders: { default: () => ["ascending", "descending", null] }
+  },
+  setup(O) {
+    const t = O, d = H(), c = K(), C = ee("table"), s = R({}), m = V(() => {
+      let e = c.parent;
+      for (; e && !e.tableId; )
+        e = e.parent;
+      return e;
+    }), { registerNormalWatchers: P, registerComplexWatchers: T } = Y(
+      m,
+      t
+    ), {
+      columnId: h,
+      isSubColumn: f,
+      realHeaderAlign: B,
+      columnOrTableParent: g,
+      setColumnWidth: F,
+      setColumnForcedProps: M,
+      setColumnRenders: N,
+      getPropsData: S,
+      getColumnElIndex: _,
+      realAlign: A,
+      updateColumnOrder: b
+    } = Z(t, d, m), l = g.value, E = "tableId" in l ? l.tableId : l.columnId;
+    h.value = L(E), z(() => {
+      var v, y;
+      f.value = m.value !== l;
+      const e = t.type || "default", r = t.sortable === "" ? !0 : t.sortable, a = e === "selection" ? !1 : I(t.showOverflowTooltip) ? l.props.showOverflowTooltip ?? ((v = C.value) == null ? void 0 : v.showOverflowTooltip) : t.showOverflowTooltip, i = I(t.tooltipFormatter) ? l.props.tooltipFormatter ?? ((y = C.value) == null ? void 0 : y.tooltipFormatter) : t.tooltipFormatter, o = {
+        ...J[e],
+        id: h.value,
+        type: e,
+        property: t.prop || t.property,
+        align: A,
+        headerAlign: B,
+        showOverflowTooltip: a,
+        tooltipFormatter: i,
+        // filter 相关属性
+        filterable: t.filters || t.filterMethod,
+        filteredValue: [],
+        filterPlacement: "",
+        filterClassName: "",
+        isColumnGroup: !1,
+        isSubColumn: !1,
+        filterOpened: !1,
+        // sort 相关属性
+        sortable: r,
+        // index 列
+        index: t.index,
+        // <el-table-column key="xxx" />
+        rawColumnKey: c.vnode.key
+      };
+      let p = S([
+        "columnKey",
+        "label",
+        "className",
+        "labelClassName",
+        "type",
+        "renderHeader",
+        "formatter",
+        "fixed",
+        "resizable"
+      ], ["sortMethod", "sortBy", "sortOrders"], ["selectable", "reserveSelection"], [
+        "filterMethod",
+        "filters",
+        "filterMultiple",
+        "filterOpened",
+        "filteredValue",
+        "filterPlacement",
+        "filterClassName"
+      ]);
+      p = Q(o, p), p = X(N, F, M)(p), s.value = p, P(), T();
+    }), D(() => {
+      var o, u;
+      const e = g.value, r = f.value ? (o = e.vnode.el) == null ? void 0 : o.children : (u = e.refs.hiddenColumns) == null ? void 0 : u.children, a = () => _(r || [], c.vnode.el);
+      s.value.getColumnIndex = a, a() > -1 && m.value.store.commit(
+        "insertColumn",
+        s.value,
+        f.value ? "columnConfig" in e && e.columnConfig.value : null,
+        b
+      );
+    }), G(() => {
+      const e = s.value.getColumnIndex;
+      (e ? e() : -1) > -1 && m.value.store.commit(
+        "removeColumn",
+        s.value,
+        f.value ? "columnConfig" in l && l.columnConfig.value : null,
+        b
+      );
+    }), c.columnId = h.value, c.columnConfig = s;
+    const W = () => {
+      var e, r;
+      try {
+        const a = (e = d.default) == null ? void 0 : e.call(d, {
+          row: {},
+          column: {},
+          $index: -1
+        }), i = [];
+        if (w(a))
+          for (const o of a) {
+            const u = (r = o.type) == null ? void 0 : r.name;
+            u === "EpTableColumn" || u === "ElTableColumn" || o.shapeFlag & 2 ? i.push(o) : o.type === $ && w(o.children) && o.children.forEach((n) => {
+              (n == null ? void 0 : n.patchFlag) !== 1024 && !q(n == null ? void 0 : n.children) && i.push(n);
+            });
+          }
+        return x("div", i);
+      } catch {
+        return x("div", []);
+      }
+    };
+    return (e, r) => (U(), j(W));
+  }
+});
+export {
+  Ce as default
+};