@khanacademy/wonder-blocks-timing 5.0.1 → 6.0.0

package/src/util/__tests__/interval.test.ts

@@ -1,234 +0,0 @@
-import Interval from "../interval";
-import {SchedulePolicy, ClearPolicy} from "../policies";
-
-describe("Interval", () => {
-    beforeEach(() => {
-        jest.useFakeTimers();
-    });
-
-    afterEach(() => {
-        jest.restoreAllMocks();
-    });
-
-    describe("constructor", () => {
-        it("creates instance", () => {
-            // Arrange
-
-            // Act
-            const result = new Interval(() => {}, 1000);
-
-            // Assert
-            expect(result).toBeDefined();
-        });
-
-        it("throws if the action is not a function", () => {
-            // Arrange
-
-            // Act
-            const underTest = () => new Interval(null as any, 1);
-
-            // Assert
-            expect(underTest).toThrowErrorMatchingInlineSnapshot(
-                `"Action must be a function"`,
-            );
-        });
-
-        it("throws if the period is less than 1", () => {
-            // Arrange
-
-            // Act
-            const underTest = () => new Interval(() => {}, 0);
-
-            // Assert
-            expect(underTest).toThrowErrorMatchingInlineSnapshot(
-                `"Interval period must be >= 1"`,
-            );
-        });
-
-        it("sets an interval when schedule policy is SchedulePolicy.Immediately", () => {
-            // Arrange
-            const intervalSpy = jest.spyOn(global, "setInterval");
-
-            // Act
-            // eslint-disable-next-line no-new
-            new Interval(() => {}, 1000, SchedulePolicy.Immediately);
-
-            // Assert
-            expect(intervalSpy).toHaveBeenCalledTimes(1);
-        });
-    });
-
-    describe("isSet", () => {
-        it("is false when the interval has not been set", () => {
-            // Arrange
-            const interval = new Interval(
-                () => {},
-                1000,
-                SchedulePolicy.OnDemand,
-            );
-
-            // Act
-            const result = interval.isSet;
-
-            // Assert
-            expect(result).toBeFalsy();
-        });
-
-        it("is true when the interval is active", () => {
-            // Arrange
-            const interval = new Interval(() => {}, 1000);
-            interval.set();
-
-            // Act
-            const result = interval.isSet;
-
-            // Assert
-            expect(result).toBeTruthy();
-        });
-
-        it("is false when the interval is cleared", () => {
-            // Arrange
-            const interval = new Interval(() => {}, 1000);
-            interval.set();
-            interval.clear();
-
-            // Act
-            const result = interval.isSet;
-
-            // Assert
-            expect(result).toBeFalsy();
-        });
-    });
-
-    describe("#set", () => {
-        it("should call setInterval", () => {
-            // Arrange
-            const intervalSpy = jest.spyOn(global, "setInterval");
-            const interval = new Interval(
-                () => {},
-                500,
-                SchedulePolicy.OnDemand,
-            );
-
-            // Act
-            interval.set();
-
-            // Assert
-            expect(intervalSpy).toHaveBeenNthCalledWith(
-                1,
-                expect.any(Function),
-                500,
-            );
-        });
-
-        it("should invoke setInterval to call the given action", () => {
-            // Arrange
-            const intervalSpy = jest.spyOn(global, "setInterval");
-            const action = jest.fn();
-            const interval = new Interval(
-                () => action(),
-                500,
-                SchedulePolicy.OnDemand,
-            );
-            interval.set();
-            const scheduledAction = intervalSpy.mock.calls[0][0];
-
-            // Act
-            scheduledAction();
-
-            // Assert
-            expect(action).toHaveBeenCalledTimes(1);
-        });
-
-        it("should clear the active interval", () => {
-            // Arrange
-            const action = jest.fn();
-            const interval = new Interval(
-                () => action(),
-                500,
-                SchedulePolicy.OnDemand,
-            );
-            interval.set();
-
-            // Act
-            interval.set();
-            jest.advanceTimersByTime(501);
-
-            // Assert
-            expect(action).toHaveBeenCalledTimes(1);
-        });
-
-        it("should set an interval that stays active while not cleared", () => {
-            // Arrange
-            const action = jest.fn();
-            const interval = new Interval(() => action(), 500);
-            interval.set();
-
-            // Act
-            jest.advanceTimersByTime(1501);
-
-            // Assert
-            expect(action).toHaveBeenCalledTimes(3);
-        });
-    });
-
-    describe("#clear", () => {
-        it("should clear an active interval", () => {
-            // Arrange
-            const action = jest.fn();
-            const interval = new Interval(action, 500);
-            interval.set();
-
-            // Act
-            interval.clear();
-            jest.advanceTimersByTime(501);
-
-            // Assert
-            expect(action).not.toHaveBeenCalled();
-        });
-
-        it("should invoke the action if clear policy is ClearPolicy.Resolve", () => {
-            // Arrange
-            const action = jest.fn();
-            const interval = new Interval(action, 500);
-            interval.set();
-
-            // Act
-            interval.clear(ClearPolicy.Resolve);
-            jest.advanceTimersByTime(501);
-
-            // Assert
-            expect(action).toHaveBeenCalledTimes(1);
-        });
-
-        it("should not invoke the action if clear policy is ClearPolicy.Cancel", () => {
-            // Arrange
-            const action = jest.fn();
-            const interval = new Interval(
-                action,
-                500,
-                SchedulePolicy.Immediately,
-            );
-
-            // Act
-            interval.clear(ClearPolicy.Cancel);
-            jest.advanceTimersByTime(501);
-
-            // Assert
-            expect(action).not.toHaveBeenCalled();
-        });
-
-        it("should not invoke the action if interval is inactive and clear policy is ClearPolicy.Resolve", () => {
-            // Arrange
-            const action = jest.fn();
-            const interval = new Interval(action, 500, SchedulePolicy.OnDemand);
-
-            // Act
-            interval.clear(ClearPolicy.Resolve);
-            jest.advanceTimersByTime(501);
-
-            // Assert
-            expect(action).not.toHaveBeenCalled();
-        });
-    });
-});

package/src/util/__tests__/timeout.test.ts

@@ -1,224 +0,0 @@
-import Timeout from "../timeout";
-import {SchedulePolicy, ClearPolicy} from "../policies";
-
-describe("Timeout", () => {
-    beforeEach(() => {
-        jest.useFakeTimers();
-    });
-
-    afterEach(() => {
-        jest.restoreAllMocks();
-    });
-
-    describe("constructor", () => {
-        it("creates instance", () => {
-            // Arrange
-
-            // Act
-            const result = new Timeout(() => {}, 0);
-
-            // Assert
-            expect(result).toBeDefined();
-        });
-
-        it("throws if the action is not a function", () => {
-            // Arrange
-
-            // Act
-            const underTest = () => new Timeout(null as any, 0);
-
-            // Assert
-            expect(underTest).toThrowErrorMatchingInlineSnapshot(
-                `"Action must be a function"`,
-            );
-        });
-
-        it("throws if the period is less than 0", () => {
-            // Arrange
-
-            // Act
-            const underTest = () => new Timeout(() => {}, -1);
-
-            // Assert
-            expect(underTest).toThrowErrorMatchingInlineSnapshot(
-                `"Timeout period must be >= 0"`,
-            );
-        });
-
-        it("sets a timeout when schedule policy is SchedulePolicy.Immediately", () => {
-            // Arrange
-            const timeoutSpy = jest.spyOn(global, "setTimeout");
-
-            // Act
-            // eslint-disable-next-line no-new
-            new Timeout(() => {}, 0, SchedulePolicy.Immediately);
-
-            // Assert
-            expect(timeoutSpy).toHaveBeenCalledTimes(1);
-        });
-    });
-
-    describe("isSet", () => {
-        it("is false when the timeout has not been set", () => {
-            // Arrange
-            const timeout = new Timeout(() => {}, 0, SchedulePolicy.OnDemand);
-
-            // Act
-            const result = timeout.isSet;
-
-            // Assert
-            expect(result).toBeFalsy();
-        });
-
-        it("is true when the timeout is pending", () => {
-            // Arrange
-            const timeout = new Timeout(() => {}, 0);
-            timeout.set();
-
-            // Act
-            const result = timeout.isSet;
-
-            // Assert
-            expect(result).toBeTruthy();
-        });
-
-        it("is false when the timeout has executed", () => {
-            // Arrange
-            const timeout = new Timeout(() => {}, 0);
-            timeout.set();
-            jest.runOnlyPendingTimers();
-
-            // Act
-            const result = timeout.isSet;
-
-            // Assert
-            expect(result).toBeFalsy();
-        });
-    });
-
-    describe("#set", () => {
-        it("should call setTimeout", () => {
-            // Arrange
-            const timeoutSpy = jest.spyOn(global, "setTimeout");
-            const timeout = new Timeout(() => {}, 500, SchedulePolicy.OnDemand);
-
-            // Act
-            timeout.set();
-
-            // Assert
-            expect(timeoutSpy).toHaveBeenNthCalledWith(
-                1,
-                expect.any(Function),
-                500,
-            );
-        });
-
-        it("should invoke setTimeout to call the given action", () => {
-            // Arrange
-            const timeoutSpy = jest.spyOn(global, "setTimeout");
-            const action = jest.fn();
-            const timeout = new Timeout(
-                () => action(),
-                500,
-                SchedulePolicy.OnDemand,
-            );
-            timeout.set();
-            const scheduledAction = timeoutSpy.mock.calls[0][0];
-
-            // Act
-            scheduledAction();
-
-            // Assert
-            expect(action).toHaveBeenCalledTimes(1);
-        });
-
-        it("should clear any pending timeout", () => {
-            // Arrange
-            const action = jest.fn();
-            const timeout = new Timeout(() => action(), 500);
-            timeout.set();
-
-            // Act
-            timeout.set();
-            jest.runOnlyPendingTimers();
-
-            // Assert
-            expect(action).toHaveBeenCalledTimes(1);
-        });
-
-        it("should set the timeout again if it has already executed", () => {
-            // Arrange
-            const timeoutSpy = jest.spyOn(global, "setTimeout");
-            const action = jest.fn();
-            const timeout = new Timeout(action, 500, SchedulePolicy.OnDemand);
-            timeout.set();
-            jest.runAllTimers();
-
-            // Act
-            timeout.set();
-
-            // Assert
-            expect(timeoutSpy).toHaveBeenCalledTimes(2);
-        });
-    });
-
-    describe("#clear", () => {
-        it("should clear a pending timout", () => {
-            // Arrange
-            const action = jest.fn();
-            const timeout = new Timeout(action, 500);
-            timeout.set();
-
-            // Act
-            timeout.clear();
-            jest.runOnlyPendingTimers();
-
-            // Assert
-            expect(action).not.toHaveBeenCalled();
-        });
-
-        it("should invoke the action if clear policy is ClearPolicy.Resolve", () => {
-            // Arrange
-            const action = jest.fn();
-            const timeout = new Timeout(action, 500);
-            timeout.set();
-
-            // Act
-            timeout.clear(ClearPolicy.Resolve);
-            jest.runOnlyPendingTimers();
-
-            // Assert
-            expect(action).toHaveBeenCalledTimes(1);
-        });
-
-        it("should not invoke the action if clear policy is ClearPolicy.Cancel", () => {
-            // Arrange
-            const action = jest.fn();
-            const timeout = new Timeout(
-                action,
-                500,
-                SchedulePolicy.Immediately,
-            );
-
-            // Act
-            timeout.clear(ClearPolicy.Cancel);
-            jest.runOnlyPendingTimers();
-
-            // Assert
-            expect(action).not.toHaveBeenCalled();
-        });
-
-        it("should not invoke the action if timeout is not pending", () => {
-            // Arrange
-            const action = jest.fn();
-            const timeout = new Timeout(action, 500, SchedulePolicy.OnDemand);
-
-            // Act
-            timeout.clear(ClearPolicy.Resolve);
-            jest.runOnlyPendingTimers();
-
-            // Assert
-            expect(action).not.toHaveBeenCalled();
-        });
-    });
-});

package/src/util/action-scheduler.ts

@@ -1,89 +0,0 @@
-import Timeout from "./timeout";
-import Interval from "./interval";
-import AnimationFrame from "./animation-frame";
-
-import type {
-    IAnimationFrame,
-    IInterval,
-    ITimeout,
-    IScheduleActions,
-    Options,
-} from "./types";
-
-/**
- * Implements the `IScheduleActions` API to provide timeout, interval, and
- * animation frame support. This is not intended for direct use, but instead
- * is to be used solely by the `ActionSchedulerProvider` to provide an
- * `IScheduleActions` instance.
- */
-export default class ActionScheduler implements IScheduleActions {
-    _disabled = false;
-    _registeredActions: Array<() => void> = [];
-    static readonly NoopAction: ITimeout & IAnimationFrame & IInterval = {
-        set: () => {},
-        get isSet() {
-            return false;
-        },
-        clear: () => {},
-    };
-
-    timeout(
-        action: () => unknown,
-        period: number,
-        options?: Options,
-    ): ITimeout {
-        if (this._disabled) {
-            return ActionScheduler.NoopAction;
-        }
-        const timeout = new Timeout(action, period, options?.schedulePolicy);
-        this._registeredActions.push(() => timeout.clear(options?.clearPolicy));
-        return timeout;
-    }
-
-    interval(
-        action: () => unknown,
-        period: number,
-        options?: Options,
-    ): IInterval {
-        if (this._disabled) {
-            return ActionScheduler.NoopAction;
-        }
-        const interval = new Interval(action, period, options?.schedulePolicy);
-        this._registeredActions.push(() =>
-            interval.clear(options?.clearPolicy),
-        );
-        return interval;
-    }
-
-    animationFrame(
-        action: (arg1: DOMHighResTimeStamp) => void,
-        options?: Options,
-    ): IAnimationFrame {
-        if (this._disabled) {
-            return ActionScheduler.NoopAction;
-        }
-        const animationFrame = new AnimationFrame(
-            action,
-            options?.schedulePolicy,
-        );
-        this._registeredActions.push(() =>
-            animationFrame.clear(options?.clearPolicy),
-        );
-        return animationFrame;
-    }
-
-    clearAll(): void {
-        const registered = [...this._registeredActions];
-        this._registeredActions = [];
-        registered.forEach((clearFn) => clearFn());
-    }
-
-    /**
-     * Prevents this scheduler from creating any additional actions.
-     * This also clears any pending actions.
-     */
-    disable(): void {
-        this._disabled = true;
-        this.clearAll();
-    }
-}

package/src/util/animation-frame.ts

@@ -1,103 +0,0 @@
-import {SchedulePolicy, ClearPolicy} from "./policies";
-
-import type {IAnimationFrame} from "./types";
-
-/**
- * Encapsulates everything associated with calling requestAnimationFrame/
- * cancelAnimationFrame, and managing the lifecycle of that request, including
- * the ability to resolve or cancel a pending request action.
- *
- * @export
- * @class AnimationFrame
- * @implements {IAnimationFrame}
- */
-export default class AnimationFrame implements IAnimationFrame {
-    _animationFrameId: number | null | undefined;
-    _action: (time: DOMHighResTimeStamp) => unknown;
-
-    /**
-     * Creates an animation frame request that will invoke the given action.
-     * The request is not made until set is called.
-     *
-     * @param  action The action to be invoked.
-     * @param [schedulePolicy] When SchedulePolicy.Immediately,
-     * the interval is set immediately on instantiation; otherwise, `set` must be
-     * called to set the interval.
-     * Defaults to `SchedulePolicy.Immediately`.
-     * @memberof AnimationFrame
-     */
-    constructor(
-        action: (time: DOMHighResTimeStamp) => unknown,
-        schedulePolicy: SchedulePolicy = SchedulePolicy.Immediately,
-    ) {
-        if (typeof action !== "function") {
-            throw new Error("Action must be a function");
-        }
-
-        this._action = action;
-
-        if (schedulePolicy === SchedulePolicy.Immediately) {
-            this.set();
-        }
-    }
-
-    /**
-     * Determine if the request is pending or not.
-     *
-     * @returns {boolean} true if the request is pending, otherwise
-     * false.
-     * @memberof AnimationFrame
-     */
-    get isSet(): boolean {
-        return this._animationFrameId != null;
-    }
-
-    /**
-     * Make the animation frame request.
-     *
-     * If the request is pending, this cancels that pending request and
-     * makes the request afresh. If the request is not pending, this
-     * makes a new request.
-     *
-     * @memberof AnimationFrame
-     */
-    set(): void {
-        if (this.isSet) {
-            this.clear(ClearPolicy.Cancel);
-        }
-        this._animationFrameId = requestAnimationFrame((time) =>
-            this.clear(ClearPolicy.Resolve, time),
-        );
-    }
-
-    /**
-     * Clear the pending request.
-     *
-     * If the request is pending, this cancels that pending request without
-     * invoking the action. If no request is pending, this does nothing.
-     *
-     * @param [policy] When ClearPolicy.Resolve, if the request
-     * was set when called, the request action is invoked after cancelling
-     * the request; otherwise, the pending action is cancelled.
-     * Defaults to `ClearPolicy.Cancel`.
-     * @param [time] Timestamp to pass to the action when
-     * ClearPolicy.Resolve is specified. Ignored when ClearPolicy.Cancel is
-     * specified.
-     *
-     * @memberof AnimationFrame
-     */
-    clear(
-        policy: ClearPolicy = ClearPolicy.Cancel,
-        time?: DOMHighResTimeStamp,
-    ): void {
-        const animationFrameId = this._animationFrameId;
-        this._animationFrameId = null;
-        if (animationFrameId == null) {
-            return;
-        }
-        cancelAnimationFrame(animationFrameId);
-        if (policy === ClearPolicy.Resolve) {
-            this._action(time || performance.now());
-        }
-    }
-}