ep-craft 0.1.39 → 0.1.41

package/dist/components/table-v2/src/tokens.d.ts

@@ -1,5 +1,5 @@
 import type { InjectionKey, Ref } from 'vue';
-import type { UseNamespaceReturn } from '../../../hooks';
+import type { UseNamespaceReturn } from '../../../hooks/index.js';
 export type TableV2Context = {
     isScrolling: Ref<boolean>;
     isResetting: Ref<boolean>;

package/dist/components/table-v2/src/types.d.ts

@@ -1,5 +1,5 @@
-import type { ColumnAlignment } from '../../../constants/column-alignment';
-import type { FixedDir, SortOrder } from './constants';
+import type { ColumnAlignment } from '../../../constants/column-alignment.js';
+import type { FixedDir, SortOrder } from './constants.js';
 import type { CSSProperties, FunctionalComponent, HTMLAttributes, RendererElement, RendererNode, VNode } from 'vue';
 export type Alignment = ColumnAlignment;
 export type FixedDirection = FixedDir;

package/dist/components/table-v2/src/use-table.d.ts

@@ -1,24 +1,24 @@
-import type { TableV2Props } from './table';
-import type { TableGridInstance } from './table-grid';
+import type { TableV2Props } from './table.js';
+import type { TableGridInstance } from './table-grid.js';
 declare function useTable(props: TableV2Props): {
     columns: import("vue").ComputedRef<{
-        key: import("./types").KeyType;
-        align?: import("./types").Alignment;
-        class?: string | import("./types").ClassNameGetter<any> | undefined;
-        dataKey?: import("./types").KeyType;
-        fixed?: true | import("./types").FixedDirection;
+        key: import("./types.js").KeyType;
+        align?: import("./types.js").Alignment;
+        class?: string | import("./types.js").ClassNameGetter<any> | undefined;
+        dataKey?: import("./types.js").KeyType;
+        fixed?: true | import("./types.js").FixedDirection;
         flexGrow?: import("vue").CSSProperties["flexGrow"];
         flexShrink?: import("vue").CSSProperties["flexShrink"];
         title?: string;
         hidden?: boolean;
-        headerClass?: string | import("./types").HeaderClassGetter<any> | undefined;
+        headerClass?: string | import("./types.js").HeaderClassGetter<any> | undefined;
         maxWidth?: number;
         minWidth?: number;
         style?: import("vue").CSSProperties;
         sortable?: boolean;
         width: number;
-        cellRenderer?: import("./types").CellRenderer<any> | undefined;
-        headerCellRenderer?: import("./types").HeaderCellRenderer<any> | undefined;
+        cellRenderer?: import("./types.js").CellRenderer<any> | undefined;
+        headerCellRenderer?: import("./types.js").HeaderCellRenderer<any> | undefined;
     }[]>;
     containerRef: import("vue").Ref<any, any>;
     mainTableRef: import("vue").Ref<TableGridInstance | undefined, TableGridInstance | undefined>;
@@ -28,50 +28,50 @@ declare function useTable(props: TableV2Props): {
     isResetting: import("vue").ShallowRef<boolean, boolean>;
     isScrolling: import("vue").ShallowRef<boolean, boolean>;
     hasFixedColumns: import("vue").ComputedRef<number>;
-    columnsStyles: import("vue").ComputedRef<Record<import("./types").KeyType, import("vue").CSSProperties>>;
+    columnsStyles: import("vue").ComputedRef<Record<import("./types.js").KeyType, import("vue").CSSProperties>>;
     columnsTotalWidth: import("vue").ComputedRef<number>;
     data: import("vue").ComputedRef<any[]>;
-    expandedRowKeys: import("vue").Ref<import("./types").KeyType[], import("./types").KeyType[]>;
-    depthMap: import("vue").Ref<Record<import("./types").KeyType, number>, Record<import("./types").KeyType, number>>;
+    expandedRowKeys: import("vue").Ref<import("./types.js").KeyType[], import("./types.js").KeyType[]>;
+    depthMap: import("vue").Ref<Record<import("./types.js").KeyType, number>, Record<import("./types.js").KeyType, number>>;
     fixedColumnsOnLeft: import("vue").ComputedRef<{
-        key: import("./types").KeyType;
-        align?: import("./types").Alignment;
-        class?: string | import("./types").ClassNameGetter<any> | undefined;
-        dataKey?: import("./types").KeyType;
-        fixed?: true | import("./types").FixedDirection;
+        key: import("./types.js").KeyType;
+        align?: import("./types.js").Alignment;
+        class?: string | import("./types.js").ClassNameGetter<any> | undefined;
+        dataKey?: import("./types.js").KeyType;
+        fixed?: true | import("./types.js").FixedDirection;
         flexGrow?: import("vue").CSSProperties["flexGrow"];
         flexShrink?: import("vue").CSSProperties["flexShrink"];
         title?: string;
         hidden?: boolean;
-        headerClass?: string | import("./types").HeaderClassGetter<any> | undefined;
+        headerClass?: string | import("./types.js").HeaderClassGetter<any> | undefined;
         maxWidth?: number;
         minWidth?: number;
         style?: import("vue").CSSProperties;
         sortable?: boolean;
         width: number;
-        cellRenderer?: import("./types").CellRenderer<any> | undefined;
-        headerCellRenderer?: import("./types").HeaderCellRenderer<any> | undefined;
+        cellRenderer?: import("./types.js").CellRenderer<any> | undefined;
+        headerCellRenderer?: import("./types.js").HeaderCellRenderer<any> | undefined;
     }[]>;
     fixedColumnsOnRight: import("vue").ComputedRef<{
-        key: import("./types").KeyType;
-        align?: import("./types").Alignment;
-        class?: string | import("./types").ClassNameGetter<any> | undefined;
-        dataKey?: import("./types").KeyType;
-        fixed?: true | import("./types").FixedDirection;
+        key: import("./types.js").KeyType;
+        align?: import("./types.js").Alignment;
+        class?: string | import("./types.js").ClassNameGetter<any> | undefined;
+        dataKey?: import("./types.js").KeyType;
+        fixed?: true | import("./types.js").FixedDirection;
         flexGrow?: import("vue").CSSProperties["flexGrow"];
         flexShrink?: import("vue").CSSProperties["flexShrink"];
         title?: string;
         hidden?: boolean;
-        headerClass?: string | import("./types").HeaderClassGetter<any> | undefined;
+        headerClass?: string | import("./types.js").HeaderClassGetter<any> | undefined;
         maxWidth?: number;
         minWidth?: number;
         style?: import("vue").CSSProperties;
         sortable?: boolean;
         width: number;
-        cellRenderer?: import("./types").CellRenderer<any> | undefined;
-        headerCellRenderer?: import("./types").HeaderCellRenderer<any> | undefined;
+        cellRenderer?: import("./types.js").CellRenderer<any> | undefined;
+        headerCellRenderer?: import("./types.js").HeaderCellRenderer<any> | undefined;
     }[]>;
-    mainColumns: import("vue").ComputedRef<import("./types").AnyColumns>;
+    mainColumns: import("vue").ComputedRef<import("./types.js").AnyColumns>;
     bodyWidth: import("vue").ComputedRef<number>;
     emptyStyle: import("vue").ComputedRef<import("vue").CSSProperties>;
     rootStyle: import("vue").ComputedRef<import("vue").CSSProperties>;
@@ -83,16 +83,16 @@ declare function useTable(props: TableV2Props): {
     showEmpty: import("vue").ComputedRef<boolean>;
     getRowHeight: (rowIndex: number) => number;
     onColumnSorted: (e: MouseEvent) => void;
-    onRowHovered: ({ hovered, rowKey }: import("./row").RowHoverParams) => void;
-    onRowExpanded: ({ expanded, rowData, rowIndex, rowKey, }: import("./row").RowExpandParams) => void;
-    onRowsRendered: (params: import("./grid").onRowRenderedParams) => void;
-    onRowHeightChange: ({ rowKey, height, rowIndex }: import("./row").RowHeightChangedParams, fixedDir: import("./types").FixedDirection) => void;
-    scrollTo: (params: import("./composables").ScrollPos) => void;
+    onRowHovered: ({ hovered, rowKey }: import("./row.js").RowHoverParams) => void;
+    onRowExpanded: ({ expanded, rowData, rowIndex, rowKey, }: import("./row.js").RowExpandParams) => void;
+    onRowsRendered: (params: import("./grid.js").onRowRenderedParams) => void;
+    onRowHeightChange: ({ rowKey, height, rowIndex }: import("./row.js").RowHeightChangedParams, fixedDir: import("./types.js").FixedDirection) => void;
+    scrollTo: (params: import("./composables/index.js").ScrollPos) => void;
     scrollToLeft: (scrollLeft: number) => void;
     scrollToTop: (scrollTop: number) => void;
-    scrollToRow: (row: number, strategy?: import("./composables").ScrollStrategy) => void;
-    onScroll: (params: import("./composables").ScrollPos) => void;
-    onVerticalScroll: ({ scrollTop }: import("./composables").ScrollPos) => void;
+    scrollToRow: (row: number, strategy?: import("./composables/index.js").ScrollStrategy) => void;
+    onScroll: (params: import("./composables/index.js").ScrollPos) => void;
+    onVerticalScroll: ({ scrollTop }: import("./composables/index.js").ScrollPos) => void;
 };
 export { useTable };
 export type UseTableReturn = ReturnType<typeof useTable>;

package/dist/components/table-v2/src/use-table.js

@@ -1,107 +1,100 @@
-import { ref as l, toRef as y, getCurrentInstance as le, shallowRef as se, computed as S, unref as t, watch as v } from "vue";
-import { isNumber as ae } from "../../../utils/types.js";
-import "lodash-unified";
+import { ref as s, toRef as y, getCurrentInstance as se, shallowRef as ae, computed as S, unref as t, watch as v } from "vue";
+import { isNumber as re } from "../../../utils/types.js";
+import { useNamespace as ce } from "../../../hooks/use-namespace/index.js";
 import "@vueuse/core";
-import { isArray as ce } from "@vue/shared";
-import "@element-plus/icons-vue";
-import { useNamespace as me } from "../../../hooks/use-namespace/index.js";
 import "../../../hooks/use-size/index.js";
-import "@popperjs/core";
-import "../../../hooks/use-z-index/index.js";
-import "../../../hooks/use-delayed-toggle/index.js";
 import "../../../hooks/use-aria/index.js";
-import "../../../hooks/use-model-toggle/index.js";
-import "../../../hooks/use-empty-values/index.js";
+import { useColumns as me } from "./composables/use-columns.js";
 import { useScrollbar as de } from "./composables/use-scrollbar.js";
-import { useColumns as fe } from "./composables/use-columns.js";
+import { useRow as fe } from "./composables/use-row.js";
 import { useData as ue } from "./composables/use-data.js";
-import { useRow as he } from "./composables/use-row.js";
-import { useStyles as ge } from "./composables/use-styles.js";
-function Me(e) {
-  const c = l(), m = l(), d = l(), {
+import { useStyles as he } from "./composables/use-styles.js";
+import { isArray as ge } from "@vue/shared";
+function Ie(e) {
+  const c = s(), m = s(), d = s(), {
     columns: C,
-    columnsStyles: p,
+    columnsStyles: D,
     columnsTotalWidth: g,
     fixedColumnsOnLeft: R,
     fixedColumnsOnRight: w,
-    hasFixedColumns: D,
-    mainColumns: E,
-    onColumnSorted: I
-  } = fe(e, y(e, "columns"), y(e, "fixed")), {
-    scrollTo: W,
-    scrollToLeft: K,
-    scrollToTop: O,
-    scrollToRow: A,
-    onScroll: L,
-    onVerticalScroll: M,
-    scrollPos: N
+    hasFixedColumns: E,
+    mainColumns: I,
+    onColumnSorted: W
+  } = me(e, y(e, "columns"), y(e, "fixed")), {
+    scrollTo: K,
+    scrollToLeft: O,
+    scrollToTop: A,
+    scrollToRow: L,
+    onScroll: M,
+    onVerticalScroll: N,
+    scrollPos: _
   } = de(e, {
     mainTableRef: c,
     leftTableRef: m,
     rightTableRef: d,
-    onMaybeEndReached: re
-  }), _ = me("table-v2"), j = le(), b = se(!1), {
+    onMaybeEndReached: le
+  }), j = ce("table-v2"), z = se(), b = ae(!1), {
     expandedRowKeys: f,
     lastRenderedRowIndex: H,
-    isDynamic: z,
-    isResetting: F,
+    isDynamic: F,
+    isResetting: P,
     rowHeights: T,
-    resetAfterIndex: P,
-    onRowExpanded: V,
-    onRowHeightChange: k,
-    onRowHovered: q,
-    onRowsRendered: B
-  } = he(e, {
+    resetAfterIndex: V,
+    onRowExpanded: k,
+    onRowHeightChange: q,
+    onRowHovered: B,
+    onRowsRendered: G
+  } = fe(e, {
     mainTableRef: c,
     leftTableRef: m,
     rightTableRef: d,
-    tableInstance: j,
-    ns: _,
+    tableInstance: z,
+    ns: j,
     isScrolling: b
-  }), { data: s, depthMap: G } = ue(e, {
+  }), { data: a, depthMap: J } = ue(e, {
     expandedRowKeys: f,
     lastRenderedRowIndex: H,
-    resetAfterIndex: P
+    resetAfterIndex: V
   }), u = S(() => {
-    const { estimatedRowHeight: o, rowHeight: n } = e, i = t(s);
-    return ae(o) ? Object.values(t(T)).reduce(
-      (r, h) => r + h,
+    const { estimatedRowHeight: o, rowHeight: n } = e, i = t(a);
+    return re(o) ? Object.values(t(T)).reduce(
+      (l, h) => l + h,
       0
     ) : i.length * n;
   }), {
-    bodyWidth: J,
-    fixedTableHeight: Q,
+    bodyWidth: Q,
+    fixedTableHeight: U,
     mainTableHeight: x,
-    leftTableWidth: U,
-    rightTableWidth: X,
-    windowHeight: Y,
-    footerHeight: Z,
-    emptyStyle: $,
+    leftTableWidth: X,
+    rightTableWidth: Y,
+    windowHeight: Z,
+    footerHeight: $,
+    emptyStyle: p,
     rootStyle: ee,
     headerHeight: te
-  } = ge(e, {
+  } = he(e, {
     columnsTotalWidth: g,
     fixedColumnsOnLeft: R,
     fixedColumnsOnRight: w,
     rowsHeight: u
-  }), oe = l(), ne = S(() => {
-    const o = t(s).length === 0;
-    return ce(e.fixedData) ? e.fixedData.length === 0 && o : o;
+  }), oe = s(), ne = S(() => {
+    const o = t(a).length === 0;
+    return ge(e.fixedData) ? e.fixedData.length === 0 && o : o;
   });
   function ie(o) {
-    const { estimatedRowHeight: n, rowHeight: i, rowKey: r } = e;
-    return n ? t(T)[t(s)[o][r]] || n : i;
+    const { estimatedRowHeight: n, rowHeight: i, rowKey: l } = e;
+    return n ? t(T)[t(a)[o][l]] || n : i;
   }
-  const a = l(!1);
-  function re() {
+  const r = s(!1);
+  function le() {
     const { onEndReached: o } = e;
     if (!o) return;
-    const { scrollTop: n } = t(N), i = t(u), r = t(Y), h = i - (n + r) + e.hScrollbarSize;
-    !a.value && t(H) >= 0 && i <= n + t(x) - t(te) ? (a.value = !0, o(h)) : a.value = !1;
+    const { scrollTop: n } = t(_), i = t(u), l = t(Z), h = i - (n + l) + e.hScrollbarSize;
+    !r.value && t(H) >= 0 && i <= n + t(x) - t(te) ? (r.value = !0, o(h)) : r.value = !1;
   }
   return v(
     () => t(u),
-    () => a.value = !1
+    () => r.value = !1
   ), v(
     () => e.expandedRowKeys,
     (o) => f.value = o,
@@ -116,47 +109,47 @@ function Me(e) {
     leftTableRef: m,
     rightTableRef: d,
     // states
-    isDynamic: z,
-    isResetting: F,
+    isDynamic: F,
+    isResetting: P,
     isScrolling: b,
-    hasFixedColumns: D,
+    hasFixedColumns: E,
     // records
-    columnsStyles: p,
+    columnsStyles: D,
     columnsTotalWidth: g,
-    data: s,
+    data: a,
     expandedRowKeys: f,
-    depthMap: G,
+    depthMap: J,
     fixedColumnsOnLeft: R,
     fixedColumnsOnRight: w,
-    mainColumns: E,
+    mainColumns: I,
     // metadata
-    bodyWidth: J,
-    emptyStyle: $,
+    bodyWidth: Q,
+    emptyStyle: p,
     rootStyle: ee,
-    footerHeight: Z,
+    footerHeight: $,
     mainTableHeight: x,
-    fixedTableHeight: Q,
-    leftTableWidth: U,
-    rightTableWidth: X,
+    fixedTableHeight: U,
+    leftTableWidth: X,
+    rightTableWidth: Y,
     // flags
     showEmpty: ne,
     // methods
     getRowHeight: ie,
     // event handlers
-    onColumnSorted: I,
-    onRowHovered: q,
-    onRowExpanded: V,
-    onRowsRendered: B,
-    onRowHeightChange: k,
+    onColumnSorted: W,
+    onRowHovered: B,
+    onRowExpanded: k,
+    onRowsRendered: G,
+    onRowHeightChange: q,
     // use scrollbars
-    scrollTo: W,
-    scrollToLeft: K,
-    scrollToTop: O,
-    scrollToRow: A,
-    onScroll: L,
-    onVerticalScroll: M
+    scrollTo: K,
+    scrollToLeft: O,
+    scrollToTop: A,
+    scrollToRow: L,
+    onScroll: M,
+    onVerticalScroll: N
   };
 }
 export {
-  Me as useTable
+  Ie as useTable
 };

package/dist/components/table-v2/src/utils.js

@@ -1,15 +1,12 @@
-import { isVNode as m, h as n } from "vue";
-import { isArray as c, isFunction as i } from "@vue/shared";
-import "lodash-unified";
-import "@vueuse/core";
-import { addUnit as d } from "../../../utils/dom/style.js";
-import "@element-plus/icons-vue";
-const u = (r, o) => r + o, x = (r) => c(r) ? r.reduce(u, 0) : r, U = (r, o, t = {}) => i(r) ? r(o) : r ?? t, W = (r) => (["width", "maxWidth", "minWidth", "height"].forEach((o) => {
-  r[o] = d(r[o]);
-}), r), g = (r) => m(r) ? (o) => n(r, o) : r;
+import { isVNode as n, h as c } from "vue";
+import { addUnit as m } from "../../../utils/dom/style.js";
+import { isArray as d, isFunction as u } from "@vue/shared";
+const h = (r, o) => r + o, f = (r) => d(r) ? r.reduce(h, 0) : r, p = (r, o, t = {}) => u(r) ? r(o) : r ?? t, e = (r) => (["width", "maxWidth", "minWidth", "height"].forEach((o) => {
+  r[o] = m(r[o]);
+}), r), x = (r) => n(r) ? (o) => c(r, o) : r;
 export {
-  g as componentToSlot,
-  W as enforceUnit,
-  x as sum,
-  U as tryCall
+  x as componentToSlot,
+  e as enforceUnit,
+  f as sum,
+  p as tryCall
 };

package/dist/components/tabs/composables/use-tab-nav-touch.js

@@ -1,35 +1,32 @@
 import { ref as A, computed as O } from "vue";
 import { isUndefined as S, clamp as g } from "lodash-unified";
-import "@vue/shared";
-import "@vueuse/core";
-import { getClientXY as x } from "../../../utils/dom/position.js";
-import "@element-plus/icons-vue";
-const b = 5, _ = ({
-  scrollable: r,
+import { getClientXY as T } from "../../../utils/dom/position.js";
+const b = 5, H = ({
+  scrollable: l,
   navOffset: s,
-  navSize: T,
+  navSize: p,
   navContainerSize: D,
-  isHorizontal: i
+  isHorizontal: u
 }) => {
-  const o = A(!1), l = O(
-    () => Math.max(T.value - D.value, 0)
+  const n = A(!1), r = O(
+    () => Math.max(p.value - D.value, 0)
   );
   let e, a;
   const M = (t) => {
-    if (!r.value || t.touches.length !== 1) return;
-    const { clientX: n, clientY: c } = x(t);
+    if (!l.value || t.touches.length !== 1) return;
+    const { clientX: c, clientY: o } = T(t);
     e = {
-      startX: n,
-      startY: c,
+      startX: c,
+      startY: o,
       startOffset: s.value
     }, a = void 0;
   }, X = (t) => {
-    if (!e || !r.value) return;
+    if (!e || !l.value) return;
     if (t.touches.length !== 1) {
-      u();
+      i();
       return;
     }
-    const { clientX: n, clientY: c } = x(t), f = e.startX - n, h = e.startY - c, m = i.value ? f : h, Y = i.value ? h : f, v = Math.abs(m), d = Math.abs(Y);
+    const { clientX: c, clientY: o } = T(t), f = e.startX - c, h = e.startY - o, m = u.value ? f : h, Y = u.value ? h : f, v = Math.abs(m), d = Math.abs(Y);
     if (S(a)) {
       if (Math.max(v, d) <= b)
         return;
@@ -37,22 +34,22 @@ const b = 5, _ = ({
     }
     if (!a)
       return;
-    const p = g(
+    const x = g(
       e.startOffset + m,
       0,
-      l.value
+      r.value
     );
-    l.value <= 0 || p === s.value || !t.cancelable || (t.preventDefault(), o.value = !0, s.value = p);
-  }, u = () => {
-    e = void 0, a = void 0, o.value = !1;
+    r.value <= 0 || x === s.value || !t.cancelable || (t.preventDefault(), n.value = !0, s.value = x);
+  }, i = () => {
+    e = void 0, a = void 0, n.value = !1;
   };
   return {
-    isTouchScrolling: o,
+    isTouchScrolling: n,
     handleTouchStart: M,
     handleTouchMove: X,
-    handleTouchEnd: u
+    handleTouchEnd: i
   };
 };
 export {
-  _ as useTabNavTouch
+  H as useTabNavTouch
 };

package/dist/components/tabs/constants.d.ts

@@ -1,5 +1,5 @@
 import type { ComputedRef, InjectionKey, Ref, Slots, UnwrapRef, VNode } from 'vue';
-import type { TabsProps } from './tabs';
+import type { TabsProps } from './tabs.js';
 export type TabPaneName = string | number;
 /**
  * tab-pane 的 props 类型，与 element-plus `tabs/src/tab-pane.ts` 的 `TabPaneProps`

package/dist/components/tabs/index.d.ts

@@ -1,4 +1,4 @@
 import type { Plugin } from 'vue';
-import _EpTabs from './tabs';
+import _EpTabs from './tabs.js';
 export declare const EpTabs: typeof _EpTabs & Plugin;
 export default EpTabs;

package/dist/components/tabs/tab-bar.d.ts

@@ -1,11 +1,11 @@
 import type { ExtractPublicPropTypes } from 'vue';
-import type { TabPaneName, TabsPaneContext } from './constants';
-import type TabBar from './tab-bar.vue';
+import type { TabPaneName, TabsPaneContext } from './constants.js';
+import type TabBar from './tab-bar.vue.js';
 /**
  * @deprecated Removed after 3.0.0, Use `TabBarProps` instead.
  */
 export declare const tabBarProps: {
-    readonly tabs: import("../../utils/index").EpPropFinalized<(new (...args: any[]) => {
+    readonly tabs: import("../../utils/index.js").EpPropFinalized<(new (...args: any[]) => {
         uid: number;
         getVnode: () => import("vue").VNode;
         slots: import("vue").Slots;
@@ -70,7 +70,7 @@ export declare const tabBarProps: {
         isClosable: boolean;
         isFocusInsidePane: () => boolean | undefined;
     }[])) | null)[], unknown, unknown, () => [], boolean>;
-    readonly tabRefs: import("../../utils/index").EpPropFinalized<(new (...args: any[]) => {
+    readonly tabRefs: import("../../utils/index.js").EpPropFinalized<(new (...args: any[]) => {
         [key: string]: HTMLDivElement;
         [key: number]: HTMLDivElement;
     }) | (() => {
@@ -82,7 +82,7 @@ export declare const tabBarProps: {
     }) | (() => {
         [key: string]: HTMLDivElement;
         [key: number]: HTMLDivElement;
-    })) | null)[], unknown, unknown, () => import("../../utils/index").Mutable<{}>, boolean>;
+    })) | null)[], unknown, unknown, () => import("../../utils/index.js").Mutable<{}>, boolean>;
 };
 export type TabBarProps = {
     tabs?: TabsPaneContext[];

package/dist/components/tabs/tab-bar.vue.d.ts

@@ -1,4 +1,4 @@
-import type { TabBarProps } from './tab-bar';
+import type { TabBarProps } from './tab-bar.js';
 import type { CSSProperties } from 'vue';
 declare const _default: import("vue").DefineComponent<TabBarProps, {
     /** @description tab root html element */
@@ -6,9 +6,9 @@ declare const _default: import("vue").DefineComponent<TabBarProps, {
     /** @description method to manually update tab bar style, return the updated style */
     update: () => CSSProperties;
 }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<TabBarProps> & Readonly<{}>, {
-    tabs: import("./constants").TabsPaneContext[];
+    tabs: import("./constants.js").TabsPaneContext[];
     tabRefs: {
-        [key: import("./constants").TabPaneName]: HTMLDivElement;
+        [key: import("./constants.js").TabPaneName]: HTMLDivElement;
     };
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 export default _default;