vevet 2.0.1-dev.26 → 2.0.1-dev.28

package/src/ts/components/scroll/scrollbar/Bar.ts

@@ -1,7 +1,7 @@
 import { addEventListener, createElement, IAddEventListener } from 'vevet-dom';
 import { IRemovable } from '../../../utils/types/general';
 import onScroll from '../../../utils/listeners/onScroll';
-import boundVal from '../../../utils/math/boundVal';
+import clamp from '../../../utils/math/clamp';
 import { DraggerMove, NDraggerMove } from '../../dragger/DraggerMove';
 import { SmoothScroll } from '../smooth-scroll/SmoothScroll';
 
@@ -293,7 +293,7 @@ export default class Bar {
      */
     protected _renderThumb () {
         // calculate progress
-        const progress = boundVal(
+        const progress = clamp(
             this._scrollVal / this.scrollLine,
             [0, 1],
         );
@@ -321,7 +321,7 @@ export default class Bar {
         // calculate thumb sizes
         if (this.prop.autoSize) {
             if (this.isX) {
-                const barSize = boundVal(
+                const barSize = clamp(
                     this._outerWidth / (this.scrollWidth / (
                         this.scrollWidth - scrollLine
                     )),
@@ -329,7 +329,7 @@ export default class Bar {
                 );
                 thumb.style.width = `${barSize}px`;
             } else {
-                const barSize = boundVal(
+                const barSize = clamp(
                     this._outerHeight / (this.scrollHeight / (
                         this.scrollHeight - scrollLine
                     )),

package/src/ts/components/scroll/smooth-scroll/SmoothScroll.ts

@@ -6,7 +6,7 @@ import { Component, NComponent } from '../../../base/Component';
 import { RequiredModuleProp } from '../../../utils/types/utility';
 import { AnimationFrame } from '../../animation-frame/AnimationFrame';
 import { ScrollableElement } from '../types';
-import boundVal from '../../../utils/math/boundVal';
+import clamp from '../../../utils/math/clamp';
 import { NCallbacks } from '../../../base/Callbacks';
 import { lerp } from '../../../utils/math';
 
@@ -215,7 +215,7 @@ export class SmoothScroll <
             ? -this.prop.overscroll.max : 0;
         const max = this.maxScrollableWidth
             + (!!this.prop.overscroll && this.prop.isHorizontal ? this.prop.overscroll.max : 0);
-        this._targetLeft = boundVal(
+        this._targetLeft = clamp(
             val,
             [min, max],
         );
@@ -247,7 +247,7 @@ export class SmoothScroll <
             ? -this.prop.overscroll.max : 0;
         const max = this.maxScrollableHeight
             + (!!this.prop.overscroll && !this.prop.isHorizontal ? this.prop.overscroll.max : 0);
-        this._targetTop = boundVal(
+        this._targetTop = clamp(
             val,
             [min, max],
         );
@@ -492,8 +492,8 @@ export class SmoothScroll <
         // get sizes
         this._clientWidth = outer.clientWidth;
         this._clientHeight = outer.clientHeight;
-        this._scrollWidth = boundVal(container.clientWidth, [this.clientWidth, Infinity]);
-        this._scrollHeight = boundVal(container.clientHeight, [this.clientHeight, Infinity]);
+        this._scrollWidth = clamp(container.clientWidth, [this.clientWidth, Infinity]);
+        this._scrollHeight = clamp(container.clientHeight, [this.clientHeight, Infinity]);
 
         // force instant change
         // it means that after resizing, scrolling will be instantaneous for a while

package/src/ts/components/timeline/StaticTimeline.ts

@@ -2,8 +2,8 @@ import easingProgress from 'easing-progress';
 import { NApplication } from '../../app/Application';
 import { Component, NComponent } from '../../base/Component';
 import { RequiredModuleProp } from '../../utils/types/utility';
-import scopeProgress from '../../utils/math/scopeProgress';
-import boundVal from '../../utils/math/boundVal';
+import scoped from '../../utils/math/scoped';
+import clamp from '../../utils/math/clamp';
 
 
 
@@ -174,8 +174,8 @@ export class StaticTimeline <
         for (let index = 0, l = length; index < l; index += 1) {
             const tm = this._nestedTimelines[index];
             // calculate progress of this very timeline
-            const tmProgress = boundVal(
-                scopeProgress(progressForNested, tm.prop.nestedScope),
+            const tmProgress = clamp(
+                scoped(progressForNested, tm.prop.nestedScope),
                 [0, 1],
             );
             tm.progress = tmProgress;

package/src/ts/components/timeline/Timeline.ts

@@ -1,6 +1,6 @@
 import { StaticTimeline, NStaticTimeline } from './StaticTimeline';
 import { RequiredModuleProp } from '../../utils/types/utility';
-import boundVal from '../../utils/math/boundVal';
+import clamp from '../../utils/math/clamp';
 
 
 
@@ -205,7 +205,7 @@ export class Timeline <
 
         // calculate current progress
         const progressIterator = frameDiff / this.prop.duration / (isReversed ? -1 : 1);
-        const progressTarget = boundVal(
+        const progressTarget = clamp(
             this.progress + progressIterator,
             [0, 1],
         );

package/src/ts/utils/math/{boundVal.ts → clamp.ts}

@@ -1,9 +1,9 @@
 /**
- * Bound a value between two points
+ * Clamp the value between two points
  */
-export default function boundVal (
+export default function clamp (
     val: number,
-    scope: [number, number] = [0, 1],
+    scope = [0, 1],
 ) {
     if (val < scope[0]) {
         return scope[0];

package/src/ts/utils/math/clampScope.ts

@@ -0,0 +1,16 @@
+import scoped from './scoped';
+import clamp from './clamp';
+
+/**
+ * Get progress relatively to the scope and clamp it within two points
+ */
+export default function clampScoped (
+    val: number,
+    scope = [0, 1],
+    clampScope = [0, 1],
+) {
+    return clamp(
+        scoped(val, scope),
+        clampScope,
+    );
+}

package/src/ts/utils/math/inScope.ts

@@ -0,0 +1,9 @@
+/**
+ * Check if the value is within the scope
+ */
+export default function inScope (
+    val: number,
+    scopeValue = [0, 1],
+) {
+    return val >= scopeValue[0] && val <= scopeValue[1];
+}

package/src/ts/utils/math/index.ts

@@ -1,13 +1,17 @@
-import boundVal from './boundVal';
+import clamp from './clamp';
 import lerp from './lerp';
-import scopeProgress from './scopeProgress';
-import spreadScopeProgress from './spreadScopeProgress';
+import scoped from './scoped';
+import spreadScope from './spreadScope';
+import inScope from './inScope';
+import clampScope from './clampScope';
 import wrap from './wrap';
 
 export {
-    boundVal,
+    clamp,
     lerp,
-    scopeProgress,
-    spreadScopeProgress,
+    scoped,
+    spreadScope,
+    inScope,
+    clampScope,
     wrap,
 };

package/src/ts/utils/math/scoped.ts

@@ -0,0 +1,17 @@
+/**
+ * Get progress relatively to the scope.
+ *
+ * @example
+ *
+ * scope(.35, [0, 1]);
+ * // => .5
+ * scope(.35, [.25, 1]);
+ * // => .133
+ */
+export default function scoped (
+    val: number,
+    scopeValue = [0, 1],
+) {
+    const result = (val - scopeValue[0]) / (scopeValue[1] - scopeValue[0]);
+    return result;
+}

package/src/ts/utils/math/{spreadScopeProgress.ts → spreadScope.ts}

@@ -1,11 +1,11 @@
 /**
  * Distribute scope progress among a certain quantity of timelines.
  */
-export default function spreadScopeProgress (
+export default function spreadScope (
     quantity: number,
     shift: number,
 ) {
-    const timelines: [number, number][] = [];
+    const timelines: number[][] = [];
     // duration for each element
     const duration = 1 / (quantity - shift * (quantity - 1));
     // calculate timelines

package/src/ts/utils/math/scopeProgress.ts

@@ -1,23 +0,0 @@
-/**
- * Get progress relatively to the scope.
- *
- * @example
- *
- * scopeProgress(.35, [0, 1]);
- * // => .5
- * scopeProgress(.35, [.25, 1]);
- * // => .133
- */
-export default function scopeProgress (
-    /**
-     * Current progress
-     */
-    progress: number,
-    /**
-     * Progress scope
-     */
-    scope: [number, number],
-) {
-    const result = (progress - scope[0]) / (scope[1] - scope[0]);
-    return result;
-}