@grame/faustwasm 0.12.2 → 0.13.0

package/src/FaustSensors.ts

@@ -9,18 +9,18 @@
 }
 
 /** Enum describing the axis of the accelerometer or gyroscope */
-export enum Axis { x, y, z }
+export enum Axis {
+    x,
+    y,
+    z
+}
 
 /** Enum describing the curve of the accelerometer */
-export enum Curve { Up, Down, UpDown, DownUp }
-
-/** Object describing value off accelerometer metadata values */
-class AccMeta {
-    axis: Axis;
-    curve: Curve;
-    amin: number;
-    amid: number;
-    amax: number;
+export enum Curve {
+    Up,
+    Down,
+    UpDown,
+    DownUp
 }
 
 interface Range {
@@ -51,7 +51,11 @@ interface Interpolator3pt {
     fSegment2: Interpolator;
     fMid: number;
     returnMappedValue(v: number): number;
-    getMappingValues(amin: number, amid: number, amax: number): InterpolateObject3pt;
+    getMappingValues(
+        amin: number,
+        amid: number,
+        amax: number
+    ): InterpolateObject3pt;
 }
 
 /**
@@ -68,8 +72,19 @@ interface ValueConverter {
 export interface UpdatableValueConverter extends ValueConverter {
     fActive: boolean;
 
-    setMappingValues(amin: number, amid: number, amax: number, min: number, init: number, max: number): void;
-    getMappingValues(amin: number, amid: number, amax: number): InterpolateObject3pt;
+    setMappingValues(
+        amin: number,
+        amid: number,
+        amax: number,
+        min: number,
+        init: number,
+        max: number
+    ): void;
+    getMappingValues(
+        amin: number,
+        amid: number,
+        amax: number
+    ): InterpolateObject3pt;
 
     setActive(onOff: boolean): void;
     getActive(): boolean;
@@ -78,7 +93,7 @@ export interface UpdatableValueConverter extends ValueConverter {
 export default class FaustSensors {
     /**
      * Function to convert a number to an axis type
-     * 
+     *
      * @param value number
      * @returns axis type
      */
@@ -91,13 +106,13 @@ export default class FaustSensors {
             case 2:
                 return Axis.z;
             default:
-                console.error("Error: Axis not found value: " + value);
+                console.error('Error: Axis not found value: ' + value);
                 return Axis.x;
         }
     }
     /**
      * Function to convert a number to a curve type
-     * 
+     *
      * @param value number
      * @returns curve type
      */
@@ -112,7 +127,7 @@ export default class FaustSensors {
             case 3:
                 return Curve.DownUp;
             default:
-                console.error("Error: Curve not found value: " + value);
+                console.error('Error: Curve not found value: ' + value);
                 return Curve.Up;
         }
     }
@@ -140,7 +155,12 @@ export default class FaustSensors {
         return this._Range;
     }
 
-    static _Interpolator: new (lo: number, hi: number, v1: number, v2: number) => Interpolator;
+    static _Interpolator: new (
+        lo: number,
+        hi: number,
+        v1: number,
+        v2: number
+    ) => Interpolator;
     /**
      * Interpolator class
      */
@@ -164,7 +184,7 @@ export default class FaustSensors {
                     }
                 }
                 returnMappedValue(v: number): number {
-                    var x = this.fRange.clip(v);
+                    const x = this.fRange.clip(v);
                     return this.fOffset + x * this.fCoef;
                 }
                 getLowHigh(amin: number, amax: number): InterpolateObject {
@@ -175,174 +195,441 @@ export default class FaustSensors {
         return this._Interpolator;
     }
 
-    static _Interpolator3pt: new (lo: number, mid: number, hi: number, v1: number, vMid: number, v2: number) => Interpolator3pt;
+    static _Interpolator3pt: new (
+        lo: number,
+        mid: number,
+        hi: number,
+        v1: number,
+        vMid: number,
+        v2: number
+    ) => Interpolator3pt;
     /**
      * Interpolator3pt class, combine two interpolators
      */
     static get Interpolator3pt() {
         if (!this._Interpolator3pt) {
             this._Interpolator3pt = class {
-
                 fSegment1: Interpolator;
                 fSegment2: Interpolator;
                 fMid: number;
 
-                constructor(lo: number, mid: number, hi: number, v1: number, vMid: number, v2: number) {
-                    this.fSegment1 = new FaustSensors.Interpolator(lo, mid, v1, vMid);
-                    this.fSegment2 = new FaustSensors.Interpolator(mid, hi, vMid, v2);
+                constructor(
+                    lo: number,
+                    mid: number,
+                    hi: number,
+                    v1: number,
+                    vMid: number,
+                    v2: number
+                ) {
+                    this.fSegment1 = new FaustSensors.Interpolator(
+                        lo,
+                        mid,
+                        v1,
+                        vMid
+                    );
+                    this.fSegment2 = new FaustSensors.Interpolator(
+                        mid,
+                        hi,
+                        vMid,
+                        v2
+                    );
                     this.fMid = mid;
                 }
                 returnMappedValue(x: number): number {
-                    return (x < this.fMid) ? this.fSegment1.returnMappedValue(x) : this.fSegment2.returnMappedValue(x);
+                    return x < this.fMid
+                        ? this.fSegment1.returnMappedValue(x)
+                        : this.fSegment2.returnMappedValue(x);
                 }
 
-                getMappingValues(amin: number, amid: number, amax: number): InterpolateObject3pt {
-                    var lowHighSegment1 = this.fSegment1.getLowHigh(amin, amid);
-                    var lowHighSegment2 = this.fSegment2.getLowHigh(amid, amax);
-                    return { amin: lowHighSegment1.amin, amid: lowHighSegment2.amin, amax: lowHighSegment2.amax };
+                getMappingValues(
+                    amin: number,
+                    amid: number,
+                    amax: number
+                ): InterpolateObject3pt {
+                    const lowHighSegment1 = this.fSegment1.getLowHigh(
+                        amin,
+                        amid
+                    );
+                    const lowHighSegment2 = this.fSegment2.getLowHigh(
+                        amid,
+                        amax
+                    );
+                    return {
+                        amin: lowHighSegment1.amin,
+                        amid: lowHighSegment2.amin,
+                        amax: lowHighSegment2.amax
+                    };
                 }
-            }
-
+            };
         }
         return this._Interpolator3pt;
     }
-    static _UpConverter: new (amin: number, amid: number, amax: number, fmin: number, fmid: number, fmax: number) => UpdatableValueConverter;
+    static _UpConverter: new (
+        amin: number,
+        amid: number,
+        amax: number,
+        fmin: number,
+        fmid: number,
+        fmax: number
+    ) => UpdatableValueConverter;
     /**
      * UpConverter class, convert accelerometer value to Faust value
      */
     static get UpConverter() {
         if (!this._UpConverter) {
             this._UpConverter = class implements UpdatableValueConverter {
-
                 fA2F: Interpolator3pt;
                 fF2A: Interpolator3pt;
                 fActive: boolean = true;
 
-                constructor(amin: number, amid: number, amax: number, fmin: number, fmid: number, fmax: number) {
-                    this.fA2F = new FaustSensors.Interpolator3pt(amin, amid, amax, fmin, fmid, fmax);
-                    this.fF2A = new FaustSensors.Interpolator3pt(fmin, fmid, fmax, amin, amid, amax);
+                constructor(
+                    amin: number,
+                    amid: number,
+                    amax: number,
+                    fmin: number,
+                    fmid: number,
+                    fmax: number
+                ) {
+                    this.fA2F = new FaustSensors.Interpolator3pt(
+                        amin,
+                        amid,
+                        amax,
+                        fmin,
+                        fmid,
+                        fmax
+                    );
+                    this.fF2A = new FaustSensors.Interpolator3pt(
+                        fmin,
+                        fmid,
+                        fmax,
+                        amin,
+                        amid,
+                        amax
+                    );
                 }
 
-                uiToFaust(x: number) { return this.fA2F.returnMappedValue(x) }
-                faustToUi(x: number) { return this.fF2A.returnMappedValue(x) }
+                uiToFaust(x: number) {
+                    return this.fA2F.returnMappedValue(x);
+                }
+                faustToUi(x: number) {
+                    return this.fF2A.returnMappedValue(x);
+                }
 
-                setMappingValues(amin: number, amid: number, amax: number, min: number, init: number, max: number): void {
-                    this.fA2F = new FaustSensors.Interpolator3pt(amin, amid, amax, min, init, max);
-                    this.fF2A = new FaustSensors.Interpolator3pt(min, init, max, amin, amid, amax);
+                setMappingValues(
+                    amin: number,
+                    amid: number,
+                    amax: number,
+                    min: number,
+                    init: number,
+                    max: number
+                ): void {
+                    this.fA2F = new FaustSensors.Interpolator3pt(
+                        amin,
+                        amid,
+                        amax,
+                        min,
+                        init,
+                        max
+                    );
+                    this.fF2A = new FaustSensors.Interpolator3pt(
+                        min,
+                        init,
+                        max,
+                        amin,
+                        amid,
+                        amax
+                    );
                 }
 
-                getMappingValues(amin: number, amid: number, amax: number): InterpolateObject3pt {
+                getMappingValues(
+                    amin: number,
+                    amid: number,
+                    amax: number
+                ): InterpolateObject3pt {
                     return this.fA2F.getMappingValues(amin, amid, amax);
                 }
 
-                setActive(onOff: boolean): void { this.fActive = onOff }
-                getActive(): boolean { return this.fActive }
-            }
-
+                setActive(onOff: boolean): void {
+                    this.fActive = onOff;
+                }
+                getActive(): boolean {
+                    return this.fActive;
+                }
+            };
         }
         return this._UpConverter;
     }
-    static _DownConverter: new (amin: number, amid: number, amax: number, fmin: number, fmid: number, fmax: number) => UpdatableValueConverter;
+    static _DownConverter: new (
+        amin: number,
+        amid: number,
+        amax: number,
+        fmin: number,
+        fmid: number,
+        fmax: number
+    ) => UpdatableValueConverter;
     /**
      * DownConverter class, convert accelerometer value to Faust value
      */
     static get DownConverter() {
         if (!this._DownConverter) {
             this._DownConverter = class implements UpdatableValueConverter {
-
                 fA2F: Interpolator3pt;
                 fF2A: Interpolator3pt;
                 fActive: boolean = true;
 
-                constructor(amin: number, amid: number, amax: number, fmin: number, fmid: number, fmax: number) {
-                    this.fA2F = new FaustSensors.Interpolator3pt(amin, amid, amax, fmax, fmid, fmin);
-                    this.fF2A = new FaustSensors.Interpolator3pt(fmin, fmid, fmax, amax, amid, amin);
+                constructor(
+                    amin: number,
+                    amid: number,
+                    amax: number,
+                    fmin: number,
+                    fmid: number,
+                    fmax: number
+                ) {
+                    this.fA2F = new FaustSensors.Interpolator3pt(
+                        amin,
+                        amid,
+                        amax,
+                        fmax,
+                        fmid,
+                        fmin
+                    );
+                    this.fF2A = new FaustSensors.Interpolator3pt(
+                        fmin,
+                        fmid,
+                        fmax,
+                        amax,
+                        amid,
+                        amin
+                    );
                 }
 
-                uiToFaust(x: number) { return this.fA2F.returnMappedValue(x) }
-                faustToUi(x: number) { return this.fF2A.returnMappedValue(x) }
+                uiToFaust(x: number) {
+                    return this.fA2F.returnMappedValue(x);
+                }
+                faustToUi(x: number) {
+                    return this.fF2A.returnMappedValue(x);
+                }
 
-                setMappingValues(amin: number, amid: number, amax: number, min: number, init: number, max: number): void {
-                    this.fA2F = new FaustSensors.Interpolator3pt(amin, amid, amax, max, init, min);
-                    this.fF2A = new FaustSensors.Interpolator3pt(min, init, max, amax, amid, amin);
+                setMappingValues(
+                    amin: number,
+                    amid: number,
+                    amax: number,
+                    min: number,
+                    init: number,
+                    max: number
+                ): void {
+                    this.fA2F = new FaustSensors.Interpolator3pt(
+                        amin,
+                        amid,
+                        amax,
+                        max,
+                        init,
+                        min
+                    );
+                    this.fF2A = new FaustSensors.Interpolator3pt(
+                        min,
+                        init,
+                        max,
+                        amax,
+                        amid,
+                        amin
+                    );
                 }
-                getMappingValues(amin: number, amid: number, amax: number): InterpolateObject3pt {
+                getMappingValues(
+                    amin: number,
+                    amid: number,
+                    amax: number
+                ): InterpolateObject3pt {
                     return this.fA2F.getMappingValues(amin, amid, amax);
                 }
 
-                setActive(onOff: boolean): void { this.fActive = onOff }
-                getActive(): boolean { return this.fActive }
-            }
-
+                setActive(onOff: boolean): void {
+                    this.fActive = onOff;
+                }
+                getActive(): boolean {
+                    return this.fActive;
+                }
+            };
         }
         return this._DownConverter;
     }
-    static _UpDownConverter: new (amin: number, amid: number, amax: number, fmin: number, fmid: number, fmax: number) => UpdatableValueConverter;
+    static _UpDownConverter: new (
+        amin: number,
+        amid: number,
+        amax: number,
+        fmin: number,
+        fmid: number,
+        fmax: number
+    ) => UpdatableValueConverter;
     /**
      * UpDownConverter class, convert accelerometer value to Faust value
      */
     static get UpDownConverter() {
         if (!this._UpDownConverter) {
             this._UpDownConverter = class implements UpdatableValueConverter {
-
                 fA2F: Interpolator3pt;
                 fF2A: Interpolator;
                 fActive: boolean = true;
 
-                constructor(amin: number, amid: number, amax: number, fmin: number, fmid: number, fmax: number) {
-                    this.fA2F = new FaustSensors.Interpolator3pt(amin, amid, amax, fmin, fmax, fmin);
-                    this.fF2A = new FaustSensors.Interpolator(fmin, fmax, amin, amax);
+                constructor(
+                    amin: number,
+                    amid: number,
+                    amax: number,
+                    fmin: number,
+                    fmid: number,
+                    fmax: number
+                ) {
+                    this.fA2F = new FaustSensors.Interpolator3pt(
+                        amin,
+                        amid,
+                        amax,
+                        fmin,
+                        fmax,
+                        fmin
+                    );
+                    this.fF2A = new FaustSensors.Interpolator(
+                        fmin,
+                        fmax,
+                        amin,
+                        amax
+                    );
                 }
 
-                uiToFaust(x: number) { return this.fA2F.returnMappedValue(x) }
-                faustToUi(x: number) { return this.fF2A.returnMappedValue(x) }
+                uiToFaust(x: number) {
+                    return this.fA2F.returnMappedValue(x);
+                }
+                faustToUi(x: number) {
+                    return this.fF2A.returnMappedValue(x);
+                }
 
-                setMappingValues(amin: number, amid: number, amax: number, min: number, init: number, max: number): void {
-                    this.fA2F = new FaustSensors.Interpolator3pt(amin, amid, amax, min, max, min);
-                    this.fF2A = new FaustSensors.Interpolator(min, max, amin, amax);
+                setMappingValues(
+                    amin: number,
+                    amid: number,
+                    amax: number,
+                    min: number,
+                    init: number,
+                    max: number
+                ): void {
+                    this.fA2F = new FaustSensors.Interpolator3pt(
+                        amin,
+                        amid,
+                        amax,
+                        min,
+                        max,
+                        min
+                    );
+                    this.fF2A = new FaustSensors.Interpolator(
+                        min,
+                        max,
+                        amin,
+                        amax
+                    );
                 }
-                getMappingValues(amin: number, amid: number, amax: number): InterpolateObject3pt {
+                getMappingValues(
+                    amin: number,
+                    amid: number,
+                    amax: number
+                ): InterpolateObject3pt {
                     return this.fA2F.getMappingValues(amin, amid, amax);
                 }
 
-                setActive(onOff: boolean): void { this.fActive = onOff }
-                getActive(): boolean { return this.fActive }
-            }
-
+                setActive(onOff: boolean): void {
+                    this.fActive = onOff;
+                }
+                getActive(): boolean {
+                    return this.fActive;
+                }
+            };
         }
         return this._UpDownConverter;
     }
     /**
      * DownUpConverter class, convert accelerometer value to Faust value
      */
-    static _DownUpConverter: new (amin: number, amid: number, amax: number, fmin: number, fmid: number, fmax: number) => UpdatableValueConverter;
+    static _DownUpConverter: new (
+        amin: number,
+        amid: number,
+        amax: number,
+        fmin: number,
+        fmid: number,
+        fmax: number
+    ) => UpdatableValueConverter;
     static get DownUpConverter() {
         if (!this._DownUpConverter) {
             this._DownUpConverter = class implements UpdatableValueConverter {
-
                 fA2F: Interpolator3pt;
                 fF2A: Interpolator;
                 fActive: boolean = true;
 
-                constructor(amin: number, amid: number, amax: number, fmin: number, fmid: number, fmax: number) {
-                    this.fA2F = new FaustSensors.Interpolator3pt(amin, amid, amax, fmax, fmin, fmax);
-                    this.fF2A = new FaustSensors.Interpolator(fmin, fmax, amin, amax);
+                constructor(
+                    amin: number,
+                    amid: number,
+                    amax: number,
+                    fmin: number,
+                    fmid: number,
+                    fmax: number
+                ) {
+                    this.fA2F = new FaustSensors.Interpolator3pt(
+                        amin,
+                        amid,
+                        amax,
+                        fmax,
+                        fmin,
+                        fmax
+                    );
+                    this.fF2A = new FaustSensors.Interpolator(
+                        fmin,
+                        fmax,
+                        amin,
+                        amax
+                    );
                 }
 
-                uiToFaust(x: number) { return this.fA2F.returnMappedValue(x) }
-                faustToUi(x: number) { return this.fF2A.returnMappedValue(x) }
+                uiToFaust(x: number) {
+                    return this.fA2F.returnMappedValue(x);
+                }
+                faustToUi(x: number) {
+                    return this.fF2A.returnMappedValue(x);
+                }
 
-                setMappingValues(amin: number, amid: number, amax: number, min: number, init: number, max: number): void {
-                    this.fA2F = new FaustSensors.Interpolator3pt(amin, amid, amax, max, min, max);
-                    this.fF2A = new FaustSensors.Interpolator(min, max, amin, amax);
+                setMappingValues(
+                    amin: number,
+                    amid: number,
+                    amax: number,
+                    min: number,
+                    init: number,
+                    max: number
+                ): void {
+                    this.fA2F = new FaustSensors.Interpolator3pt(
+                        amin,
+                        amid,
+                        amax,
+                        max,
+                        min,
+                        max
+                    );
+                    this.fF2A = new FaustSensors.Interpolator(
+                        min,
+                        max,
+                        amin,
+                        amax
+                    );
                 }
-                getMappingValues(amin: number, amid: number, amax: number): InterpolateObject3pt {
+                getMappingValues(
+                    amin: number,
+                    amid: number,
+                    amax: number
+                ): InterpolateObject3pt {
                     return this.fA2F.getMappingValues(amin, amid, amax);
                 }
 
-                setActive(onOff: boolean): void { this.fActive = onOff }
-                getActive(): boolean { return this.fActive }
-            }
+                setActive(onOff: boolean): void {
+                    this.fActive = onOff;
+                }
+                getActive(): boolean {
+                    return this.fActive;
+                }
+            };
         }
         return this._DownUpConverter;
     }
@@ -351,18 +638,61 @@ export default class FaustSensors {
      *
      * @returns `UpdatableValueConverter` built for the given curve
      */
-    static buildHandler(curve: Curve, amin: number, amid: number, amax: number, min: number, init: number, max: number): UpdatableValueConverter {
+    static buildHandler(
+        curve: Curve,
+        amin: number,
+        amid: number,
+        amax: number,
+        min: number,
+        init: number,
+        max: number
+    ): UpdatableValueConverter {
         switch (curve) {
             case Curve.Up:
-                return new FaustSensors.UpConverter(amin, amid, amax, min, init, max);
+                return new FaustSensors.UpConverter(
+                    amin,
+                    amid,
+                    amax,
+                    min,
+                    init,
+                    max
+                );
             case Curve.Down:
-                return new FaustSensors.DownConverter(amin, amid, amax, min, init, max);
+                return new FaustSensors.DownConverter(
+                    amin,
+                    amid,
+                    amax,
+                    min,
+                    init,
+                    max
+                );
             case Curve.UpDown:
-                return new FaustSensors.UpDownConverter(amin, amid, amax, min, init, max);
+                return new FaustSensors.UpDownConverter(
+                    amin,
+                    amid,
+                    amax,
+                    min,
+                    init,
+                    max
+                );
             case Curve.DownUp:
-                return new FaustSensors.DownUpConverter(amin, amid, amax, min, init, max);
+                return new FaustSensors.DownUpConverter(
+                    amin,
+                    amid,
+                    amax,
+                    min,
+                    init,
+                    max
+                );
             default:
-                return new FaustSensors.UpConverter(amin, amid, amax, min, init, max);
+                return new FaustSensors.UpConverter(
+                    amin,
+                    amid,
+                    amax,
+                    min,
+                    init,
+                    max
+                );
         }
     }
 }