updated remapRange to accept arrays, adding tests, removing default export to be more like ESM (can always import * as lathe)

Author: danielgamage

docs/src/App.test.js

@@ -1,3 +1,5 @@
+/** Contains the minimum and maximum of a range */
+declare type Range = [number, number];
 /**
  * Maps bipolar numbers [-1, 1] to the unipolar closed unit interval [0, 1]
  */
@@ -6,6 +8,10 @@ export declare const biToUni: (v: number) => number;
  * Maps unipolar numbers [0, 1] to the bipolar closed interval [-1, 1]
  */
 export declare const uniToBi: (v: number) => number;
+/**
+ * Maps a number from one range to another, optionally clamping it to the input range
+ */
+export declare const remapRange: (input: number, inputRange: Range, outputRange?: Range, clampInput?: boolean) => number;
 /**
  * Clamps overflowing numbers within the closed interval [min, max]
  */
@@ -43,7 +49,7 @@ export declare const doubleExponentialSigmoid: (x: number, a: number) => number;
  * @see http://www.flong.com/archive/texts/code/shapers_exp/index.html
  */
 export declare const doubleExponentialSeat: (input: number, a: number) => number;
-export declare const cubicSlope: (input: number, bias: number) => number;
+export declare const cubicSlope: (input: number, bias: number, tension?: number) => number;
 /**
  * @see http://www.flong.com/archive/texts/code/shapers_bez/index.html
  */
@@ -103,28 +109,4 @@ export declare const mirrorAcrossOrigin: (input: number, fn: any, ...args: any[]
  * Calls function `fn` reflected across the point at `x`, `y`
  */
 export declare function inflectionThroughPoint<Fn extends (...args: any[]) => number>(input: any, x: any, y: any, fn: Fn, ...args: Omit<Parameters<Fn>, "input">): any;
-declare const functions: {
-    biToUni: (v: number) => number;
-    uniToBi: (v: number) => number;
-    clamp: (x: number, min: number, max: number) => number;
-    lerp: (input: number, a: number, b: number) => number;
-    tanh: (x: any, gain?: number) => number;
-    quadraticThroughAGivenPoint: (input: number, x: number, y: number, clamped?: boolean) => number;
-    quadraticBezier: (input: number, x: number, y: number) => number;
-    quadraticSlope: (input: number, bias: number) => number;
-    doubleExponentialSigmoid: (x: number, a: number) => number;
-    doubleExponentialSeat: (input: number, a: number) => number;
-    quantize: (input: number, step: number, algorithm?: "round" | "ceil" | "floor") => number;
-    fold: (input: number, gain: number) => number;
-    pcurve: (x: number, a: number, b: number) => number;
-    sineFold: (input: number, gain: number) => number;
-    circularArc: (input: number, bias: number) => number;
-    logistic: (input: number, gain: number) => number;
-    smoothStep: (input: number, edge0: number, edge1: number) => number;
-    linearStep: (input: number, x: number, y: number) => number;
-    polyline: (input: number, midpointX: number, midpointY: number) => number;
-    mirrorAcrossY: (input: number, fn: any, ...args: any[]) => any;
-    mirrorAcrossOrigin: (input: number, fn: any, ...args: any[]) => any;
-    inflectionThroughPoint: typeof inflectionThroughPoint;
-};
-export default functions;
+export {};

index.d.ts

@@ -10,6 +10,16 @@ const biToUni = (v) => v / 2 + 0.5;
  * Maps unipolar numbers [0, 1] to the bipolar closed interval [-1, 1]
  */
 const uniToBi = (v) => v * 2 - 1;
+/**
+ * Maps a number from one range to another, optionally clamping it to the input range
+ */
+const remapRange = (input, inputRange, outputRange = [0, 1], clampInput = true) => {
+    const [inMin, inMax] = inputRange;
+    const [outMin, outMax] = outputRange;
+    const clampedInput = clampInput ? clamp(input, inMin, inMax) : input;
+    const normalized = (clampedInput - inMin) / (inMax - inMin);
+    return lerp(normalized, outMin, outMax);
+};
 /**
  * Clamps overflowing numbers within the closed interval [min, max]
  */
@@ -135,8 +145,20 @@ const doubleExponentialSeat = (input, a) => {
 };
 const cubicSlope = (input, 
 /** range from 0..1 */
-bias) => {
-    return cubicBezier(input, 1 - bias, bias, 1 - bias, bias);
+bias, 
+/** range from 0..1 */
+tension = 0.5) => {
+    // Calculate pointA based on bias
+    const pointA = [
+        tension * (1 - bias),
+        tension * (bias) // y goes from 0 to 1 as bias goes 0->1
+    ];
+    // Calculate pointB as the mirrored point of pointA
+    const pointB = [
+        1 - pointA[1],
+        1 - pointA[0]
+    ];
+    return cubicBezier(input, pointA[0], pointA[1], pointB[0], pointB[1]);
 };
 /**
  * @see http://www.flong.com/archive/texts/code/shapers_bez/index.html
@@ -344,28 +366,4 @@ function inflectionThroughPoint(input, x, y, fn, ...args) {
         return (1 - fn(1 - (input - x) / (1 - x + epsilon), ...args)) * (1 - y) + y;
         // input scaled to 0 1
     }
-}
-const functions = {
-    biToUni,
-    uniToBi,
-    clamp,
-    lerp,
-    tanh,
-    quadraticThroughAGivenPoint,
-    quadraticBezier,
-    quadraticSlope,
-    doubleExponentialSigmoid,
-    doubleExponentialSeat,
-    quantize,
-    fold,
-    pcurve,
-    sineFold,
-    circularArc,
-    logistic,
-    smoothStep,
-    linearStep,
-    polyline,
-    mirrorAcrossY,
-    mirrorAcrossOrigin,
-    inflectionThroughPoint,
-};export{biToUni,circularArc,clamp,cubicBezier,cubicSlope,functions as default,doubleCubicSeat,doubleCubicSeatWithLinearBlend,doubleExponentialSeat,doubleExponentialSigmoid,ease,fold,inflectionThroughPoint,lerp,linearStep,logistic,mirrorAcrossOrigin,mirrorAcrossY,pcurve,polyline,quadraticBezier,quadraticSlope,quadraticThroughAGivenPoint,quantize,sineFold,smoothStep,tanh,uniToBi};
+}export{biToUni,circularArc,clamp,cubicBezier,cubicSlope,doubleCubicSeat,doubleCubicSeatWithLinearBlend,doubleExponentialSeat,doubleExponentialSigmoid,ease,fold,inflectionThroughPoint,lerp,linearStep,logistic,mirrorAcrossOrigin,mirrorAcrossY,pcurve,polyline,quadraticBezier,quadraticSlope,quadraticThroughAGivenPoint,quantize,remapRange,sineFold,smoothStep,tanh,uniToBi};