(#130) Updated implementation

Author: s1hofmann

Diff for: index.ts

@@ -31,7 +31,7 @@ export {Button} from "./lib/button.enum";
 export {centerOf, randomPointIn} from "./lib/location.function";
 export {LocationParameters} from "./lib/locationparameters.class";
 export {OptionalSearchParameters} from "./lib/optionalsearchparameters.class";
-export {linear} from "./lib/movementtype.function";
+export {EasingFunction, linear} from "./lib/mouse-movement.function";
 export {Point} from "./lib/point.class";
 export {Region} from "./lib/region.class";
 export {Window} from "./lib/window.class";

Diff for: lib/mouse-movement.function.spec.ts

@@ -0,0 +1,60 @@
+import {
+    calculateBaseStepDuration,
+    linear,
+    calculateMovementTimesteps
+} from "./mouse-movement.function";
+
+describe("MovementType", () => {
+    describe("baseStepDuration", () => {
+        it("should calculate the base step duration in nanoseconds", () => {
+            // GIVEN
+            const speedInPixelsPerSecond = 1000;
+            const expectedBaseStepDuration = 1_000_000;
+
+            // WHEN
+            const result = calculateBaseStepDuration(speedInPixelsPerSecond);
+
+            // THEN
+            expect(result).toBe(expectedBaseStepDuration);
+        });
+    });
+
+    describe("stepDuration", () => {
+        it("should call easing function progress to calculate current step duration", () => {
+            // GIVEN
+            const amountOfSteps = 100;
+            const speedInPixelsPerSecond = 1000;
+            const easingFunction = jest.fn(() => 0);
+
+            // WHEN
+            calculateMovementTimesteps(amountOfSteps, speedInPixelsPerSecond, easingFunction);
+
+            // THEN
+            expect(easingFunction).toBeCalledTimes(amountOfSteps);
+        })
+    });
+
+    describe('linear', () => {
+        it("should return a set of linear timesteps, 1000000 nanosecond per step.", () => {
+            // GIVEN
+            const expected = [1000000, 1000000, 1000000, 1000000, 1000000, 1000000];
+
+            // WHEN
+            const result = calculateMovementTimesteps(6, 1000, linear);
+
+            // THEN
+            expect(result).toEqual(expected);
+        });
+
+        it("should should return a set of linear timesteps, 2000000 nanoseconds per step.", () => {
+            // GIVEN
+            const expected = [2000000, 2000000, 2000000, 2000000, 2000000, 2000000];
+
+            // WHEN
+            const result = calculateMovementTimesteps(6, 500, linear);
+
+            // THEN
+            expect(result).toEqual(expected);
+        });
+    });
+});

Diff for: lib/mouse-movement.function.ts

@@ -0,0 +1,34 @@
+/**
+ * {@link EasingFunction}s are used to modify movement behaviour.
+ *
+ * See https://easings.net/ for reference
+ */
+export interface EasingFunction {
+    (progressPercentage: number): number;
+}
+
+export const calculateBaseStepDuration = (speedInPixelsPerSecond: number) => (1 / speedInPixelsPerSecond) * 1_000_000_000;
+
+export const calculateMovementTimesteps = (
+    amountOfSteps: number,
+    speedInPixelsPerSecond: number,
+    easingFunction: EasingFunction = linear
+): number[] => {
+    // Duration per movement step in nanoseconds
+    let baseStepDuration = calculateBaseStepDuration(speedInPixelsPerSecond);
+    baseStepDuration = (isFinite(baseStepDuration) && baseStepDuration > 0) ? baseStepDuration : 0;
+
+    return Array(amountOfSteps)
+        .fill(baseStepDuration)
+        .map((duration: number, idx: number) => {
+            if (typeof easingFunction === "function") {
+                const stepDuration = duration * (1 + easingFunction(idx / amountOfSteps));
+                return stepDuration > 0 ? stepDuration : 0;
+            }
+            return duration;
+        });
+};
+
+export const linear: EasingFunction = (_: number): number => {
+    return 0;
+};