origam 2.16.0 → 2.17.1

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

@@ -1,18 +1,5 @@
-import {
-  computed,
-  inject,
-  onActivated,
-  onBeforeUnmount,
-  onDeactivated,
-  onMounted,
-  provide,
-  reactive,
-  ref,
-  shallowRef
-} from "vue";
-import { useResizeObserver } from "../../composables/index.js";
-import { ORIGAM_LAYOUT_ITEM_KEY, ORIGAM_LAYOUT_KEY, ROOT_ZINDEX } from "../../consts/index.js";
-import { convertToUnit, findChildrenWithProvide, generateLayers, getCurrentInstance, getUid, int } from "../../utils/index.js";
+import { inject } from "vue";
+import { ORIGAM_LAYOUT_KEY } from "../../consts/Commons/layout.const.js";
 export function useLayout() {
   const layout = inject(ORIGAM_LAYOUT_KEY);
   if (!layout) {
@@ -25,241 +12,3 @@ export function useLayout() {
     mainId: layout.layoutId
   };
 }
-export function useLayoutItem(options) {
-  const layout = inject(ORIGAM_LAYOUT_KEY);
-  if (!layout) {
-    return {
-      layoutItemStyles: computed(() => ({})),
-      layoutRect: shallowRef(void 0),
-      layoutItemScrimStyles: computed(() => ({})),
-      layoutId: "origam-layout-orphan"
-    };
-  }
-  const id = options.id ?? `layout-item-${getUid()}`;
-  const vm = getCurrentInstance("useLayoutItem");
-  provide(ORIGAM_LAYOUT_ITEM_KEY, shallowRef({ id }));
-  const isKeptAlive = shallowRef(false);
-  onDeactivated(() => {
-    isKeptAlive.value = true;
-  });
-  onActivated(() => {
-    isKeptAlive.value = false;
-  });
-  const {
-    layoutItemStyles,
-    layoutItemScrimStyles
-  } = layout.register(vm, {
-    ...options,
-    active: computed(() => isKeptAlive.value ? false : options.active.value),
-    id
-  });
-  onBeforeUnmount(() => {
-    layout.unregister(id);
-  });
-  return {
-    layoutItemStyles,
-    layoutRect: layout.layoutRect,
-    layoutItemScrimStyles,
-    layoutId: layout.layoutId
-  };
-}
-export function useCreateLayout(props) {
-  const parentLayout = inject(ORIGAM_LAYOUT_KEY, null);
-  const uid = getUid();
-  const layoutId = computed(() => props.id || `layout-${uid}`);
-  const rootZIndex = computed(() => parentLayout ? parentLayout.rootZIndex.value - 100 : ROOT_ZINDEX);
-  const registered = ref([]);
-  const positions = reactive(/* @__PURE__ */ new Map());
-  const layoutSizes = reactive(/* @__PURE__ */ new Map());
-  const priorities = reactive(/* @__PURE__ */ new Map());
-  const activeItems = reactive(/* @__PURE__ */ new Map());
-  const disabledTransitions = reactive(/* @__PURE__ */ new Map());
-  const { resizeRef, contentRect: layoutRect } = useResizeObserver();
-  const computedOverlaps = computed(() => {
-    const map = /* @__PURE__ */ new Map();
-    const overlaps = props.overlaps ?? [];
-    for (const overlap of overlaps.filter((item) => item.includes(":"))) {
-      const [top, bottom] = overlap.split(":");
-      if (!registered.value.includes(top) || !registered.value.includes(bottom)) continue;
-      const topPosition = positions.get(top);
-      const bottomPosition = positions.get(bottom);
-      const topAmount = layoutSizes.get(top);
-      const bottomAmount = layoutSizes.get(bottom);
-      if (!topPosition || !bottomPosition || !topAmount || !bottomAmount) continue;
-      map.set(bottom, { position: topPosition.value, amount: int(topAmount.value) });
-      map.set(top, { position: bottomPosition.value, amount: -int(bottomAmount.value) });
-    }
-    return map;
-  });
-  const layers = computed(() => {
-    const uniquePriorities = [...new Set([...priorities.values()].map((p) => p.value))].sort((a, b) => a - b);
-    const layout = [];
-    for (const p of uniquePriorities) {
-      const items2 = registered.value.filter((id) => priorities.get(id)?.value === p);
-      layout.push(...items2);
-    }
-    return generateLayers(layout, positions, layoutSizes, activeItems);
-  });
-  const transitionsEnabled = computed(() => {
-    return !Array.from(disabledTransitions.values()).some((ref2) => ref2.value);
-  });
-  const mainRect = computed(() => {
-    return layers.value[layers.value.length - 1].layer;
-  });
-  const mainStyles = computed(() => {
-    const left = convertToUnit(mainRect.value.left) ?? "0px";
-    const right = convertToUnit(mainRect.value.right) ?? "0px";
-    const top = convertToUnit(mainRect.value.top) ?? "0px";
-    const bottom = convertToUnit(mainRect.value.bottom) ?? "0px";
-    return {
-      "left": left,
-      "right": right,
-      "top": top,
-      "bottom": bottom,
-      "--origam-layout---position-left": left,
-      "--origam-layout---position-right": right,
-      "--origam-layout---position-top": top,
-      "--origam-layout---position-bottom": bottom,
-      ...transitionsEnabled.value ? void 0 : { transition: "none" }
-    };
-  });
-  const items = computed(() => {
-    return layers.value.slice(1).map(({ id }, index) => {
-      const { layer } = layers.value[index];
-      const size = layoutSizes.get(id);
-      const position = positions.get(id);
-      return {
-        id,
-        ...layer,
-        size: Number(size.value),
-        position: position.value
-      };
-    });
-  });
-  const getLayoutItem = (id) => {
-    return items.value.find((item) => item.id === id);
-  };
-  const rootVm = getCurrentInstance("createLayout");
-  const isMounted = shallowRef(false);
-  onMounted(() => {
-    isMounted.value = true;
-  });
-  provide(ORIGAM_LAYOUT_KEY, {
-    register: (vm, {
-      id,
-      order,
-      position,
-      layoutSize,
-      elementSize,
-      active,
-      disableTransitions,
-      absolute
-    }) => {
-      priorities.set(id, order);
-      positions.set(id, position);
-      layoutSizes.set(id, layoutSize);
-      activeItems.set(id, active);
-      if (disableTransitions) {
-        disabledTransitions.set(id, disableTransitions);
-      }
-      const staleIds = registered.value.filter(
-        (existingId) => existingId !== id && priorities.get(existingId)?.value === order.value && positions.get(existingId)?.value === position.value
-      );
-      if (staleIds.length > 0) {
-        const staleSet = new Set(staleIds);
-        for (const staleId of staleIds) {
-          priorities.delete(staleId);
-          positions.delete(staleId);
-          layoutSizes.delete(staleId);
-          activeItems.delete(staleId);
-          disabledTransitions.delete(staleId);
-        }
-        registered.value = registered.value.filter((v) => !staleSet.has(v));
-      }
-      const instances = findChildrenWithProvide(ORIGAM_LAYOUT_KEY, rootVm?.vnode);
-      const instanceIndex = instances.indexOf(vm);
-      if (instanceIndex > -1) registered.value.splice(instanceIndex, 0, id);
-      else registered.value.push(id);
-      const index = computed(() => items.value.findIndex((i) => i.id === id));
-      const zIndex = computed(() => rootZIndex.value + layers.value.length * 2 - index.value * 2);
-      const layoutItemStyles = computed(() => {
-        const isHorizontal = position.value === "left" || position.value === "right";
-        const isOppositeHorizontal = position.value === "right";
-        const isOppositeVertical = position.value === "bottom";
-        const styles = {
-          [position.value]: 0,
-          "z-index": zIndex.value,
-          "transform": `translate${isHorizontal ? "X" : "Y"}(${(active.value ? 0 : -110) * (isOppositeHorizontal || isOppositeVertical ? -1 : 1)}%)`,
-          "position": absolute.value || rootZIndex.value !== ROOT_ZINDEX ? "absolute" : "fixed",
-          ...transitionsEnabled.value ? void 0 : { "transition": "none" }
-        };
-        if (!isMounted.value) return styles;
-        const item = items.value[index.value];
-        if (!item) return styles;
-        const overlap = computedOverlaps.value.get(id);
-        if (overlap) {
-          item[overlap.position] += overlap.amount;
-        }
-        return {
-          ...styles,
-          "height": isHorizontal ? `calc(100% - ${convertToUnit(item.top)} - ${convertToUnit(item.bottom)})` : elementSize.value ? `${convertToUnit(elementSize.value)}` : void 0,
-          left: isOppositeHorizontal ? void 0 : convertToUnit(item.left),
-          right: isOppositeHorizontal ? convertToUnit(item.right) : void 0,
-          top: position.value !== "bottom" ? convertToUnit(item.top) : void 0,
-          bottom: position.value !== "top" ? convertToUnit(item.bottom) : void 0,
-          "width": !isHorizontal ? `calc(100% - ${convertToUnit(item.left)} - ${convertToUnit(item.right)})` : elementSize.value ? `${convertToUnit(elementSize.value)}` : void 0
-        };
-      });
-      const layoutItemScrimStyles = computed(() => ({
-        "z-index": zIndex.value - 1
-      }));
-      return { layoutItemStyles, layoutItemScrimStyles, zIndex };
-    },
-    unregister: (id) => {
-      priorities.delete(id);
-      positions.delete(id);
-      layoutSizes.delete(id);
-      activeItems.delete(id);
-      disabledTransitions.delete(id);
-      registered.value = registered.value.filter((v) => v !== id);
-    },
-    mainRect,
-    mainStyles,
-    getLayoutItem,
-    items,
-    layoutRect,
-    rootZIndex,
-    layoutId
-  });
-  const layoutClasses = computed(() => {
-    return [
-      "origam-layout",
-      { "origam-layout--full-height": props.fullHeight }
-    ];
-  });
-  const layoutStyles = computed(() => {
-    const left = convertToUnit(mainRect.value.left) ?? "0px";
-    const right = convertToUnit(mainRect.value.right) ?? "0px";
-    const top = convertToUnit(mainRect.value.top) ?? "0px";
-    const bottom = convertToUnit(mainRect.value.bottom) ?? "0px";
-    const out = {
-      "z-index": parentLayout ? rootZIndex.value : void 0,
-      "position": parentLayout ? "relative" : void 0,
-      "overflow": parentLayout ? "hidden" : void 0
-    };
-    out["--origam-layout---position-left"] = left;
-    out["--origam-layout---position-right"] = right;
-    out["--origam-layout---position-top"] = top;
-    out["--origam-layout---position-bottom"] = bottom;
-    return out;
-  });
-  return {
-    layoutClasses,
-    layoutStyles,
-    getLayoutItem,
-    items,
-    layoutRect,
-    layoutRef: resizeRef,
-    layoutId
-  };
-}

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

@@ -0,0 +1,49 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useLayoutItem = useLayoutItem;
+var _vue = require("vue");
+var _layout = require("../../consts/Commons/layout.const.cjs");
+var _getCurrentInstance = require("../../utils/Commons/getCurrentInstance.util.cjs");
+function useLayoutItem(options) {
+  const layout = (0, _vue.inject)(_layout.ORIGAM_LAYOUT_KEY);
+  if (!layout) {
+    return {
+      layoutItemStyles: (0, _vue.computed)(() => ({})),
+      layoutRect: (0, _vue.shallowRef)(void 0),
+      layoutItemScrimStyles: (0, _vue.computed)(() => ({})),
+      layoutId: "origam-layout-orphan"
+    };
+  }
+  const id = options.id ?? `layout-item-${(0, _getCurrentInstance.getUid)()}`;
+  const vm = (0, _getCurrentInstance.getCurrentInstance)("useLayoutItem");
+  (0, _vue.provide)(_layout.ORIGAM_LAYOUT_ITEM_KEY, (0, _vue.shallowRef)({
+    id
+  }));
+  const isKeptAlive = (0, _vue.shallowRef)(false);
+  (0, _vue.onDeactivated)(() => {
+    isKeptAlive.value = true;
+  });
+  (0, _vue.onActivated)(() => {
+    isKeptAlive.value = false;
+  });
+  const {
+    layoutItemStyles,
+    layoutItemScrimStyles
+  } = layout.register(vm, {
+    ...options,
+    active: (0, _vue.computed)(() => isKeptAlive.value ? false : options.active.value),
+    id
+  });
+  (0, _vue.onBeforeUnmount)(() => {
+    layout.unregister(id);
+  });
+  return {
+    layoutItemStyles,
+    layoutRect: layout.layoutRect,
+    layoutItemScrimStyles,
+    layoutId: layout.layoutId
+  };
+}

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

@@ -0,0 +1,34 @@
+import type { ComputedRef, CSSProperties, Ref } from 'vue';
+import type { TDirectionBoth } from '../../types/Commons/anchor.type';
+/*********************************************************
+ * useLayoutItem
+ *
+ * @description
+ * Registers a component (BottomNav, AppBar, Drawer…) as an item of the
+ * nearest `ORIGAM_LAYOUT_KEY` layout provided by `useCreateLayout`.
+ * Falls back to inert styles when no layout provider is present so the
+ * component still renders standalone (stories, modal previews, tests).
+ * Independent from `useLayout` / `useCreateLayout` at the call level
+ * (no direct function dependency) — the three only share the
+ * `ORIGAM_LAYOUT_KEY` provide/inject contract.
+ ********************************************************/
+export declare function useLayoutItem(options: {
+    id: string | undefined;
+    order: Ref<number>;
+    position: Ref<TDirectionBoth>;
+    layoutSize: Ref<number | string>;
+    elementSize: Ref<number | string | undefined>;
+    active: Ref<boolean> | ComputedRef<boolean>;
+    disableTransitions?: Ref<boolean>;
+    absolute: Ref<boolean | undefined>;
+}): {
+    layoutItemStyles: ComputedRef<CSSProperties>;
+    layoutRect: import("vue").ShallowRef<undefined, undefined>;
+    layoutItemScrimStyles: ComputedRef<CSSProperties>;
+    layoutId: string;
+} | {
+    layoutItemStyles: Ref<CSSProperties, CSSProperties>;
+    layoutRect: Ref<DOMRectReadOnly | undefined, DOMRectReadOnly | undefined>;
+    layoutItemScrimStyles: Ref<CSSProperties, CSSProperties>;
+    layoutId: ComputedRef<string>;
+};

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

@@ -0,0 +1,41 @@
+import { computed, inject, onActivated, onBeforeUnmount, onDeactivated, provide, shallowRef } from "vue";
+import { ORIGAM_LAYOUT_ITEM_KEY, ORIGAM_LAYOUT_KEY } from "../../consts/Commons/layout.const.js";
+import { getCurrentInstance, getUid } from "../../utils/Commons/getCurrentInstance.util.js";
+export function useLayoutItem(options) {
+  const layout = inject(ORIGAM_LAYOUT_KEY);
+  if (!layout) {
+    return {
+      layoutItemStyles: computed(() => ({})),
+      layoutRect: shallowRef(void 0),
+      layoutItemScrimStyles: computed(() => ({})),
+      layoutId: "origam-layout-orphan"
+    };
+  }
+  const id = options.id ?? `layout-item-${getUid()}`;
+  const vm = getCurrentInstance("useLayoutItem");
+  provide(ORIGAM_LAYOUT_ITEM_KEY, shallowRef({ id }));
+  const isKeptAlive = shallowRef(false);
+  onDeactivated(() => {
+    isKeptAlive.value = true;
+  });
+  onActivated(() => {
+    isKeptAlive.value = false;
+  });
+  const {
+    layoutItemStyles,
+    layoutItemScrimStyles
+  } = layout.register(vm, {
+    ...options,
+    active: computed(() => isKeptAlive.value ? false : options.active.value),
+    id
+  });
+  onBeforeUnmount(() => {
+    layout.unregister(id);
+  });
+  return {
+    layoutItemStyles,
+    layoutRect: layout.layoutRect,
+    layoutItemScrimStyles,
+    layoutId: layout.layoutId
+  };
+}

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

@@ -1,6 +1,20 @@
 import { Ref } from 'vue';
 /*********************************************************
  * useLazy
+ *
+ * @description
+ * Rendu paresseux du contenu d'un composant flottant/conditionnel :
+ * `hasContent` ne devient vrai qu'apres la PREMIERE activation de
+ * `active` (ou immediatement si `props.eager`), et reste vrai ensuite
+ * (`isBooted`) meme quand `active` repasse a `false` — le contenu n'est
+ * donc monte qu'une fois, puis conserve.
+ *
+ * @description
+ * `onAfterLeave` (a cabler sur la fin de transition de sortie) remet
+ * `isBooted` a `false` pour un composant NON `eager` — c'est ce hook qui
+ * demonte reellement le contenu apres la fermeture, pas le changement de
+ * `active` lui-meme. Un composant `eager` ignore ce reset : son contenu
+ * reste toujours monte.
  ********************************************************/
 export declare function useLazy(props: {
     eager: boolean;

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

@@ -0,0 +1,42 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useLink = useLink;
+var _vue = require("vue");
+var _commons = require("../../utils/Commons/commons.util.cjs");
+var _getCurrentInstance = require("../../utils/Commons/getCurrentInstance.util.cjs");
+var _route = require("./route.composable.cjs");
+function useLink(props, attrs) {
+  const RouterLink = (0, _vue.resolveDynamicComponent)("RouterLink");
+  const vm = (0, _getCurrentInstance.getCurrentInstance)("useLink");
+  const isLink = (0, _vue.computed)(() => !!(props.href || props.to));
+  const isClickable = (0, _vue.computed)(() => {
+    return isLink?.value || (0, _commons.hasEvent)(attrs, "click") || (0, _commons.hasEvent)(props, "click") || (0, _commons.hasEvent)(vm.vnode.props ?? {}, "click");
+  });
+  const tag = (0, _vue.computed)(() => isLink.value ? "a" : props.tag ?? "div");
+  if (typeof RouterLink === "string") {
+    return {
+      tag,
+      isLink,
+      isClickable,
+      href: (0, _vue.toRef)(props, "href")
+    };
+  }
+  const link = props.to ? RouterLink.useLink(props) : void 0;
+  const route = (0, _route.useRoute)();
+  return {
+    tag,
+    isLink,
+    isClickable,
+    route: link?.route,
+    navigate: link?.navigate,
+    isActive: link && (0, _vue.computed)(() => {
+      if (!props.exact) return link.isActive?.value;
+      if (!route.value) return link.isExactActive?.value;
+      return link.isExactActive?.value && (0, _commons.deepEqual)(link.route.value.query, route.value.query);
+    }),
+    href: (0, _vue.computed)(() => props.to ? link?.route.value.href : props.href)
+  };
+}

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

@@ -0,0 +1,14 @@
+import type { SetupContext } from 'vue';
+import type { ITagProps } from '../../interfaces/Commons/commons.interface';
+import type { ILink, ILinkProps } from '../../interfaces/Commons/router.interface';
+/*********************************************************
+ * useLink
+ *
+ * @description
+ * Resolves the tag / clickable state / router-aware navigation of any
+ * link-like component (Btn, Card, Chip, ListItem, BreadcrumbItem…).
+ * Depends on `useRoute` for the exact-match `isActive` derivation —
+ * kept in its own file since it is a consumer of `useRoute`, not a
+ * variant of it.
+ ********************************************************/
+export declare function useLink(props: ILinkProps & ITagProps, attrs: SetupContext['attrs']): ILink;

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

@@ -0,0 +1,36 @@
+import { computed, resolveDynamicComponent, toRef } from "vue";
+import { deepEqual, hasEvent } from "../../utils/Commons/commons.util.js";
+import { getCurrentInstance } from "../../utils/Commons/getCurrentInstance.util.js";
+import { useRoute } from "./route.composable.js";
+export function useLink(props, attrs) {
+  const RouterLink = resolveDynamicComponent("RouterLink");
+  const vm = getCurrentInstance("useLink");
+  const isLink = computed(() => !!(props.href || props.to));
+  const isClickable = computed(() => {
+    return isLink?.value || hasEvent(attrs, "click") || hasEvent(props, "click") || hasEvent(vm.vnode.props ?? {}, "click");
+  });
+  const tag = computed(() => isLink.value ? "a" : props.tag ?? "div");
+  if (typeof RouterLink === "string") {
+    return {
+      tag,
+      isLink,
+      isClickable,
+      href: toRef(props, "href")
+    };
+  }
+  const link = props.to ? RouterLink.useLink(props) : void 0;
+  const route = useRoute();
+  return {
+    tag,
+    isLink,
+    isClickable,
+    route: link?.route,
+    navigate: link?.navigate,
+    isActive: link && computed(() => {
+      if (!props.exact) return link.isActive?.value;
+      if (!route.value) return link.isExactActive?.value;
+      return link.isExactActive?.value && deepEqual(link.route.value.query, route.value.query);
+    }),
+    href: computed(() => props.to ? link?.route.value.href : props.href)
+  };
+}

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

@@ -6,8 +6,8 @@ Object.defineProperty(exports, "__esModule", {
 exports.useLoader = useLoader;
 var _vue = require("vue");
 var _enums = require("../../enums/index.cjs");
-var _utils = require("../../utils/index.cjs");
-function useLoader(props, defaultKind = _enums.LOADER_KIND.CIRCULAR, name = (0, _utils.getCurrentInstanceName)()) {
+var _getCurrentInstance = require("../../utils/Commons/getCurrentInstance.util.cjs");
+function useLoader(props, defaultKind = _enums.LOADER_KIND.CIRCULAR, name = (0, _getCurrentInstance.getCurrentInstanceName)()) {
   const isLoading = (0, _vue.computed)(() => {
     const v = props.loading;
     if (v === false || v === void 0 || v === null) return false;

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

@@ -1,26 +1,26 @@
 import { type ComputedRef } from 'vue';
-import type { ILoaderProps, IResolvedLoader } from '../../interfaces';
-import type { TLoaderKind } from '../../types';
-export type { IResolvedLoader } from '../../interfaces';
-/**
- * Resolve the polymorphic `loading` prop into a normalised descriptor.
- *
- * Accepts `boolean | number | TLoaderConfig` and produces:
- * - `loaderClasses` — backward-compatible class map containing
- *   `${name}--loading` when active.
- * - `isLoading` — boolean ref, true when any loading state is active.
- * - `loaderConfig` — full `IResolvedLoader` descriptor used by the
- *   consumer to mount the correct renderer with the correct props.
- *
- * @param props - The component props extending `ILoaderProps`.
- * @param defaultKind - Renderer to use when the user passes `true` or a
- *   number (i.e. when no `type` discriminant was provided). Each consumer
- *   picks its preferred kind: `'circular'` for Btn, `'line'` for Card, etc.
- * @param name - Override the kebab-case component name used to build the
- *   `${name}--loading` class. Defaults to `getCurrentInstanceName()`.
- */
+import type { ILoaderProps, IResolvedLoader } from '../../interfaces/Commons/loader.interface';
+import type { TLoaderKind } from '../../types/Commons/loader.type';
+export type { IResolvedLoader } from '../../interfaces/Commons/loader.interface';
 /*********************************************************
  * useLoader
+ *
+ * @description
+ * Resout la prop polymorphe `loading` (`boolean | number | TLoaderConfig`)
+ * en un descripteur normalise : `loaderClasses` (`{name}--loading`),
+ * `isLoading` (booleen), et `loaderConfig` (kind, `modelValue`,
+ * `indeterminate`, `overrides`) que le composant utilise pour monter le
+ * bon renderer. `defaultKind` est choisi par CHAQUE consommateur —
+ * `'circular'` pour Btn, `'line'` pour Card, etc. — utilise quand
+ * `loading` est `true`/un nombre plutot qu'un objet `{ type }`.
+ *
+ * @description
+ * Determinisme derive de la FORME de la valeur, pas d'un flag explicite :
+ * `loading={true}` → indetermine ; `loading={42}` → determine a 42 ;
+ * `loading={{ type: 'line', modelValue: 42 }}` → determine ; `loading=
+ * {{ type: 'line' }}` (sans `modelValue`) → indetermine. Un objet SANS
+ * `type` est traite comme "pas d'objet reconnu" et retombe sur l'etat
+ * inactif.
  ********************************************************/
 export declare function useLoader(props: ILoaderProps, defaultKind?: TLoaderKind, name?: string): {
     loaderClasses: ComputedRef<Record<string, boolean>>;

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

@@ -1,6 +1,6 @@
 import { computed } from "vue";
 import { LOADER_KIND } from "../../enums/index.js";
-import { getCurrentInstanceName } from "../../utils/index.js";
+import { getCurrentInstanceName } from "../../utils/Commons/getCurrentInstance.util.js";
 export function useLoader(props, defaultKind = LOADER_KIND.CIRCULAR, name = getCurrentInstanceName()) {
   const isLoading = computed(() => {
     const v = props.loading;

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

@@ -4,75 +4,48 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.createLocale = createLocale;
-exports.createRtl = createRtl;
 exports.provideLocale = provideLocale;
-exports.provideRtl = provideRtl;
 exports.useLocale = useLocale;
-exports.useRtl = useRtl;
 var _vue = require("vue");
 var origamMessages = _interopRequireWildcard(require("../../assets/locales/index.cjs"));
-var _consts = require("../../consts/index.cjs");
-var _utils = require("../../utils/index.cjs");
+var _locale = require("../../consts/Commons/locale.const.cjs");
+var _commons = require("../../utils/Commons/commons.util.cjs");
+var _locale2 = require("../../utils/Commons/locale.util.cjs");
+var _rtl = require("./rtl.composable.cjs");
 function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
 function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
 function createLocale(options) {
-  const merged = (0, _utils.mergeDeep)({
+  const merged = (0, _commons.mergeDeep)({
     locale: "en",
     fallbackLocale: "en",
     messages: JSON.parse(JSON.stringify(origamMessages))
     // Fix problems with json file imported
   }, options);
-  const locale = options?.adapter ?? (0, _utils.createBuiltinAdapter)({
+  const locale = options?.adapter ?? (0, _locale2.createBuiltinAdapter)({
     current: (0, _vue.ref)(merged.locale),
     fallback: (0, _vue.ref)(merged.fallbackLocale),
     messages: (0, _vue.computed)(() => merged.messages)
   });
-  const rtl = createRtl(locale, options);
+  const rtl = (0, _rtl.createRtl)(locale, options);
   return {
     ...locale,
     ...rtl
   };
 }
-function useLocale() {
-  const locale = (0, _vue.inject)(_consts.ORIGAM_LOCALE_KEY);
-  if (!locale) throw new Error("[Origam] Could not find injected locale instance");
+function useLocale(strict = true) {
+  const locale = (0, _vue.inject)(_locale.ORIGAM_LOCALE_KEY, null);
+  if (!locale && strict) throw new Error("[Origam] Could not find injected locale instance");
   return locale;
 }
 function provideLocale(props) {
-  const locale = (0, _vue.inject)(_consts.ORIGAM_LOCALE_KEY);
+  const locale = (0, _vue.inject)(_locale.ORIGAM_LOCALE_KEY);
   if (!locale) throw new Error("[Origam] Could not find injected locale instance");
   const i18n = locale.provide(props);
-  const rtl = provideRtl(i18n, locale.rtl, props);
+  const rtl = (0, _rtl.provideRtl)(i18n, locale.rtl, props);
   const data = {
     ...i18n,
     ...rtl
   };
-  (0, _vue.provide)(_consts.ORIGAM_LOCALE_KEY, data);
+  (0, _vue.provide)(_locale.ORIGAM_LOCALE_KEY, data);
   return data;
-}
-function createRtl(i18n, options) {
-  const rtl = (0, _vue.ref)(options?.rtl ?? _consts.LOCALE_RTL_DEFAULT);
-  const isRtl = (0, _vue.computed)(() => rtl.value[i18n.current.value] ?? false);
-  return {
-    isRtl,
-    rtl
-  };
-}
-function useRtl(name = (0, _utils.getCurrentInstanceName)()) {
-  const locale = (0, _vue.inject)(_consts.ORIGAM_LOCALE_KEY);
-  if (!locale) throw new Error("[Origam] Could not find injected rtl instance");
-  const rtlClasses = (0, _vue.computed)(() => {
-    return `${name}--is-${locale.isRtl.value ? "rtl" : "ltr"}`;
-  });
-  return {
-    isRtl: locale.isRtl,
-    rtlClasses
-  };
-}
-function provideRtl(locale, rtl, props) {
-  const isRtl = (0, _vue.computed)(() => props.rtl ?? rtl.value[locale.current.value] ?? false);
-  return {
-    isRtl,
-    rtl
-  };
 }