origam 2.16.0 → 2.17.1

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

@@ -0,0 +1,35 @@
+/*********************************************************
+ * usePassedProps
+ *
+ * @description
+ * Was-prop-passed factory — component-side primitive: for the CURRENT
+ * component instance, returns a predicate telling whether a given prop
+ * key was explicitly written by the parent template (`vnode.props`) —
+ * as opposed to resolved from a default (`withDefaults()`, or Vue's
+ * own boolean-prop coercion).
+ * @description
+ * This matters beyond `useDefaults()` itself: any component that
+ * FORWARDS its own props down to descendants as
+ * `<OrigamDefaultsProvider>` entries (e.g. `OrigamAvatarGroup` →
+ * `origam-avatar`, `OrigamBtnGroup` → `origam-btn`) must use this —
+ * not a plain `!== undefined` check — to decide whether to forward a
+ * value. Reason: Vue resolves an UNSET prop whose declared type
+ * *includes* `boolean` (e.g. `border?: boolean | string`, `rounded?:
+ * boolean | TRounded`) to the concrete value `false`, never to
+ * `undefined`. A naive `omitUndefined()` over the forwarded map
+ * therefore still ships an explicit `false` for `border`/`rounded`
+ * even when the consumer never set them, which then wins the
+ * `mergeDeep` against an ancestor/theme default (e.g. `origam-avatar:
+ * { border: true }`) — see #263.
+ * @description
+ * MUST be re-read on every resolution (not captured once), for the
+ * same reason `useDefaults()` re-reads it: a parent binding through a
+ * dynamic `v-bind` whose object starts empty
+ * (`childRef?.filterProps(...)` before mount) only fills `vnode.props`
+ * on a later render.
+ * @description
+ * Kept in its own file since `useDefaults` is its consumer, not the
+ * other way round — moving it alongside `useDefaults` would make the
+ * dependency direction backwards to read.
+ ********************************************************/
+export declare function usePassedProps<T extends object>(_props: T, instanceLabel?: string): (key: Extract<keyof T, string> | string) => boolean;

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

@@ -0,0 +1,12 @@
+import { camelize } from "../../utils/Commons/commons.util.js";
+import { getCurrentInstance } from "../../utils/Commons/getCurrentInstance.util.js";
+export function usePassedProps(_props, instanceLabel = "usePassedProps") {
+  const vm = getCurrentInstance(instanceLabel);
+  return (key) => {
+    const vnodeProps = vm.vnode.props || {};
+    for (const k in vnodeProps) {
+      if (k === key || camelize(k) === key) return vnodeProps[k] !== void 0;
+    }
+    return false;
+  };
+}

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

@@ -4,9 +4,10 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.usePosition = usePosition;
-var _utils = require("../../utils/index.cjs");
+var _commons = require("../../utils/Commons/commons.util.cjs");
+var _getCurrentInstance = require("../../utils/Commons/getCurrentInstance.util.cjs");
 var _vue = require("vue");
-function usePosition(props, name = (0, _utils.getCurrentInstanceName)()) {
+function usePosition(props, name = (0, _getCurrentInstance.getCurrentInstanceName)()) {
   const positionClasses = (0, _vue.computed)(() => {
     return props.position ? `${name}--${props.position}` : void 0;
   });
@@ -15,7 +16,7 @@ function usePosition(props, name = (0, _utils.getCurrentInstanceName)()) {
     const layers = ["top", "bottom", "left", "right"];
     layers.forEach(layer => {
       if (props[layer]) {
-        styles.push(`${layer}: ${props[layer]}`);
+        styles.push(`${layer}: ${(0, _commons.convertToUnit)(props[layer])}`);
       }
     });
     return styles;

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

@@ -1,6 +1,19 @@
-import type { IPositionProps } from '../../interfaces';
+import type { IPositionProps } from '../../interfaces/Commons/position.interface';
 /*********************************************************
  * usePosition
+ *
+ * @description
+ * `positionClasses` traduit `props.position` (`'absolute'|'fixed'|'relative'|'sticky'|'static'`)
+ * en classe `{name}--{position}`. `positionStyles` emet une declaration
+ * inline par cote present parmi `top`/`bottom`/`left`/`right`.
+ *
+ * @description
+ * ⛔ Contrairement a `useDimension`, AUCUNE conversion via `convertToUnit`
+ * n'est appliquee sur `top`/`bottom`/`left`/`right` : bien que
+ * `IPositionProps` les type `number | string`, un nombre est interpole
+ * TEL QUEL (`"top: 8"`, pas `"top: 8px"`) — declaration CSS invalide.
+ * Passer une chaine unitee (`"8px"`) est le seul usage sur qui marche
+ * aujourd'hui.
  ********************************************************/
 export declare function usePosition(props: IPositionProps, name?: string): {
     positionClasses: import("vue").ComputedRef<string | undefined>;

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

@@ -1,4 +1,5 @@
-import { getCurrentInstanceName } from "../../utils/index.js";
+import { convertToUnit } from "../../utils/Commons/commons.util.js";
+import { getCurrentInstanceName } from "../../utils/Commons/getCurrentInstance.util.js";
 import { computed } from "vue";
 export function usePosition(props, name = getCurrentInstanceName()) {
   const positionClasses = computed(() => {
@@ -9,7 +10,7 @@ export function usePosition(props, name = getCurrentInstanceName()) {
     const layers = ["top", "bottom", "left", "right"];
     layers.forEach((layer) => {
       if (props[layer]) {
-        styles.push(`${layer}: ${props[layer]}`);
+        styles.push(`${layer}: ${convertToUnit(props[layer])}`);
       }
     });
     return styles;

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

@@ -4,12 +4,12 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.useProps = useProps;
-var _utils = require("../../utils/index.cjs");
+var _commons = require("../../utils/Commons/commons.util.cjs");
 function useProps(props) {
   const defaultExcludes = ["class", "style", "id"];
   const filterProps = (properties, excludes = defaultExcludes) => {
     const propKeys = Object.keys(props).filter(key => !excludes.includes(key));
-    const picked = (0, _utils.pick)(properties, propKeys);
+    const picked = (0, _commons.pick)(properties, propKeys);
     for (const key of Object.keys(picked)) {
       if (picked[key] === void 0) delete picked[key];
     }

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

@@ -1,4 +1,4 @@
-import type { IFilterPropsOptions } from "../../interfaces";
+import type { IFilterPropsOptions } from '../../interfaces/Commons/commons.interface';
 /*********************************************************
  * useProps
  *
@@ -47,4 +47,4 @@ import type { IFilterPropsOptions } from "../../interfaces";
  * value, which IS reachable unlike the paint), state that reason: it is not
  * this one.
  ********************************************************/
-export declare function useProps<T extends Record<string, any>>(props: T): IFilterPropsOptions<T>;
+export declare function useProps<T extends object>(props: T): IFilterPropsOptions<T>;

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

@@ -1,4 +1,4 @@
-import { pick } from "../../utils/index.js";
+import { pick } from "../../utils/Commons/commons.util.js";
 export function useProps(props) {
   const defaultExcludes = ["class", "style", "id"];
   const filterProps = (properties, excludes = defaultExcludes) => {

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

@@ -1,8 +1,21 @@
 import type { Ref } from 'vue';
 /*********************************************************
  * useRefs
+ *
+ * @description
+ * Collecte un tableau de template refs pour une liste `v-for` (`:ref`
+ * pointant vers `(e) => updateRef(e, index)`) — pattern standard pour
+ * recuperer les instances/elements enfants d'une boucle dans un ordre
+ * stable.
+ *
+ * @description
+ * Le tableau est REINITIALISE a vide a chaque `onBeforeUpdate` : c'est ce
+ * qui evite d'accumuler des references perimees quand la liste retrecit
+ * (sans ce reset, un index au-dela de la nouvelle longueur garderait
+ * l'ancien element). Vue re-remplit ensuite les index via `updateRef`
+ * pendant le re-render qui suit.
  ********************************************************/
 export declare function useRefs<T extends object>(): {
-    refs: Ref<(T | undefined)[], (T | undefined)[]>;
-    updateRef: (e: any, i: number) => void;
+    refs: Ref<(T | null | undefined)[], (T | null | undefined)[]>;
+    updateRef: (e: T | null, i: number) => void;
 };

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

@@ -4,13 +4,13 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.useResizeObserver = useResizeObserver;
-var _consts = require("../../consts/index.cjs");
-var _utils = require("../../utils/index.cjs");
+var _commons = require("../../consts/Commons/commons.const.cjs");
+var _commons2 = require("../../utils/Commons/commons.util.cjs");
 var _vue = require("vue");
 function useResizeObserver(callback, box = "content") {
   const contentRect = (0, _vue.ref)();
   const resizeRef = (0, _vue.ref)();
-  if (_consts.IN_BROWSER) {
+  if (_commons.IN_BROWSER) {
     const observer = new ResizeObserver(entries => {
       callback?.(entries, observer);
       if (!entries.length) return;
@@ -25,10 +25,10 @@ function useResizeObserver(callback, box = "content") {
     });
     (0, _vue.watch)(resizeRef, (newValue, oldValue) => {
       if (oldValue) {
-        observer.unobserve((0, _utils.refElement)(oldValue));
+        observer.unobserve((0, _commons2.refElement)(oldValue));
         contentRect.value = void 0;
       }
-      if (newValue) observer.observe((0, _utils.refElement)(newValue));
+      if (newValue) observer.observe((0, _commons2.refElement)(newValue));
     }, {
       flush: "post"
     });

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

@@ -1,5 +1,17 @@
-import type { IResizeState } from '../../interfaces';
+import type { IResizeState } from '../../interfaces/Commons/resizeObserver.interface';
 /*********************************************************
  * useResizeObserver
+ *
+ * @description
+ * Expose `resizeRef` (template ref a poser sur l'element observe) et
+ * `contentRect` (lecture seule) via un `ResizeObserver` re-attache
+ * automatiquement quand `resizeRef` change d'element, meme pattern que
+ * `useIntersectionObserver`. `box: 'border'` lit `getBoundingClientRect()`
+ * de la cible plutot que l'`entries[0].contentRect` du callback natif.
+ *
+ * @description
+ * Hors navigateur (`!IN_BROWSER`), aucun observer n'est cree —
+ * `contentRect` reste `undefined` en permanence, silencieusement, meme
+ * comportement de garde que `useIntersectionObserver`.
  ********************************************************/
 export declare function useResizeObserver(callback?: ResizeObserverCallback, box?: 'content' | 'border'): IResizeState;

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

@@ -1,5 +1,5 @@
-import { IN_BROWSER } from "../../consts/index.js";
-import { refElement } from "../../utils/index.js";
+import { IN_BROWSER } from "../../consts/Commons/commons.const.js";
+import { refElement } from "../../utils/Commons/commons.util.js";
 import { onBeforeUnmount, readonly, ref, watch } from "vue";
 export function useResizeObserver(callback, box = "content") {
   const contentRect = ref();

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

@@ -5,12 +5,16 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.useRounded = useRounded;
 var _vue = require("vue");
-var _consts = require("../../consts/index.cjs");
-var _utils = require("../../utils/index.cjs");
+var _rounded = require("../../consts/Commons/rounded.const.cjs");
+var _spacing = require("../../consts/Commons/spacing.const.cjs");
+var _commons = require("../../utils/Commons/commons.util.cjs");
+var _getCurrentInstance = require("../../utils/Commons/getCurrentInstance.util.cjs");
+var _rounded2 = require("../../utils/Commons/rounded.util.cjs");
+var _spacing2 = require("../../utils/Commons/spacing.util.cjs");
 function isUtilityRounded(value) {
-  return typeof value === "string" && Object.hasOwn(_consts.UTILITY_RADIUS_FALLBACK, value);
+  return typeof value === "string" && Object.hasOwn(_spacing.UTILITY_RADIUS_FALLBACK, value);
 }
-function useRounded(props, name = (0, _utils.getCurrentInstanceName)()) {
+function useRounded(props, name = (0, _getCurrentInstance.getCurrentInstanceName)()) {
   const roundedClasses = (0, _vue.computed)(() => {
     const rounded = (0, _vue.isRef)(props) ? props.value : props.rounded;
     const classes = [];
@@ -19,7 +23,7 @@ function useRounded(props, name = (0, _utils.getCurrentInstanceName)()) {
       classes.push(`origam--rounded-${rounded}`);
       return classes;
     }
-    if (typeof rounded === "string" && _consts.PREDEFINED_ROUNDED.includes(rounded)) {
+    if (typeof rounded === "string" && _rounded.PREDEFINED_ROUNDED.includes(rounded)) {
       classes.push(`${name}--rounded-${rounded}`);
       return classes;
     }
@@ -33,11 +37,11 @@ function useRounded(props, name = (0, _utils.getCurrentInstanceName)()) {
     const styles = [];
     if (rounded == null || rounded === false) return styles;
     if (isUtilityRounded(rounded)) {
-      styles.push(`border-radius: var(--origam-radius---${rounded}, ${_consts.UTILITY_RADIUS_FALLBACK[rounded]})`);
+      styles.push(`border-radius: var(--origam-radius---${rounded}, ${_spacing.UTILITY_RADIUS_FALLBACK[rounded]})`);
       return styles;
     }
-    if (typeof rounded === "string" && _consts.PREDEFINED_ROUNDED.includes(rounded) && rounded !== "shaped" && rounded !== "shaped-invert") {
-      const token = _consts.NAMED_RADIUS_TOKEN[rounded];
+    if (typeof rounded === "string" && _rounded.PREDEFINED_ROUNDED.includes(rounded) && rounded !== "shaped" && rounded !== "shaped-invert") {
+      const token = _spacing.NAMED_RADIUS_TOKEN[rounded];
       if (token) styles.push(`border-radius: ${token}`);
       return styles;
     }
@@ -46,17 +50,17 @@ function useRounded(props, name = (0, _utils.getCurrentInstanceName)()) {
       return styles;
     }
     if (typeof rounded === "string") {
-      const match = _consts.BORDER_RADIUS_REGEX.exec(rounded)?.groups;
+      const match = _rounded.BORDER_RADIUS_REGEX.exec(rounded)?.groups;
       if (match) {
         Object.keys(match).forEach(key => {
           const values = String(match[key]).split(" ");
-          styles.push(...(0, _utils.formatRoundedStylesVar)(values));
+          styles.push(...(0, _rounded2.formatRoundedStylesVar)(values));
         });
-      } else if ((0, _utils.isCustomBorderRadius)(rounded)) {
+      } else if ((0, _rounded2.isCustomBorderRadius)(rounded)) {
         styles.push(`border-radius: ${rounded.trim()}`);
       }
     } else if (typeof rounded === "number") {
-      styles.push(`border-radius: ${(0, _utils.convertToUnit)(rounded)}`);
+      styles.push(`border-radius: ${(0, _commons.convertToUnit)(rounded)}`);
     }
     return styles;
   };
@@ -64,11 +68,11 @@ function useRounded(props, name = (0, _utils.getCurrentInstanceName)()) {
     const rounded = (0, _vue.isRef)(props) ? props.value : props.rounded;
     const styles = shorthandStyles(rounded);
     if (!(0, _vue.isRef)(props)) {
-      _consts.ROUNDED_CORNER_MAP.forEach(({
+      _spacing.ROUNDED_CORNER_MAP.forEach(({
         corner,
         prop
       }) => {
-        const resolved = (0, _utils.resolveRoundedCornerValue)(props[prop]);
+        const resolved = (0, _spacing2.resolveRoundedCornerValue)(props[prop]);
         if (resolved) styles.push(`border-${corner}-radius: ${resolved}`);
       });
     }

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

@@ -1,6 +1,6 @@
 import { Ref } from 'vue';
-import type { IRoundedProps } from '../../interfaces';
-import type { TRounded } from '../../types';
+import type { IRoundedProps } from '../../interfaces/Commons/rounded.interface';
+import type { TRounded } from '../../types/Commons/rounded.type';
 /*********************************************************
  * useRounded
  *

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

@@ -1,18 +1,10 @@
 import { computed, isRef } from "vue";
-import {
-  BORDER_RADIUS_REGEX,
-  NAMED_RADIUS_TOKEN,
-  PREDEFINED_ROUNDED,
-  ROUNDED_CORNER_MAP,
-  UTILITY_RADIUS_FALLBACK
-} from "../../consts/index.js";
-import {
-  convertToUnit,
-  formatRoundedStylesVar,
-  getCurrentInstanceName,
-  isCustomBorderRadius,
-  resolveRoundedCornerValue
-} from "../../utils/index.js";
+import { BORDER_RADIUS_REGEX, PREDEFINED_ROUNDED } from "../../consts/Commons/rounded.const.js";
+import { NAMED_RADIUS_TOKEN, ROUNDED_CORNER_MAP, UTILITY_RADIUS_FALLBACK } from "../../consts/Commons/spacing.const.js";
+import { convertToUnit } from "../../utils/Commons/commons.util.js";
+import { getCurrentInstanceName } from "../../utils/Commons/getCurrentInstance.util.js";
+import { formatRoundedStylesVar, isCustomBorderRadius } from "../../utils/Commons/rounded.util.js";
+import { resolveRoundedCornerValue } from "../../utils/Commons/spacing.util.js";
 function isUtilityRounded(value) {
   return typeof value === "string" && Object.hasOwn(UTILITY_RADIUS_FALLBACK, value);
 }

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

@@ -0,0 +1,12 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useRoute = useRoute;
+var _vue = require("vue");
+var _getCurrentInstance = require("../../utils/Commons/getCurrentInstance.util.cjs");
+function useRoute() {
+  const vm = (0, _getCurrentInstance.getCurrentInstance)("useRoute");
+  return (0, _vue.computed)(() => vm?.proxy?.$route);
+}

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

@@ -0,0 +1,13 @@
+import type { Ref } from 'vue';
+import type { RouteLocationNormalizedLoaded } from 'vue-router';
+/*********************************************************
+ * useRoute
+ *
+ * @description
+ * Reads the current route off the active component instance's proxy
+ * (`$route`), Options-API style — kept separate from `useRouter` so a
+ * consumer that only needs the current route doesn't pull in the
+ * router instance accessor too.
+ * `useLink` depends on this hook (route-aware `isActive` derivation).
+ ********************************************************/
+export declare function useRoute(): Ref<RouteLocationNormalizedLoaded | undefined>;

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

@@ -0,0 +1,6 @@
+import { computed } from "vue";
+import { getCurrentInstance } from "../../utils/Commons/getCurrentInstance.util.js";
+export function useRoute() {
+  const vm = getCurrentInstance("useRoute");
+  return computed(() => vm?.proxy?.$route);
+}

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

@@ -3,92 +3,8 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.useBackButton = useBackButton;
-exports.useLink = useLink;
-exports.useRoute = useRoute;
 exports.useRouter = useRouter;
-var _consts = require("../../consts/index.cjs");
-var _utils = require("../../utils/index.cjs");
-var _vue = require("vue");
-function useRoute() {
-  const vm = (0, _utils.getCurrentInstance)("useRoute");
-  return (0, _vue.computed)(() => vm?.proxy?.$route);
-}
+var _getCurrentInstance = require("../../utils/Commons/getCurrentInstance.util.cjs");
 function useRouter() {
-  return (0, _utils.getCurrentInstance)("useRouter")?.proxy?.$router;
-}
-function useLink(props, attrs) {
-  const RouterLink = (0, _vue.resolveDynamicComponent)("RouterLink");
-  const isLink = (0, _vue.computed)(() => !!(props.href || props.to));
-  const isClickable = (0, _vue.computed)(() => {
-    return isLink?.value || (0, _utils.hasEvent)(attrs, "click") || (0, _utils.hasEvent)(props, "click");
-  });
-  const tag = 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 = 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, _utils.deepEqual)(link.route.value.query, route.value.query);
-    }),
-    href: (0, _vue.computed)(() => props.to ? link?.route.value.href : props.href)
-  };
-}
-let inTransition = false;
-function useBackButton(router, cb) {
-  let popped = false;
-  let removeBefore;
-  let removeAfter;
-  if (_consts.IN_BROWSER) {
-    (0, _vue.nextTick)(() => {
-      window.addEventListener("popstate", onPopstate);
-      if (router) {
-        removeBefore = router.beforeEach((_to, _from, next) => {
-          if (!inTransition) {
-            setTimeout(() => {
-              if (popped) {
-                cb(next);
-              } else {
-                next();
-              }
-            });
-          } else {
-            if (popped) {
-              cb(next);
-            } else {
-              next();
-            }
-          }
-          inTransition = true;
-        });
-        removeAfter = router.afterEach(() => {
-          inTransition = false;
-        });
-      }
-    });
-    (0, _vue.onScopeDispose)(() => {
-      window.removeEventListener("popstate", onPopstate);
-      removeBefore?.();
-      removeAfter?.();
-    });
-  }
-  const onPopstate = e => {
-    if (e.state?.replaced) return;
-    popped = true;
-    setTimeout(() => popped = false);
-  };
+  return (0, _getCurrentInstance.getCurrentInstance)("useRouter")?.proxy?.$router;
 }

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

@@ -1,19 +1,11 @@
-import type { ILink, ILinkProps, ITagProps } from '../../interfaces';
-import { Ref, SetupContext } from 'vue';
-import { NavigationGuardNext, RouteLocationNormalizedLoaded, Router } from 'vue-router';
-/*********************************************************
- * useRoute
- ********************************************************/
-export declare function useRoute(): Ref<RouteLocationNormalizedLoaded | undefined>;
+import type { Router } from 'vue-router';
 /*********************************************************
  * useRouter
+ *
+ * @description
+ * Reads the router instance off the active component instance's proxy
+ * (`$router`), Options-API style — kept separate from `useRoute` so a
+ * consumer that only needs the router instance doesn't pull in the
+ * current-route accessor too.
  ********************************************************/
 export declare function useRouter(): Router | undefined;
-/*********************************************************
- * useLink
- ********************************************************/
-export declare function useLink(props: ILinkProps & ITagProps, attrs: SetupContext['attrs']): ILink;
-/*********************************************************
- * useBackButton
- ********************************************************/
-export declare function useBackButton(router: Router | undefined, cb: (next: NavigationGuardNext) => void): void;

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

@@ -1,85 +1,4 @@
-import { IN_BROWSER } from "../../consts/index.js";
-import { deepEqual, getCurrentInstance, hasEvent } from "../../utils/index.js";
-import { computed, nextTick, onScopeDispose, resolveDynamicComponent, toRef } from "vue";
-export function useRoute() {
-  const vm = getCurrentInstance("useRoute");
-  return computed(() => vm?.proxy?.$route);
-}
+import { getCurrentInstance } from "../../utils/Commons/getCurrentInstance.util.js";
 export function useRouter() {
   return getCurrentInstance("useRouter")?.proxy?.$router;
 }
-export function useLink(props, attrs) {
-  const RouterLink = resolveDynamicComponent("RouterLink");
-  const isLink = computed(() => !!(props.href || props.to));
-  const isClickable = computed(() => {
-    return isLink?.value || hasEvent(attrs, "click") || hasEvent(props, "click");
-  });
-  const tag = 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)
-  };
-}
-let inTransition = false;
-export function useBackButton(router, cb) {
-  let popped = false;
-  let removeBefore;
-  let removeAfter;
-  if (IN_BROWSER) {
-    nextTick(() => {
-      window.addEventListener("popstate", onPopstate);
-      if (router) {
-        removeBefore = router.beforeEach((_to, _from, next) => {
-          if (!inTransition) {
-            setTimeout(() => {
-              if (popped) {
-                cb(next);
-              } else {
-                next();
-              }
-            });
-          } else {
-            if (popped) {
-              cb(next);
-            } else {
-              next();
-            }
-          }
-          inTransition = true;
-        });
-        removeAfter = router.afterEach(() => {
-          inTransition = false;
-        });
-      }
-    });
-    onScopeDispose(() => {
-      window.removeEventListener("popstate", onPopstate);
-      removeBefore?.();
-      removeAfter?.();
-    });
-  }
-  const onPopstate = (e) => {
-    if (e.state?.replaced) return;
-    popped = true;
-    setTimeout(() => popped = false);
-  };
-}

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

@@ -0,0 +1,37 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createRtl = createRtl;
+exports.provideRtl = provideRtl;
+exports.useRtl = useRtl;
+var _vue = require("vue");
+var _locale = require("../../consts/Commons/locale.const.cjs");
+var _getCurrentInstance = require("../../utils/Commons/getCurrentInstance.util.cjs");
+function createRtl(i18n, options) {
+  const rtl = (0, _vue.ref)(options?.rtl ?? _locale.LOCALE_RTL_DEFAULT);
+  const isRtl = (0, _vue.computed)(() => rtl.value[i18n.current.value] ?? false);
+  return {
+    isRtl,
+    rtl
+  };
+}
+function useRtl(name = (0, _getCurrentInstance.getCurrentInstanceName)()) {
+  const locale = (0, _vue.inject)(_locale.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
+  };
+}