origam 2.16.0 → 2.17.0

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

@@ -0,0 +1,14 @@
+import { computed, watch } from "vue";
+import { getCurrentInstance } from "../../utils/Commons/getCurrentInstance.util.js";
+export function usePaginatedItems(options) {
+  const vm = getCurrentInstance("usePaginatedItems");
+  const { items, startIndex, stopIndex, itemsPerPage } = options;
+  const paginatedItems = computed(() => {
+    if (itemsPerPage.value <= 0) return items.value;
+    return items.value.slice(startIndex.value, stopIndex.value);
+  });
+  watch(paginatedItems, (val) => {
+    vm.emit("update:currentItems", val);
+  });
+  return { paginatedItems };
+}

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

@@ -5,15 +5,14 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.createPagination = createPagination;
 exports.providePagination = providePagination;
-exports.usePaginatedItems = usePaginatedItems;
 exports.usePagination = usePagination;
 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");
+var _commons = require("../../utils/Commons/commons.util.cjs");
 function createPagination(props) {
-  const page = (0, _composables.useVModel)(props, "page", void 0, value => +(value ?? 1));
-  const itemsPerPage = (0, _composables.useVModel)(props, "itemsPerPage", void 0, value => +(value ?? 10));
+  const page = (0, _vModel.useVModel)(props, "page", void 0, value => +(value ?? _dataTable.DATA_TABLE_DEFAULT_PAGE));
+  const itemsPerPage = (0, _vModel.useVModel)(props, "itemsPerPage", void 0, value => +(value ?? _dataTable.DATA_TABLE_DEFAULT_ITEMS_PER_PAGE));
   return {
     page,
     itemsPerPage
@@ -26,15 +25,15 @@ function providePagination(options) {
     itemsLength
   } = options;
   const startIndex = (0, _vue.computed)(() => {
-    if (itemsPerPage.value === -1) return 0;
-    return itemsPerPage.value * (page.value - 1);
+    if (itemsPerPage.value === _dataTable.DATA_TABLE_ITEMS_PER_PAGE_ALL) return 0;
+    return itemsPerPage.value * (page.value - _dataTable.DATA_TABLE_DEFAULT_PAGE);
   });
   const stopIndex = (0, _vue.computed)(() => {
-    if (itemsPerPage.value === -1) return itemsLength.value;
+    if (itemsPerPage.value === _dataTable.DATA_TABLE_ITEMS_PER_PAGE_ALL) return itemsLength.value;
     return Math.min(itemsLength.value, startIndex.value + itemsPerPage.value);
   });
   const pageCount = (0, _vue.computed)(() => {
-    if (itemsPerPage.value === -1 || itemsLength.value === 0) return 1;
+    if (itemsPerPage.value === _dataTable.DATA_TABLE_ITEMS_PER_PAGE_ALL || itemsLength.value === 0) return _dataTable.DATA_TABLE_MIN_PAGE_COUNT;
     return Math.ceil(itemsLength.value / itemsPerPage.value);
   });
   (0, _vue.watchEffect)(() => {
@@ -44,16 +43,16 @@ function providePagination(options) {
   });
   const setItemsPerPage = value => {
     itemsPerPage.value = value;
-    page.value = 1;
+    page.value = _dataTable.DATA_TABLE_DEFAULT_PAGE;
   };
   const nextPage = () => {
-    page.value = (0, _utils.clamp)(page.value + 1, 1, pageCount.value);
+    page.value = (0, _commons.clamp)(page.value + 1, _dataTable.DATA_TABLE_DEFAULT_PAGE, pageCount.value);
   };
   const prevPage = () => {
-    page.value = (0, _utils.clamp)(page.value - 1, 1, pageCount.value);
+    page.value = (0, _commons.clamp)(page.value - 1, _dataTable.DATA_TABLE_DEFAULT_PAGE, pageCount.value);
   };
   const setPage = value => {
-    page.value = (0, _utils.clamp)(value, 1, pageCount.value);
+    page.value = (0, _commons.clamp)(value, _dataTable.DATA_TABLE_DEFAULT_PAGE, pageCount.value);
   };
   const data = {
     page,
@@ -67,30 +66,11 @@ function providePagination(options) {
     setPage,
     setItemsPerPage
   };
-  (0, _vue.provide)(_consts.ORIGAM_DATA_TABLE_PAGINATION_KEY, data);
+  (0, _vue.provide)(_dataTable.ORIGAM_DATA_TABLE_PAGINATION_KEY, data);
   return data;
 }
 function usePagination() {
-  const data = (0, _vue.inject)(_consts.ORIGAM_DATA_TABLE_PAGINATION_KEY);
-  if (!data) throw new Error("Missing pagination!");
+  const data = (0, _vue.inject)(_dataTable.ORIGAM_DATA_TABLE_PAGINATION_KEY);
+  if (!data) throw new Error(_dataTable.DATA_TABLE_PAGINATION_MISSING_ERROR);
   return data;
-}
-function usePaginatedItems(options) {
-  const vm = (0, _utils.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/pagination.composable.d.ts

@@ -1,7 +1,15 @@
-import { Ref } from 'vue';
-import type { IDataTableGroup, IDataTablePaginationProps, IDataTableProvidePagination } from '../../interfaces';
+import type { Ref } from 'vue';
+import type { IDataTableProvidePagination, IDataTablePaginationProps } from '../../interfaces/DataTable/pagination.interface';
 /*********************************************************
  * createPagination
+ *
+ * @description
+ * Reads the `page` / `itemsPerPage` props into the v-model refs
+ * `providePagination` expects. Kept alongside `usePagination` /
+ * `providePagination` in this file — all three address the same
+ * `ORIGAM_DATA_TABLE_PAGINATION_KEY` contract. `usePaginatedItems`
+ * (own file) is the pure item-slicing sibling and does not depend on
+ * any of the three.
  ********************************************************/
 export declare function createPagination(props: IDataTablePaginationProps): {
     page: import("../../types").TVModel<IDataTablePaginationProps, "page", number>;
@@ -9,6 +17,12 @@ export declare function createPagination(props: IDataTablePaginationProps): {
 };
 /*********************************************************
  * providePagination
+ *
+ * @description
+ * Provider-side hook: derives `startIndex` / `stopIndex` / `pageCount`
+ * plus the `nextPage` / `prevPage` / `setPage` / `setItemsPerPage`
+ * mutators, and provides `ORIGAM_DATA_TABLE_PAGINATION_KEY` for
+ * `usePagination` consumers down the tree.
  ********************************************************/
 export declare function providePagination(options: {
     page: Ref<number>;
@@ -17,6 +31,11 @@ export declare function providePagination(options: {
 }): IDataTableProvidePagination;
 /*********************************************************
  * usePagination
+ *
+ * @description
+ * Reads the injected pagination state provided by `providePagination`.
+ * Independent from `usePaginatedItems` (own file) — that hook slices a
+ * plain items array and never touches this injection.
  ********************************************************/
 export declare function usePagination(): {
     page: Ref<number>;
@@ -30,14 +49,3 @@ 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>;
-    stopIndex: Ref<number>;
-    itemsPerPage: Ref<number>;
-}): {
-    paginatedItems: import("vue").ComputedRef<readonly (T | IDataTableGroup<T>)[]>;
-};

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

@@ -1,24 +1,31 @@
-import { computed, inject, provide, watch, watchEffect } from "vue";
-import { useVModel } from "../../composables/index.js";
-import { ORIGAM_DATA_TABLE_PAGINATION_KEY } from "../../consts/index.js";
-import { clamp, getCurrentInstance } from "../../utils/index.js";
+import { computed, inject, provide, watchEffect } from "vue";
+import { useVModel } from "../Commons/vModel.composable.js";
+import {
+  DATA_TABLE_DEFAULT_ITEMS_PER_PAGE,
+  DATA_TABLE_DEFAULT_PAGE,
+  DATA_TABLE_ITEMS_PER_PAGE_ALL,
+  DATA_TABLE_MIN_PAGE_COUNT,
+  DATA_TABLE_PAGINATION_MISSING_ERROR,
+  ORIGAM_DATA_TABLE_PAGINATION_KEY
+} from "../../consts/DataTable/data-table.const.js";
+import { clamp } from "../../utils/Commons/commons.util.js";
 export function createPagination(props) {
-  const page = useVModel(props, "page", void 0, (value) => +(value ?? 1));
-  const itemsPerPage = useVModel(props, "itemsPerPage", void 0, (value) => +(value ?? 10));
+  const page = useVModel(props, "page", void 0, (value) => +(value ?? DATA_TABLE_DEFAULT_PAGE));
+  const itemsPerPage = useVModel(props, "itemsPerPage", void 0, (value) => +(value ?? DATA_TABLE_DEFAULT_ITEMS_PER_PAGE));
   return { page, itemsPerPage };
 }
 export function providePagination(options) {
   const { page, itemsPerPage, itemsLength } = options;
   const startIndex = computed(() => {
-    if (itemsPerPage.value === -1) return 0;
-    return itemsPerPage.value * (page.value - 1);
+    if (itemsPerPage.value === DATA_TABLE_ITEMS_PER_PAGE_ALL) return 0;
+    return itemsPerPage.value * (page.value - DATA_TABLE_DEFAULT_PAGE);
   });
   const stopIndex = computed(() => {
-    if (itemsPerPage.value === -1) return itemsLength.value;
+    if (itemsPerPage.value === DATA_TABLE_ITEMS_PER_PAGE_ALL) return itemsLength.value;
     return Math.min(itemsLength.value, startIndex.value + itemsPerPage.value);
   });
   const pageCount = computed(() => {
-    if (itemsPerPage.value === -1 || itemsLength.value === 0) return 1;
+    if (itemsPerPage.value === DATA_TABLE_ITEMS_PER_PAGE_ALL || itemsLength.value === 0) return DATA_TABLE_MIN_PAGE_COUNT;
     return Math.ceil(itemsLength.value / itemsPerPage.value);
   });
   watchEffect(() => {
@@ -28,16 +35,16 @@ export function providePagination(options) {
   });
   const setItemsPerPage = (value) => {
     itemsPerPage.value = value;
-    page.value = 1;
+    page.value = DATA_TABLE_DEFAULT_PAGE;
   };
   const nextPage = () => {
-    page.value = clamp(page.value + 1, 1, pageCount.value);
+    page.value = clamp(page.value + 1, DATA_TABLE_DEFAULT_PAGE, pageCount.value);
   };
   const prevPage = () => {
-    page.value = clamp(page.value - 1, 1, pageCount.value);
+    page.value = clamp(page.value - 1, DATA_TABLE_DEFAULT_PAGE, pageCount.value);
   };
   const setPage = (value) => {
-    page.value = clamp(value, 1, pageCount.value);
+    page.value = clamp(value, DATA_TABLE_DEFAULT_PAGE, pageCount.value);
   };
   const data = {
     page,
@@ -56,18 +63,6 @@ export function providePagination(options) {
 }
 export function usePagination() {
   const data = inject(ORIGAM_DATA_TABLE_PAGINATION_KEY);
-  if (!data) throw new Error("Missing pagination!");
+  if (!data) throw new Error(DATA_TABLE_PAGINATION_MISSING_ERROR);
   return data;
 }
-export function usePaginatedItems(options) {
-  const vm = getCurrentInstance("usePaginatedItems");
-  const { items, startIndex, stopIndex, itemsPerPage } = options;
-  const paginatedItems = computed(() => {
-    if (itemsPerPage.value <= 0) return items.value;
-    return items.value.slice(startIndex.value, stopIndex.value);
-  });
-  watch(paginatedItems, (val) => {
-    vm.emit("update:currentItems", val);
-  });
-  return { paginatedItems };
-}

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

@@ -5,17 +5,17 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.provideSelection = provideSelection;
 exports.useSelection = useSelection;
-var _composables = require("../../composables/index.cjs");
-var _consts = require("../../consts/index.cjs");
+var _vModel = require("../Commons/vModel.composable.cjs");
+var _dataTable = require("../../consts/DataTable/data-table.const.cjs");
 var _enums = require("../../enums/index.cjs");
-var _utils = require("../../utils/index.cjs");
+var _commons = require("../../utils/Commons/commons.util.cjs");
 var _vue = require("vue");
 function provideSelection(props, {
   allItems,
   currentPage
 }) {
   const valueComparator = (0, _vue.computed)(() => {
-    return props.valueComparator ?? _utils.deepEqual;
+    return props.valueComparator ?? _commons.deepEqual;
   });
   const allSelectable = (0, _vue.computed)(() => allItems.value.filter(item => item.selectable));
   const currentPageSelectable = (0, _vue.computed)(() => currentPage.value.filter(item => item.selectable));
@@ -23,26 +23,26 @@ function provideSelection(props, {
     if (typeof props.selectStrategy === "object") return props.selectStrategy;
     switch (props.selectStrategy) {
       case _enums.DATATABLE_SELECT_STRATEGY.SINGLE:
-        return _consts.singleSelectStrategy;
+        return _dataTable.singleSelectStrategy;
       case _enums.DATATABLE_SELECT_STRATEGY.ALL:
-        return _consts.allSelectStrategy;
+        return _dataTable.allSelectStrategy;
       case _enums.DATATABLE_SELECT_STRATEGY.PAGE:
       default:
-        return _consts.pageSelectStrategy;
+        return _dataTable.pageSelectStrategy;
     }
   });
-  const selected = (0, _composables.useVModel)(props, "modelValue", props.modelValue, v => {
-    return new Set((0, _utils.wrapInArray)(v).map(v2 => {
+  const selected = (0, _vModel.useVModel)(props, "modelValue", void 0, v => {
+    return new Set((0, _commons.wrapInArray)(v).map(v2 => {
       return allItems.value.find(item => valueComparator.value(v2, item.value))?.value ?? v2;
     }));
   }, v => {
     return [...v.values()];
   });
   const isSelected = items => {
-    return (0, _utils.wrapInArray)(items).every(item => selected.value.has(item.value));
+    return (0, _commons.wrapInArray)(items).every(item => selected.value.has(item.value));
   };
   const isSomeSelected = items => {
-    return (0, _utils.wrapInArray)(items).some(item => selected.value.has(item.value));
+    return (0, _commons.wrapInArray)(items).some(item => selected.value.has(item.value));
   };
   const select = (items, value) => {
     const newSelected = selectStrategy.value.select({
@@ -87,11 +87,11 @@ function provideSelection(props, {
     allSelected,
     showSelectAll
   };
-  (0, _vue.provide)(_consts.ORIGAM_DATA_TABLE_SELECT_KEY, data);
+  (0, _vue.provide)(_dataTable.ORIGAM_DATA_TABLE_SELECT_KEY, data);
   return data;
 }
 function useSelection() {
-  const data = (0, _vue.inject)(_consts.ORIGAM_DATA_TABLE_SELECT_KEY);
+  const data = (0, _vue.inject)(_dataTable.ORIGAM_DATA_TABLE_SELECT_KEY);
   if (!data) throw new Error("Missing selection!");
   return data;
 }

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

@@ -1,7 +1,29 @@
-import type { IDataTableProvideSelection, IDataTableSelectableItem, IDataTableSelectProps } from '../../interfaces';
+import type { IDataTableProvideSelection, IDataTableSelectableItem, IDataTableSelectProps } from '../../interfaces/DataTable/select.interface';
 import { Ref } from 'vue';
 /*********************************************************
  * provideSelection
+ *
+ * @description
+ * Cree l'etat de selection d'un `<origam-data-table>` et le `provide` sous
+ * `ORIGAM_DATA_TABLE_SELECT_KEY`. Prend en second argument `allItems` et
+ * `currentPage` : la selection a besoin des deux, puisque « tout selectionner »
+ * ne veut pas dire la meme chose selon la strategie.
+ *
+ * @description
+ * La strategie vient de `props.selectStrategy` : `single`, `all`, ou `page`
+ * (le defaut). Un OBJET peut aussi etre passe a la place d'un mot-cle, auquel
+ * cas il est utilise tel quel — c'est le point d'extension pour une regle de
+ * selection maison.
+ *
+ * @description
+ * Seuls les elements dont `selectable` est vrai entrent dans les calculs :
+ * `allSelectable` et `currentPageSelectable` filtrent en amont, donc une ligne
+ * non selectionnable ne fausse jamais l'etat « tout est selectionne ».
+ *
+ * @description
+ * La comparaison des valeurs passe par `props.valueComparator`, avec
+ * `deepEqual` par defaut — necessaire des que la valeur d'une ligne est un
+ * objet plutot qu'une cle primitive.
  ********************************************************/
 export declare function provideSelection(props: IDataTableSelectProps, { allItems, currentPage }: {
     allItems: Ref<Array<IDataTableSelectableItem>>;
@@ -9,5 +31,14 @@ export declare function provideSelection(props: IDataTableSelectProps, { allItem
 }): IDataTableProvideSelection;
 /*********************************************************
  * useSelection
+ *
+ * @description
+ * Cote consommateur de `provideSelection` : recupere l'etat de selection
+ * fourni par le `<origam-data-table>` ancetre.
+ *
+ * @description
+ * ⛔ LEVE si aucun ancetre ne l'a fourni, pour la meme raison que
+ * `useExpanded` : une ligne montee hors de son tableau est une erreur de
+ * structure, et un echec silencieux la rendrait invisible.
  ********************************************************/
 export declare function useSelection(): IDataTableProvideSelection;

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

@@ -1,7 +1,7 @@
-import { useVModel } from "../../composables/index.js";
-import { allSelectStrategy, ORIGAM_DATA_TABLE_SELECT_KEY, pageSelectStrategy, singleSelectStrategy } from "../../consts/index.js";
+import { useVModel } from "../Commons/vModel.composable.js";
+import { allSelectStrategy, ORIGAM_DATA_TABLE_SELECT_KEY, pageSelectStrategy, singleSelectStrategy } from "../../consts/DataTable/data-table.const.js";
 import { DATATABLE_SELECT_STRATEGY } from "../../enums/index.js";
-import { deepEqual, wrapInArray } from "../../utils/index.js";
+import { deepEqual, wrapInArray } from "../../utils/Commons/commons.util.js";
 import { computed, inject, provide } from "vue";
 export function provideSelection(props, { allItems, currentPage }) {
   const valueComparator = computed(() => {
@@ -21,7 +21,7 @@ export function provideSelection(props, { allItems, currentPage }) {
         return pageSelectStrategy;
     }
   });
-  const selected = useVModel(props, "modelValue", props.modelValue, (v) => {
+  const selected = useVModel(props, "modelValue", void 0, (v) => {
     return new Set(wrapInArray(v).map((v2) => {
       return allItems.value.find((item) => valueComparator.value(v2, item.value))?.value ?? v2;
     }));

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

@@ -6,14 +6,12 @@ Object.defineProperty(exports, "__esModule", {
 exports.createSort = createSort;
 exports.provideSort = provideSort;
 exports.useSort = useSort;
-exports.useSortedItems = useSortedItems;
-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");
+var _vModel = require("../Commons/vModel.composable.cjs");
+var _dataTable = require("../../consts/DataTable/data-table.const.cjs");
+var _enums = require("../../enums/index.cjs");
 function createSort(props) {
-  const sortBy = (0, _composables.useVModel)(props, "sortBy", []);
+  const sortBy = (0, _vModel.useVModel)(props, "sortBy", []);
   const mustSort = (0, _vue.toRef)(props, "mustSort");
   const multiSort = (0, _vue.toRef)(props, "multiSort");
   return {
@@ -63,27 +61,11 @@ function provideSort(options) {
     toggleSort,
     isSorted
   };
-  (0, _vue.provide)(_consts.ORIGAM_DATA_TABLE_SORT_KEY, data);
+  (0, _vue.provide)(_dataTable.ORIGAM_DATA_TABLE_SORT_KEY, data);
   return data;
 }
 function useSort() {
-  const data = (0, _vue.inject)(_consts.ORIGAM_DATA_TABLE_SORT_KEY);
+  const data = (0, _vue.inject)(_dataTable.ORIGAM_DATA_TABLE_SORT_KEY);
   if (!data) throw new Error("Missing sort!");
   return data;
-}
-function useSortedItems(props, items, sortBy, options) {
-  const sortedItems = (0, _vue.computed)(() => {
-    if (!sortBy.value.length) return items.value;
-    return (0, _utils.sortItems)(items.value, sortBy.value, {
-      transform: options?.transform,
-      sortFunctions: {
-        ...props.customKeySort,
-        ...options?.sortFunctions?.value
-      },
-      sortRawFunctions: options?.sortRawFunctions?.value
-    });
-  });
-  return {
-    sortedItems
-  };
 }

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

@@ -1,8 +1,16 @@
-import type { IDataTableProvideSort, IDataTableSortItem, IDataTableSortProps, IInternalDataTableHeader, IInternalItem } from '../../interfaces';
-import type { TDataTableCompareFunction } from '../../types';
-import { Ref } from 'vue';
+import type { Ref } from 'vue';
+import type { IInternalDataTableHeader } from '../../interfaces/DataTable/data-table-header.interface';
+import type { IDataTableProvideSort, IDataTableSortItem, IDataTableSortProps } from '../../interfaces/DataTable/sort.interface';
 /*********************************************************
  * createSort
+ *
+ * @description
+ * Reads the `sortBy` / `mustSort` / `multiSort` props into the v-model
+ * + refs shape `provideSort` expects. Kept alongside `useSort` /
+ * `provideSort` in this file — all three address the same
+ * `ORIGAM_DATA_TABLE_SORT_KEY` contract. `useSortedItems` (own file)
+ * is the pure item-sorting sibling and does not depend on any of the
+ * three.
  ********************************************************/
 export declare function createSort(props: IDataTableSortProps): {
     sortBy: import("../../types").TVModel<IDataTableSortProps, "sortBy", IDataTableSortItem[] | undefined>;
@@ -11,6 +19,12 @@ export declare function createSort(props: IDataTableSortProps): {
 };
 /*********************************************************
  * provideSort
+ *
+ * @description
+ * Provider-side hook: wires `toggleSort` / `isSorted` on top of the
+ * `sortBy` / `mustSort` / `multiSort` refs (typically built by
+ * `createSort`) and provides `ORIGAM_DATA_TABLE_SORT_KEY` for `useSort`
+ * consumers down the tree.
  ********************************************************/
 export declare function provideSort(options: {
     sortBy: Ref<Array<IDataTableSortItem>>;
@@ -20,21 +34,14 @@ export declare function provideSort(options: {
 }): IDataTableProvideSort;
 /*********************************************************
  * useSort
+ *
+ * @description
+ * Reads the injected sort state provided by `provideSort`.
+ * Independent from `useSortedItems` (own file) — that hook sorts a
+ * plain items array and never touches this injection.
  ********************************************************/
 export declare function useSort(): {
     sortBy: Ref<Array<IDataTableSortItem>>;
     toggleSort: (column: IInternalDataTableHeader) => void;
     isSorted: (column: IInternalDataTableHeader) => boolean;
 };
-/*********************************************************
- * useSortedItems
- ********************************************************/
-export declare function useSortedItems<T extends IInternalItem>(props: {
-    customKeySort: TDataTableCompareFunction | undefined;
-}, items: Ref<T[]>, sortBy: Ref<Array<IDataTableSortItem>>, options?: {
-    transform?: (item: T) => Record<string, unknown>;
-    sortFunctions?: Ref<Record<string, TDataTableCompareFunction> | undefined>;
-    sortRawFunctions?: Ref<Record<string, TDataTableCompareFunction> | undefined>;
-}): {
-    sortedItems: import("vue").ComputedRef<T[]>;
-};

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

@@ -1,8 +1,7 @@
-import { useVModel } from "../../composables/index.js";
-import { ORIGAM_DATA_TABLE_SORT_KEY } from "../../consts/index.js";
+import { inject, provide, toRef } from "vue";
+import { useVModel } from "../Commons/vModel.composable.js";
+import { ORIGAM_DATA_TABLE_SORT_KEY } from "../../consts/DataTable/data-table.const.js";
 import { SORT_DIRECTION } from "../../enums/index.js";
-import { sortItems } from "../../utils/index.js";
-import { computed, inject, provide, toRef } from "vue";
 export function createSort(props) {
   const sortBy = useVModel(props, "sortBy", []);
   const mustSort = toRef(props, "mustSort");
@@ -42,17 +41,3 @@ export function useSort() {
   if (!data) throw new Error("Missing sort!");
   return data;
 }
-export function useSortedItems(props, items, sortBy, options) {
-  const sortedItems = computed(() => {
-    if (!sortBy.value.length) return items.value;
-    return sortItems(items.value, sortBy.value, {
-      transform: options?.transform,
-      sortFunctions: {
-        ...props.customKeySort,
-        ...options?.sortFunctions?.value
-      },
-      sortRawFunctions: options?.sortRawFunctions?.value
-    });
-  });
-  return { sortedItems };
-}

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

@@ -0,0 +1,24 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useSortedItems = useSortedItems;
+var _vue = require("vue");
+var _sort = require("../../utils/DataTable/sort.util.cjs");
+function useSortedItems(props, items, sortBy, options) {
+  const sortedItems = (0, _vue.computed)(() => {
+    if (!sortBy.value.length) return items.value;
+    return (0, _sort.sortItems)(items.value, sortBy.value, {
+      transform: options?.transform,
+      sortFunctions: {
+        ...props.customKeySort,
+        ...options?.sortFunctions?.value
+      },
+      sortRawFunctions: options?.sortRawFunctions?.value
+    });
+  });
+  return {
+    sortedItems
+  };
+}

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

@@ -0,0 +1,23 @@
+import type { Ref } from 'vue';
+import type { IDataTableSortItem } from '../../interfaces/DataTable/sort.interface';
+import type { IInternalItem } from '../../interfaces/List/list-children.interface';
+import type { TDataTableCompareFunction } from '../../types/DataTable/data-table.type';
+/*********************************************************
+ * useSortedItems
+ *
+ * @description
+ * Pure item-sorting hook: applies `sortBy` (+ optional custom compare
+ * functions) to a plain items array. Independent from `useSort` /
+ * `provideSort` / `createSort` (own file) — it consumes a `sortBy` ref
+ * as a plain argument, never the `ORIGAM_DATA_TABLE_SORT_KEY`
+ * injection those manage.
+ ********************************************************/
+export declare function useSortedItems<T extends IInternalItem>(props: {
+    customKeySort: TDataTableCompareFunction | undefined;
+}, items: Ref<T[]>, sortBy: Ref<Array<IDataTableSortItem>>, options?: {
+    transform?: (item: T) => Record<string, unknown>;
+    sortFunctions?: Ref<Record<string, TDataTableCompareFunction> | undefined>;
+    sortRawFunctions?: Ref<Record<string, TDataTableCompareFunction> | undefined>;
+}): {
+    sortedItems: import("vue").ComputedRef<T[]>;
+};

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

@@ -0,0 +1,16 @@
+import { computed } from "vue";
+import { sortItems } from "../../utils/DataTable/sort.util.js";
+export function useSortedItems(props, items, sortBy, options) {
+  const sortedItems = computed(() => {
+    if (!sortBy.value.length) return items.value;
+    return sortItems(items.value, sortBy.value, {
+      transform: options?.transform,
+      sortFunctions: {
+        ...props.customKeySort,
+        ...options?.sortFunctions?.value
+      },
+      sortRawFunctions: options?.sortRawFunctions?.value
+    });
+  });
+  return { sortedItems };
+}

package/dist/src/composables/Form/form.composable.cjs

@@ -5,11 +5,11 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.useForm = useForm;
 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 _form = require("../../consts/Form/form.const.cjs");
+var _console = require("../../utils/Commons/console.util.cjs");
 function useForm(props) {
-  const model = (0, _composables.useVModel)(props, "modelValue");
+  const model = (0, _vModel.useVModel)(props, "modelValue");
   const isDisabled = (0, _vue.computed)(() => {
     return props.disabled ?? false;
   });
@@ -67,7 +67,7 @@ function useForm(props) {
     deep: true,
     flush: "post"
   });
-  (0, _vue.provide)(_consts.ORIGAM_FORM_KEY, {
+  (0, _vue.provide)(_form.ORIGAM_FORM_KEY, {
     register: ({
       id,
       vm,
@@ -76,7 +76,7 @@ function useForm(props) {
       resetValidation: resetValidation2
     }) => {
       if (items.value.some(item => item.id === id)) {
-        (0, _utils.consoleWarn)(`Duplicate input name "${id}"`);
+        (0, _console.consoleWarn)(`Duplicate input name "${id}"`);
       }
       items.value.push({
         id,

package/dist/src/composables/Form/form.composable.d.ts

@@ -1,7 +1,25 @@
-import type { IFormField, IFormProps, IValidationFieldResult } from '../../interfaces';
+import type { IValidationFieldResult } from '../../interfaces/Commons/validation.interface';
+import type { IFormField, IFormProps } from '../../interfaces/Form/form.interface';
 /*********************************************************
  * useForm
  ********************************************************/
+/*********************************************************
+ * useForm
+ *
+ * @description
+ * Etat d'un `<origam-form>` : agrege les champs qui s'y enregistrent et
+ * expose la validation d'ensemble, `reset` et `resetValidation`.
+ *
+ * @description
+ * La validite globale n'est pas calculee par le formulaire mais DELEGUEE aux
+ * champs : `validate` appelle chacun d'eux et rassemble les erreurs. Un champ
+ * ajoute dynamiquement participe donc sans que le formulaire ait a le
+ * connaitre a l'avance.
+ *
+ * @description
+ * `disabled` et `readonly` descendent aux champs enregistres — les poser sur
+ * le formulaire evite de les repeter sur chaque champ.
+ ********************************************************/
 export declare function useForm(props: IFormProps): {
     errors: import("vue").Ref<{
         id: number | string;