@khanacademy/perseus 19.1.4 → 19.1.6

package/src/widgets/lights-puzzle.tsx

@@ -1,359 +0,0 @@
-/* eslint-disable @typescript-eslint/no-unused-vars, react/sort-comp */
-import * as i18n from "@khanacademy/wonder-blocks-i18n";
-import PropTypes from "prop-types";
-import * as React from "react";
-import _ from "underscore";
-
-import * as Changeable from "../mixins/changeable";
-import WidgetJsonifyDeprecated from "../mixins/widget-jsonify-deprecated";
-
-import type {WidgetExports} from "../types";
-
-const MAX_SIZE = 8;
-
-// Styling
-const CELL_PADDING = 5;
-
-const TABLE_STYLE = {
-    display: "table",
-    tableLayout: "fixed",
-} as const;
-
-const ROW_STYLE = {
-    display: "table-row",
-} as const;
-
-const CELL_STYLE = {
-    display: "table-cell",
-    padding: CELL_PADDING,
-} as const;
-
-const BASE_TILE_STYLE = {
-    borderRadius: 10,
-    cursor: "pointer",
-} as const;
-
-const MOVE_COUNT_STYLE = {
-    padding: CELL_PADDING,
-    display: "inline-block",
-} as const;
-
-const RESET_BUTTON_STYLE = {
-    float: "right",
-    paddingRight: CELL_PADDING,
-} as const;
-
-const MAIN_TILE_SIZE = 50;
-
-const mapCells = (cells: any, func: any) => {
-    return _.map(cells, (row, y) => {
-        return _.map(row, (value, x) => {
-            return func(value, y, x);
-        });
-    });
-};
-
-const genCells = (height: any, width, func: any) => {
-    return _.times(height, (y) => {
-        return _.times(width, (x) => {
-            return func(y, x);
-        });
-    });
-};
-
-const PATTERNS = {
-    plus: () => [
-        [false, true, false],
-        [true, true, true],
-        [false, true, false],
-    ],
-    x: () => [
-        [true, false, true],
-        [false, true, false],
-        [true, false, true],
-    ],
-    "plus/x": (iter) => {
-        return iter % 2 ? PATTERNS.x() : PATTERNS.plus();
-    },
-} as const;
-
-/**
- * Clamps value to an integer in the range [min, max]
- */
-const clampToInt = function (value: number, min: any, max) {
-    value = Math.floor(value);
-    value = Math.max(value, min);
-    value = Math.min(value, max);
-    return value;
-};
-
-// A single glowy cell
-class Tile extends React.Component<any> {
-    static propTypes = {
-        value: PropTypes.bool.isRequired,
-        size: PropTypes.number.isRequired,
-    };
-
-    render(): React.ReactNode {
-        const color = this.props.value ? "#55dd55" : "#115511";
-        const style = _.extend({}, BASE_TILE_STYLE, {
-            width: this.props.size,
-            height: this.props.size,
-            backgroundColor: color,
-        });
-        return <div style={style} onClick={this._flip} />;
-    }
-
-    _flip = () => {
-        this.props.onChange(!this.props.value);
-    };
-}
-
-// A grid of glowy cells
-class TileGrid extends React.Component<any> {
-    static propTypes = {
-        cells: PropTypes.arrayOf(PropTypes.arrayOf(PropTypes.bool)).isRequired,
-        size: PropTypes.number.isRequired,
-    };
-
-    render(): React.ReactNode {
-        return (
-            <div style={TABLE_STYLE} className="no-select">
-                {_.map(this.props.cells, (row, y) => {
-                    return (
-                        <div key={y} style={ROW_STYLE}>
-                            {_.map(row, (cell, x) => {
-                                return (
-                                    <div key={x} style={CELL_STYLE}>
-                                        <Tile
-                                            value={cell}
-                                            size={this.props.size}
-                                            onChange={_.partial(
-                                                this.props.onChange,
-                                                y,
-                                                x,
-                                            )}
-                                        />
-                                    </div>
-                                );
-                            })}
-                        </div>
-                    );
-                })}
-            </div>
-        );
-    }
-}
-
-// Returns a copy of the tiles, with tiles flipped according to
-// whether or not their y, x position satisfies the predicate
-const flipTilesPredicate = (
-    oldCells: any,
-    predicate: (y?: any, x?: any) => any | boolean,
-) => {
-    return _.map(oldCells, (row, y) => {
-        return _.map(row, (cell, x) => {
-            return predicate(y, x) ? !cell : cell;
-        });
-    });
-};
-
-const flipTilesPattern = (oldCells: any, tileY: any, tileX, pattern: any) => {
-    return flipTilesPredicate(oldCells, (y, x) => {
-        const offsetY = y - tileY;
-        const offsetX = x - tileX;
-        if (Math.abs(offsetY) <= 1 && Math.abs(offsetX) <= 1) {
-            return pattern[offsetY + 1][offsetX + 1];
-        }
-        return false;
-    });
-};
-
-// The lights puzzle widget
-class LightsPuzzle extends React.Component<any> {
-    _currPattern: any;
-    _nextPattern: any;
-    // @ts-expect-error - TS2564 - Property '_patternIndex' has no initializer and is not definitely assigned in the constructor.
-    _patternIndex: number;
-
-    static propTypes = {
-        ...Changeable.propTypes,
-        cells: PropTypes.arrayOf(PropTypes.arrayOf(PropTypes.bool)),
-        startCells: PropTypes.arrayOf(PropTypes.arrayOf(PropTypes.bool)),
-        flipPattern: PropTypes.string.isRequired,
-        moveCount: PropTypes.number.isRequired,
-    };
-
-    static defaultProps: any = {
-        cells: [
-            [false, false, false],
-            [false, false, false],
-            [false, false, false],
-        ],
-        startCells: [
-            [false, false, false],
-            [false, false, false],
-            [false, false, false],
-        ],
-        flipPattern: "plus",
-        moveCount: 0,
-    };
-
-    getUserInput: () => any = () => {
-        return WidgetJsonifyDeprecated.getUserInput.call(this);
-    };
-
-    render(): React.ReactNode {
-        const width = this._width();
-        const tileSize = MAIN_TILE_SIZE;
-        const pxWidth = width * (tileSize + 2 * CELL_PADDING);
-        return (
-            <div>
-                <TileGrid
-                    cells={this.props.cells}
-                    size={tileSize}
-                    onChange={this._flipTile}
-                />
-                <div style={{width: pxWidth}}>
-                    <div style={MOVE_COUNT_STYLE}>
-                        {i18n.ngettext(
-                            "Moves: %(num)s",
-                            "Moves: %(num)s",
-                            this.props.moveCount,
-                        )}
-                    </div>
-                    <div style={RESET_BUTTON_STYLE}>
-                        <input
-                            type="button"
-                            value="Reset"
-                            onClick={this._reset}
-                            className="simple-button"
-                        />
-                    </div>
-                </div>
-                <div className="clearfix" />
-            </div>
-        );
-    }
-
-    change: (...args: ReadonlyArray<unknown>) => any = (...args) => {
-        // @ts-expect-error - TS2345 - Argument of type 'readonly unknown[]' is not assignable to parameter of type 'any[]'.
-        return Changeable.change.apply(this, args);
-    };
-
-    _width: () => number = () => {
-        if (this.props.cells.length !== 0) {
-            return this.props.cells[0].length;
-        }
-        return 0; // default to 0
-    };
-
-    componentDidMount() {
-        this._initNextPatterns();
-    }
-
-    componentDidUpdate(prevProps: any) {
-        if (prevProps.flipPattern !== this.props.flipPattern) {
-            this._initNextPatterns();
-        }
-    }
-
-    _initNextPatterns: () => void = () => {
-        this._currPattern = PATTERNS[this.props.flipPattern](0);
-        this._nextPattern = PATTERNS[this.props.flipPattern](1);
-        this._patternIndex = 2;
-    };
-
-    _shiftPatterns: () => void = () => {
-        this._currPattern = this._nextPattern;
-        this._nextPattern = PATTERNS[this.props.flipPattern](
-            this._patternIndex,
-        );
-        this._patternIndex++;
-    };
-
-    _flipTile: (arg1: any, arg2: any) => void = (tileY, tileX) => {
-        const newCells = flipTilesPattern(
-            this.props.cells,
-            tileY,
-            tileX,
-            this._currPattern,
-        );
-        this._shiftPatterns();
-
-        this.change({
-            cells: newCells,
-            moveCount: this.props.moveCount + 1,
-        });
-    };
-
-    _reset: () => void = () => {
-        this.change({
-            cells: this.props.startCells,
-            moveCount: 0,
-        });
-    };
-
-    simpleValidate: (arg1: any) => any = (rubric) => {
-        return validate(rubric, this.getUserInput());
-    };
-}
-
-// grading function
-const validate = function (rubric: any, state: any) {
-    const empty = _.all(state.cells, (row, y) => {
-        return _.all(row, (cell, x) => {
-            return cell === rubric.startCells[y][x];
-        });
-    });
-    if (empty) {
-        return {
-            type: "invalid",
-            message: i18n._("Click on the tiles to change the lights."),
-        };
-    }
-
-    const correct = _.all(state.cells, (row) => {
-        return _.all(row, (cell) => {
-            return cell;
-        });
-    });
-
-    if (correct) {
-        return {
-            type: "points",
-            earned: 1,
-            total: 1,
-            message: null,
-        };
-    }
-    if (rubric.gradeIncompleteAsWrong) {
-        return {
-            type: "points",
-            earned: 0,
-            total: 1,
-            message: null,
-        };
-    }
-    return {
-        type: "invalid",
-        message: i18n._("You must turn on all of the lights to continue."),
-    };
-};
-
-// The function run on the editor props to create the widget props
-const transformProps: (arg1: any) => any = function (editorProps) {
-    return {
-        cells: editorProps.startCells,
-        startCells: editorProps.startCells,
-        flipPattern: editorProps.flipPattern,
-    };
-};
-
-export default {
-    name: "lights-puzzle",
-    displayName: "Lights puzzle (deprecated)",
-    hidden: true,
-    widget: LightsPuzzle,
-    transform: transformProps,
-} as WidgetExports<typeof LightsPuzzle>;

package/src/widgets/matcher.tsx

@@ -1,298 +0,0 @@
-/* eslint-disable @khanacademy/ts-no-error-suppressions */
-/* eslint-disable react/forbid-prop-types, react/sort-comp */
-import {
-    linterContextProps,
-    linterContextDefault,
-} from "@khanacademy/perseus-linter";
-import {CircularSpinner} from "@khanacademy/wonder-blocks-progress-spinner";
-import {StyleSheet, css} from "aphrodite";
-import PropTypes from "prop-types";
-import * as React from "react";
-import _ from "underscore";
-
-import Sortable, {Layout} from "../components/sortable";
-import {getDependencies} from "../dependencies";
-import {ApiOptions} from "../perseus-api";
-import Renderer from "../renderer";
-import Util from "../util";
-
-import type {SortableOption} from "../components/sortable";
-import type {WidgetExports} from "../types";
-
-const {shuffle, seededRNG} = Util;
-const HACKY_CSS_CLASSNAME = "perseus-widget-matcher";
-
-type State = {
-    leftHeight: number;
-    rightHeight: number;
-    texRendererLoaded: boolean;
-};
-
-export class Matcher extends React.Component<any, any> {
-    static propTypes = {
-        apiOptions: ApiOptions.propTypes,
-        labels: PropTypes.array,
-        left: PropTypes.array,
-        onChange: PropTypes.func,
-        orderMatters: PropTypes.bool,
-        padding: PropTypes.bool,
-        problemNum: PropTypes.number,
-        right: PropTypes.array,
-        trackInteraction: PropTypes.func.isRequired,
-        linterContext: linterContextProps,
-    };
-
-    static defaultProps: any = {
-        left: [],
-        right: [],
-        labels: ["", ""],
-        orderMatters: false,
-        padding: true,
-        problemNum: 0,
-        onChange: function () {},
-        linterContext: linterContextDefault,
-    };
-
-    state: State = {
-        leftHeight: 0,
-        rightHeight: 0,
-        texRendererLoaded: false,
-    };
-
-    render(): React.ReactElement {
-        // To minimize layout shift, we display a spinner until our math
-        // renderer is ready to render the math inside the matcher. To
-        // do this, we:
-        // - render a dummy TeX component to force the math renderer to load
-        // - display a spinner until the TeX component calls its onRender
-        //   callback, signifying that the math is rendered (from which we can
-        //   infer that the math renderer has loaded)
-        //
-        // If we didn't do this, the user might see a matcher with empty
-        // columns on first render, and then the math would pop in a few
-        // moments later once the rendering library loaded.
-        if (!this.state.texRendererLoaded) {
-            const {TeX} = getDependencies();
-            return (
-                <>
-                    <CircularSpinner />
-                    <div style={{display: "none"}}>
-                        <TeX
-                            onRender={() => {
-                                this.setState({texRendererLoaded: true});
-                            }}
-                        >
-                            1
-                        </TeX>
-                    </div>
-                </>
-            );
-        }
-
-        // Use the same random() function to shuffle both columns sequentially
-        const rng = seededRNG(this.props.problemNum);
-
-        let left;
-        if (!this.props.orderMatters) {
-            // If the order doesn't matter, don't shuffle the left column
-            left = this.props.left;
-        } else {
-            left = shuffle(this.props.left, rng, /* ensurePermuted */ true);
-        }
-
-        const right = shuffle(this.props.right, rng, /* ensurePermuted */ true);
-
-        const showLabels = _.any(this.props.labels);
-        const constraints = {
-            height: _.max([this.state.leftHeight, this.state.rightHeight]),
-        } as const;
-
-        const cellMarginPx = this.props.apiOptions.isMobile ? 8 : 5;
-
-        return (
-            <table className={css(styles.widget) + " " + HACKY_CSS_CLASSNAME}>
-                <tbody>
-                    {showLabels && (
-                        <tr className={css(styles.row)}>
-                            <th
-                                className={css(
-                                    styles.column,
-                                    styles.columnLabel,
-                                )}
-                            >
-                                <Renderer
-                                    content={this.props.labels[0] || "..."}
-                                    linterContext={this.props.linterContext}
-                                />
-                            </th>
-                            <th
-                                className={css(
-                                    styles.column,
-                                    styles.columnRight,
-                                    styles.columnLabel,
-                                )}
-                            >
-                                <Renderer
-                                    content={this.props.labels[1] || "..."}
-                                    linterContext={this.props.linterContext}
-                                />
-                            </th>
-                        </tr>
-                    )}
-                    <tr className={css(styles.row)}>
-                        <td className={css(styles.column)}>
-                            <Sortable
-                                options={left}
-                                layout={Layout.VERTICAL}
-                                padding={this.props.padding}
-                                disabled={!this.props.orderMatters}
-                                constraints={constraints}
-                                onMeasure={this.onMeasureLeft}
-                                onChange={this.changeAndTrack}
-                                margin={cellMarginPx}
-                                linterContext={this.props.linterContext}
-                                // eslint-disable-next-line react/no-string-refs
-                                ref="left"
-                            />
-                        </td>
-                        <td className={css(styles.column, styles.columnRight)}>
-                            <Sortable
-                                // @ts-expect-error - TS2322 - Type 'readonly unknown[]' is not assignable to type 'readonly string[]'.
-                                options={right}
-                                layout={Layout.VERTICAL}
-                                padding={this.props.padding}
-                                constraints={constraints}
-                                onMeasure={this.onMeasureRight}
-                                onChange={this.changeAndTrack}
-                                margin={cellMarginPx}
-                                linterContext={this.props.linterContext}
-                                // eslint-disable-next-line react/no-string-refs
-                                ref="right"
-                            />
-                        </td>
-                    </tr>
-                </tbody>
-            </table>
-        );
-    }
-
-    changeAndTrack: (arg1: any) => void = (e) => {
-        this.props.onChange(e);
-        this.props.trackInteraction();
-    };
-
-    onMeasureLeft: (arg1: any) => void = (dimensions) => {
-        const height = _.max(dimensions.heights);
-        this.setState({leftHeight: height});
-    };
-
-    onMeasureRight: (arg1: any) => void = (dimensions) => {
-        const height = _.max(dimensions.heights);
-        this.setState({rightHeight: height});
-    };
-
-    getUserInput: () => any = () => {
-        // If the math renderer hasn't loaded then we won't be able to get the
-        // contents of the sortables on the left and right, so we just return
-        // empty arrays until we render for the first time.
-        if (!this.state.texRendererLoaded) {
-            return {
-                left: [],
-                right: [],
-            };
-        }
-
-        return {
-            // eslint-disable-next-line react/no-string-refs
-            // @ts-expect-error - TS2339 - Property 'getOptions' does not exist on type 'ReactInstance'.
-            left: this.refs.left.getOptions(),
-            // eslint-disable-next-line react/no-string-refs
-            // @ts-expect-error - TS2339 - Property 'getOptions' does not exist on type 'ReactInstance'.
-            right: this.refs.right.getOptions(),
-        };
-    };
-
-    // Programatic API for moving options
-    // This is used by testing
-    moveLeftOptionToIndex: (option: SortableOption, index: number) => void = (
-        option,
-        index,
-    ) => {
-        // eslint-disable-next-line react/no-string-refs
-        // @ts-expect-error - TS2339 - Property 'moveOptionToIndex' does not exist on type 'ReactInstance'.
-        this.refs.left.moveOptionToIndex(option, index);
-    };
-
-    // Programatic API for moving options
-    // This is used by testing
-    moveRightOptionToIndex: (option: SortableOption, index: number) => void = (
-        option,
-        index,
-    ) => {
-        // eslint-disable-next-line react/no-string-refs
-        // @ts-expect-error - TS2339 - Property 'moveOptionToIndex' does not exist on type 'ReactInstance'.
-        this.refs.right.moveOptionToIndex(option, index);
-    };
-
-    simpleValidate: (arg1: any) => any = (rubric) => {
-        // @ts-expect-error - TS2339 - Property 'validate' does not exist on type 'typeof Matcher'.
-        return Matcher.validate(this.getUserInput(), rubric);
-    };
-}
-
-_.extend(Matcher, {
-    validate: function (state, rubric) {
-        const correct =
-            _.isEqual(state.left, rubric.left) &&
-            _.isEqual(state.right, rubric.right);
-
-        return {
-            type: "points",
-            earned: correct ? 1 : 0,
-            total: 1,
-            message: null,
-        };
-    },
-});
-
-const padding = 5;
-const border = "1px solid #444";
-
-const styles = StyleSheet.create({
-    widget: {
-        paddingTop: padding,
-        maxWidth: "100%",
-
-        // Need to override minWidth in CSS :(
-        minWidth: "auto",
-    },
-
-    row: {
-        // Need to override global rules in CSS :(
-        border: 0,
-    },
-
-    column: {
-        // TODO(benkomalo): constraint to half width?
-        padding: 0,
-        border: 0,
-    },
-
-    columnRight: {
-        borderLeft: border,
-    },
-
-    columnLabel: {
-        fontWeight: "inherit",
-        borderBottom: border,
-        padding: `0 ${padding}px ${padding}px ${padding}px`,
-        textAlign: "center",
-    },
-});
-
-export default {
-    name: "matcher",
-    displayName: "Matcher (two column)",
-    widget: Matcher,
-    isLintable: true,
-} as WidgetExports<typeof Matcher>;