@khanacademy/wonder-blocks-timing 2.1.1 → 2.1.2

package/dist/hooks/use-timeout.js.flow

@@ -0,0 +1,18 @@
+/**
+ * Flowtype definitions for use-timeout
+ * Generated by Flowgen from a Typescript Definition
+ * Flowgen v1.21.0
+ * @flow
+ */
+
+/**
+ * A simple hook for using `setTimeout`.
+ * @param action called after `timeoutMs` when `active` is true
+ * @param timeoutMs the duration after which `action` is called
+ * @param active whether or not the interval is active
+ */
+declare export function useTimeout(
+  action: () => mixed,
+  timeoutMs: number,
+  active: boolean
+): void;

package/dist/index.d.ts

@@ -0,0 +1,8 @@
+import type { IAnimationFrame, IInterval, IScheduleActions, ITimeout, WithActionScheduler, WithActionSchedulerProps, WithoutActionScheduler } from "./util/types";
+export type { IAnimationFrame, IInterval, IScheduleActions, ITimeout, WithActionScheduler, WithActionSchedulerProps, WithoutActionScheduler, };
+export { SchedulePolicy, ClearPolicy } from "./util/policies";
+export { default as withActionScheduler } from "./components/with-action-scheduler";
+export { useInterval } from "./hooks/use-interval";
+export { useTimeout } from "./hooks/use-timeout";
+export { useScheduledInterval } from "./hooks/use-scheduled-interval";
+export { useScheduledTimeout } from "./hooks/use-scheduled-timeout";

package/dist/index.js

@@ -2,11 +2,8 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var _extends = require('@babel/runtime/helpers/extends');
 var React = require('react');
 
-function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
-
 function _interopNamespace(e) {
     if (e && e.__esModule) return e;
     var n = Object.create(null);
@@ -25,7 +22,6 @@ function _interopNamespace(e) {
     return Object.freeze(n);
 }
 
-var _extends__default = /*#__PURE__*/_interopDefaultLegacy(_extends);
 var React__namespace = /*#__PURE__*/_interopNamespace(React);
 
 const SchedulePolicy = {
@@ -37,227 +33,278 @@ const ClearPolicy = {
   Cancel: "cancel-on-clear"
 };
 
-class Timeout {
-  constructor(action, timeoutMs, schedulePolicy = SchedulePolicy.Immediately) {
+function _extends() {
+  _extends = Object.assign ? Object.assign.bind() : function (target) {
+    for (var i = 1; i < arguments.length; i++) {
+      var source = arguments[i];
+      for (var key in source) {
+        if (Object.prototype.hasOwnProperty.call(source, key)) {
+          target[key] = source[key];
+        }
+      }
+    }
+    return target;
+  };
+  return _extends.apply(this, arguments);
+}
+
+function _setPrototypeOf(o, p) {
+  _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) {
+    o.__proto__ = p;
+    return o;
+  };
+  return _setPrototypeOf(o, p);
+}
+
+function _inheritsLoose(subClass, superClass) {
+  subClass.prototype = Object.create(superClass.prototype);
+  subClass.prototype.constructor = subClass;
+  _setPrototypeOf(subClass, superClass);
+}
+
+function _typeof(obj) {
+  "@babel/helpers - typeof";
+
+  return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) {
+    return typeof obj;
+  } : function (obj) {
+    return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
+  }, _typeof(obj);
+}
+
+function _toPrimitive(input, hint) {
+  if (_typeof(input) !== "object" || input === null) return input;
+  var prim = input[Symbol.toPrimitive];
+  if (prim !== undefined) {
+    var res = prim.call(input, hint || "default");
+    if (_typeof(res) !== "object") return res;
+    throw new TypeError("@@toPrimitive must return a primitive value.");
+  }
+  return (hint === "string" ? String : Number)(input);
+}
+
+function _toPropertyKey(arg) {
+  var key = _toPrimitive(arg, "string");
+  return _typeof(key) === "symbol" ? key : String(key);
+}
+
+function _defineProperties(target, props) {
+  for (var i = 0; i < props.length; i++) {
+    var descriptor = props[i];
+    descriptor.enumerable = descriptor.enumerable || false;
+    descriptor.configurable = true;
+    if ("value" in descriptor) descriptor.writable = true;
+    Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor);
+  }
+}
+function _createClass(Constructor, protoProps, staticProps) {
+  if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+  if (staticProps) _defineProperties(Constructor, staticProps);
+  Object.defineProperty(Constructor, "prototype", {
+    writable: false
+  });
+  return Constructor;
+}
+
+let Timeout = function () {
+  function Timeout(action, timeoutMs, schedulePolicy = SchedulePolicy.Immediately) {
+    this._timeoutId = void 0;
+    this._action = void 0;
+    this._timeoutMs = void 0;
     if (typeof action !== "function") {
       throw new Error("Action must be a function");
     }
-
     if (timeoutMs < 0) {
       throw new Error("Timeout period must be >= 0");
     }
-
     this._action = action;
     this._timeoutMs = timeoutMs;
-
     if (schedulePolicy === SchedulePolicy.Immediately) {
       this.set();
     }
   }
-
-  get isSet() {
-    return this._timeoutId != null;
-  }
-
-  set() {
+  var _proto = Timeout.prototype;
+  _proto.set = function set() {
     if (this.isSet) {
       this.clear(ClearPolicy.Cancel);
     }
-
     this._timeoutId = setTimeout(() => this.clear(ClearPolicy.Resolve), this._timeoutMs);
-  }
-
-  clear(policy = ClearPolicy.Cancel) {
+  };
+  _proto.clear = function clear(policy = ClearPolicy.Cancel) {
     const timeoutId = this._timeoutId;
     this._timeoutId = null;
-
     if (timeoutId == null) {
       return;
     }
-
     clearTimeout(timeoutId);
-
     if (policy === ClearPolicy.Resolve) {
       this._action();
     }
-  }
-
-}
-
-class Interval {
-  constructor(action, intervalMs, schedulePolicy = SchedulePolicy.Immediately) {
+  };
+  _createClass(Timeout, [{
+    key: "isSet",
+    get: function () {
+      return this._timeoutId != null;
+    }
+  }]);
+  return Timeout;
+}();
+
+let Interval = function () {
+  function Interval(action, intervalMs, schedulePolicy = SchedulePolicy.Immediately) {
+    this._intervalId = void 0;
+    this._action = void 0;
+    this._intervalMs = void 0;
     if (typeof action !== "function") {
       throw new Error("Action must be a function");
     }
-
     if (intervalMs < 1) {
       throw new Error("Interval period must be >= 1");
     }
-
     this._action = action;
     this._intervalMs = intervalMs;
-
     if (schedulePolicy === SchedulePolicy.Immediately) {
       this.set();
     }
   }
-
-  get isSet() {
-    return this._intervalId != null;
-  }
-
-  set() {
+  var _proto = Interval.prototype;
+  _proto.set = function set() {
     if (this.isSet) {
       this.clear(ClearPolicy.Cancel);
     }
-
     this._intervalId = setInterval(() => this._action(), this._intervalMs);
-  }
-
-  clear(policy = ClearPolicy.Cancel) {
+  };
+  _proto.clear = function clear(policy = ClearPolicy.Cancel) {
     const intervalId = this._intervalId;
     this._intervalId = null;
-
     if (intervalId == null) {
       return;
     }
-
     clearInterval(intervalId);
-
     if (policy === ClearPolicy.Resolve) {
       this._action();
     }
-  }
-
-}
-
-class AnimationFrame {
-  constructor(action, schedulePolicy = SchedulePolicy.Immediately) {
+  };
+  _createClass(Interval, [{
+    key: "isSet",
+    get: function () {
+      return this._intervalId != null;
+    }
+  }]);
+  return Interval;
+}();
+
+let AnimationFrame = function () {
+  function AnimationFrame(action, schedulePolicy = SchedulePolicy.Immediately) {
+    this._animationFrameId = void 0;
+    this._action = void 0;
     if (typeof action !== "function") {
       throw new Error("Action must be a function");
     }
-
     this._action = action;
-
     if (schedulePolicy === SchedulePolicy.Immediately) {
       this.set();
     }
   }
-
-  get isSet() {
-    return this._animationFrameId != null;
-  }
-
-  set() {
+  var _proto = AnimationFrame.prototype;
+  _proto.set = function set() {
     if (this.isSet) {
       this.clear(ClearPolicy.Cancel);
     }
-
     this._animationFrameId = requestAnimationFrame(time => this.clear(ClearPolicy.Resolve, time));
-  }
-
-  clear(policy = ClearPolicy.Cancel, time) {
+  };
+  _proto.clear = function clear(policy = ClearPolicy.Cancel, time) {
     const animationFrameId = this._animationFrameId;
     this._animationFrameId = null;
-
     if (animationFrameId == null) {
       return;
     }
-
     cancelAnimationFrame(animationFrameId);
-
     if (policy === ClearPolicy.Resolve) {
       this._action(time || performance.now());
     }
-  }
-
-}
+  };
+  _createClass(AnimationFrame, [{
+    key: "isSet",
+    get: function () {
+      return this._animationFrameId != null;
+    }
+  }]);
+  return AnimationFrame;
+}();
 
-class ActionScheduler {
-  constructor() {
+let ActionScheduler = function () {
+  function ActionScheduler() {
     this._disabled = false;
     this._registeredActions = [];
   }
-
-  timeout(action, period, options) {
+  var _proto = ActionScheduler.prototype;
+  _proto.timeout = function timeout(action, period, options) {
     if (this._disabled) {
       return ActionScheduler.NoopAction;
     }
-
     const timeout = new Timeout(action, period, options == null ? void 0 : options.schedulePolicy);
-
     this._registeredActions.push(() => timeout.clear(options == null ? void 0 : options.clearPolicy));
-
     return timeout;
-  }
-
-  interval(action, period, options) {
+  };
+  _proto.interval = function interval(action, period, options) {
     if (this._disabled) {
       return ActionScheduler.NoopAction;
     }
-
     const interval = new Interval(action, period, options == null ? void 0 : options.schedulePolicy);
-
     this._registeredActions.push(() => interval.clear(options == null ? void 0 : options.clearPolicy));
-
     return interval;
-  }
-
-  animationFrame(action, options) {
+  };
+  _proto.animationFrame = function animationFrame(action, options) {
     if (this._disabled) {
       return ActionScheduler.NoopAction;
     }
-
     const animationFrame = new AnimationFrame(action, options == null ? void 0 : options.schedulePolicy);
-
     this._registeredActions.push(() => animationFrame.clear(options == null ? void 0 : options.clearPolicy));
-
     return animationFrame;
-  }
-
-  clearAll() {
+  };
+  _proto.clearAll = function clearAll() {
     const registered = [].concat(this._registeredActions);
     this._registeredActions = [];
     registered.forEach(clearFn => clearFn());
-  }
-
-  disable() {
+  };
+  _proto.disable = function disable() {
     this._disabled = true;
     this.clearAll();
-  }
-
-}
+  };
+  return ActionScheduler;
+}();
 ActionScheduler.NoopAction = {
   set: () => {},
-
   get isSet() {
     return false;
   },
-
   clear: () => {}
 };
 
-class ActionSchedulerProvider extends React__namespace.Component {
-  constructor(...args) {
-    super(...args);
-    this._actionScheduler = new ActionScheduler();
+let ActionSchedulerProvider = function (_React$Component) {
+  _inheritsLoose(ActionSchedulerProvider, _React$Component);
+  function ActionSchedulerProvider(...args) {
+    var _this;
+    _this = _React$Component.call.apply(_React$Component, [this].concat(args)) || this;
+    _this._actionScheduler = new ActionScheduler();
+    return _this;
   }
-
-  componentWillUnmount() {
+  var _proto = ActionSchedulerProvider.prototype;
+  _proto.componentWillUnmount = function componentWillUnmount() {
     this._actionScheduler.disable();
-  }
-
-  render() {
+  };
+  _proto.render = function render() {
     const {
       children
     } = this.props;
     return children(this._actionScheduler);
-  }
-
-}
+  };
+  return ActionSchedulerProvider;
+}(React__namespace.Component);
 
 function withActionScheduler(WrappedComponent) {
-  return React__namespace.forwardRef((props, ref) => React__namespace.createElement(ActionSchedulerProvider, null, schedule => React__namespace.createElement(WrappedComponent, _extends__default["default"]({}, props, {
+  return React__namespace.forwardRef((props, ref) => React__namespace.createElement(ActionSchedulerProvider, null, schedule => React__namespace.createElement(WrappedComponent, _extends({}, props, {
     ref: ref,
     schedule: schedule
   }))));
@@ -301,28 +348,22 @@ function useTimeout(action, timeoutMs, active) {
 
 function useScheduledInterval(action, intervalMs, options) {
   var _options$schedulePoli;
-
   if (typeof action !== "function") {
     throw new Error("Action must be a function");
   }
-
   if (intervalMs < 1) {
     throw new Error("Interval period must be >= 1");
   }
-
   const schedulePolicy = (_options$schedulePoli = options == null ? void 0 : options.schedulePolicy) != null ? _options$schedulePoli : SchedulePolicy.Immediately;
   const [isSet, setIsSet] = React.useState(schedulePolicy === SchedulePolicy.Immediately);
   const set = React.useCallback(() => setIsSet(true), []);
   const actionRef = useUpdatingRef(action);
   const clear = React.useCallback(policy => {
     var _policy;
-
     policy = (_policy = policy) != null ? _policy : options == null ? void 0 : options.clearPolicy;
-
     if (isSet && policy === ClearPolicy.Resolve) {
       actionRef.current();
     }
-
     setIsSet(false);
   }, [actionRef, isSet, options == null ? void 0 : options.clearPolicy]);
   const runOnUnmountRef = useUpdatingRef(isSet && (options == null ? void 0 : options.clearPolicy) === ClearPolicy.Resolve);
@@ -343,15 +384,12 @@ function useScheduledInterval(action, intervalMs, options) {
 
 function useScheduledTimeout(action, timeoutMs, options) {
   var _options$schedulePoli;
-
   if (typeof action !== "function") {
     throw new Error("Action must be a function");
   }
-
   if (timeoutMs < 0) {
     throw new Error("Timeout period must be >= 0");
   }
-
   const schedulePolicy = (_options$schedulePoli = options == null ? void 0 : options.schedulePolicy) != null ? _options$schedulePoli : SchedulePolicy.Immediately;
   const [isSet, setIsSet] = React.useState(schedulePolicy === SchedulePolicy.Immediately);
   const set = React.useCallback(() => setIsSet(true), []);
@@ -362,13 +400,10 @@ function useScheduledTimeout(action, timeoutMs, options) {
   const actionRef = useUpdatingRef(wrappedAction);
   const clear = React.useCallback(policy => {
     var _policy;
-
     policy = (_policy = policy) != null ? _policy : options == null ? void 0 : options.clearPolicy;
-
     if (isSet && policy === ClearPolicy.Resolve) {
       actionRef.current();
     }
-
     setIsSet(false);
   }, [actionRef, isSet, options == null ? void 0 : options.clearPolicy]);
   const runOnUnmountRef = useUpdatingRef(isSet && (options == null ? void 0 : options.clearPolicy) === ClearPolicy.Resolve);

package/dist/index.js.flow

@@ -1,2 +1,31 @@
-// @flow
-export * from "../src/index";
+/**
+ * Flowtype definitions for index
+ * Generated by Flowgen from a Typescript Definition
+ * Flowgen v1.21.0
+ * @flow
+ */
+
+import type {
+  IAnimationFrame,
+  IInterval,
+  IScheduleActions,
+  ITimeout,
+  WithActionScheduler,
+  WithActionSchedulerProps,
+  WithoutActionScheduler,
+} from "./util/types";
+export type {
+  IAnimationFrame,
+  IInterval,
+  IScheduleActions,
+  ITimeout,
+  WithActionScheduler,
+  WithActionSchedulerProps,
+  WithoutActionScheduler,
+};
+declare export { SchedulePolicy, ClearPolicy } from "./util/policies";
+declare export { default as withActionScheduler } from "./components/with-action-scheduler";
+declare export { useInterval } from "./hooks/use-interval";
+declare export { useTimeout } from "./hooks/use-timeout";
+declare export { useScheduledInterval } from "./hooks/use-scheduled-interval";
+declare export { useScheduledTimeout } from "./hooks/use-scheduled-timeout";

package/dist/util/action-scheduler.d.ts

@@ -0,0 +1,21 @@
+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: boolean;
+    _registeredActions: Array<() => void>;
+    static readonly NoopAction: ITimeout & IAnimationFrame & IInterval;
+    timeout(action: () => unknown, period: number, options?: Options): ITimeout;
+    interval(action: () => unknown, period: number, options?: Options): IInterval;
+    animationFrame(action: (arg1: DOMHighResTimeStamp) => void, options?: Options): IAnimationFrame;
+    clearAll(): void;
+    /**
+     * Prevents this scheduler from creating any additional actions.
+     * This also clears any pending actions.
+     */
+    disable(): void;
+}

package/dist/util/action-scheduler.js.flow

@@ -0,0 +1,39 @@
+/**
+ * Flowtype definitions for action-scheduler
+ * Generated by Flowgen from a Typescript Definition
+ * Flowgen v1.21.0
+ * @flow
+ */
+
+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.
+ */
+declare export default class ActionScheduler mixins IScheduleActions {
+  _disabled: boolean;
+  _registeredActions: Array<() => void>;
+  static +NoopAction: { ...ITimeout, ...IAnimationFrame, ...IInterval };
+  timeout(action: () => mixed, period: number, options?: Options): ITimeout;
+  interval(action: () => mixed, period: number, options?: Options): IInterval;
+  animationFrame(
+    action: (arg1: DOMHighResTimeStamp) => void,
+    options?: Options
+  ): IAnimationFrame;
+  clearAll(): void;
+
+  /**
+   * Prevents this scheduler from creating any additional actions.
+   * This also clears any pending actions.
+   */
+  disable(): void;
+}

package/dist/util/animation-frame.d.ts

@@ -0,0 +1,62 @@
+import type { IAnimationFrame, SchedulePolicy, ClearPolicy } 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: (arg1: DOMHighResTimeStamp) => unknown;
+    /**
+     * Creates an animation frame request that will invoke the given action.
+     * The request is not made until set is called.
+     *
+     * @param {DOMHighResTimeStamp => mixed} action The action to be invoked.
+     * @param {SchedulePolicy} [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: (arg1: DOMHighResTimeStamp) => unknown, schedulePolicy?: SchedulePolicy);
+    /**
+     * Determine if the request is pending or not.
+     *
+     * @returns {boolean} true if the request is pending, otherwise
+     * false.
+     * @memberof AnimationFrame
+     */
+    get isSet(): boolean;
+    /**
+     * 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;
+    /**
+     * 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 {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`.
+     * @param {DOMHighResTimeStamp} [time] Timestamp to pass to the action when
+     * ClearPolicy.Resolve is specified. Ignored when ClearPolicy.Cancel is
+     * specified.
+     *
+     * @returns {void}
+     * @memberof AnimationFrame
+     */
+    clear(policy?: ClearPolicy, time?: DOMHighResTimeStamp): void;
+}