origam 0.3.9 → 2.2.1

package/dist/src/composables/Commons/style.composable.d.ts

@@ -8,6 +8,9 @@ import { ComputedRef, MaybeRef } from 'vue';
  * @param css
  * @param options
  */
+/*********************************************************
+ * useStyleTag
+ ********************************************************/
 export declare function useStyleTag(css: MaybeRef<string>, options?: IStyleTagOptions): {
     id: string;
     css: import("vue").Ref<string, string> | import("vue").ShallowRef<string, string> | import("vue").WritableComputedRef<string, string>;
@@ -15,6 +18,9 @@ export declare function useStyleTag(css: MaybeRef<string>, options?: IStyleTagOp
     load: () => void;
     isLoaded: Readonly<import("vue").Ref<boolean, boolean>>;
 };
+/*********************************************************
+ * useStyle
+ ********************************************************/
 export declare function useStyle(styles: ComputedRef, uniq?: undefined, name?: string): {
     id: ComputedRef<string>;
     styleTagId: string;

package/dist/src/composables/Commons/teleport.composable.d.ts

@@ -1,4 +1,7 @@
 import { Ref } from 'vue';
+/*********************************************************
+ * useTeleport
+ ********************************************************/
 export declare function useTeleport(target: Ref<boolean | string | Element>): {
     teleportTarget: import("vue").ComputedRef<Element | undefined>;
 };

package/dist/src/composables/Commons/throttle.composable.d.ts

@@ -1 +1,4 @@
+/*********************************************************
+ * useThrottleFn
+ ********************************************************/
 export declare function useThrottleFn<T extends any[], R = void>(fn: (...args: T) => R, wait: number): (...args: T) => void;

package/dist/src/composables/Commons/toggleScope.composable.d.ts

@@ -1,2 +1,5 @@
 import type { WatchSource } from 'vue';
+/*********************************************************
+ * useToggleScope
+ ********************************************************/
 export declare function useToggleScope(source: WatchSource<boolean>, fn: (reset: () => void) => void): void;

package/dist/src/composables/Commons/touch.composable.d.ts

@@ -1,4 +1,7 @@
 import { Ref } from 'vue';
+/*********************************************************
+ * useTouch
+ ********************************************************/
 export declare function useTouch({ isActive, isTemporary, width, touchless, position }: {
     isActive: Ref<boolean>;
     isTemporary: Ref<boolean>;

package/dist/src/composables/Commons/vModel.composable.cjs

@@ -12,12 +12,13 @@ function useVModel(props, prop, defaultValue, transformIn = v => v, transformOut
   const internal = (0, _vue.ref)(props[prop] !== void 0 ? props[prop] : defaultValue);
   const kebabProp = (0, _utils.toKebabCase)(prop);
   const checkKebab = kebabProp !== prop;
+  const has = key => Object.prototype.hasOwnProperty.call(vm.vnode.props ?? {}, key);
   const isControlled = checkKebab ? (0, _vue.computed)(() => {
     void props[prop];
-    return (Object.prototype.hasOwnProperty.call(vm.vnode.props, prop) || Object.prototype.hasOwnProperty.call(vm.vnode.props, kebabProp)) && (Object.prototype.hasOwnProperty.call(vm.vnode.props, `onUpdate:${prop}`) || Object.prototype.hasOwnProperty.call(vm.vnode.props, `onUpdate:${kebabProp}`));
+    return (has(prop) || has(kebabProp)) && (has(`onUpdate:${prop}`) || has(`onUpdate:${kebabProp}`));
   }) : (0, _vue.computed)(() => {
     void props[prop];
-    return Object.prototype.hasOwnProperty.call(vm.vnode.props, prop) && Object.prototype.hasOwnProperty.call(vm.vnode.props, `onUpdate:${prop}`);
+    return has(prop) && has(`onUpdate:${prop}`);
   });
   (0, _composables.useToggleScope)(() => !isControlled.value, () => {
     (0, _vue.watch)(() => props[prop], val => {

package/dist/src/composables/Commons/vModel.composable.d.ts

@@ -1,4 +1,7 @@
 import type { TEventProp, TVModel } from '../../types';
+/*********************************************************
+ * useVModel
+ ********************************************************/
 export declare function useVModel<Props extends object & {
     [key in Prop as `onUpdate:${Prop}`]?: TEventProp | undefined;
 }, Prop extends Extract<keyof Props, string>, Inner = Props[Prop]>(props: Props, prop: Prop, defaultValue?: Props[Prop], transformIn?: (value?: Props[Prop]) => Inner, transformOut?: (value: Inner) => Props[Prop]): TVModel<Props, Prop, Inner>;

package/dist/src/composables/Commons/vModel.composable.js

@@ -6,12 +6,13 @@ export function useVModel(props, prop, defaultValue, transformIn = (v) => v, tra
   const internal = ref(props[prop] !== void 0 ? props[prop] : defaultValue);
   const kebabProp = toKebabCase(prop);
   const checkKebab = kebabProp !== prop;
+  const has = (key) => Object.prototype.hasOwnProperty.call(vm.vnode.props ?? {}, key);
   const isControlled = checkKebab ? computed(() => {
     void props[prop];
-    return (Object.prototype.hasOwnProperty.call(vm.vnode.props, prop) || Object.prototype.hasOwnProperty.call(vm.vnode.props, kebabProp)) && (Object.prototype.hasOwnProperty.call(vm.vnode.props, `onUpdate:${prop}`) || Object.prototype.hasOwnProperty.call(vm.vnode.props, `onUpdate:${kebabProp}`));
+    return (has(prop) || has(kebabProp)) && (has(`onUpdate:${prop}`) || has(`onUpdate:${kebabProp}`));
   }) : computed(() => {
     void props[prop];
-    return Object.prototype.hasOwnProperty.call(vm.vnode.props, prop) && Object.prototype.hasOwnProperty.call(vm.vnode.props, `onUpdate:${prop}`);
+    return has(prop) && has(`onUpdate:${prop}`);
   });
   useToggleScope(() => !isControlled.value, () => {
     watch(() => props[prop], (val) => {

package/dist/src/composables/Commons/validation.composable.d.ts

@@ -1,5 +1,8 @@
 import type { IValidationProps } from '../../interfaces';
 import { MaybeRef } from 'vue';
+/*********************************************************
+ * useValidation
+ ********************************************************/
 export declare function useValidation(props: IValidationProps, name?: string, id?: MaybeRef<string | number>): {
     errorMessages: import("vue").ComputedRef<string[]>;
     isDirty: import("vue").ComputedRef<boolean>;

package/dist/src/composables/Commons/variant.composable.cjs

@@ -0,0 +1,22 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useVariant = useVariant;
+var _utils = require("../../utils/index.cjs");
+var _vue = require("vue");
+function useVariant(props, name = (0, _utils.getCurrentInstanceName)()) {
+  const variantClasses = (0, _vue.computed)(() => {
+    const variant = (0, _vue.isRef)(props) ? props.value : props.variant;
+    const classes = [];
+    if (variant == null) return classes;
+    if (variant) {
+      classes.push(`${name}--variant-${variant}`);
+    }
+    return classes;
+  });
+  return {
+    variantClasses
+  };
+}

package/dist/src/composables/Commons/variant.composable.d.ts

@@ -0,0 +1,9 @@
+import type { IVariantProps } from '../../interfaces';
+import type { TVariant, TVariantInput } from '../../types';
+import { Ref } from 'vue';
+/*********************************************************
+ * useVariant
+ ********************************************************/
+export declare function useVariant(props: IVariantProps | Ref<TVariant | TVariantInput | string | undefined>, name?: string): {
+    variantClasses: import("vue").ComputedRef<string[]>;
+};

package/dist/src/composables/Commons/variant.composable.js

@@ -0,0 +1,14 @@
+import { getCurrentInstanceName } from "../../utils/index.js";
+import { computed, isRef } from "vue";
+export function useVariant(props, name = getCurrentInstanceName()) {
+  const variantClasses = computed(() => {
+    const variant = isRef(props) ? props.value : props.variant;
+    const classes = [];
+    if (variant == null) return classes;
+    if (variant) {
+      classes.push(`${name}--variant-${variant}`);
+    }
+    return classes;
+  });
+  return { variantClasses };
+}

package/dist/src/composables/Commons/velocity.composable.d.ts

@@ -1,3 +1,6 @@
+/*********************************************************
+ * useVelocity
+ ********************************************************/
 export declare function useVelocity(): {
     addMovement: (e: TouchEvent) => void;
     endTouch: (e: TouchEvent) => void;

package/dist/src/composables/Commons/virtual.composable.cjs

@@ -10,6 +10,7 @@ var _utils = require("../../utils/index.cjs");
 var _vue = require("vue");
 function useVirtual(props, items) {
   const display = (0, _composables.useDisplay)();
+  const goTo = (0, _composables.useGoTo)();
   const itemHeight = (0, _vue.shallowRef)(0);
   (0, _vue.watchEffect)(() => {
     itemHeight.value = parseFloat(props.itemHeight || 0);
@@ -155,13 +156,24 @@ function useVirtual(props, items) {
     paddingTop.value = calculateOffset(first.value);
     paddingBottom.value = calculateOffset(items.value.length) - calculateOffset(last.value);
   };
-  const scrollToIndex = index => {
+  const scrollToIndex = (index, options = {}) => {
     const offset = calculateOffset(index);
     if (!containerRef.value || index && !offset) {
       targetScrollIndex = index;
-    } else {
+      return;
+    }
+    const duration = options.duration ?? props.scrollDuration ?? 300;
+    const easing = options.easing ?? props.scrollEasing ?? "easeInOutCubic";
+    if (duration <= 0) {
       containerRef.value.scrollTop = offset;
+      return;
     }
+    void goTo(offset, {
+      container: containerRef.value,
+      duration,
+      easing,
+      ...options
+    });
   };
   const computedItems = (0, _vue.computed)(() => {
     return items.value.slice(first.value, last.value).map((item, index) => ({

package/dist/src/composables/Commons/virtual.composable.d.ts

@@ -1,5 +1,8 @@
-import type { IVirtualProps } from '../../interfaces';
+import type { IGoToOptions, IVirtualProps } from '../../interfaces';
 import { Ref } from 'vue';
+/*********************************************************
+ * useVirtual
+ ********************************************************/
 export declare function useVirtual<T>(props: IVirtualProps, items: Ref<readonly T[]>): {
     containerRef: Ref<HTMLElement | undefined, HTMLElement | undefined>;
     markerRef: Ref<HTMLElement | undefined, HTMLElement | undefined>;
@@ -9,7 +12,7 @@ export declare function useVirtual<T>(props: IVirtualProps, items: Ref<readonly
     }[]>;
     paddingTop: import("vue").ShallowRef<number, number>;
     paddingBottom: import("vue").ShallowRef<number, number>;
-    scrollToIndex: (index: number) => void;
+    scrollToIndex: (index: number, options?: Partial<IGoToOptions>) => void;
     handleScroll: () => void;
     handleScrollend: () => void;
     handleItemResize: (index: number, height: number) => void;

package/dist/src/composables/Commons/virtual.composable.js

@@ -1,9 +1,10 @@
-import { useDisplay, useResizeObserver } from "../../composables/index.js";
+import { useDisplay, useGoTo, useResizeObserver } from "../../composables/index.js";
 import { BUFFER_PX, DOWN, IN_BROWSER, UP } from "../../consts/index.js";
 import { binaryClosest, clamp, debounce, int } from "../../utils/index.js";
 import { computed, nextTick, onScopeDispose, ref, shallowRef, watch, watchEffect } from "vue";
 export function useVirtual(props, items) {
   const display = useDisplay();
+  const goTo = useGoTo();
   const itemHeight = shallowRef(0);
   watchEffect(() => {
     itemHeight.value = parseFloat(props.itemHeight || 0);
@@ -143,13 +144,24 @@ export function useVirtual(props, items) {
     paddingTop.value = calculateOffset(first.value);
     paddingBottom.value = calculateOffset(items.value.length) - calculateOffset(last.value);
   };
-  const scrollToIndex = (index) => {
+  const scrollToIndex = (index, options = {}) => {
     const offset = calculateOffset(index);
     if (!containerRef.value || index && !offset) {
       targetScrollIndex = index;
-    } else {
+      return;
+    }
+    const duration = options.duration ?? props.scrollDuration ?? 300;
+    const easing = options.easing ?? props.scrollEasing ?? "easeInOutCubic";
+    if (duration <= 0) {
       containerRef.value.scrollTop = offset;
+      return;
     }
+    void goTo(offset, {
+      container: containerRef.value,
+      duration,
+      easing,
+      ...options
+    });
   };
   const computedItems = computed(() => {
     return items.value.slice(first.value, last.value).map((item, index) => ({

package/dist/src/composables/CssSupport/cssSupport.composable.cjs

@@ -0,0 +1,100 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports._resetCssSupportCache = _resetCssSupportCache;
+exports.useCssSupport = useCssSupport;
+var _vue = require("vue");
+const _cache = /* @__PURE__ */new Map();
+let _initialized = false;
+const FEATURE_QUERIES = {
+  grid: "display: grid",
+  subgrid: "grid-template-columns: subgrid",
+  flexGap: "gap: 1px",
+  containerQueries: "(container-type: inline-size)",
+  has: "selector(:has(*))",
+  aspectRatio: "aspect-ratio: 1",
+  colorMix: "color: color-mix(in srgb, red, blue)",
+  accentColor: "accent-color: red",
+  minMaxClamp: "width: min(10px, 20px)",
+  mathFunctions: "width: calc(min(10px, 20px) + max(5px, 8px))",
+  anchorPositioning: "anchor-name: --foo",
+  scrollDrivenAnims: "animation-timeline: scroll()",
+  viewTransitions: "view-transition-name: foo",
+  nestedSelectors: "selector(& > a)",
+  individualTransforms: "translate: 1px 1px",
+  logicalProperties: "margin-inline: 1px",
+  backdropFilter: "backdrop-filter: blur(1px)",
+  fieldSizing: "field-sizing: content",
+  textWrapBalance: "text-wrap: balance",
+  contentVisibility: "content-visibility: auto"
+};
+function rawSupports(query) {
+  if (typeof window === "undefined" || typeof CSS === "undefined" || !CSS.supports) {
+    return false;
+  }
+  if (_cache.has(query)) return _cache.get(query);
+  let result = false;
+  try {
+    result = CSS.supports(query);
+  } catch {
+    result = false;
+  }
+  _cache.set(query, result);
+  return result;
+}
+const _flags = (0, _vue.ref)(emptyMap());
+function emptyMap() {
+  const out = {};
+  for (const k of Object.keys(FEATURE_QUERIES)) {
+    out[k] = false;
+  }
+  return Object.freeze(out);
+}
+function detectAll() {
+  const out = {};
+  for (const k of Object.keys(FEATURE_QUERIES)) {
+    out[k] = rawSupports(FEATURE_QUERIES[k]);
+  }
+  return Object.freeze(out);
+}
+function ensureInitialized() {
+  if (_initialized) return;
+  if (typeof window === "undefined") return;
+  _flags.value = detectAll();
+  _initialized = true;
+}
+function useCssSupport() {
+  ensureInitialized();
+  function supports(query) {
+    return rawSupports(query);
+  }
+  function supportsAny(...queries) {
+    for (const q of queries) {
+      if (rawSupports(q)) return true;
+    }
+    return false;
+  }
+  function supportsAll(...queries) {
+    for (const q of queries) {
+      if (!rawSupports(q)) return false;
+    }
+    return true;
+  }
+  function has(feature) {
+    return (0, _vue.computed)(() => _flags.value[feature]);
+  }
+  return {
+    css: (0, _vue.readonly)(_flags),
+    supports,
+    supportsAny,
+    supportsAll,
+    has
+  };
+}
+function _resetCssSupportCache() {
+  _cache.clear();
+  _initialized = false;
+  _flags.value = emptyMap();
+}

package/dist/src/composables/CssSupport/cssSupport.composable.d.ts

@@ -0,0 +1,70 @@
+import { type ComputedRef, type Ref } from 'vue';
+declare const FEATURE_QUERIES: {
+    readonly grid: "display: grid";
+    readonly subgrid: "grid-template-columns: subgrid";
+    readonly flexGap: "gap: 1px";
+    readonly containerQueries: "(container-type: inline-size)";
+    readonly has: "selector(:has(*))";
+    readonly aspectRatio: "aspect-ratio: 1";
+    readonly colorMix: "color: color-mix(in srgb, red, blue)";
+    readonly accentColor: "accent-color: red";
+    readonly minMaxClamp: "width: min(10px, 20px)";
+    readonly mathFunctions: "width: calc(min(10px, 20px) + max(5px, 8px))";
+    readonly anchorPositioning: "anchor-name: --foo";
+    readonly scrollDrivenAnims: "animation-timeline: scroll()";
+    readonly viewTransitions: "view-transition-name: foo";
+    readonly nestedSelectors: "selector(& > a)";
+    readonly individualTransforms: "translate: 1px 1px";
+    readonly logicalProperties: "margin-inline: 1px";
+    readonly backdropFilter: "backdrop-filter: blur(1px)";
+    readonly fieldSizing: "field-sizing: content";
+    readonly textWrapBalance: "text-wrap: balance";
+    readonly contentVisibility: "content-visibility: auto";
+};
+export type TCssFeatureName = keyof typeof FEATURE_QUERIES;
+export type TCssSupportMap = Readonly<Record<TCssFeatureName, boolean>>;
+export interface IUseCssSupport {
+    /**
+     * Reactive map of feature → `boolean`. Computed once on first browser-
+     * side call; subsequent calls share the same frozen snapshot.
+     */
+    css: Readonly<Ref<TCssSupportMap>>;
+    /**
+     * Free-form query support. Pass any string accepted by `CSS.supports()`.
+     * Result is cached per-query.
+     *
+     * @example
+     *   supports('display: grid')                  // true on modern browsers
+     *   supports('selector(:has(*))')              // selector query
+     *   supports('width: clamp(1px, 50%, 100px)')  // math function
+     */
+    supports: (query: string) => boolean;
+    /**
+     * `true` if at least ONE of the queries is supported.
+     */
+    supportsAny: (...queries: string[]) => boolean;
+    /**
+     * `true` if EVERY query is supported.
+     */
+    supportsAll: (...queries: string[]) => boolean;
+    /**
+     * Reactive `ComputedRef<boolean>` for a single named feature. Useful in
+     * templates: `<div v-if="hasGrid">…`.
+     */
+    has: (feature: TCssFeatureName) => ComputedRef<boolean>;
+}
+/*********************************************************
+ * useCssSupport
+ ********************************************************/
+export declare function useCssSupport(): IUseCssSupport;
+/**
+ * Test-only helper — clear the internal cache + re-detect on next call.
+ * Not part of the public API; consumers must not depend on it.
+ *
+ * @internal
+ */
+/*********************************************************
+ * _resetCssSupportCache
+ ********************************************************/
+export declare function _resetCssSupportCache(): void;
+export {};

package/dist/src/composables/CssSupport/cssSupport.composable.js

@@ -0,0 +1,93 @@
+import { computed, readonly, ref } from "vue";
+const _cache = /* @__PURE__ */ new Map();
+let _initialized = false;
+const FEATURE_QUERIES = {
+  grid: "display: grid",
+  subgrid: "grid-template-columns: subgrid",
+  flexGap: "gap: 1px",
+  containerQueries: "(container-type: inline-size)",
+  has: "selector(:has(*))",
+  aspectRatio: "aspect-ratio: 1",
+  colorMix: "color: color-mix(in srgb, red, blue)",
+  accentColor: "accent-color: red",
+  minMaxClamp: "width: min(10px, 20px)",
+  mathFunctions: "width: calc(min(10px, 20px) + max(5px, 8px))",
+  anchorPositioning: "anchor-name: --foo",
+  scrollDrivenAnims: "animation-timeline: scroll()",
+  viewTransitions: "view-transition-name: foo",
+  nestedSelectors: "selector(& > a)",
+  individualTransforms: "translate: 1px 1px",
+  logicalProperties: "margin-inline: 1px",
+  backdropFilter: "backdrop-filter: blur(1px)",
+  fieldSizing: "field-sizing: content",
+  textWrapBalance: "text-wrap: balance",
+  contentVisibility: "content-visibility: auto"
+};
+function rawSupports(query) {
+  if (typeof window === "undefined" || typeof CSS === "undefined" || !CSS.supports) {
+    return false;
+  }
+  if (_cache.has(query)) return _cache.get(query);
+  let result = false;
+  try {
+    result = CSS.supports(query);
+  } catch {
+    result = false;
+  }
+  _cache.set(query, result);
+  return result;
+}
+const _flags = ref(emptyMap());
+function emptyMap() {
+  const out = {};
+  for (const k of Object.keys(FEATURE_QUERIES)) {
+    out[k] = false;
+  }
+  return Object.freeze(out);
+}
+function detectAll() {
+  const out = {};
+  for (const k of Object.keys(FEATURE_QUERIES)) {
+    out[k] = rawSupports(FEATURE_QUERIES[k]);
+  }
+  return Object.freeze(out);
+}
+function ensureInitialized() {
+  if (_initialized) return;
+  if (typeof window === "undefined") return;
+  _flags.value = detectAll();
+  _initialized = true;
+}
+export function useCssSupport() {
+  ensureInitialized();
+  function supports(query) {
+    return rawSupports(query);
+  }
+  function supportsAny(...queries) {
+    for (const q of queries) {
+      if (rawSupports(q)) return true;
+    }
+    return false;
+  }
+  function supportsAll(...queries) {
+    for (const q of queries) {
+      if (!rawSupports(q)) return false;
+    }
+    return true;
+  }
+  function has(feature) {
+    return computed(() => _flags.value[feature]);
+  }
+  return {
+    css: readonly(_flags),
+    supports,
+    supportsAny,
+    supportsAll,
+    has
+  };
+}
+export function _resetCssSupportCache() {
+  _cache.clear();
+  _initialized = false;
+  _flags.value = emptyMap();
+}

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

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

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

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

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

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

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

@@ -1,6 +1,9 @@
 import { Ref } from 'vue';
 import type { IDataTableHeaderProps, IDataTableSortItem, IHeaderCellProps, IInternalDataTableHeader } from '../../interfaces';
 import type { TDataTableCompareFunction, TFilterKeyFunctions } from '../../types';
+/*********************************************************
+ * createHeaders
+ ********************************************************/
 export declare function createHeaders(props: IDataTableHeaderProps, options?: {
     groupBy?: Ref<Array<IDataTableSortItem>> | undefined;
     showSelect?: Ref<boolean>;
@@ -464,10 +467,16 @@ export declare function createHeaders(props: IDataTableHeaderProps, options?: {
     sortRawFunctions: Ref<Record<string, TDataTableCompareFunction>, Record<string, TDataTableCompareFunction>>;
     filterFunctions: Ref<TFilterKeyFunctions, TFilterKeyFunctions>;
 };
+/*********************************************************
+ * useHeaders
+ ********************************************************/
 export declare function useHeaders(): {
     headers: Ref<Array<Array<IInternalDataTableHeader>>>;
     columns: Ref<Array<IInternalDataTableHeader>>;
 };
+/*********************************************************
+ * useHeadersCell
+ ********************************************************/
 export declare function useHeadersCell(props: IHeaderCellProps): {
     getSortIcon: (column: IInternalDataTableHeader) => import("../../types").TIcon | undefined;
 };

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

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

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

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

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

@@ -1,14 +1,23 @@
 import { Ref } from 'vue';
 import type { IDataTableGroup, IDataTablePaginationProps, IDataTableProvidePagination } from '../../interfaces';
+/*********************************************************
+ * createPagination
+ ********************************************************/
 export declare function createPagination(props: IDataTablePaginationProps): {
     page: import("../../types").TVModel<IDataTablePaginationProps, "page", number>;
     itemsPerPage: import("../../types").TVModel<IDataTablePaginationProps, "itemsPerPage", number>;
 };
+/*********************************************************
+ * providePagination
+ ********************************************************/
 export declare function providePagination(options: {
     page: Ref<number>;
     itemsPerPage: Ref<number>;
     itemsLength: Ref<number>;
 }): IDataTableProvidePagination;
+/*********************************************************
+ * usePagination
+ ********************************************************/
 export declare function usePagination(): {
     page: Ref<number>;
     itemsPerPage: Ref<number>;
@@ -21,6 +30,9 @@ export declare function usePagination(): {
     setPage: (value: number) => void;
     setItemsPerPage: (value: number) => void;
 };
+/*********************************************************
+ * usePaginatedItems
+ ********************************************************/
 export declare function usePaginatedItems<T>(options: {
     items: Ref<readonly (T | IDataTableGroup<T>)[]>;
     startIndex: Ref<number>;