origam 2.16.0 → 2.17.1

package/dist/src/utils/Commons/validation.util.d.ts

@@ -0,0 +1,44 @@
+import type { TValidationRule } from '../../types/Commons/validation.type';
+/*********************************************************
+ * collectRuleErrors — l'UNIQUE boucle d'evaluation de regles du DS
+ *
+ * @description
+ * Parcourt `rules` dans l'ordre, applique chacune a `value`, et accumule
+ * les messages d'erreur jusqu'a `maxErrors`. Retourne un tableau vide
+ * quand tout passe, quand `rules` est absent, ou quand `maxErrors` vaut 0.
+ *
+ * @description
+ * POURQUOI CETTE FONCTION EXISTE. La boucle vivait en DEUX exemplaires :
+ * `useValidation.validate()` (moteur des champs de formulaire) et
+ * `useInlineEdit.runRules()`, dont le commentaire avouait « mirrors the
+ * evaluation logic of `useValidation` ». Les deux copies avaient DIVERGE
+ * sur le cas `false` : `useValidation` le comptait comme un echec sans
+ * message, `runRules` le laissait passer en silence. Consequence mesuree
+ * sur `<OrigamInlineEdit>` : une regle ecrite `(v) => v.length > 3` — la
+ * forme la plus naturelle qui soit — ne bloquait JAMAIS la validation,
+ * ni sur `true` ni sur `false`. Le trou etait invisible parce que
+ * `TInlineEditRule` interdit `false` au niveau du type : rien ne
+ * ratrappait un consommateur JS, ni une regle typee `any`.
+ *
+ * @description
+ * SEMANTIQUE RETENUE — celle de `useValidation`, qui est le sur-ensemble :
+ * une regle peut etre une valeur au lieu d'une fonction (coercee en
+ * `() => valeur`), `false` echoue avec le message vide, et un verdict qui
+ * n'est ni booleen ni chaine est signale puis ignore. `runRules` ne
+ * faisait aucun des trois.
+ *
+ * @description
+ * ⛔ LA VALEUR EST LUE UNE SEULE FOIS, avant la boucle — alors que
+ * `useValidation` relisait `validationModel.value` a CHAQUE iteration. La
+ * difference n'est observable qu'avec au moins deux regles, `maxErrors`
+ * superieur a 1, une regle asynchrone, et une mutation du modele pendant
+ * l'attente : la regle suivante voyait alors une autre valeur que la
+ * precedente. Une passe de validation juge UNE valeur ; ce resserrement
+ * est deliberé.
+ *
+ * @description
+ * Fonction pure et sans reactivite : c'est ce qui lui permet de servir
+ * `useInlineEdit`, qui n'a deliberement aucun couplage au provider de
+ * formulaire.
+ ********************************************************/
+export declare function collectRuleErrors(rules: Array<TValidationRule> | undefined, value: unknown, maxErrors?: number): Promise<Array<string>>;

package/dist/src/utils/Commons/validation.util.js

@@ -0,0 +1,16 @@
+export async function collectRuleErrors(rules, value, maxErrors = 1) {
+  const errors = [];
+  if (!rules) return errors;
+  for (const rule of rules) {
+    if (errors.length >= maxErrors) break;
+    const handler = typeof rule === "function" ? rule : () => rule;
+    const result = await handler(value);
+    if (result === true) continue;
+    if (result !== false && typeof result !== "string") {
+      console.warn(`${result} is not a valid value. Rule functions must return boolean true or a string.`);
+      continue;
+    }
+    errors.push(result || "");
+  }
+  return errors;
+}

package/dist/src/utils/Commons/velocity.util.d.ts

@@ -1,4 +1,4 @@
-import type { ISample } from "../../interfaces";
+import type { ISample } from '../../interfaces/Commons/commons.interface';
 /**
  * Calculate impulse velocity.
  *

package/dist/src/utils/DataList/data-list-kv-item-value-component.util.d.ts

@@ -1,4 +1,5 @@
-import type { IDataListKVItem, IDataListKVItemValueComponent } from '../../interfaces';
+import type { IDataListKVItemValueComponent } from '../../interfaces/DataList/data-list-kv-item-value-component.interface';
+import type { IDataListKVItem } from '../../interfaces/DataList/data-list-kv-item.interface';
 /**
  * Type-guard helper — narrows a KV row's `value` to the dynamic-
  * component descriptor shape so the template can call

package/dist/src/utils/DataTable/group.util.cjs

@@ -6,12 +6,12 @@ Object.defineProperty(exports, "__esModule", {
 exports.flattenItems = flattenItems;
 exports.groupItems = groupItems;
 exports.groupItemsByProperty = groupItemsByProperty;
-var _utils = require("../../utils/index.cjs");
+var _commons = require("../Commons/commons.util.cjs");
 function groupItemsByProperty(items, groupBy) {
   if (!items.length) return [];
   const groups = /* @__PURE__ */new Map();
   for (const item of items) {
-    const value = (0, _utils.getObjectValueByPath)(item.raw, groupBy);
+    const value = (0, _commons.getObjectValueByPath)(item.raw, groupBy);
     if (!groups.has(value)) {
       groups.set(value, []);
     }

package/dist/src/utils/DataTable/group.util.d.ts

@@ -1,4 +1,4 @@
-import type { IDataTableGroup, IDataTableGroupableItem } from '../../interfaces';
+import type { IDataTableGroup, IDataTableGroupableItem } from '../../interfaces/DataTable/group.interface';
 /**
  * Group items by property.
  *

package/dist/src/utils/DataTable/group.util.js

@@ -1,4 +1,4 @@
-import { getObjectValueByPath } from "../../utils/index.js";
+import { getObjectValueByPath } from "../Commons/commons.util.js";
 export function groupItemsByProperty(items, groupBy) {
   if (!items.length) return [];
   const groups = /* @__PURE__ */ new Map();

package/dist/src/utils/DataTable/headers.util.cjs

@@ -11,8 +11,8 @@ exports.getHeaderDepth = getHeaderDepth;
 exports.parseFixedColumns = parseFixedColumns;
 exports.parseHeaderItems = parseHeaderItems;
 exports.priorityQueue = priorityQueue;
-var _consts = require("../../consts/index.cjs");
-var _utils = require("../../utils/index.cjs");
+var _dataTable = require("../../consts/DataTable/data-table.const.cjs");
+var _console = require("../Commons/console.util.cjs");
 function extractKeys(headers, keys = /* @__PURE__ */new Set()) {
   for (const item of headers) {
     if (item.key) keys.add(item.key);
@@ -24,8 +24,8 @@ function extractKeys(headers, keys = /* @__PURE__ */new Set()) {
 }
 function getDataTableHeadersDefaultItem(item) {
   if (!item.key) return void 0;
-  if (item.key === "data-table-group") return _consts.DEFAULT_HEADER;
-  if (["data-table-expand", "data-table-select"].includes(item.key)) return _consts.DEFAULT_ACTION_HEADER;
+  if (item.key === "data-table-group") return _dataTable.DEFAULT_HEADER;
+  if (["data-table-expand", "data-table-select"].includes(item.key)) return _dataTable.DEFAULT_ACTION_HEADER;
   return void 0;
 }
 function convertToInternalHeaders(items) {
@@ -64,7 +64,7 @@ function parseFixedColumns(items) {
         if (!seenFixed) {
           item.lastFixed = true;
         } else if (isNaN(+item.width)) {
-          (0, _utils.consoleError)(`Multiple fixed columns should have a static width (key: ${item.key})`);
+          (0, _console.consoleError)(`Multiple fixed columns should have a static width (key: ${item.key})`);
         }
         seenFixed = true;
       }

package/dist/src/utils/DataTable/headers.util.d.ts

@@ -1,4 +1,4 @@
-import type { IDataTableHeader, IInternalDataTableHeader } from '../../interfaces';
+import type { IDataTableHeader, IInternalDataTableHeader } from '../../interfaces/DataTable/data-table-header.interface';
 /**
  * Extract keys.
  *

package/dist/src/utils/DataTable/headers.util.js

@@ -1,5 +1,5 @@
-import { DEFAULT_ACTION_HEADER, DEFAULT_HEADER } from "../../consts/index.js";
-import { consoleError } from "../../utils/index.js";
+import { DEFAULT_ACTION_HEADER, DEFAULT_HEADER } from "../../consts/DataTable/data-table.const.js";
+import { consoleError } from "../Commons/console.util.js";
 export function extractKeys(headers, keys = /* @__PURE__ */ new Set()) {
   for (const item of headers) {
     if (item.key) keys.add(item.key);

package/dist/src/utils/DataTable/items.util.cjs

@@ -5,20 +5,20 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.transformDataTableItem = transformDataTableItem;
 exports.transformDataTableItems = transformDataTableItems;
-var _utils = require("../../utils/index.cjs");
+var _commons = require("../Commons/commons.util.cjs");
 function transformDataTableItems(props, items, columns) {
   return items?.map((item, index) => transformDataTableItem(props, item, index, columns)) || [];
 }
 function transformDataTableItem(props, item, index, columns) {
-  const value = props.returnObject ? item : (0, _utils.getPropertyFromItem)(item, props.itemValue);
-  const selectable = (0, _utils.getPropertyFromItem)(item, props.itemSelectable, true);
+  const value = props.returnObject ? item : (0, _commons.getPropertyFromItem)(item, props.itemValue);
+  const selectable = (0, _commons.getPropertyFromItem)(item, props.itemSelectable, true);
   const itemColumns = columns.reduce((obj, column) => {
-    if (column.key != null) obj[column.key] = (0, _utils.getPropertyFromItem)(item, column.value);
+    if (column.key != null) obj[column.key] = (0, _commons.getPropertyFromItem)(item, column.value);
     return obj;
   }, {});
   return {
     type: "item",
-    key: props.returnObject ? (0, _utils.getPropertyFromItem)(item, props.itemValue) : value,
+    key: props.returnObject ? (0, _commons.getPropertyFromItem)(item, props.itemValue) : value,
     index,
     value,
     selectable,

package/dist/src/utils/DataTable/items.util.d.ts

@@ -1,4 +1,5 @@
-import type { IDataTableItem, IDataTableItemsProps, IInternalDataTableHeader } from '../../interfaces';
+import type { IInternalDataTableHeader } from '../../interfaces/DataTable/data-table-header.interface';
+import type { IDataTableItem, IDataTableItemsProps } from '../../interfaces/DataTable/items.interface';
 /**
  * Transform data table items.
  *

package/dist/src/utils/DataTable/items.util.js

@@ -1,4 +1,4 @@
-import { getPropertyFromItem } from "../../utils/index.js";
+import { getPropertyFromItem } from "../Commons/commons.util.js";
 export function transformDataTableItems(props, items, columns) {
   return items?.map((item, index) => transformDataTableItem(props, item, index, columns)) || [];
 }

package/dist/src/utils/DataTable/slot-name.util.cjs

@@ -0,0 +1,28 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.isDataTableHeaderColumnSlot = isDataTableHeaderColumnSlot;
+exports.isDataTableItemColumnSlot = isDataTableItemColumnSlot;
+exports.pickDataTableHeaderColumnSlotNames = pickDataTableHeaderColumnSlotNames;
+exports.pickDataTableItemColumnSlotNames = pickDataTableItemColumnSlotNames;
+exports.pickDataTableRowsSlotNames = pickDataTableRowsSlotNames;
+var _dataTable = require("../../consts/DataTable/data-table.const.cjs");
+function isDataTableItemColumnSlot(name) {
+  return name.startsWith(_dataTable.DATA_TABLE_ITEM_SLOT_PREFIX);
+}
+function isDataTableHeaderColumnSlot(name) {
+  return name.startsWith(_dataTable.DATA_TABLE_HEADER_SLOT_PREFIX) && !_dataTable.DATA_TABLE_RESERVED_HEADER_SLOT_NAMES.includes(name);
+}
+function pickDataTableRowsSlotNames(names) {
+  return names.filter(name => {
+    return _dataTable.DATA_TABLE_ROWS_SLOT_NAMES.includes(name) || isDataTableItemColumnSlot(name) || isDataTableHeaderColumnSlot(name);
+  });
+}
+function pickDataTableHeaderColumnSlotNames(names) {
+  return names.filter(isDataTableHeaderColumnSlot);
+}
+function pickDataTableItemColumnSlotNames(names) {
+  return names.filter(isDataTableItemColumnSlot);
+}

package/dist/src/utils/DataTable/slot-name.util.d.ts

@@ -0,0 +1,40 @@
+import type { TDataTableRowsSlotName } from '../../types/DataTable/data-table.type';
+import type { TDataTableHeaderColumnSlotName, TDataTableItemColumnSlotName } from '../../types/DataTable/data-table-rows.type';
+/*********************************************************
+ * Relais de slots de la famille DataTable
+ *
+ * @description
+ * `<OrigamDataTable>` monte `<OrigamDataTableHeaders>` et
+ * `<OrigamDataTableRows>`, qui montent a leur tour `HeadersCell` /
+ * `HeaderCell` et `Row` / `GroupHeaderRow`. Chaque maillon doit renvoyer
+ * les slots qui ne lui appartiennent pas au maillon suivant, sinon le
+ * contenu du consommateur n'atteint jamais l'element qui le rend.
+ *
+ * @description
+ * Ces predicats sont le seul endroit ou le decoupage est decrit. Les
+ * quatre composants du relais les partagent — un nom ajoute ici circule
+ * dans toute la chaine, sans quoi il faudrait le repeter quatre fois.
+ *
+ * @description
+ * Chaque fonction prend les noms de slots bruts (`Object.keys(useSlots())`)
+ * et rend le sous-ensemble destine a l'enfant suivant :
+ * `pickDataTableRowsSlotNames` pour `<OrigamDataTableRows>` (noms fixes +
+ * les deux familles colonne), `pickDataTableHeaderColumnSlotNames` pour la
+ * chaine d'en-tete (`header.{cle}` seul), `pickDataTableItemColumnSlotNames`
+ * pour les valeurs de cellule (`item.{cle}` seul).
+ *
+ * @description
+ * `header.mobile` et `header.loader` sont EXCLUS de la famille colonne :
+ * ils adressent les slots propres d'`<OrigamDataTableHeaders>`, deja
+ * forwardes nommement, et aucune colonne ne peut porter ces cles.
+ *
+ * @description
+ * Les predicats sont des gardes de type. Ce n'est pas cosmetique : un nom
+ * de slot dynamique typé `string` ne peut pas indexer l'interface de slots
+ * de la cible, et `vue-tsc` rougit en `TS7053` sur chaque relais.
+ ********************************************************/
+export declare function isDataTableItemColumnSlot(name: string): name is TDataTableItemColumnSlotName;
+export declare function isDataTableHeaderColumnSlot(name: string): name is TDataTableHeaderColumnSlotName;
+export declare function pickDataTableRowsSlotNames(names: Array<string>): Array<TDataTableRowsSlotName>;
+export declare function pickDataTableHeaderColumnSlotNames(names: Array<string>): Array<TDataTableHeaderColumnSlotName>;
+export declare function pickDataTableItemColumnSlotNames(names: Array<string>): Array<TDataTableItemColumnSlotName>;

package/dist/src/utils/DataTable/slot-name.util.js

@@ -0,0 +1,23 @@
+import {
+  DATA_TABLE_HEADER_SLOT_PREFIX,
+  DATA_TABLE_ITEM_SLOT_PREFIX,
+  DATA_TABLE_RESERVED_HEADER_SLOT_NAMES,
+  DATA_TABLE_ROWS_SLOT_NAMES
+} from "../../consts/DataTable/data-table.const.js";
+export function isDataTableItemColumnSlot(name) {
+  return name.startsWith(DATA_TABLE_ITEM_SLOT_PREFIX);
+}
+export function isDataTableHeaderColumnSlot(name) {
+  return name.startsWith(DATA_TABLE_HEADER_SLOT_PREFIX) && !DATA_TABLE_RESERVED_HEADER_SLOT_NAMES.includes(name);
+}
+export function pickDataTableRowsSlotNames(names) {
+  return names.filter((name) => {
+    return DATA_TABLE_ROWS_SLOT_NAMES.includes(name) || isDataTableItemColumnSlot(name) || isDataTableHeaderColumnSlot(name);
+  });
+}
+export function pickDataTableHeaderColumnSlotNames(names) {
+  return names.filter(isDataTableHeaderColumnSlot);
+}
+export function pickDataTableItemColumnSlotNames(names) {
+  return names.filter(isDataTableItemColumnSlot);
+}

package/dist/src/utils/DataTable/sort.util.cjs

@@ -5,7 +5,7 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.sortItems = sortItems;
 var _enums = require("../../enums/index.cjs");
-var _utils = require("../../utils/index.cjs");
+var _commons = require("../Commons/commons.util.cjs");
 function sortItems(items, sortByItems, options) {
   const transformedItems = items.map(item => [item, options?.transform ? options.transform(item) : item]);
   return transformedItems.sort((a, b) => {
@@ -47,9 +47,9 @@ function sortItems(items, sortByItems, options) {
       sortA = sortA != null ? sortA.toString().toLocaleLowerCase() : sortA;
       sortB = sortB != null ? sortB.toString().toLocaleLowerCase() : sortB;
       if (sortA !== sortB) {
-        if ((0, _utils.isEmpty)(sortA) && (0, _utils.isEmpty)(sortB)) return 0;
-        if ((0, _utils.isEmpty)(sortA)) return -1;
-        if ((0, _utils.isEmpty)(sortB)) return 1;
+        if ((0, _commons.isEmpty)(sortA) && (0, _commons.isEmpty)(sortB)) return 0;
+        if ((0, _commons.isEmpty)(sortA)) return -1;
+        if ((0, _commons.isEmpty)(sortB)) return 1;
         if (!isNaN(sortA) && !isNaN(sortB)) return Number(sortA) - Number(sortB);
         return sortA.localeCompare(sortB);
       }

package/dist/src/utils/DataTable/sort.util.d.ts

@@ -1,5 +1,6 @@
-import type { IDataTableSortItem, IInternalItem } from '../../interfaces';
-import type { TDataTableCompareFunction } from '../../types';
+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';
 /**
  * Sort items.
  *

package/dist/src/utils/DataTable/sort.util.js

@@ -1,5 +1,5 @@
 import { SORT_DIRECTION } from "../../enums/index.js";
-import { isEmpty } from "../../utils/index.js";
+import { isEmpty } from "../Commons/commons.util.js";
 export function sortItems(items, sortByItems, options) {
   const transformedItems = items.map(
     (item) => [item, options?.transform ? options.transform(item) : item]

package/dist/src/utils/Input/input.util.cjs

@@ -4,12 +4,13 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.filterInputAttrs = filterInputAttrs;
-var _consts = require("../../consts/index.cjs");
-var _utils = require("../../utils/index.cjs");
+var _commons = require("../../consts/Commons/commons.const.cjs");
+var _input = require("../../consts/Input/input.const.cjs");
+var _commons2 = require("../Commons/commons.util.cjs");
 function filterInputAttrs(attrs) {
-  const [events, props] = (0, _utils.pickWithRest)(attrs, [_consts.ON_REGEX]);
-  const inputEvents = (0, _utils.omit)(events, _consts.BUBBLING_EVENTS);
-  const [rootAttrs, inputAttrs] = (0, _utils.pickWithRest)(props, ["class", "style", "id", /^data-/]);
+  const [events, props] = (0, _commons2.pickWithRest)(attrs, [_commons.ON_REGEX]);
+  const inputEvents = (0, _commons2.omit)(events, _input.BUBBLING_EVENTS);
+  const [rootAttrs, inputAttrs] = (0, _commons2.pickWithRest)(props, ["class", "style", "id", /^data-/]);
   Object.assign(rootAttrs, events);
   Object.assign(inputAttrs, inputEvents);
   return [rootAttrs, inputAttrs];

package/dist/src/utils/Input/input.util.js

@@ -1,5 +1,6 @@
-import { BUBBLING_EVENTS, ON_REGEX } from "../../consts/index.js";
-import { omit, pickWithRest } from "../../utils/index.js";
+import { ON_REGEX } from "../../consts/Commons/commons.const.js";
+import { BUBBLING_EVENTS } from "../../consts/Input/input.const.js";
+import { omit, pickWithRest } from "../Commons/commons.util.js";
 export function filterInputAttrs(attrs) {
   const [events, props] = pickWithRest(attrs, [ON_REGEX]);
   const inputEvents = omit(events, BUBBLING_EVENTS);

package/dist/src/utils/List/list-item.util.cjs

@@ -5,7 +5,7 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.transformListItem = transformListItem;
 exports.transformListItems = transformListItems;
-var _utils = require("../../utils/index.cjs");
+var _commons = require("../Commons/commons.util.cjs");
 function transformListItems(props, items) {
   const array = [];
   for (const item of items) {
@@ -14,18 +14,21 @@ function transformListItems(props, items) {
   return array;
 }
 function transformListItem(props, item) {
-  const title = (0, _utils.getPropertyFromItem)(item, props.itemTitle, item);
-  const value = (0, _utils.getPropertyFromItem)(item, props.itemValue, title);
-  const children = (0, _utils.getPropertyFromItem)(item, props.itemChildren);
-  const itemProps = props.itemProps === true ? typeof item === "object" && item != null && !Array.isArray(item) ? "children" in item ? (0, _utils.omit)(item, ["children"]) : item : void 0 : (0, _utils.getPropertyFromItem)(item, props.itemProps);
+  const type = (0, _commons.getPropertyFromItem)(item, props.itemType);
+  const title = (0, _commons.getPropertyFromItem)(item, props.itemTitle, item);
+  const value = (0, _commons.getPropertyFromItem)(item, props.itemValue, title);
+  const children = (0, _commons.getPropertyFromItem)(item, props.itemChildren);
+  const itemProps = props.itemProps === true ? typeof item === "object" && item != null && !Array.isArray(item) ? "children" in item ? (0, _commons.omit)(item, ["children"]) : item : void 0 : (0, _commons.getPropertyFromItem)(item, props.itemProps);
   const _props = {
     title,
     value,
     ...itemProps
   };
+  _props.title = String(_props.title ?? "");
   return {
-    title: String(_props.title ?? ""),
+    title: _props.title,
     value: _props.value,
+    type,
     props: _props,
     children: Array.isArray(children) ? transformListItems(props, children) : void 0,
     raw: item

package/dist/src/utils/List/list-item.util.d.ts

@@ -1,4 +1,5 @@
-import type { IInternalListItem, IInternalListItemChildren, IItemProps } from '../../interfaces';
+import type { IItemProps } from '../../interfaces/Commons/item.interface';
+import type { IInternalListItemChildren } from '../../interfaces/List/list-children.interface';
 /**
  * Transform list items.
  *
@@ -21,5 +22,21 @@ export declare function transformListItems(props: IItemProps & {
  * the item's resolved title becomes both its display label and its selection
  * value. This is NOT a bug — it enables string arrays to work without any
  * additional configuration (e.g. `items: ['Alice', 'Bob']`).
+ *
+ * @note (#424) `transformListItem` never read `props.itemType`, so a structural
+ * entry (`{ type: 'divider' }`, `{ type: 'subheader', title: '…' }`) never
+ * carried a `type` field forward — `OrigamListChildren.hasDivider` /
+ * `hasSubheader` only match on `item.type`, so those entries silently fell
+ * through to the default `OrigamListItem` branch instead of rendering as a
+ * divider/subheader. Compounding it, a divider item has no resolvable
+ * `title` key, so the raw-item fallback above (intentional for primitive
+ * items) surfaced the whole raw object as `_props.title`; since only the
+ * top-level `title` field was ever run through `String()`, the un-stringified
+ * object reached the ListItem's `title` prop and Vue's `toDisplayString`
+ * rendered it as a literal JSON dump. Both are fixed here: `type` is now
+ * read and forwarded, and `_props.title` gets the same `String()` coercion
+ * as the top-level field so no raw value can leak through `props`.
  */
-export declare function transformListItem(props: Omit<IItemProps, 'items'>, item: any): IInternalListItem;
+export declare function transformListItem(props: Omit<IItemProps, 'items'> & {
+    itemType?: string;
+}, item: any): IInternalListItemChildren;

package/dist/src/utils/List/list-item.util.js

@@ -1,4 +1,4 @@
-import { getPropertyFromItem, omit } from "../../utils/index.js";
+import { getPropertyFromItem, omit } from "../Commons/commons.util.js";
 export function transformListItems(props, items) {
   const array = [];
   for (const item of items) {
@@ -7,6 +7,7 @@ export function transformListItems(props, items) {
   return array;
 }
 export function transformListItem(props, item) {
+  const type = getPropertyFromItem(item, props.itemType);
   const title = getPropertyFromItem(item, props.itemTitle, item);
   const value = getPropertyFromItem(item, props.itemValue, title);
   const children = getPropertyFromItem(item, props.itemChildren);
@@ -16,9 +17,11 @@ export function transformListItem(props, item) {
     value,
     ...itemProps
   };
+  _props.title = String(_props.title ?? "");
   return {
-    title: String(_props.title ?? ""),
+    title: _props.title,
     value: _props.value,
+    type,
     props: _props,
     children: Array.isArray(children) ? transformListItems(props, children) : void 0,
     raw: item

package/dist/src/utils/Parallax/parallax-element.util.d.ts

@@ -1,5 +1,5 @@
-import type { IParallaxElementCicle, IParallaxElementMovement } from '../../interfaces';
-import type { TPoint } from '../../types';
+import type { IParallaxElementCicle, IParallaxElementMovement } from '../../interfaces/Parallax/parallax-element.interface';
+import type { TPoint } from '../../types/Commons/point.type';
 /**
  * Element movement.
  *
@@ -8,7 +8,7 @@ import type { TPoint } from '../../types';
 export declare function elementMovement(action: IParallaxElementMovement): {
     x: number;
     y: number;
-    target: import("../../interfaces").IBox | DOMRect | undefined;
+    target: DOMRect | import("../../interfaces").IBox | undefined;
 };
 /**
  * Cyclic movement.

package/dist/src/utils/QrCode/qr-code-adapters.util.d.ts

@@ -1,4 +1,5 @@
-import type { TColor, TRounded } from '../../types';
+import type { TColor } from '../../types/Commons/color.type';
+import type { TRounded } from '../../types/Commons/rounded.type';
 /**
  * Transform a DS-shaped colour (intent, raw CSS, `currentColor`,
  * `transparent`, undefined) into a literal CSS string ready to drop

package/dist/src/utils/Snackbar/snackbar-group.util.cjs

@@ -0,0 +1,50 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getStore = exports.generateId = exports.clearTimer = void 0;
+exports.resetSnackbarGroupForTesting = resetSnackbarGroupForTesting;
+var _vue = require("vue");
+var _snackbarGroup = require("../../consts/Snackbar/snackbar-group.const.cjs");
+const STORES = /* @__PURE__ */new Map();
+const getStore = id => {
+  let store = STORES.get(id);
+  if (!store) {
+    store = {
+      items: (0, _vue.ref)([]),
+      timers: /* @__PURE__ */new Map(),
+      counter: {
+        current: 0
+      },
+      defaultDuration: (0, _vue.ref)(_snackbarGroup.SNACKBAR_GROUP_DEFAULT_DURATION)
+    };
+    STORES.set(id, store);
+  }
+  return store;
+};
+exports.getStore = getStore;
+const generateId = state => {
+  state.counter.current += 1;
+  return `origam-snackbar-group-item-${state.counter.current}`;
+};
+exports.generateId = generateId;
+const clearTimer = (state, itemId) => {
+  const handle = state.timers.get(itemId);
+  if (handle !== void 0) {
+    if (typeof window !== "undefined") window.clearTimeout(handle);
+    state.timers.delete(itemId);
+  }
+};
+exports.clearTimer = clearTimer;
+function resetSnackbarGroupForTesting() {
+  STORES.forEach(state => {
+    state.timers.forEach(handle => {
+      if (typeof window !== "undefined") window.clearTimeout(handle);
+    });
+    state.timers.clear();
+    state.items.value = [];
+    state.counter.current = 0;
+  });
+  STORES.clear();
+}

package/dist/src/utils/Snackbar/snackbar-group.util.d.ts

@@ -0,0 +1,13 @@
+import type { ISnackbarGroupState } from '../../interfaces/Snackbar/snackbar-group.interface';
+export declare const getStore: (id: string) => ISnackbarGroupState;
+export declare const generateId: (state: ISnackbarGroupState) => string;
+export declare const clearTimer: (state: ISnackbarGroupState, itemId: string) => void;
+/*********************************************************
+ * Test helper
+ *
+ * @description
+ * Vitest needs to wipe the singleton between specs so that
+ * counters / timers do not leak across tests. Not part of
+ * the public surface — do not import in product code.
+ ********************************************************/
+export declare function resetSnackbarGroupForTesting(): void;

package/dist/src/utils/Snackbar/snackbar-group.util.js

@@ -0,0 +1,38 @@
+import { ref } from "vue";
+import { SNACKBAR_GROUP_DEFAULT_DURATION } from "../../consts/Snackbar/snackbar-group.const.js";
+const STORES = /* @__PURE__ */ new Map();
+export const getStore = (id) => {
+  let store = STORES.get(id);
+  if (!store) {
+    store = {
+      items: ref([]),
+      timers: /* @__PURE__ */ new Map(),
+      counter: { current: 0 },
+      defaultDuration: ref(SNACKBAR_GROUP_DEFAULT_DURATION)
+    };
+    STORES.set(id, store);
+  }
+  return store;
+};
+export const generateId = (state) => {
+  state.counter.current += 1;
+  return `origam-snackbar-group-item-${state.counter.current}`;
+};
+export const clearTimer = (state, itemId) => {
+  const handle = state.timers.get(itemId);
+  if (handle !== void 0) {
+    if (typeof window !== "undefined") window.clearTimeout(handle);
+    state.timers.delete(itemId);
+  }
+};
+export function resetSnackbarGroupForTesting() {
+  STORES.forEach((state) => {
+    state.timers.forEach((handle) => {
+      if (typeof window !== "undefined") window.clearTimeout(handle);
+    });
+    state.timers.clear();
+    state.items.value = [];
+    state.counter.current = 0;
+  });
+  STORES.clear();
+}

package/dist/src/utils/{Textarea → TextareaField}/sanitize-html.util.cjs

@@ -4,7 +4,7 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.sanitizeHtml = sanitizeHtml;
-var _consts = require("../../consts/index.cjs");
+var _textareaField = require("../../consts/TextareaField/textarea-field.const.cjs");
 function sanitizeHtml(input) {
   if (input == null || input === "") return "";
   if (typeof input !== "string") return "";
@@ -20,11 +20,11 @@ function walk(node) {
   const children = Array.from(node.children);
   for (const child of children) {
     const tag = child.tagName.toLowerCase();
-    if (_consts.BLOCKED_TAGS.includes(tag)) {
+    if (_textareaField.BLOCKED_TAGS.includes(tag)) {
       child.remove();
       continue;
     }
-    if (!_consts.ALLOWED_TAGS.includes(tag)) {
+    if (!_textareaField.ALLOWED_TAGS.includes(tag)) {
       walk(child);
       unwrap(child);
       continue;
@@ -43,7 +43,7 @@ function unwrap(el) {
   parent.removeChild(el);
 }
 function sanitizeAttributes(el, tag) {
-  const allowed = _consts.ALLOWED_ATTRIBUTES[tag] ?? [];
+  const allowed = _textareaField.ALLOWED_ATTRIBUTES[tag] ?? [];
   const attrs = Array.from(el.attributes);
   for (const attr of attrs) {
     const name = attr.name.toLowerCase();
@@ -75,8 +75,8 @@ function isSafeUrl(raw) {
   if (value === "") return false;
   if (value.startsWith("/") || value.startsWith("#") || value.startsWith("?")) return true;
   const lower = value.toLowerCase();
-  return _consts.ALLOWED_URL_SCHEMES.some(scheme => lower.startsWith(scheme));
+  return _textareaField.ALLOWED_URL_SCHEMES.some(scheme => lower.startsWith(scheme));
 }
 function filterClassList(value) {
-  return String(value).split(/\s+/).filter(cls => cls.startsWith(_consts.ALLOWED_CLASS_PREFIX)).join(" ");
+  return String(value).split(/\s+/).filter(cls => cls.startsWith(_textareaField.ALLOWED_CLASS_PREFIX)).join(" ");
 }