@doenet/doenetml 0.6.0-alpha1

package/src/Core/components/Group.js

@@ -0,0 +1,7 @@
+import Template from "./Template";
+
+export default class Group extends Template {
+  static componentType = "group";
+
+  static renderedDefault = true;
+}

package/src/Core/components/HasSameFactoring.js

@@ -0,0 +1,407 @@
+import checkEquality from "../utils/checkEquality";
+import BooleanComponent from "./Boolean";
+import me from "math-expressions";
+
+export default class HasSameFactoring extends BooleanComponent {
+  static componentType = "hasSameFactoring";
+  static rendererType = "boolean";
+
+  static createAttributesObject() {
+    let attributes = super.createAttributesObject();
+
+    attributes.variable = {
+      createComponentOfType: "_variableName",
+      createStateVariable: "variable",
+      defaultValue: me.fromAst("x"),
+    };
+
+    attributes.restrictDivision = {
+      createComponentOfType: "boolean",
+      createStateVariable: "restrictDivision",
+      defaultValue: false,
+    };
+
+    // Note: monomialFactorMustMatch implies restrictDivision
+    attributes.monomialFactorMustMatch = {
+      createComponentOfType: "boolean",
+      createStateVariable: "monomialFactorMustMatch",
+      defaultValue: false,
+    };
+
+    // Note: allowOnlySignDifferences implies monomialFactorMustMatch and restrictDivision
+    attributes.allowOnlySignDifferences = {
+      createComponentOfType: "boolean",
+      createStateVariable: "allowOnlySignDifferences",
+      defaultValue: false,
+    };
+
+    return attributes;
+  }
+
+  static returnChildGroups() {
+    return [
+      {
+        group: "maths",
+        componentTypes: ["math"],
+      },
+    ];
+  }
+
+  static returnStateVariableDefinitions() {
+    let stateVariableDefinitions = super.returnStateVariableDefinitions();
+
+    delete stateVariableDefinitions.parsedExpression;
+    delete stateVariableDefinitions.mathChildrenByCode;
+
+    stateVariableDefinitions.value = {
+      public: true,
+      shadowingInstructions: {
+        createComponentOfType: "boolean",
+      },
+      forRenderer: true,
+      returnDependencies: () => ({
+        mathChildren: {
+          dependencyType: "child",
+          childGroups: ["maths"],
+          variableNames: ["value"],
+        },
+        allowedErrorInNumbers: {
+          dependencyType: "stateVariable",
+          variableName: "allowedErrorInNumbers",
+        },
+        includeErrorInNumberExponents: {
+          dependencyType: "stateVariable",
+          variableName: "includeErrorInNumberExponents",
+        },
+        allowedErrorIsAbsolute: {
+          dependencyType: "stateVariable",
+          variableName: "allowedErrorIsAbsolute",
+        },
+        numSignErrorsMatched: {
+          dependencyType: "stateVariable",
+          variableName: "numSignErrorsMatched",
+        },
+        variable: {
+          dependencyType: "stateVariable",
+          variableName: "variable",
+        },
+        restrictDivision: {
+          dependencyType: "stateVariable",
+          variableName: "restrictDivision",
+        },
+        monomialFactorMustMatch: {
+          dependencyType: "stateVariable",
+          variableName: "monomialFactorMustMatch",
+        },
+        allowOnlySignDifferences: {
+          dependencyType: "stateVariable",
+          variableName: "allowOnlySignDifferences",
+        },
+      }),
+      definition: function ({ dependencyValues }) {
+        if (dependencyValues.mathChildren.length !== 2) {
+          return { setValue: { value: false } };
+        }
+
+        let expr1 = dependencyValues.mathChildren[0].stateValues.value;
+        let expr2 = dependencyValues.mathChildren[1].stateValues.value;
+
+        let result = checkEquality({
+          object1: expr1,
+          object2: expr2,
+          isUnordered: false,
+          partialMatches: false,
+          symbolicEquality: false,
+          allowedErrorInNumbers: dependencyValues.allowedErrorInNumbers,
+          includeErrorInNumberExponents:
+            dependencyValues.includeErrorInNumberExponents,
+          allowedErrorIsAbsolute: dependencyValues.allowedErrorIsAbsolute,
+          numSignErrorsMatched: dependencyValues.numSignErrorsMatched,
+        });
+
+        if (result.fraction_equal !== 1) {
+          return { setValue: { value: false } };
+        }
+
+        if (Array.isArray(expr1.tree) && expr1.tree[0] === "-") {
+          expr1 = me.fromAst(expr1.tree[1]);
+        }
+        if (Array.isArray(expr2.tree) && expr2.tree[0] === "-") {
+          expr2 = me.fromAst(expr2.tree[1]);
+        }
+
+        if (
+          !dependencyValues.restrictDivision &&
+          !dependencyValues.monomialFactorMustMatch &&
+          !dependencyValues.allowOnlySignDifferences
+        ) {
+          // if have a ratio where denominator is a constant
+          // ignore denominator
+          if (
+            Array.isArray(expr1.tree) &&
+            expr1.tree[0] === "/" &&
+            me.fromAst(expr1.tree[2]).variables().length === 0
+          ) {
+            expr1 = me.fromAst(expr1.tree[1]);
+            if (Array.isArray(expr1.tree) && expr1.tree[0] === "-") {
+              expr1 = me.fromAst(expr1.tree[1]);
+            }
+          }
+          if (
+            Array.isArray(expr2.tree) &&
+            expr2.tree[0] === "/" &&
+            me.fromAst(expr2.tree[2]).variables().length === 0
+          ) {
+            expr2 = me.fromAst(expr2.tree[1]);
+            if (Array.isArray(expr2.tree) && expr2.tree[0] === "-") {
+              expr2 = me.fromAst(expr2.tree[1]);
+            }
+          }
+        }
+
+        expr1 = me.fromAst(expandPositiveIntegerPowers(expr1.tree));
+        expr2 = me.fromAst(expandPositiveIntegerPowers(expr2.tree));
+
+        if (!(Array.isArray(expr1.tree) && expr1.tree[0] === "*")) {
+          if (!(Array.isArray(expr2.tree) && expr2.tree[0] === "*")) {
+            // neither expression is a product, so they have the same factoring
+            return { setValue: { value: true } };
+          } else {
+            return { setValue: { value: false } };
+          }
+        } else if (!(Array.isArray(expr2.tree) && expr2.tree[0] === "*")) {
+          return { setValue: { value: false } };
+        }
+
+        // both expressions are products and are mathematically equivalent
+
+        if (
+          dependencyValues.monomialFactorMustMatch ||
+          dependencyValues.allowOnlySignDifferences
+        ) {
+          let monomial1 = findMonomialFromFactors(expr1.tree.slice(1));
+          let monomial2 = findMonomialFromFactors(expr2.tree.slice(1));
+          if (!monomial1.equals(monomial2)) {
+            // also OK if monomials are opposites
+            let monomial2Opposite = me.fromAst(["-", monomial2.tree]);
+            if (!monomial1.equals(monomial2Opposite)) {
+              return { setValue: { value: false } };
+            }
+          }
+        }
+
+        if (dependencyValues.allowOnlySignDifferences) {
+          let expr1Normalized = normalizeFactorSigns(expr1);
+          let expr2Normalized = normalizeFactorSigns(expr2);
+          return {
+            setValue: {
+              value: expr1Normalized.equalsViaSyntax(expr2Normalized, {
+                allowed_error_in_numbers:
+                  dependencyValues.allowedErrorInNumbers,
+                include_error_in_number_exponents:
+                  dependencyValues.includeErrorInNumberExponents,
+                allowed_error_is_absolute:
+                  dependencyValues.allowedErrorIsAbsolute,
+              }),
+            },
+          };
+        }
+
+        let nonConstantFactors1 = expr1.tree
+          .slice(1)
+          .filter((x) => me.fromAst(x).variables().length > 0);
+        let nonConstantFactors2 = expr2.tree
+          .slice(1)
+          .filter((x) => me.fromAst(x).variables().length > 0);
+
+        if (nonConstantFactors1.length !== nonConstantFactors2.length) {
+          return { setValue: { value: false } };
+        }
+
+        let numQuadraticFactors1 = 0,
+          numLinearFactors1 = 0;
+        let numQuadraticFactors2 = 0,
+          numLinearFactors2 = 0;
+
+        let v = dependencyValues.variable.subscripts_to_strings().tree;
+
+        for (let factor of nonConstantFactors1) {
+          let deriv2 = me
+            .fromAst(factor)
+            .subscripts_to_strings()
+            .derivative(v)
+            .derivative(v)
+            .simplify();
+          if (deriv2.tree === 0) {
+            numLinearFactors1++;
+          } else if (deriv2.variables().length === 0) {
+            numQuadraticFactors1++;
+          } else {
+            return { setValue: { value: false } };
+          }
+        }
+
+        for (let factor of nonConstantFactors2) {
+          let deriv2 = me
+            .fromAst(factor)
+            .subscripts_to_strings()
+            .derivative(v)
+            .derivative(v)
+            .simplify();
+          if (deriv2.tree === 0) {
+            numLinearFactors2++;
+          } else if (deriv2.variables().length === 0) {
+            numQuadraticFactors2++;
+          } else {
+            return { setValue: { value: false } };
+          }
+        }
+
+        let value =
+          numLinearFactors1 === numLinearFactors2 &&
+          numQuadraticFactors1 === numQuadraticFactors2;
+
+        return {
+          setValue: {
+            value,
+          },
+        };
+      },
+    };
+
+    return stateVariableDefinitions;
+  }
+}
+
+function expandPositiveIntegerPowers(tree) {
+  if (!Array.isArray(tree)) {
+    return tree;
+  }
+
+  if (tree[0] === "^") {
+    let base = tree[1];
+    let exponent = tree[2];
+    if (Number.isInteger(exponent) && exponent > 0) {
+      tree = ["*", ...Array(exponent).fill(base)];
+    }
+  }
+
+  if (tree[0] === "*") {
+    let oldTree = tree;
+    tree = ["*"];
+    for (let factor of oldTree.slice(1)) {
+      if (Array.isArray(factor) && factor[0] === "^") {
+        let base = factor[1];
+        let exponent = factor[2];
+        if (Number.isInteger(exponent) && exponent > 0) {
+          tree.push(...Array(exponent).fill(base));
+        } else {
+          tree.push(factor);
+        }
+      } else {
+        tree.push(factor);
+      }
+    }
+  }
+
+  return tree;
+}
+
+function findMonomialFromFactors(factors) {
+  let monomialFactors = [];
+
+  let inMonomial = false;
+
+  for (let factor of factors) {
+    if (
+      typeof factor === "string" ||
+      me.fromAst(factor).variables().length === 0
+    ) {
+      if (!inMonomial) {
+        if (monomialFactors.length > 0) {
+          // found a second monomial
+          return me.fromAst("\uff3f");
+        } else {
+          inMonomial = true;
+        }
+      }
+      monomialFactors.push(factor);
+    } else {
+      inMonomial = false;
+    }
+  }
+
+  let monomialTree;
+
+  if (monomialFactors.length === 0) {
+    monomialTree = 1;
+  } else if (monomialFactors.length === 1) {
+    monomialTree = monomialFactors[0];
+  } else {
+    monomialTree = ["*", ...monomialFactors];
+  }
+
+  return me.fromAst(monomialTree);
+}
+
+function normalizeFactorSigns(expr) {
+  let exprTree = expr.simplify().tree;
+
+  if (exprTree[0] === "-") {
+    exprTree = exprTree[1];
+  }
+
+  if (exprTree[0] !== "*") {
+    return me.fromAst(exprTree).simplify();
+  }
+
+  let newTree = ["*"];
+
+  for (let factor of exprTree.slice(1)) {
+    if (typeof factor === "number") {
+      if (factor < 0) {
+        newTree.push(-factor);
+      } else {
+        newTree.push(factor);
+      }
+    } else if (!Array.isArray(factor)) {
+      newTree.push(factor);
+    } else if (factor[0] === "-") {
+      newTree.push(factor[1]);
+    } else if (factor[0] === "+") {
+      let firstTermHasNeg = false;
+      let term = factor[1];
+      if (typeof term === "number") {
+        if (term < 0) {
+          firstTermHasNeg = true;
+        }
+      } else if (Array.isArray(term)) {
+        if (term[0] === "-") {
+          firstTermHasNeg = true;
+        } else if (term[0] === "*") {
+          let firstFactorInTerm = term[1];
+          if (typeof firstFactorInTerm === "number") {
+            if (firstFactorInTerm < 0) {
+              firstTermHasNeg = true;
+            }
+          } else if (
+            Array.isArray(firstFactorInTerm) &&
+            firstFactorInTerm[0] === "-"
+          ) {
+            firstTermHasNeg = true;
+          }
+        }
+      }
+
+      if (firstTermHasNeg) {
+        newTree.push(me.fromAst(["-", factor]).simplify().tree);
+      } else {
+        newTree.push(factor);
+      }
+    } else {
+      newTree.push(factor);
+    }
+  }
+
+  return me.fromAst(newTree).simplify();
+}

package/src/Core/components/Hint.js

@@ -0,0 +1,241 @@
+import BlockComponent from "./abstract/BlockComponent";
+
+export default class Hint extends BlockComponent {
+  constructor(args) {
+    super(args);
+
+    Object.assign(this.actions, {
+      revealHint: this.revealHint.bind(this),
+      closeHint: this.closeHint.bind(this),
+      recordVisibilityChange: this.recordVisibilityChange.bind(this),
+    });
+  }
+  static componentType = "hint";
+  static renderChildren = true;
+
+  static includeBlankStringChildren = true;
+
+  static returnChildGroups() {
+    return [
+      {
+        group: "titles",
+        componentTypes: ["title"],
+      },
+      {
+        group: "anything",
+        componentTypes: ["_base"],
+      },
+    ];
+  }
+
+  static returnStateVariableDefinitions() {
+    let stateVariableDefinitions = super.returnStateVariableDefinitions();
+
+    stateVariableDefinitions.showHints = {
+      forRenderer: true,
+      returnDependencies: () => ({
+        hide: {
+          dependencyType: "stateVariable",
+          variableName: "hide",
+        },
+        showHintsFlag: {
+          dependencyType: "flag",
+          flagName: "showHints",
+        },
+      }),
+      definition({ dependencyValues }) {
+        return {
+          setValue: {
+            showHints: dependencyValues.showHintsFlag && !dependencyValues.hide,
+          },
+        };
+      },
+    };
+
+    stateVariableDefinitions.open = {
+      public: true,
+      shadowingInstructions: {
+        createComponentOfType: "boolean",
+      },
+      forRenderer: true,
+      defaultValue: false,
+      hasEssential: true,
+      doNotShadowEssential: true,
+      returnDependencies: () => ({}),
+      definition() {
+        return {
+          useEssentialOrDefaultValue: {
+            open: true,
+          },
+        };
+      },
+      inverseDefinition({ desiredStateVariableValues }) {
+        return {
+          success: true,
+          instructions: [
+            {
+              setEssentialValue: "open",
+              value: desiredStateVariableValues.open,
+            },
+          ],
+        };
+      },
+    };
+
+    stateVariableDefinitions.titleChildName = {
+      forRenderer: true,
+      returnDependencies: () => ({
+        titleChild: {
+          dependencyType: "child",
+          childGroups: ["titles"],
+        },
+      }),
+      definition({ dependencyValues }) {
+        let titleChildName = null;
+        if (dependencyValues.titleChild.length > 0) {
+          titleChildName =
+            dependencyValues.titleChild[dependencyValues.titleChild.length - 1]
+              .componentName;
+        }
+        return {
+          setValue: { titleChildName },
+        };
+      },
+    };
+
+    stateVariableDefinitions.childIndicesToRender = {
+      returnDependencies: () => ({
+        titleChildren: {
+          dependencyType: "child",
+          childGroups: ["titles"],
+        },
+        allChildren: {
+          dependencyType: "child",
+          childGroups: ["anything", "titles"],
+        },
+        titleChildName: {
+          dependencyType: "stateVariable",
+          variableName: "titleChildName",
+        },
+      }),
+      definition({ dependencyValues }) {
+        let childIndicesToRender = [];
+
+        let allTitleChildNames = dependencyValues.titleChildren.map(
+          (x) => x.componentName,
+        );
+
+        for (let [ind, child] of dependencyValues.allChildren.entries()) {
+          if (
+            typeof child !== "object" ||
+            !allTitleChildNames.includes(child.componentName) ||
+            child.componentName === dependencyValues.titleChildName
+          ) {
+            childIndicesToRender.push(ind);
+          }
+        }
+
+        return { setValue: { childIndicesToRender } };
+      },
+    };
+
+    stateVariableDefinitions.title = {
+      public: true,
+      shadowingInstructions: {
+        createComponentOfType: "text",
+      },
+      forRenderer: true,
+      returnDependencies: () => ({
+        titleChild: {
+          dependencyType: "child",
+          childGroups: ["titles"],
+          variableNames: ["text"],
+        },
+      }),
+      definition({ dependencyValues }) {
+        if (dependencyValues.titleChild.length === 0) {
+          return { setValue: { title: "Hint" } };
+        } else {
+          return {
+            setValue: {
+              title:
+                dependencyValues.titleChild[
+                  dependencyValues.titleChild.length - 1
+                ].stateValues.text,
+            },
+          };
+        }
+      },
+    };
+
+    return stateVariableDefinitions;
+  }
+
+  async revealHint({
+    actionId,
+    sourceInformation = {},
+    skipRendererUpdate = false,
+  }) {
+    return await this.coreFunctions.performUpdate({
+      updateInstructions: [
+        {
+          updateType: "updateValue",
+          componentName: this.componentName,
+          stateVariable: "open",
+          value: true,
+        },
+      ],
+      overrideReadOnly: true,
+      actionId,
+      sourceInformation,
+      skipRendererUpdate,
+      event: {
+        verb: "viewed",
+        object: {
+          componentName: this.componentName,
+          componentType: this.componentType,
+        },
+      },
+    });
+  }
+
+  async closeHint({
+    actionId,
+    sourceInformation = {},
+    skipRendererUpdate = false,
+  }) {
+    return await this.coreFunctions.performUpdate({
+      updateInstructions: [
+        {
+          updateType: "updateValue",
+          componentName: this.componentName,
+          stateVariable: "open",
+          value: false,
+        },
+      ],
+      overrideReadOnly: true,
+      actionId,
+      sourceInformation,
+      skipRendererUpdate,
+      event: {
+        verb: "closed",
+        object: {
+          componentName: this.componentName,
+          componentType: this.componentType,
+        },
+      },
+    });
+  }
+
+  recordVisibilityChange({ isVisible, actionId }) {
+    this.coreFunctions.requestRecordEvent({
+      verb: "visibilityChanged",
+      object: {
+        componentName: this.componentName,
+        componentType: this.componentType,
+      },
+      result: { isVisible },
+    });
+    this.coreFunctions.resolveAction({ actionId });
+  }
+}