@vived/core 1.0.1 → 1.1.0

package/dist/types/Utilities/degreesToRadians.d.ts

@@ -0,0 +1,2 @@
+export declare function degreesToRadians(deg: number): number;
+//# sourceMappingURL=degreesToRadians.d.ts.map

package/dist/types/Utilities/degreesToRadians.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"degreesToRadians.d.ts","sourceRoot":"","sources":["../../../src/Utilities/degreesToRadians.ts"],"names":[],"mappings":"AAAA,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,MAAM,GAAE,MAAM,CAEnD"}

package/dist/types/Utilities/degreesToRadians.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=degreesToRadians.test.d.ts.map

package/dist/types/Utilities/degreesToRadians.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"degreesToRadians.test.d.ts","sourceRoot":"","sources":["../../../src/Utilities/degreesToRadians.test.ts"],"names":[],"mappings":""}

package/dist/types/Utilities/easeFunctions.d.ts

@@ -0,0 +1,24 @@
+import { EaseFn } from "../Types";
+export declare const easeLinear: EaseFn;
+export declare const quadIn: EaseFn;
+export declare const quadOut: EaseFn;
+export declare const quadInOut: EaseFn;
+export declare const cubicIn: EaseFn;
+export declare const cubicOut: EaseFn;
+export declare const cubicInOut: EaseFn;
+export declare const expoIn: EaseFn;
+export declare const expoOut: EaseFn;
+export declare const expoInOut: EaseFn;
+export declare const sinIn: EaseFn;
+export declare const sinOut: EaseFn;
+export declare const sinInOut: EaseFn;
+export declare const quartIn: EaseFn;
+export declare const quartOut: EaseFn;
+export declare const quartInOut: EaseFn;
+export declare const quintIn: EaseFn;
+export declare const quintOut: EaseFn;
+export declare const quintInOut: EaseFn;
+export declare const circIn: EaseFn;
+export declare const circOut: EaseFn;
+export declare const circInOut: EaseFn;
+//# sourceMappingURL=easeFunctions.d.ts.map

package/dist/types/Utilities/easeFunctions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"easeFunctions.d.ts","sourceRoot":"","sources":["../../../src/Utilities/easeFunctions.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AAGlC,eAAO,MAAM,UAAU,EAAE,MAKxB,CAAC;AAEF,eAAO,MAAM,MAAM,EAAE,MAKpB,CAAC;AAEF,eAAO,MAAM,OAAO,EAAE,MAKrB,CAAC;AAEF,eAAO,MAAM,SAAS,EAAE,MASvB,CAAC;AAEF,eAAO,MAAM,OAAO,EAAE,MAKrB,CAAC;AAEF,eAAO,MAAM,QAAQ,EAAE,MAKtB,CAAC;AAEF,eAAO,MAAM,UAAU,EAAE,MAWxB,CAAC;AAEF,eAAO,MAAM,MAAM,EAAE,MAKpB,CAAC;AAEF,eAAO,MAAM,OAAO,EAAE,MAKrB,CAAC;AAEF,eAAO,MAAM,SAAS,EAAE,MAOvB,CAAC;AAEF,eAAO,MAAM,KAAK,EAAE,MAKnB,CAAC;AAEF,eAAO,MAAM,MAAM,EAAE,MAKpB,CAAC;AAEF,eAAO,MAAM,QAAQ,EAAE,MAKtB,CAAC;AAEF,eAAO,MAAM,OAAO,EAAE,MAKrB,CAAC;AAEF,eAAO,MAAM,QAAQ,EAAE,MAKtB,CAAC;AAEF,eAAO,MAAM,UAAU,EAAE,MASxB,CAAC;AAEF,eAAO,MAAM,OAAO,EAAE,MAKrB,CAAC;AAEF,eAAO,MAAM,QAAQ,EAAE,MAKtB,CAAC;AAEF,eAAO,MAAM,UAAU,EAAE,MASxB,CAAC;AAEF,eAAO,MAAM,MAAM,EAAE,MAKpB,CAAC;AAEF,eAAO,MAAM,OAAO,EAAE,MAKrB,CAAC;AAEF,eAAO,MAAM,SAAS,EAAE,MASvB,CAAC"}

package/dist/types/Utilities/easeFunctions.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=easeFunctions.test.d.ts.map

package/dist/types/Utilities/easeFunctions.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"easeFunctions.test.d.ts","sourceRoot":"","sources":["../../../src/Utilities/easeFunctions.test.ts"],"names":[],"mappings":""}

package/dist/types/Utilities/generateUniqueID.d.ts

@@ -0,0 +1,2 @@
+export declare function generateUniqueID(): string;
+//# sourceMappingURL=generateUniqueID.d.ts.map

package/dist/types/Utilities/generateUniqueID.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generateUniqueID.d.ts","sourceRoot":"","sources":["../../../src/Utilities/generateUniqueID.ts"],"names":[],"mappings":"AAEA,wBAAgB,gBAAgB,IAAI,MAAM,CAEzC"}

package/dist/types/Utilities/index.d.ts

@@ -0,0 +1,6 @@
+export * from "./degreesToRadians";
+export * from "./LengthConverters";
+export * from "./generateUniqueID";
+export * from "./easeFunctions";
+export * from "./interpolateNumber";
+//# sourceMappingURL=index.d.ts.map

package/dist/types/Utilities/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/Utilities/index.ts"],"names":[],"mappings":"AAAA,cAAc,oBAAoB,CAAC;AACnC,cAAc,oBAAoB,CAAC;AACnC,cAAc,oBAAoB,CAAC;AACnC,cAAc,iBAAiB,CAAC;AAChC,cAAc,qBAAqB,CAAC"}

package/dist/types/Utilities/interpolateNumber.d.ts

@@ -0,0 +1,2 @@
+export declare function interpolateNumber(start: number, end: number, percent: number, clamp?: boolean): number;
+//# sourceMappingURL=interpolateNumber.d.ts.map

package/dist/types/Utilities/interpolateNumber.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"interpolateNumber.d.ts","sourceRoot":"","sources":["../../../src/Utilities/interpolateNumber.ts"],"names":[],"mappings":"AAAA,wBAAgB,iBAAiB,CAC/B,KAAK,EAAE,MAAM,EACb,GAAG,EAAE,MAAM,EACX,OAAO,EAAE,MAAM,EACf,KAAK,GAAE,OAAe,GACrB,MAAM,CAeR"}

package/dist/types/Utilities/interpolateNumber.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=interpolateNumber.test.d.ts.map

package/dist/types/Utilities/interpolateNumber.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"interpolateNumber.test.d.ts","sourceRoot":"","sources":["../../../src/Utilities/interpolateNumber.test.ts"],"names":[],"mappings":""}

package/dist/types/index.d.ts

@@ -1,5 +1,6 @@
 export * from "./AppObject";
 export * from "./Entities";
 export * from "./Types";
+export * from "./Utilities";
 export * from "./ValueObjects";
 //# sourceMappingURL=index.d.ts.map

package/dist/types/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAC;AAC5B,cAAc,YAAY,CAAC;AAC3B,cAAc,SAAS,CAAC;AACxB,cAAc,gBAAgB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAC;AAC5B,cAAc,YAAY,CAAC;AAC3B,cAAc,SAAS,CAAC;AACxB,cAAc,aAAa,CAAC;AAC5B,cAAc,gBAAgB,CAAC"}

package/package.json

@@ -1,9 +1,9 @@
 {
   "name": "@vived/core",
-  "version": "1.0.1",
+  "version": "1.1.0",
   "description": "Core Components for VIVED Apps and Hosts",
   "main": "dist/cjs/index.js",
-  "module": "dist/esm/index.js", 
+  "module": "dist/esm/index.js",
   "types": "dist/types/index.d.ts",
   "exports": {
     "import": "./dist/esm/index.js",
@@ -33,6 +33,7 @@
   "homepage": "https://bitbucket.org/cyberscience3d/npm_vived_core#readme",
   "devDependencies": {
     "@types/jest": "^29.5.14",
+    "@types/uuid": "^10.0.0",
     "jest": "^29.7.0",
     "prettier": "^3.5.3",
     "ts-jest": "^29.2.6",
@@ -42,5 +43,8 @@
   },
   "publishConfig": {
     "access": "public"
+  },
+  "dependencies": {
+    "uuid": "^11.1.0"
   }
 }

package/src/Utilities/LengthConverters.test.ts

@@ -0,0 +1,30 @@
+import {
+  feetToMeters,
+  inchesToMeters,
+  metersToFeet,
+  metersToInches,
+} from "./LengthConverters";
+
+test("Converting inches to meters", () => {
+  expect(inchesToMeters(0)).toEqual(0);
+  expect(inchesToMeters(12)).toEqual(0.30479983540808886);
+  expect(inchesToMeters(-12)).toEqual(-0.30479983540808886);
+});
+
+test("Converting meters to inches", () => {
+  expect(metersToInches(0)).toEqual(0);
+  expect(metersToInches(2)).toEqual(78.7402);
+  expect(metersToInches(-2)).toEqual(-78.7402);
+});
+
+test("Converting feet to meters", () => {
+  expect(feetToMeters(0)).toEqual(0);
+  expect(feetToMeters(5)).toEqual(1.5239999512320015);
+  expect(feetToMeters(-5)).toEqual(-1.5239999512320015);
+});
+
+test("Converting meters to feet", () => {
+  expect(metersToFeet(0)).toEqual(0);
+  expect(metersToFeet(2)).toEqual(6.56168);
+  expect(metersToFeet(-2)).toEqual(-6.56168);
+});

package/src/Utilities/LengthConverters.ts

@@ -0,0 +1,18 @@
+const inchesPerMeter = 39.3701;
+const feetPerMeter = 3.28084;
+
+export function inchesToMeters(inches: number): number {
+  return inches / inchesPerMeter;
+}
+
+export function metersToInches(meters: number): number {
+  return meters * inchesPerMeter;
+}
+
+export function feetToMeters(feet: number): number {
+  return feet / feetPerMeter;
+}
+
+export function metersToFeet(meters: number): number {
+  return meters * feetPerMeter;
+}

package/src/Utilities/LerpNumber.test.ts

@@ -0,0 +1,109 @@
+import { LerpNumber } from "./LerpNumber";
+
+describe("Lerp Number", () => {
+  let lerpNumber: LerpNumber;
+  let updateFn: jest.Mock;
+
+  beforeEach(() => {
+    lerpNumber = new LerpNumber();
+    updateFn = jest.fn();
+    jest.useFakeTimers();
+  });
+
+  afterEach(() => {
+    jest.useRealTimers();
+  });
+
+  it("should lerp from start to end value", async () => {
+    lerpNumber.defaultDurationMS = 1000;
+    const promise = lerpNumber.lerp({
+      start: 0,
+      end: 100,
+      update: updateFn,
+    });
+
+    // Test middle point (should have multiple updates by this point)
+    jest.advanceTimersByTime(500);
+    expect(updateFn).toHaveBeenCalledWith(expect.closeTo(50, 5)); // Allow some margin due to interval timing
+
+    // Complete animation
+    jest.advanceTimersByTime(500);
+    await promise;
+
+    expect(updateFn).toHaveBeenCalledWith(0); // Start value
+    expect(updateFn).toHaveBeenLastCalledWith(100); // End value
+  });
+
+  it("should cancel lerp when requested", async () => {
+    const onCancel = jest.fn();
+    const promise = lerpNumber.lerp({
+      start: 0,
+      end: 100,
+      update: updateFn,
+      onCancel,
+    });
+
+    expect(lerpNumber.isLerping).toBe(true);
+
+    lerpNumber.cancel();
+    jest.advanceTimersByTime(10); // Allow interval to execute
+    await promise;
+
+    expect(lerpNumber.isLerping).toBe(false);
+    expect(onCancel).toHaveBeenCalled();
+  });
+
+  it("should respect custom duration", async () => {
+    const promise = lerpNumber.lerp({
+      start: 0,
+      end: 100,
+      update: updateFn,
+      durationMS: 500,
+    });
+
+    jest.advanceTimersByTime(250); // Half way
+    expect(updateFn).toHaveBeenLastCalledWith(expect.any(Number));
+
+    jest.advanceTimersByTime(250); // Complete
+    await promise;
+
+    expect(updateFn).toHaveBeenLastCalledWith(100);
+  });
+
+  it("should call onComplete when finished", async () => {
+    const onComplete = jest.fn();
+    const promise = lerpNumber.lerp({
+      start: 0,
+      end: 100,
+      update: updateFn,
+      onComplete,
+    });
+
+    jest.advanceTimersByTime(1000);
+    await promise;
+
+    expect(onComplete).toHaveBeenCalled();
+  });
+
+  it("should cancel existing lerp when starting a new one", async () => {
+    const onCancel = jest.fn();
+    const firstPromise = lerpNumber.lerp({
+      start: 0,
+      end: 100,
+      update: updateFn,
+      onCancel,
+    });
+
+    const secondPromise = lerpNumber.lerp({
+      start: 200,
+      end: 300,
+      update: updateFn,
+    });
+
+    jest.advanceTimersByTime(1000);
+    await Promise.all([firstPromise, secondPromise]);
+
+    expect(onCancel).toHaveBeenCalled();
+    expect(updateFn).toHaveBeenLastCalledWith(300);
+  });
+});

package/src/Utilities/LerpNumber.ts

@@ -0,0 +1,109 @@
+import { EaseFn } from "../Types";
+import { quintInOut } from "./easeFunctions";
+
+/**
+ * Configuration object for performing a linear interpolation (lerp) operation.
+ * @interface LerpNumberDTO
+ */
+export interface LerpNumberDTO {
+  /** Starting value of the lerp */
+  start: number;
+  /** Target/ending value of the lerp */
+  end: number;
+  /** Callback function that receives the interpolated value on each update */
+  update: (value: number) => void;
+  /** Duration of the lerp in milliseconds. Defaults to LerpNumber.defaultDurationMS */
+  durationMS?: number;
+  /** Easing function to modify the interpolation curve. Defaults to LerpNumber.defaultEase */
+  ease?: EaseFn;
+  /** Optional callback function called when lerp completes naturally */
+  onComplete?: () => void;
+  /** Optional callback function called when lerp is cancelled */
+  onCancel?: () => void;
+}
+
+/**
+ * Utility class for smoothly interpolating between two numbers over time.
+ * Uses requestAnimationFrame for smooth animation and supports custom easing functions.
+ *
+ * @example
+ * const lerper = new LerpNumber();
+ * // Animate from 0 to 100 over 2 seconds
+ * await lerper.lerp({
+ *   start: 0,
+ *   end: 100,
+ *   durationMS: 2000,
+ *   update: (value) => console.log(value)
+ * });
+ */
+export class LerpNumber {
+  public defaultDurationMS = 1000;
+  public defaultEase: EaseFn = quintInOut;
+
+  public get isLerping() {
+    return this._isLerping;
+  }
+  private _isLerping = false;
+
+  /**
+   * Cancels the current lerp operation if one is in progress.
+   * Triggers the onCancel callback if provided in the original lerp configuration.
+   */
+  public cancel() {
+    if (!this._isLerping) return;
+
+    this._cancelLerp = true;
+  }
+
+  private _cancelLerp = false;
+
+  /**
+   * Initiates a lerp (linear interpolation) operation.
+   * If a lerp is already in progress, it will be cancelled before starting the new one.
+   *
+   * @param data - Configuration object for the lerp operation
+   * @returns Promise that resolves when the lerp completes or is cancelled
+   * @throws Never throws, but may reject if the update function throws
+   */
+  lerp = (data: LerpNumberDTO): Promise<void> => {
+    if (this._isLerping) {
+      this.cancel();
+    }
+    const { start, end, durationMS, ease, onComplete, update, onCancel } = data;
+
+    const durationToUse = durationMS ?? this.defaultDurationMS;
+    const easeToUse = ease ?? this.defaultEase;
+
+    return new Promise((resolve) => {
+      const startTime = performance.now();
+      this._isLerping = true;
+
+      update(start);
+
+      const interval = setInterval(() => {
+        if (this._cancelLerp) {
+          clearInterval(interval);
+          this._isLerping = false;
+          this._cancelLerp = false;
+          if (onCancel) onCancel();
+          return resolve();
+        }
+
+        const currentTime = performance.now();
+        const elapsedTime = currentTime - startTime;
+        const progress = Math.min(elapsedTime / durationToUse, 1);
+        const easedProgress = easeToUse(progress);
+        const value = start + (end - start) * easedProgress;
+        update(value);
+
+        if (progress >= 1) {
+          clearInterval(interval);
+          this._isLerping = false;
+          update(end);
+          if (onComplete) onComplete();
+          resolve();
+        }
+      }, 10);
+    });
+  };
+}

package/src/Utilities/degreesToRadians.test.ts

@@ -0,0 +1,8 @@
+import { degreesToRadians } from "./degreesToRadians"
+
+test("Converting degrees to radians", ()=>{
+  expect(degreesToRadians(0)).toEqual(0);
+  expect(degreesToRadians(180)).toBeCloseTo(Math.PI);
+  expect(degreesToRadians(-90)).toBeCloseTo(-Math.PI/2);
+})
+

package/src/Utilities/degreesToRadians.ts

@@ -0,0 +1,3 @@
+export function degreesToRadians(deg: number):number{
+  return deg * Math.PI / 180;
+}

package/src/Utilities/easeFunctions.test.ts

@@ -0,0 +1,251 @@
+import {
+  easeLinear,
+  quadIn,
+  quadInOut,
+  quadOut,
+  cubicIn,
+  cubicInOut,
+  cubicOut,
+  expoIn,
+  expoInOut,
+  expoOut,
+  sinIn,
+  sinInOut,
+  sinOut,
+  quartIn,
+  quartInOut,
+  quartOut,
+  quintIn,
+  quintInOut,
+  quintOut,
+  circIn,
+  circInOut,
+  circOut,
+} from "./easeFunctions";
+
+it("Returns the proper values for ease linear", () => {
+  expect(easeLinear(-1)).toEqual(0);
+  expect(easeLinear(0)).toEqual(0);
+  expect(easeLinear(0.25)).toEqual(0.25);
+  expect(easeLinear(0.5)).toEqual(0.5);
+  expect(easeLinear(0.75)).toEqual(0.75);
+  expect(easeLinear(1)).toEqual(1);
+  expect(easeLinear(2)).toEqual(1);
+});
+
+// Quad
+it("Returns the proper val for quad in", () => {
+  expect(quadIn(-1)).toEqual(0);
+  expect(quadIn(0)).toEqual(0);
+  expect(quadIn(0.25)).toEqual(0.0625);
+  expect(quadIn(0.5)).toEqual(0.25);
+  expect(quadIn(0.75)).toEqual(0.5625);
+  expect(quadIn(1)).toEqual(1);
+  expect(quadIn(2)).toEqual(1);
+});
+
+it("Returns the proper val for quad out", () => {
+  expect(quadOut(-1)).toEqual(0);
+  expect(quadOut(0)).toEqual(0);
+  expect(quadOut(0.25)).toEqual(0.4375);
+  expect(quadOut(0.5)).toEqual(0.75);
+  expect(quadOut(0.75)).toEqual(0.9375);
+  expect(quadOut(1)).toEqual(1);
+  expect(quadOut(2)).toEqual(1);
+});
+
+it("Returns the proper val for quad in out", () => {
+  expect(quadInOut(-1)).toEqual(0);
+  expect(quadInOut(0)).toEqual(0);
+  expect(quadInOut(0.25)).toEqual(0.125);
+  expect(quadInOut(0.5)).toEqual(0.5);
+  expect(quadInOut(0.75)).toEqual(0.875);
+  expect(quadInOut(1)).toEqual(1);
+  expect(quadInOut(2)).toEqual(1);
+});
+
+// Cubic
+it("Returns the proper val for cubic in", () => {
+  expect(cubicIn(-1)).toEqual(0);
+  expect(cubicIn(0)).toEqual(0);
+  expect(cubicIn(0.25)).toEqual(0.015625);
+  expect(cubicIn(0.5)).toEqual(0.125);
+  expect(cubicIn(0.75)).toEqual(0.421875);
+  expect(cubicIn(1)).toEqual(1);
+  expect(cubicIn(2)).toEqual(1);
+});
+
+it("Returns the proper val for cubic out", () => {
+  expect(cubicOut(-1)).toEqual(0);
+  expect(cubicOut(0)).toEqual(0);
+  expect(cubicOut(0.25)).toEqual(0.578125);
+  expect(cubicOut(0.5)).toEqual(0.875);
+  expect(cubicOut(0.75)).toEqual(0.984375);
+  expect(cubicOut(1)).toEqual(1);
+  expect(cubicOut(2)).toEqual(1);
+});
+
+it("Returns the proper val for cubic in out", () => {
+  expect(cubicInOut(-1)).toEqual(0);
+  expect(cubicInOut(0)).toEqual(0);
+  expect(cubicInOut(0.25)).toEqual(0.0625);
+  expect(cubicInOut(0.5)).toEqual(0.5);
+  expect(cubicInOut(0.75)).toEqual(0.9375);
+  expect(cubicInOut(1)).toEqual(1);
+  expect(cubicInOut(2)).toEqual(1);
+});
+
+// Expo
+it("Returns the proper val for Expo in", () => {
+  expect(expoIn(-1)).toEqual(0);
+  expect(expoIn(0)).toEqual(0);
+  expect(expoIn(0.25)).toEqual(0.005524271728019902);
+  expect(expoIn(0.5)).toEqual(0.03125);
+  expect(expoIn(0.75)).toEqual(0.17677669529663687);
+  expect(expoIn(1)).toEqual(1);
+  expect(expoIn(2)).toEqual(1);
+});
+
+it("Returns the proper val for Expo out", () => {
+  expect(expoOut(-1)).toEqual(0);
+  expect(expoOut(0)).toEqual(0);
+  expect(expoOut(0.25)).toEqual(0.8232233047033631);
+  expect(expoOut(0.5)).toEqual(0.96875);
+  expect(expoOut(0.75)).toEqual(0.99447572827198);
+  expect(expoOut(1)).toEqual(1);
+  expect(expoOut(2)).toEqual(1);
+});
+
+it("Returns the proper val for Expo in out", () => {
+  expect(expoInOut(-1)).toEqual(0);
+  expect(expoInOut(0)).toEqual(0);
+  expect(expoInOut(0.25)).toEqual(0.015625);
+  expect(expoInOut(0.5)).toEqual(0.5);
+  expect(expoInOut(0.75)).toEqual(0.984375);
+  expect(expoInOut(1)).toEqual(1);
+  expect(expoInOut(2)).toEqual(1);
+});
+
+// Sin
+it("Returns the proper val for Sin in", () => {
+  expect(sinIn(-1)).toEqual(0);
+  expect(sinIn(0)).toEqual(0);
+  expect(sinIn(0.25)).toEqual(0.07612046748871326);
+  expect(sinIn(0.5)).toEqual(0.2928932188134524);
+  expect(sinIn(0.75)).toEqual(0.6173165676349102);
+  expect(sinIn(1)).toEqual(1);
+  expect(sinIn(2)).toEqual(1);
+});
+
+it("Returns the proper val for Sin out", () => {
+  expect(sinOut(-1)).toEqual(0);
+  expect(sinOut(0)).toEqual(0);
+  expect(sinOut(0.25)).toEqual(0.3826834323650898);
+  expect(sinOut(0.5)).toEqual(0.7071067811865475);
+  expect(sinOut(0.75)).toEqual(0.9238795325112867);
+  expect(sinOut(1)).toEqual(1);
+  expect(sinOut(2)).toEqual(1);
+});
+
+it("Returns the proper val for Sin in out", () => {
+  expect(sinInOut(-1)).toEqual(0);
+  expect(sinInOut(0)).toEqual(0);
+  expect(sinInOut(0.25)).toEqual(0.1464466094067262);
+  expect(sinInOut(0.5)).toBeCloseTo(0.5);
+  expect(sinInOut(0.75)).toEqual(0.8535533905932737);
+  expect(sinInOut(1)).toEqual(1);
+  expect(sinInOut(2)).toEqual(1);
+});
+
+// Quart
+it("Returns the proper val for Quart in", () => {
+  expect(quartIn(-1)).toEqual(0);
+  expect(quartIn(0)).toEqual(0);
+  expect(quartIn(0.25)).toEqual(0.00390625);
+  expect(quartIn(0.5)).toEqual(0.0625);
+  expect(quartIn(0.75)).toEqual(0.31640625);
+  expect(quartIn(1)).toEqual(1);
+  expect(quartIn(2)).toEqual(1);
+});
+
+it("Returns the proper val for Quart out", () => {
+  expect(quartOut(-1)).toEqual(0);
+  expect(quartOut(0)).toEqual(0);
+  expect(quartOut(0.25)).toEqual(0.68359375);
+  expect(quartOut(0.5)).toEqual(0.9375);
+  expect(quartOut(0.75)).toEqual(0.99609375);
+  expect(quartOut(1)).toEqual(1);
+  expect(quartOut(2)).toEqual(1);
+});
+
+it("Returns the proper val for Quart in out", () => {
+  expect(quartInOut(-1)).toEqual(0);
+  expect(quartInOut(0)).toEqual(0);
+  expect(quartInOut(0.25)).toEqual(0.03125);
+  expect(quartInOut(0.5)).toBeCloseTo(0.5);
+  expect(quartInOut(0.75)).toEqual(0.96875);
+  expect(quartInOut(1)).toEqual(1);
+  expect(quartInOut(2)).toEqual(1);
+});
+
+// Quint
+it("Returns the proper val for Quint in", () => {
+  expect(quintIn(-1)).toEqual(0);
+  expect(quintIn(0)).toEqual(0);
+  expect(quintIn(0.25)).toEqual(0.0009765625);
+  expect(quintIn(0.5)).toEqual(0.03125);
+  expect(quintIn(0.75)).toEqual(0.2373046875);
+  expect(quintIn(1)).toEqual(1);
+  expect(quintIn(2)).toEqual(1);
+});
+
+it("Returns the proper val for Quint out", () => {
+  expect(quintOut(-1)).toEqual(0);
+  expect(quintOut(0)).toEqual(0);
+  expect(quintOut(0.25)).toEqual(0.7626953125);
+  expect(quintOut(0.5)).toEqual(0.96875);
+  expect(quintOut(0.75)).toEqual(0.9990234375);
+  expect(quintOut(1)).toEqual(1);
+  expect(quintOut(2)).toEqual(1);
+});
+
+it("Returns the proper val for Quint in out", () => {
+  expect(quintInOut(-1)).toEqual(0);
+  expect(quintInOut(0)).toEqual(0);
+  expect(quintInOut(0.25)).toEqual(0.015625);
+  expect(quintInOut(0.5)).toBeCloseTo(0.5);
+  expect(quintInOut(0.75)).toEqual(0.984375);
+  expect(quintInOut(1)).toEqual(1);
+  expect(quintInOut(2)).toEqual(1);
+});
+
+// Circ
+it("Returns the proper val for Circ in", () => {
+  expect(circIn(-1)).toEqual(0);
+  expect(circIn(0)).toEqual(0);
+  expect(circIn(0.25)).toEqual(0.031754163448145745);
+  expect(circIn(0.5)).toEqual(0.1339745962155614);
+  expect(circIn(0.75)).toEqual(0.3385621722338523);
+  expect(circIn(1)).toEqual(1);
+  expect(circIn(2)).toEqual(1);
+});
+
+it("Returns the proper val for Circ out", () => {
+  expect(circOut(-1)).toEqual(0);
+  expect(circOut(0)).toEqual(0);
+  expect(circOut(0.25)).toEqual(0.6614378277661477);
+  expect(circOut(0.5)).toEqual(0.8660254037844386);
+  expect(circOut(0.75)).toEqual(0.9682458365518543);
+  expect(circOut(1)).toEqual(1);
+  expect(circOut(2)).toEqual(1);
+});
+
+it("Returns the proper val for Circ in out", () => {
+  expect(circInOut(-1)).toEqual(0);
+  expect(circInOut(0)).toEqual(0);
+  expect(circInOut(0.25)).toEqual(0.0669872981077807);
+  expect(circInOut(0.5)).toBeCloseTo(0.5);
+  expect(circInOut(0.75)).toEqual(0.9330127018922193);
+  expect(circInOut(1)).toEqual(1);
+  expect(circInOut(2)).toEqual(1);
+});