origam 2.16.0 → 2.17.1

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

@@ -4,47 +4,55 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.useNested = void 0;
-exports.useNestedGroupActivator = useNestedGroupActivator;
-exports.useNestedItem = useNestedItem;
-var _composables = require("../../composables/index.cjs");
-var _consts = require("../../consts/index.cjs");
-var _enums = require("../../enums/index.cjs");
-var _utils = require("../../utils/index.cjs");
 var _vue = require("vue");
+var _vModel = require("./vModel.composable.cjs");
+var _nested = require("../../consts/Commons/nested.const.cjs");
+var _enums = require("../../enums/index.cjs");
+var _getCurrentInstance = require("../../utils/Commons/getCurrentInstance.util.cjs");
+var _nested2 = require("../../utils/Commons/nested.util.cjs");
 const useNested = props => {
   let isUnmounted = false;
+  let openedTouchedBeforeMount = false;
   const children = (0, _vue.ref)(/* @__PURE__ */new Map());
   const parents = (0, _vue.ref)(/* @__PURE__ */new Map());
   const opened = (0, _vue.ref)(new Set(props.opened));
+  (0, _vue.watch)(() => props.opened, val => {
+    opened.value = new Set(val);
+  });
+  (0, _vue.onMounted)(() => {
+    if (!openedTouchedBeforeMount) {
+      opened.value = new Set(props.opened);
+    }
+  });
   const selectStrategy = (0, _vue.computed)(() => {
     if (typeof props.selectStrategy === "object") return props.selectStrategy;
     switch (props.selectStrategy) {
       case _enums.SELECT_STRATEGY.SINGLE_LEAF:
-        return (0, _utils.leafSingleSelectStrategy)(props.mandatory);
+        return (0, _nested2.leafSingleSelectStrategy)(props.mandatory);
       case _enums.SELECT_STRATEGY.LEAF:
-        return (0, _utils.leafSelectStrategy)(props.mandatory);
+        return (0, _nested2.leafSelectStrategy)(props.mandatory);
       case _enums.SELECT_STRATEGY.INDEPENDENT:
-        return (0, _utils.independentSelectStrategy)(props.mandatory);
+        return (0, _nested2.independentSelectStrategy)(props.mandatory);
       case _enums.SELECT_STRATEGY.SINGLE_INDEPENDENT:
-        return (0, _utils.independentSingleSelectStrategy)(props.mandatory);
+        return (0, _nested2.independentSingleSelectStrategy)(props.mandatory);
       case _enums.SELECT_STRATEGY.CLASSIC:
       default:
-        return (0, _utils.classicSelectStrategy)(props.mandatory);
+        return (0, _nested2.classicSelectStrategy)(props.mandatory);
     }
   });
   const openStrategy = (0, _vue.computed)(() => {
     if (typeof props.openStrategy === "object") return props.openStrategy;
     switch (props.openStrategy) {
       case _enums.OPEN_STRATEGY.LIST:
-        return _consts.LIST_OPEN_STRATEGY;
+        return _nested.LIST_OPEN_STRATEGY;
       case _enums.OPEN_STRATEGY.SINGLE:
-        return _consts.SINGLE_OPEN_STRATEGY;
+        return _nested.SINGLE_OPEN_STRATEGY;
       case _enums.OPEN_STRATEGY.MULTIPLE:
       default:
-        return _consts.MULTIPLE_OPEN_STRATEGY;
+        return _nested.MULTIPLE_OPEN_STRATEGY;
     }
   });
-  const selected = (0, _composables.useVModel)(props, "selected", props.selected, v => selectStrategy.value.in(v, children.value, parents.value), v => selectStrategy.value.out(v, children.value, parents.value));
+  const selected = (0, _vModel.useVModel)(props, "selected", void 0, v => selectStrategy.value.in(v, children.value, parents.value), v => selectStrategy.value.out(v, children.value, parents.value));
   (0, _vue.onBeforeUnmount)(() => {
     isUnmounted = true;
   });
@@ -57,7 +65,7 @@ const useNested = props => {
     }
     return path;
   };
-  const vm = (0, _utils.getCurrentInstance)("nested");
+  const vm = (0, _getCurrentInstance.getCurrentInstance)("nested");
   const nested = {
     id: (0, _vue.shallowRef)(),
     root: {
@@ -110,6 +118,7 @@ const useNested = props => {
           event
         });
         if (newOpened) {
+          openedTouchedBeforeMount = true;
           opened.value = new Set(newOpened);
           vm.emit("update:opened", newOpened);
         }
@@ -125,6 +134,7 @@ const useNested = props => {
           event
         });
         if (newOpened) {
+          openedTouchedBeforeMount = true;
           opened.value = newOpened;
         }
       },
@@ -153,61 +163,7 @@ const useNested = props => {
       parents
     }
   };
-  (0, _vue.provide)(_consts.ORIGAM_NESTED_KEY, nested);
+  (0, _vue.provide)(_nested.ORIGAM_NESTED_KEY, nested);
   return nested.root;
 };
-exports.useNested = useNested;
-function useNestedItem(id, isGroup) {
-  const parent = (0, _vue.inject)(_consts.ORIGAM_NESTED_KEY, _consts.EMPTY_NESTED);
-  const uidSymbol = Symbol((0, _utils.getUid)());
-  const computedId = (0, _vue.computed)(() => id.value !== void 0 ? id.value : uidSymbol);
-  const item = {
-    ...parent,
-    id: computedId,
-    open: (open, e) => {
-      if (parent?.root) {
-        parent.root.open(computedId.value, open, e);
-      }
-    },
-    openOnSelect: (open, e) => {
-      if (parent?.root) {
-        parent.root.openOnSelect(computedId.value, open, e);
-      }
-    },
-    isOpen: (0, _vue.computed)(() => Boolean(parent?.root?.opened.value.has(computedId.value))),
-    parent: (0, _vue.computed)(() => parent?.root?.parents.value.get(computedId.value)),
-    select: (selected, e) => {
-      if (parent?.root) {
-        parent.root.select(computedId.value, selected, e);
-      }
-    },
-    isSelected: (0, _vue.computed)(() => Boolean(parent?.root?.selected.value.get((0, _vue.toRaw)(computedId.value)) === _enums.SELECTED.ON)),
-    isIndeterminate: (0, _vue.computed)(() => Boolean(parent?.root?.selected.value.get(computedId.value) === _enums.SELECTED.INDETERMINATE)),
-    isLeaf: (0, _vue.computed)(() => Boolean(!parent?.root?.children.value.get(computedId.value))),
-    isGroupActivator: parent?.isGroupActivator
-  };
-  if (!parent?.isGroupActivator) {
-    if (parent?.root) {
-      parent.root.register(computedId.value, parent?.id.value, isGroup);
-    }
-  }
-  (0, _vue.onBeforeUnmount)(() => {
-    if (!parent?.isGroupActivator) {
-      if (parent?.root) {
-        parent.root.unregister(computedId.value);
-      }
-    }
-  });
-  if (isGroup) {
-    (0, _vue.provide)(_consts.ORIGAM_NESTED_KEY, item);
-  }
-  return item;
-}
-function useNestedGroupActivator() {
-  const parent = (0, _vue.inject)(_consts.ORIGAM_NESTED_KEY, _consts.EMPTY_NESTED);
-  const item = {
-    ...parent,
-    isGroupActivator: true
-  };
-  (0, _vue.provide)(_consts.ORIGAM_NESTED_KEY, item);
-}
+exports.useNested = useNested;

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

@@ -1,46 +1,26 @@
 import { SELECTED } from '../../enums';
-import type { INestedProps } from '../../interfaces';
-import { Ref } from 'vue';
+import type { INestedProps } from '../../interfaces/Commons/nested.interface';
+/*********************************************************
+ * useNested
+ *
+ * @description
+ * Root of the nested-tree system — tracks children/parents/opened/
+ * selected state and provides `ORIGAM_NESTED_KEY` so `useNestedItem` /
+ * `useNestedGroupActivator` consumers down the tree (list items, tree
+ * nodes, menu items…) can register and read/write back into it.
+ * Independent from `useNestedItem` / `useNestedGroupActivator` at the
+ * call level (no direct function dependency) — the three only share
+ * the `ORIGAM_NESTED_KEY` provide/inject contract.
+ ********************************************************/
 export declare const useNested: (props: INestedProps) => {
-    children: Ref<Map<unknown, Array<unknown>>>;
-    parents: Ref<Map<unknown, unknown>>;
-    opened: Ref<Set<unknown>>;
-    selected: Ref<Map<unknown, `${SELECTED}`>>;
-    selectedValues: Ref<Array<unknown>>;
+    children: import("vue").Ref<Map<unknown, Array<unknown>>>;
+    parents: import("vue").Ref<Map<unknown, unknown>>;
+    opened: import("vue").Ref<Set<unknown>>;
+    selected: import("vue").Ref<Map<unknown, `${SELECTED}`>>;
+    selectedValues: import("vue").Ref<Array<unknown>>;
     register: (id: unknown, parentId: unknown, isGroup?: boolean) => void;
     unregister: (id: unknown) => void;
     open: (id: unknown, value: boolean, event?: Event) => void;
     select: (id: unknown, value: boolean, event?: Event) => void;
     openOnSelect: (id: unknown, value: boolean, event?: Event) => void;
 };
-/*********************************************************
- * useNestedItem
- ********************************************************/
-export declare function useNestedItem(id: Ref<unknown>, isGroup: boolean): {
-    id: import("vue").ComputedRef<{} | null>;
-    open: (open: boolean, e: Event) => void;
-    openOnSelect: (open: boolean, e?: Event) => void;
-    isOpen: import("vue").ComputedRef<boolean>;
-    parent: import("vue").ComputedRef<unknown>;
-    select: (selected: boolean, e?: Event) => void;
-    isSelected: import("vue").ComputedRef<boolean>;
-    isIndeterminate: import("vue").ComputedRef<boolean>;
-    isLeaf: import("vue").ComputedRef<boolean>;
-    isGroupActivator: boolean | undefined;
-    root: {
-        children: Ref<Map<unknown, Array<unknown>>>;
-        parents: Ref<Map<unknown, unknown>>;
-        opened: Ref<Set<unknown>>;
-        selected: Ref<Map<unknown, `${SELECTED}`>>;
-        selectedValues: Ref<Array<unknown>>;
-        register: (id: unknown, parentId: unknown, isGroup?: boolean) => void;
-        unregister: (id: unknown) => void;
-        open: (id: unknown, value: boolean, event?: Event) => void;
-        select: (id: unknown, value: boolean, event?: Event) => void;
-        openOnSelect: (id: unknown, value: boolean, event?: Event) => void;
-    };
-};
-/*********************************************************
- * useNestedGroupActivator
- ********************************************************/
-export declare function useNestedGroupActivator(): void;

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

@@ -1,27 +1,23 @@
-import { useVModel } from "../../composables/index.js";
-import {
-  EMPTY_NESTED,
-  LIST_OPEN_STRATEGY,
-  MULTIPLE_OPEN_STRATEGY,
-  ORIGAM_NESTED_KEY,
-  SINGLE_OPEN_STRATEGY
-} from "../../consts/index.js";
+import { computed, onBeforeUnmount, onMounted, provide, ref, shallowRef, watch } from "vue";
+import { useVModel } from "./vModel.composable.js";
+import { LIST_OPEN_STRATEGY, MULTIPLE_OPEN_STRATEGY, ORIGAM_NESTED_KEY, SINGLE_OPEN_STRATEGY } from "../../consts/Commons/nested.const.js";
 import { OPEN_STRATEGY, SELECTED, SELECT_STRATEGY } from "../../enums/index.js";
-import {
-  classicSelectStrategy,
-  getCurrentInstance,
-  getUid,
-  independentSelectStrategy,
-  independentSingleSelectStrategy,
-  leafSelectStrategy,
-  leafSingleSelectStrategy
-} from "../../utils/index.js";
-import { computed, inject, onBeforeUnmount, provide, ref, shallowRef, toRaw } from "vue";
+import { getCurrentInstance } from "../../utils/Commons/getCurrentInstance.util.js";
+import { classicSelectStrategy, independentSelectStrategy, independentSingleSelectStrategy, leafSelectStrategy, leafSingleSelectStrategy } from "../../utils/Commons/nested.util.js";
 export const useNested = (props) => {
   let isUnmounted = false;
+  let openedTouchedBeforeMount = false;
   const children = ref(/* @__PURE__ */ new Map());
   const parents = ref(/* @__PURE__ */ new Map());
   const opened = ref(new Set(props.opened));
+  watch(() => props.opened, (val) => {
+    opened.value = new Set(val);
+  });
+  onMounted(() => {
+    if (!openedTouchedBeforeMount) {
+      opened.value = new Set(props.opened);
+    }
+  });
   const selectStrategy = computed(() => {
     if (typeof props.selectStrategy === "object") return props.selectStrategy;
     switch (props.selectStrategy) {
@@ -53,7 +49,7 @@ export const useNested = (props) => {
   const selected = useVModel(
     props,
     "selected",
-    props.selected,
+    void 0,
     (v) => selectStrategy.value.in(v, children.value, parents.value),
     (v) => selectStrategy.value.out(v, children.value, parents.value)
   );
@@ -117,6 +113,7 @@ export const useNested = (props) => {
           event
         });
         if (newOpened) {
+          openedTouchedBeforeMount = true;
           opened.value = new Set(newOpened);
           vm.emit("update:opened", newOpened);
         }
@@ -132,6 +129,7 @@ export const useNested = (props) => {
           event
         });
         if (newOpened) {
+          openedTouchedBeforeMount = true;
           opened.value = newOpened;
         }
       },
@@ -158,57 +156,3 @@ export const useNested = (props) => {
   provide(ORIGAM_NESTED_KEY, nested);
   return nested.root;
 };
-export function useNestedItem(id, isGroup) {
-  const parent = inject(ORIGAM_NESTED_KEY, EMPTY_NESTED);
-  const uidSymbol = Symbol(getUid());
-  const computedId = computed(() => id.value !== void 0 ? id.value : uidSymbol);
-  const item = {
-    ...parent,
-    id: computedId,
-    open: (open, e) => {
-      if (parent?.root) {
-        parent.root.open(computedId.value, open, e);
-      }
-    },
-    openOnSelect: (open, e) => {
-      if (parent?.root) {
-        parent.root.openOnSelect(computedId.value, open, e);
-      }
-    },
-    isOpen: computed(() => Boolean(parent?.root?.opened.value.has(computedId.value))),
-    parent: computed(() => parent?.root?.parents.value.get(computedId.value)),
-    select: (selected, e) => {
-      if (parent?.root) {
-        parent.root.select(computedId.value, selected, e);
-      }
-    },
-    isSelected: computed(() => Boolean(parent?.root?.selected.value.get(toRaw(computedId.value)) === SELECTED.ON)),
-    isIndeterminate: computed(() => Boolean(parent?.root?.selected.value.get(computedId.value) === SELECTED.INDETERMINATE)),
-    isLeaf: computed(() => Boolean(!parent?.root?.children.value.get(computedId.value))),
-    isGroupActivator: parent?.isGroupActivator
-  };
-  if (!parent?.isGroupActivator) {
-    if (parent?.root) {
-      parent.root.register(computedId.value, parent?.id.value, isGroup);
-    }
-  }
-  onBeforeUnmount(() => {
-    if (!parent?.isGroupActivator) {
-      if (parent?.root) {
-        parent.root.unregister(computedId.value);
-      }
-    }
-  });
-  if (isGroup) {
-    provide(ORIGAM_NESTED_KEY, item);
-  }
-  return item;
-}
-export function useNestedGroupActivator() {
-  const parent = inject(ORIGAM_NESTED_KEY, EMPTY_NESTED);
-  const item = {
-    ...parent,
-    isGroupActivator: true
-  };
-  provide(ORIGAM_NESTED_KEY, item);
-}

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

@@ -0,0 +1,16 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useNestedGroupActivator = useNestedGroupActivator;
+var _vue = require("vue");
+var _nested = require("../../consts/Commons/nested.const.cjs");
+function useNestedGroupActivator() {
+  const parent = (0, _vue.inject)(_nested.ORIGAM_NESTED_KEY, _nested.EMPTY_NESTED);
+  const item = {
+    ...parent,
+    isGroupActivator: true
+  };
+  (0, _vue.provide)(_nested.ORIGAM_NESTED_KEY, item);
+}

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

@@ -0,0 +1,13 @@
+/*********************************************************
+ * useNestedGroupActivator
+ *
+ * @description
+ * Marks the current provide scope as a "group activator" — the next
+ * `useNestedItem` down the tree reads `isGroupActivator` off the
+ * nearest `ORIGAM_NESTED_KEY` value to skip its own register/unregister
+ * (the activator is a visual proxy for its group, not a node itself).
+ * Independent from `useNested` / `useNestedItem` at the call level (no
+ * direct function dependency) — the three only share the
+ * `ORIGAM_NESTED_KEY` provide/inject contract.
+ ********************************************************/
+export declare function useNestedGroupActivator(): void;

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

@@ -0,0 +1,10 @@
+import { inject, provide } from "vue";
+import { EMPTY_NESTED, ORIGAM_NESTED_KEY } from "../../consts/Commons/nested.const.js";
+export function useNestedGroupActivator() {
+  const parent = inject(ORIGAM_NESTED_KEY, EMPTY_NESTED);
+  const item = {
+    ...parent,
+    isGroupActivator: true
+  };
+  provide(ORIGAM_NESTED_KEY, item);
+}

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

@@ -0,0 +1,56 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useNestedItem = useNestedItem;
+var _vue = require("vue");
+var _nested = require("../../consts/Commons/nested.const.cjs");
+var _enums = require("../../enums/index.cjs");
+var _getCurrentInstance = require("../../utils/Commons/getCurrentInstance.util.cjs");
+function useNestedItem(id, isGroup) {
+  const parent = (0, _vue.inject)(_nested.ORIGAM_NESTED_KEY, _nested.EMPTY_NESTED);
+  const uidSymbol = Symbol((0, _getCurrentInstance.getUid)());
+  const computedId = (0, _vue.computed)(() => id.value !== void 0 ? id.value : uidSymbol);
+  const item = {
+    ...parent,
+    id: computedId,
+    open: (open, e) => {
+      if (parent?.root) {
+        parent.root.open(computedId.value, open, e);
+      }
+    },
+    openOnSelect: (open, e) => {
+      if (parent?.root) {
+        parent.root.openOnSelect(computedId.value, open, e);
+      }
+    },
+    isOpen: (0, _vue.computed)(() => Boolean(parent?.root?.opened.value.has(computedId.value))),
+    parent: (0, _vue.computed)(() => parent?.root?.parents.value.get(computedId.value)),
+    select: (selected, e) => {
+      if (parent?.root) {
+        parent.root.select(computedId.value, selected, e);
+      }
+    },
+    isSelected: (0, _vue.computed)(() => Boolean(parent?.root?.selected.value.get((0, _vue.toRaw)(computedId.value)) === _enums.SELECTED.ON)),
+    isIndeterminate: (0, _vue.computed)(() => Boolean(parent?.root?.selected.value.get(computedId.value) === _enums.SELECTED.INDETERMINATE)),
+    isLeaf: (0, _vue.computed)(() => Boolean(!parent?.root?.children.value.get(computedId.value))),
+    isGroupActivator: parent?.isGroupActivator
+  };
+  if (!parent?.isGroupActivator) {
+    if (parent?.root) {
+      parent.root.register(computedId.value, parent?.id.value, isGroup);
+    }
+  }
+  (0, _vue.onBeforeUnmount)(() => {
+    if (!parent?.isGroupActivator) {
+      if (parent?.root) {
+        parent.root.unregister(computedId.value);
+      }
+    }
+  });
+  if (isGroup) {
+    (0, _vue.provide)(_nested.ORIGAM_NESTED_KEY, item);
+  }
+  return item;
+}

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

@@ -0,0 +1,36 @@
+import type { Ref } from 'vue';
+import { SELECTED } from '../../enums';
+/*********************************************************
+ * useNestedItem
+ *
+ * @description
+ * Registers a single node (list item, tree node, menu item…) against
+ * the nearest `ORIGAM_NESTED_KEY` tree provided by `useNested`.
+ * Independent from `useNested` / `useNestedGroupActivator` at the call
+ * level (no direct function dependency) — the three only share the
+ * `ORIGAM_NESTED_KEY` provide/inject contract.
+ ********************************************************/
+export declare function useNestedItem(id: Ref<unknown>, isGroup: boolean): {
+    id: import("vue").ComputedRef<{} | null>;
+    open: (open: boolean, e: Event) => void;
+    openOnSelect: (open: boolean, e?: Event) => void;
+    isOpen: import("vue").ComputedRef<boolean>;
+    parent: import("vue").ComputedRef<unknown>;
+    select: (selected: boolean, e?: Event) => void;
+    isSelected: import("vue").ComputedRef<boolean>;
+    isIndeterminate: import("vue").ComputedRef<boolean>;
+    isLeaf: import("vue").ComputedRef<boolean>;
+    isGroupActivator: boolean | undefined;
+    root: {
+        children: Ref<Map<unknown, Array<unknown>>>;
+        parents: Ref<Map<unknown, unknown>>;
+        opened: Ref<Set<unknown>>;
+        selected: Ref<Map<unknown, `${SELECTED}`>>;
+        selectedValues: Ref<Array<unknown>>;
+        register: (id: unknown, parentId: unknown, isGroup?: boolean) => void;
+        unregister: (id: unknown) => void;
+        open: (id: unknown, value: boolean, event?: Event) => void;
+        select: (id: unknown, value: boolean, event?: Event) => void;
+        openOnSelect: (id: unknown, value: boolean, event?: Event) => void;
+    };
+};

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

@@ -0,0 +1,50 @@
+import { computed, inject, onBeforeUnmount, provide, toRaw } from "vue";
+import { EMPTY_NESTED, ORIGAM_NESTED_KEY } from "../../consts/Commons/nested.const.js";
+import { SELECTED } from "../../enums/index.js";
+import { getUid } from "../../utils/Commons/getCurrentInstance.util.js";
+export function useNestedItem(id, isGroup) {
+  const parent = inject(ORIGAM_NESTED_KEY, EMPTY_NESTED);
+  const uidSymbol = Symbol(getUid());
+  const computedId = computed(() => id.value !== void 0 ? id.value : uidSymbol);
+  const item = {
+    ...parent,
+    id: computedId,
+    open: (open, e) => {
+      if (parent?.root) {
+        parent.root.open(computedId.value, open, e);
+      }
+    },
+    openOnSelect: (open, e) => {
+      if (parent?.root) {
+        parent.root.openOnSelect(computedId.value, open, e);
+      }
+    },
+    isOpen: computed(() => Boolean(parent?.root?.opened.value.has(computedId.value))),
+    parent: computed(() => parent?.root?.parents.value.get(computedId.value)),
+    select: (selected, e) => {
+      if (parent?.root) {
+        parent.root.select(computedId.value, selected, e);
+      }
+    },
+    isSelected: computed(() => Boolean(parent?.root?.selected.value.get(toRaw(computedId.value)) === SELECTED.ON)),
+    isIndeterminate: computed(() => Boolean(parent?.root?.selected.value.get(computedId.value) === SELECTED.INDETERMINATE)),
+    isLeaf: computed(() => Boolean(!parent?.root?.children.value.get(computedId.value))),
+    isGroupActivator: parent?.isGroupActivator
+  };
+  if (!parent?.isGroupActivator) {
+    if (parent?.root) {
+      parent.root.register(computedId.value, parent?.id.value, isGroup);
+    }
+  }
+  onBeforeUnmount(() => {
+    if (!parent?.isGroupActivator) {
+      if (parent?.root) {
+        parent.root.unregister(computedId.value);
+      }
+    }
+  });
+  if (isGroup) {
+    provide(ORIGAM_NESTED_KEY, item);
+  }
+  return item;
+}

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

@@ -5,12 +5,16 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.usePadding = usePadding;
 var _vue = require("vue");
-var _consts = require("../../consts/index.cjs");
-var _utils = require("../../utils/index.cjs");
+var _padding = require("../../consts/Commons/padding.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 _padding2 = require("../../utils/Commons/padding.util.cjs");
+var _spacing2 = require("../../utils/Commons/spacing.util.cjs");
 function isUtilityPaddingScale(value) {
-  return typeof value === "string" && _consts.SPACING_SCALE_STEPS.includes(value);
+  return typeof value === "string" && _spacing.SPACING_SCALE_STEPS.includes(value);
 }
-function usePadding(props, name = (0, _utils.getCurrentInstanceName)()) {
+function usePadding(props, name = (0, _getCurrentInstance.getCurrentInstanceName)()) {
   const paddingClasses = (0, _vue.computed)(() => {
     const padding = props.padding;
     const classes = [];
@@ -27,29 +31,29 @@ function usePadding(props, name = (0, _utils.getCurrentInstanceName)()) {
     const styles = [];
     if (!isUtilityPaddingScale(padding)) {
       if (typeof padding === "string" && padding !== "") {
-        const match = _consts.PADDING_REGEX.exec(padding)?.groups;
+        const match = _padding.PADDING_REGEX.exec(padding)?.groups;
         if (match) {
           Object.keys(match).forEach(key => {
             const values = String(match[key]).split(" ");
-            styles.push(...(0, _utils.formatPaddingStylesVar)(values));
+            styles.push(...(0, _padding2.formatPaddingStylesVar)(values));
           });
         }
       } else if (typeof padding === "number") {
-        styles.push(`padding: ${(0, _utils.convertToUnit)(padding)}`);
+        styles.push(`padding: ${(0, _commons.convertToUnit)(padding)}`);
       }
     }
-    _consts.PADDING_LOGICAL_AXIS_MAP.forEach(({
+    _spacing.PADDING_LOGICAL_AXIS_MAP.forEach(({
       axis,
       prop
     }) => {
-      const resolved = (0, _utils.resolveSpacingValue)(props[prop]);
+      const resolved = (0, _spacing2.resolveSpacingValue)(props[prop]);
       if (resolved) styles.push(`padding-${axis}: ${resolved}`);
     });
-    _consts.PADDING_POSITION_MAP.forEach(({
+    _spacing.PADDING_POSITION_MAP.forEach(({
       side,
       prop
     }) => {
-      const resolved = (0, _utils.resolveSpacingValue)(props[prop]);
+      const resolved = (0, _spacing2.resolveSpacingValue)(props[prop]);
       if (resolved) styles.push(`padding-${side}: ${resolved}`);
     });
     return styles;

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

@@ -1,4 +1,4 @@
-import type { IPaddingProps } from '../../interfaces';
+import type { IPaddingProps } from '../../interfaces/Commons/padding.interface';
 /*********************************************************
  * usePadding
  *

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

@@ -1,6 +1,10 @@
 import { computed } from "vue";
-import { PADDING_LOGICAL_AXIS_MAP, PADDING_POSITION_MAP, PADDING_REGEX, SPACING_SCALE_STEPS } from "../../consts/index.js";
-import { convertToUnit, formatPaddingStylesVar, getCurrentInstanceName, resolveSpacingValue } from "../../utils/index.js";
+import { PADDING_REGEX } from "../../consts/Commons/padding.const.js";
+import { PADDING_LOGICAL_AXIS_MAP, PADDING_POSITION_MAP, SPACING_SCALE_STEPS } from "../../consts/Commons/spacing.const.js";
+import { convertToUnit } from "../../utils/Commons/commons.util.js";
+import { getCurrentInstanceName } from "../../utils/Commons/getCurrentInstance.util.js";
+import { formatPaddingStylesVar } from "../../utils/Commons/padding.util.js";
+import { resolveSpacingValue } from "../../utils/Commons/spacing.util.js";
 function isUtilityPaddingScale(value) {
   return typeof value === "string" && SPACING_SCALE_STEPS.includes(value);
 }

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

@@ -0,0 +1,18 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.usePassedProps = usePassedProps;
+var _commons = require("../../utils/Commons/commons.util.cjs");
+var _getCurrentInstance = require("../../utils/Commons/getCurrentInstance.util.cjs");
+function usePassedProps(_props, instanceLabel = "usePassedProps") {
+  const vm = (0, _getCurrentInstance.getCurrentInstance)(instanceLabel);
+  return key => {
+    const vnodeProps = vm.vnode.props || {};
+    for (const k in vnodeProps) {
+      if (k === key || (0, _commons.camelize)(k) === key) return vnodeProps[k] !== void 0;
+    }
+    return false;
+  };
+}