@khanacademy/perseus-core 3.0.5 → 3.2.0

package/dist/types.d.ts

@@ -17,4 +17,16 @@ export type KEScore = {
     guess: any;
     state: any;
 };
+export type MarkerType = {
+    answers: ReadonlyArray<string>;
+    label: string;
+    x: number;
+    y: number;
+};
+export type InteractiveMarkerType = MarkerType & {
+    selected?: ReadonlyArray<string>;
+    showCorrectness?: "correct" | "incorrect";
+    focused?: boolean;
+};
+export type Relationship = "lt" | "gt" | "le" | "ge";
 export {};

package/dist/utils/deep-clone.d.ts

@@ -0,0 +1,3 @@
+type Cloneable = null | undefined | boolean | string | number | Cloneable[] | readonly Cloneable[];
+declare function deepClone<T extends Cloneable>(obj: T): T;
+export default deepClone;

package/dist/utils/equality.d.ts

@@ -0,0 +1,9 @@
+/**
+ * APPROXIMATE equality on numbers and primitives.
+ */
+export declare function approximateEqual<T>(x: T, y: T): boolean;
+/**
+ * Deep APPROXIMATE equality on primitives, numbers, arrays, and objects.
+ * Recursive.
+ */
+export declare function approximateDeepEqual<T>(x: T, y: T): boolean;

package/dist/utils/get-decimal-separator.d.ts

@@ -0,0 +1,5 @@
+/**
+ *  Get the character used for separating decimals.
+ */
+declare const getDecimalSeparator: (locale: string) => string;
+export default getDecimalSeparator;

package/dist/utils/get-matrix-size.d.ts

@@ -0,0 +1,2 @@
+declare function getMatrixSize(matrix: ReadonlyArray<ReadonlyArray<number>>): number[];
+export default getMatrixSize;

package/dist/utils/grapher-types.d.ts

@@ -0,0 +1,58 @@
+import type { Coord } from "../data-schema";
+export type Coords = [Coord, Coord];
+type SharedGrapherType = {
+    url: string;
+    defaultCoords: Coords;
+    getFunctionForCoeffs: (coeffs: ReadonlyArray<number>, x: number) => number;
+    getEquationString: (coords: Coords, asymptote?: Coords) => string | null;
+    areEqual: (coeffs1: ReadonlyArray<number>, coeffs2: ReadonlyArray<number>) => boolean;
+    Movable: any;
+    getCoefficients: (coords: Coords, asymptote?: Coords) => ReadonlyArray<number> | undefined;
+};
+type AsymptoticGraphsType = {
+    defaultAsymptote: Coords;
+    extraCoordConstraint: (newCoord: Coord, oldCoord: Coord, coords: Coords, asymptote: Coords, graph: any) => boolean | Coord;
+    extraAsymptoteConstraint: (newCoord: Coord, oldCoord: Coord, coords: Coords, asymptote: Coords, graph: any) => Coord;
+    allowReflectOverAsymptote: boolean;
+};
+export type LinearType = SharedGrapherType & {
+    getPropsForCoeffs: (coeffs: ReadonlyArray<number>) => {
+        fn: any;
+    };
+};
+export type QuadraticType = SharedGrapherType & {
+    getPropsForCoeffs: (coeffs: ReadonlyArray<number>) => {
+        a: number;
+        b: number;
+        c: number;
+    };
+};
+export type SinusoidType = SharedGrapherType & {
+    getPropsForCoeffs: (coeffs: ReadonlyArray<number>) => {
+        a: number;
+        b: number;
+        c: number;
+        d: number;
+    };
+};
+export type TangentType = SharedGrapherType & {
+    getPropsForCoeffs: (coeffs: ReadonlyArray<number>) => {
+        fn: any;
+    };
+};
+export type ExponentialType = SharedGrapherType & AsymptoticGraphsType & {
+    getPropsForCoeffs: (coeffs: ReadonlyArray<number>) => {
+        fn: any;
+    };
+};
+export type LogarithmType = SharedGrapherType & AsymptoticGraphsType & {
+    getPropsForCoeffs: (coeffs: ReadonlyArray<number>) => {
+        fn: any;
+    };
+};
+export type AbsoluteValueType = SharedGrapherType & {
+    getPropsForCoeffs: (coeffs: ReadonlyArray<number>) => {
+        fn: any;
+    };
+};
+export {};

package/dist/utils/grapher-util.d.ts

@@ -0,0 +1,20 @@
+import type { LinearType, QuadraticType, SinusoidType, TangentType, ExponentialType, LogarithmType, AbsoluteValueType } from "./grapher-types";
+export declare const MOVABLES: {
+    PLOT: string;
+    PARABOLA: string;
+    SINUSOID: string;
+};
+declare const functionTypeMapping: {
+    readonly linear: LinearType;
+    readonly quadratic: QuadraticType;
+    readonly sinusoid: SinusoidType;
+    readonly tangent: TangentType;
+    readonly exponential: ExponentialType;
+    readonly logarithm: LogarithmType;
+    readonly absolute_value: AbsoluteValueType;
+};
+export declare const allTypes: any;
+export type FunctionTypeMappingKeys = keyof typeof functionTypeMapping;
+type ConditionalGraderType<T extends FunctionTypeMappingKeys> = T extends "linear" ? LinearType : T extends "quadratic" ? QuadraticType : T extends "sinusoid" ? SinusoidType : T extends "tangent" ? TangentType : T extends "exponential" ? ExponentialType : T extends "logarithm" ? LogarithmType : T extends "absolute_value" ? AbsoluteValueType : never;
+export declare function functionForType<T extends FunctionTypeMappingKeys>(type: T): ConditionalGraderType<T>;
+export {};

package/dist/utils/objective_.d.ts

@@ -0,0 +1,30 @@
+/**
+ * _ utilities for objects
+ */
+/**
+ * Does a pluck on keys inside objects in an object
+ *
+ * Ex:
+ * tools = {
+ *     translation: {
+ *         enabled: true
+ *     },
+ *     rotation: {
+ *         enabled: false
+ *     }
+ * };
+ * pluckObject(tools, "enabled") returns {
+ *     translation: true
+ *     rotation: false
+ * }
+ */
+export declare const pluck: (table: any, subKey: string) => any;
+/**
+ * Maps an object to an object
+ *
+ * > mapObject({a: '1', b: '2'}, (value, key) => {
+ *       return value + 1;
+ *   });
+ * {a: 2, b: 3}
+ */
+export declare const mapObject: <K extends string, V, U>(obj: Record<K, V>, lambda: (arg1: V, arg2: K) => U) => Record<K, U>;

package/package.json

@@ -3,7 +3,7 @@
     "description": "Shared Perseus infrastructure",
     "author": "Khan Academy",
     "license": "MIT",
-    "version": "3.0.5",
+    "version": "3.2.0",
     "publishConfig": {
         "access": "public"
     },