origam 0.3.3 → 0.3.5

package/dist/src/composables/DataTable/cell.composable.d.ts

@@ -1,4 +1,4 @@
-import type { IInternalDataTableHeader } from "@/interfaces";
+import type { IInternalDataTableHeader } from "../../interfaces";
 export declare function useCell(): {
-    getPadding: (column: IInternalDataTableHeader) => any;
+    getPadding: (column: IInternalDataTableHeader) => string | number | undefined;
 };

package/dist/src/composables/DataTable/expand.composable.cjs

@@ -5,8 +5,8 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.provideExpanded = provideExpanded;
 exports.useExpanded = useExpanded;
-var _composables = require("@/composables");
-var _consts = require("@/consts");
+var _composables = require("../../composables/index.cjs");
+var _consts = require("../../consts/index.cjs");
 var _vue = require("vue");
 function provideExpanded(props) {
   const expandOnClick = (0, _vue.toRef)(props, "expandOnClick");

package/dist/src/composables/DataTable/expand.composable.d.ts

@@ -1,3 +1,9 @@
-import type { IDataTableExpandProps, IDataTableProvideExpanded } from '@/interfaces';
+import type { IDataTableExpandProps, IDataTableItem, IDataTableProvideExpanded } from '../../interfaces';
 export declare function provideExpanded(props: IDataTableExpandProps): IDataTableProvideExpanded;
-export declare function useExpanded(): {};
+export declare function useExpanded(): {
+    expand: (item: IDataTableItem, value: boolean) => void;
+    expanded: import("vue").Ref<Set<string>>;
+    expandOnClick: import("vue").Ref<boolean | undefined>;
+    isExpanded: (item: IDataTableItem) => boolean;
+    toggleExpand: (item: IDataTableItem) => void;
+};

package/dist/src/composables/DataTable/expand.composable.js

@@ -1,5 +1,5 @@
-import { useVModel } from "@/composables";
-import { ORIGAM_DATA_TABLE_EXPAND_KEY } from "@/consts";
+import { useVModel } from "../../composables/index.js";
+import { ORIGAM_DATA_TABLE_EXPAND_KEY } from "../../consts/index.js";
 import { inject, provide, toRef } from "vue";
 export function provideExpanded(props) {
   const expandOnClick = toRef(props, "expandOnClick");

package/dist/src/composables/DataTable/group.composable.cjs

@@ -7,9 +7,9 @@ exports.createGroupBy = createGroupBy;
 exports.provideGroupBy = provideGroupBy;
 exports.useGroupBy = useGroupBy;
 exports.useGroupedItems = useGroupedItems;
-var _composables = require("@/composables");
-var _consts = require("@/consts");
-var _utils = require("@/utils");
+var _composables = require("../../composables/index.cjs");
+var _consts = require("../../consts/index.cjs");
+var _utils = require("../../utils/index.cjs");
 var _vue = require("vue");
 function createGroupBy(props) {
   const groupBy = (0, _composables.useVModel)(props, "groupBy", []);

package/dist/src/composables/DataTable/group.composable.d.ts

@@ -1,13 +1,20 @@
-import type { IDataTableGroupableItem, IDataTableGroupProps, IDataTableProvideGroup, IDataTableSortItem } from '@/interfaces';
+import type { IDataTableGroup, IDataTableGroupableItem, IDataTableGroupProps, IDataTableProvideGroup, IDataTableSortItem } from '../../interfaces';
 import { ComputedRef, Ref } from 'vue';
 export declare function createGroupBy(props: IDataTableGroupProps): {
-    groupBy: any;
+    groupBy: import("../../types").TVModel<IDataTableGroupProps, "groupBy", IDataTableSortItem[] | undefined>;
 };
 export declare function provideGroupBy(options: {
     groupBy: Ref<Array<IDataTableSortItem>>;
     sortBy: Ref<Array<IDataTableSortItem>>;
 }): IDataTableProvideGroup;
 export declare function useGroupedItems<T extends IDataTableGroupableItem>(items: ComputedRef<Array<T>>, groupBy: Ref<Array<IDataTableSortItem>>, opened: Ref<Set<string>>): {
-    flatItems: ComputedRef<any>;
+    flatItems: ComputedRef<(T | IDataTableGroup<T>)[]>;
+};
+export declare function useGroupBy(): {
+    opened: Ref<Set<string>>;
+    toggleGroup: (group: IDataTableGroup) => void;
+    isGroupOpen: (group: IDataTableGroup) => boolean;
+    sortByWithGroups: Ref<Array<IDataTableSortItem>>;
+    groupBy: Ref<Array<IDataTableSortItem>>;
+    extractRows: (items: Array<import("../../interfaces").IDataTableItem | IDataTableGroup<import("../../interfaces").IDataTableItem>>) => Array<import("../../interfaces").IDataTableItem>;
 };
-export declare function useGroupBy(): {};

package/dist/src/composables/DataTable/group.composable.js

@@ -1,6 +1,6 @@
-import { useVModel } from "@/composables";
-import { ORIGAM_DATA_TABLE_GROUP_KEY } from "@/consts";
-import { flattenItems, groupItems } from "@/utils";
+import { useVModel } from "../../composables/index.js";
+import { ORIGAM_DATA_TABLE_GROUP_KEY } from "../../consts/index.js";
+import { flattenItems, groupItems } from "../../utils/index.js";
 import { computed, inject, provide, ref } from "vue";
 export function createGroupBy(props) {
   const groupBy = useVModel(props, "groupBy", []);

package/dist/src/composables/DataTable/headers.composable.cjs

@@ -6,10 +6,10 @@ Object.defineProperty(exports, "__esModule", {
 exports.createHeaders = createHeaders;
 exports.useHeaders = useHeaders;
 exports.useHeadersCell = useHeadersCell;
-var _composables = require("@/composables");
-var _consts = require("@/consts");
-var _enums = require("@/enums");
-var _utils = require("@/utils");
+var _composables = require("../../composables/index.cjs");
+var _consts = require("../../consts/index.cjs");
+var _enums = require("../../enums/index.cjs");
+var _utils = require("../../utils/index.cjs");
 var _vue = require("vue");
 function createHeaders(props, options) {
   const headers = (0, _vue.ref)([]);

package/dist/src/composables/DataTable/headers.composable.d.ts

@@ -1,17 +1,473 @@
-import type { IDataTableHeaderProps, IDataTableSortItem, IHeaderCellProps, IInternalDataTableHeader } from '@/interfaces';
+import type { IDataTableHeaderProps, IDataTableSortItem, IHeaderCellProps, IInternalDataTableHeader } from '../../interfaces';
+import type { TDataTableCompareFunction, TFilterKeyFunctions } from '../../types';
 import { Ref } from 'vue';
 export declare function createHeaders(props: IDataTableHeaderProps, options?: {
     groupBy?: Ref<Array<IDataTableSortItem>> | undefined;
     showSelect?: Ref<boolean>;
     showExpand?: Ref<boolean>;
 }): {
-    headers: Ref<any, any>;
-    columns: Ref<any, any>;
+    headers: Ref<{
+        key: string | null;
+        value: import("../../types").TSelectItemKey | null;
+        sortable: boolean;
+        fixedOffset?: number | undefined;
+        lastFixed?: boolean | undefined;
+        nowrap?: boolean | undefined;
+        padding?: string | number | undefined;
+        colspan?: number | undefined;
+        rowspan?: number | undefined;
+        children?: /*elided*/ any[] | undefined;
+        maxWidth?: string | undefined;
+        minWidth?: string | undefined;
+        width?: number | string | undefined;
+        fixed?: boolean | undefined;
+        sort?: TDataTableCompareFunction | undefined;
+        filter?: import("../../types").TFilterFunction | undefined;
+        title?: string | undefined;
+        align?: {
+            readonly [x: number]: string;
+            [Symbol.iterator]: () => StringIterator<string>;
+            small: () => string;
+            fixed: () => string;
+            replace: {
+                (searchValue: string | RegExp, replaceValue: string): string;
+                (searchValue: string | RegExp, replacer: (substring: string, ...args: any[]) => string): string;
+                (searchValue: {
+                    [Symbol.replace](string: string, replaceValue: string): string;
+                }, replaceValue: string): string;
+                (searchValue: {
+                    [Symbol.replace](string: string, replacer: (substring: string, ...args: any[]) => string): string;
+                }, replacer: (substring: string, ...args: any[]) => string): string;
+            };
+            search: {
+                (regexp: string | RegExp): number;
+                (searcher: {
+                    [Symbol.search](string: string): number;
+                }): number;
+            };
+            charAt: (pos: number) => string;
+            charCodeAt: (index: number) => number;
+            concat: (...strings: string[]) => string;
+            indexOf: (searchString: string, position?: number) => number;
+            lastIndexOf: (searchString: string, position?: number) => number;
+            localeCompare: {
+                (that: string): number;
+                (that: string, locales?: string | string[], options?: Intl.CollatorOptions): number;
+                (that: string, locales?: Intl.LocalesArgument, options?: Intl.CollatorOptions): number;
+            };
+            match: {
+                (regexp: string | RegExp): RegExpMatchArray | null;
+                (matcher: {
+                    [Symbol.match](string: string): RegExpMatchArray | null;
+                }): RegExpMatchArray | null;
+            };
+            slice: (start?: number, end?: number) => string;
+            split: {
+                (separator: string | RegExp, limit?: number): string[];
+                (splitter: {
+                    [Symbol.split](string: string, limit?: number): string[];
+                }, limit?: number): string[];
+            };
+            substring: (start: number, end?: number) => string;
+            toLowerCase: () => string;
+            toLocaleLowerCase: {
+                (locales?: string | string[]): string;
+                (locales?: Intl.LocalesArgument): string;
+            };
+            toUpperCase: () => string;
+            toLocaleUpperCase: {
+                (locales?: string | string[]): string;
+                (locales?: Intl.LocalesArgument): string;
+            };
+            trim: () => string;
+            readonly length: number;
+            substr: (from: number, length?: number) => string;
+            codePointAt: (pos: number) => number | undefined;
+            includes: (searchString: string, position?: number) => boolean;
+            endsWith: (searchString: string, endPosition?: number) => boolean;
+            normalize: {
+                (form: "NFC" | "NFD" | "NFKC" | "NFKD"): string;
+                (form?: string): string;
+            };
+            repeat: (count: number) => string;
+            startsWith: (searchString: string, position?: number) => boolean;
+            anchor: (name: string) => string;
+            big: () => string;
+            blink: () => string;
+            bold: () => string;
+            fontcolor: (color: string) => string;
+            fontsize: {
+                (size: number): string;
+                (size: string): string;
+            };
+            italics: () => string;
+            link: (url: string) => string;
+            strike: () => string;
+            sub: () => string;
+            sup: () => string;
+            padStart: (maxLength: number, fillString?: string) => string;
+            padEnd: (maxLength: number, fillString?: string) => string;
+            trimEnd: () => string;
+            trimStart: () => string;
+            trimLeft: () => string;
+            trimRight: () => string;
+            matchAll: (regexp: RegExp) => RegExpStringIterator<RegExpExecArray>;
+            toString: () => string;
+            valueOf: () => string;
+        } | undefined;
+        headerProps?: any;
+        cellProps?: import("../../types").TDataTableHeaderCell | undefined;
+        sortRaw?: TDataTableCompareFunction | undefined;
+        mobile?: boolean | undefined;
+    }[][], IInternalDataTableHeader[][] | {
+        key: string | null;
+        value: import("../../types").TSelectItemKey | null;
+        sortable: boolean;
+        fixedOffset?: number | undefined;
+        lastFixed?: boolean | undefined;
+        nowrap?: boolean | undefined;
+        padding?: string | number | undefined;
+        colspan?: number | undefined;
+        rowspan?: number | undefined;
+        children?: /*elided*/ any[] | undefined;
+        maxWidth?: string | undefined;
+        minWidth?: string | undefined;
+        width?: number | string | undefined;
+        fixed?: boolean | undefined;
+        sort?: TDataTableCompareFunction | undefined;
+        filter?: import("../../types").TFilterFunction | undefined;
+        title?: string | undefined;
+        align?: {
+            readonly [x: number]: string;
+            [Symbol.iterator]: () => StringIterator<string>;
+            small: () => string;
+            fixed: () => string;
+            replace: {
+                (searchValue: string | RegExp, replaceValue: string): string;
+                (searchValue: string | RegExp, replacer: (substring: string, ...args: any[]) => string): string;
+                (searchValue: {
+                    [Symbol.replace](string: string, replaceValue: string): string;
+                }, replaceValue: string): string;
+                (searchValue: {
+                    [Symbol.replace](string: string, replacer: (substring: string, ...args: any[]) => string): string;
+                }, replacer: (substring: string, ...args: any[]) => string): string;
+            };
+            search: {
+                (regexp: string | RegExp): number;
+                (searcher: {
+                    [Symbol.search](string: string): number;
+                }): number;
+            };
+            charAt: (pos: number) => string;
+            charCodeAt: (index: number) => number;
+            concat: (...strings: string[]) => string;
+            indexOf: (searchString: string, position?: number) => number;
+            lastIndexOf: (searchString: string, position?: number) => number;
+            localeCompare: {
+                (that: string): number;
+                (that: string, locales?: string | string[], options?: Intl.CollatorOptions): number;
+                (that: string, locales?: Intl.LocalesArgument, options?: Intl.CollatorOptions): number;
+            };
+            match: {
+                (regexp: string | RegExp): RegExpMatchArray | null;
+                (matcher: {
+                    [Symbol.match](string: string): RegExpMatchArray | null;
+                }): RegExpMatchArray | null;
+            };
+            slice: (start?: number, end?: number) => string;
+            split: {
+                (separator: string | RegExp, limit?: number): string[];
+                (splitter: {
+                    [Symbol.split](string: string, limit?: number): string[];
+                }, limit?: number): string[];
+            };
+            substring: (start: number, end?: number) => string;
+            toLowerCase: () => string;
+            toLocaleLowerCase: {
+                (locales?: string | string[]): string;
+                (locales?: Intl.LocalesArgument): string;
+            };
+            toUpperCase: () => string;
+            toLocaleUpperCase: {
+                (locales?: string | string[]): string;
+                (locales?: Intl.LocalesArgument): string;
+            };
+            trim: () => string;
+            readonly length: number;
+            substr: (from: number, length?: number) => string;
+            codePointAt: (pos: number) => number | undefined;
+            includes: (searchString: string, position?: number) => boolean;
+            endsWith: (searchString: string, endPosition?: number) => boolean;
+            normalize: {
+                (form: "NFC" | "NFD" | "NFKC" | "NFKD"): string;
+                (form?: string): string;
+            };
+            repeat: (count: number) => string;
+            startsWith: (searchString: string, position?: number) => boolean;
+            anchor: (name: string) => string;
+            big: () => string;
+            blink: () => string;
+            bold: () => string;
+            fontcolor: (color: string) => string;
+            fontsize: {
+                (size: number): string;
+                (size: string): string;
+            };
+            italics: () => string;
+            link: (url: string) => string;
+            strike: () => string;
+            sub: () => string;
+            sup: () => string;
+            padStart: (maxLength: number, fillString?: string) => string;
+            padEnd: (maxLength: number, fillString?: string) => string;
+            trimEnd: () => string;
+            trimStart: () => string;
+            trimLeft: () => string;
+            trimRight: () => string;
+            matchAll: (regexp: RegExp) => RegExpStringIterator<RegExpExecArray>;
+            toString: () => string;
+            valueOf: () => string;
+        } | undefined;
+        headerProps?: any;
+        cellProps?: import("../../types").TDataTableHeaderCell | undefined;
+        sortRaw?: TDataTableCompareFunction | undefined;
+        mobile?: boolean | undefined;
+    }[][]>;
+    columns: Ref<{
+        key: string | null;
+        value: import("../../types").TSelectItemKey | null;
+        sortable: boolean;
+        fixedOffset?: number | undefined;
+        lastFixed?: boolean | undefined;
+        nowrap?: boolean | undefined;
+        padding?: string | number | undefined;
+        colspan?: number | undefined;
+        rowspan?: number | undefined;
+        children?: /*elided*/ any[] | undefined;
+        maxWidth?: string | undefined;
+        minWidth?: string | undefined;
+        width?: number | string | undefined;
+        fixed?: boolean | undefined;
+        sort?: TDataTableCompareFunction | undefined;
+        filter?: import("../../types").TFilterFunction | undefined;
+        title?: string | undefined;
+        align?: {
+            readonly [x: number]: string;
+            [Symbol.iterator]: () => StringIterator<string>;
+            small: () => string;
+            fixed: () => string;
+            replace: {
+                (searchValue: string | RegExp, replaceValue: string): string;
+                (searchValue: string | RegExp, replacer: (substring: string, ...args: any[]) => string): string;
+                (searchValue: {
+                    [Symbol.replace](string: string, replaceValue: string): string;
+                }, replaceValue: string): string;
+                (searchValue: {
+                    [Symbol.replace](string: string, replacer: (substring: string, ...args: any[]) => string): string;
+                }, replacer: (substring: string, ...args: any[]) => string): string;
+            };
+            search: {
+                (regexp: string | RegExp): number;
+                (searcher: {
+                    [Symbol.search](string: string): number;
+                }): number;
+            };
+            charAt: (pos: number) => string;
+            charCodeAt: (index: number) => number;
+            concat: (...strings: string[]) => string;
+            indexOf: (searchString: string, position?: number) => number;
+            lastIndexOf: (searchString: string, position?: number) => number;
+            localeCompare: {
+                (that: string): number;
+                (that: string, locales?: string | string[], options?: Intl.CollatorOptions): number;
+                (that: string, locales?: Intl.LocalesArgument, options?: Intl.CollatorOptions): number;
+            };
+            match: {
+                (regexp: string | RegExp): RegExpMatchArray | null;
+                (matcher: {
+                    [Symbol.match](string: string): RegExpMatchArray | null;
+                }): RegExpMatchArray | null;
+            };
+            slice: (start?: number, end?: number) => string;
+            split: {
+                (separator: string | RegExp, limit?: number): string[];
+                (splitter: {
+                    [Symbol.split](string: string, limit?: number): string[];
+                }, limit?: number): string[];
+            };
+            substring: (start: number, end?: number) => string;
+            toLowerCase: () => string;
+            toLocaleLowerCase: {
+                (locales?: string | string[]): string;
+                (locales?: Intl.LocalesArgument): string;
+            };
+            toUpperCase: () => string;
+            toLocaleUpperCase: {
+                (locales?: string | string[]): string;
+                (locales?: Intl.LocalesArgument): string;
+            };
+            trim: () => string;
+            readonly length: number;
+            substr: (from: number, length?: number) => string;
+            codePointAt: (pos: number) => number | undefined;
+            includes: (searchString: string, position?: number) => boolean;
+            endsWith: (searchString: string, endPosition?: number) => boolean;
+            normalize: {
+                (form: "NFC" | "NFD" | "NFKC" | "NFKD"): string;
+                (form?: string): string;
+            };
+            repeat: (count: number) => string;
+            startsWith: (searchString: string, position?: number) => boolean;
+            anchor: (name: string) => string;
+            big: () => string;
+            blink: () => string;
+            bold: () => string;
+            fontcolor: (color: string) => string;
+            fontsize: {
+                (size: number): string;
+                (size: string): string;
+            };
+            italics: () => string;
+            link: (url: string) => string;
+            strike: () => string;
+            sub: () => string;
+            sup: () => string;
+            padStart: (maxLength: number, fillString?: string) => string;
+            padEnd: (maxLength: number, fillString?: string) => string;
+            trimEnd: () => string;
+            trimStart: () => string;
+            trimLeft: () => string;
+            trimRight: () => string;
+            matchAll: (regexp: RegExp) => RegExpStringIterator<RegExpExecArray>;
+            toString: () => string;
+            valueOf: () => string;
+        } | undefined;
+        headerProps?: any;
+        cellProps?: import("../../types").TDataTableHeaderCell | undefined;
+        sortRaw?: TDataTableCompareFunction | undefined;
+        mobile?: boolean | undefined;
+    }[], IInternalDataTableHeader[] | {
+        key: string | null;
+        value: import("../../types").TSelectItemKey | null;
+        sortable: boolean;
+        fixedOffset?: number | undefined;
+        lastFixed?: boolean | undefined;
+        nowrap?: boolean | undefined;
+        padding?: string | number | undefined;
+        colspan?: number | undefined;
+        rowspan?: number | undefined;
+        children?: /*elided*/ any[] | undefined;
+        maxWidth?: string | undefined;
+        minWidth?: string | undefined;
+        width?: number | string | undefined;
+        fixed?: boolean | undefined;
+        sort?: TDataTableCompareFunction | undefined;
+        filter?: import("../../types").TFilterFunction | undefined;
+        title?: string | undefined;
+        align?: {
+            readonly [x: number]: string;
+            [Symbol.iterator]: () => StringIterator<string>;
+            small: () => string;
+            fixed: () => string;
+            replace: {
+                (searchValue: string | RegExp, replaceValue: string): string;
+                (searchValue: string | RegExp, replacer: (substring: string, ...args: any[]) => string): string;
+                (searchValue: {
+                    [Symbol.replace](string: string, replaceValue: string): string;
+                }, replaceValue: string): string;
+                (searchValue: {
+                    [Symbol.replace](string: string, replacer: (substring: string, ...args: any[]) => string): string;
+                }, replacer: (substring: string, ...args: any[]) => string): string;
+            };
+            search: {
+                (regexp: string | RegExp): number;
+                (searcher: {
+                    [Symbol.search](string: string): number;
+                }): number;
+            };
+            charAt: (pos: number) => string;
+            charCodeAt: (index: number) => number;
+            concat: (...strings: string[]) => string;
+            indexOf: (searchString: string, position?: number) => number;
+            lastIndexOf: (searchString: string, position?: number) => number;
+            localeCompare: {
+                (that: string): number;
+                (that: string, locales?: string | string[], options?: Intl.CollatorOptions): number;
+                (that: string, locales?: Intl.LocalesArgument, options?: Intl.CollatorOptions): number;
+            };
+            match: {
+                (regexp: string | RegExp): RegExpMatchArray | null;
+                (matcher: {
+                    [Symbol.match](string: string): RegExpMatchArray | null;
+                }): RegExpMatchArray | null;
+            };
+            slice: (start?: number, end?: number) => string;
+            split: {
+                (separator: string | RegExp, limit?: number): string[];
+                (splitter: {
+                    [Symbol.split](string: string, limit?: number): string[];
+                }, limit?: number): string[];
+            };
+            substring: (start: number, end?: number) => string;
+            toLowerCase: () => string;
+            toLocaleLowerCase: {
+                (locales?: string | string[]): string;
+                (locales?: Intl.LocalesArgument): string;
+            };
+            toUpperCase: () => string;
+            toLocaleUpperCase: {
+                (locales?: string | string[]): string;
+                (locales?: Intl.LocalesArgument): string;
+            };
+            trim: () => string;
+            readonly length: number;
+            substr: (from: number, length?: number) => string;
+            codePointAt: (pos: number) => number | undefined;
+            includes: (searchString: string, position?: number) => boolean;
+            endsWith: (searchString: string, endPosition?: number) => boolean;
+            normalize: {
+                (form: "NFC" | "NFD" | "NFKC" | "NFKD"): string;
+                (form?: string): string;
+            };
+            repeat: (count: number) => string;
+            startsWith: (searchString: string, position?: number) => boolean;
+            anchor: (name: string) => string;
+            big: () => string;
+            blink: () => string;
+            bold: () => string;
+            fontcolor: (color: string) => string;
+            fontsize: {
+                (size: number): string;
+                (size: string): string;
+            };
+            italics: () => string;
+            link: (url: string) => string;
+            strike: () => string;
+            sub: () => string;
+            sup: () => string;
+            padStart: (maxLength: number, fillString?: string) => string;
+            padEnd: (maxLength: number, fillString?: string) => string;
+            trimEnd: () => string;
+            trimStart: () => string;
+            trimLeft: () => string;
+            trimRight: () => string;
+            matchAll: (regexp: RegExp) => RegExpStringIterator<RegExpExecArray>;
+            toString: () => string;
+            valueOf: () => string;
+        } | undefined;
+        headerProps?: any;
+        cellProps?: import("../../types").TDataTableHeaderCell | undefined;
+        sortRaw?: TDataTableCompareFunction | undefined;
+        mobile?: boolean | undefined;
+    }[]>;
     sortFunctions: Ref<Record<string, TDataTableCompareFunction>, Record<string, TDataTableCompareFunction>>;
     sortRawFunctions: Ref<Record<string, TDataTableCompareFunction>, Record<string, TDataTableCompareFunction>>;
-    filterFunctions: any;
+    filterFunctions: Ref<TFilterKeyFunctions, TFilterKeyFunctions>;
+};
+export declare function useHeaders(): {
+    headers: Ref<Array<Array<IInternalDataTableHeader>>>;
+    columns: Ref<Array<IInternalDataTableHeader>>;
 };
-export declare function useHeaders(): {};
 export declare function useHeadersCell(props: IHeaderCellProps): {
-    getSortIcon: (column: IInternalDataTableHeader) => any;
+    getSortIcon: (column: IInternalDataTableHeader) => import("../../types").TIcon | undefined;
 };

package/dist/src/composables/DataTable/headers.composable.js

@@ -1,7 +1,7 @@
-import { useSort } from "@/composables";
-import { ORIGAM_DATA_TABLE_HEADERS_KEY } from "@/consts";
-import { SORT_DIRECTION } from "@/enums";
-import { convertToInternalHeaders, extractKeys, getHeaderDepth, parseFixedColumns, parseHeaderItems } from "@/utils";
+import { useSort } from "../../composables/index.js";
+import { ORIGAM_DATA_TABLE_HEADERS_KEY } from "../../consts/index.js";
+import { SORT_DIRECTION } from "../../enums/index.js";
+import { convertToInternalHeaders, extractKeys, getHeaderDepth, parseFixedColumns, parseHeaderItems } from "../../utils/index.js";
 import { capitalize, inject, provide, ref, watchEffect } from "vue";
 export function createHeaders(props, options) {
   const headers = ref([]);

package/dist/src/composables/DataTable/items.composable.cjs

@@ -4,7 +4,7 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.useDataTableItems = useDataTableItems;
-var _utils = require("@/utils");
+var _utils = require("../../utils/index.cjs");
 var _vue = require("vue");
 function useDataTableItems(props, columns) {
   const items = (0, _vue.computed)(() => (0, _utils.transformDataTableItems)(props, props.items, columns.value));

package/dist/src/composables/DataTable/items.composable.d.ts

@@ -1,5 +1,5 @@
-import type { IDataTableItemsProps, IInternalDataTableHeader } from '@/interfaces';
+import type { IDataTableItemsProps, IInternalDataTableHeader } from '../../interfaces';
 import { Ref } from 'vue';
 export declare function useDataTableItems(props: IDataTableItemsProps, columns: Ref<Array<IInternalDataTableHeader>>): {
-    items: import("vue").ComputedRef<any>;
+    items: import("vue").ComputedRef<import("../../interfaces").IDataTableItem<any>[]>;
 };

package/dist/src/composables/DataTable/items.composable.js

@@ -1,4 +1,4 @@
-import { transformDataTableItems } from "@/utils";
+import { transformDataTableItems } from "../../utils/index.js";
 import { computed } from "vue";
 export function useDataTableItems(props, columns) {
   const items = computed(() => transformDataTableItems(props, props.items, columns.value));

package/dist/src/composables/DataTable/options.composable.cjs

@@ -4,7 +4,7 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.useOptions = useOptions;
-var _utils = require("@/utils");
+var _utils = require("../../utils/index.cjs");
 var _vue = require("vue");
 function useOptions({
   page,

package/dist/src/composables/DataTable/options.composable.d.ts

@@ -1,4 +1,4 @@
-import type { IDataTableSortItem } from '@/interfaces';
+import type { IDataTableSortItem } from '../../interfaces';
 import { Ref } from 'vue';
 export declare function useOptions({ page, itemsPerPage, sortBy, groupBy, search }: {
     page: Ref<number>;

package/dist/src/composables/DataTable/options.composable.js

@@ -1,4 +1,4 @@
-import { deepEqual, getCurrentInstance } from "@/utils";
+import { deepEqual, getCurrentInstance } from "../../utils/index.js";
 import { computed, watch } from "vue";
 export function useOptions({
   page,