origam 2.16.0 → 2.17.1

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

@@ -1,10 +1,36 @@
-import type { IDataTableExpandProps, IDataTableItem, IDataTableProvideExpanded } from '../../interfaces';
+import type { IDataTableExpandProps, IDataTableProvideExpanded } from '../../interfaces/DataTable/expand.interface';
+import type { IDataTableItem } from '../../interfaces/DataTable/items.interface';
 /*********************************************************
  * provideExpanded
+ *
+ * @description
+ * Cree l'etat « quelles lignes sont depliees » d'un `<origam-data-table>` et
+ * le `provide` sous `ORIGAM_DATA_TABLE_EXPAND_KEY`, pour que les lignes le
+ * consomment sans que le tableau ait a le faire descendre par props.
+ *
+ * @description
+ * L'etat est un `Set` de valeurs de ligne, expose en v-model via `useVModel`
+ * avec conversion dans les deux sens : tableau cote consommateur, `Set` en
+ * interne. Le consommateur n'a donc jamais a manipuler un `Set`.
+ *
+ * @description
+ * Retourne `{ expand, expanded, expandOnClick, isExpanded, toggleExpand }` —
+ * le meme objet que celui qui est fourni, pour que le composant appelant
+ * puisse s'en servir directement sans re-injecter.
  ********************************************************/
 export declare function provideExpanded(props: IDataTableExpandProps): IDataTableProvideExpanded;
 /*********************************************************
  * useExpanded
+ *
+ * @description
+ * Cote consommateur de `provideExpanded` : recupere l'etat de depliage fourni
+ * par le `<origam-data-table>` ancetre.
+ *
+ * @description
+ * ⛔ LEVE si aucun ancetre ne l'a fourni (`Missing expand!`), plutot que de
+ * retourner `undefined`. Un composant de ligne utilise hors d'un tableau est
+ * une erreur de montage, pas un cas a gerer : echouer bruyamment au montage
+ * vaut mieux qu'un `isExpanded` qui repond toujours `false` sans rien dire.
  ********************************************************/
 export declare function useExpanded(): {
     expand: (item: IDataTableItem, value: boolean) => void;

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

@@ -1,9 +1,9 @@
 import { inject, provide, toRef } from "vue";
-import { useVModel } from "../../composables/index.js";
-import { ORIGAM_DATA_TABLE_EXPAND_KEY } from "../../consts/index.js";
+import { useVModel } from "../Commons/vModel.composable.js";
+import { ORIGAM_DATA_TABLE_EXPAND_KEY } from "../../consts/DataTable/data-table.const.js";
 export function provideExpanded(props) {
   const expandOnClick = toRef(props, "expandOnClick");
-  const expanded = useVModel(props, "expanded", props.expanded, (v) => {
+  const expanded = useVModel(props, "expanded", void 0, (v) => {
     return new Set(v);
   }, (v) => {
     return [...v.values()];

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

@@ -6,13 +6,11 @@ Object.defineProperty(exports, "__esModule", {
 exports.createGroupBy = createGroupBy;
 exports.provideGroupBy = provideGroupBy;
 exports.useGroupBy = useGroupBy;
-exports.useGroupedItems = useGroupedItems;
 var _vue = require("vue");
-var _composables = require("../../composables/index.cjs");
-var _consts = require("../../consts/index.cjs");
-var _utils = require("../../utils/index.cjs");
+var _vModel = require("../Commons/vModel.composable.cjs");
+var _dataTable = require("../../consts/DataTable/data-table.const.cjs");
 function createGroupBy(props) {
-  const groupBy = (0, _composables.useVModel)(props, "groupBy", []);
+  const groupBy = (0, _vModel.useVModel)(props, "groupBy", []);
   return {
     groupBy
   };
@@ -66,21 +64,11 @@ function provideGroupBy(options) {
     extractRows,
     isGroupOpen
   };
-  (0, _vue.provide)(_consts.ORIGAM_DATA_TABLE_GROUP_KEY, data);
+  (0, _vue.provide)(_dataTable.ORIGAM_DATA_TABLE_GROUP_KEY, data);
   return data;
 }
-function useGroupedItems(items, groupBy, opened) {
-  const flatItems = (0, _vue.computed)(() => {
-    if (!groupBy.value.length) return items.value;
-    const groupedItems = (0, _utils.groupItems)(items.value, groupBy.value.map(item => item.key));
-    return (0, _utils.flattenItems)(groupedItems, opened.value);
-  });
-  return {
-    flatItems
-  };
-}
 function useGroupBy() {
-  const data = (0, _vue.inject)(_consts.ORIGAM_DATA_TABLE_GROUP_KEY);
+  const data = (0, _vue.inject)(_dataTable.ORIGAM_DATA_TABLE_GROUP_KEY);
   if (!data) throw new Error("Missing group!");
   return data;
 }

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

@@ -1,26 +1,39 @@
-import { ComputedRef, Ref } from 'vue';
-import type { IDataTableGroup, IDataTableGroupableItem, IDataTableGroupProps, IDataTableProvideGroup, IDataTableSortItem } from '../../interfaces';
+import type { Ref } from 'vue';
+import type { IDataTableGroup, IDataTableGroupProps, IDataTableProvideGroup } from '../../interfaces/DataTable/group.interface';
+import type { IDataTableSortItem } from '../../interfaces/DataTable/sort.interface';
 /*********************************************************
  * createGroupBy
+ *
+ * @description
+ * Reads the `groupBy` prop into the v-model ref `provideGroupBy`
+ * expects. Kept alongside `useGroupBy` / `provideGroupBy` in this file
+ * — all three address the same `ORIGAM_DATA_TABLE_GROUP_KEY` contract.
+ * `useGroupedItems` (own file) is the pure item-grouping sibling and
+ * does not depend on any of the three.
  ********************************************************/
 export declare function createGroupBy(props: IDataTableGroupProps): {
     groupBy: import("../../types").TVModel<IDataTableGroupProps, "groupBy", IDataTableSortItem[] | undefined>;
 };
 /*********************************************************
  * provideGroupBy
+ *
+ * @description
+ * Provider-side hook: derives `sortByWithGroups` plus the
+ * `toggleGroup` / `isGroupOpen` / `extractRows` helpers, and provides
+ * `ORIGAM_DATA_TABLE_GROUP_KEY` for `useGroupBy` consumers down the
+ * tree.
  ********************************************************/
 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
+ *
+ * @description
+ * Reads the injected group state provided by `provideGroupBy`.
+ * Independent from `useGroupedItems` (own file) — that hook groups a
+ * plain items array and never touches this injection.
  ********************************************************/
 export declare function useGroupBy(): {
     opened: Ref<Set<string>>;

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

@@ -1,7 +1,6 @@
 import { computed, inject, provide, ref } from "vue";
-import { useVModel } from "../../composables/index.js";
-import { ORIGAM_DATA_TABLE_GROUP_KEY } from "../../consts/index.js";
-import { flattenItems, groupItems } from "../../utils/index.js";
+import { useVModel } from "../Commons/vModel.composable.js";
+import { ORIGAM_DATA_TABLE_GROUP_KEY } from "../../consts/DataTable/data-table.const.js";
 export function createGroupBy(props) {
   const groupBy = useVModel(props, "groupBy", []);
   return { groupBy };
@@ -42,14 +41,6 @@ export function provideGroupBy(options) {
   provide(ORIGAM_DATA_TABLE_GROUP_KEY, data);
   return data;
 }
-export function useGroupedItems(items, groupBy, opened) {
-  const flatItems = computed(() => {
-    if (!groupBy.value.length) return items.value;
-    const groupedItems = groupItems(items.value, groupBy.value.map((item) => item.key));
-    return flattenItems(groupedItems, opened.value);
-  });
-  return { flatItems };
-}
 export function useGroupBy() {
   const data = inject(ORIGAM_DATA_TABLE_GROUP_KEY);
   if (!data) throw new Error("Missing group!");

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

@@ -0,0 +1,18 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useGroupedItems = useGroupedItems;
+var _vue = require("vue");
+var _group = require("../../utils/DataTable/group.util.cjs");
+function useGroupedItems(items, groupBy, opened) {
+  const flatItems = (0, _vue.computed)(() => {
+    if (!groupBy.value.length) return items.value;
+    const groupedItems = (0, _group.groupItems)(items.value, groupBy.value.map(item => item.key));
+    return (0, _group.flattenItems)(groupedItems, opened.value);
+  });
+  return {
+    flatItems
+  };
+}

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

@@ -0,0 +1,17 @@
+import type { ComputedRef, Ref } from 'vue';
+import type { IDataTableGroupableItem } from '../../interfaces/DataTable/group.interface';
+import type { IDataTableSortItem } from '../../interfaces/DataTable/sort.interface';
+/*********************************************************
+ * useGroupedItems
+ *
+ * @description
+ * Pure item-grouping hook: builds the grouped tree (via `groupItems`)
+ * and flattens it back to a display list honouring `opened` groups.
+ * Independent from `useGroupBy` / `provideGroupBy` / `createGroupBy`
+ * (own file) — it consumes `groupBy` / `opened` refs as plain
+ * arguments, never the `ORIGAM_DATA_TABLE_GROUP_KEY` injection those
+ * manage.
+ ********************************************************/
+export declare function useGroupedItems<T extends IDataTableGroupableItem>(items: ComputedRef<Array<T>>, groupBy: Ref<Array<IDataTableSortItem>>, opened: Ref<Set<string>>): {
+    flatItems: ComputedRef<(T | import("../../interfaces").IDataTableGroup<T>)[]>;
+};

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

@@ -0,0 +1,10 @@
+import { computed } from "vue";
+import { flattenItems, groupItems } from "../../utils/DataTable/group.util.js";
+export function useGroupedItems(items, groupBy, opened) {
+  const flatItems = computed(() => {
+    if (!groupBy.value.length) return items.value;
+    const groupedItems = groupItems(items.value, groupBy.value.map((item) => item.key));
+    return flattenItems(groupedItems, opened.value);
+  });
+  return { flatItems };
+}

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

@@ -5,12 +5,9 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.createHeaders = createHeaders;
 exports.useHeaders = useHeaders;
-exports.useHeadersCell = useHeadersCell;
 var _vue = require("vue");
-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 _dataTable = require("../../consts/DataTable/data-table.const.cjs");
+var _headers2 = require("../../utils/DataTable/headers.util.cjs");
 function createHeaders(props, options) {
   const headers = (0, _vue.ref)([]);
   const columns = (0, _vue.ref)([]);
@@ -23,7 +20,7 @@ function createHeaders(props, options) {
       title: (0, _vue.capitalize)(key)
     }));
     const items = _headers.slice();
-    const keys = (0, _utils.extractKeys)(items);
+    const keys = (0, _headers2.extractKeys)(items);
     if (options?.groupBy?.value?.length && !keys.has("data-table-group")) {
       items.unshift({
         key: "data-table-group",
@@ -40,10 +37,10 @@ function createHeaders(props, options) {
         key: "data-table-expand"
       });
     }
-    const internalHeaders = (0, _utils.convertToInternalHeaders)(items);
-    (0, _utils.parseFixedColumns)(internalHeaders);
-    const maxDepth = Math.max(...internalHeaders.map(item => (0, _utils.getHeaderDepth)(item))) + 1;
-    const parsed = (0, _utils.parseHeaderItems)(internalHeaders, maxDepth);
+    const internalHeaders = (0, _headers2.convertToInternalHeaders)(items);
+    (0, _headers2.parseFixedColumns)(internalHeaders);
+    const maxDepth = Math.max(...internalHeaders.map(item => (0, _headers2.getHeaderDepth)(item))) + 1;
+    const parsed = (0, _headers2.parseHeaderItems)(internalHeaders, maxDepth);
     headers.value = parsed.headers;
     columns.value = parsed.columns;
     const flatHeaders = parsed.headers.flat(1);
@@ -69,26 +66,11 @@ function createHeaders(props, options) {
     sortRawFunctions,
     filterFunctions
   };
-  (0, _vue.provide)(_consts.ORIGAM_DATA_TABLE_HEADERS_KEY, data);
+  (0, _vue.provide)(_dataTable.ORIGAM_DATA_TABLE_HEADERS_KEY, data);
   return data;
 }
 function useHeaders() {
-  const data = (0, _vue.inject)(_consts.ORIGAM_DATA_TABLE_HEADERS_KEY);
+  const data = (0, _vue.inject)(_dataTable.ORIGAM_DATA_TABLE_HEADERS_KEY);
   if (!data) throw new Error("Missing headers!");
   return data;
-}
-function useHeadersCell(props) {
-  const {
-    sortBy
-  } = (0, _composables.useSort)();
-  const getSortIcon = column => {
-    const item = sortBy.value.find(sortByItem => {
-      return sortByItem.key === column.key;
-    });
-    if (!item) return props.sortAscIcon;
-    return item.order === _enums.SORT_DIRECTION.ASC ? props.sortAscIcon : props.sortDescIcon;
-  };
-  return {
-    getSortIcon
-  };
 }

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

@@ -1,8 +1,19 @@
-import { Ref } from 'vue';
-import type { IDataTableHeaderProps, IDataTableSortItem, IHeaderCellProps, IInternalDataTableHeader } from '../../interfaces';
-import type { TDataTableCompareFunction, TFilterKeyFunctions } from '../../types';
+import type { Ref } from 'vue';
+import type { IDataTableHeaderProps, IInternalDataTableHeader } from '../../interfaces/DataTable/data-table-header.interface';
+import type { IDataTableSortItem } from '../../interfaces/DataTable/sort.interface';
+import type { TFilterKeyFunctions } from '../../types/Commons/filters.type';
+import type { TDataTableCompareFunction } from '../../types/DataTable/data-table.type';
 /*********************************************************
  * createHeaders
+ *
+ * @description
+ * Normalises the raw `headers` prop (or infers columns from the first
+ * item) into the internal multi-row header + column + sort/filter
+ * function maps, and provides `ORIGAM_DATA_TABLE_HEADERS_KEY` for
+ * `useHeaders` consumers down the tree. Kept alongside `useHeaders` in
+ * this file — the two address the same contract. `useHeadersCell` (own
+ * file) is the per-cell sort-icon sibling and depends on `useSort`
+ * instead, not on this injection.
  ********************************************************/
 export declare function createHeaders(props: IDataTableHeaderProps, options?: {
     groupBy?: Ref<Array<IDataTableSortItem>> | undefined;
@@ -24,14 +35,14 @@ export declare function createHeaders(props: IDataTableHeaderProps, options?: {
         minWidth?: string | undefined;
         width?: number | string | undefined;
         fixed?: boolean | undefined;
+        title?: string | undefined;
         sort?: TDataTableCompareFunction | undefined;
         filter?: import("../../types").TFilterFunction | undefined;
-        title?: string | undefined;
         align?: (import("../../enums").ALIGN.START | import("../../enums").ALIGN.END | import("../../enums").ALIGN.CENTER) | undefined;
+        mobile?: boolean | undefined;
         headerProps?: any;
         cellProps?: import("../../types").TDataTableHeaderCell | undefined;
         sortRaw?: TDataTableCompareFunction | undefined;
-        mobile?: boolean | undefined;
     }[][], IInternalDataTableHeader[][] | {
         key: string | null;
         value: import("../../types").TSelectItemKey | null;
@@ -47,14 +58,14 @@ export declare function createHeaders(props: IDataTableHeaderProps, options?: {
         minWidth?: string | undefined;
         width?: number | string | undefined;
         fixed?: boolean | undefined;
+        title?: string | undefined;
         sort?: TDataTableCompareFunction | undefined;
         filter?: import("../../types").TFilterFunction | undefined;
-        title?: string | undefined;
         align?: (import("../../enums").ALIGN.START | import("../../enums").ALIGN.END | import("../../enums").ALIGN.CENTER) | undefined;
+        mobile?: boolean | undefined;
         headerProps?: any;
         cellProps?: import("../../types").TDataTableHeaderCell | undefined;
         sortRaw?: TDataTableCompareFunction | undefined;
-        mobile?: boolean | undefined;
     }[][]>;
     columns: Ref<{
         key: string | null;
@@ -71,14 +82,14 @@ export declare function createHeaders(props: IDataTableHeaderProps, options?: {
         minWidth?: string | undefined;
         width?: number | string | undefined;
         fixed?: boolean | undefined;
+        title?: string | undefined;
         sort?: TDataTableCompareFunction | undefined;
         filter?: import("../../types").TFilterFunction | undefined;
-        title?: string | undefined;
         align?: (import("../../enums").ALIGN.START | import("../../enums").ALIGN.END | import("../../enums").ALIGN.CENTER) | undefined;
+        mobile?: boolean | undefined;
         headerProps?: any;
         cellProps?: import("../../types").TDataTableHeaderCell | undefined;
         sortRaw?: TDataTableCompareFunction | undefined;
-        mobile?: boolean | undefined;
     }[], IInternalDataTableHeader[] | {
         key: string | null;
         value: import("../../types").TSelectItemKey | null;
@@ -94,14 +105,14 @@ export declare function createHeaders(props: IDataTableHeaderProps, options?: {
         minWidth?: string | undefined;
         width?: number | string | undefined;
         fixed?: boolean | undefined;
+        title?: string | undefined;
         sort?: TDataTableCompareFunction | undefined;
         filter?: import("../../types").TFilterFunction | undefined;
-        title?: string | undefined;
         align?: (import("../../enums").ALIGN.START | import("../../enums").ALIGN.END | import("../../enums").ALIGN.CENTER) | undefined;
+        mobile?: boolean | 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>>;
@@ -109,14 +120,13 @@ export declare function createHeaders(props: IDataTableHeaderProps, options?: {
 };
 /*********************************************************
  * useHeaders
+ *
+ * @description
+ * Reads the injected headers state provided by `createHeaders`.
+ * Independent from `useHeadersCell` (own file) — that hook resolves a
+ * per-cell sort icon via `useSort` and never touches this injection.
  ********************************************************/
 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/headers.composable.js

@@ -1,8 +1,6 @@
 import { capitalize, inject, provide, ref, watchEffect } from "vue";
-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 { ORIGAM_DATA_TABLE_HEADERS_KEY } from "../../consts/DataTable/data-table.const.js";
+import { convertToInternalHeaders, extractKeys, getHeaderDepth, parseFixedColumns, parseHeaderItems } from "../../utils/DataTable/headers.util.js";
 export function createHeaders(props, options) {
   const headers = ref([]);
   const columns = ref([]);
@@ -53,14 +51,3 @@ export function useHeaders() {
   if (!data) throw new Error("Missing headers!");
   return data;
 }
-export function useHeadersCell(props) {
-  const { sortBy } = useSort();
-  const getSortIcon = (column) => {
-    const item = sortBy.value.find((sortByItem) => {
-      return sortByItem.key === column.key;
-    });
-    if (!item) return props.sortAscIcon;
-    return item.order === SORT_DIRECTION.ASC ? props.sortAscIcon : props.sortDescIcon;
-  };
-  return { getSortIcon };
-}

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

@@ -0,0 +1,23 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useHeadersCell = useHeadersCell;
+var _sort = require("./sort.composable.cjs");
+var _enums = require("../../enums/index.cjs");
+function useHeadersCell(props) {
+  const {
+    sortBy
+  } = (0, _sort.useSort)();
+  const getSortIcon = column => {
+    const item = sortBy.value.find(sortByItem => {
+      return sortByItem.key === column.key;
+    });
+    if (!item) return props.sortAscIcon;
+    return item.order === _enums.SORT_DIRECTION.ASC ? props.sortAscIcon : props.sortDescIcon;
+  };
+  return {
+    getSortIcon
+  };
+}

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

@@ -0,0 +1,15 @@
+import type { IInternalDataTableHeader } from '../../interfaces/DataTable/data-table-header.interface';
+import type { IHeaderCellProps } from '../../interfaces/DataTable/header-cell-base.interface';
+/*********************************************************
+ * useHeadersCell
+ *
+ * @description
+ * Resolves which sort icon (asc/desc) a header cell should show for
+ * the current `sortBy` state — reads `useSort`'s injection, NOT the
+ * `ORIGAM_DATA_TABLE_HEADERS_KEY` injection `useHeaders` (own file)
+ * manages, so the two hooks are independent despite living in the
+ * same domain folder.
+ ********************************************************/
+export declare function useHeadersCell(props: IHeaderCellProps): {
+    getSortIcon: (column: IInternalDataTableHeader) => import("../../types").TIcon | undefined;
+};

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

@@ -0,0 +1,13 @@
+import { useSort } from "./sort.composable.js";
+import { SORT_DIRECTION } from "../../enums/index.js";
+export function useHeadersCell(props) {
+  const { sortBy } = useSort();
+  const getSortIcon = (column) => {
+    const item = sortBy.value.find((sortByItem) => {
+      return sortByItem.key === column.key;
+    });
+    if (!item) return props.sortAscIcon;
+    return item.order === SORT_DIRECTION.ASC ? props.sortAscIcon : props.sortDescIcon;
+  };
+  return { getSortIcon };
+}

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

@@ -5,9 +5,9 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.useDataTableItems = useDataTableItems;
 var _vue = require("vue");
-var _utils = require("../../utils/index.cjs");
+var _items = require("../../utils/DataTable/items.util.cjs");
 function useDataTableItems(props, columns) {
-  const items = (0, _vue.computed)(() => (0, _utils.transformDataTableItems)(props, props.items, columns.value));
+  const items = (0, _vue.computed)(() => (0, _items.transformDataTableItems)(props, props.items, columns.value));
   return {
     items
   };

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

@@ -1,8 +1,23 @@
 import { Ref } from 'vue';
-import type { IDataTableItemsProps, IInternalDataTableHeader } from '../../interfaces';
+import type { IInternalDataTableHeader } from '../../interfaces/DataTable/data-table-header.interface';
+import type { IDataTableItemsProps } from '../../interfaces/DataTable/items.interface';
 /*********************************************************
  * useDataTableItems
  ********************************************************/
+/*********************************************************
+ * useDataTableItems
+ *
+ * @description
+ * Transforme les donnees brutes de `props.items` en lignes internes de
+ * `<origam-data-table>`, via `transformDataTableItems`. Retourne `{ items }`.
+ *
+ * @description
+ * Depend des COLONNES autant que des donnees : la transformation extrait une
+ * valeur par colonne declaree. Les colonnes sont donc passees en `Ref` et non
+ * en valeur, pour que le calcul se refasse quand elles changent — un tableau
+ * dont les colonnes sont dynamiques recalculerait sinon ses lignes sur
+ * l'ancien jeu.
+ ********************************************************/
 export declare function useDataTableItems(props: IDataTableItemsProps, columns: Ref<Array<IInternalDataTableHeader>>): {
     items: import("vue").ComputedRef<import("../../interfaces").IDataTableItem<any>[]>;
 };

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

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

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

@@ -4,7 +4,8 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.useOptions = useOptions;
-var _utils = require("../../utils/index.cjs");
+var _commons = require("../../utils/Commons/commons.util.cjs");
+var _getCurrentInstance = require("../../utils/Commons/getCurrentInstance.util.cjs");
 var _vue = require("vue");
 function useOptions({
   page,
@@ -13,7 +14,7 @@ function useOptions({
   groupBy,
   search
 }) {
-  const vm = (0, _utils.getCurrentInstance)("OrigamDataTable");
+  const vm = (0, _getCurrentInstance.getCurrentInstance)("OrigamDataTable");
   const options = (0, _vue.computed)(() => ({
     page: page.value,
     itemsPerPage: itemsPerPage.value,
@@ -23,7 +24,7 @@ function useOptions({
   }));
   let oldOptions = null;
   (0, _vue.watch)(options, () => {
-    if ((0, _utils.deepEqual)(oldOptions, options.value)) return;
+    if ((0, _commons.deepEqual)(oldOptions, options.value)) return;
     if (oldOptions && oldOptions.search !== options.value.search) {
       page.value = 1;
     }

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

@@ -1,8 +1,28 @@
-import type { IDataTableSortItem } from '../../interfaces';
+import type { IDataTableSortItem } from '../../interfaces/DataTable/sort.interface';
 import { Ref } from 'vue';
 /*********************************************************
  * useOptions
  ********************************************************/
+/*********************************************************
+ * useOptions
+ *
+ * @description
+ * Regroupe pagination, tri, groupement et recherche en un seul objet
+ * `options`, et emet `update:options` sur `<origam-data-table>` a chaque
+ * changement reel. C'est le point unique par lequel un consommateur en mode
+ * serveur apprend qu'il doit recharger.
+ *
+ * @description
+ * Ne retourne RIEN : ce composable est un effet de bord, pas une source de
+ * valeur. Les refs qu'il surveille appartiennent deja a l'appelant.
+ *
+ * @description
+ * ⛔ Deux protections contre les emissions parasites. Un `deepEqual` avec
+ * l'objet precedent evite d'emettre quand une ref a ete reassignee sans que
+ * son contenu change. Et un changement de `search` REMET LA PAGE A 1 avant
+ * d'emettre — sans quoi une recherche depuis la page 4 demanderait la page 4
+ * d'un jeu de resultats qui n'en a peut-etre qu'une.
+ ********************************************************/
 export declare function useOptions({ page, itemsPerPage, sortBy, groupBy, search }: {
     page: Ref<number>;
     itemsPerPage: Ref<number>;

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

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

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

@@ -0,0 +1,27 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.usePaginatedItems = usePaginatedItems;
+var _vue = require("vue");
+var _getCurrentInstance = require("../../utils/Commons/getCurrentInstance.util.cjs");
+function usePaginatedItems(options) {
+  const vm = (0, _getCurrentInstance.getCurrentInstance)("usePaginatedItems");
+  const {
+    items,
+    startIndex,
+    stopIndex,
+    itemsPerPage
+  } = options;
+  const paginatedItems = (0, _vue.computed)(() => {
+    if (itemsPerPage.value <= 0) return items.value;
+    return items.value.slice(startIndex.value, stopIndex.value);
+  });
+  (0, _vue.watch)(paginatedItems, val => {
+    vm.emit("update:currentItems", val);
+  });
+  return {
+    paginatedItems
+  };
+}

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

@@ -0,0 +1,21 @@
+import type { Ref } from 'vue';
+import type { IDataTableGroup } from '../../interfaces/DataTable/group.interface';
+/*********************************************************
+ * usePaginatedItems
+ *
+ * @description
+ * Pure item-slicing hook: slices a plain items array to the current
+ * `[startIndex, stopIndex)` window and emits `update:currentItems`.
+ * Independent from `usePagination` / `providePagination` /
+ * `createPagination` (own file) — it consumes `startIndex` / `stopIndex`
+ * / `itemsPerPage` refs as plain arguments, never the
+ * `ORIGAM_DATA_TABLE_PAGINATION_KEY` injection those manage.
+ ********************************************************/
+export declare function usePaginatedItems<T>(options: {
+    items: Ref<readonly (T | IDataTableGroup<T>)[]>;
+    startIndex: Ref<number>;
+    stopIndex: Ref<number>;
+    itemsPerPage: Ref<number>;
+}): {
+    paginatedItems: import("vue").ComputedRef<readonly (T | IDataTableGroup<T>)[]>;
+};