@khanacademy/perseus 19.1.4 → 19.1.5

package/dist/index.js

@@ -3999,10 +3999,10 @@ class FixedToResponsive extends React__namespace.Component {
 
 /* Local helper methods. */
 
-function getKey(eventName, id) {
+function getKey$1(eventName, id) {
   return eventName + ":" + id;
 }
-function getEventName(key) {
+function getEventName$1(key) {
   return key.split(":")[0];
 }
 const MovableHelperMethods = {
@@ -4083,7 +4083,7 @@ const MovableHelperMethods = {
 
     // If there's an existing handler, replace it by using its index in
     // `this.state[eventName]`; otherwise, add this handler to the end
-    const key = getKey(eventName, id);
+    const key = getKey$1(eventName, id);
     const index = this._listenerMap[key] = this._listenerMap[key] || this.state[eventName].length;
     this.state[eventName][index] = func;
   },
@@ -4095,7 +4095,7 @@ const MovableHelperMethods = {
    */
   unlisten: function (eventName, id) {
     this._listenerMap = this._listenerMap || {};
-    const key = getKey(eventName, id);
+    const key = getKey$1(eventName, id);
     const index = this._listenerMap[key];
     if (index !== undefined) {
       // Remove handler from list of event handlers and listenerMap
@@ -4105,7 +4105,7 @@ const MovableHelperMethods = {
       // Re-index existing events: if they occur after `index`, decrement
       const keys = ___default["default"].keys(this._listenerMap);
       ___default["default"].each(keys, function (key) {
-        if (getEventName(key) === eventName &&
+        if (getEventName$1(key) === eventName &&
         // @ts-expect-error - TS2683 - 'this' implicitly has type 'any' because it does not have a type annotation.
         this._listenerMap[key] > index) {
           // @ts-expect-error - TS2683 - 'this' implicitly has type 'any' because it does not have a type annotation.
@@ -8707,6 +8707,9 @@ class Graphie$1 {
   // TODO(benchristel): xpixels and ypixels are never used by this class, but
   // other code reaches in to access them :(
   // Refactor to accessor methods that look at this.dimensions.
+  // set by Movables
+  // TODO(benchristel): consider putting this state on the Movable instead of
+  // on the Graphie
   constructor(el) {
     this.el = el;
     $__default["default"](el).css("position", "relative");
@@ -9538,6 +9541,11 @@ class Graphie$1 {
     });
     return processed;
   }
+
+  // This is a stub that's overridden in interactive.ts
+  getMouseCoord(event) {
+    throw new Error("getMouseCoord is a stub, and is not implemented");
+  }
 }
 const labelDirections = {
   center: [-0.5, -0.5],
@@ -13746,8 +13754,7 @@ var GraphieClasses = {
 const normalizeOptions$3 = InteractiveUtil.normalizeOptions;
 const assert$8 = InteractiveUtil.assert;
 
-// Default "props" and "state". Both are added to this.state and
-// receive magic getter methods (this.isHovering() etc).
+// Default "props" and "state". Both are added to this.state.
 // However, properties in DEFAULT_PROPS are updated on `modify()`,
 // while those in DEFAULT_STATE persist and are not updated.
 // Things that the user might want to change should be on "props",
@@ -13762,29 +13769,26 @@ const DEFAULT_STATE$3 = {
   isDragging: false,
   mouseTarget: null
 };
-const Movable = function (graphie, options) {
-  // @ts-expect-error - TS2683 - 'this' implicitly has type 'any' because it does not have a type annotation.
-  ___default["default"].extend(this, {
-    graphie,
-    state: {
-      // Set here because this must be unique for each instance
+class Movable {
+  // TODO(benchristel): delete _listenerMap; it's unused
+  _listenerMap = {};
+  constructor(graphie, options) {
+    this.graphie = graphie;
+    this.state = {
       id: ___default["default"].uniqueId("movable")
-    }
-  });
-
-  // We only set DEFAULT_STATE once, here
-  // @ts-expect-error - TS2683 - 'this' implicitly has type 'any' because it does not have a type annotation.
-  this.modify(___default["default"].extend({}, DEFAULT_STATE$3, options));
-};
-InteractiveUtil.createGettersFor(Movable, ___default["default"].extend({}, DEFAULT_PROPS$3, DEFAULT_STATE$3));
-InteractiveUtil.addMovableHelperMethodsTo(Movable);
-___default["default"].extend(Movable.prototype, {
-  cloneState: function () {
-    return {
-      ...this.state
     };
-  },
-  _createDefaultState: function () {
+    this.modify({
+      ...DEFAULT_STATE$3,
+      ...options
+    });
+  }
+  modify(options) {
+    this.update({
+      ...this._createDefaultState(),
+      ...options
+    });
+  }
+  _createDefaultState() {
     return {
       id: this.state.id,
       add: [],
@@ -13799,66 +13803,11 @@ ___default["default"].extend(Movable.prototype, {
       // be persistent, and updated appropriately in modify()
       ...DEFAULT_PROPS$3
     };
-  },
-  /**
-   * Resets the object to its state as if it were constructed with
-   * `options` originally. The only state maintained is `state.id`
-   *
-   * Analogous to React.js's replaceProps
-   */
-  modify: function (options) {
-    this.update({
-      ...this._createDefaultState(),
-      ...options
-    });
-  },
-  /**
-   * Simulates a mouse grab event on the movable object.
-   */
-  grab: function (coord) {
-    assert$8(kmath.point.is(coord));
-    const self = this;
-    const graphie = self.graphie;
-    const state = self.state;
-    state.isHovering = true;
-    state.isDragging = true;
-    graphie.isDragging = true;
-    const startMouseCoord = coord;
-    let prevMouseCoord = startMouseCoord;
-    self._fireEvent(state.onMoveStart, startMouseCoord, startMouseCoord);
-    const moveHandler = function (e) {
-      e.preventDefault();
-      const mouseCoord = graphie.getMouseCoord(e);
-      self._fireEvent(state.onMove, mouseCoord, prevMouseCoord);
-      self.draw();
-      prevMouseCoord = mouseCoord;
-    };
-    const upHandler = function (e) {
-      $__default["default"](document).unbind("vmousemove", moveHandler);
-      $__default["default"](document).unbind("vmouseup", upHandler);
-      if (state.isHovering) {
-        self._fireEvent(state.onClick, prevMouseCoord, startMouseCoord);
-      }
-      state.isHovering = self.state.isMouseOver;
-      state.isDragging = false;
-      graphie.isDragging = false;
-      self._fireEvent(state.onMoveEnd, prevMouseCoord, startMouseCoord);
-      self.draw();
-    };
-    $__default["default"](document).bind("vmousemove", moveHandler);
-    $__default["default"](document).bind("vmouseup", upHandler);
-  },
-  /**
-   * Adjusts constructor parameters without changing previous settings
-   * for any option not specified
-   *
-   * Analogous to React.js's setProps
-   */
-  update: function (options) {
-    const self = this;
-    const graphie = self.graphie;
-    const prevState = self.cloneState();
-    const state = ___default["default"].extend(self.state, normalizeOptions$3(options));
+  }
+  update(options) {
+    const graphie = this.graphie;
+    const prevState = this.cloneState();
+    const state = Object.assign(this.state, normalizeOptions$3(options));
 
     // the invisible shape in front of the point that gets mouse events
     if (state.mouseTarget && !prevState.mouseTarget) {
@@ -13870,24 +13819,24 @@ ___default["default"].extend(Movable.prototype, {
       }
       const isMouse = !("ontouchstart" in window);
       if (isMouse) {
-        $mouseTarget.on("vmouseover", function () {
+        $mouseTarget.on("vmouseover", () => {
           state.isMouseOver = true;
           if (!graphie.isDragging) {
             state.isHovering = true;
           }
-          if (self.state.added) {
+          if (this.state.added) {
             // Avoid drawing if the point has been removed
-            self.draw();
+            this.draw();
           }
         });
-        $mouseTarget.on("vmouseout", function () {
+        $mouseTarget.on("vmouseout", () => {
           state.isMouseOver = false;
           if (!state.isDragging) {
             state.isHovering = false;
           }
-          if (self.state.added) {
+          if (this.state.added) {
             // Avoid drawing if the point has been removed
-            self.draw();
+            this.draw();
           }
         });
       }
@@ -13899,13 +13848,13 @@ ___default["default"].extend(Movable.prototype, {
       }, {
         passive: false
       });
-      $mouseTarget.on("vmousedown", function (e) {
+      $mouseTarget.on("vmousedown", e => {
         if (e.which !== 0 && e.which !== 1) {
           return;
         }
         e.preventDefault();
         const mouseCoord = graphie.getMouseCoord(e);
-        self.grab(mouseCoord);
+        this.grab(mouseCoord);
       });
     }
     if (state.mouseTarget && state.cursor !== undefined) {
@@ -13922,39 +13871,217 @@ ___default["default"].extend(Movable.prototype, {
 
     // Trigger an add event if this hasn't been added before
     if (!state.added) {
-      self._fireEvent(state.modify, self.cloneState(), {});
+      // TODO(benchristel): No one seems to handle the modify event. Can
+      // we delete this?
+      // @ts-expect-error - TS2345: Argument of type '{}' is not assignable to parameter of type 'State'.
+      this._fireEvent(state.modify, this.cloneState(), {});
       state.added = true;
 
       // Update the state for `added` and in case the add event
       // changed it
-      self.prevState = self.cloneState();
+      this.prevState = this.cloneState();
     }
 
     // Trigger a modify event
-    self._fireEvent(state.modify, self.cloneState(), self.prevState);
-  },
-  remove: function () {
-    this.state.added = false;
-    this._fireEvent(this.state.remove);
-    if (this.state.mouseTarget) {
-      $__default["default"](this.state.mouseTarget).off();
-      this.state.mouseTarget.remove();
-      this.state.mouseTarget = null;
+    this._fireEvent(state.modify, this.cloneState(), this.prevState);
+  }
+  cloneState() {
+    return {
+      ...this.state
+    };
+  }
+
+  /**
+   * Fire an onSomething type event to all functions in listeners
+   */
+  _fireEvent(listeners) {
+    for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+      args[_key - 1] = arguments[_key];
     }
-  },
+    if (listeners == null) {
+      return;
+    }
+    for (const listener of listeners) {
+      listener.call(this, ...args);
+    }
+  }
+
+  /**
+   * Call all draw functions, and update our prevState for the next
+   * draw function
+   */
+  draw() {
+    const currState = this.cloneState();
+    this._fireEvent(this.state.draw, currState, this.prevState);
+    this.prevState = currState;
+  }
+
+  /**
+   * Simulates a mouse grab event on the movable object.
+   */
+  grab(coord) {
+    assert$8(kmath.point.is(coord));
+    const graphie = this.graphie;
+    const state = this.state;
+    state.isHovering = true;
+    state.isDragging = true;
+    graphie.isDragging = true;
+    const startMouseCoord = coord;
+    let prevMouseCoord = startMouseCoord;
+    this._fireEvent(state.onMoveStart, startMouseCoord, startMouseCoord);
+    const moveHandler = e => {
+      e.preventDefault();
+      const mouseCoord = graphie.getMouseCoord(e);
+      this._fireEvent(state.onMove, mouseCoord, prevMouseCoord);
+      this.draw();
+      prevMouseCoord = mouseCoord;
+    };
+    const upHandler = () => {
+      $__default["default"](document).unbind("vmousemove", moveHandler);
+      $__default["default"](document).unbind("vmouseup", upHandler);
+      if (state.isHovering) {
+        this._fireEvent(state.onClick, prevMouseCoord, startMouseCoord);
+      }
+      state.isHovering = this.state.isMouseOver;
+      state.isDragging = false;
+      graphie.isDragging = false;
+      this._fireEvent(state.onMoveEnd, prevMouseCoord, startMouseCoord);
+      this.draw();
+    };
+    $__default["default"](document).bind("vmousemove", moveHandler);
+    $__default["default"](document).bind("vmouseup", upHandler);
+  }
+  _applyConstraints(current, previous, extraOptions) {
+    let skipRemaining = false;
+    return (this.state.constraints ?? []).reduce((memo, constraint) => {
+      // A move that has been cancelled won't be propagated to later
+      // constraints calls
+      if (memo === false) {
+        return false;
+      }
+      if (skipRemaining) {
+        return memo;
+      }
+      const result = constraint.call(this, memo, previous, {
+        onSkipRemaining: () => {
+          skipRemaining = true;
+        },
+        ...extraOptions
+      });
+      if (result === false) {
+        // Returning false cancels the move
+        return false;
+      }
+      if (kmath.point.is(result, 2)) {
+        // Returning a coord from constraints overrides the move
+        return result;
+      }
+      if (result === true || result == null) {
+        // Returning true or undefined allow the move to occur
+        return memo;
+      }
+      // Anything else is an error
+      throw new PerseusError("Constraint returned invalid result: " + result, Errors.Internal);
+    }, current);
+  }
+
   // Change z-order to back
-  toBack: function () {
+  toBack() {
     if (this.state.mouseTarget) {
       this.state.mouseTarget.toBack();
     }
-  },
+  }
+
   // Change z-order to front
-  toFront: function () {
+  toFront() {
     if (this.state.mouseTarget) {
       this.state.mouseTarget.toFront();
     }
   }
-});
+
+  /**
+   * Add a listener to any event: startMove, constraints, onMove, onMoveEnd,
+   * etc. If a listener is already bound to the given eventName and id, then
+   * it is overwritten by func.
+   *
+   * eventName: the string name of the event to listen to. one of:
+   *   "onMoveStart", "onMove", "onMoveEnd", "draw", "remove"
+   *
+   * id: a string id that can be used to remove this event at a later time
+   *   note: adding multiple listeners with the same id is undefined behavior
+   *
+   * func: the function to call when the event happens, which is called
+   *   with the event's standard parameters [usually (coord, prevCoord) or
+   *   (state, prevState)]
+   */
+  listen(eventName, id, func) {
+    this._listenerMap = this._listenerMap || {};
+
+    // If there's an existing handler, replace it by using its index in
+    // `this.state[eventName]`; otherwise, add this handler to the end
+    const key = getKey(eventName, id);
+    const index = this._listenerMap[key] = this._listenerMap[key] || this.state[eventName].length;
+    this.state[eventName][index] = func;
+  }
+
+  /**
+   * Remove a previously added listener, by the id specified in the
+   * corresponding listen() call
+   *
+   * If the given id has not been registered already, this is a no-op
+   */
+  unlisten(eventName, id) {
+    this._listenerMap = this._listenerMap || {};
+    const key = getKey(eventName, id);
+    const index = this._listenerMap[key];
+    if (index !== undefined) {
+      // Remove handler from list of event handlers and listenerMap
+      this.state[eventName].splice(index, 1);
+      delete this._listenerMap[key];
+
+      // Re-index existing events: if they occur after `index`, decrement
+      const keys = ___default["default"].keys(this._listenerMap);
+      keys.forEach(key => {
+        if (getEventName(key) === eventName && this._listenerMap[key] > index) {
+          this._listenerMap[key]--;
+        }
+      });
+    }
+  }
+  remove() {
+    this.state.added = false;
+    this._fireEvent(this.state.remove);
+    if (this.state.mouseTarget) {
+      $__default["default"](this.state.mouseTarget).off();
+      this.state.mouseTarget.remove();
+      this.state.mouseTarget = null;
+    }
+  }
+  cursor() {
+    return this.state.cursor;
+  }
+  added() {
+    return this.state.added;
+  }
+  isHovering() {
+    return this.state.isHovering;
+  }
+  isMouseOver() {
+    return this.state.isMouseOver;
+  }
+  isDragging() {
+    return this.state.isDragging;
+  }
+  mouseTarget() {
+    return this.state.mouseTarget;
+  }
+}
+function getKey(eventName, id) {
+  return eventName + ":" + id;
+}
+function getEventName(key) {
+  return key.split(":")[0];
+}
 
 /* eslint-disable @babel/no-invalid-this */
 /**
@@ -14800,31 +14927,39 @@ const constraints$1 = {
   snap: function (snap) {
     return function (coord) {
       if (snap === null) {
-        // NOTE(kevinb): this should probably return the original point
+        // TODO(benchristel), NOTE(kevinb): this should probably return
+        // the original point
         return true;
       }
-      // @ts-expect-error - TS2683 - 'this' implicitly has type 'any' because it does not have a type annotation.
-      snap = snap || this.graphie.snap;
-      return kmath.point.roundTo(coord, snap);
+      // @ts-expect-error - TS2339: Property 'snap' does not exist on type 'Graphie'.
+      return kmath.point.roundTo(coord, snap || this.graphie.snap);
     };
   },
-  bound: function (range, snap, paddingPx) {
-    if (paddingPx === undefined) {
-      if (range === undefined) {
-        paddingPx = 10;
+  bound: function (range, snap, optionalPaddingPx) {
+    const paddingPx = (() => {
+      if (optionalPaddingPx === undefined) {
+        if (range === undefined) {
+          return 10;
+        } else {
+          return 0;
+        }
       } else {
-        paddingPx = 0;
+        return optionalPaddingPx;
       }
-    }
+    })();
     return function (coord, prev, options) {
-      // @ts-expect-error - TS2683 - 'this' implicitly has type 'any' because it does not have a type annotation.
       const graphie = this.graphie;
       range = range || graphie.range;
       if (snap === undefined) {
+        // @ts-expect-error - Property 'snap' does not exist on type 'Graphie'.
         snap = graphie.snap;
       }
-      let lower = graphie.unscalePoint([paddingPx, graphie.ypixels - paddingPx]);
-      let upper = graphie.unscalePoint([graphie.xpixels - paddingPx, paddingPx]);
+      let lower = graphie.unscalePoint([paddingPx,
+      // @ts-expect-error - 'graphie.ypixels' is possibly 'undefined'.
+      graphie.ypixels - paddingPx]);
+      let upper = graphie.unscalePoint([
+      // @ts-expect-error - 'graphie.ypixels' is possibly 'undefined'.
+      graphie.xpixels - paddingPx, paddingPx]);
       if (snap) {
         lower = kmath.point.ceilTo(lower, snap);
         upper = kmath.point.floorTo(upper, snap);
@@ -41611,7 +41746,7 @@ const init = function (options) {
 
 // This file is processed by a Rollup plugin (replace) to inject the production
 const libName = "@khanacademy/perseus";
-const libVersion = "19.1.4";
+const libVersion = "19.1.5";
 perseusCore.addLibraryVersionToPerseusDebug(libName, libVersion);
 
 const apiVersion = {