origam 0.3.10 → 2.2.1

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

@@ -1,3 +1,13 @@
 import { Ref } from 'vue';
+/**
+ * Resolve unref.
+ *
+ * @param r …
+ */
 export declare function resolveUnref(r: Ref | (() => unknown)): any;
+/**
+ * Unref element.
+ *
+ * @param elRef …
+ */
 export declare function unrefElement(elRef: Ref): any;

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

@@ -1,6 +1,19 @@
 import type { IInternalItem } from '../../interfaces';
 import type { TFilterFunction, TFilterKeyFunctions, TFilterKeys, TFilterMatch, TFilterMode } from '../../types';
+/**
+ * Default filter.
+ *
+ * @param value …
+ * @param query …
+ */
 export declare function defaultFilter(value: string | number, query: string | number): number;
+/**
+ * Filter items.
+ *
+ * @param items   …
+ * @param query   …
+ * @param options …
+ */
 export declare function filterItems(items: readonly (readonly [item: IInternalItem, transformed: Record<string, unknown>])[] | readonly IInternalItem[], query: string, options?: {
     customKeyFilter?: TFilterKeyFunctions;
     default?: TFilterFunction;

package/dist/src/utils/Commons/format-bytes.util.cjs

@@ -0,0 +1,20 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.formatBytes = formatBytes;
+function formatBytes(bytes, decimals = 1) {
+  if (!Number.isFinite(bytes) || bytes <= 0) return "0 B";
+  const base = 1024;
+  if (bytes < base) return `${Math.round(bytes)} B`;
+  const units = ["KB", "MB", "GB", "TB", "PB"];
+  let unit = -1;
+  let value = bytes;
+  while (value >= base && unit < units.length - 1) {
+    value /= base;
+    unit++;
+  }
+  const safeDecimals = Math.max(0, Math.floor(decimals));
+  return `${value.toFixed(safeDecimals)} ${units[unit]}`;
+}

package/dist/src/utils/Commons/format-bytes.util.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Human-readable byte formatter — used by the FileField "showSize" mode and
+ * any consumer that needs to display a file size next to a file name.
+ *
+ * Pure function, no side-effects, no locale-aware formatting (the consumer
+ * is expected to wrap the output in `t(...)` if a translation is needed).
+ *
+ * Convention:
+ *   - Base 1024 (binary), but we still emit the SI suffixes (KB / MB / GB)
+ *     for legibility — this matches the design system's reference deck and
+ *     the existing `humanReadableFileSize(_, 1000 | 1024)` helper.
+ *   - Negative values are clamped to 0 and the sign is dropped (file sizes
+ *     are non-negative by definition).
+ *   - 0 returns the literal `"0 B"` (not `"0 KB"`).
+ *   - Anything below 1024 returns the raw byte count with the `B` unit and
+ *     no decimals (e.g. `1023` → `"1023 B"`).
+ */
+export declare function formatBytes(bytes: number, decimals?: number): string;

package/dist/src/utils/Commons/format-bytes.util.js

@@ -0,0 +1,14 @@
+export function formatBytes(bytes, decimals = 1) {
+  if (!Number.isFinite(bytes) || bytes <= 0) return "0 B";
+  const base = 1024;
+  if (bytes < base) return `${Math.round(bytes)} B`;
+  const units = ["KB", "MB", "GB", "TB", "PB"];
+  let unit = -1;
+  let value = bytes;
+  while (value >= base && unit < units.length - 1) {
+    value /= base;
+    unit++;
+  }
+  const safeDecimals = Math.max(0, Math.floor(decimals));
+  return `${value.toFixed(safeDecimals)} ${units[unit]}`;
+}

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

@@ -1,6 +1,19 @@
 import { ComponentPublicInstance, Ref, UnwrapRef } from 'vue';
 import type { TOmitPrefix, TOmitProps, TUnionToIntersection } from '../../types';
+/**
+ * Forward refs.
+ *
+ * @param target …
+ * @param refs   …
+ * @returns …
+ */
 export declare function forwardRefs<T extends Record<string, unknown>, U extends Ref<HTMLElement | Omit<ComponentPublicInstance, '$emit' | '$slots'> | undefined>[]>(target: T, ...refs: U): T & TUnionToIntersection<{
     [K in keyof U]: TOmitPrefix<TOmitProps<NonNullable<UnwrapRef<U[K]>>>, '$'>;
 }[number]>;
+/**
+ * Get descriptor.
+ *
+ * @param obj …
+ * @param key …
+ */
 export declare function getDescriptor(obj: any, key: PropertyKey): TypedPropertyDescriptor<any> | undefined;

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

@@ -1,7 +1,26 @@
 import type { ComponentInternalInstance } from 'vue';
+/**
+ * Get life cycle target.
+ *
+ * @param target …
+ */
 export declare function getLifeCycleTarget(target?: any): any;
+/**
+ * Get current instance.
+ *
+ * @param name    …
+ * @param message …
+ */
 export declare function getCurrentInstance(name: string, message?: string): ComponentInternalInstance;
+/**
+ * Get current instance name.
+ *
+ * @param name …
+ */
 export declare function getCurrentInstanceName(name?: string): string;
+/**
+ * Get uid.
+ */
 export declare function getUid(): number;
 export declare namespace getUid {
     var reset: () => void;

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

@@ -1,12 +1,43 @@
 import { ComponentPublicInstance } from 'vue';
 import type { IGoToInstance, IGoToOptions } from '../../interfaces';
+/**
+ * Gen defaults.
+ *
+ * @returns …
+ */
 export declare function genDefaults(): Partial<IGoToOptions>;
+/**
+ * Get container.
+ *
+ * @param el …
+ */
 export declare function getContainer(el?: ComponentPublicInstance | HTMLElement | string): HTMLElement;
+/**
+ * Get target.
+ *
+ * @param el …
+ */
 export declare function getTarget(el: ComponentPublicInstance | HTMLElement | string | undefined): HTMLElement | null | undefined;
+/**
+ * Get location offset.
+ *
+ * @param target     …
+ * @param horizontal …
+ * @param rtl        …
+ * @returns …
+ */
 export declare function getLocationOffset(target: any, horizontal?: boolean, rtl?: boolean): number;
 /**
  * Clamp target value to achieve a smooth scroll animation
  * when the value goes outside the scroll container size
  */
 export declare function clampTarget(container: HTMLElement, value: number, horizontal: boolean): number;
+/**
+ * Scroll to.
+ *
+ * @param _target    …
+ * @param _options   …
+ * @param horizontal …
+ * @param goTo       …
+ */
 export declare function scrollTo(_target: ComponentPublicInstance | HTMLElement | number | string, _options: Partial<IGoToOptions>, horizontal?: boolean, goTo?: IGoToInstance): Promise<unknown>;

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

@@ -1,5 +1,23 @@
 import { UnwrapRef } from 'vue';
 import type { IGroupItem } from '../../interfaces';
+/**
+ * Get item index.
+ *
+ * @param items …
+ * @param value …
+ */
 export declare function getItemIndex(items: UnwrapRef<Array<IGroupItem>>, value: unknown): number;
+/**
+ * Get ids.
+ *
+ * @param items      …
+ * @param modelValue …
+ */
 export declare function getIds(items: UnwrapRef<Array<IGroupItem>>, modelValue: Array<any>): number[];
+/**
+ * Get values.
+ *
+ * @param items …
+ * @param ids   …
+ */
 export declare function getValues(items: UnwrapRef<Array<IGroupItem>>, ids: Array<any>): unknown[];

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

@@ -1,8 +1,42 @@
 import type { IHoverDirectiveBinding, IHoverHtmlElement } from '../../interfaces';
 import type { THoverEvent } from '../../types';
+/**
+ * Update hover.
+ *
+ * @param el         …
+ * @param binding    …
+ * @param wasEnabled …
+ * @param name       …
+ */
 export declare function updateHover(el: IHoverHtmlElement, binding: IHoverDirectiveBinding, wasEnabled: boolean, name: string): void;
+/**
+ * Is hover enabled.
+ *
+ * @param value …
+ * @returns …
+ */
 export declare function isHoverEnabled(value: any): value is true;
+/**
+ * Hover show.
+ *
+ * @param e …
+ */
 export declare function hoverShow(e: THoverEvent): void;
+/**
+ * Hover stop.
+ *
+ * @param e …
+ */
 export declare function hoverStop(e: THoverEvent): void;
+/**
+ * Hover hide.
+ *
+ * @param e …
+ */
 export declare function hoverHide(e: Event): void;
+/**
+ * Hover remove listeners.
+ *
+ * @param el …
+ */
 export declare function hoverRemoveListeners(el: IHoverHtmlElement): void;

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

@@ -1,2 +1,8 @@
 import type { IIntersectDirectiveBinding, IIntersectHtmlElement } from '../../interfaces';
+/**
+ * Unmount intersect.
+ *
+ * @param el      …
+ * @param binding …
+ */
 export declare function unmountIntersect(el: IIntersectHtmlElement, binding: IIntersectDirectiveBinding): void;

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

@@ -1,6 +1,15 @@
 import type { Ref } from 'vue';
 import type { ILayer } from '../../interfaces';
 import type { TDirectionBoth } from '../../types';
+/**
+ * Generate layers.
+ *
+ * @param layout      …
+ * @param positions   …
+ * @param layoutSizes …
+ * @param activeItems …
+ * @returns …
+ */
 export declare function generateLayers(layout: Array<string>, positions: Map<string, Ref<TDirectionBoth>>, layoutSizes: Map<string, Ref<number | string>>, activeItems: Map<string, Ref<boolean>>): Array<{
     id: string;
     layer: ILayer;

package/dist/src/utils/Commons/locale.util.cjs

@@ -8,6 +8,12 @@ exports.createVueI18nAdapter = createVueI18nAdapter;
 exports.useProvided = useProvided;
 var _vue = require("vue");
 var _composables = require("../../composables/index.cjs");
+function callI18nT(fn, key, params) {
+  if (typeof key !== "string" || !key) return key;
+  if (!params.length) return fn(key);
+  const list = params.map(p => p == null ? "" : p);
+  return fn(key, list);
+}
 function createVueI18nAdapter({
   i18n,
   useI18n: useI18n2
@@ -20,7 +26,7 @@ function createVueI18nAdapter({
     current,
     fallback,
     messages,
-    t: (key, ...params) => i18n.global.t(key, params),
+    t: (key, ...params) => callI18nT(i18n.global.t.bind(i18n.global), key, params),
     n: i18n.global.n,
     provide: createProvideFunction({
       current,
@@ -51,7 +57,7 @@ function createProvideFunction(data) {
       current,
       fallback,
       messages,
-      t: (key, ...params) => i18n.t(key, params),
+      t: (key, ...params) => callI18nT(i18n.t.bind(i18n), key, params),
       n: i18n.n,
       provide: createProvideFunction({
         current,

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

@@ -1,11 +1,30 @@
 import { ComputedRef, Ref } from "vue";
 import { useI18n } from "vue-i18n";
 import type { ILocaleI18n, ILocaleInstance, ILocaleMessages, ILocaleProps } from "../../interfaces";
+/**
+ * Create vue i 18 n adapter.
+ *
+ * @param options …
+ * @returns …
+ */
 export declare function createVueI18nAdapter({ i18n, useI18n }: ILocaleI18n): ILocaleInstance;
+/**
+ * Create provide function.
+ *
+ * @param data …
+ */
 export declare function createProvideFunction(data: {
     current: Ref<string>;
     fallback: Ref<string>;
     messages: ComputedRef<ILocaleMessages>;
     useI18n: typeof useI18n;
 }): (props: ILocaleProps) => ILocaleInstance;
+/**
+ * Use provided.
+ *
+ * @param props    …
+ * @param prop     …
+ * @param provided …
+ * @returns …
+ */
 export declare function useProvided<T>(props: any, prop: string, provided: Ref<T>): Ref<T>;

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

@@ -1,5 +1,11 @@
 import { watch } from "vue";
 import { useVModel } from "../../composables/index.js";
+function callI18nT(fn, key, params) {
+  if (typeof key !== "string" || !key) return key;
+  if (!params.length) return fn(key);
+  const list = params.map((p) => p == null ? "" : p);
+  return fn(key, list);
+}
 export function createVueI18nAdapter({ i18n, useI18n: useI18n2 }) {
   const current = i18n.global.locale;
   const fallback = i18n.global.fallbackLocale;
@@ -9,7 +15,7 @@ export function createVueI18nAdapter({ i18n, useI18n: useI18n2 }) {
     current,
     fallback,
     messages,
-    t: (key, ...params) => i18n.global.t(key, params),
+    t: (key, ...params) => callI18nT(i18n.global.t.bind(i18n.global), key, params),
     n: i18n.global.n,
     provide: createProvideFunction({ current, fallback, messages, useI18n: useI18n2 })
   };
@@ -35,7 +41,7 @@ export function createProvideFunction(data) {
       current,
       fallback,
       messages,
-      t: (key, ...params) => i18n.t(key, params),
+      t: (key, ...params) => callI18nT(i18n.t.bind(i18n), key, params),
       n: i18n.n,
       provide: createProvideFunction({ current, fallback, messages, useI18n: data.useI18n })
     };

package/dist/src/utils/Commons/location.util.cjs

@@ -79,7 +79,7 @@ function connectedLocationStrategy(data, props, contentStyles) {
     const targetBox = (0, _utils.getTargetBox)(data.target.value);
     const contentBox = getIntrinsicSize(data.contentEl.value);
     const scrollParents = (0, _utils.getScrollParents)(data.contentEl.value);
-    const viewportMargin = 12;
+    const viewportMargin = props.viewportMargin ?? 12;
     if (!scrollParents.length) {
       scrollParents.push(document.documentElement);
       if (!(data.contentEl.value.style.top && data.contentEl.value.style.left)) {

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

@@ -1,6 +1,16 @@
 import { Ref } from 'vue';
 import type { IBox, ILocationStrategyData, ILocationStrategyProps } from '../../interfaces';
+/**
+ * Static location strategy.
+ */
 export declare function staticLocationStrategy(): void;
+/**
+ * Connected location strategy.
+ *
+ * @param data          …
+ * @param props         …
+ * @param contentStyles …
+ */
 export declare function connectedLocationStrategy(data: ILocationStrategyData, props: ILocationStrategyProps, contentStyles: Ref<Record<string, string>>): {
     updateLocation: () => {
         available: {
@@ -12,6 +22,21 @@ export declare function connectedLocationStrategy(data: ILocationStrategyData, p
 };
 /** Get size of element ignoring max-width/max-height */
 export declare function getIntrinsicSize(el: HTMLElement): IBox;
+/**
+ * Pixel round.
+ *
+ * @param val …
+ */
 export declare function pixelRound(val: number): number;
+/**
+ * Pixel ceil.
+ *
+ * @param val …
+ */
 export declare function pixelCeil(val: number): number;
+/**
+ * Is fixed position.
+ *
+ * @param el …
+ */
 export declare function isFixedPosition(el?: HTMLElement): boolean;

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

@@ -82,7 +82,7 @@ export function connectedLocationStrategy(data, props, contentStyles) {
     const targetBox = getTargetBox(data.target.value);
     const contentBox = getIntrinsicSize(data.contentEl.value);
     const scrollParents = getScrollParents(data.contentEl.value);
-    const viewportMargin = 12;
+    const viewportMargin = props.viewportMargin ?? 12;
     if (!scrollParents.length) {
       scrollParents.push(document.documentElement);
       if (!(data.contentEl.value.style.top && data.contentEl.value.style.left)) {

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

@@ -1 +1,6 @@
+/**
+ * Format margin styles var.
+ *
+ * @param values …
+ */
 export declare function formatMarginStylesVar(values: Array<string>): never[];

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

@@ -1,6 +1,36 @@
 import type { TStrategySelect } from '../../types';
+/**
+ * Independent select strategy.
+ *
+ * @param mandatory …
+ * @returns …
+ */
 export declare function independentSelectStrategy(mandatory?: boolean): TStrategySelect;
+/**
+ * Independent single select strategy.
+ *
+ * @param mandatory …
+ * @returns …
+ */
 export declare function independentSingleSelectStrategy(mandatory?: boolean): TStrategySelect;
+/**
+ * Leaf select strategy.
+ *
+ * @param mandatory …
+ * @returns …
+ */
 export declare function leafSelectStrategy(mandatory?: boolean): TStrategySelect;
+/**
+ * Leaf single select strategy.
+ *
+ * @param mandatory …
+ * @returns …
+ */
 export declare function leafSingleSelectStrategy(mandatory?: boolean): TStrategySelect;
+/**
+ * Classic select strategy.
+ *
+ * @param mandatory …
+ * @returns …
+ */
 export declare function classicSelectStrategy(mandatory?: boolean): TStrategySelect;

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

@@ -1 +1,6 @@
+/**
+ * Format padding styles var.
+ *
+ * @param values …
+ */
 export declare function formatPaddingStylesVar(values: Array<string>): never[];

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

@@ -1,5 +1,11 @@
 import type { IBox } from '../../interfaces';
 import type { TElementPoint, TOffset, TParsedAnchor, TPoint, TViewportPoint } from '../../types';
+/**
+ * Element to viewport.
+ *
+ * @param point  …
+ * @param offset …
+ */
 export declare function elementToViewport(point: TElementPoint, offset: TOffset | IBox): TViewportPoint;
 /** Convert a point in viewport space to local space */
 export declare function viewportToElement(point: TViewportPoint, offset: TOffset | IBox): TElementPoint;
@@ -7,5 +13,16 @@ export declare function viewportToElement(point: TViewportPoint, offset: TOffset
 export declare function getOffset<T extends TPoint>(a: T, b: T): TOffset;
 /** Convert an anchor object to a point in local space */
 export declare function anchorToPoint(anchor: TParsedAnchor, box: IBox): TViewportPoint;
+/**
+ * In viewport.
+ *
+ * @param element …
+ */
 export declare function inViewport(element: IBox | DOMRect): boolean;
+/**
+ * Get center.
+ *
+ * @param element …
+ * @returns …
+ */
 export declare function getCenter(element: IBox | DOMRect): TPoint;

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

@@ -1,9 +1,41 @@
 import type { IRippleDirectiveBinding, IRippleHtmlElement, IRippleOptions } from '../../interfaces';
 import type { TRippleEvent } from '../../types';
+/**
+ * Update ripple.
+ *
+ * @param el         …
+ * @param binding    …
+ * @param wasEnabled …
+ */
 export declare function updateRipple(el: IRippleHtmlElement, binding: IRippleDirectiveBinding, wasEnabled: boolean): void;
+/**
+ * Is ripple enabled.
+ *
+ * @param value …
+ * @returns …
+ */
 export declare function isRippleEnabled(value: any): value is true;
+/**
+ * Is touch event.
+ *
+ * @param e …
+ * @returns …
+ */
 export declare function isTouchEvent(e: TRippleEvent): e is TouchEvent;
+/**
+ * Is keyboard event.
+ *
+ * @param e …
+ * @returns …
+ */
 export declare function isKeyboardEvent(e: TRippleEvent): e is KeyboardEvent;
+/**
+ * Calculate.
+ *
+ * @param e     …
+ * @param el    …
+ * @param value …
+ */
 export declare function calculate(e: TRippleEvent, el: IRippleHtmlElement, value?: IRippleOptions): {
     radius: number;
     scale: number;
@@ -12,12 +44,58 @@ export declare function calculate(e: TRippleEvent, el: IRippleHtmlElement, value
     centerX: string;
     centerY: string;
 };
+/**
+ * Ripple show.
+ *
+ * @param e …
+ */
 export declare function rippleShow(e: TRippleEvent): void;
+/**
+ * Ripple stop.
+ *
+ * @param e …
+ */
 export declare function rippleStop(e: TRippleEvent): void;
+/**
+ * Ripple hide.
+ *
+ * @param e …
+ */
 export declare function rippleHide(e: Event): void;
+/**
+ * Ripple cancel show.
+ *
+ * @param e …
+ */
 export declare function rippleCancelShow(e: MouseEvent | TouchEvent): void;
+/**
+ * Ripple remove listeners.
+ *
+ * @param el …
+ */
 export declare function rippleRemoveListeners(el: IRippleHtmlElement): void;
+/**
+ * Ripple transform.
+ *
+ * @param el    …
+ * @param value …
+ */
 export declare function rippleTransform(el: IRippleHtmlElement, value: string): void;
+/**
+ * Keyboard ripple show.
+ *
+ * @param e …
+ */
 export declare function keyboardRippleShow(e: KeyboardEvent): void;
+/**
+ * Keyboard ripple hide.
+ *
+ * @param e …
+ */
 export declare function keyboardRippleHide(e: KeyboardEvent): void;
+/**
+ * Focus ripple hide.
+ *
+ * @param e …
+ */
 export declare function focusRippleHide(e: FocusEvent): void;

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

@@ -1 +1,6 @@
+/**
+ * Format rounded styles var.
+ *
+ * @param values …
+ */
 export declare function formatRoundedStylesVar(values: Array<string>): never[];

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

@@ -1,10 +1,56 @@
 import type { IScrollStrategyData, IScrollStrategyProps } from '../../interfaces';
 import { EffectScope } from 'vue';
+/**
+ * Get scroll parent.
+ *
+ * @param el            …
+ * @param includeHidden …
+ */
 export declare function getScrollParent(el?: HTMLElement, includeHidden?: boolean): HTMLElement;
+/**
+ * Get scroll parents.
+ *
+ * @param el     …
+ * @param stopAt …
+ */
 export declare function getScrollParents(el?: Element | null, stopAt?: Element | null): HTMLElement[];
+/**
+ * Has scrollbar.
+ *
+ * @param el …
+ */
 export declare function hasScrollbar(el?: Element | null): boolean;
+/**
+ * Is potentially scrollable.
+ *
+ * @param el …
+ */
 export declare function isPotentiallyScrollable(el?: Element | null): boolean;
+/**
+ * Close scroll strategy.
+ *
+ * @param data …
+ */
 export declare function closeScrollStrategy(data: IScrollStrategyData): void;
+/**
+ * Block scroll strategy.
+ *
+ * @param data  …
+ * @param props …
+ */
 export declare function blockScrollStrategy(data: IScrollStrategyData, props: IScrollStrategyProps): void;
+/**
+ * Reposition scroll strategy.
+ *
+ * @param data   …
+ * @param _props …
+ * @param scope  …
+ */
 export declare function repositionScrollStrategy(data: IScrollStrategyData, _props: IScrollStrategyProps, scope: EffectScope): void;
+/**
+ * Bind scroll.
+ *
+ * @param el       …
+ * @param onScroll …
+ */
 export declare function bindScroll(el: HTMLElement | undefined, onScroll: (e: Event) => void): void;