@ironsource/shared-ui 1.4.2-test.18 → 1.4.2-test.2

package/components/table/Table.vue.js

@@ -1,346 +1,6 @@
-import { defineComponent, useCssVars, unref, ref, provide, computed, useSlots, onMounted, openBlock, createElementBlock, createElementVNode, normalizeStyle, normalizeClass, renderSlot, createVNode, withCtx, createTextVNode, toDisplayString, createCommentVNode, Fragment, renderList, createBlock, mergeProps, withDirectives, vShow } from 'vue';
-/* empty css                                                                     */import _export_sfc from '../../_virtual/plugin-vue_export-helper.vue.js';
-import Text from '../typography/Text.vue.js';
-/* empty css                                                            *//* empty css                                                                    *//* empty css                                                                *//* empty css                                                                    */import ScrollButton from '../button/ScrollButton.vue.js';
-import Skeleton from '../skeleton/Skeleton.vue.js';
-import EmptyState from '../emptyState/EmptyState.vue.js';
-import TableHeaderSorter from './TableHeaderSorter.vue.js';
-import { useVirtualList, useInfiniteScroll } from '@vueuse/core';
-import { TableContext } from './TableContext.vue.js';
-/* empty css                                                       *//* empty css                                           */
-import "../../Table.vue_vue_type_style_index_0_scoped_true_lang.css";
-const _hoisted_1 = { class: "table-title" };
-const _hoisted_2 = { class: "table-header-actions" };
-const _hoisted_3 = { class: "sections" };
-const _hoisted_4 = ["onClick"];
-const _hoisted_5 = { class: "table-head-container" };
-const _hoisted_6 = ["onMouseenter"];
-const _hoisted_7 = { key: 1 };
-const _hoisted_8 = { key: 1 };
-const _sfc_main = /* @__PURE__ */ defineComponent({
-  __name: "Table",
-  props: {
-    title: null,
-    columns: null,
-    rows: null,
-    sections: { default: null },
-    sort: null,
-    isSticky: { type: Boolean, default: true },
-    isStickyHeader: { type: Boolean, default: false },
-    isLoading: { type: Boolean, default: false },
-    emptyStateTitle: { default: "No results found" },
-    emptyStateSubtitle: { default: "Try again with different filters" },
-    isInfiniteScroll: { type: Boolean, default: false },
-    infiniteScrollThreshold: { default: 100 },
-    rowHeight: { type: [Number, Function], default: 48 },
-    loadingRowCount: { default: 3 },
-    defaultScrollPosition: { default: null }
-  },
-  emits: ["update:sort", "onScroll", "saveRow", "loadMore"],
-  setup(__props, { emit }) {
-    const props = __props;
-    useCssVars((_ctx) => ({
-      "7b0d5a02": unref(gridColumnTemplate)
-    }));
-    const savingRows = ref([]);
-    provide(TableContext, {
-      onClose({ rowIndex, cellIndex, value } = {}) {
-        if (value) {
-          savingRows.value = [...savingRows.value, rowIndex];
-          emit("saveRow", {
-            rowIndex,
-            cellIndex,
-            value,
-            confirm: () => {
-              savingRows.value = savingRows.value.filter((row) => row !== rowIndex);
-            }
-          });
-        }
-      }
-    });
-    const gridColumnTemplate = computed(() => {
-      return props.columns.reduce((acc, column) => {
-        if (column === props.columns[props.columns.length - 1] && column.width) {
-          return `${acc} minmax(${column.width}px, 1fr)`;
-        }
-        const columnTemplate = column.width ? `${column.width}px` : `${column.colSpan || 1}fr`;
-        return `${acc} ${columnTemplate}`;
-      }, "");
-    });
-    const activeRow = ref(null);
-    const loadingRows = computed(() => {
-      return Array(props.loadingRowCount).fill(
-        Array(props.columns.length).fill("")
-      );
-    });
-    const rows = computed(() => {
-      return props.isLoading ? [...props.rows, ...loadingRows.value] : props.rows;
-    });
-    const { list, containerProps, wrapperProps } = useVirtualList(rows, {
-      itemHeight: props.rowHeight
-    });
-    const floatingActionRef = ref(null);
-    const floatingActionPosition = ref(0);
-    const slots = useSlots();
-    const hasSearchSlot = computed(() => !!slots.search);
-    const onScroll = (event) => {
-      containerProps.onScroll();
-      floatingActionPosition.value = event.target.scrollLeft + event.target.getBoundingClientRect().width;
-      emit("onScroll", event.target.scrollTop);
-    };
-    onMounted(() => {
-      floatingActionPosition.value = containerProps.ref.value?.getBoundingClientRect().width;
-      if (props.defaultScrollPosition) {
-        setTimeout(() => {
-          containerProps.ref.value.scrollTo({
-            top: props.defaultScrollPosition,
-            behavior: "smooth"
-          });
-        }, 300);
-      }
-    });
-    const showBackToTopButton = computed(() => {
-      const [firstListItem] = list.value;
-      return firstListItem && firstListItem.index > 0;
-    });
-    const containerStyle = computed(() => containerProps.style);
-    const columnsStickyPositions = computed(() => {
-      return props.columns.reduce((acc, column) => {
-        if (column.isSticky) {
-          acc[column.id] = getColumnStickyPosition(column);
-        }
-        return acc;
-      }, {});
-    });
-    useInfiniteScroll(
-      containerProps.ref,
-      () => {
-        if (!props.isInfiniteScroll)
-          return;
-        emit("loadMore");
-      },
-      { distance: props.infiniteScrollThreshold }
-    );
-    function scrollToTop() {
-      containerProps.ref.value.scrollTo({
-        top: 0,
-        behavior: "smooth"
-      });
-    }
-    function toggleSortOrder(column) {
-      const toggledColumn = props.sort.sortBy === column.id;
-      const isColumnSortable = column.isSortable || column.isSortable === void 0;
-      if (!isColumnSortable)
-        return;
-      let sortOrder = props.sort.sortOrder;
-      let sortBy = props.sort.sortBy;
-      if (toggledColumn) {
-        sortOrder = props.sort.sortOrder === "asc" ? "desc" : "asc";
-      } else {
-        sortBy = column.id;
-      }
-      emit("update:sort", { sortBy, sortOrder });
-    }
-    function getColumnStickyPosition(column) {
-      const { isSticky, width } = column;
-      if (!isSticky || !width)
-        return null;
-      const columnIndex = props.columns.findIndex((c) => c.id === column.id);
-      const left = props.columns.reduce((acc, col, index) => {
-        if (index < columnIndex)
-          return acc + col.width;
-        return acc;
-      }, 0);
-      return {
-        left: `${left}px`,
-        zIndex: 1
-      };
-    }
-    return (_ctx, _cache) => {
-      return openBlock(), createElementBlock("div", {
-        class: "table-container",
-        onMouseleave: _cache[0] || (_cache[0] = ($event) => activeRow.value = null)
-      }, [
-        createElementVNode("table", {
-          ref: unref(containerProps).ref,
-          style: normalizeStyle(unref(containerStyle)),
-          onScrollPassive: onScroll
-        }, [
-          __props.title || _ctx.$slots["search"] ? (openBlock(), createElementBlock("div", {
-            key: 0,
-            class: normalizeClass(["table-header", { isStickyHeader: __props.isStickyHeader }])
-          }, [
-            createElementVNode("div", _hoisted_1, [
-              renderSlot(_ctx.$slots, "title", {}, () => [
-                createVNode(unref(Text), {
-                  size: "md",
-                  strong: ""
-                }, {
-                  default: withCtx(() => [
-                    createTextVNode(toDisplayString(__props.title), 1)
-                  ]),
-                  _: 1
-                })
-              ], true)
-            ]),
-            createElementVNode("div", {
-              class: normalizeClass(["table-header-right", unref(hasSearchSlot) ? "border-search" : ""])
-            }, [
-              renderSlot(_ctx.$slots, "search", {}, void 0, true)
-            ], 2),
-            createElementVNode("div", _hoisted_2, [
-              renderSlot(_ctx.$slots, "table-header-actions", {}, void 0, true)
-            ])
-          ], 2)) : createCommentVNode("", true),
-          createElementVNode("thead", {
-            class: normalizeClass({ sticky: __props.isSticky, isStickyHeader: __props.isStickyHeader })
-          }, [
-            createElementVNode("div", _hoisted_3, [
-              (openBlock(true), createElementBlock(Fragment, null, renderList(__props.sections, (section) => {
-                return openBlock(), createElementBlock("div", {
-                  key: section.id,
-                  class: normalizeClass(["section-container", { sticky: section.isSticky }])
-                }, [
-                  renderSlot(_ctx.$slots, `section-${section.id}`, {}, () => [
-                    createElementVNode("div", {
-                      style: normalizeStyle({ width: section.width + "px" }),
-                      class: normalizeClass({ section: true })
-                    }, [
-                      createVNode(unref(Text), { size: "xs" }, {
-                        default: withCtx(() => [
-                          createTextVNode(toDisplayString(section.title), 1)
-                        ]),
-                        _: 2
-                      }, 1024)
-                    ], 4)
-                  ], true)
-                ], 2);
-              }), 128))
-            ]),
-            createElementVNode("tr", null, [
-              (openBlock(true), createElementBlock(Fragment, null, renderList(__props.columns, (column) => {
-                return openBlock(), createElementBlock("th", {
-                  key: column.id,
-                  class: normalizeClass({
-                    sticky: column.isSticky,
-                    bordered: column.isBordered,
-                    isTextRight: column.isTextRight,
-                    isSortable: column.isSortable
-                  }),
-                  style: normalizeStyle(column.isSticky ? unref(columnsStickyPositions)[column.id] : null),
-                  onClick: ($event) => toggleSortOrder(column)
-                }, [
-                  createElementVNode("div", _hoisted_5, [
-                    renderSlot(_ctx.$slots, `header-${column.id}`, { column }, () => [
-                      createVNode(unref(Text), {
-                        size: "sm",
-                        strong: "",
-                        "is-truncated": false
-                      }, {
-                        default: withCtx(() => [
-                          createTextVNode(toDisplayString(column.title), 1)
-                        ]),
-                        _: 2
-                      }, 1024)
-                    ], true),
-                    column.id === __props.sort.sortBy ? (openBlock(), createBlock(TableHeaderSorter, {
-                      key: 0,
-                      class: "table-head-sorter",
-                      "sort-order": __props.sort.sortOrder
-                    }, null, 8, ["sort-order"])) : createCommentVNode("", true)
-                  ])
-                ], 14, _hoisted_4);
-              }), 128))
-            ])
-          ], 2),
-          createElementVNode("tbody", null, [
-            unref(list).length > 0 ? (openBlock(), createElementBlock("div", mergeProps({
-              key: 0,
-              class: "table-body-wrapper"
-            }, unref(wrapperProps)), [
-              (openBlock(true), createElementBlock(Fragment, null, renderList(unref(list), (row) => {
-                return openBlock(), createElementBlock("tr", {
-                  key: row.index,
-                  class: normalizeClass(["table-row", {
-                    loading: __props.isLoading || __props.isLoading && !row.data || savingRows.value.includes(row.index),
-                    active: activeRow.value === row.index
-                  }]),
-                  onMouseenter: ($event) => activeRow.value = row.index
-                }, [
-                  withDirectives(createElementVNode("div", {
-                    ref_for: true,
-                    ref_key: "floatingActionRef",
-                    ref: floatingActionRef,
-                    style: normalizeStyle({ left: floatingActionPosition.value + "px" }),
-                    class: "floating-actions"
-                  }, [
-                    renderSlot(_ctx.$slots, "floating-actions", { row }, void 0, true)
-                  ], 4), [
-                    [
-                      vShow,
-                      _ctx.$slots["floating-actions"] && activeRow.value === row.index && !__props.isLoading
-                    ]
-                  ]),
-                  (openBlock(true), createElementBlock(Fragment, null, renderList(row.data, (cell, cellIndex) => {
-                    return openBlock(), createElementBlock("td", {
-                      key: cellIndex,
-                      class: normalizeClass({
-                        sticky: __props.columns[cellIndex].isSticky,
-                        bordered: __props.columns[cellIndex].isBordered,
-                        isTextRight: __props.columns[cellIndex].isTextRight
-                      }),
-                      style: normalizeStyle(
-                        __props.columns[cellIndex].isSticky ? unref(columnsStickyPositions)[__props.columns[cellIndex].id] : null
-                      )
-                    }, [
-                      !__props.isLoading || __props.isLoading && !!cell ? (openBlock(), createElementBlock("div", {
-                        key: 0,
-                        class: normalizeClass({
-                          last: cellIndex === row.data.length - 1,
-                          "table-cell": true,
-                          floating: _ctx.$slots["floating-actions"]
-                        })
-                      }, [
-                        renderSlot(_ctx.$slots, `cell-${__props.columns[cellIndex].id}`, {
-                          cell,
-                          isLoading: savingRows.value.includes(row.index),
-                          cellIndex,
-                          row,
-                          rowIndex: row.index
-                        }, () => [
-                          createVNode(unref(Text), { size: "sm" }, {
-                            default: withCtx(() => [
-                              createTextVNode(toDisplayString(cell), 1)
-                            ]),
-                            _: 2
-                          }, 1024)
-                        ], true)
-                      ], 2)) : renderSlot(_ctx.$slots, "loader", { key: 1 }, () => [
-                        createVNode(unref(Skeleton), { round: "" })
-                      ], true)
-                    ], 6);
-                  }), 128))
-                ], 42, _hoisted_6);
-              }), 128))
-            ], 16)) : (openBlock(), createElementBlock("div", _hoisted_7, [
-              renderSlot(_ctx.$slots, "empty-state", {}, () => [
-                createVNode(unref(EmptyState), {
-                  title: __props.emptyStateTitle,
-                  subtitle: __props.emptyStateSubtitle
-                }, null, 8, ["title", "subtitle"])
-              ], true)
-            ]))
-          ]),
-          unref(list).length > 0 ? (openBlock(), createElementBlock("tfoot", _hoisted_8)) : createCommentVNode("", true)
-        ], 36),
-        createVNode(unref(ScrollButton), {
-          show: unref(showBackToTopButton),
-          onScrolled: scrollToTop
-        }, null, 8, ["show"])
-      ], 32);
-    };
-  }
-});
-var Table = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-7b2b8bf4"]]);
-
-export { Table as default };
+import o from "./Table.vue2.js";
+/* empty css            *//* empty css            */import t from "../../_virtual/_plugin-vue_export-helper.js";
+const a = /* @__PURE__ */ t(o, [["__scopeId", "data-v-365ff6b7"]]);
+export {
+  a as default
+};

package/components/table/Table.vue2.js

@@ -0,0 +1,261 @@
+import { defineComponent as K, useCssVars as Q, unref as s, ref as $, provide as U, computed as g, onMounted as W, openBlock as r, createElementBlock as n, createElementVNode as u, normalizeStyle as v, renderSlot as c, createVNode as f, withCtx as w, createTextVNode as C, toDisplayString as B, createCommentVNode as P, normalizeClass as y, Fragment as T, renderList as p, createBlock as X, mergeProps as Y, withDirectives as Z, vShow as I } from "vue";
+/* empty css                          */import L from "../typography/Text.vue.js";
+/* empty css                 *//* empty css                        *//* empty css                     *//* empty css                         */import _ from "../button/ScrollButton.vue.js";
+import tt from "../skeleton/Skeleton.vue.js";
+import et from "../emptyState/EmptyState.vue.js";
+import ot from "./TableHeaderSorter.vue.js";
+import { useVirtualList as st, useInfiniteScroll as it } from "@vueuse/core";
+import { TableContext as lt } from "./TableContext.js";
+const rt = {
+  key: 0,
+  class: "table-header"
+}, nt = { class: "table-title" }, at = { class: "table-header-right" }, dt = { class: "table-header-actions" }, ut = { class: "sections" }, ct = ["onClick"], ft = { class: "table-head-container" }, yt = ["onMouseenter"], mt = { key: 1 }, ht = { key: 1 }, zt = /* @__PURE__ */ K({
+  __name: "Table",
+  props: {
+    title: null,
+    columns: null,
+    rows: null,
+    sections: { default: null },
+    sort: null,
+    isSticky: { type: Boolean, default: !0 },
+    isLoading: { type: Boolean, default: !1 },
+    emptyStateTitle: { default: "No results found" },
+    emptyStateSubtitle: { default: "Try again with different filters" },
+    isInfiniteScroll: { type: Boolean, default: !1 },
+    infiniteScrollThreshold: { default: 100 },
+    rowHeight: { type: [Number, Function], default: 48 },
+    loadingRowCount: { default: 3 }
+  },
+  emits: ["update:sort", "saveRow", "loadMore"],
+  setup(o, { emit: R }) {
+    const i = o;
+    Q((e) => ({
+      "287203b6": s(N)
+    }));
+    const m = $([]);
+    U(lt, {
+      onClose({ rowIndex: e, cellIndex: l, value: t } = {}) {
+        t && (m.value = [...m.value, e], R("saveRow", {
+          rowIndex: e,
+          cellIndex: l,
+          value: t,
+          confirm: () => {
+            m.value = m.value.filter((a) => a !== e);
+          }
+        }));
+      }
+    });
+    const N = g(() => i.columns.reduce((e, l) => {
+      const t = l.width ? `${l.width}px` : `${l.colSpan || 1}fr`;
+      return `${e} ${t}`;
+    }, "")), S = $(null), V = g(() => Array(i.loadingRowCount).fill(
+      Array(i.columns.length).fill("")
+    )), A = g(() => i.isLoading ? [...i.rows, ...V.value] : i.rows), { list: k, containerProps: h, wrapperProps: O } = st(A, {
+      itemHeight: i.rowHeight
+    }), H = $(null), z = $(0), x = (e) => {
+      h.onScroll(), z.value = e.target.scrollLeft + e.target.getBoundingClientRect().width;
+    };
+    W(() => {
+      z.value = h.ref.value?.getBoundingClientRect().width;
+    });
+    const E = g(() => {
+      const [e] = k.value;
+      return e && e.index > 0;
+    }), D = g(() => h.style), M = g(() => i.columns.reduce((e, l) => (l.isSticky && (e[l.id] = q(l)), e), {}));
+    it(
+      h.ref,
+      () => {
+        i.isInfiniteScroll && R("loadMore");
+      },
+      { distance: i.infiniteScrollThreshold }
+    );
+    function F() {
+      h.ref.value.scrollTo({
+        top: 0,
+        behavior: "smooth"
+      });
+    }
+    function j(e) {
+      const l = i.sort.sortBy === e.id;
+      if (!(e.isSortable || e.isSortable === void 0))
+        return;
+      let a = i.sort.sortOrder, d = i.sort.sortBy;
+      l ? a = i.sort.sortOrder === "asc" ? "desc" : "asc" : d = e.id, R("update:sort", { sortBy: d, sortOrder: a });
+    }
+    function q(e) {
+      const { isSticky: l, width: t } = e;
+      if (!l || !t)
+        return null;
+      const a = i.columns.findIndex((b) => b.id === e.id);
+      return {
+        left: `${i.columns.reduce((b, G, J) => J < a ? b + G.width : b, 0)}px`,
+        zIndex: 1
+      };
+    }
+    return (e, l) => (r(), n("div", {
+      class: "table-container",
+      onMouseleave: l[0] || (l[0] = (t) => S.value = null)
+    }, [
+      u("table", {
+        ref: s(h).ref,
+        style: v(s(D)),
+        onScrollPassive: x
+      }, [
+        o.title || e.$slots.search ? (r(), n("div", rt, [
+          u("div", nt, [
+            c(e.$slots, "title", {}, () => [
+              f(s(L), {
+                size: "md",
+                strong: ""
+              }, {
+                default: w(() => [
+                  C(B(o.title), 1)
+                ]),
+                _: 1
+              })
+            ], !0)
+          ]),
+          u("div", at, [
+            c(e.$slots, "search", {}, void 0, !0)
+          ]),
+          u("div", dt, [
+            c(e.$slots, "table-header-actions", {}, void 0, !0)
+          ])
+        ])) : P("", !0),
+        u("thead", {
+          class: y({ sticky: o.isSticky })
+        }, [
+          u("div", ut, [
+            (r(!0), n(T, null, p(o.sections, (t) => (r(), n("div", {
+              key: t.id,
+              class: y(["section-container", { sticky: t.isSticky }])
+            }, [
+              c(e.$slots, `section-${t.id}`, {}, () => [
+                u("div", {
+                  style: v({ width: t.width + "px" }),
+                  class: y({ section: !0 })
+                }, [
+                  f(s(L), { size: "xs" }, {
+                    default: w(() => [
+                      C(B(t.title), 1)
+                    ]),
+                    _: 2
+                  }, 1024)
+                ], 4)
+              ], !0)
+            ], 2))), 128))
+          ]),
+          u("tr", null, [
+            (r(!0), n(T, null, p(o.columns, (t) => (r(), n("th", {
+              key: t.id,
+              class: y({ sticky: t.isSticky, bordered: t.isBordered }),
+              style: v(t.isSticky ? s(M)[t.id] : null),
+              onClick: (a) => j(t)
+            }, [
+              u("div", ft, [
+                c(e.$slots, `header-${t.id}`, { column: t }, () => [
+                  f(s(L), {
+                    size: "sm",
+                    strong: "",
+                    "is-truncated": !1
+                  }, {
+                    default: w(() => [
+                      C(B(t.title), 1)
+                    ]),
+                    _: 2
+                  }, 1024)
+                ], !0),
+                t.id === o.sort.sortBy ? (r(), X(ot, {
+                  key: 0,
+                  class: "table-head-sorter",
+                  "sort-order": o.sort.sortOrder
+                }, null, 8, ["sort-order"])) : P("", !0)
+              ])
+            ], 14, ct))), 128))
+          ])
+        ], 2),
+        u("tbody", null, [
+          s(k).length > 0 ? (r(), n("div", Y({
+            key: 0,
+            class: "table-body-wrapper"
+          }, s(O)), [
+            (r(!0), n(T, null, p(s(k), (t) => (r(), n("tr", {
+              key: t.index,
+              class: y(["table-row", {
+                loading: o.isLoading || o.isLoading && !t.data || m.value.includes(t.index),
+                active: S.value === t.index
+              }]),
+              onMouseenter: (a) => S.value = t.index
+            }, [
+              Z(u("div", {
+                ref_for: !0,
+                ref_key: "floatingActionRef",
+                ref: H,
+                style: v({ left: z.value + "px" }),
+                class: "floating-actions"
+              }, [
+                c(e.$slots, "floating-actions", { row: t }, void 0, !0)
+              ], 4), [
+                [
+                  I,
+                  e.$slots["floating-actions"] && S.value === t.index && !o.isLoading
+                ]
+              ]),
+              (r(!0), n(T, null, p(t.data, (a, d) => (r(), n("td", {
+                key: d,
+                class: y({
+                  sticky: o.columns[d].isSticky,
+                  bordered: o.columns[d].isBordered
+                }),
+                style: v(
+                  o.columns[d].isSticky ? s(M)[o.columns[d].id] : null
+                )
+              }, [
+                !o.isLoading || o.isLoading && a ? (r(), n("div", {
+                  key: 0,
+                  class: y({
+                    last: d === t.data.length - 1,
+                    "table-cell": !0,
+                    floating: e.$slots["floating-actions"]
+                  })
+                }, [
+                  c(e.$slots, `cell-${o.columns[d].id}`, {
+                    cell: a,
+                    isLoading: m.value.includes(t.index),
+                    cellIndex: d,
+                    row: t,
+                    rowIndex: t.index
+                  }, () => [
+                    f(s(L), { size: "sm" }, {
+                      default: w(() => [
+                        C(B(a), 1)
+                      ]),
+                      _: 2
+                    }, 1024)
+                  ], !0)
+                ], 2)) : c(e.$slots, "loader", { key: 1 }, () => [
+                  f(s(tt), { round: "" })
+                ], !0)
+              ], 6))), 128))
+            ], 42, yt))), 128))
+          ], 16)) : (r(), n("div", mt, [
+            c(e.$slots, "empty-state", {}, () => [
+              f(s(et), {
+                title: o.emptyStateTitle,
+                subtitle: o.emptyStateSubtitle
+              }, null, 8, ["title", "subtitle"])
+            ], !0)
+          ]))
+        ]),
+        s(k).length > 0 ? (r(), n("tfoot", ht)) : P("", !0)
+      ], 36),
+      f(s(_), {
+        show: s(E),
+        onScrolled: F
+      }, null, 8, ["show"])
+    ], 32));
+  }
+});
+export {
+  zt as default
+};

package/components/table/TableContext.js

@@ -0,0 +1,18 @@
+import { inject as o } from "vue";
+const n = Symbol(
+  "TableContext"
+);
+function c(e) {
+  const t = o(n, {});
+  if (t === null) {
+    const r = new Error(
+      `<${e} /> is missing a parent <Table /> component.`
+    );
+    throw Error.captureStackTrace && Error.captureStackTrace(r, c), r;
+  }
+  return t;
+}
+export {
+  n as TableContext,
+  c as useTableContext
+};

package/components/table/TableHeaderSorter.vue.d.ts

@@ -1,15 +1,12 @@
-declare const _default: import("vue").DefineComponent<__VLS_TypePropsToRuntimeProps<{
-    sortOrder: 'asc' | 'desc';
-}>, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<__VLS_TypePropsToRuntimeProps<{
-    sortOrder: 'asc' | 'desc';
-}>>>, {}>;
-export default _default;
-type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
-type __VLS_TypePropsToRuntimeProps<T> = {
-    [K in keyof T]-?: {} extends Pick<T, K> ? {
-        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
-    } : {
-        type: import('vue').PropType<T[K]>;
+declare const _default: import("vue").DefineComponent<{
+    sortOrder: {
+        type: import("vue").PropType<"desc" | "asc">;
+        required: true;
+    };
+}, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    sortOrder: {
+        type: import("vue").PropType<"desc" | "asc">;
         required: true;
     };
-};
+}>>, {}>;
+export default _default;