@doenet/doenetml 0.6.0-alpha1

package/src/Core/components/AsList.js

@@ -0,0 +1,83 @@
+import InlineComponent from "./abstract/InlineComponent";
+
+export default class AsList extends InlineComponent {
+  static componentType = "asList";
+  static renderChildren = true;
+
+  static returnChildGroups() {
+    return [
+      {
+        group: "inline",
+        componentTypes: ["_inline"],
+      },
+    ];
+  }
+
+  static returnStateVariableDefinitions() {
+    let stateVariableDefinitions = super.returnStateVariableDefinitions();
+
+    stateVariableDefinitions.text = {
+      public: true,
+      shadowingInstructions: {
+        createComponentOfType: "text",
+      },
+      returnDependencies: () => ({
+        inlineChildren: {
+          dependencyType: "child",
+          childGroups: ["inline"],
+          variableNames: ["text"],
+          variablesOptional: true,
+        },
+      }),
+      definition: function ({ dependencyValues }) {
+        let textpieces = [];
+        for (let child of dependencyValues.inlineChildren) {
+          if (typeof child !== "object") {
+            textpieces.push(child.toString());
+          } else if (typeof child.stateValues.text === "string") {
+            textpieces.push(child.stateValues.text);
+          } else {
+            textpieces.push("");
+          }
+        }
+        let text = textpieces.join(", ");
+
+        return { setValue: { text } };
+      },
+    };
+
+    stateVariableDefinitions.latex = {
+      public: true,
+      shadowingInstructions: {
+        createComponentOfType: "latex",
+      },
+      returnDependencies: () => ({
+        inlineChildren: {
+          dependencyType: "child",
+          childGroups: ["inline"],
+          variableNames: ["text", "latex"],
+          variablesOptional: true,
+        },
+      }),
+      definition: function ({ dependencyValues }) {
+        let latexpieces = [];
+        for (let child of dependencyValues.inlineChildren) {
+          if (typeof child !== "object") {
+            latexpieces.push(child.toString());
+          } else if (typeof child.stateValues.latex === "string") {
+            latexpieces.push(child.stateValues.latex);
+          } else if (typeof child.stateValues.text === "string") {
+            latexpieces.push(child.stateValues.text);
+          } else {
+            latexpieces.push("");
+          }
+        }
+        let latex = latexpieces.join(", ");
+
+        return { setValue: { latex } };
+      },
+    };
+
+    return stateVariableDefinitions;
+  }
+}

package/src/Core/components/AttractTo.js

@@ -0,0 +1,245 @@
+import { findFiniteNumericalValue } from "../utils/math";
+import ConstraintComponent from "./abstract/ConstraintComponent";
+
+export default class AttractTo extends ConstraintComponent {
+  static componentType = "attractTo";
+
+  static createAttributesObject() {
+    let attributes = super.createAttributesObject();
+
+    attributes.relativeToGraphScales = {
+      createComponentOfType: "boolean",
+      createStateVariable: "relativeToGraphScales",
+      defaultValue: false,
+      public: true,
+    };
+
+    attributes.threshold = {
+      createComponentOfType: "number",
+    };
+
+    return attributes;
+  }
+
+  static returnChildGroups() {
+    return [
+      {
+        group: "graphical",
+        componentTypes: ["_graphical"],
+      },
+    ];
+  }
+
+  static returnStateVariableDefinitions() {
+    let stateVariableDefinitions = super.returnStateVariableDefinitions();
+
+    stateVariableDefinitions.threshold = {
+      public: true,
+      shadowingInstructions: {
+        createComponentOfType: "number",
+      },
+      hasEssential: true,
+      returnDependencies: () => ({
+        thresholdAttr: {
+          dependencyType: "attributeComponent",
+          attributeName: "threshold",
+          variableNames: ["value"],
+        },
+        constraintsAncestor: {
+          dependencyType: "ancestor",
+          componentType: "constraints",
+          variableNames: ["graphXmin"],
+        },
+        relativeToGraphScales: {
+          dependencyType: "stateVariable",
+          variableName: "relativeToGraphScales",
+        },
+      }),
+      definition({ dependencyValues }) {
+        if (dependencyValues.thresholdAttr) {
+          return {
+            setValue: {
+              threshold: dependencyValues.thresholdAttr.stateValues.value,
+            },
+          };
+        } else {
+          return {
+            useEssentialOrDefaultValue: {
+              threshold: {
+                get defaultValue() {
+                  let useRelative =
+                    dependencyValues.relativeToGraphScales &&
+                    dependencyValues.constraintsAncestor !== null &&
+                    dependencyValues.constraintsAncestor.stateValues
+                      .graphXmin !== null;
+
+                  return useRelative ? 0.02 : 0.5;
+                },
+              },
+            },
+          };
+        }
+      },
+      inverseDefinition({ desiredStateVariableValues, dependencyValues }) {
+        if (dependencyValues.thresholdAttr) {
+          return {
+            success: true,
+            instructions: [
+              {
+                setDependency: "thresholdAttr",
+                desiredValue: desiredStateVariableValues.threshold,
+              },
+            ],
+          };
+        } else {
+          return {
+            success: true,
+            instructions: [
+              {
+                setEssentialValue: "threshold",
+                value: desiredStateVariableValues.threshold,
+              },
+            ],
+          };
+        }
+      },
+    };
+
+    stateVariableDefinitions.nearestPointFunctions = {
+      returnDependencies: () => ({
+        graphicalChildren: {
+          dependencyType: "child",
+          childGroups: ["graphical"],
+          variableNames: ["nearestPoint"],
+          variablesOptional: true,
+        },
+      }),
+      definition: function ({ dependencyValues }) {
+        let nearestPointFunctions = [];
+
+        for (let child of dependencyValues.graphicalChildren) {
+          if (!child.stateValues.nearestPoint) {
+            console.warn(
+              `cannot attract to ${child.componentName} as it doesn't have a nearestPoint state variable`,
+            );
+            continue;
+          }
+          nearestPointFunctions.push(child.stateValues.nearestPoint);
+        }
+
+        return { setValue: { nearestPointFunctions } };
+      },
+    };
+
+    stateVariableDefinitions.applyConstraint = {
+      returnDependencies() {
+        let dependencies = {
+          nearestPointFunctions: {
+            dependencyType: "stateVariable",
+            variableName: "nearestPointFunctions",
+          },
+          threshold: {
+            dependencyType: "stateVariable",
+            variableName: "threshold",
+          },
+          relativeToGraphScales: {
+            dependencyType: "stateVariable",
+            variableName: "relativeToGraphScales",
+          },
+          constraintsAncestor: {
+            dependencyType: "ancestor",
+            componentType: "constraints",
+            variableNames: ["scales"],
+          },
+        };
+
+        return dependencies;
+      },
+      definition({ dependencyValues }) {
+        let scales;
+
+        if (dependencyValues.relativeToGraphScales) {
+          scales = dependencyValues.constraintsAncestor?.stateValues.scales || [
+            1, 1, 1,
+          ];
+        } else {
+          scales = [1, 1, 1];
+        }
+
+        return {
+          setValue: {
+            applyConstraint: function (variables) {
+              let closestDistance2 = Infinity;
+              let closestPoint = {};
+
+              let numericalVariables = {};
+              for (let varName in variables) {
+                numericalVariables[varName] = findFiniteNumericalValue(
+                  variables[varName],
+                );
+              }
+
+              for (let nearestPointFunction of dependencyValues.nearestPointFunctions) {
+                let nearestPoint = nearestPointFunction({ variables, scales });
+
+                if (nearestPoint === undefined) {
+                  continue;
+                }
+
+                let constrainedVariables = {};
+                let distance2 = 0;
+
+                if (numericalVariables.x1 !== undefined) {
+                  if (nearestPoint.x1 === undefined) {
+                    continue;
+                  }
+                  constrainedVariables.x1 = nearestPoint.x1;
+                  distance2 += Math.pow(
+                    (numericalVariables.x1 - nearestPoint.x1) / scales[0],
+                    2,
+                  );
+                }
+                if (numericalVariables.x2 !== undefined) {
+                  if (nearestPoint.x2 === undefined) {
+                    continue;
+                  }
+                  constrainedVariables.x2 = nearestPoint.x2;
+                  distance2 += Math.pow(
+                    (numericalVariables.x2 - nearestPoint.x2) / scales[1],
+                    2,
+                  );
+                }
+                if (numericalVariables.x3 !== undefined) {
+                  if (nearestPoint.x3 === undefined) {
+                    continue;
+                  }
+                  constrainedVariables.x3 = nearestPoint.x3;
+                  distance2 += Math.pow(
+                    numericalVariables.x3 - nearestPoint.x3,
+                    2,
+                  );
+                }
+
+                if (distance2 < closestDistance2) {
+                  closestPoint = constrainedVariables;
+                  closestDistance2 = distance2;
+                }
+              }
+
+              if (
+                closestDistance2 >
+                dependencyValues.threshold * dependencyValues.threshold
+              ) {
+                return {};
+              }
+
+              return { constrained: true, variables: closestPoint };
+            },
+          },
+        };
+      },
+    };
+
+    return stateVariableDefinitions;
+  }
+}

package/src/Core/components/AttractToAngles.js

@@ -0,0 +1,262 @@
+import ConstraintComponent from "./abstract/ConstraintComponent";
+
+export default class AttractToAngles extends ConstraintComponent {
+  static componentType = "attractToAngles";
+
+  static createAttributesObject() {
+    let attributes = super.createAttributesObject();
+    attributes.threshold = {
+      createComponentOfType: "number",
+      createStateVariable: "threshold",
+      defaultValue: 0.3,
+      public: true,
+    };
+    return attributes;
+  }
+
+  static returnChildLogic(args) {
+    let childLogic = super.returnChildLogic(args);
+
+    let addAngles = function ({ activeChildrenMatched }) {
+      // add <angles> around children
+      let anglesChildren = [];
+      for (let child of activeChildrenMatched) {
+        anglesChildren.push({
+          createdComponent: true,
+          componentName: child.componentName,
+        });
+      }
+      return {
+        success: true,
+        newChildren: [{ componentType: "angles", children: anglesChildren }],
+      };
+    };
+
+    let AtLeastOneAngle = childLogic.newLeaf({
+      name: "AtLeastOneAngle",
+      componentType: "angle",
+      comparison: "atLeast",
+      number: 1,
+      isSugar: true,
+      replacementFunction: addAngles,
+    });
+
+    let AtLeastOneString = childLogic.newLeaf({
+      name: "AtLeastOneString",
+      componentType: "string",
+      comparison: "atLeast",
+      number: 1,
+    });
+
+    let AtLeastOneMath = childLogic.newLeaf({
+      name: "AtLeastOneMath",
+      componentType: "math",
+      comparison: "atLeast",
+      number: 1,
+    });
+
+    let StringsAndMaths = childLogic.newOperator({
+      name: "StringsAndMaths",
+      operator: "or",
+      propositions: [AtLeastOneString, AtLeastOneMath],
+      requireConsecutive: true,
+      isSugar: true,
+      replacementFunction: addAngles,
+    });
+
+    let AtMostOneAngles = childLogic.newLeaf({
+      name: "AtMostOneAngles",
+      componentType: "angles",
+      comparison: "atMost",
+      number: 1,
+    });
+
+    let Angles = childLogic.newOperator({
+      name: "Angles",
+      operator: "xor",
+      propositions: [AtLeastOneAngle, StringsAndMaths, AtMostOneAngles],
+      setAsBase: true,
+    });
+
+    let AtMostOnePoint = childLogic.newLeaf({
+      name: "AtMostOnePoint",
+      componentType: "point",
+      comparison: "atMost",
+      number: 1,
+    });
+
+    childLogic.newOperator({
+      name: "AnglesAndPoint",
+      operator: "and",
+      propositions: [Angles, AtMostOnePoint],
+      setAsBase: true,
+    });
+
+    return childLogic;
+  }
+
+  updateState(args = {}) {
+    super.updateState(args);
+
+    if (!this.childLogicSatisfied) {
+      this.unresolvedState.angles = true;
+      this.unresolvedState.offset = true;
+      return;
+    }
+
+    let trackChanges = this.currentTracker.trackChanges;
+    let childrenChanged = trackChanges.childrenChanged(this.componentName);
+
+    if (childrenChanged) {
+      let anglesInd = this.childLogic.returnMatches("AtMostOneAngles");
+
+      if (anglesInd.length === 1) {
+        this.state.anglesChild = this.activeChildren[anglesInd[0]];
+      } else {
+        delete this.state.anglesChild;
+        this.state.angles = [];
+        delete this.unresolvedState.angles;
+      }
+
+      let pointInd = this.childLogic.returnMatches("AtMostOnePoint");
+      if (pointInd.length === 1) {
+        this.state.pointChild = this.activeChildren[pointInd[0]];
+      } else {
+        delete this.state.pointChild;
+        this.state.offset = [0, 0, 0];
+        delete this.unresolvedState.offset;
+      }
+    }
+
+    if (this.state.anglesChild) {
+      if (this.state.anglesChild.unresolvedState.angles) {
+        this.unresolvedState.angles = true;
+        return;
+      }
+
+      if (
+        childrenChanged ||
+        trackChanges.getVariableChanges({
+          component: this.state.anglesChild,
+          variable: "angles",
+        })
+      ) {
+        delete this.unresolvedState.angles;
+        this.state.angles = this.state.anglesChild.state.angles;
+      }
+    }
+
+    if (this.state.pointChild) {
+      if (this.state.pointChild.unresolvedState.xs) {
+        this.unresolvedState.offset = true;
+        return;
+      }
+
+      if (
+        childrenChanged ||
+        trackChanges.getVariableChanges({
+          component: this.state.pointChild,
+          variable: "xs",
+        })
+      ) {
+        delete this.unresolvedState.offset;
+
+        this.state.offset = [];
+        for (let i = 0; i < this.state.pointChild.state.ndimensions; i++) {
+          let temp = this.state.pointChild.state.xs[i].evaluate_to_constant();
+          if (!Number.isFinite(temp)) {
+            this.state.offset = NaN;
+            break;
+          }
+          this.state.offset.push(temp);
+        }
+      }
+    }
+  }
+
+  applyTheConstraint({ x1, x2, x3, offset }) {
+    // use the convention of x1, x2, and x3 for variable names
+    // so that components can call constraints generically for n-dimensions
+
+    if (this.unresolvedState.angles || this.unresolvedState.offset) {
+      return {};
+    }
+
+    // only works in 2D
+    if (x1 === undefined || x2 === undefined || x3 !== undefined) {
+      return {};
+    }
+
+    // only works for numerical x1 and x2
+    x1 = this.findFiniteNumericalValue(x1);
+    x2 = this.findFiniteNumericalValue(x2);
+
+    if (!Number.isFinite(x1) || !Number.isFinite(x2)) {
+      return {};
+    }
+
+    if (offset === undefined) {
+      offset = this.state.offset;
+    }
+
+    // if didn't get a numerical value for one of the offset components
+    // return no constraint
+    if (Number.isNaN(offset)) {
+      return {};
+    }
+
+    let dx1 = x1 - offset[0];
+    let dx2 = x2 - offset[1];
+
+    let foundAngle = Math.atan2(dx2, dx1);
+
+    let closestDistance = Infinity;
+    let closestAngle;
+    let closestInd;
+
+    for (let [ind, angleComp] of this.state.angles.entries()) {
+      let angle = angleComp.state.angle.evaluate_to_constant();
+
+      if (!Number.isFinite(angle)) {
+        continue;
+      }
+
+      let distanceToAngle = Math.abs(
+        ((angle - foundAngle + Math.PI) % (2 * Math.PI)) - Math.PI,
+      );
+
+      if (distanceToAngle < closestDistance) {
+        closestAngle = angle;
+        closestInd = ind;
+        closestDistance = distanceToAngle;
+      }
+    }
+
+    if (closestAngle === undefined) {
+      return {};
+    }
+
+    let mag = Math.sqrt(dx1 * dx1 + dx2 * dx2);
+
+    let newX1 = offset[0] + mag * Math.cos(closestAngle);
+    let newX2 = offset[1] + mag * Math.sin(closestAngle);
+
+    let distanceAsPoints = Math.sqrt(
+      Math.pow(newX1 - x1, 2) + Math.pow(newX2 - x2, 2),
+    );
+    if (distanceAsPoints >= this.state.threshold) {
+      return {};
+    }
+
+    let result = {
+      variables: {
+        x1: newX1,
+        x2: newX2,
+      },
+      constraintIndices: [closestInd + 1],
+      constrained: true,
+    };
+
+    return result;
+  }
+}

package/src/Core/components/AttractToConstraint.js

@@ -0,0 +1,104 @@
+import ConstraintComponent from "./abstract/ConstraintComponent";
+import { findFiniteNumericalValue } from "../utils/math";
+import { applyConstraintFromComponentConstraints } from "../utils/constraints";
+
+export default class AttractToConstraint extends ConstraintComponent {
+  static componentType = "attractToConstraint";
+
+  static createAttributesObject() {
+    let attributes = super.createAttributesObject();
+    attributes.threshold = {
+      createComponentOfType: "number",
+      createStateVariable: "threshold",
+      defaultValue: 0.5,
+      public: true,
+    };
+    return attributes;
+  }
+
+  static returnChildGroups() {
+    return [
+      {
+        group: "constraints",
+        componentTypes: ["_constraint"],
+      },
+    ];
+  }
+
+  static returnStateVariableDefinitions() {
+    let stateVariableDefinitions = super.returnStateVariableDefinitions();
+
+    stateVariableDefinitions.applyConstraint = {
+      returnDependencies: () => ({
+        constraintChild: {
+          dependencyType: "child",
+          childGroups: ["constraints"],
+          variableNames: ["applyConstraint", "applyComponentConstraint"],
+          variablesOptional: true,
+        },
+        independentComponentConstraints: {
+          dependencyType: "stateVariable",
+          variableName: "independentComponentConstraints",
+        },
+        threshold: {
+          dependencyType: "stateVariable",
+          variableName: "threshold",
+        },
+      }),
+      definition: ({ dependencyValues }) => ({
+        setValue: {
+          applyConstraint: function (variables) {
+            let constraintResult;
+
+            let constraintChild = dependencyValues.constraintChild[0];
+
+            if (!constraintChild) {
+              return {};
+            }
+
+            if (constraintChild.stateValues.applyConstraint) {
+              constraintResult =
+                constraintChild.stateValues.applyConstraint(variables);
+            } else {
+              constraintResult = applyConstraintFromComponentConstraints(
+                variables,
+                constraintChild.stateValues.applyComponentConstraint,
+              );
+            }
+
+            let distance2 = 0;
+
+            for (let varname in constraintResult.variables) {
+              // since, for now, have a distance function only for numerical values,
+              // skip if don't have numerical values
+              let originalVar = findFiniteNumericalValue(variables[varname]);
+              let constrainedVar = findFiniteNumericalValue(
+                constraintResult.variables[varname],
+              );
+
+              if (
+                !Number.isFinite(originalVar) ||
+                !Number.isFinite(constrainedVar)
+              ) {
+                return {};
+              }
+
+              distance2 += Math.pow(originalVar - constrainedVar, 2);
+            }
+
+            if (
+              distance2 >
+              dependencyValues.threshold * dependencyValues.threshold
+            ) {
+              return {};
+            }
+
+            return constraintResult;
+          },
+        },
+      }),
+    };
+
+    return stateVariableDefinitions;
+  }
+}