vevet 3.20.0 → 4.0.0-beta.1

package/lib/types/utils/image/load.d.ts

@@ -1,28 +1,31 @@
 import { PCancelable } from '../common/PCancelable';
-type TLoadImageProps = {
+/** Image loading options */
+export type TLoadImageProps = {
     /**
+     * Specifies the `crossOrigin` attribute for the image.
+     * Can be `null` or a string such as 'anonymous' or 'use-credentials'.
      * @default null
      */
     crossOrigin?: string | null;
     /**
+     * When set to `true`, the image will be cached in memory and will not be loaded again for subsequent requests.
      * @default false
      */
     useCache?: boolean;
 };
 /**
- * Load an image
+ * Loads an image from a given source, either a URL or an HTMLImageElement.
+ * Supports caching and handling cross-origin requests.
  *
  * @example
- *
  * const loaderWithoutCache = loadImage('/image.jpg');
- *
  * loaderWithoutCache.then((img) => console.log(img)).catch(() => {});
  *
  * const loaderWithCache = loadImage('/image.jpg', {
  *   crossOrigin: 'anonymous',
  *   useCache: true,
  * });
+ * loaderWithCache.then((img) => console.log(img)).catch(() => {});
  */
 export declare function loadImage(source: string | HTMLImageElement, props?: TLoadImageProps): PCancelable<HTMLImageElement>;
-export {};
 //# sourceMappingURL=load.d.ts.map

package/lib/types/utils/image/load.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"load.d.ts","sourceRoot":"","sources":["../../../../src/utils/image/load.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAC;AAOzD,KAAK,eAAe,GAAG;IACrB;;OAEG;IACH,WAAW,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5B;;OAEG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB,CAAC;AAEF;;;;;;;;;;;;;GAaG;AACH,wBAAgB,SAAS,CACvB,MAAM,EAAE,MAAM,GAAG,gBAAgB,EACjC,KAAK,CAAC,EAAE,eAAe,iCAgExB"}
+{"version":3,"file":"load.d.ts","sourceRoot":"","sources":["../../../../src/utils/image/load.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAC;AAOzD,4BAA4B;AAC5B,MAAM,MAAM,eAAe,GAAG;IAC5B;;;;OAIG;IACH,WAAW,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5B;;;OAGG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB,CAAC;AAEF;;;;;;;;;;;;;GAaG;AACH,wBAAgB,SAAS,CACvB,MAAM,EAAE,MAAM,GAAG,gBAAgB,EACjC,KAAK,CAAC,EAAE,eAAe,iCAiExB"}

package/lib/types/utils/image/pathsToProps.d.ts

@@ -8,17 +8,23 @@ export interface IImageAdaptivePaths<S extends Record<string | number, string> =
     sizesWebp?: S;
 }
 /**
- * Transform image paths to properties
+ * Transforms image paths into properties for use in `src` and `srcSet` attributes.
+ * Supports adaptive images with WebP and fallback formats.
  *
- * @example
+ * Depending on WebP support, this function selects the most appropriate image for `src`
+ * and generates the `srcSet` if adaptive image sizes are provided.
  *
+ * @example
+ * // Basic usage with original, thumb, and thumbWebp paths
  * imagePathsToProps({
  *   original: '/original.jpg',
  *   thumb: '/thumb.jpg',
  *   thumbWebp: '/thumb.webp',
  * });
- * // => {"src":"/thumb.webp","srcSet":""}
+ * // => { src: '/thumb.webp', srcSet: '' }
  *
+ * @example
+ * // Usage with adaptive sizes for different screen widths
  * imagePathsToProps({
  *   original: '/original.jpg',
  *   thumb: '/thumb.jpg',
@@ -40,7 +46,7 @@ export interface IImageAdaptivePaths<S extends Record<string | number, string> =
  *     2560: '/2560.webp',
  *   },
  * });
- * // => {"src":"/thumb.webp","srcSet":"/640.webp 640w, /750.webp 750w, /1024.webp 1024w, /1440.webp 1440w, /1920.webp 1920w, /2560.webp 2560w"}
+ * // => { src: '/thumb.webp', srcSet: '/640.webp 640w, /750.webp 750w, /1024.webp 1024w, /1440.webp 1440w, /1920.webp 1920w, /2560.webp 2560w' }
  */
 export declare function imagePathsToProps(data: IImagePaths | IImageAdaptivePaths): {
     src: string;

package/lib/types/utils/image/pathsToProps.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"pathsToProps.d.ts","sourceRoot":"","sources":["../../../../src/utils/image/pathsToProps.ts"],"names":[],"mappings":"AAGA,MAAM,WAAW,WAAW;IAC1B,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,mBAAmB,CAClC,CAAC,SAAS,MAAM,CAAC,MAAM,GAAG,MAAM,EAAE,MAAM,CAAC,GAAG,EAAE,CAC9C,SAAQ,WAAW;IACnB,KAAK,CAAC,EAAE,CAAC,CAAC;IACV,SAAS,CAAC,EAAE,CAAC,CAAC;CACf;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,WAAW,GAAG,mBAAmB;;;EAyBxE"}
+{"version":3,"file":"pathsToProps.d.ts","sourceRoot":"","sources":["../../../../src/utils/image/pathsToProps.ts"],"names":[],"mappings":"AAGA,MAAM,WAAW,WAAW;IAC1B,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,mBAAmB,CAClC,CAAC,SAAS,MAAM,CAAC,MAAM,GAAG,MAAM,EAAE,MAAM,CAAC,GAAG,EAAE,CAC9C,SAAQ,WAAW;IACnB,KAAK,CAAC,EAAE,CAAC,CAAC;IACV,SAAS,CAAC,EAAE,CAAC,CAAC;CACf;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,WAAW,GAAG,mBAAmB;;;EAyBxE"}

package/lib/types/utils/image/sizesToSrcSet.d.ts

@@ -1,15 +1,19 @@
 /**
- * Transform image sizes to src set
+ * Transforms an object of image sizes into a `srcSet` string suitable for
+ * responsive images using the `srcSet` attribute.
  *
- * @example
+ * Each key in the `sizes` object represents a width in pixels, and the associated value is the image URL.
+ *
+ * @param {Record<string | number, string>} sizes - An object where the keys are widths (in pixels) and the values are URLs for the images.
+ * @returns {string} A `srcSet` string, where each image URL is followed by its width (e.g., "640w").
  *
+ * @example
  * imageSizesToSrcSet({
  *   640: '/640.jpg',
  *   750: '/750.jpg',
  *   1024: '/1024.jpg',
  *   1440: '/1440.jpg',
  * });
- *
  * // => "/640.jpg 640w, /750.jpg 750w, /1024.jpg 1024w, /1440.jpg 1440w"
  */
 export declare function imageSizesToSrcSet(sizes: Record<string | number, string>): string;

package/lib/types/utils/image/sizesToSrcSet.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sizesToSrcSet.d.ts","sourceRoot":"","sources":["../../../../src/utils/image/sizesToSrcSet.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,GAAG,MAAM,EAAE,MAAM,CAAC,UAYxE"}
+{"version":3,"file":"sizesToSrcSet.d.ts","sourceRoot":"","sources":["../../../../src/utils/image/sizesToSrcSet.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,GAAG,MAAM,EAAE,MAAM,CAAC,UAYxE"}

package/lib/types/utils/internal/getApp.d.ts

@@ -1,2 +1,2 @@
-export declare function getApp(): import("../..").Application;
+export declare function getApp(): import("../..").IVevet;
 //# sourceMappingURL=getApp.d.ts.map

package/lib/types/utils/internal/getApp.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"getApp.d.ts","sourceRoot":"","sources":["../../../../src/utils/internal/getApp.ts"],"names":[],"mappings":"AAAA,wBAAgB,MAAM,gCAErB"}
+{"version":3,"file":"getApp.d.ts","sourceRoot":"","sources":["../../../../src/utils/internal/getApp.ts"],"names":[],"mappings":"AAEA,wBAAgB,MAAM,2BAUrB"}

package/lib/types/utils/listeners/isIntersectionObserverSupported.d.ts

@@ -1,5 +1,5 @@
 /**
- * Check if intersection observer is supported
+ * Check if `IntersectionObserver` is supported
  */
 export declare function isIntersectionObserverSupported(): boolean;
 //# sourceMappingURL=isIntersectionObserverSupported.d.ts.map

package/lib/types/utils/listeners/onResize.d.ts

@@ -1,5 +1,5 @@
-import { NViewport } from '../../Application/events/createViewport';
-export type TOnResizeTarget = keyof NViewport.ICallbacksTypes;
+import { IViewportCallbackTypes } from '../../Vevet/events/createViewport/types';
+export type TOnResizeTarget = keyof IViewportCallbackTypes;
 export interface IOnResizeCallbackProps {
     trigger: 'unknown' | 'Viewport' | 'ResizeObserver';
 }
@@ -11,13 +11,12 @@ export interface IOnResizeProps {
     element?: Element | Element[] | false;
     /**
      * Viewport target on resize.
-     * It will be used if `element` is not provided
-     * or `ResizeObserver` is not supported.
+     * It will be used if `element` is not provided or `ResizeObserver` is not supported.
      * @default 'any'
      */
     viewportTarget?: TOnResizeTarget;
     /**
-     * Has both `vewport resize` and `ResizeObserver`
+     * Has both `viewport` callbacks and `ResizeObserver`
      * @default false
      */
     hasBothEvents?: boolean;
@@ -38,9 +37,9 @@ export interface IOnResize {
     hasResizeObserver: boolean;
 }
 /**
- * Add events on resize.
- * If `element` is provided, `ResizeObserver` will be used (first callback will not be fired).
- * Otherwise, viewport callbacks will be used.
+ * Adds resize event listeners to either an element (using `ResizeObserver`) or the viewport (using custom resize events).
+ * It handles debouncing and allows the removal of listeners when no longer needed.
+ * If both `element` and `hasBothEvents` are provided, both `ResizeObserver` and viewport resize events will be used.
  *
  * @example
  *
@@ -48,18 +47,18 @@ export interface IOnResize {
  *   onResize: () => console.log('resize'),
  *   element: document.getElementById('app')!,
  *   viewportTarget: 'any',
- *   hasBothEvents: true,   // trace both element and viewport sizes
+ *   hasBothEvents: true,   // Trace both element and viewport sizes
  *   resizeDebounce: 100,
  * });
  *
- * // resize with timeout called twice, but `onResize` will be called only once
+ * // Trigger resize with debounce
  * handler.debounceResize();
  * handler.debounceResize();
  *
- * // resize without timeout
+ * // Trigger resize without debounce
  * handler.resize();
  *
- * // remove listeners
+ * // Remove listeners
  * handler.remove();
  */
 export declare function onResize({ onResize: handleResize, element, viewportTarget, hasBothEvents, resizeDebounce, }: IOnResizeProps): IOnResize;

package/lib/types/utils/listeners/onResize.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"onResize.d.ts","sourceRoot":"","sources":["../../../../src/utils/listeners/onResize.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AAIpE,MAAM,MAAM,eAAe,GAAG,MAAM,SAAS,CAAC,eAAe,CAAC;AAE9D,MAAM,WAAW,sBAAsB;IACrC,OAAO,EAAE,SAAS,GAAG,UAAU,GAAG,gBAAgB,CAAC;CACpD;AAED,MAAM,MAAM,iBAAiB,GAAG,CAAC,KAAK,EAAE,sBAAsB,KAAK,IAAI,CAAC;AAExE,MAAM,WAAW,cAAc;IAC7B,yBAAyB;IACzB,QAAQ,EAAE,iBAAiB,CAAC;IAC5B,yBAAyB;IACzB,OAAO,CAAC,EAAE,OAAO,GAAG,OAAO,EAAE,GAAG,KAAK,CAAC;IACtC;;;;;OAKG;IACH,cAAc,CAAC,EAAE,eAAe,CAAC;IACjC;;;OAGG;IACH,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB;;;OAGG;IACH,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB;AAED,MAAM,WAAW,SAAS;IACxB,2BAA2B;IAC3B,MAAM,EAAE,MAAM,IAAI,CAAC;IACnB,6BAA6B;IAC7B,MAAM,EAAE,MAAM,IAAI,CAAC;IACnB,2CAA2C;IAC3C,cAAc,EAAE,MAAM,IAAI,CAAC;IAC3B,gCAAgC;IAChC,iBAAiB,EAAE,OAAO,CAAC;CAC5B;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,QAAQ,CAAC,EACvB,QAAQ,EAAE,YAAY,EACtB,OAAO,EACP,cAAsB,EACtB,aAAqB,EACrB,cAAkB,GACnB,EAAE,cAAc,GAAG,SAAS,CA8D5B"}
+{"version":3,"file":"onResize.d.ts","sourceRoot":"","sources":["../../../../src/utils/listeners/onResize.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,sBAAsB,EAAE,MAAM,yCAAyC,CAAC;AAEjF,MAAM,MAAM,eAAe,GAAG,MAAM,sBAAsB,CAAC;AAE3D,MAAM,WAAW,sBAAsB;IACrC,OAAO,EAAE,SAAS,GAAG,UAAU,GAAG,gBAAgB,CAAC;CACpD;AAED,MAAM,MAAM,iBAAiB,GAAG,CAAC,KAAK,EAAE,sBAAsB,KAAK,IAAI,CAAC;AAExE,MAAM,WAAW,cAAc;IAC7B,yBAAyB;IACzB,QAAQ,EAAE,iBAAiB,CAAC;IAC5B,yBAAyB;IACzB,OAAO,CAAC,EAAE,OAAO,GAAG,OAAO,EAAE,GAAG,KAAK,CAAC;IACtC;;;;OAIG;IACH,cAAc,CAAC,EAAE,eAAe,CAAC;IACjC;;;OAGG;IACH,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB;;;OAGG;IACH,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB;AAED,MAAM,WAAW,SAAS;IACxB,2BAA2B;IAC3B,MAAM,EAAE,MAAM,IAAI,CAAC;IACnB,6BAA6B;IAC7B,MAAM,EAAE,MAAM,IAAI,CAAC;IACnB,2CAA2C;IAC3C,cAAc,EAAE,MAAM,IAAI,CAAC;IAC3B,gCAAgC;IAChC,iBAAiB,EAAE,OAAO,CAAC;CAC5B;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,QAAQ,CAAC,EACvB,QAAQ,EAAE,YAAY,EACtB,OAAO,EACP,cAAsB,EACtB,aAAqB,EACrB,cAAkB,GACnB,EAAE,cAAc,GAAG,SAAS,CA0D5B"}

package/lib/types/utils/math/clamp.d.ts

@@ -1,10 +1,15 @@
 /**
- * Clamp the value between two points
+ * Clamp the value between two points.
+ * Ensures that `value` is between the minimum and maximum of the provided `scope`.
+ *
+ * @param value - The value to be clamped.
+ * @param scope - The range to clamp the value between, defaulting to [0, 1].
  *
  * @example
  *
  * clamp(1.5, [0.1, 0.9]); // => 0.9
  * clamp(0.001, [0.1, 0.9]); // => 0.1
+ * clamp(0.5, [0, 1]); // => 0.5
  */
-export declare function clamp(val: number, scope?: number[]): number;
+export declare function clamp(value: number, scope?: number[]): number;
 //# sourceMappingURL=clamp.d.ts.map

package/lib/types/utils/math/clamp.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"clamp.d.ts","sourceRoot":"","sources":["../../../../src/utils/math/clamp.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,wBAAgB,KAAK,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,WAAS,UAShD"}
+{"version":3,"file":"clamp.d.ts","sourceRoot":"","sources":["../../../../src/utils/math/clamp.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,wBAAgB,KAAK,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,WAAS,GAAG,MAAM,CAS3D"}

package/lib/types/utils/math/clampScope.d.ts

@@ -1,5 +1,12 @@
 /**
- * Get progress relatively to the scope and clamp it within two points
+ * Get progress relative to a given scope and then clamp it within another range.
+ *
+ * The function first scales the `value` relative to `scopeProp` using the `scoped` function,
+ * and then clamps the result within `clampProp` using the `clamp` function.
+ *
+ * @param value - The value to be scaled and clamped.
+ * @param scopeProp - The scope within which the value will be scaled.
+ * @param clampProp - The range to clamp the scaled value within.
  *
  * @example
  *

package/lib/types/utils/math/clampScope.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"clampScope.d.ts","sourceRoot":"","sources":["../../../../src/utils/math/clampScope.ts"],"names":[],"mappings":"AAGA;;;;;;;GAOG;AACH,wBAAgB,UAAU,CACxB,KAAK,EAAE,MAAM,EACb,SAAS,WAAS,EAClB,SAAS,WAAS,UAGnB"}
+{"version":3,"file":"clampScope.d.ts","sourceRoot":"","sources":["../../../../src/utils/math/clampScope.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,UAAU,CACxB,KAAK,EAAE,MAAM,EACb,SAAS,WAAS,EAClB,SAAS,WAAS,GACjB,MAAM,CAER"}

package/lib/types/utils/math/easing.d.ts

@@ -2,7 +2,10 @@ import { easing as easingProgress } from 'easing-progress';
 export { EaseInBack, EaseInBounce, EaseInCirc, EaseInCubic, EaseInElastic, EaseInExpo, EaseInOutBack, EaseInOutBounce, EaseInOutCirc, EaseInOutCubic, EaseInOutElastic, EaseInOutExpo, EaseInOutQuad, EaseInOutQuart, EaseInOutQuint, EaseInOutSine, EaseInQuad, EaseInQuart, EaseInQuint, EaseInSine, EaseOutBack, EaseOutBounce, EaseOutCirc, EaseOutCubic, EaseOutElastic, EaseOutExpo, EaseOutQuad, EaseOutQuart, EaseOutQuint, EaseOutSine, } from 'easing-progress';
 export type { TEasingBezier, TEasingFunction, TEasingType, } from 'easing-progress';
 /**
- * Easing progress
+ * Calculates easing progress using a specified easing function, bezier curve, or custom easing function.
+ *
+ * @param progress - The current progress value (between 0 and 1).
+ * @param easingType - The easing type to apply. It can be a predefined easing function, a bezier array, or a custom easing function. Defaults to the global app's easing settings if available.
  *
  * @example
  *

package/lib/types/utils/math/easing.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"easing.d.ts","sourceRoot":"","sources":["../../../../src/utils/math/easing.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,IAAI,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAG3D,OAAO,EACL,UAAU,EACV,YAAY,EACZ,UAAU,EACV,WAAW,EACX,aAAa,EACb,UAAU,EACV,aAAa,EACb,eAAe,EACf,aAAa,EACb,cAAc,EACd,gBAAgB,EAChB,aAAa,EACb,aAAa,EACb,cAAc,EACd,cAAc,EACd,aAAa,EACb,UAAU,EACV,WAAW,EACX,WAAW,EACX,UAAU,EACV,WAAW,EACX,aAAa,EACb,WAAW,EACX,YAAY,EACZ,cAAc,EACd,WAAW,EACX,WAAW,EACX,YAAY,EACZ,YAAY,EACZ,WAAW,GACZ,MAAM,iBAAiB,CAAC;AAEzB,YAAY,EACV,aAAa,EACb,eAAe,EACf,WAAW,GACZ,MAAM,iBAAiB,CAAC;AAEzB;;;;;;;;GAQG;AACH,eAAO,MAAM,MAAM,EAAE,OAAO,cAGa,CAAC"}
+{"version":3,"file":"easing.d.ts","sourceRoot":"","sources":["../../../../src/utils/math/easing.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,IAAI,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAG3D,OAAO,EACL,UAAU,EACV,YAAY,EACZ,UAAU,EACV,WAAW,EACX,aAAa,EACb,UAAU,EACV,aAAa,EACb,eAAe,EACf,aAAa,EACb,cAAc,EACd,gBAAgB,EAChB,aAAa,EACb,aAAa,EACb,cAAc,EACd,cAAc,EACd,aAAa,EACb,UAAU,EACV,WAAW,EACX,WAAW,EACX,UAAU,EACV,WAAW,EACX,aAAa,EACb,WAAW,EACX,YAAY,EACZ,cAAc,EACd,WAAW,EACX,WAAW,EACX,YAAY,EACZ,YAAY,EACZ,WAAW,GACZ,MAAM,iBAAiB,CAAC;AAEzB,YAAY,EACV,aAAa,EACb,eAAe,EACf,WAAW,GACZ,MAAM,iBAAiB,CAAC;AAEzB;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,MAAM,EAAE,OAAO,cAGa,CAAC"}

package/lib/types/utils/math/inScope.d.ts

@@ -1,5 +1,8 @@
 /**
- * Check if the value is within the scope
+ * Check if a given value is within a defined scope (inclusive of the scope's boundaries).
+ *
+ * @param value - The value to check.
+ * @param scopeValue - An array defining the range [min, max] where `value` should be compared against.
  *
  * @example
  *
@@ -8,5 +11,5 @@
  * inScope(2, [0, 1]); // => false
  * inScope(-1, [0, 1]); // => false
  */
-export declare function inScope(val: number, scopeValue?: number[]): boolean;
+export declare function inScope(value: number, scopeValue?: number[]): boolean;
 //# sourceMappingURL=inScope.d.ts.map

package/lib/types/utils/math/inScope.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"inScope.d.ts","sourceRoot":"","sources":["../../../../src/utils/math/inScope.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,wBAAgB,OAAO,CAAC,GAAG,EAAE,MAAM,EAAE,UAAU,WAAS,WAEvD"}
+{"version":3,"file":"inScope.d.ts","sourceRoot":"","sources":["../../../../src/utils/math/inScope.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,wBAAgB,OAAO,CAAC,KAAK,EAAE,MAAM,EAAE,UAAU,WAAS,WAEzD"}

package/lib/types/utils/math/lerp.d.ts

@@ -1,10 +1,18 @@
 /**
- * Linear interpolation
+ * Performs linear interpolation between the current and target values using an ease factor.
+ *
+ * Linear interpolation (LERP) calculates the intermediate value between two values (`current` and `target`)
+ * based on a given easing factor.
+ *
+ * @param current - The current value or starting point.
+ * @param target - The target value or end point.
+ * @param factor - The factor, typically between 0 and 1, which controls how fast the interpolation happens. A value closer to 0 makes the change slower, and a value closer to 1 makes it faster.
+ * @param approximationLeft - The threshold within which the difference between `current` and `target` is considered negligible, and the function returns the `target` value directly.
  *
  * @example
  *
  * lerp(0, 1, 0.4); // => 0.4
  * lerp(0.75, 0.8, 0.98); // => 0.799
  */
-export declare function lerp(current: number, target: number, ease: number, approximationLeft?: number): number;
+export declare function lerp(current: number, target: number, factor: number, approximationLeft?: number): number;
 //# sourceMappingURL=lerp.d.ts.map

package/lib/types/utils/math/lerp.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"lerp.d.ts","sourceRoot":"","sources":["../../../../src/utils/math/lerp.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,wBAAgB,IAAI,CAClB,OAAO,EAAE,MAAM,EACf,MAAM,EAAE,MAAM,EACd,IAAI,EAAE,MAAM,EACZ,iBAAiB,SAAQ,UAU1B"}
+{"version":3,"file":"lerp.d.ts","sourceRoot":"","sources":["../../../../src/utils/math/lerp.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,IAAI,CAClB,OAAO,EAAE,MAAM,EACf,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,EACd,iBAAiB,SAAQ,UAU1B"}

package/lib/types/utils/math/normalizeNestedScope.d.ts

@@ -1,10 +1,19 @@
 /**
- * Cast scope value relative to global scope
+ * Normalizes a nested scope (`innerScope`) relative to a larger `globalScope`.
+ *
+ * This function calculates the relative position of an inner scope within a global scope,
+ * adjusting the inner scope's values based on the size and position of the global scope.
+ *
+ * @param innerScope - The scope that is nested within the global scope. This is a range [start, end] relative to the global scope.
+ * @param globalScope - The global scope or range [start, end] that the inner scope should be normalized to.
  *
  * @example
  *
- * normalizeNestedScope([0, 1], [0.1, 0.8]); // => [0.1, 0.8]
- * normalizeNestedScope([0.2, 0.9], [0.1, 0.8]); // => [0.24, 0.73]
+ * normalizeNestedScope([0, 1], [0.1, 0.8]);
+ * // => [0.1, 0.8] // No change, since innerScope matches the full globalScope
+ *
+ * normalizeNestedScope([0.2, 0.9], [0.1, 0.8]);
+ * // => [0.24, 0.73] // Adjusted to fit within globalScope [0.1, 0.8]
  */
 export declare function normalizeNestedScope(innerScope: [number, number] | number[], globalScope: [number, number] | number[]): [number, number];
 //# sourceMappingURL=normalizeNestedScope.d.ts.map

package/lib/types/utils/math/normalizeNestedScope.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"normalizeNestedScope.d.ts","sourceRoot":"","sources":["../../../../src/utils/math/normalizeNestedScope.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,wBAAgB,oBAAoB,CAClC,UAAU,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,MAAM,EAAE,EACvC,WAAW,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,MAAM,EAAE,GACvC,CAAC,MAAM,EAAE,MAAM,CAAC,CAOlB"}
+{"version":3,"file":"normalizeNestedScope.d.ts","sourceRoot":"","sources":["../../../../src/utils/math/normalizeNestedScope.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,oBAAoB,CAClC,UAAU,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,MAAM,EAAE,EACvC,WAAW,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,MAAM,EAAE,GACvC,CAAC,MAAM,EAAE,MAAM,CAAC,CAOlB"}

package/lib/types/utils/math/scoped.d.ts

@@ -1,11 +1,22 @@
 /**
- * Get progress relatively to the scope.
+ * Get the progress of a value (`value`) relative to a given scope (`scope`).
+ *
+ * This function calculates how far along a value is within a specific range (scope),
+ * providing a normalized result between 0 and 1, depending on its position in the scope.
+ *
+ * @param value - The value for which to determine the relative progress within the scope.
+ * @param scope - The range (start, end) within which the value's progress will be calculated. Defaults to [0, 1].
  *
  * @example
  *
- * scoped(0.35, [0, 1]); // => 0.35
- * scoped(0.35, [0.25, 1]); // => 0.133
- * scoped(0.35, [0.25, 0.9]); // => 0.153
+ * scoped(0.35, [0, 1]);
+ * // => 0.35  // Progress of 0.35 within the full range [0, 1]
+ *
+ * scoped(0.35, [0.25, 1]);
+ * // => 0.133  // Progress of 0.35 within the range [0.25, 1]
+ *
+ * scoped(0.35, [0.25, 0.9]);
+ * // => 0.153  // Progress of 0.35 within the narrower range [0.25, 0.9]
  */
-export declare function scoped(val: number, scopeValue?: number[]): number;
+export declare function scoped(value: number, scope?: number[]): number;
 //# sourceMappingURL=scoped.d.ts.map

package/lib/types/utils/math/scoped.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"scoped.d.ts","sourceRoot":"","sources":["../../../../src/utils/math/scoped.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,wBAAgB,MAAM,CAAC,GAAG,EAAE,MAAM,EAAE,UAAU,WAAS,UAItD"}
+{"version":3,"file":"scoped.d.ts","sourceRoot":"","sources":["../../../../src/utils/math/scoped.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,MAAM,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,WAAS,UAInD"}

package/lib/types/utils/math/spreadScope.d.ts

@@ -1,10 +1,24 @@
 /**
- * Distribute scope progress among a certain quantity of timelines.
+ * Distribute the progress scope evenly across a specified number of timelines,
+ * with an optional overlap or shift between them.
+ *
+ * The function divides the range `[0, 1]` into segments, where each segment represents
+ * the progress of a timeline. The `shift` parameter allows overlap or space between
+ * the timelines. A `shift` of 0 means no overlap, while positive values introduce
+ * overlap between timelines.
+ *
+ * @param quantity - The number of timelines to distribute the progress scope over.
+ * @param shift - A value from `0` to `1` that determines how much overlap exists between timelines. A `shift` of 0 means no overlap, while a shift closer to `1` results in more overlap. Negative values could introduce gaps between the timelines.
  *
  * @example
  *
- * spreadScope(3, 0.1); // => [[0,0.35714285714285715],[0.32142857142857145,0.6785714285714286],[0.6428571428571429,1]]
- * spreadScope(3, 0.9); // => [[0,0.8333333333333334],[0.08333333333333331,0.9166666666666667],[0.16666666666666663,1]]
+ * spreadScope(3, 0.1);
+ * // => [[0, 0.357], [0.321, 0.678], [0.642, 1]]
+ * // Progress of 3 timelines with 0.1 shift (slight overlap)
+ *
+ * spreadScope(3, 0.9);
+ * // => [[0, 0.833], [0.083, 0.916], [0.167, 1]]
+ * // Progress of 3 timelines with 0.9 shift (more overlap)
  */
 export declare function spreadScope(quantity: number, shift: number): number[][];
 //# sourceMappingURL=spreadScope.d.ts.map

package/lib/types/utils/math/spreadScope.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"spreadScope.d.ts","sourceRoot":"","sources":["../../../../src/utils/math/spreadScope.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,wBAAgB,WAAW,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,cAc1D"}
+{"version":3,"file":"spreadScope.d.ts","sourceRoot":"","sources":["../../../../src/utils/math/spreadScope.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,WAAW,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,cAc1D"}

package/lib/types/utils/math/wrap.d.ts

@@ -1,13 +1,19 @@
 /**
- * Wrap values
+ * Wrap a value around a specified range.
+ * When the value exceeds the `max`, it wraps back to `min`, and when it's below `min`,
+ * it wraps around to `max`.
+ *
+ * @param min - The minimum value of the range.
+ * @param max - The maximum value of the range.
+ * @param value - The value to wrap around the range.
  *
  * @example
  *
  * wrap(0, 3, 0); // => 0
  * wrap(0, 3, 1); // => 1
  * wrap(0, 3, 2); // => 2
- * wrap(0, 3, 3); // => 0
- * wrap(0, 3, -1); // => 2
+ * wrap(0, 3, 3); // => 0 (wraps back to the start)
+ * wrap(0, 3, -1); // => 2 (wraps from below to the end)
  * wrap(0, 3, -2); // => 1
  * wrap(0, 3, -3); // => 0
  */

package/lib/types/utils/math/wrap.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"wrap.d.ts","sourceRoot":"","sources":["../../../../src/utils/math/wrap.ts"],"names":[],"mappings":"AAIA;;;;;;;;;;;;GAYG;AACH,wBAAgB,IAAI,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,UAO3D"}
+{"version":3,"file":"wrap.d.ts","sourceRoot":"","sources":["../../../../src/utils/math/wrap.ts"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,IAAI,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,UAO3D"}

package/lib/types/utils/scroll/getScrollValues.d.ts

@@ -4,11 +4,23 @@ export interface IGetScrollValues {
     scrollLeft: number;
 }
 /**
- * Get scroll values of a certain element
+ * Get the scroll values (scrollTop and scrollLeft) of a specific element, window, or a custom scroll-like object.
+ * This function retrieves the vertical and horizontal scroll positions.
+ *
+ * @param selector - The element, window, or custom scroll-like object to get scroll values from. If no selector is provided, it defaults to `window`.
  *
  * @example
  *
+ * // Get scroll values of the window
  * getScrollValues(window); // => { scrollTop: 0, scrollLeft: 0 }
+ *
+ * // Get scroll values of a specific DOM element
+ * const element = document.querySelector('.scrollable');
+ * getScrollValues(element); // => { scrollTop: 100, scrollLeft: 50 }
+ *
+ * // Get scroll values of a custom scroll-like object
+ * const customScroll: IScrollLike = { scrollTop: 200, scrollLeft: 75 };
+ * getScrollValues(customScroll); // => { scrollTop: 200, scrollLeft: 75 }
  */
 export declare function getScrollValues(selector?: Window | Element | IScrollLike | undefined): IGetScrollValues | undefined;
 //# sourceMappingURL=getScrollValues.d.ts.map

package/lib/types/utils/scroll/getScrollValues.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"getScrollValues.d.ts","sourceRoot":"","sources":["../../../../src/utils/scroll/getScrollValues.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAE9C,MAAM,WAAW,gBAAgB;IAC/B,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;CACpB;AAED;;;;;;GAMG;AACH,wBAAgB,eAAe,CAC7B,QAAQ,GAAE,MAAM,GAAG,OAAO,GAAG,WAAW,GAAG,SAAkB,GAC5D,gBAAgB,GAAG,SAAS,CAe9B"}
+{"version":3,"file":"getScrollValues.d.ts","sourceRoot":"","sources":["../../../../src/utils/scroll/getScrollValues.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAE9C,MAAM,WAAW,gBAAgB;IAC/B,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;CACpB;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,eAAe,CAC7B,QAAQ,GAAE,MAAM,GAAG,OAAO,GAAG,WAAW,GAAG,SAAkB,GAC5D,gBAAgB,GAAG,SAAS,CAe9B"}

package/lib/types/utils/scroll/isPageScrolling.d.ts

@@ -1,5 +1,25 @@
+/**
+ * Creates an instance to check whether the page is currently scrolling.
+ * This function manages the scroll state across multiple instances, ensuring the listener is created only once.
+ *
+ * @example
+ *
+ * const scrollChecker = createIsPageScrolling();
+ *
+ * // Check if page is scrolling
+ * const isPageScrolling = scrollChecker.get(); // => true or false
+ *
+ * // Destroy the instance when not needed
+ * scrollChecker.destroy();
+ */
 export declare function createIsPageScrolling(): {
+    /**
+     * @returns {boolean} - Returns whether the page is currently scrolling.
+     */
     get: () => boolean;
+    /**
+     * Destroys the scroll listener instance.
+     */
     destroy: () => void;
 };
 //# sourceMappingURL=isPageScrolling.d.ts.map

package/lib/types/utils/scroll/isPageScrolling.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"isPageScrolling.d.ts","sourceRoot":"","sources":["../../../../src/utils/scroll/isPageScrolling.ts"],"names":[],"mappings":"AAkCA,wBAAgB,qBAAqB;;;EAepC"}
+{"version":3,"file":"isPageScrolling.d.ts","sourceRoot":"","sources":["../../../../src/utils/scroll/isPageScrolling.ts"],"names":[],"mappings":"AAyCA;;;;;;;;;;;;;GAaG;AACH,wBAAgB,qBAAqB;IAejC;;OAEG;;IAGH;;OAEG;;EAGN"}

package/lib/types/utils/scroll/normalizeWheel.d.ts

@@ -1,11 +1,16 @@
 /**
- * Normalize wheel delta. This function is reexported from `normalize-wheel` for convenience.
+ * Normalize wheel delta. This function is re-exported from `normalize-wheel` for convenience.
+ * It helps normalize the wheel event's delta values (spinX, spinY, pixelX, pixelY) across different browsers.
  *
  * @see https://www.npmjs.com/package/normalize-wheel
  *
  * @example
  *
- * normalizeWheel(event); // => { spinX: -0, spinY: 1.25, pixelX: -0, pixelY: 125 }
+ * document.addEventListener('wheel', (event) => {
+ *   const normalized = normalizeWheel(event);
+ *   console.log(normalized);
+ *   // => { spinX: -0, spinY: 1.25, pixelX: -0, pixelY: 125 }
+ * });
  */
 export declare function normalizeWheel(event: WheelEvent): {
     spinX: number;
@@ -13,5 +18,8 @@ export declare function normalizeWheel(event: WheelEvent): {
     pixelX: number;
     pixelY: number;
 };
+/**
+ * Type definition for the normalized wheel event.
+ */
 export type TNormalizeWheel = ReturnType<typeof normalizeWheel>;
 //# sourceMappingURL=normalizeWheel.d.ts.map

package/lib/types/utils/scroll/normalizeWheel.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"normalizeWheel.d.ts","sourceRoot":"","sources":["../../../../src/utils/scroll/normalizeWheel.ts"],"names":[],"mappings":"AAEA;;;;;;;;GAQG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,UAAU;;;;;EAE/C;AAED,MAAM,MAAM,eAAe,GAAG,UAAU,CAAC,OAAO,cAAc,CAAC,CAAC"}
+{"version":3,"file":"normalizeWheel.d.ts","sourceRoot":"","sources":["../../../../src/utils/scroll/normalizeWheel.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;GAaG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,UAAU;;;;;EAE/C;AAED;;GAEG;AACH,MAAM,MAAM,eAAe,GAAG,UAAU,CAAC,OAAO,cAAc,CAAC,CAAC"}

package/lib/types/utils/scroll/onScroll.d.ts

@@ -1,17 +1,23 @@
 import { IRemovable } from '../../types/general';
-import type { SmoothScroll } from '../../components/SmoothScroll';
-type TContainer = string | Element | SmoothScroll | Window;
+import type { CustomScroll } from '../../components/CustomScroll';
+export type TOnScrollContainer = string | Element | CustomScroll | Window;
 export interface IOnScrollCallbackParameter {
     scrollTop: number;
     scrollLeft: number;
 }
 export interface IOnScrollProps {
-    container: TContainer;
+    container: TOnScrollContainer;
     callback: (data: IOnScrollCallbackParameter) => void;
     isPassive?: boolean;
 }
 /**
- * Add `onScroll` event
+ * Add `onScroll` event listener to the provided container (DOM element, custom scroll, or window).
+ * It automatically manages multiple scroll listeners by stacking them in instances.
+ *
+ * If an instance already exists for the container, it adds the new callback to the existing stack.
+ * Otherwise, it creates a new scroll listener.
+ *
+ * This function supports both native scrollable elements and `CustomScroll` instances.
  *
  * @example
  *
@@ -22,5 +28,4 @@ export interface IOnScrollProps {
  * });
  */
 export declare function onScroll({ container, callback, isPassive, }: IOnScrollProps): IRemovable;
-export {};
 //# sourceMappingURL=onScroll.d.ts.map

package/lib/types/utils/scroll/onScroll.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"onScroll.d.ts","sourceRoot":"","sources":["../../../../src/utils/scroll/onScroll.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAE7C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AAG9D,KAAK,UAAU,GAAG,MAAM,GAAG,OAAO,GAAG,YAAY,GAAG,MAAM,CAAC;AAE3D,MAAM,WAAW,0BAA0B;IACzC,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;CACpB;AAaD,MAAM,WAAW,cAAc;IAC7B,SAAS,EAAE,UAAU,CAAC;IACtB,QAAQ,EAAE,CAAC,IAAI,EAAE,0BAA0B,KAAK,IAAI,CAAC;IACrD,SAAS,CAAC,EAAE,OAAO,CAAC;CACrB;AAID;;;;;;;;;;GAUG;AACH,wBAAgB,QAAQ,CAAC,EACvB,SAAS,EACT,QAAQ,EACR,SAAiB,GAClB,EAAE,cAAc,GAAG,UAAU,CAyE7B"}
+{"version":3,"file":"onScroll.d.ts","sourceRoot":"","sources":["../../../../src/utils/scroll/onScroll.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAE7C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AAG9D,MAAM,MAAM,kBAAkB,GAAG,MAAM,GAAG,OAAO,GAAG,YAAY,GAAG,MAAM,CAAC;AAE1E,MAAM,WAAW,0BAA0B;IACzC,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;CACpB;AAaD,MAAM,WAAW,cAAc;IAC7B,SAAS,EAAE,kBAAkB,CAAC;IAC9B,QAAQ,EAAE,CAAC,IAAI,EAAE,0BAA0B,KAAK,IAAI,CAAC;IACrD,SAAS,CAAC,EAAE,OAAO,CAAC;CACrB;AAID;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,QAAQ,CAAC,EACvB,SAAS,EACT,QAAQ,EACR,SAAiB,GAClB,EAAE,cAAc,GAAG,UAAU,CA0E7B"}