@doenet/doenetml 0.6.0-alpha1

package/src/Core/components/Ref.js

@@ -0,0 +1,350 @@
+import InlineComponent from "./abstract/InlineComponent";
+
+export default class Ref extends InlineComponent {
+  constructor(args) {
+    super(args);
+
+    Object.assign(this.actions, {
+      navigateToTarget: this.navigateToTarget.bind(this),
+    });
+  }
+  static componentType = "ref";
+  static renderChildren = true;
+
+  static acceptTarget = true;
+
+  static createAttributesObject() {
+    let attributes = super.createAttributesObject();
+    attributes.textType = {
+      createComponentOfType: "text",
+      createStateVariable: "textType",
+      defaultValue: "type-global",
+      public: true,
+    };
+    attributes.uri = {
+      createPrimitiveOfType: "string",
+      createStateVariable: "uri",
+      defaultValue: null,
+      public: true,
+      forRenderer: true,
+    };
+    attributes.page = {
+      createPrimitiveOfType: "integer",
+      createStateVariable: "page",
+      defaultValue: null,
+      public: true,
+      forRenderer: true,
+    };
+    attributes.createButton = {
+      createComponentOfType: "boolean",
+      createStateVariable: "createButton",
+      defaultValue: false,
+      forRenderer: true,
+    };
+    return attributes;
+  }
+
+  static returnChildGroups() {
+    return [
+      {
+        group: "anything",
+        componentTypes: ["_base"],
+      },
+    ];
+  }
+
+  static returnStateVariableDefinitions() {
+    let stateVariableDefinitions = super.returnStateVariableDefinitions();
+
+    stateVariableDefinitions.targetComponent = {
+      returnDependencies: () => ({
+        targetComponent: {
+          dependencyType: "targetComponent",
+        },
+      }),
+      definition: function ({ dependencyValues }) {
+        return {
+          setValue: {
+            targetComponent: dependencyValues.targetComponent,
+          },
+        };
+      },
+    };
+
+    stateVariableDefinitions.targetInactive = {
+      stateVariablesDeterminingDependencies: ["targetComponent"],
+      returnDependencies({ stateValues }) {
+        if (stateValues.targetComponent) {
+          return {
+            targetIsInactiveCompositeReplacement: {
+              dependencyType: "stateVariable",
+              componentName: stateValues.targetComponent.componentName,
+              variableName: "isInactiveCompositeReplacement",
+            },
+          };
+        } else {
+          return {};
+        }
+      },
+      definition: function ({ dependencyValues }) {
+        return {
+          setValue: {
+            targetInactive: Boolean(
+              dependencyValues.targetIsInactiveCompositeReplacement,
+            ),
+          },
+        };
+      },
+    };
+
+    stateVariableDefinitions.targetName = {
+      forRenderer: true,
+      returnDependencies: () => ({
+        targetComponent: {
+          dependencyType: "stateVariable",
+          variableName: "targetComponent",
+        },
+        uri: {
+          dependencyType: "stateVariable",
+          variableName: "uri",
+        },
+        page: {
+          dependencyType: "stateVariable",
+          variableName: "page",
+        },
+        targetInactive: {
+          dependencyType: "stateVariable",
+          variableName: "targetInactive",
+        },
+        targetAttribute: {
+          dependencyType: "doenetAttribute",
+          attributeName: "target",
+        },
+      }),
+      definition: function ({ dependencyValues }) {
+        if (dependencyValues.uri || dependencyValues.page) {
+          if (dependencyValues.targetAttribute) {
+            let targetName = dependencyValues.targetAttribute;
+            if (targetName[0] !== "/") {
+              targetName = "/" + targetName;
+            }
+            return { setValue: { targetName } };
+          } else {
+            return { setValue: { targetName: "" } };
+          }
+        } else if (
+          dependencyValues.targetComponent === null ||
+          dependencyValues.targetInactive
+        ) {
+          return { setValue: { targetName: "" } };
+        } else {
+          return {
+            setValue: {
+              targetName: dependencyValues.targetComponent.componentName,
+            },
+          };
+        }
+      },
+    };
+
+    stateVariableDefinitions.cid = {
+      forRenderer: true,
+      additionalStateVariablesDefined: [
+        {
+          variableName: "doenetId",
+          forRenderer: true,
+        },
+        {
+          variableName: "variantIndex",
+          forRenderer: true,
+        },
+        {
+          variableName: "edit",
+          forRenderer: true,
+        },
+        {
+          variableName: "draft",
+          forRenderer: true,
+        },
+        {
+          variableName: "hash",
+          forRenderer: true,
+        },
+      ],
+      returnDependencies: () => ({
+        uri: {
+          dependencyType: "stateVariable",
+          variableName: "uri",
+        },
+      }),
+      definition: function ({ dependencyValues }) {
+        if (
+          !dependencyValues.uri ||
+          dependencyValues.uri.substring(0, 7).toLowerCase() !== "doenet:"
+        ) {
+          return {
+            setValue: {
+              cid: null,
+              doenetId: null,
+              variantIndex: null,
+              edit: null,
+              draft: null,
+              hash: null,
+            },
+          };
+        }
+
+        let cid = null,
+          doenetId = null,
+          variantIndex = null;
+        let draft = null,
+          edit = null,
+          hash = null;
+
+        let result = dependencyValues.uri.match(/[:&]cid=([^&^#]+)/i);
+        if (result) {
+          cid = result[1];
+        }
+        result = dependencyValues.uri.match(/[:&]doenetid=([^&^#]+)/i);
+        if (result) {
+          doenetId = result[1];
+        }
+        result = dependencyValues.uri.match(/[:&]variant=([^&^#]+)/i);
+        if (result) {
+          variantIndex = Number(result[1]);
+          if (!Number.isInteger(variantIndex) && variantIndex >= 1) {
+            variantIndex = 1;
+          }
+        }
+        result = dependencyValues.uri.match(/[:&]edit=([^&^#]+)/i);
+        if (result) {
+          if (result[1].toLowerCase() === "true") {
+            edit = true;
+          } else {
+            edit = false;
+          }
+        }
+        result = dependencyValues.uri.match(/[:&]draft=([^&^#]+)/i);
+        if (result) {
+          if (result[1].toLowerCase() === "true") {
+            draft = true;
+          } else {
+            draft = false;
+          }
+        }
+        result = dependencyValues.uri.match(/(#.+)/i);
+        if (result) {
+          hash = result[1];
+        }
+
+        // console.log('url parameter results', { cid, doenetId, variantIndex, edit, draft, hash })
+
+        return { setValue: { cid, doenetId, variantIndex, edit, draft, hash } };
+      },
+    };
+
+    stateVariableDefinitions.linkText = {
+      public: true,
+      shadowingInstructions: {
+        createComponentOfType: "text",
+      },
+      forRenderer: true,
+      stateVariablesDeterminingDependencies: ["targetName"],
+      returnDependencies({ stateValues }) {
+        let dependencies = {
+          allChildren: {
+            dependencyType: "child",
+            childGroups: ["anything"],
+            variableNames: ["text"],
+            variablesOptional: true,
+          },
+          uri: {
+            dependencyType: "stateVariable",
+            variableName: "uri",
+          },
+          targetInactive: {
+            dependencyType: "stateVariable",
+            variableName: "targetInactive",
+          },
+        };
+
+        if (stateValues.targetName) {
+          dependencies.equationTag = {
+            dependencyType: "stateVariable",
+            componentName: stateValues.targetName,
+            variableName: "equationTag",
+            variablesOptional: true,
+          };
+          dependencies.title = {
+            dependencyType: "stateVariable",
+            componentName: stateValues.targetName,
+            variableName: "title",
+            variablesOptional: true,
+          };
+        }
+
+        return dependencies;
+      },
+      definition: function ({ dependencyValues }) {
+        let linkText = "";
+        if (dependencyValues.allChildren.length === 0) {
+          if (dependencyValues.uri !== null) {
+            linkText = dependencyValues.uri;
+          } else if (!dependencyValues.targetInactive) {
+            if (dependencyValues.title !== null) {
+              linkText = dependencyValues.title;
+            } else if (dependencyValues.equationTag !== null) {
+              linkText = "(" + dependencyValues.equationTag + ")";
+            }
+          }
+        } else {
+          for (let child of dependencyValues.allChildren) {
+            if (typeof child !== "object") {
+              linkText += child.toString();
+            } else if (typeof child.stateValues.text === "string") {
+              linkText += child.stateValues.text;
+            }
+          }
+        }
+
+        if (!linkText) {
+          linkText = "???";
+        }
+        return { setValue: { linkText } };
+      },
+    };
+
+    return stateVariableDefinitions;
+  }
+
+  async navigateToTarget({ actionId }) {
+    if (await this.stateValues.disabled) {
+      this.coreFunctions.resolveAction({ actionId });
+    } else {
+      let cid = await this.stateValues.cid;
+      let doenetId = await this.stateValues.doenetId;
+      let variantIndex = await this.stateValues.variantIndex;
+      let edit = await this.stateValues.edit;
+      let hash = await this.stateValues.hash;
+      let page = await this.stateValues.page;
+      let uri = await this.stateValues.uri;
+      let targetName = await this.stateValues.targetName;
+
+      let effectiveName = this.componentOrAdaptedName;
+
+      this.coreFunctions.navigateToTarget({
+        cid,
+        doenetId,
+        variantIndex,
+        edit,
+        hash,
+        page,
+        uri,
+        targetName,
+        actionId,
+        componentName: this.componentName,
+        effectiveName,
+      });
+    }
+  }
+}

package/src/Core/components/RegionBetweenCurveXAxis.js

@@ -0,0 +1,124 @@
+import GraphicalComponent from "./abstract/GraphicalComponent";
+
+export default class RegionBetweenCurveXAxis extends GraphicalComponent {
+  static componentType = "regionBetweenCurveXAxis";
+
+  static createAttributesObject() {
+    let attributes = super.createAttributesObject();
+
+    attributes.boundaryValues = {
+      createComponentOfType: "numberList",
+      createStateVariable: "boundaryValues",
+      defaultValue: [0, 1],
+      forRenderer: true,
+      public: true,
+    };
+
+    attributes.function = {
+      createComponentOfType: "function",
+    };
+
+    return attributes;
+  }
+
+  static returnStateVariableDefinitions() {
+    let stateVariableDefinitions = super.returnStateVariableDefinitions();
+
+    stateVariableDefinitions.styleDescription = {
+      public: true,
+      shadowingInstructions: {
+        createComponentOfType: "text",
+      },
+      returnDependencies: () => ({
+        selectedStyle: {
+          dependencyType: "stateVariable",
+          variableName: "selectedStyle",
+        },
+        document: {
+          dependencyType: "ancestor",
+          componentType: "document",
+          variableNames: ["theme"],
+        },
+      }),
+      definition: function ({ dependencyValues }) {
+        let fillColorWord;
+        if (dependencyValues.document?.stateValues.theme === "dark") {
+          fillColorWord = dependencyValues.selectedStyle.fillColorWordDarkMode;
+        } else {
+          fillColorWord = dependencyValues.selectedStyle.fillColorWord;
+        }
+
+        return { setValue: { styleDescription: fillColorWord } };
+      },
+    };
+
+    stateVariableDefinitions.styleDescriptionWithNoun = {
+      public: true,
+      shadowingInstructions: {
+        createComponentOfType: "text",
+      },
+      returnDependencies: () => ({
+        styleDescription: {
+          dependencyType: "stateVariable",
+          variableName: "styleDescription",
+        },
+      }),
+      definition: function ({ dependencyValues }) {
+        let styleDescriptionWithNoun =
+          dependencyValues.styleDescription + " region";
+
+        return { setValue: { styleDescriptionWithNoun } };
+      },
+    };
+
+    stateVariableDefinitions.function = {
+      additionalStateVariablesDefined: [
+        {
+          variableName: "haveFunction",
+          forRenderer: true,
+        },
+        {
+          variableName: "fDefinition",
+          forRenderer: true,
+        },
+      ],
+      returnDependencies: () => ({
+        functionAttr: {
+          dependencyType: "attributeComponent",
+          attributeName: "function",
+          variableNames: [
+            "numericalfs",
+            "numInputs",
+            "numOutputs",
+            "fDefinition",
+          ],
+        },
+      }),
+      definition({ dependencyValues }) {
+        if (
+          dependencyValues.functionAttr === null ||
+          dependencyValues.functionAttr.stateValues.numInputs !== 1 ||
+          dependencyValues.functionAttr.stateValues.numOutputs !== 1
+        ) {
+          return {
+            setValue: {
+              function: () => NaN,
+              haveFunction: false,
+              fDefinition: {},
+            },
+          };
+        }
+
+        return {
+          setValue: {
+            function: dependencyValues.functionAttr.stateValues.numericalfs[0],
+            haveFunction: true,
+            fDefinition: dependencyValues.functionAttr.stateValues.fDefinition,
+          },
+        };
+      },
+    };
+
+    return stateVariableDefinitions;
+  }
+}

package/src/Core/components/RegionHalfPlane.js

@@ -0,0 +1,107 @@
+import GraphicalComponent from "./abstract/GraphicalComponent";
+
+export default class RegionHalfPlane extends GraphicalComponent {
+  static componentType = "regionHalfPlane";
+  static rendererType = undefined;
+
+  static createAttributesObject() {
+    let attributes = super.createAttributesObject();
+
+    attributes.horizontal = {
+      createComponentOfType: "boolean",
+      createStateVariable: "horizontal",
+      defaultValue: true,
+      public: true,
+    };
+
+    attributes.boundaryValue = {
+      createComponentOfType: "number",
+      createStateVariable: "boundaryValue",
+      defaultValue: 0,
+      public: true,
+    };
+
+    attributes.greaterThan = {
+      createComponentOfType: "boolean",
+      createStateVariable: "greaterThan",
+      defaultValue: true,
+      public: true,
+    };
+
+    return attributes;
+  }
+
+  static returnStateVariableDefinitions() {
+    let stateVariableDefinitions = super.returnStateVariableDefinitions();
+
+    stateVariableDefinitions.nearestPoint = {
+      returnDependencies: () => ({
+        horizontal: {
+          dependencyType: "stateVariable",
+          variableName: "horizontal",
+        },
+        boundaryValue: {
+          dependencyType: "stateVariable",
+          variableName: "boundaryValue",
+        },
+        greaterThan: {
+          dependencyType: "stateVariable",
+          variableName: "greaterThan",
+        },
+      }),
+      definition({ dependencyValues }) {
+        let value = dependencyValues.boundaryValue;
+
+        return {
+          setValue: {
+            nearestPoint: function ({ variables, scales }) {
+              if (!Number.isFinite(value)) {
+                return {};
+              }
+
+              if (dependencyValues.horizontal) {
+                if (dependencyValues.greaterThan) {
+                  if (variables.x1 < value) {
+                    let result = Object.assign({}, variables);
+                    result.x1 = value;
+                    return result;
+                  } else {
+                    return {};
+                  }
+                } else {
+                  if (variables.x1 > value) {
+                    let result = Object.assign({}, variables);
+                    result.x1 = value;
+                    return result;
+                  } else {
+                    return {};
+                  }
+                }
+              } else {
+                if (dependencyValues.greaterThan) {
+                  if (variables.x2 < value) {
+                    let result = Object.assign({}, variables);
+                    result.x2 = value;
+                    return result;
+                  } else {
+                    return {};
+                  }
+                } else {
+                  if (variables.x2 > value) {
+                    let result = Object.assign({}, variables);
+                    result.x2 = value;
+                    return result;
+                  } else {
+                    return {};
+                  }
+                }
+              }
+            },
+          },
+        };
+      },
+    };
+
+    return stateVariableDefinitions;
+  }
+}