@khanacademy/wonder-blocks-timing 2.1.1 → 2.1.2

package/dist/util/types.js.flow

@@ -0,0 +1,235 @@
+/**
+ * Flowtype definitions for types
+ * Generated by Flowgen from a Typescript Definition
+ * Flowgen v1.21.0
+ * @flow
+ */
+
+export type SchedulePolicy = "schedule-immediately" | "schedule-on-demand";
+export type ClearPolicy = "resolve-on-clear" | "cancel-on-clear";
+/**
+ * Encapsulates everything associated with calling setTimeout/clearTimeout, and
+ * managing the lifecycle of that timer, including the ability to resolve or
+ * cancel a pending timeout action.
+ * @export
+ * @interface ITimeout
+ */
+export interface ITimeout {
+  /**
+   * Determine if the timeout is set or not.
+   * @returns {boolean} true if the timeout is set (aka pending), otherwise
+   * false.
+   * @memberof ITimeout
+   */
+  isSet(): boolean;
+
+  /**
+   * Set the timeout.
+   *
+   * If the timeout is pending, this cancels that pending timeout and
+   * starts the timeout afresh. If the timeout is not pending, this
+   * starts the timeout.
+   * @memberof ITimeout
+   */
+  set(): void;
+
+  /**
+   * Clear the set timeout.
+   *
+   * If the timeout is pending, this cancels that pending timeout. If no
+   * timeout is pending, this does nothing.
+   * @param {ClearPolicy} [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`.
+   * @memberof ITimeout
+   */
+  clear(policy?: ClearPolicy): void;
+}
+/**
+ * Encapsulates everything associated with calling setInterval/clearInterval,
+ * and managing the lifecycle of that interval, including the ability to resolve
+ * or cancel an active interval.
+ * @export
+ * @interface IInterval
+ */
+export interface IInterval {
+  /**
+   * Determine if the interval is active or not.
+   * @returns {boolean} true if the interval is active, otherwise false.
+   * @memberof IInterval
+   */
+  isSet(): boolean;
+
+  /**
+   * Set the interval.
+   *
+   * If the interval is active, this cancels that interval and restarts it
+   * afresh. If the interval is not active, this starts the interval.
+   * @memberof IInterval
+   */
+  set(): void;
+
+  /**
+   * Clear the active interval.
+   *
+   * If the interval is active, this cancels that interval. If the interval
+   * is not active, this does nothing.
+   * @param {ClearPolicy} [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`.
+   * @memberof IInterval
+   */
+  clear(policy?: ClearPolicy): void;
+}
+/**
+ * Encapsulates everything associated with calling requestAnimationFrame/
+ * cancelAnimationFrame, and managing the lifecycle of that request, including
+ * the ability to resolve or cancel a pending request.
+ * @export
+ * @interface IAnimationFrame
+ */
+export interface IAnimationFrame {
+  /**
+   * Determine if the request is set or not.
+   * @returns {boolean} true if the request is set (aka pending), otherwise
+   * false.
+   * @memberof IAnimationFrame
+   */
+  isSet(): boolean;
+
+  /**
+   * Set the request.
+   *
+   * If the request is pending, this cancels that pending request and
+   * starts a request afresh. If the request is not pending, this
+   * starts the request.
+   * @memberof IAnimationFrame
+   */
+  set(): void;
+
+  /**
+   * Clear the set request.
+   *
+   * If the request is pending, this cancels that pending request. If no
+   * request is pending, this does nothing.
+   * @param {ClearPolicy} [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`.
+   * @memberof IAnimationFrame
+   */
+  clear(policy?: ClearPolicy): void;
+}
+export type Options = {
+  schedulePolicy?: SchedulePolicy,
+  clearPolicy?: ClearPolicy,
+  ...
+};
+/**
+ * Provides means to request timeouts, intervals, and animation frames, with
+ * additional support for clearing all requested actions.
+ *
+ * This interface describes a replacement for the `setTimeout`/`clearTimeout`,
+ * `setInterval`/`clearInterval` and `requestAnimationFrame`/`cancelAnimationFrame`
+ * APIs that supports the ability to easily clear all pending actions.
+ * @export
+ * @interface IScheduleActions
+ */
+export interface IScheduleActions {
+  /**
+   * Request a timeout.
+   *
+   * A timeout will wait for a given period and then invoke a given action.
+   * @param {() => void} action The action to be invoked when the timeout
+   * period is reached.
+   * @param {number} period The timeout period in milliseconds. The action
+   * will be invoked after this period has passed since the timeout was set.
+   * This value must be greater than or equal to zero.
+   * @param {boolean} [autoSchedule] Whether or not to set the timeout as soon
+   * as this call is made, or wait until `set` is explicitly called. Defaults
+   * to `true`.
+   * @param {boolean} [resolveOnClear] Whether or not the associated action
+   * will be invoked if it is still pending at the point the timeout is
+   * cleared. Defaults to `false`.
+   * @returns {ITimeout} A interface for manipulating the created timeout.
+   * @memberof IScheduleActions
+   */
+  timeout(action: () => mixed, period: number, options?: Options): ITimeout;
+
+  /**
+   * Request an interval.
+   *
+   * An interval will invoke a given action each time the given period has
+   * passed until the interval is cleared.
+   * @param {() => void} action The action to be invoked when the interval
+   * period occurs.
+   * @param {number} period The interval period in milliseconds. The action
+   * will be invoked each time this period has passed since the interval was
+   * set or last occurred.
+   * This value must be greater than zero.
+   * @param {boolean} [autoSchedule] Whether or not to set the interval as soon
+   * as this call is made, or wait until `set` is explicitly called. Defaults
+   * to `true`.
+   * @param {boolean} [resolveOnClear] Whether or not the associated action
+   * will be invoked at the point the interval is cleared if the interval
+   * is running at that time. Defaults to `false`.
+   * @returns {IInterval} An interface for manipulating the created interval.
+   * @memberof IScheduleActions
+   */
+  interval(action: () => mixed, period: number, options?: Options): IInterval;
+
+  /**
+   * Request an animation frame.
+   *
+   * An animation frame request tells the browser that you wish to perform an
+   * animation and requests that the browser call a specified function to
+   * update an animation before the next repaint.
+   * @param {DOMHighResTimeStamp}  => void} action The action to be invoked before the repaint.
+   * @param {boolean} [autoSchedule] Whether or not to make the request as soon
+   * as this call is made, or wait until `set` is explicitly called. Defaults
+   * to `true`.
+   * @param {boolean} [resolveOnClear] Whether or not the associated action
+   * will be invoked at the point the request is cleared if it has not yet
+   * executed. Defaults to `false`.
+   * @returns {IAnimationFrame} An interface for manipulating the created
+   * request.
+   * @memberof IScheduleActions
+   */
+  animationFrame(
+    action: (time: DOMHighResTimeStamp) => void,
+    options?: Options
+  ): IAnimationFrame;
+
+  /**
+   * Clears all timeouts, intervals, and animation frame requests that were
+   * made with this scheduler.
+   * @memberof IScheduleActions
+   */
+  clearAll(): void;
+}
+/**
+ * A props object type that can be spread into the a componenet wrapped with
+ * the `withActionScheduler` higher order component.
+ */
+export type WithActionSchedulerProps = {
+  /**
+   * An instance of the `IScheduleActions` API to use for scheduling
+   * intervals, timeouts, and animation frame requests.
+   */
+  schedule: IScheduleActions,
+  ...
+};
+export type WithoutActionScheduler<TProps: { [key: string]: any }> = $Diff<
+  TProps,
+  { schedule: any }
+>;
+/**
+ * Extends the given props with props that the `withActionScheduler` higher
+ * order component will inject.
+ */
+export type WithActionScheduler<TOwnProps: { [key: string]: any }> = {
+  ...TOwnProps,
+  ...WithActionSchedulerProps,
+};

package/dist/util/types.typestest.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/util/types.typestest.js.flow

@@ -0,0 +1,6 @@
+/**
+ * Flowtype definitions for types.typestest
+ * Generated by Flowgen from a Typescript Definition
+ * Flowgen v1.21.0
+ * @flow
+ */

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@khanacademy/wonder-blocks-timing",
   "private": false,
-  "version": "2.1.1",
+  "version": "2.1.2",
   "design": "v1",
   "publishConfig": {
     "access": "public"
@@ -9,7 +9,7 @@
   "description": "",
   "main": "dist/index.js",
   "module": "dist/es/index.js",
-  "source": "src/index.js",
+  "types": "dist/index.d.ts",
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1"
   },
@@ -17,7 +17,7 @@
     "react": "16.14.0"
   },
   "devDependencies": {
-    "wb-dev-build-settings": "^0.7.1"
+    "wb-dev-build-settings": "^0.7.2"
   },
   "author": "",
   "license": "MIT"

package/src/components/__tests__/{action-scheduler-provider.test.js → action-scheduler-provider.test.tsx}

@@ -1,4 +1,3 @@
-// @flow
 import * as React from "react";
 import {render} from "@testing-library/react";
 
@@ -32,7 +31,6 @@ describe("ActionSchedulerProvider", () => {
         unmount();
 
         // Assert
-        // $FlowIgnore[prop-missing]
         expect(childrenMock.mock.calls[0][0].disable).toHaveBeenCalledTimes(1);
     });
 });

package/src/components/__tests__/{with-action-scheduler.test.js → with-action-scheduler.test.tsx}

@@ -1,4 +1,3 @@
-// @flow
 import * as React from "react";
 import {render, screen} from "@testing-library/react";
 
@@ -9,8 +8,9 @@ import type {WithActionSchedulerProps} from "../../util/types";
 describe("withActionScheduler", () => {
     it("should provide wrapped component with IScheduleActions instance", () => {
         // Arrange
-        const Component = (props) =>
-            props.schedule != null ? "true" : "false";
+        const Component = (props: any) => (
+            <>{props.schedule != null ? "true" : "false"}</>
+        );
 
         // Act
         const WithScheduler = withActionScheduler(Component);
@@ -23,15 +23,15 @@ describe("withActionScheduler", () => {
     it("should forward a ref", () => {
         // Arrange
         class Component extends React.Component<WithActionSchedulerProps> {
-            render(): React.Node {
+            render(): React.ReactElement {
                 return <div>Hello, world!</div>;
             }
         }
         const TestComponent = withActionScheduler(Component);
-        let ref: mixed = null;
+        let ref: unknown = null;
 
         // Act
-        render(<TestComponent ref={(node) => (ref = node)} />);
+        render(<TestComponent ref={(node: any) => (ref = node)} />);
 
         // Assert
         expect(ref).toBeInstanceOf(Component);

package/src/components/{action-scheduler-provider.js → action-scheduler-provider.ts}

@@ -1,16 +1,15 @@
-// @flow
 import * as React from "react";
 import ActionScheduler from "../util/action-scheduler";
 
 import type {IScheduleActions} from "../util/types";
 
-type Props = {|
+type Props = {
     /**
      * A function that, when given an instance of `IScheduleActions` will
      * render a `React.Node`.
      */
-    children: (IScheduleActions) => React.Node,
-|};
+    children: (arg1: IScheduleActions) => React.ReactElement;
+};
 
 /**
  * A provider component that passes our action scheduling API to its children
@@ -29,7 +28,7 @@ export default class ActionSchedulerProvider extends React.Component<Props> {
 
     _actionScheduler: ActionScheduler = new ActionScheduler();
 
-    render(): React.Node {
+    render(): React.ReactElement {
         const {children} = this.props;
         return children(this._actionScheduler);
     }

package/src/components/{with-action-scheduler.js → with-action-scheduler.tsx}

@@ -1,15 +1,10 @@
-// @flow
 import * as React from "react";
 
 import ActionSchedulerProvider from "./action-scheduler-provider";
 
-import type {
-    IScheduleActions,
-    WithActionSchedulerProps,
-    WithActionScheduler,
-} from "../util/types";
+import type {IScheduleActions, WithActionSchedulerProps} from "../util/types";
 
-type WithoutActionScheduler<T> = $Exact<$Diff<T, WithActionSchedulerProps>>;
+type WithoutActionScheduler<T> = Omit<T, "schedule">;
 
 /**
  * A higher order component that attaches the given component to an
@@ -21,19 +16,16 @@ type WithoutActionScheduler<T> = $Exact<$Diff<T, WithActionSchedulerProps>>;
  * these props use the `WithActionScheduler` type.
  */
 export default function withActionScheduler<
-    -Config: WithActionSchedulerProps,
-    +Instance,
-    Component: React.AbstractComponent<WithActionScheduler<Config>, Instance>,
->(
-    WrappedComponent: Component,
-): React.AbstractComponent<
-    WithoutActionScheduler<React.ElementConfig<Component>>,
-    Instance,
-> {
-    return React.forwardRef<_, Instance>((props, ref) => (
+    Props extends WithActionSchedulerProps,
+>(WrappedComponent: React.ComponentType<Props>) {
+    return React.forwardRef((props: WithoutActionScheduler<Props>, ref) => (
         <ActionSchedulerProvider>
             {(schedule: IScheduleActions) => (
-                <WrappedComponent {...props} ref={ref} schedule={schedule} />
+                <WrappedComponent
+                    {...(props as Props)}
+                    ref={ref}
+                    schedule={schedule}
+                />
             )}
         </ActionSchedulerProvider>
     ));

package/src/hooks/__tests__/{use-interval.test.js → use-interval.test.ts}

@@ -1,4 +1,3 @@
-// @flow
 import {renderHook} from "@testing-library/react-hooks";
 
 import {useInterval} from "../use-interval";
@@ -38,7 +37,7 @@ describe("useTimeout", () => {
 
         // Act
         const {rerender} = renderHook(
-            ({active}) => useInterval(action, 500, active),
+            ({active}: any) => useInterval(action, 500, active),
             {initialProps: {active: false}},
         );
         rerender({active: true});
@@ -52,7 +51,7 @@ describe("useTimeout", () => {
         // Arrange
         const action = jest.fn();
         const {rerender} = renderHook(
-            ({active}) => useInterval(action, 500, active),
+            ({active}: any) => useInterval(action, 500, active),
             {initialProps: {active: true}},
         );
 
@@ -70,7 +69,7 @@ describe("useTimeout", () => {
 
         // Act
         const {rerender} = renderHook(
-            ({timeoutMs}) => useInterval(action, timeoutMs, true),
+            ({timeoutMs}: any) => useInterval(action, timeoutMs, true),
             {initialProps: {timeoutMs: 500}},
         );
         rerender({timeoutMs: 1000});
@@ -90,7 +89,7 @@ describe("useTimeout", () => {
 
         // Act
         const {rerender} = renderHook(
-            ({action}) => useInterval(action, 500, true),
+            ({action}: any) => useInterval(action, 500, true),
             {initialProps: {action: action1}},
         );
         // NOTE: For some reason setTimeout is called twice by the time we get
@@ -111,7 +110,7 @@ describe("useTimeout", () => {
 
         // Act
         const {rerender} = renderHook(
-            ({action}) => useInterval(action, 500, true),
+            ({action}: any) => useInterval(action, 500, true),
             {initialProps: {action: action1}},
         );
         rerender({action: action2});

package/src/hooks/__tests__/{use-scheduled-interval.test.js → use-scheduled-interval.test.ts}

@@ -1,4 +1,3 @@
-// @flow
 import {renderHook, act} from "@testing-library/react-hooks";
 import {SchedulePolicy, ClearPolicy} from "../../util/policies";
 
@@ -18,7 +17,7 @@ describe("useScheduledInterval", () => {
 
         // Act
         const {result} = renderHook(() =>
-            useScheduledInterval((null: any), 1000),
+            useScheduledInterval(null as any, 1000),
         );
 
         // Assert
@@ -66,7 +65,7 @@ describe("useScheduledInterval", () => {
         const action1 = jest.fn();
         const action2 = jest.fn();
         const {rerender} = renderHook(
-            ({action}) => useScheduledInterval(action, 500),
+            ({action}: any) => useScheduledInterval(action, 500),
             {
                 initialProps: {action: action1},
             },
@@ -86,7 +85,7 @@ describe("useScheduledInterval", () => {
         const action1 = jest.fn();
         const action2 = jest.fn();
         const {rerender} = renderHook(
-            ({action}) => useScheduledInterval(action, 500),
+            ({action}: any) => useScheduledInterval(action, 500),
             {
                 initialProps: {action: action1},
             },
@@ -103,7 +102,7 @@ describe("useScheduledInterval", () => {
         // Arrange
         const action = jest.fn();
         const {rerender} = renderHook(
-            ({intervalMs}) => useScheduledInterval(action, intervalMs),
+            ({intervalMs}: any) => useScheduledInterval(action, intervalMs),
             {
                 initialProps: {intervalMs: 500},
             },
@@ -121,7 +120,7 @@ describe("useScheduledInterval", () => {
         // Arrange
         const intervalSpy = jest.spyOn(global, "setInterval");
         const {rerender} = renderHook(
-            ({intervalMs}) => useScheduledInterval(() => {}, intervalMs),
+            ({intervalMs}: any) => useScheduledInterval(() => {}, intervalMs),
             {
                 initialProps: {intervalMs: 500},
             },

package/src/hooks/__tests__/{use-scheduled-timeout.test.js → use-scheduled-timeout.test.ts}

@@ -1,4 +1,3 @@
-// @flow
 import {renderHook, act} from "@testing-library/react-hooks";
 import {SchedulePolicy, ClearPolicy} from "../../util/policies";
 
@@ -18,7 +17,7 @@ describe("useScheduledTimeout", () => {
 
         // Act
         const {result} = renderHook(() =>
-            useScheduledTimeout((null: any), 1000),
+            useScheduledTimeout(null as any, 1000),
         );
 
         // Assert
@@ -81,7 +80,7 @@ describe("useScheduledTimeout", () => {
         const action1 = jest.fn();
         const action2 = jest.fn();
         const {rerender} = renderHook(
-            ({action}) => useScheduledTimeout(action, 500),
+            ({action}: any) => useScheduledTimeout(action, 500),
             {
                 initialProps: {action: action1},
             },
@@ -101,7 +100,7 @@ describe("useScheduledTimeout", () => {
         const action1 = jest.fn();
         const action2 = jest.fn();
         const {rerender} = renderHook(
-            ({action}) => useScheduledTimeout(action, 500),
+            ({action}: any) => useScheduledTimeout(action, 500),
             {
                 initialProps: {action: action1},
             },
@@ -122,7 +121,7 @@ describe("useScheduledTimeout", () => {
         // Arrange
         const action = jest.fn();
         const {rerender} = renderHook(
-            ({timeoutMs}) => useScheduledTimeout(action, timeoutMs),
+            ({timeoutMs}: any) => useScheduledTimeout(action, timeoutMs),
             {
                 initialProps: {timeoutMs: 500},
             },
@@ -140,7 +139,7 @@ describe("useScheduledTimeout", () => {
         // Arrange
         const timeoutSpy = jest.spyOn(global, "setTimeout");
         const {rerender} = renderHook(
-            ({timeoutMs}) => useScheduledTimeout(() => {}, timeoutMs),
+            ({timeoutMs}: any) => useScheduledTimeout(() => {}, timeoutMs),
             {
                 initialProps: {timeoutMs: 500},
             },
@@ -211,7 +210,7 @@ describe("useScheduledTimeout", () => {
             // Arrange
             const action = jest.fn();
             const {rerender} = renderHook(
-                ({timeoutMs}) => useScheduledTimeout(action, timeoutMs),
+                ({timeoutMs}: any) => useScheduledTimeout(action, timeoutMs),
                 {
                     initialProps: {timeoutMs: 1000},
                 },
@@ -236,7 +235,7 @@ describe("useScheduledTimeout", () => {
             // Arrange
             const action = jest.fn();
             const {rerender} = renderHook(
-                ({timeoutMs}) => useScheduledTimeout(action, timeoutMs),
+                ({timeoutMs}: any) => useScheduledTimeout(action, timeoutMs),
                 {
                     initialProps: {timeoutMs: 1000},
                 },
@@ -257,7 +256,7 @@ describe("useScheduledTimeout", () => {
             const action1 = jest.fn();
             const action2 = jest.fn();
             const {rerender} = renderHook(
-                ({action}) => useScheduledTimeout(action, 1000),
+                ({action}: any) => useScheduledTimeout(action, 1000),
                 {
                     initialProps: {action: action1},
                 },
@@ -278,7 +277,7 @@ describe("useScheduledTimeout", () => {
             const action1 = jest.fn();
             const action2 = jest.fn();
             const {rerender} = renderHook(
-                ({action}) => useScheduledTimeout(action, 1000),
+                ({action}: any) => useScheduledTimeout(action, 1000),
                 {
                     initialProps: {action: action1},
                 },

package/src/hooks/__tests__/{use-timeout.test.js → use-timeout.test.ts}

@@ -1,4 +1,3 @@
-// @flow
 import {renderHook} from "@testing-library/react-hooks";
 
 import {useTimeout} from "../use-timeout";
@@ -48,7 +47,7 @@ describe("useTimeout", () => {
         // Arrange
         const action = jest.fn();
         const {rerender} = renderHook(
-            ({active}) => useTimeout(action, 500, active),
+            ({active}: any) => useTimeout(action, 500, active),
             {initialProps: {active: false}},
         );
 
@@ -64,7 +63,7 @@ describe("useTimeout", () => {
         // Arrange
         const action = jest.fn();
         const {rerender} = renderHook(
-            ({active}) => useTimeout(action, 500, active),
+            ({active}: any) => useTimeout(action, 500, active),
             {initialProps: {active: true}},
         );
 
@@ -82,7 +81,7 @@ describe("useTimeout", () => {
 
         // Act
         const {rerender} = renderHook(
-            ({timeoutMs}) => useTimeout(action, timeoutMs, true),
+            ({timeoutMs}: any) => useTimeout(action, timeoutMs, true),
             {initialProps: {timeoutMs: 500}},
         );
         rerender({timeoutMs: 1000});
@@ -102,7 +101,7 @@ describe("useTimeout", () => {
 
         // Act
         const {rerender} = renderHook(
-            ({action}) => useTimeout(action, 500, true),
+            ({action}: any) => useTimeout(action, 500, true),
             {initialProps: {action: action1}},
         );
         // NOTE: For some reason setTimeout is called twice by the time we get
@@ -123,7 +122,7 @@ describe("useTimeout", () => {
 
         // Act
         const {rerender} = renderHook(
-            ({action}) => useTimeout(action, 500, true),
+            ({action}: any) => useTimeout(action, 500, true),
             {initialProps: {action: action1}},
         );
         rerender({action: action2});

package/src/hooks/internal/{use-updating-ref.js → use-updating-ref.ts}

@@ -1,4 +1,3 @@
-// @flow
 import {useEffect, useRef} from "react";
 
 /**
@@ -11,7 +10,11 @@ import {useEffect, useRef} from "react";
  *
  * @returns {{current: T}}
  */
-export const useUpdatingRef = <T>(value: T): {|current: T|} => {
+export const useUpdatingRef = <T>(
+    value: T,
+): {
+    current: T;
+} => {
     const ref = useRef<T>(value);
     useEffect(() => {
         ref.current = value;

package/src/hooks/{use-interval.js → use-interval.ts}

@@ -1,4 +1,3 @@
-// @flow
 import {useEffect} from "react";
 
 import {useUpdatingRef} from "./internal/use-updating-ref";
@@ -11,7 +10,7 @@ import {useUpdatingRef} from "./internal/use-updating-ref";
  * @param active whether or not the interval is active
  */
 export function useInterval(
-    action: () => mixed,
+    action: () => unknown,
     intervalMs: number,
     active: boolean,
 ) {

package/src/hooks/{use-scheduled-interval.js → use-scheduled-interval.ts}

@@ -1,4 +1,3 @@
-// @flow
 import {useEffect, useState, useCallback} from "react";
 
 import {
@@ -11,7 +10,7 @@ import {useUpdatingRef} from "./internal/use-updating-ref";
 import {useInterval} from "./use-interval";
 
 export function useScheduledInterval(
-    action: () => mixed,
+    action: () => unknown,
     intervalMs: number,
     options?: Options,
 ): IInterval {
@@ -69,5 +68,6 @@ export function useScheduledInterval(
 
     useInterval(action, intervalMs, isSet);
 
+    // @ts-expect-error [FEI-5019] - TS2322 - Type 'boolean' is not assignable to type '() => boolean'.
     return {isSet, set, clear};
 }