@khanacademy/wonder-blocks-timing 5.0.0 → 5.0.2

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @khanacademy/wonder-blocks-timing
 
+## 5.0.2
+
+### Patch Changes
+
+-   02a1b298: Make sure we don't package tsconfig and tsbuildinfo files
+
+## 5.0.1
+
+### Patch Changes
+
+-   559e82d5: Update to build tooling, generating smaller output
+
 ## 5.0.0
 
 ### Major Changes

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@khanacademy/wonder-blocks-timing",
   "private": false,
-  "version": "5.0.0",
+  "version": "5.0.2",
   "design": "v1",
   "publishConfig": {
     "access": "public"
@@ -17,7 +17,7 @@
     "react": "16.14.0"
   },
   "devDependencies": {
-    "@khanacademy/wb-dev-build-settings": "^1.0.0"
+    "@khanacademy/wb-dev-build-settings": "^1.0.1"
   },
   "author": "",
   "license": "MIT"

package/src/components/__tests__/action-scheduler-provider.test.tsx

@@ -1,36 +0,0 @@
-import * as React from "react";
-import {render} from "@testing-library/react";
-
-import ActionSchedulerProvider from "../action-scheduler-provider";
-import ActionScheduler from "../../util/action-scheduler";
-
-jest.mock("../../util/action-scheduler");
-
-describe("ActionSchedulerProvider", () => {
-    it("should render children with action scheduler instance", () => {
-        // Arrange
-        const childrenMock = jest.fn().mockReturnValueOnce(null);
-
-        // Act
-        render(
-            <ActionSchedulerProvider>{childrenMock}</ActionSchedulerProvider>,
-        );
-
-        // Assert
-        expect(childrenMock).toHaveBeenCalledWith(expect.any(ActionScheduler));
-    });
-
-    it("should call disable on the action scheduler at unmount", () => {
-        // Arrange
-        const childrenMock = jest.fn().mockReturnValueOnce(null);
-        const {unmount} = render(
-            <ActionSchedulerProvider>{childrenMock}</ActionSchedulerProvider>,
-        );
-
-        // Act
-        unmount();
-
-        // Assert
-        expect(childrenMock.mock.calls[0][0].disable).toHaveBeenCalledTimes(1);
-    });
-});

package/src/components/__tests__/with-action-scheduler.test.tsx

@@ -1,22 +0,0 @@
-import * as React from "react";
-import {render, screen} from "@testing-library/react";
-
-import withActionScheduler from "../with-action-scheduler";
-
-import type {WithActionSchedulerProps} from "../../util/types";
-
-describe("withActionScheduler", () => {
-    it("should provide wrapped component with IScheduleActions instance", () => {
-        // Arrange
-        const Component = (props: WithActionSchedulerProps) => (
-            <>{props.schedule != null ? "true" : "false"}</>
-        );
-
-        // Act
-        const WithScheduler = withActionScheduler(Component);
-        render(<WithScheduler />);
-
-        // Assert
-        expect(screen.getByText("true")).toBeInTheDocument();
-    });
-});

package/src/components/action-scheduler-provider.ts

@@ -1,35 +0,0 @@
-import * as React from "react";
-import ActionScheduler from "../util/action-scheduler";
-
-import type {IScheduleActions} from "../util/types";
-
-type Props = {
-    /**
-     * A function that, when given an instance of `IScheduleActions` will
-     * render a `React.Node`.
-     */
-    children: (arg1: IScheduleActions) => React.ReactNode;
-};
-
-/**
- * A provider component that passes our action scheduling API to its children
- * and ensures that all scheduled actions are cleared on unmount.
- *
- * ```jsx
- * <ActionSchedulerProvider>
- *     {schedule => this.renderThingThatNeedsTimers(schedule)}
- * </ActionSchedulerProvider>
- * ```
- */
-export default class ActionSchedulerProvider extends React.Component<Props> {
-    componentWillUnmount() {
-        this._actionScheduler.disable();
-    }
-
-    _actionScheduler: ActionScheduler = new ActionScheduler();
-
-    render(): React.ReactNode {
-        const {children} = this.props;
-        return children(this._actionScheduler);
-    }
-}

package/src/components/with-action-scheduler.tsx

@@ -1,36 +0,0 @@
-import * as React from "react";
-
-import ActionSchedulerProvider from "./action-scheduler-provider";
-
-import type {IScheduleActions, WithActionSchedulerProps} from "../util/types";
-
-type WithoutActionScheduler<T> = Omit<T, "schedule">;
-
-/**
- * A higher order component that attaches the given component to an
- * `IScheduleActions` instance. Any actions scheduled will automatically be
- * cleared on unmount.
- *
- * @template TOwnProps The own props of the component being rendered, without
- * the additional action scheduler prop. To attach the additional prop to
- * these props use the `WithActionScheduler` type.
- */
-export default function withActionScheduler<
-    Props extends WithActionSchedulerProps,
->(WrappedComponent: React.ComponentType<Props>) {
-    const displayName = `withActionScheduler(${
-        WrappedComponent.displayName || WrappedComponent.name
-    })`;
-
-    const C = (props: WithoutActionScheduler<Props>) => (
-        <ActionSchedulerProvider>
-            {(schedule: IScheduleActions) => (
-                <WrappedComponent {...(props as Props)} schedule={schedule} />
-            )}
-        </ActionSchedulerProvider>
-    );
-
-    C.displayName = displayName;
-
-    return C;
-}

package/src/hooks/__tests__/use-interval.test.ts

@@ -1,520 +0,0 @@
-import {renderHook, act} from "@testing-library/react-hooks";
-import {SchedulePolicy, ClearPolicy, ActionPolicy} from "../../util/policies";
-
-import {useInterval} from "../use-interval";
-
-describe("useInterval", () => {
-    beforeEach(() => {
-        jest.useFakeTimers();
-    });
-
-    afterEach(() => {
-        jest.restoreAllMocks();
-    });
-
-    it("throws if the action is not a function", () => {
-        // Arrange
-
-        // Act
-        const {result} = renderHook(() => useInterval(null as any, 1000));
-
-        // Assert
-        expect(result.error).toEqual(Error("Action must be a function"));
-    });
-
-    it("throws if the period is less than 1", () => {
-        // Arrange
-
-        // Act
-        const {result} = renderHook(() => useInterval(() => {}, 0));
-
-        // Assert
-        expect(result.error).toEqual(Error("Interval period must be >= 1"));
-    });
-
-    it("sets an interval when schedule policy is SchedulePolicy.Immediately", () => {
-        // Arrange
-        const intervalSpy = jest.spyOn(global, "setInterval");
-
-        // Act
-        renderHook(() => useInterval(() => {}, 1000));
-
-        // Assert
-        expect(intervalSpy).toHaveBeenCalledTimes(1);
-    });
-
-    it("should call the action before unmounting when clear policy is Resolve", () => {
-        const action = jest.fn();
-        const {unmount} = renderHook(() =>
-            useInterval(action, 1000, {
-                clearPolicy: ClearPolicy.Resolve,
-            }),
-        );
-
-        act(() => {
-            unmount();
-        });
-
-        expect(action).toHaveBeenCalled();
-    });
-
-    it("should call the current action", () => {
-        // Arrange
-        const action1 = jest.fn();
-        const action2 = jest.fn();
-        const {rerender} = renderHook(
-            ({action}: any) => useInterval(action, 500),
-            {
-                initialProps: {action: action1},
-            },
-        );
-
-        // Act
-        rerender({action: action2});
-        jest.advanceTimersByTime(501);
-
-        // Assert
-        expect(action2).toHaveBeenCalledTimes(1);
-    });
-
-    it("should only call setInterval once even if action changes", () => {
-        // Arrange
-        const intervalSpy = jest.spyOn(global, "setInterval");
-        const action1 = jest.fn();
-        const action2 = jest.fn();
-        const {rerender} = renderHook(
-            ({action}: any) => useInterval(action, 500),
-            {
-                initialProps: {action: action1},
-            },
-        );
-
-        // Act
-        rerender({action: action2});
-
-        // Assert
-        expect(intervalSpy).toHaveBeenCalledTimes(1);
-    });
-
-    it("should not reset the interval if the action changes", () => {
-        // Arrange
-        const action1 = jest.fn();
-        const action2 = jest.fn();
-        const {rerender} = renderHook(
-            ({action}: any) => useInterval(action, 500),
-            {
-                initialProps: {action: action1},
-            },
-        );
-
-        // Act
-        jest.advanceTimersByTime(250);
-        rerender({action: action2});
-        jest.advanceTimersByTime(751);
-
-        // Assert
-        expect(action1).not.toHaveBeenCalled();
-        expect(action2).toHaveBeenCalledTimes(2);
-    });
-
-    it("should reset the interval if the action changes and the action policy is Reset", () => {
-        // Arrange
-        const action1 = jest.fn();
-        const action2 = jest.fn();
-        const {rerender} = renderHook(
-            ({action}: any) =>
-                useInterval(action, 500, {actionPolicy: ActionPolicy.Reset}),
-            {
-                initialProps: {action: action1},
-            },
-        );
-
-        // Act
-        jest.advanceTimersByTime(250);
-        rerender({action: action2});
-        jest.advanceTimersByTime(751);
-
-        // Assert
-        expect(action1).not.toHaveBeenCalled();
-        expect(action2).toHaveBeenCalledTimes(1);
-    });
-
-    it("should use the new interval period after changing it", () => {
-        // Arrange
-        const action = jest.fn();
-        const {rerender} = renderHook(
-            ({intervalMs}: any) => useInterval(action, intervalMs),
-            {
-                initialProps: {intervalMs: 500},
-            },
-        );
-        rerender({intervalMs: 1000});
-
-        // Act
-        jest.advanceTimersByTime(1501);
-
-        // Assert
-        expect(action).toHaveBeenCalledTimes(1);
-    });
-
-    it("should restart the interval if intervalMs changes", () => {
-        // Arrange
-        const intervalSpy = jest.spyOn(global, "setInterval");
-        const {rerender} = renderHook(
-            ({intervalMs}: any) => useInterval(() => {}, intervalMs),
-            {
-                initialProps: {intervalMs: 500},
-            },
-        );
-
-        // Act
-        rerender({intervalMs: 1000});
-
-        // Assert
-        expect(intervalSpy).toHaveBeenCalledWith(expect.any(Function), 500);
-        expect(intervalSpy).toHaveBeenCalledWith(expect.any(Function), 1000);
-    });
-
-    describe("isSet", () => {
-        it("is false when the interval has not been set [SchedulePolicy.OnDemand]", () => {
-            // Arrange
-            const {result} = renderHook(() =>
-                useInterval(() => {}, 1000, {
-                    schedulePolicy: SchedulePolicy.OnDemand,
-                }),
-            );
-
-            // Act
-            const isSet = result.current.isSet;
-
-            // Assert
-            expect(isSet).toBeFalsy();
-        });
-
-        it("is true when the interval is active", () => {
-            // Arrange
-            const {result} = renderHook(() => useInterval(() => {}, 1000));
-            act(() => {
-                result.current.set();
-            });
-
-            // Act
-            const isSet = result.current.isSet;
-
-            // Assert
-            expect(isSet).toBeTruthy();
-        });
-
-        it("is false when the interval is cleared", () => {
-            // Arrange
-            const {result} = renderHook(() => useInterval(() => {}, 1000));
-            act(() => {
-                result.current.set();
-                result.current.clear();
-            });
-
-            // Act
-            const isSet = result.current.isSet;
-
-            // Assert
-            expect(isSet).toBeFalsy();
-        });
-    });
-
-    describe("#set", () => {
-        it("should call setInterval", () => {
-            // Arrange
-            const intervalSpy = jest.spyOn(global, "setInterval");
-            const {result} = renderHook(() =>
-                useInterval(() => {}, 500, {
-                    schedulePolicy: SchedulePolicy.OnDemand,
-                }),
-            );
-
-            // Act
-            act(() => {
-                result.current.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 {result} = renderHook(() =>
-                useInterval(action, 500, {
-                    schedulePolicy: SchedulePolicy.OnDemand,
-                }),
-            );
-
-            act(() => {
-                result.current.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 {result} = renderHook(() =>
-                useInterval(action, 500, {
-                    schedulePolicy: SchedulePolicy.OnDemand,
-                }),
-            );
-            act(() => {
-                result.current.set();
-            });
-
-            // Act
-            act(() => {
-                result.current.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 {result} = renderHook(() =>
-                useInterval(action, 500, {
-                    schedulePolicy: SchedulePolicy.OnDemand,
-                }),
-            );
-            act(() => {
-                result.current.set();
-            });
-
-            // Act
-            act(() => {
-                jest.advanceTimersByTime(1501);
-            });
-
-            // Assert
-            expect(action).toHaveBeenCalledTimes(3);
-        });
-
-        it("should continue to be set after calling it multiple times", () => {
-            // Arrange
-            const action = jest.fn();
-            const {result} = renderHook(() =>
-                useInterval(action, 500, {
-                    schedulePolicy: SchedulePolicy.OnDemand,
-                }),
-            );
-            act(() => {
-                result.current.set();
-            });
-
-            // Act
-            act(() => {
-                result.current.set();
-            });
-            act(() => {
-                jest.advanceTimersByTime(501);
-            });
-
-            // Assert
-            expect(action).toHaveBeenCalled();
-        });
-
-        it("should set the interval after clearing it", () => {
-            // Arrange
-            const action = jest.fn();
-            const {result} = renderHook(() =>
-                useInterval(action, 500, {
-                    schedulePolicy: SchedulePolicy.OnDemand,
-                }),
-            );
-            act(() => {
-                result.current.clear();
-            });
-
-            // Act
-            act(() => {
-                result.current.set();
-            });
-            act(() => {
-                jest.advanceTimersByTime(501);
-            });
-
-            // Assert
-            expect(action).toHaveBeenCalled();
-        });
-
-        it("should reset the inteval after calling set() again", () => {
-            // Arrange
-            const action = jest.fn();
-            const {result} = renderHook(() =>
-                useInterval(action, 750, {
-                    schedulePolicy: SchedulePolicy.OnDemand,
-                }),
-            );
-
-            // Act
-            act(() => {
-                result.current.set();
-                jest.advanceTimersByTime(501);
-                result.current.set();
-                jest.advanceTimersByTime(501);
-            });
-
-            // Assert
-            expect(action).not.toHaveBeenCalled();
-        });
-
-        it("shouldn't throw an error if called after the component unmounted", () => {
-            const action = jest.fn();
-            const {result, unmount} = renderHook(() =>
-                useInterval(action, 500),
-            );
-            act(() => {
-                unmount();
-            });
-
-            // Act
-            const underTest = () => result.current.set();
-
-            // Assert
-            expect(underTest).not.toThrow();
-        });
-    });
-
-    describe("#clear", () => {
-        it("should clear an active interval", () => {
-            // Arrange
-            const action = jest.fn();
-            const {result} = renderHook(() => useInterval(action, 500));
-            act(() => {
-                result.current.set();
-            });
-
-            // Act
-            act(() => {
-                result.current.clear();
-            });
-            act(() => {
-                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 {result} = renderHook(() => useInterval(action, 500));
-            act(() => {
-                result.current.set();
-            });
-
-            // Act
-            act(() => {
-                result.current.clear(ClearPolicy.Resolve);
-            });
-            act(() => {
-                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 {result} = renderHook(() =>
-                useInterval(action, 500, {
-                    schedulePolicy: SchedulePolicy.Immediately,
-                }),
-            );
-            act(() => {
-                result.current.set();
-            });
-
-            // Act
-            act(() => {
-                result.current.clear(ClearPolicy.Cancel);
-            });
-            act(() => {
-                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 {result} = renderHook(() =>
-                useInterval(action, 500, {
-                    schedulePolicy: SchedulePolicy.OnDemand,
-                }),
-            );
-
-            // Act
-            act(() => {
-                result.current.clear(ClearPolicy.Resolve);
-                jest.advanceTimersByTime(501);
-            });
-
-            // Assert
-            expect(action).not.toHaveBeenCalled();
-        });
-
-        it("should not call the action on unmount if the interval is not running when the clearPolicy is ClearPolicy.Resolve", async () => {
-            // Arrange
-            const action = jest.fn();
-            const {result, unmount} = renderHook(() =>
-                useInterval(action, 500, {
-                    clearPolicy: ClearPolicy.Resolve,
-                }),
-            );
-
-            // Act
-            act(() => {
-                result.current.clear();
-            });
-            act(() => {
-                unmount();
-            });
-
-            // Assert
-            expect(action).not.toHaveBeenCalled();
-        });
-
-        it("should not error if calling clear() after unmounting", () => {
-            // Arrange
-            const action = jest.fn();
-            const {result, unmount} = renderHook(() =>
-                useInterval(action, 500),
-            );
-            act(() => {
-                unmount();
-            });
-
-            // Act
-            const underTest = () => result.current.clear();
-
-            // Assert
-            expect(underTest).not.toThrow();
-        });
-    });
-});