@khanacademy/perseus 77.3.1 → 77.3.2

package/dist/widgets/interactive-graphs/backgrounds/utils.d.ts

@@ -10,6 +10,14 @@ export declare const getLabelTransform: (labelLocation: GraphConfig["labelLocati
     yLabelTransform: string;
 };
 export declare const getLabelPosition: (graphInfo: GraphDimensions, labelLocation: GraphConfig["labelLocation"], tickStep: GraphConfig["tickStep"]) => vec.Vector2[];
+/**
+ * Calculate the bottom margin needed for the graph container to prevent the
+ * x-axis label from overlapping with content below the graph.
+ *
+ * When the y-range starts at or above 0, the x-axis label can extend below
+ * the graph content area. This function calculates the extra margin needed.
+ */
+export declare const getGraphBottomMargin: (xAxisLabelLocationY: number, graphHeight: number, hasXAxisLabel: boolean, showsAxisLabels: boolean) => number;
 export declare const shouldShowLabel: (currentTick: number, range: [Interval, Interval], tickStep: number) => boolean;
 export declare function generateTickLocations(tickStep: number, min: number, max: number, otherAxisMin: number): number[];
 export declare const countSignificantDecimals: (number: number) => number;

package/dist/widgets/interactive-graphs/graphs/exponential.d.ts

@@ -3,7 +3,6 @@ import type { ExponentialGraphState, Dispatch, InteractiveGraphElementSuite } fr
 import type { Coord } from "@khanacademy/perseus-core";
 import type { Interval, vec } from "mafs";
 export declare function renderExponentialGraph(state: ExponentialGraphState, dispatch: Dispatch, i18n: I18nContextType): InteractiveGraphElementSuite;
-export declare const constrainAsymptoteKeyboard: (p: vec.Vector2, coords: ReadonlyArray<Coord>, snapStep: vec.Vector2) => vec.Vector2;
 export declare const getExponentialKeyboardConstraint: (coords: ReadonlyArray<Coord>, asymptote: number, snapStep: vec.Vector2, pointIndex: number, range: [Interval, Interval]) => {
     up: vec.Vector2;
     down: vec.Vector2;

package/dist/widgets/interactive-graphs/graphs/logarithm.d.ts

@@ -3,7 +3,6 @@ import type { LogarithmGraphState, Dispatch, InteractiveGraphElementSuite } from
 import type { Coord } from "@khanacademy/perseus-core";
 import type { Interval, vec } from "mafs";
 export declare function renderLogarithmGraph(state: LogarithmGraphState, dispatch: Dispatch, i18n: I18nContextType): InteractiveGraphElementSuite;
-export declare const constrainAsymptoteKeyboard: (p: vec.Vector2, coords: ReadonlyArray<Coord>, snapStep: vec.Vector2) => vec.Vector2;
 export declare const getLogarithmKeyboardConstraint: (coords: ReadonlyArray<Coord>, asymptote: number, snapStep: vec.Vector2, pointIndex: number, range: [Interval, Interval]) => {
     up: vec.Vector2;
     down: vec.Vector2;

package/dist/widgets/interactive-graphs/graphs/utils.d.ts

@@ -53,11 +53,19 @@ export declare function getAsymptoteGraphKeyboardConstraint(coords: ReadonlyArra
     right: vec.Vector2;
 };
 /**
- * Shared keyboard constraint for asymptote movement (exponential, logarithm).
- * When the next snapped position would land between or on the curve points,
- * snaps past all of them in the direction of travel using a midpoint heuristic.
- *
- * @param orientation - "horizontal" for exponential (asymptote moves on Y-axis),
- *   "vertical" for logarithm (asymptote moves on X-axis).
+ * Position of the asymptote's drag handle in graph-space. For a horizontal
+ * asymptote (exponential), this sits at the midpoint of the x-range on
+ * the asymptote's y-value. For a vertical asymptote (logarithm), it sits
+ * on the asymptote's x-value at the midpoint of the y-range.
+ */
+export declare function getAsymptoteHandleCoord(orientation: "horizontal" | "vertical", range: [Interval, Interval], asymptote: number): vec.Vector2;
+/**
+ * Keyboard snap + skip for the asymptote drag handle. `useDraggable`'s
+ * function-form constraint expects the returned point to be snap-aligned;
+ * it searches along the direction of travel until the returned point is
+ * far enough from the current asymptote to register as a move. After
+ * snapping, if the proposed position would put the handle on one of the
+ * curve points, we step further in the direction of travel until we find
+ * a valid position (up to 3 attempts).
  */
-export declare function constrainAsymptoteKeyboardMovement(p: vec.Vector2, coords: ReadonlyArray<Coord>, snapStep: vec.Vector2, orientation: "horizontal" | "vertical"): vec.Vector2;
+export declare function skipAsymptoteKeyboardOverPoint(proposed: vec.Vector2, currentAsymptote: number, coords: ReadonlyArray<Coord>, handleCoord: vec.Vector2, snapStep: vec.Vector2, orientation: "horizontal" | "vertical"): vec.Vector2;

package/package.json

@@ -3,7 +3,7 @@
   "description": "Core Perseus API (includes renderers and widgets)",
   "author": "Khan Academy",
   "license": "MIT",
-  "version": "77.3.1",
+  "version": "77.3.2",
   "publishConfig": {
     "access": "public"
   },
@@ -43,12 +43,12 @@
     "tiny-invariant": "1.3.1",
     "uuid": "^10.0.0",
     "@khanacademy/kas": "2.2.2",
-    "@khanacademy/keypad-context": "3.2.44",
-    "@khanacademy/kmath": "2.4.2",
-    "@khanacademy/math-input": "26.4.16",
-    "@khanacademy/perseus-core": "25.0.0",
-    "@khanacademy/perseus-linter": "4.9.5",
-    "@khanacademy/perseus-score": "8.7.0",
+    "@khanacademy/keypad-context": "3.2.45",
+    "@khanacademy/kmath": "2.4.3",
+    "@khanacademy/math-input": "26.4.17",
+    "@khanacademy/perseus-core": "26.0.0",
+    "@khanacademy/perseus-linter": "5.0.0",
+    "@khanacademy/perseus-score": "8.7.1",
     "@khanacademy/perseus-utils": "2.1.5",
     "@khanacademy/pure-markdown": "2.2.7",
     "@khanacademy/simple-markdown": "2.2.2"

package/dist/widgets/interactive-graphs/interactive-graph-question-builder.d.ts

@@ -1,196 +0,0 @@
-import { vec } from "mafs";
-import type { SnapTo } from "./types";
-import type { Coord } from "../../interactive2/types";
-import type { AxisLabelLocation, CollinearTuple, LockedFigureColor, LockedFigureFillType, LockedLineStyle, MarkingsType, PerseusRenderer, StrokeWeight } from "@khanacademy/perseus-core";
-export type LockedFunctionOptions = {
-    color?: LockedFigureColor;
-    strokeStyle?: LockedLineStyle;
-    weight?: StrokeWeight;
-    directionalAxis?: "x" | "y";
-    domain?: [min: number, max: number];
-    labels?: LockedFigureLabelOptions[];
-    ariaLabel?: string;
-};
-type LockedFigureLabelOptions = {
-    text: string;
-    coord?: Coord;
-    size?: "small" | "medium" | "large";
-};
-export declare function interactiveGraphQuestionBuilder(): InteractiveGraphQuestionBuilder;
-declare class InteractiveGraphQuestionBuilder {
-    private content;
-    private fullGraphAriaLabel?;
-    private fullGraphAriaDescription?;
-    private backgroundImage?;
-    private gridStep;
-    private labels;
-    private labelLocation;
-    private markings;
-    private xRange;
-    private yRange;
-    private showAxisArrows;
-    private snapStep;
-    private tickStep;
-    private showProtractor;
-    private showTooltips;
-    private interactiveFigureConfig;
-    private lockedFigures;
-    private snapTo;
-    private staticMode;
-    build(): PerseusRenderer;
-    withContent(content: string): InteractiveGraphQuestionBuilder;
-    withFullGraphAriaLabel(label: string): InteractiveGraphQuestionBuilder;
-    withFullGraphAriaDescription(description: string): InteractiveGraphQuestionBuilder;
-    withTooltips(showTooltips: boolean): InteractiveGraphQuestionBuilder;
-    withStaticMode(staticMode: boolean): InteractiveGraphQuestionBuilder;
-    withBackgroundImage(url: string, height: number, width: number, options?: {
-        scale?: number;
-        bottom?: number;
-        left?: number;
-        right?: number;
-        top?: number;
-    }): InteractiveGraphQuestionBuilder;
-    withGridStep(x: number, y: number): InteractiveGraphQuestionBuilder;
-    withAxisLabels(x: string, y: string): InteractiveGraphQuestionBuilder;
-    withLabelLocation(labelLocation: AxisLabelLocation): InteractiveGraphQuestionBuilder;
-    withMarkings(markings: MarkingsType): InteractiveGraphQuestionBuilder;
-    withXRange(min: number, max: number): InteractiveGraphQuestionBuilder;
-    withYRange(min: number, max: number): InteractiveGraphQuestionBuilder;
-    withShowAxisArrows({ xMin, xMax, yMin, yMax, }: {
-        xMin?: boolean;
-        xMax?: boolean;
-        yMin?: boolean;
-        yMax?: boolean;
-    }): InteractiveGraphQuestionBuilder;
-    withSnapStep(x: number, y: number): InteractiveGraphQuestionBuilder;
-    withTickStep(x: number, y: number): InteractiveGraphQuestionBuilder;
-    withProtractor(): InteractiveGraphQuestionBuilder;
-    withSegments(options?: {
-        numSegments?: number;
-        startCoords?: CollinearTuple[];
-        coords?: CollinearTuple[];
-    }): InteractiveGraphQuestionBuilder;
-    withNoInteractiveFigure(): this;
-    withLinear(options?: {
-        coords?: CollinearTuple;
-        startCoords?: CollinearTuple;
-    }): InteractiveGraphQuestionBuilder;
-    withLinearSystem(options?: {
-        coords?: CollinearTuple[];
-        startCoords?: CollinearTuple[];
-    }): InteractiveGraphQuestionBuilder;
-    withRay(options?: {
-        coords?: CollinearTuple;
-        startCoords?: CollinearTuple;
-    }): InteractiveGraphQuestionBuilder;
-    withVector(options?: {
-        coords?: CollinearTuple;
-        startCoords?: CollinearTuple;
-    }): InteractiveGraphQuestionBuilder;
-    withCircle(options?: {
-        center?: Coord;
-        radius?: number;
-        startCoords?: {
-            center: Coord;
-            radius: number;
-        };
-    }): InteractiveGraphQuestionBuilder;
-    withQuadratic(options?: {
-        coords?: [Coord, Coord, Coord];
-        startCoords?: [Coord, Coord, Coord];
-    }): InteractiveGraphQuestionBuilder;
-    withSinusoid(options?: {
-        coords?: [Coord, Coord];
-        startCoords?: [Coord, Coord];
-    }): InteractiveGraphQuestionBuilder;
-    withExponential(options?: {
-        coords?: [Coord, Coord];
-        asymptote?: number;
-        startCoords?: [Coord, Coord];
-        startAsymptote?: number;
-    }): InteractiveGraphQuestionBuilder;
-    withTangent(options?: {
-        coords?: [Coord, Coord];
-        startCoords?: [Coord, Coord];
-    }): InteractiveGraphQuestionBuilder;
-    withPolygon(snapTo?: SnapTo, options?: {
-        match?: "similar" | "congruent" | "approx";
-        numSides?: number | "unlimited";
-        showAngles?: boolean;
-        showSides?: boolean;
-        coords?: Coord[];
-        startCoords?: Coord[];
-    }): InteractiveGraphQuestionBuilder;
-    withPoints(numPoints: number | "unlimited", options?: {
-        coords?: Coord[];
-        startCoords?: Coord[];
-    }): InteractiveGraphQuestionBuilder;
-    withAngle(options?: {
-        coords?: [Coord, Coord, Coord];
-        startCoords?: [Coord, Coord, Coord];
-        showAngles?: boolean;
-        allowReflexAngles?: boolean;
-        angleOffsetDeg?: number;
-        snapDegrees?: number;
-        match?: "congruent";
-    }): InteractiveGraphQuestionBuilder;
-    withLogarithm(options?: {
-        coords?: [Coord, Coord];
-        asymptote?: number;
-        startCoords?: [Coord, Coord];
-        startAsymptote?: number;
-    }): InteractiveGraphQuestionBuilder;
-    withAbsoluteValue(options?: {
-        coords?: [Coord, Coord];
-        startCoords?: [Coord, Coord];
-    }): InteractiveGraphQuestionBuilder;
-    addLockedPointAt(x: number, y: number, options?: {
-        color?: LockedFigureColor;
-        filled?: boolean;
-        labels?: LockedFigureLabelOptions[];
-        ariaLabel?: string;
-    }): InteractiveGraphQuestionBuilder;
-    addLockedLine(point1: vec.Vector2, point2: vec.Vector2, options?: {
-        kind?: "line" | "ray" | "segment";
-        lineStyle?: LockedLineStyle;
-        color?: LockedFigureColor;
-        filled?: [boolean, boolean];
-        showPoint1?: boolean;
-        showPoint2?: boolean;
-        weight?: StrokeWeight;
-        labels?: LockedFigureLabelOptions[];
-        ariaLabel?: string;
-    }): InteractiveGraphQuestionBuilder;
-    addLockedVector(tail: vec.Vector2, tip: vec.Vector2, options?: {
-        color?: LockedFigureColor;
-        labels?: LockedFigureLabelOptions[];
-        weight?: StrokeWeight;
-        ariaLabel?: string;
-    }): InteractiveGraphQuestionBuilder;
-    addLockedEllipse(center: vec.Vector2, radius: [x: number, y: number], options?: {
-        angle?: number;
-        color?: LockedFigureColor;
-        fillStyle?: LockedFigureFillType;
-        strokeStyle?: "solid" | "dashed";
-        weight?: StrokeWeight;
-        labels?: LockedFigureLabelOptions[];
-        ariaLabel?: string;
-    }): InteractiveGraphQuestionBuilder;
-    addLockedPolygon(points: vec.Vector2[], options?: {
-        color?: LockedFigureColor;
-        showVertices?: boolean;
-        fillStyle?: LockedFigureFillType;
-        strokeStyle?: LockedLineStyle;
-        weight?: StrokeWeight;
-        labels?: LockedFigureLabelOptions[];
-        ariaLabel?: string;
-    }): InteractiveGraphQuestionBuilder;
-    addLockedFunction(equation: string, options?: LockedFunctionOptions): this;
-    addLockedLabel(text: string, coord: Coord, options?: {
-        color?: LockedFigureColor;
-        size?: "small" | "medium" | "large";
-    }): this;
-    private createLockedPoint;
-    private addLockedFigure;
-}
-export {};