@khanacademy/perseus 22.4.2 → 22.5.1

package/dist/index.css

@@ -4425,6 +4425,41 @@ html body .mq-editable-field .mq-selection .mq-nthroot-container * {
     visibility: visible;
 }
 
+.MafsView .movable-circle {
+    cursor: grab;
+}
+
+.MafsView .movable-circle.movable-circle--dragging {
+    cursor: grabbing;
+    outline: none;
+}
+
+.MafsView .movable-circle .focus-ring {
+    visibility: hidden; /* overridden when the circle is focused */
+    stroke: var(--mafs-blue);
+    stroke-width: 2px;
+    fill: transparent;
+}
+
+.MafsView .movable-circle:focus {
+    outline: none;
+}
+
+.MafsView .movable-circle:focus-visible .focus-ring {
+    visibility: visible;
+}
+
+.MafsView .movable-circle .movable-circle-handle {
+    fill: var(--mafs-blue); /* WB fadedOffBlack64 */
+    stroke: #fff;
+    stroke-width: 2px;
+}
+
+.MafsView .movable-circle .movable-circle-handle-dot {
+    fill: #fff;
+    r: 1.25px;
+}
+
 @font-face {
     font-family: Mafs-MJXTEX;
     src: url("https://cdn.kastatic.org/fonts/mathjax/MathJax_Main-Regular.woff")

package/dist/index.js

@@ -16669,7 +16669,7 @@ const Label$1 = GraphieClasses.createSimpleClass((graphie, props) => {
   }
   return elem;
 });
-const Line$2 = GraphieClasses.createClass({
+const Line$3 = GraphieClasses.createClass({
   displayName: "Line",
   movableProps: ["children"],
   add: function (graphie) {
@@ -16788,7 +16788,7 @@ var Movables = {
   Arc: Arc,
   Circle: Circle,
   Label: Label$1,
-  Line: Line$2,
+  Line: Line$3,
   MovableLine: MovableLine$3,
   MovablePoint: MovablePoint$3,
   Parabola: Parabola,
@@ -27849,7 +27849,7 @@ var Image$1 = {
 // @ts-expect-error - TS2339 - Property 'Label' does not exist on type 'typeof Graphie'.
 const Label = Graphie.Label;
 // @ts-expect-error - TS2339 - Property 'Line' does not exist on type 'typeof Graphie'.
-const Line$1 = Graphie.Line;
+const Line$2 = Graphie.Line;
 // @ts-expect-error - TS2339 - Property 'MovablePoint' does not exist on type 'typeof Graphie'.
 const MovablePoint$1 = Graphie.MovablePoint;
 // @ts-expect-error - TS2339 - Property 'MovableLine' does not exist on type 'typeof Graphie'.
@@ -28076,7 +28076,7 @@ class Interaction extends React__namespace.Component {
         this._eval(element.options.endX),
         // @ts-expect-error - TS2683 - 'this' implicitly has type 'any' because it does not have a type annotation.
         this._eval(element.options.endY)];
-        return /*#__PURE__*/React__namespace.createElement(Line$1, {
+        return /*#__PURE__*/React__namespace.createElement(Line$2, {
           key: element.key,
           start: start,
           end: end,
@@ -28785,6 +28785,16 @@ function vectorsToPixels(vectors, graphState) {
   const transformToPx = matrixBuilder().translate(...translation).scale(width / (xMax - xMin), -height / (yMax - yMin)).get();
   return vectors.map(p => mafs.vec.transform(p, transformToPx));
 }
+function dimensionsToPixels(dimens, graphState) {
+  const {
+    range,
+    width,
+    height
+  } = graphState;
+  const [[xMin, xMax], [yMin, yMax]] = range;
+  const transformToPx = matrixBuilder().scale(width / (xMax - xMin), height / (yMax - yMin)).get();
+  return dimens.map(d => mafs.vec.transform(d, transformToPx));
+}
 
 // When converting points, we translate so the pixel point ends up in the right location.
 // This is because points are specific locations on graphs, unlike vectors.
@@ -28800,6 +28810,13 @@ const useTransformVectorsToPixels = function () {
   }
   return vectorsToPixels(vectors, graphState);
 };
+const useTransformDimensionsToPixels = function () {
+  const graphState = useGraphConfig();
+  for (var _len2 = arguments.length, dimens = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+    dimens[_key2] = arguments[_key2];
+  }
+  return dimensionsToPixels(dimens, graphState);
+};
 
 function AxisLabels() {
   const {
@@ -29036,33 +29053,29 @@ function calculateAngleInDegrees(_ref) {
  */
 const getIntersectionOfRayWithBox = (initialPoint, throughPoint, box) => {
   const [[xMin, xMax], [yMin, yMax]] = box;
-  const [aX, aY] = throughPoint;
-  const [bX, bY] = initialPoint;
+  const [aX, aY] = initialPoint;
+  const [bX, bY] = throughPoint;
   const yDiff = bY - aY;
   const xDiff = bX - aX;
   const slope = yDiff / xDiff;
-  const yAtXMin = slope * (xMin - aX) + aY;
-  const yAtXMax = slope * (xMax - aX) + aY;
-  const xAtYMin = (yMin - aY) / slope + aX;
-  const xAtYMax = (yMax - aY) / slope + aX;
-
-  // clock analogy to describe quadrants
+  const inverseSlope = 1 / slope;
+  const xExtreme = xDiff < 0 ? xMin : xMax;
+  const yExtreme = yDiff < 0 ? yMin : yMax;
+  const yAtXExtreme = aY + (xExtreme - aX) * slope;
+  const xAtYExtreme = aX + (yExtreme - aY) * inverseSlope;
   switch (true) {
-    // 12 o'clock to 2:59
-    case yDiff > 0 && xDiff >= 0:
-      return xAtYMax > xMax ? [xMax, yAtXMax] : [xAtYMax, yMax];
-    // 3 o'clock to 5:59
-    case yDiff <= 0 && xDiff > 0:
-      // xAtYMin evaluates to -Infinity here, so we use absolute value
-      return Math.abs(xAtYMin) > xMax ? [xMax, yAtXMax] : [xAtYMin, yMin];
-    // 9 o'clock to 11:59
-    case yDiff >= 0 && xDiff < 0:
-      return xAtYMax < xMin ? [xMin, yAtXMin] : [xAtYMax, yMax];
-    // 6 o'clock to 8:59
-    case yDiff < 0 && xDiff <= 0:
-      return xAtYMin < xMin ? [xMin, yAtXMin] : [xAtYMin, yMin];
+    // does the ray exit the graph bounding box via the left or right edge?
+    case isBetween(yAtXExtreme, yMin, yMax):
+      return [xExtreme, yAtXExtreme];
+
+    // does the ray exit the graph bounding box via the top or bottom edge?
+    case isBetween(xAtYExtreme, xMin, xMax):
+      return [xAtYExtreme, yExtreme];
     default:
-      return [xMax, yAtXMax];
+      // This default case is only reachable if the input is invalid
+      // (initialPoint is outside the graph bounds, or initialPoint and
+      // throughPoint are the same).
+      return [0, 0];
   }
 };
 const getLines = points => {
@@ -29071,6 +29084,9 @@ const getLines = points => {
     return [point, next];
   });
 };
+function isBetween(x, low, high) {
+  return x >= low && x <= high;
+}
 
 function SVGLine(props) {
   const {
@@ -29123,15 +29139,15 @@ const LockedLine = props => {
     lineStyle,
     kind,
     points,
-    showStartPoint,
-    showEndPoint,
+    showPoint1,
+    showPoint2,
     range
   } = props;
   const [point1, point2] = points;
   let line;
   if (kind === "ray") {
     // Rays extend to the end of the graph in one direction.
-    const extendedPoint = getIntersectionOfRayWithBox(point2.coord, point1.coord, range);
+    const extendedPoint = getIntersectionOfRayWithBox(point1.coord, point2.coord, range);
     line = /*#__PURE__*/React__namespace.createElement(Vector, {
       tail: point1.coord,
       tip: extendedPoint,
@@ -29142,7 +29158,7 @@ const LockedLine = props => {
     });
   } else {
     const LineType = kind === "segment" ? mafs.Line.Segment : mafs.Line.ThroughPoints;
-    let arrowTip = kind === "segment" ? point2.coord : getIntersectionOfRayWithBox(point2.coord, point1.coord, range);
+    let arrowTip = kind === "segment" ? point2.coord : getIntersectionOfRayWithBox(point1.coord, point2.coord, range);
     const direction = mafs.vec.sub(point2.coord, point1.coord);
     let angle = calculateAngleInDegrees(direction);
     const startArrowHead = kind !== "segment" && /*#__PURE__*/React__namespace.createElement(Arrowhead, {
@@ -29150,7 +29166,7 @@ const LockedLine = props => {
       tip: arrowTip,
       color: lockedFigureColors[color]
     });
-    arrowTip = kind === "segment" ? point1.coord : getIntersectionOfRayWithBox(point1.coord, point2.coord, range);
+    arrowTip = kind === "segment" ? point1.coord : getIntersectionOfRayWithBox(point2.coord, point1.coord, range);
     angle = angle > 180 ? angle - 180 : angle + 180;
     const endArrowHead = kind !== "segment" && /*#__PURE__*/React__namespace.createElement(Arrowhead, {
       angle: angle,
@@ -29166,7 +29182,7 @@ const LockedLine = props => {
   }
   return /*#__PURE__*/React__namespace.createElement("g", {
     className: kind === "ray" ? "locked-ray" : "locked-line"
-  }, line, showStartPoint && /*#__PURE__*/React__namespace.createElement(mafs.Point, {
+  }, line, showPoint1 && /*#__PURE__*/React__namespace.createElement(mafs.Point, {
     x: point1.coord[0],
     y: point1.coord[1],
     svgCircleProps: {
@@ -29176,7 +29192,7 @@ const LockedLine = props => {
         strokeWidth: wonderBlocksTokens.spacing.xxxxSmall_2
       }
     }
-  }), showEndPoint && /*#__PURE__*/React__namespace.createElement(mafs.Point, {
+  }), showPoint2 && /*#__PURE__*/React__namespace.createElement(mafs.Point, {
     x: point2.coord[0],
     y: point2.coord[1],
     svgCircleProps: {
@@ -29438,9 +29454,10 @@ function tabIndex(config) {
   return undefined;
 }
 
-const Segment = props => {
+const MovableLine = props => {
   const {
-    onMoveLine,
+    onMoveLine = () => {},
+    onMovePoint = () => {},
     color,
     points: [start, end],
     extend
@@ -29460,18 +29477,19 @@ const Segment = props => {
   const {
     visiblePoint: visiblePoint1,
     focusableHandle: focusableHandle1
-  } = useControlPoint(start, color, p => props.onMovePoint(0, p));
+  } = useControlPoint(start, color, p => onMovePoint(0, p));
   const {
     visiblePoint: visiblePoint2,
     focusableHandle: focusableHandle2
-  } = useControlPoint(end, color, p => props.onMovePoint(1, p));
-  return /*#__PURE__*/React__namespace.createElement(React__namespace.Fragment, null, focusableHandle1, /*#__PURE__*/React__namespace.createElement(MovableLine, {
+  } = useControlPoint(end, color, p => onMovePoint(1, p));
+  const line = /*#__PURE__*/React__namespace.createElement(Line$1, {
     start: start,
     end: end,
     stroke: color,
     extend: extend,
     onMove: onMoveLine
-  }), focusableHandle2, visiblePoint1, visiblePoint2);
+  });
+  return /*#__PURE__*/React__namespace.createElement(React__namespace.Fragment, null, focusableHandle1, line, focusableHandle2, visiblePoint1, visiblePoint2);
 };
 function useControlPoint(point, color, onMovePoint) {
   const {
@@ -29517,7 +29535,7 @@ function useControlPoint(point, color, onMovePoint) {
   };
 }
 const defaultStroke = "var(--movable-line-stroke-color)";
-const MovableLine = props => {
+const Line$1 = props => {
   const {
     start,
     end,
@@ -29525,29 +29543,29 @@ const MovableLine = props => {
     extend,
     stroke = defaultStroke
   } = props;
-  const midpoint = mafs.vec.midpoint(start, end);
   const [startPtPx, endPtPx] = useTransformVectorsToPixels(start, end);
   const {
     range,
-    graphDimensionsInPixels
+    graphDimensionsInPixels,
+    snapStep
   } = useGraphConfig();
   let startExtend = undefined;
   let endExtend = undefined;
   if (extend) {
     const trimmedRange = trimRange(range, graphDimensionsInPixels);
-    startExtend = extend.start ? getIntersectionOfRayWithBox(start, end, trimmedRange) : undefined;
-    endExtend = extend.end ? getIntersectionOfRayWithBox(end, start, trimmedRange) : undefined;
+    startExtend = extend.start ? getIntersectionOfRayWithBox(end, start, trimmedRange) : undefined;
+    endExtend = extend.end ? getIntersectionOfRayWithBox(start, end, trimmedRange) : undefined;
   }
   const line = React.useRef(null);
   const {
     dragging
   } = mafs.useMovable({
     gestureTarget: line,
-    point: midpoint,
+    point: start,
     onMove: newPoint => {
-      onMove(mafs.vec.sub(newPoint, midpoint));
+      onMove(mafs.vec.sub(newPoint, start));
     },
-    constrain: p => p
+    constrain: p => snap(snapStep, p)
   });
   return /*#__PURE__*/React__namespace.createElement(React__namespace.Fragment, null, /*#__PURE__*/React__namespace.createElement("g", {
     ref: line,
@@ -29620,7 +29638,7 @@ const SegmentGraph = props => {
   const {
     coords: segments
   } = props.graphState;
-  return /*#__PURE__*/React__namespace.createElement(React__namespace.Fragment, null, segments?.map((segment, i) => /*#__PURE__*/React__namespace.createElement(Segment, {
+  return /*#__PURE__*/React__namespace.createElement(React__namespace.Fragment, null, segments?.map((segment, i) => /*#__PURE__*/React__namespace.createElement(MovableLine, {
     key: i,
     points: segment,
     onMoveLine: delta => {
@@ -29640,7 +29658,7 @@ const LinearGraph = props => {
     coords: lines
   } = props.graphState;
   const colors = ["var(--movable-line-stroke-color)", "var(--mafs-violet)"];
-  return /*#__PURE__*/React__namespace.createElement(React__namespace.Fragment, null, lines?.map((line, i) => /*#__PURE__*/React__namespace.createElement(Segment, {
+  return /*#__PURE__*/React__namespace.createElement(React__namespace.Fragment, null, lines?.map((line, i) => /*#__PURE__*/React__namespace.createElement(MovableLine, {
     key: i,
     points: line,
     onMoveLine: delta => {
@@ -29664,7 +29682,7 @@ const RayGraph = props => {
   } = props.graphState;
   const handleMoveLine = delta => dispatch(moveLine(0, delta));
   const handleMovePoint = (pointIndex, newPoint) => dispatch(moveControlPoint(pointIndex, newPoint, 0));
-  return /*#__PURE__*/React__namespace.createElement(Segment
+  return /*#__PURE__*/React__namespace.createElement(MovableLine
   // a ray only has one line
   , {
     points: lines[0],
@@ -29822,7 +29840,7 @@ const isRightAngle = angle => Math.abs(angle - Math.PI / 2) < 0.01;
  */
 const shouldDrawArcOutside = (midpoint, vertex, range, polygonLines) => {
   // Create a ray from the midpoint (inside angle) to the edge of the range
-  const rangeIntersectionPoint = getIntersectionOfRayWithBox(vertex, midpoint, range);
+  const rangeIntersectionPoint = getIntersectionOfRayWithBox(midpoint, vertex, range);
   let lineIntersectionCount = 0;
   polygonLines.forEach(line => linesIntersect([vertex, rangeIntersectionPoint], line) && lineIntersectionCount++);
 
@@ -29966,14 +29984,12 @@ function initializeGraphState(params) {
     graph,
     step,
     snapStep,
-    range,
-    markings
+    range
   } = params;
   const shared = {
     hasBeenInteractedWith: false,
     range,
-    snapStep,
-    markings
+    snapStep
   };
   switch (graph.type) {
     case "segment":
@@ -30224,16 +30240,10 @@ function CircleGraph(props) {
     center,
     radiusPoint
   } = graphState;
-  return /*#__PURE__*/React__namespace.createElement(React__namespace.Fragment, null, /*#__PURE__*/React__namespace.createElement(mafs.Circle, {
+  return /*#__PURE__*/React__namespace.createElement(React__namespace.Fragment, null, /*#__PURE__*/React__namespace.createElement(MovableCircle, {
     center: center,
     radius: getRadius(graphState),
-    fillOpacity: 0,
-    color: wonderBlocksTokens.color.blue
-  }), /*#__PURE__*/React__namespace.createElement(StyledMovablePoint, {
-    point: center,
-    onMove: newCenter => {
-      dispatch(moveCenter(newCenter));
-    }
+    onMove: newCenter => dispatch(moveCenter(newCenter))
   }), /*#__PURE__*/React__namespace.createElement(StyledMovablePoint, {
     point: radiusPoint,
     onMove: newRadiusPoint => {
@@ -30241,6 +30251,80 @@ function CircleGraph(props) {
     }
   }));
 }
+function MovableCircle(props) {
+  const {
+    center,
+    radius,
+    onMove
+  } = props;
+  const {
+    snapStep
+  } = useGraphConfig();
+  const draggableRef = React.useRef(null);
+  const {
+    dragging
+  } = mafs.useMovable({
+    gestureTarget: draggableRef,
+    point: center,
+    onMove,
+    constrain: p => snap(snapStep, p)
+  });
+  const [centerPx] = useTransformVectorsToPixels(center);
+  const [radiiPx] = useTransformDimensionsToPixels([radius, radius]);
+  return /*#__PURE__*/React__namespace.createElement("g", {
+    ref: draggableRef,
+    tabIndex: 0,
+    className: `movable-circle ${dragging ? "movable-circle--dragging" : ""}`
+  }, /*#__PURE__*/React__namespace.createElement("ellipse", {
+    className: "focus-ring",
+    cx: centerPx[0],
+    cy: centerPx[1],
+    rx: radiiPx[0] + 3,
+    ry: radiiPx[1] + 3
+  }), /*#__PURE__*/React__namespace.createElement(mafs.Circle, {
+    center: center,
+    radius: radius,
+    fillOpacity: 0,
+    color: wonderBlocksTokens.color.blue
+  }), /*#__PURE__*/React__namespace.createElement(DragHandle, {
+    center: center
+  }));
+}
+const dragHandleDimensions = [24, 14];
+const dragHandleDotPositions = crossProduct([-4.4, 0, 4.4], [-2.1, 2.1]);
+function DragHandle(props) {
+  const {
+    center
+  } = props;
+  const cornerRadius = Math.min(...dragHandleDimensions) / 2;
+  const [centerPx] = useTransformVectorsToPixels(center);
+  const topLeft = mafs.vec.sub(centerPx, mafs.vec.scale(dragHandleDimensions, 0.5));
+  return /*#__PURE__*/React__namespace.createElement(React__namespace.Fragment, null, /*#__PURE__*/React__namespace.createElement("rect", {
+    className: "movable-circle-handle",
+    x: topLeft[0],
+    y: topLeft[1],
+    width: dragHandleDimensions[0],
+    height: dragHandleDimensions[1],
+    rx: cornerRadius,
+    ry: cornerRadius
+  }), dragHandleDotPositions.map(offsetPx => {
+    const [xPx, yPx] = mafs.vec.add(offsetPx, centerPx);
+    return /*#__PURE__*/React__namespace.createElement("circle", {
+      className: "movable-circle-handle-dot",
+      cx: xPx,
+      cy: yPx
+    });
+  }));
+}
+function crossProduct(as, bs) {
+  const result = [];
+  for (const a of as) {
+    for (const b of bs) {
+      result.push([a, b]);
+    }
+  }
+  return result;
+}
 
 function PointGraph(props) {
   const {
@@ -31433,35 +31517,22 @@ function mafsStateToInteractiveGraph(state) {
   };
 }
 const StatefulMafsGraph = /*#__PURE__*/React__namespace.forwardRef((props, ref) => {
+  const {
+    onChange
+  } = props;
   const [state, dispatch] = React__namespace.useReducer(interactiveGraphReducer, props, initializeGraphState);
   React.useImperativeHandle(ref, () => ({
     getUserInput: () => getGradableGraph(state, props.graph)
   }));
-  function onChange(next) {
-    props.onChange(mafsStateToInteractiveGraph(next));
-  }
-  return /*#__PURE__*/React__namespace.createElement(MafsGraph, _extends({}, props, {
-    state: state,
-    dispatch: dispatch,
-    onChange: onChange
-  }));
-});
-const MafsGraph = props => {
-  const {
-    state,
-    dispatch,
-    labels
-  } = props;
-  const [width, height] = props.box;
   const prevState = React.useRef(state);
   React.useEffect(() => {
     if (prevState.current !== state) {
-      props.onChange({
+      onChange(mafsStateToInteractiveGraph({
         graph: state
-      });
+      }));
     }
     prevState.current = state;
-  }, [props, state]);
+  }, [onChange, state]);
 
   // Destructuring first to keep useEffect from making excess calls
   const [xSnap, ySnap] = props.snapStep;
@@ -31474,6 +31545,18 @@ const MafsGraph = props => {
   React.useEffect(() => {
     dispatch(changeRange([[xMinRange, xMaxRange], [yMinRange, yMaxRange]]));
   }, [dispatch, xMinRange, xMaxRange, yMinRange, yMaxRange]);
+  return /*#__PURE__*/React__namespace.createElement(MafsGraph, _extends({}, props, {
+    state: state,
+    dispatch: dispatch
+  }));
+});
+const MafsGraph = props => {
+  const {
+    state,
+    dispatch,
+    labels
+  } = props;
+  const [width, height] = props.box;
   return /*#__PURE__*/React__namespace.createElement(GraphConfigContext.Provider, {
     value: {
       range: state.range,
@@ -31506,8 +31589,8 @@ const MafsGraph = props => {
   }, props.markings === "graph" && /*#__PURE__*/React__namespace.createElement(AxisLabels, null), /*#__PURE__*/React__namespace.createElement(mafs.Mafs, {
     preserveAspectRatio: false,
     viewBox: {
-      x: props.range[0],
-      y: props.range[1],
+      x: state.range[0],
+      y: state.range[1],
       padding: 0
     },
     pan: false,
@@ -31517,12 +31600,12 @@ const MafsGraph = props => {
   }, /*#__PURE__*/React__namespace.createElement(SvgDefs, null), /*#__PURE__*/React__namespace.createElement(Grid, {
     tickStep: props.step,
     gridStep: props.gridStep,
-    range: props.range,
+    range: state.range,
     containerSizeClass: props.containerSizeClass,
     markings: props.markings
   }), props.lockedFigures && /*#__PURE__*/React__namespace.createElement(GraphLockedLayer, {
     lockedFigures: props.lockedFigures,
-    range: props.range
+    range: state.range
   }), renderGraph({
     state,
     dispatch
@@ -43618,7 +43701,7 @@ const init = function (options) {
 
 // This file is processed by a Rollup plugin (replace) to inject the production
 const libName = "@khanacademy/perseus";
-const libVersion = "22.4.2";
+const libVersion = "22.5.1";
 perseusCore.addLibraryVersionToPerseusDebug(libName, libVersion);
 
 const apiVersion = {