origam 2.16.0 → 2.17.1

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

@@ -1,7 +1,7 @@
 import { computed, markRaw, provide, ref, shallowRef, toRef, watch } from "vue";
-import { useVModel } from "../../composables/index.js";
-import { ORIGAM_FORM_KEY } from "../../consts/index.js";
-import { consoleWarn } from "../../utils/index.js";
+import { useVModel } from "../Commons/vModel.composable.js";
+import { ORIGAM_FORM_KEY } from "../../consts/Form/form.const.js";
+import { consoleWarn } from "../../utils/Commons/console.util.js";
 export function useForm(props) {
   const model = useVModel(props, "modelValue");
   const isDisabled = computed(() => {

package/dist/src/composables/Icon/icon.composable.cjs

@@ -6,16 +6,17 @@ Object.defineProperty(exports, "__esModule", {
 exports.createIcons = createIcons;
 exports.useIcon = void 0;
 var _vue = require("vue");
-var _components = require("../../components/index.cjs");
-var _consts = require("../../consts/index.cjs");
-var _utils = require("../../utils/index.cjs");
+var _index = require("../../components/Icon/index.cjs");
+var _mdi = require("../../consts/Commons/mdi.const.cjs");
+var _icon = require("../../consts/Icon/icon.const.cjs");
+var _commons = require("../../utils/Commons/commons.util.cjs");
 const useIcon = props => {
-  const icons = (0, _vue.inject)(_consts.ORIGAM_ICONS_KEY);
+  const icons = (0, _vue.inject)(_icon.ORIGAM_ICONS_KEY);
   if (!icons) throw new Error("Missing Origam Icons provide!");
   const iconData = (0, _vue.computed)(() => {
     const iconAlias = (0, _vue.unref)(props);
     if (!iconAlias) return {
-      component: _components.OrigamComponentIcon
+      component: _index.OrigamComponentIcon
     };
     let icon = iconAlias;
     if (typeof icon === "string") {
@@ -27,23 +28,23 @@ const useIcon = props => {
     if (!icon) {
       console.warn("[Origam] useIcon: could not resolve the aliased icon, falling back to empty icon:", iconAlias);
       return {
-        component: _components.OrigamComponentIcon
+        component: _index.OrigamComponentIcon
       };
     }
     if (Array.isArray(icon)) {
       return {
-        component: _components.OrigamSvgIcon,
+        component: _index.OrigamSvgIcon,
         icon
       };
     } else if (typeof icon !== "string") {
       return {
-        component: _components.OrigamComponentIcon,
+        component: _index.OrigamComponentIcon,
         icon
       };
     }
     if (/^[MmLlHhVvCcSsQqTtAaZz][\s\d,.-]/.test(icon)) {
       return {
-        component: _components.OrigamSvgIcon,
+        component: _index.OrigamSvgIcon,
         icon
       };
     }
@@ -61,14 +62,14 @@ const useIcon = props => {
 };
 exports.useIcon = useIcon;
 function createIcons(options) {
-  return (0, _utils.mergeDeep)({
+  return (0, _commons.mergeDeep)({
     defaultSet: "mdi",
     sets: {
-      ..._consts.DEFAULT_SETS,
-      mdi: _consts.MDI
+      ..._icon.DEFAULT_SETS,
+      mdi: _mdi.MDI
     },
     aliases: {
-      ..._consts.MDI_ALIASES
+      ..._mdi.MDI_ALIASES
     }
   }, options);
 }

package/dist/src/composables/Icon/icon.composable.d.ts

@@ -1,9 +1,36 @@
 import { Ref } from 'vue';
-import type { TIcon, TIconInstance, TIconOptions } from '../../types';
+import type { TIcon, TIconInstance, TIconOptions } from '../../types/Icon/icon.type';
+/*********************************************************
+ * useIcon
+ *
+ * @description
+ * Resout une valeur de prop `icon` en composant a rendre : suit les alias,
+ * choisit le jeu, et retombe sur `OrigamComponentIcon` quand la valeur est
+ * absente.
+ *
+ * @description
+ * ⛔ LEVE si `createOrigam()` n'a pas installe la configuration d'icones
+ * (`Missing Origam Icons provide!`). C'est deliberement bruyant : une icone
+ * qui ne resout pas silencieusement laisserait un trou dans l'interface sans
+ * que rien ne l'explique.
+ ********************************************************/
 export declare const useIcon: (props: Ref<TIcon | undefined>) => {
     iconData: import("vue").ComputedRef<TIconInstance>;
 };
 /*********************************************************
  * createIcons
  ********************************************************/
+/*********************************************************
+ * createIcons
+ *
+ * @description
+ * Construit la configuration d'icones fournie a l'application par
+ * `createOrigam()` : jeu par defaut, jeux disponibles et alias. Les options du
+ * consommateur sont fusionnees en profondeur sur les valeurs du DS, donc
+ * declarer un alias n'efface pas les autres.
+ *
+ * @description
+ * Le jeu par defaut est `mdi`, et les alias MDI sont pre-charges — c'est ce
+ * qui permet d'ecrire `icon="mdi-account"` sans configuration prealable.
+ ********************************************************/
 export declare function createIcons(options?: TIconOptions): Record<string, unknown>;

package/dist/src/composables/Icon/icon.composable.js

@@ -1,7 +1,8 @@
 import { computed, inject, unref } from "vue";
-import { OrigamComponentIcon, OrigamSvgIcon } from "../../components/index.js";
-import { DEFAULT_SETS, MDI, MDI_ALIASES, ORIGAM_ICONS_KEY } from "../../consts/index.js";
-import { mergeDeep } from "../../utils/index.js";
+import { OrigamComponentIcon, OrigamSvgIcon } from "../../components/Icon/index.js";
+import { MDI, MDI_ALIASES } from "../../consts/Commons/mdi.const.js";
+import { DEFAULT_SETS, ORIGAM_ICONS_KEY } from "../../consts/Icon/icon.const.js";
+import { mergeDeep } from "../../utils/Commons/commons.util.js";
 export const useIcon = (props) => {
   const icons = inject(ORIGAM_ICONS_KEY);
   if (!icons) throw new Error("Missing Origam Icons provide!");

package/dist/src/composables/Icon/iconAccessibility.composable.cjs

@@ -0,0 +1,25 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useIconAccessibility = useIconAccessibility;
+var _vue = require("vue");
+function useIconAccessibility() {
+  const attrs = (0, _vue.useAttrs)();
+  const isClickable = (0, _vue.computed)(() => !!attrs.onClick);
+  const ariaHidden = (0, _vue.computed)(() => !isClickable.value);
+  const hasAccessibleName = (0, _vue.computed)(() => !!(attrs["aria-label"] || attrs["aria-labelledby"]));
+  if (process.env?.DEV) {
+    (0, _vue.watchEffect)(() => {
+      if (isClickable.value && !hasAccessibleName.value) {
+        console.warn('[Origam] A clickable icon is a button. Use <origam-btn icon="\u2026" aria-label="\u2026"/> instead of attaching @click directly to an icon \u2014 see OrigamBtn.md.');
+      }
+    });
+  }
+  return {
+    isClickable,
+    ariaHidden,
+    hasAccessibleName
+  };
+}

package/dist/src/composables/Icon/iconAccessibility.composable.d.ts

@@ -0,0 +1,61 @@
+/*********************************************************
+ * useIconAccessibility
+ *
+ * @description
+ * ⛔ issue #427 / #653 — shared accessibility contract for every icon leaf
+ * (`OrigamIcon`, `OrigamClassIcon`, `OrigamComponentIcon`,
+ * `OrigamLigatureIcon`). A glyph is decorative by default
+ * (`aria-hidden="true"`).
+ *
+ * @description
+ * ⛔ issue #653 — this hook used to also set `role="button"` the moment a
+ * `@click` listener was attached, and briefly grew a typed `clickable`
+ * prop + a `vue-tsc`-enforced discriminated union
+ * (`IAccessibleClickableProps`) to force an accessible name alongside it.
+ * BOTH were removed:
+ * - Zero components across the whole repo (DS, stories, docs, marketing)
+ *   ever passed `clickable` — constraining an API nobody used just delays
+ *   the real fix.
+ * - `role="button"` was measured (not assumed) to be actively harmful:
+ *   the icon family sets NO `tabindex` and NO keydown handler anywhere,
+ *   so the element was announced as an interactive control a keyboard or
+ *   switch-device user could never reach (`Tab` never lands on it) or
+ *   activate (`Enter` / `Space` do nothing) — a WCAG 2.1.1 (Keyboard)
+ *   violation, not a defensible ARIA fallback.
+ * - Compared against `OrigamCard` (#392), the DS's own precedent for
+ *   `role="button"` on a non-native element: Card pairs the role with
+ *   `tabindex="0"` AND a keydown handler, and does so ONLY because its
+ *   content model makes a native `<button>` illegal (Card renders flow
+ *   content a `<button>` cannot legally contain). `OrigamIcon` has no
+ *   such constraint — `OrigamBtn`'s icon-only mode (a REAL `<button>`,
+ *   full keyboard support for free) is always available, so reproducing
+ *   Card's tabindex+keydown machinery here would just duplicate `OrigamBtn`
+ *   instead of removing the anti-pattern.
+ *
+ * @description
+ * The DS's own rule already covered this: an interactive control is a
+ * `<button>` or `<a href>` — "ARIA is a complement, never a replacement".
+ * `<origam-icon @click="…">` remains POSSIBLE (nothing stops a consumer
+ * attaching a plain DOM listener) but no longer announces itself as a
+ * control it cannot behave as. This hook does not fabricate a label (a
+ * guessed "icon button" string would itself be bad ARIA, see #622 — the
+ * auto-label that overwrote a visible `<label for>`); it surfaces the
+ * anti-pattern as a dev-time warning pointing at the real fix,
+ * `origam-btn`, instead of asking for `aria-label` / `aria-labelledby`
+ * on an element that was never going to be operable either way. See the
+ * #653 ticket report for the full measurements, and #660 for
+ * `OrigamSvgIcon`'s separate, still-open gap (never calls this hook at
+ * all).
+ *
+ * @description
+ * Reads `$attrs` only (`onClick`, `aria-label`, `aria-labelledby`) —
+ * never a themable prop — so this carries no ADR-005 lazy-read
+ * obligation. `useAttrs()` is safe to call from within a composable:
+ * it resolves against whichever component is currently mid-`setup()`,
+ * regardless of how many function calls deep it's invoked from.
+ ********************************************************/
+export declare function useIconAccessibility(): {
+    isClickable: import("vue").ComputedRef<boolean>;
+    ariaHidden: import("vue").ComputedRef<boolean>;
+    hasAccessibleName: import("vue").ComputedRef<boolean>;
+};

package/dist/src/composables/Icon/iconAccessibility.composable.js

@@ -0,0 +1,15 @@
+import { computed, useAttrs, watchEffect } from "vue";
+export function useIconAccessibility() {
+  const attrs = useAttrs();
+  const isClickable = computed(() => !!attrs.onClick);
+  const ariaHidden = computed(() => !isClickable.value);
+  const hasAccessibleName = computed(() => !!(attrs["aria-label"] || attrs["aria-labelledby"]));
+  if (import.meta.env?.DEV) {
+    watchEffect(() => {
+      if (isClickable.value && !hasAccessibleName.value) {
+        console.warn('[Origam] A clickable icon is a button. Use <origam-btn icon="\u2026" aria-label="\u2026"/> instead of attaching @click directly to an icon \u2014 see OrigamBtn.md.');
+      }
+    });
+  }
+  return { isClickable, ariaHidden, hasAccessibleName };
+}

package/dist/src/composables/InlineEdit/inline-edit.composable.cjs

@@ -5,18 +5,20 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.useInlineEdit = useInlineEdit;
 var _vue = require("vue");
+var _validation = require("../../utils/Commons/validation.util.cjs");
 const toDraft = value => {
   if (value === null || value === void 0) return "";
   return String(value);
 };
 function useInlineEdit(modelValue, options = {}) {
-  const trim = options.trim ?? true;
+  const resolveOptions = () => (0, _vue.toValue)(options);
+  const trim = (0, _vue.computed)(() => resolveOptions().trim ?? true);
   const isEditing = (0, _vue.ref)(false);
   const draft = (0, _vue.ref)("");
   const error = (0, _vue.ref)(null);
   const isPending = (0, _vue.ref)(false);
   let validationToken = 0;
-  const normalisedDraft = (0, _vue.computed)(() => trim ? draft.value.trim() : draft.value);
+  const normalisedDraft = (0, _vue.computed)(() => trim.value ? draft.value.trim() : draft.value);
   const isDraftEmpty = (0, _vue.computed)(() => normalisedDraft.value.length === 0);
   const edit = () => {
     if (isEditing.value) return;
@@ -37,37 +39,29 @@ function useInlineEdit(modelValue, options = {}) {
     error.value = null;
     isEditing.value = false;
     draft.value = "";
-    options.onCancel?.();
+    resolveOptions().onCancel?.();
   };
   const runValidator = async (value, validator) => {
     if (!validator) return null;
     const verdict = await validator(value);
     if (verdict === true) return null;
-    return typeof verdict === "string" ? verdict : "Invalid value";
-  };
-  const runRules = async (value, rules) => {
-    if (!rules || rules.length === 0) return null;
-    for (const rule of rules) {
-      const result = await rule(value);
-      if (result === true) continue;
-      if (typeof result === "string") return result;
-    }
-    return null;
+    return typeof verdict === "string" ? verdict : resolveOptions().invalidMessage ?? "Invalid value";
   };
   const confirm = async () => {
     if (!isEditing.value) return false;
     const token = ++validationToken;
     const next = normalisedDraft.value;
     error.value = null;
-    const hasRules = options.rules && options.rules.length > 0;
-    const hasValidate = !!options.validate;
+    const currentOptions = resolveOptions();
+    const hasRules = currentOptions.rules && currentOptions.rules.length > 0;
+    const hasValidate = !!currentOptions.validate;
     if (hasRules || hasValidate) {
       isPending.value = true;
       let verdict = null;
       try {
-        verdict = await runRules(next, options.rules);
+        verdict = (await (0, _validation.collectRuleErrors)(currentOptions.rules, next, 1))[0] ?? null;
         if (verdict === null) {
-          verdict = await runValidator(next, options.validate);
+          verdict = await runValidator(next, currentOptions.validate);
         }
       } catch (err) {
         verdict = err instanceof Error ? err.message : String(err);
@@ -76,12 +70,12 @@ function useInlineEdit(modelValue, options = {}) {
       isPending.value = false;
       if (verdict !== null) {
         error.value = verdict;
-        options.onError?.(verdict);
+        currentOptions.onError?.(verdict);
         return false;
       }
     }
     isEditing.value = false;
-    options.onConfirm?.(next);
+    currentOptions.onConfirm?.(next);
     draft.value = "";
     await (0, _vue.nextTick)();
     return true;

package/dist/src/composables/InlineEdit/inline-edit.composable.d.ts

@@ -1,5 +1,5 @@
-import { type ComputedRef, type Ref } from 'vue';
-import type { IUseInlineEditOptions } from '../../interfaces';
+import { type ComputedRef, type MaybeRefOrGetter, type Ref } from 'vue';
+import type { IUseInlineEditOptions } from '../../interfaces/InlineEdit/inline-edit.interface';
 /**
  * Headless edit-in-place state machine.
  *
@@ -22,7 +22,7 @@ import type { IUseInlineEditOptions } from '../../interfaces';
  * })
  * ```
  */
-export declare function useInlineEdit(modelValue: Ref<string | number> | ComputedRef<string | number>, options?: IUseInlineEditOptions): {
+export declare function useInlineEdit(modelValue: Ref<string | number> | ComputedRef<string | number>, options?: MaybeRefOrGetter<IUseInlineEditOptions>): {
     isEditing: Ref<boolean, boolean>;
     draft: Ref<string, string>;
     error: Ref<string | null, string | null>;

package/dist/src/composables/InlineEdit/inline-edit.composable.js

@@ -2,20 +2,23 @@ import {
   computed,
   nextTick,
   ref,
+  toValue,
   unref
 } from "vue";
+import { collectRuleErrors } from "../../utils/Commons/validation.util.js";
 const toDraft = (value) => {
   if (value === null || value === void 0) return "";
   return String(value);
 };
 export function useInlineEdit(modelValue, options = {}) {
-  const trim = options.trim ?? true;
+  const resolveOptions = () => toValue(options);
+  const trim = computed(() => resolveOptions().trim ?? true);
   const isEditing = ref(false);
   const draft = ref("");
   const error = ref(null);
   const isPending = ref(false);
   let validationToken = 0;
-  const normalisedDraft = computed(() => trim ? draft.value.trim() : draft.value);
+  const normalisedDraft = computed(() => trim.value ? draft.value.trim() : draft.value);
   const isDraftEmpty = computed(() => normalisedDraft.value.length === 0);
   const edit = () => {
     if (isEditing.value) return;
@@ -36,37 +39,29 @@ export function useInlineEdit(modelValue, options = {}) {
     error.value = null;
     isEditing.value = false;
     draft.value = "";
-    options.onCancel?.();
+    resolveOptions().onCancel?.();
   };
   const runValidator = async (value, validator) => {
     if (!validator) return null;
     const verdict = await validator(value);
     if (verdict === true) return null;
-    return typeof verdict === "string" ? verdict : "Invalid value";
-  };
-  const runRules = async (value, rules) => {
-    if (!rules || rules.length === 0) return null;
-    for (const rule of rules) {
-      const result = await rule(value);
-      if (result === true) continue;
-      if (typeof result === "string") return result;
-    }
-    return null;
+    return typeof verdict === "string" ? verdict : resolveOptions().invalidMessage ?? "Invalid value";
   };
   const confirm = async () => {
     if (!isEditing.value) return false;
     const token = ++validationToken;
     const next = normalisedDraft.value;
     error.value = null;
-    const hasRules = options.rules && options.rules.length > 0;
-    const hasValidate = !!options.validate;
+    const currentOptions = resolveOptions();
+    const hasRules = currentOptions.rules && currentOptions.rules.length > 0;
+    const hasValidate = !!currentOptions.validate;
     if (hasRules || hasValidate) {
       isPending.value = true;
       let verdict = null;
       try {
-        verdict = await runRules(next, options.rules);
+        verdict = (await collectRuleErrors(currentOptions.rules, next, 1))[0] ?? null;
         if (verdict === null) {
-          verdict = await runValidator(next, options.validate);
+          verdict = await runValidator(next, currentOptions.validate);
         }
       } catch (err) {
         verdict = err instanceof Error ? err.message : String(err);
@@ -75,12 +70,12 @@ export function useInlineEdit(modelValue, options = {}) {
       isPending.value = false;
       if (verdict !== null) {
         error.value = verdict;
-        options.onError?.(verdict);
+        currentOptions.onError?.(verdict);
         return false;
       }
     }
     isEditing.value = false;
-    options.onConfirm?.(next);
+    currentOptions.onConfirm?.(next);
     draft.value = "";
     await nextTick();
     return true;

package/dist/src/composables/List/createList.composable.cjs

@@ -0,0 +1,31 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useCreateList = useCreateList;
+var _vue = require("vue");
+var _list = require("../../consts/List/list.const.cjs");
+var _listItem = require("../../enums/List/list-item.enum.cjs");
+function useCreateList(itemRole) {
+  const parent = (0, _vue.inject)(_list.ORIGAM_LIST_KEY, {
+    hasPrepend: (0, _vue.shallowRef)(false),
+    updateHasPrepend: () => null,
+    hasAppend: (0, _vue.shallowRef)(false),
+    updateHasAppend: () => null,
+    itemRole: (0, _vue.computed)(() => _listItem.LIST_ITEM_ROLE.LISTITEM)
+  });
+  const data = {
+    hasPrepend: (0, _vue.shallowRef)(false),
+    hasAppend: (0, _vue.shallowRef)(false),
+    updateHasPrepend: value => {
+      if (value) data.hasPrepend.value = value.value;
+    },
+    updateHasAppend: value => {
+      if (value) data.hasAppend.value = value.value;
+    },
+    itemRole: (0, _vue.computed)(() => itemRole ? itemRole.value : parent.itemRole.value)
+  };
+  (0, _vue.provide)(_list.ORIGAM_LIST_KEY, data);
+  return parent;
+}

package/dist/src/composables/List/createList.composable.d.ts

@@ -0,0 +1,34 @@
+import type { ComputedRef } from 'vue';
+import type { TListItemRole } from '../../types/List/list-item.type';
+/*********************************************************
+ * useCreateList
+ *
+ * @description
+ * Root of a list — tracks whether any item registered a prepend/append
+ * slot (so the list can reserve gutter space consistently across all
+ * its items), publishes the ARIA role its rows must carry, and provides
+ * `ORIGAM_LIST_KEY` for `useList` consumers. Independent from `useList`
+ * at the call level (no direct function dependency) — the two only
+ * share the `ORIGAM_LIST_KEY` provide/inject contract.
+ *
+ * @param itemRole
+ * The row role for the list being created, passed ONLY by the component
+ * that owns the mode (`<OrigamList>`). Every other caller —
+ * `<OrigamListChildren>`, which re-provides a scope for its own rows —
+ * omits it and INHERITS the role its ancestor list published. Without
+ * that inheritance a nested renderer would silently reset every row of
+ * a `listbox` back to `listitem`.
+ *
+ * @description
+ * The published `itemRole` stays a lazy `computed` on both branches: the
+ * mode derives from props, and ADR-005 writes theme-resolved props AFTER
+ * `setup()`. Resolving it eagerly here would snapshot the pre-theme
+ * value, and nothing would warn.
+ ********************************************************/
+export declare function useCreateList(itemRole?: ComputedRef<TListItemRole>): {
+    hasPrepend: import("vue").Ref<boolean>;
+    updateHasPrepend: (value: ComputedRef<boolean>) => void;
+    hasAppend: import("vue").Ref<boolean>;
+    updateHasAppend: (value: ComputedRef<boolean>) => void;
+    itemRole: ComputedRef<TListItemRole>;
+};

package/dist/src/composables/List/createList.composable.js

@@ -0,0 +1,25 @@
+import { computed, inject, provide, shallowRef } from "vue";
+import { ORIGAM_LIST_KEY } from "../../consts/List/list.const.js";
+import { LIST_ITEM_ROLE } from "../../enums/List/list-item.enum.js";
+export function useCreateList(itemRole) {
+  const parent = inject(ORIGAM_LIST_KEY, {
+    hasPrepend: shallowRef(false),
+    updateHasPrepend: () => null,
+    hasAppend: shallowRef(false),
+    updateHasAppend: () => null,
+    itemRole: computed(() => LIST_ITEM_ROLE.LISTITEM)
+  });
+  const data = {
+    hasPrepend: shallowRef(false),
+    hasAppend: shallowRef(false),
+    updateHasPrepend: (value) => {
+      if (value) data.hasPrepend.value = value.value;
+    },
+    updateHasAppend: (value) => {
+      if (value) data.hasAppend.value = value.value;
+    },
+    itemRole: computed(() => itemRole ? itemRole.value : parent.itemRole.value)
+  };
+  provide(ORIGAM_LIST_KEY, data);
+  return parent;
+}

package/dist/src/composables/List/list.composable.cjs

@@ -3,30 +3,9 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.useCreateList = useCreateList;
 exports.useList = useList;
 var _vue = require("vue");
-var _consts = require("../../consts/index.cjs");
-function useCreateList() {
-  const parent = (0, _vue.inject)(_consts.ORIGAM_LIST_KEY, {
-    hasPrepend: (0, _vue.shallowRef)(false),
-    updateHasPrepend: () => null,
-    hasAppend: (0, _vue.shallowRef)(false),
-    updateHasAppend: () => null
-  });
-  const data = {
-    hasPrepend: (0, _vue.shallowRef)(false),
-    hasAppend: (0, _vue.shallowRef)(false),
-    updateHasPrepend: value => {
-      if (value) data.hasPrepend.value = value.value;
-    },
-    updateHasAppend: value => {
-      if (value) data.hasAppend.value = value.value;
-    }
-  };
-  (0, _vue.provide)(_consts.ORIGAM_LIST_KEY, data);
-  return parent;
-}
+var _list = require("../../consts/List/list.const.cjs");
 function useList() {
-  return (0, _vue.inject)(_consts.ORIGAM_LIST_KEY, null);
+  return (0, _vue.inject)(_list.ORIGAM_LIST_KEY, null);
 }

package/dist/src/composables/List/list.composable.d.ts

@@ -1,19 +1,17 @@
-import { ComputedRef } from 'vue';
-/*********************************************************
- * useCreateList
- ********************************************************/
-export declare function useCreateList(): {
-    hasPrepend: import("vue").Ref<boolean>;
-    updateHasPrepend: (value: ComputedRef<boolean>) => void;
-    hasAppend: import("vue").Ref<boolean>;
-    updateHasAppend: (value: ComputedRef<boolean>) => void;
-};
 /*********************************************************
  * useList
+ *
+ * @description
+ * Reads the nearest `ORIGAM_LIST_KEY` injection provided by
+ * `useCreateList`, or `null` when rendered outside a list.
+ * Independent from `useCreateList` at the call level (no direct
+ * function dependency) — the two only share the `ORIGAM_LIST_KEY`
+ * provide/inject contract.
  ********************************************************/
 export declare function useList(): {
     hasPrepend: import("vue").Ref<boolean>;
-    updateHasPrepend: (value: ComputedRef<boolean>) => void;
+    updateHasPrepend: (value: import("vue").ComputedRef<boolean>) => void;
     hasAppend: import("vue").Ref<boolean>;
-    updateHasAppend: (value: ComputedRef<boolean>) => void;
+    updateHasAppend: (value: import("vue").ComputedRef<boolean>) => void;
+    itemRole: import("vue").ComputedRef<import("../../types").TListItemRole>;
 } | null;

package/dist/src/composables/List/list.composable.js

@@ -1,25 +1,5 @@
-import { inject, provide, shallowRef } from "vue";
-import { ORIGAM_LIST_KEY } from "../../consts/index.js";
-export function useCreateList() {
-  const parent = inject(ORIGAM_LIST_KEY, {
-    hasPrepend: shallowRef(false),
-    updateHasPrepend: () => null,
-    hasAppend: shallowRef(false),
-    updateHasAppend: () => null
-  });
-  const data = {
-    hasPrepend: shallowRef(false),
-    hasAppend: shallowRef(false),
-    updateHasPrepend: (value) => {
-      if (value) data.hasPrepend.value = value.value;
-    },
-    updateHasAppend: (value) => {
-      if (value) data.hasAppend.value = value.value;
-    }
-  };
-  provide(ORIGAM_LIST_KEY, data);
-  return parent;
-}
+import { inject } from "vue";
+import { ORIGAM_LIST_KEY } from "../../consts/List/list.const.js";
 export function useList() {
   return inject(ORIGAM_LIST_KEY, null);
 }

package/dist/src/composables/Masonry/masonry.composable.d.ts

@@ -1,6 +1,6 @@
-import type { TMasonryAlign } from '../../types';
-import type { IMasonryLayoutResult, IUseMasonryOptions, TMasonryColumnBreakpoints } from '../../interfaces';
-export type { IMasonryItemRect, IMasonryLayoutResult, IUseMasonryOptions } from '../../interfaces';
+import type { TMasonryAlign } from '../../types/Masonry/masonry.type';
+import type { IMasonryLayoutResult, IUseMasonryOptions, TMasonryColumnBreakpoints } from '../../interfaces/Masonry/masonry.interface';
+export type { IMasonryItemRect, IMasonryLayoutResult, IUseMasonryOptions } from '../../interfaces/Masonry/masonry.interface';
 /**
  * Decide how many columns to use given a container width and a
  * breakpoint map. Picks the LARGEST key ≤ width. Falls back to