@khanacademy/perseus-linter 0.0.0-PR862-20231207182234 → 0.0.0-PR875-20250221232857

package/dist/index.js

@@ -2,7 +2,6 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var perseusError = require('@khanacademy/perseus-error');
 var perseusCore = require('@khanacademy/perseus-core');
 var PropTypes = require('prop-types');
 
@@ -29,7 +28,7 @@ class Selector {
    * subclasses must provide an implementation of this method.
    */
   match(state) {
-    throw new perseusError.PerseusError("Selector subclasses must implement match()", perseusError.Errors.NotAllowed);
+    throw new perseusCore.PerseusError("Selector subclasses must implement match()", perseusCore.Errors.NotAllowed);
   }
 
   /**
@@ -51,9 +50,9 @@ class Selector {
  * Instead call the static Selector.parse() method.
  */
 class Parser {
-  // We do lexing with a simple regular expression
-  // The array of tokens
-  // Which token in the array we're looking at now
+  static TOKENS; // We do lexing with a simple regular expression
+  tokens; // The array of tokens
+  tokenIndex; // Which token in the array we're looking at now
 
   constructor(s) {
     // Normalize whitespace:
@@ -212,6 +211,7 @@ class ParseError extends Error {
  * first.
  */
 class SelectorList extends Selector {
+  selectors;
   constructor(selectors) {
     super();
     this.selectors = selectors;
@@ -254,6 +254,7 @@ class AnyNode extends Selector {
  * it matches any node whose `type` property is a specified string
  */
 class TypeSelector extends Selector {
+  type;
   constructor(type) {
     super();
     this.type = type;
@@ -277,6 +278,8 @@ class TypeSelector extends Selector {
  * method.
  */
 class SelectorCombinator extends Selector {
+  left;
+  right;
   constructor(left, right) {
     super();
     this.left = left;
@@ -522,41 +525,47 @@ class SiblingCombinator extends SelectorCombinator {
 // This represents the type returned by String.match(). It is an
 // array of strings, but also has index:number and input:string properties.
 // TypeScript doesn't handle it well, so we punt and just use any.
+
 // This is the return type of the check() method of a Rule object
+
 // This is the return type of the lint detection function passed as the 4th
 // argument to the Rule() constructor. It can return null or a string or an
 // object containing a string and two numbers.
 // prettier-ignore
 // (prettier formats this in a way that ka-lint does not like)
+
 // This is the type of the lint detection function that the Rule() constructor
 // expects as its fourth argument. It is passed the TraversalState object and
 // content string that were passed to check(), and is also passed the array of
 // nodes returned by the selector match and the array of strings returned by
 // the pattern match. It should return null if no lint is detected or an
 // error message or an object contining an error message.
+
 // An optional check to verify whether or not a particular rule should
 // be checked by context. For example, some rules only apply in exercises,
 // and should never be applied to articles. Defaults to true, so if we
 // omit the applies function in a rule, it'll be tested everywhere.
+
 /**
  * A Rule object describes a Perseus lint rule. See the comment at the top of
  * this file for detailed description.
  */
 class Rule {
-  // The name of the rule
-  // The severity of the rule
-  // The specified selector or the DEFAULT_SELECTOR
-  // A regular expression if one was specified
-  // The lint-testing function or a default
-  // Checks to see if we should apply a rule or not
-  // The error message for use with the default function
+  name; // The name of the rule
+  severity; // The severity of the rule
+  selector; // The specified selector or the DEFAULT_SELECTOR
+  pattern; // A regular expression if one was specified
+  lint; // The lint-testing function or a default
+  applies; // Checks to see if we should apply a rule or not
+  message; // The error message for use with the default function
+  static DEFAULT_SELECTOR;
 
   // The comment at the top of this file has detailed docs for
   // this constructor and its arguments
   constructor(name, severity, selector, pattern, lint, applies) {
     var _this = this;
     if (!selector && !pattern) {
-      throw new perseusError.PerseusError("Lint rules must have a selector or pattern", perseusError.Errors.InvalidInput, {
+      throw new perseusCore.PerseusError("Lint rules must have a selector or pattern", perseusCore.Errors.InvalidInput, {
         metadata: {
           name
         }
@@ -624,7 +633,6 @@ class Rule {
       if (!error) {
         return null; // No lint; we're done
       }
-
       if (typeof error === "string") {
         // If the lint function returned a string we assume it
         // applies to the entire content of the node and return it.
@@ -787,12 +795,61 @@ var DoubleSpacingAfterTerminal = Rule.makeRule({
 any other kind of terminal punctuation.`
 });
 
+function buttonNotInButtonSet(name, set) {
+  return `Answer requires a button not found in the button sets: ${name} (in ${set})`;
+}
+const stringToButtonSet = {
+  "\\sqrt": "prealgebra",
+  "\\sin": "trig",
+  "\\cos": "trig",
+  "\\tan": "trig",
+  "\\log": "logarithms",
+  "\\ln": "logarithms"
+};
+
+/**
+ * Rule to make sure that Expression questions that require
+ * a specific math symbol to answer have that math symbol
+ * available in the keypad (desktop learners can use a keyboard,
+ * but mobile learners must use the MathInput keypad)
+ */
+var ExpressionWidget = Rule.makeRule({
+  name: "expression-widget",
+  severity: Rule.Severity.WARNING,
+  selector: "widget",
+  lint: function (state, content, nodes, match, context) {
+    // This rule only looks at image widgets
+    if (state.currentNode().widgetType !== "expression") {
+      return;
+    }
+    const nodeId = state.currentNode().id;
+    if (!nodeId) {
+      return;
+    }
+
+    // If it can't find a definition for the widget it does nothing
+    const widget = context?.widgets?.[nodeId];
+    if (!widget) {
+      return;
+    }
+    const answers = widget.options.answerForms;
+    const buttons = widget.options.buttonSets;
+    for (const answer of answers) {
+      for (const [str, set] of Object.entries(stringToButtonSet)) {
+        if (answer.value.includes(str) && !buttons.includes(set)) {
+          return buttonNotInButtonSet(str, set);
+        }
+      }
+    }
+  }
+});
+
 var ExtraContentSpacing = Rule.makeRule({
   name: "extra-content-spacing",
   selector: "paragraph",
   pattern: /\s+$/,
   applies: function (context) {
-    return context.contentType === "article";
+    return context?.contentType === "article";
   },
   message: `No extra whitespace at the end of content blocks.`
 });
@@ -957,6 +1014,28 @@ Whitespace in image URLs causes translation difficulties.`;
   }
 });
 
+var ImageUrlEmpty = Rule.makeRule({
+  name: "image-url-empty",
+  severity: Rule.Severity.ERROR,
+  selector: "image",
+  lint: function (state, content, nodes) {
+    const image = nodes[0];
+    const url = image.target;
+
+    // If no URL is provided, an infinite spinner will be shown in articles
+    // overlaying the page where the image should be. This prevents the page
+    // from fully loading. As a result, we check for URLS with all images.
+    if (!url || !url.trim()) {
+      return "Images should have a URL";
+    }
+
+    // NOTE(TB): Ideally there would be a check to confirm the URL works
+    // and leads to a valid resource, but fetching the URL would require
+    // linting to be able to handle async functions, which it currently
+    // cannot do.
+  }
+});
+
 // Normally we have one rule per file. But since our selector class
 // can't match specific widget types directly, this rule implements
 // a number of image widget related rules in one place. This should
@@ -972,9 +1051,13 @@ var ImageWidget = Rule.makeRule({
     if (state.currentNode().widgetType !== "image") {
       return;
     }
+    const nodeId = state.currentNode().id;
+    if (!nodeId) {
+      return;
+    }
 
     // If it can't find a definition for the widget it does nothing
-    const widget = context && context.widgets && context.widgets[state.currentNode().id];
+    const widget = context && context.widgets && context.widgets[nodeId];
     if (!widget) {
       return;
     }
@@ -1058,7 +1141,7 @@ var MathAlignLinebreaks = Rule.makeRule({
       const index = text.indexOf("\\\\");
       if (index === -1) {
         // No more backslash pairs, so we found no lint
-        return null;
+        return;
       }
       text = text.substring(index + 2);
 
@@ -1089,15 +1172,6 @@ var MathEmpty = Rule.makeRule({
   message: "Empty math: don't use $$ in your markdown."
 });
 
-var MathFontSize = Rule.makeRule({
-  name: "math-font-size",
-  severity: Rule.Severity.GUIDELINE,
-  selector: "math, blockMath",
-  pattern: /\\(tiny|Tiny|small|large|Large|LARGE|huge|Huge|scriptsize|normalsize)\s*{/,
-  message: `Math font size:
-Don't change the default font size with \\Large{} or similar commands`
-});
-
 var MathFrac = Rule.makeRule({
   name: "math-frac",
   severity: Rule.Severity.GUIDELINE,
@@ -1154,12 +1228,29 @@ nested lists are hard to read on mobile devices;
 do not use additional indentation.`
 });
 
-var Profanity = Rule.makeRule({
-  name: "profanity",
-  // This list could obviously be expanded a lot, but I figured we
-  // could start with https://en.wikipedia.org/wiki/Seven_dirty_words
-  pattern: /\b(shit|piss|fuck|cunt|cocksucker|motherfucker|tits)\b/i,
-  message: "Avoid profanity"
+var StaticWidgetInQuestionStem = Rule.makeRule({
+  name: "static-widget-in-question-stem",
+  severity: Rule.Severity.WARNING,
+  selector: "widget",
+  lint: (state, content, nodes, match, context) => {
+    if (context?.contentType !== "exercise") {
+      return;
+    }
+    if (context.stack.includes("hint")) {
+      return;
+    }
+    const nodeId = state.currentNode().id;
+    if (!nodeId) {
+      return;
+    }
+    const widget = context?.widgets?.[nodeId];
+    if (!widget) {
+      return;
+    }
+    if (widget.static) {
+      return `Widget in question stem is static (non-interactive).`;
+    }
+  }
 });
 
 var TableMissingCells = Rule.makeRule({
@@ -1209,7 +1300,7 @@ do not put widgets inside of tables.`
 });
 
 // TODO(davidflanagan):
-var AllRules = [AbsoluteUrl, BlockquotedMath, BlockquotedWidget, DoubleSpacingAfterTerminal, ExtraContentSpacing, HeadingLevel1, HeadingLevelSkip, HeadingSentenceCase, HeadingTitleCase, ImageAltText, ImageInTable, LinkClickHere, LongParagraph, MathAdjacent, MathAlignExtraBreak, MathAlignLinebreaks, MathEmpty, MathFontSize, MathFrac, MathNested, MathStartsWithSpace, MathTextEmpty, NestedLists, TableMissingCells, UnescapedDollar, WidgetInTable, Profanity, MathWithoutDollars, UnbalancedCodeDelimiters, ImageSpacesAroundUrls, ImageWidget];
+var AllRules = [AbsoluteUrl, BlockquotedMath, BlockquotedWidget, DoubleSpacingAfterTerminal, ImageUrlEmpty, ExpressionWidget, ExtraContentSpacing, HeadingLevel1, HeadingLevelSkip, HeadingSentenceCase, HeadingTitleCase, ImageAltText, ImageInTable, LinkClickHere, LongParagraph, MathAdjacent, MathAlignExtraBreak, MathAlignLinebreaks, MathEmpty, MathFrac, MathNested, MathStartsWithSpace, MathTextEmpty, NestedLists, StaticWidgetInQuestionStem, TableMissingCells, UnescapedDollar, WidgetInTable, MathWithoutDollars, UnbalancedCodeDelimiters, ImageSpacesAroundUrls, ImageWidget];
 
 /**
  * TreeTransformer is a class for traversing and transforming trees.  Create a
@@ -1271,12 +1362,16 @@ var AllRules = [AbsoluteUrl, BlockquotedMath, BlockquotedWidget, DoubleSpacingAf
 
 // TreeNode is the type of a node in a parse tree. The only real requirement is
 // that every node has a string-valued `type` property
+
 // TraversalCallback is the type of the callback function passed to the
 // traverse() method. It is invoked with node, state, and content arguments
 // and is expected to return nothing.
+
 // This is the TreeTransformer class described in detail at the
 // top of this file.
 class TreeTransformer {
+  root;
+
   // To create a tree transformer, just pass the root node of the tree
   constructor(root) {
     this.root = root;
@@ -1424,6 +1519,7 @@ class TreeTransformer {
  **/
 class TraversalState {
   // The root node of the tree being traversed
+  root;
 
   // These are internal state properties. Use the accessor methods defined
   // below instead of using these properties directly. Note that the
@@ -1431,6 +1527,11 @@ class TraversalState {
   // elements, depending on whether we just recursed on an array or on a
   // node. This is hard for TypeScript to deal with, so you'll see a number of
   // type casts through the any type when working with these two properties.
+  _currentNode;
+  _containers;
+  _indexes;
+  _ancestors;
+
   // The constructor just stores the root node and creates empty stacks.
   constructor(root) {
     this.root = root;
@@ -1558,7 +1659,7 @@ class TraversalState {
   replace() {
     const parent = this._containers.top();
     if (!parent) {
-      throw new perseusError.PerseusError("Can't replace the root of the tree", perseusError.Errors.Internal);
+      throw new perseusCore.PerseusError("Can't replace the root of the tree", perseusCore.Errors.Internal);
     }
 
     // The top of the container stack is either an array or an object
@@ -1611,7 +1712,7 @@ class TraversalState {
    */
   goToPreviousSibling() {
     if (!this.hasPreviousSibling()) {
-      throw new perseusError.PerseusError("goToPreviousSibling(): node has no previous sibling", perseusError.Errors.Internal);
+      throw new perseusCore.PerseusError("goToPreviousSibling(): node has no previous sibling", perseusCore.Errors.Internal);
     }
     this._currentNode = this.previousSibling();
     // Since we know that we have a previous sibling, we know that
@@ -1641,7 +1742,7 @@ class TraversalState {
    */
   goToParent() {
     if (!this.hasParent()) {
-      throw new perseusError.PerseusError("goToParent(): node has no ancestor", perseusError.Errors.NotAllowed);
+      throw new perseusCore.PerseusError("goToParent(): node has no ancestor", perseusCore.Errors.NotAllowed);
     }
     this._currentNode = this._ancestors.pop();
 
@@ -1688,6 +1789,7 @@ class TraversalState {
  * the TraversalState class simpler in a number of places.
  */
 class Stack {
+  stack;
   constructor(array) {
     this.stack = array ? array.slice(0) : [];
   }
@@ -1745,10 +1847,51 @@ class Stack {
   }
 }
 
+/**
+ * Adds the given perseus library version information to the __perseus_debug__
+ * object and ensures that the object is attached to `globalThis` (`window` in
+ * browser environments).
+ *
+ * This allows each library to provide runtime version information to assist in
+ * debugging in production environments.
+ */
+const addLibraryVersionToPerseusDebug = (libraryName, libraryVersion) => {
+  // If the library version is the default value, then we don't want to
+  // prefix it with a "v" to indicate that it is a version number.
+  let prefix = "v";
+  if (libraryVersion === "__lib_version__") {
+    prefix = "";
+  }
+  const formattedVersion = `${prefix}${libraryVersion}`;
+  if (typeof globalThis !== "undefined") {
+    globalThis.__perseus_debug__ = globalThis.__perseus_debug__ ?? {};
+    const existingVersionEntry = globalThis.__perseus_debug__[libraryName];
+    if (existingVersionEntry) {
+      // If we already have an entry and it doesn't match the registered
+      // version, we morph the entry into an array and log a warning.
+      if (existingVersionEntry !== formattedVersion) {
+        // Existing entry might be an array already (oops, at least 2
+        // versions of the library already loaded!).
+        const allVersions = Array.isArray(existingVersionEntry) ? existingVersionEntry : [existingVersionEntry];
+        allVersions.push(formattedVersion);
+        globalThis.__perseus_debug__[libraryName] = allVersions;
+
+        // eslint-disable-next-line no-console
+        console.warn(`Multiple versions of ${libraryName} loaded on this page: ${allVersions.sort().join(", ")}`);
+      }
+    } else {
+      globalThis.__perseus_debug__[libraryName] = formattedVersion;
+    }
+  } else {
+    // eslint-disable-next-line no-console
+    console.warn(`globalThis not found found (${formattedVersion})`);
+  }
+};
+
 // This file is processed by a Rollup plugin (replace) to inject the production
 const libName = "@khanacademy/perseus-linter";
-const libVersion = "0.3.9";
-perseusCore.addLibraryVersionToPerseusDebug(libName, libVersion);
+const libVersion = "1.2.18";
+addLibraryVersionToPerseusDebug(libName, libVersion);
 
 // Define the shape of the linter context object that is passed through the
 const linterContextProps = PropTypes__default["default"].shape({