@khanacademy/perseus 3.0.0 → 4.0.0

package/src/widgets/video.jsx

@@ -1,126 +0,0 @@
-// @flow
-/**
- * This is a video widget for embedding videos in articles.
- */
-
-import {View} from "@khanacademy/wonder-blocks-core";
-import * as i18n from "@khanacademy/wonder-blocks-i18n";
-import * as React from "react";
-import _ from "underscore";
-
-import FixedToResponsive from "../components/fixed-to-responsive.jsx";
-import {getDependencies} from "../dependencies.js";
-import * as Changeable from "../mixins/changeable.jsx";
-import a11y from "../util/a11y.js";
-
-import VideoTranscriptLink from "./video-transcript-link.jsx";
-
-import type {PerseusVideoWidgetOptions} from "../perseus-types.js";
-import type {PerseusScore, WidgetExports, WidgetProps} from "../types.js";
-
-// Current default is 720p, based on the typical videos we upload currently
-const DEFAULT_WIDTH = 1280;
-const DEFAULT_HEIGHT = 720;
-
-const KA_EMBED = "{host}/embed_video?slug={slug}" + "&internal_video_only=1";
-const IS_URL = /^https?:\/\//;
-const IS_KA_SITE = /(khanacademy\.org|localhost)/;
-
-type UserInput = null;
-type Rubric = PerseusVideoWidgetOptions;
-type RenderProps = PerseusVideoWidgetOptions; // exports has no 'transform'
-type Props = {|
-    ...WidgetProps<RenderProps, Rubric>,
-    alignment: string, // Where does this get set?
-|};
-
-/**
- * Video renderer.
- */
-class Video extends React.Component<Props> {
-    /**
-     * This is the widget's grading function.
-     * Points for videos are tallied by the embedded video itself, in the case
-     * of Khan Academy videos.
-     */
-    static validate(userInput: UserInput, rubric: Rubric): PerseusScore {
-        return {
-            type: "points",
-            earned: 0,
-            total: 0,
-            message: null,
-        };
-    }
-
-    getUserInput: () => ?void = () => {
-        return null;
-    };
-
-    simpleValidate: (Rubric) => PerseusScore = (rubric) => {
-        return Video.validate(null, rubric);
-    };
-
-    change: (...args: $ReadOnlyArray<mixed>) => $FlowFixMe = (...args) => {
-        // $FlowFixMe[incompatible-call]
-        return Changeable.change.apply(this, args);
-    };
-
-    render(): React.Node {
-        const {InitialRequestUrl} = getDependencies();
-
-        const location = this.props.location;
-        if (!location) {
-            return <div />;
-        }
-
-        let url;
-
-        if (IS_URL.test(location)) {
-            url = location;
-        } else {
-            url = KA_EMBED.replace("{slug}", location);
-            let embedHostname = "https://www.khanacademy.org";
-            if (IS_KA_SITE.test(InitialRequestUrl.host)) {
-                embedHostname = InitialRequestUrl.origin;
-            }
-            url = url.replace("{host}", embedHostname);
-        }
-
-        return (
-            <View>
-                <FixedToResponsive
-                    width={DEFAULT_WIDTH}
-                    height={DEFAULT_HEIGHT}
-                    // The key is here for the benefit of the editor, to ensure that
-                    // any changes cause a re-rendering of the frame.
-                    key={location + this.props.alignment}
-                >
-                    <View style={a11y.srOnly}>
-                        {i18n._("Khan Academy video wrapper")}
-                    </View>
-
-                    <iframe
-                        // TODO(joshuan): Consider not using iframes when we're
-                        // loading this from webapp. This iframe is problematic
-                        // for screenreaders.
-                        className="perseus-video-widget"
-                        sandbox="allow-same-origin allow-scripts"
-                        width={DEFAULT_WIDTH}
-                        height={DEFAULT_HEIGHT}
-                        src={url}
-                        allowFullScreen={true}
-                    />
-                </FixedToResponsive>
-                <VideoTranscriptLink location={location} />
-            </View>
-        );
-    }
-}
-
-export default ({
-    name: "video",
-    displayName: "Video",
-    defaultAlignment: "block",
-    supportedAlignments: ["block", "float-left", "float-right", "full-width"],
-    widget: Video,
-}: WidgetExports<typeof Video>);

package/src/widgets.js

@@ -1,431 +0,0 @@
-// @flow
-import * as React from "react";
-import _ from "underscore";
-
-import {Errors, Log} from "./logging/log.js";
-import {PerseusError} from "./perseus-error.js";
-
-import type {
-    Alignment,
-    Tracking,
-    Version,
-    WidgetExports,
-    WidgetInfo,
-    WidgetTransform,
-} from "./types.js";
-
-const DEFAULT_ALIGNMENT = "block";
-// NOTE(kevinb): "default" is not one in `validAlignments`.
-const DEFAULT_SUPPORTED_ALIGNMENTS = ["default"];
-const DEFAULT_STATIC = false;
-const DEFAULT_TRACKING = "";
-const DEFAULT_LINTABLE = false;
-
-type Editor = $FlowFixMe;
-
-const widgets: {|[string]: WidgetExports<>|} = {};
-const editors = {};
-
-// Widgets must be registered to avoid circular dependencies with the
-// core Editor and Renderer components.
-// TODO(jeremy): The widget name is already embedded in the WidgetExports type
-// so could we drop the `name` parameter here?
-export const registerWidget = (name: string, widget: WidgetExports<>) => {
-    widgets[name] = widget;
-};
-
-export const registerWidgets = (widgets: $ReadOnlyArray<WidgetExports<>>) => {
-    widgets.forEach((widget) => {
-        registerWidget(widget.name, widget);
-    });
-
-    validateAlignments();
-};
-
-export const registerEditors = (editorsToRegister: $ReadOnlyArray<Editor>) => {
-    editorsToRegister.forEach((editor) => {
-        if (!editor.widgetName) {
-            throw new PerseusError(
-                `Editor ${editor.displayName} doesn't have a widgetName property`,
-                Errors.Internal,
-            );
-        }
-        editors[editor.widgetName] = editor;
-    });
-};
-
-export const getWidget = (name: string): ?React.ComponentType<any> => {
-    // TODO(alex): Consider referring to these as renderers to avoid
-    // overloading "widget"
-    if (!_.has(widgets, name)) {
-        return null;
-    }
-
-    // Allow widgets to specify a widget directly or via a function
-    if (widgets[name].getWidget) {
-        return widgets[name].getWidget();
-    }
-    return widgets[name].widget;
-};
-
-export const getEditor = (name: string): ?Editor => {
-    return _.has(editors, name) ? editors[name] : null;
-};
-
-export const getTransform = (name: string): ?WidgetTransform => {
-    return _.has(widgets, name) ? widgets[name].transform || _.identity : null;
-};
-
-export const getVersion = (name: string): ?Version => {
-    const widgetInfo = widgets[name];
-    if (widgetInfo) {
-        return widgets[name].version || {major: 0, minor: 0};
-    }
-    return null;
-};
-
-export const getVersionVector = (): {|[string]: Version|} => {
-    const version = {};
-    _.each(_.keys(widgets), function (name) {
-        version[name] = getVersion(name);
-    });
-    return version;
-};
-
-export const getPublicWidgets = (): $ReadOnlyArray<WidgetExports<>> => {
-    // TODO(alex): Update underscore.js so that _.pick can take a function.
-    return _.pick(
-        widgets,
-        _.reject(_.keys(widgets), function (name) {
-            return widgets[name].hidden;
-        }),
-    );
-};
-
-export const isAccessible = (widgetInfo: WidgetInfo): boolean => {
-    const accessible = widgets[widgetInfo.type].accessible;
-    if (typeof accessible === "function") {
-        return accessible(widgetInfo.options);
-    }
-    return !!accessible;
-};
-
-export const getAllWidgetTypes = (): $ReadOnlyArray<string> => {
-    return _.keys(widgets);
-};
-
-export const upgradeWidgetInfoToLatestVersion = (
-    oldWidgetInfo: WidgetInfo,
-): WidgetInfo => {
-    const type = oldWidgetInfo.type;
-    // TODO(LP-10707): Remove unnecessary type checking (`type` is a string)
-    if (!_.isString(type)) {
-        throw new PerseusError(
-            "widget type must be a string, but was: " + type,
-            Errors.Internal,
-        );
-    }
-    const widgetExports = widgets[type];
-
-    if (widgetExports == null) {
-        // If we have a widget that isn't registered, we can't upgrade it
-        // TODO(aria): Figure out what the best thing to do here would be
-        return oldWidgetInfo;
-    }
-
-    // Unversioned widgets (pre-July 2014) are all implicitly 0.0
-    const initialVersion = oldWidgetInfo.version || {major: 0, minor: 0};
-    const latestVersion = widgetExports.version || {major: 0, minor: 0};
-
-    // If the widget version is later than what we understand (major
-    // version is higher than latest, or major versions are equal and minor
-    // version is higher than latest), don't perform any upgrades.
-    if (
-        initialVersion.major > latestVersion.major ||
-        (initialVersion.major === latestVersion.major &&
-            initialVersion.minor > latestVersion.minor)
-    ) {
-        return oldWidgetInfo;
-    }
-
-    // We do a clone here so that it's safe to mutate the input parameter
-    // in propUpgrades functions (which I will probably accidentally do at
-    // some point, and we would like to not break when that happens).
-    let newEditorProps = _.clone(oldWidgetInfo.options) || {};
-
-    const upgradePropsMap = widgetExports.propUpgrades || {};
-
-    // Empty props usually mean a newly created widget by the editor,
-    // and are always considerered up-to-date.
-    // Mostly, we'd rather not run upgrade functions on props that are
-    // not complete.
-    if (_.keys(newEditorProps).length !== 0) {
-        // We loop through all the versions after the current version of
-        // the loaded widget, up to and including the latest version of the
-        // loaded widget, and run the upgrade function to bring our loaded
-        // widget's props up to that version.
-        // There is a little subtlety here in that we call
-        // upgradePropsMap[1] to upgrade *to* version 1,
-        // (not from version 1).
-        for (
-            let nextVersion = initialVersion.major + 1;
-            nextVersion <= latestVersion.major;
-            nextVersion++
-        ) {
-            if (upgradePropsMap[String(nextVersion)]) {
-                newEditorProps =
-                    upgradePropsMap[String(nextVersion)](newEditorProps);
-            } else {
-                // This is a Log.error because it is unlikely to be hit in
-                // local testing, and a Log.error is slightly less scary in
-                // prod than a `throw new Error`
-                Log.error(
-                    "No upgrade found for widget. Cannot render.",
-                    Errors.Internal,
-                    {
-                        loggedMetadata: {
-                            type,
-                            fromMajorVersion: nextVersion - 1,
-                            toMajorVersion: nextVersion,
-                        },
-                    },
-                );
-                // But try to keep going anyways (yolo!)
-                // (Throwing an error here would just break the page
-                // silently anyways, so that doesn't seem much better
-                // than a halfhearted attempt to continue, however
-                // shallow...)
-            }
-        }
-    }
-
-    // Minor version upgrades (eg. new optional props) don't have
-    // transform functions. Instead, we fill in the new props with their
-    // defaults.
-    const defaultProps = type in editors ? editors[type].defaultProps : {};
-    newEditorProps = {
-        ...defaultProps,
-        ...newEditorProps,
-    };
-
-    let alignment = oldWidgetInfo.alignment;
-
-    // Widgets that support multiple alignments will "lock in" the
-    // alignment to the alignment that would be listed first in the
-    // select box. If the widget only supports one alignment, the
-    // alignment value will likely just end up as "default".
-    if (alignment == null || alignment === "default") {
-        alignment = getSupportedAlignments(type)[0];
-    }
-
-    let widgetStatic = oldWidgetInfo.static;
-
-    if (widgetStatic == null) {
-        widgetStatic = DEFAULT_STATIC;
-    }
-
-    return _.extend({}, oldWidgetInfo, {
-        // maintain other info, like type
-        // After upgrading we guarantee that the version is up-to-date
-        version: latestVersion,
-        // Default graded to true (so null/undefined becomes true):
-        graded: oldWidgetInfo.graded != null ? oldWidgetInfo.graded : true,
-        alignment: alignment,
-        static: widgetStatic,
-        options: newEditorProps,
-    });
-};
-
-export const getRendererPropsForWidgetInfo = (
-    widgetInfo: WidgetInfo,
-    problemNum?: number,
-): $FlowFixMe => {
-    const type = widgetInfo.type;
-    const widgetExports = widgets[type];
-    if (widgetExports == null) {
-        // The widget is not a registered widget
-        // It shouldn't matter what we return here, but for consistency
-        // we return the untransformed options, as if the widget did
-        // not have a transform defined.
-        return widgetInfo.options;
-    }
-    let transform;
-    if (widgetInfo.static) {
-        // There aren't a lot of real places where we'll have to default to
-        // _.identity, but it's theoretically possible if someone changes
-        // the JSON manually / we have to back out static support for a
-        // widget.
-        transform = getStaticTransform(type) || _.identity;
-    } else {
-        transform = widgetExports.transform || _.identity;
-    }
-    // widgetInfo.options are the widgetEditor's props:
-    return transform(widgetInfo.options, problemNum);
-};
-
-export const traverseChildWidgets = (
-    widgetInfo: WidgetInfo,
-    traverseRenderer: $FlowFixMe,
-): WidgetInfo => {
-    if (!traverseRenderer) {
-        throw new PerseusError(
-            "traverseRenderer must be provided, but was not",
-            Errors.Internal,
-        );
-    }
-
-    if (!widgetInfo || !widgetInfo.type || !widgets[widgetInfo.type]) {
-        return widgetInfo;
-    }
-
-    const widgetExports = widgets[widgetInfo.type];
-    const props = widgetInfo.options;
-
-    if (widgetExports.traverseChildWidgets && props) {
-        const newProps = widgetExports.traverseChildWidgets(
-            props,
-            traverseRenderer,
-        );
-        return _.extend({}, widgetInfo, {options: newProps});
-    }
-    return widgetInfo;
-};
-
-/**
- * Handling for the optional alignments for widgets
- * See widget-container.jsx for details on how alignments are implemented.
- */
-
-/**
- * Returns the list of supported alignments for the given (string) widget
- * type. This is used primarily at editing time to display the choices
- * for the user.
- *
- * Supported alignments are given as an array of strings in the exports of
- * a widget's module.
- */
-export const getSupportedAlignments = (
-    type: string,
-): $ReadOnlyArray<Alignment> => {
-    const widgetExport = widgets[type];
-    return (
-        (widgetExport && widgetExport.supportedAlignments) ||
-        DEFAULT_SUPPORTED_ALIGNMENTS
-    );
-};
-
-/**
- * For the given (string) widget type, determine the default alignment for
- * the widget. This is used at rendering time to go from "default" alignment
- * to the actual alignment displayed on the screen.
- *
- * The default alignment is given either as a string (called
- * `defaultAlignment`) or a function (called `getDefaultAlignment`) on
- * the exports of a widget's module.
- */
-export const getDefaultAlignment = (type: string): Alignment => {
-    const widgetExports = widgets[type];
-    let alignment;
-    if (!widgetExports) {
-        return DEFAULT_ALIGNMENT;
-    }
-
-    if (widgetExports.getDefaultAlignment) {
-        alignment = widgetExports.getDefaultAlignment();
-    } else {
-        alignment = widgetExports.defaultAlignment;
-    }
-    return alignment || DEFAULT_ALIGNMENT;
-};
-
-const validAlignments: $ReadOnlyArray<Alignment> = [
-    "block",
-    "inline-block",
-    "inline",
-    "float-left",
-    "float-right",
-    "full-width",
-];
-
-/**
- * Used at startup to fail fast if an alignment given by a widget is
- * invalid.
- */
-// TODO(alex): Change this to run as a testcase (vs. being run at runtime)
-// TODO(LP-10707): I think this can be completely removed because our Flow types
-// enforce this!
-export const validateAlignments = () => {
-    _.each(widgets, function (widgetInfo) {
-        if (
-            widgetInfo.defaultAlignment &&
-            !_.contains(validAlignments, widgetInfo.defaultAlignment)
-        ) {
-            throw new PerseusError(
-                "Widget '" +
-                    widgetInfo.displayName +
-                    "' has an invalid defaultAlignment value: " +
-                    widgetInfo.defaultAlignment,
-                Errors.InvalidInput,
-            );
-        }
-
-        if (widgetInfo.supportedAlignments) {
-            const unknownAlignments = _.difference(
-                widgetInfo.supportedAlignments,
-                validAlignments,
-            );
-
-            if (unknownAlignments.length) {
-                throw new PerseusError(
-                    "Widget '" +
-                        widgetInfo.displayName +
-                        "' has an invalid value for supportedAlignments: " +
-                        unknownAlignments.join(" "),
-                    Errors.InvalidInput,
-                );
-            }
-        }
-    });
-};
-
-/**
- * Handling for static mode for widgets that support it.
- */
-
-/**
- * Returns true iff the widget supports static mode.
- * A widget implicitly supports static mode if it exports a
- * staticTransform function.
- */
-export const supportsStaticMode = (type: string): boolean => {
-    const widgetInfo = widgets[type];
-    return widgetInfo && widgetInfo.staticTransform != null;
-};
-
-/**
- * Return the staticTransform function used to convert the editorProps to
- * the rendered widget state.
- */
-export const getStaticTransform = (type: string): ?WidgetTransform => {
-    const widgetInfo = widgets[type];
-    return widgetInfo && widgetInfo.staticTransform;
-};
-
-/**
- * Returns the tracking option for the widget. The default is "",
- * which means simply to track interactions once. The other available
- * option is "all" which means to track all interactions.
- */
-export const getTracking = (type: string): Tracking => {
-    const widgetExport = widgets[type];
-    return (widgetExport && widgetExport.tracking) || DEFAULT_TRACKING;
-};
-
-/**
- * Returns true if this widget can include lintable markdown text
- * and supports a highlightLint prop, or false otherwise.
- */
-export const isLintable = (type: string): boolean => {
-    const widgetExports = widgets[type];
-    return (widgetExports && widgetExports.isLintable) || DEFAULT_LINTABLE;
-};