@doenet/doenetml 0.6.0-alpha1

package/src/Core/components/Sort.js

@@ -0,0 +1,398 @@
+import CompositeComponent from "./abstract/CompositeComponent";
+import { postProcessCopy } from "../utils/copy";
+import me from "math-expressions";
+import { processAssignNames } from "../utils/serializedStateProcessing";
+
+export default class Sort extends CompositeComponent {
+  static componentType = "sort";
+
+  static stateVariableToEvaluateAfterReplacements = "readyToExpandWhenResolved";
+  static assignNamesToReplacements = true;
+
+  static createAttributesObject() {
+    let attributes = super.createAttributesObject();
+
+    attributes.assignNamesSkip = {
+      createPrimitiveOfType: "number",
+    };
+
+    attributes.sortVectorsBy = {
+      createComponentOfType: "text",
+      createStateVariable: "sortVectorsBy",
+      defaultValue: "displacement",
+      public: true,
+      toLowerCase: true,
+      validValues: ["displacement", "tail"],
+    };
+
+    attributes.sortByComponent = {
+      createComponentOfType: "integer",
+      createStateVariable: "sortByComponent",
+      defaultValue: "1",
+      public: true,
+    };
+
+    attributes.sortByProp = {
+      createPrimitiveOfType: "string",
+    };
+
+    return attributes;
+  }
+
+  static returnChildGroups() {
+    return [
+      {
+        group: "anything",
+        componentTypes: ["_base"],
+      },
+    ];
+  }
+
+  static returnStateVariableDefinitions() {
+    let stateVariableDefinitions = super.returnStateVariableDefinitions();
+
+    stateVariableDefinitions.propName = {
+      returnDependencies: () => ({
+        propName: {
+          dependencyType: "attributePrimitive",
+          attributeName: "sortByProp",
+        },
+      }),
+      definition: function ({ dependencyValues }) {
+        return { setValue: { propName: dependencyValues.propName } };
+      },
+    };
+
+    stateVariableDefinitions.componentNamesForValues = {
+      returnDependencies: () => ({
+        children: {
+          dependencyType: "child",
+          childGroups: ["anything"],
+          variableNames: ["componentNamesInList"],
+          variablesOptional: true,
+        },
+      }),
+      definition({ dependencyValues }) {
+        let componentNamesForValues = [];
+        for (let child of dependencyValues.children) {
+          if (child.stateValues.componentNamesInList) {
+            componentNamesForValues.push(
+              ...child.stateValues.componentNamesInList,
+            );
+          } else {
+            componentNamesForValues.push(child.componentName);
+          }
+        }
+
+        return { setValue: { componentNamesForValues } };
+      },
+    };
+
+    stateVariableDefinitions.sortedValues = {
+      stateVariablesDeterminingDependencies: [
+        "componentNamesForValues",
+        "sortByComponent",
+        "propName",
+      ],
+      returnDependencies({ stateValues }) {
+        let dependencies = {
+          sortVectorsBy: {
+            dependencyType: "stateVariable",
+            variableName: "sortVectorsBy",
+          },
+          sortByComponent: {
+            dependencyType: "stateVariable",
+            variableName: "sortByComponent",
+          },
+          propName: {
+            dependencyType: "stateVariable",
+            variableName: "propName",
+          },
+        };
+        if (stateValues.propName) {
+          for (let [
+            ind,
+            cName,
+          ] of stateValues.componentNamesForValues.entries()) {
+            dependencies[`component${ind}`] = {
+              dependencyType: "stateVariable",
+              componentName: cName,
+              variableName: stateValues.propName,
+              variablesOptional: true,
+              caseInsensitiveVariableMatch: true,
+              publicStateVariablesOnly: true,
+              returnAsComponentObject: true,
+            };
+          }
+        } else {
+          for (let [
+            ind,
+            cName,
+          ] of stateValues.componentNamesForValues.entries()) {
+            dependencies[`component${ind}`] = {
+              dependencyType: "multipleStateVariables",
+              componentName: cName,
+              variableNames: [
+                "value",
+                `x${stateValues.sortByComponent}`,
+                `tailX${stateValues.sortByComponent}`,
+              ],
+              variablesOptional: true,
+            };
+          }
+        }
+        return dependencies;
+      },
+      definition({ dependencyValues, componentInfoObjects }) {
+        let allValues = [];
+        let allAreNumeric = true;
+        for (let depName in dependencyValues) {
+          if (depName.substring(0, 9) !== "component") {
+            continue;
+          }
+          let component = dependencyValues[depName];
+          if (dependencyValues.propName) {
+            let value = Object.values(component.stateValues)[0];
+            allValues.push({
+              componentName: component.componentName,
+              numericalValue: Number(value),
+              textValue: String(value),
+            });
+            if (!Number.isFinite(value)) {
+              allAreNumeric = false;
+            }
+          } else if (
+            componentInfoObjects.isInheritedComponentType({
+              inheritedComponentType: component.componentType,
+              baseComponentType: "number",
+            })
+          ) {
+            allValues.push({
+              componentName: component.componentName,
+              numericalValue: component.stateValues.value,
+              textValue: String(component.stateValues.value),
+            });
+          } else if (
+            componentInfoObjects.isInheritedComponentType({
+              inheritedComponentType: component.componentType,
+              baseComponentType: "text",
+            })
+          ) {
+            let numericalValue = NaN;
+            let textValue = component.stateValues.value;
+            allValues.push({
+              componentName: component.componentName,
+              numericalValue,
+              textValue,
+            });
+            allAreNumeric = false;
+          } else if (
+            componentInfoObjects.isInheritedComponentType({
+              inheritedComponentType: component.componentType,
+              baseComponentType: "math",
+            })
+          ) {
+            let numericalValue =
+              component.stateValues.value.evaluate_to_constant();
+            if (Number.isNaN(numericalValue)) {
+              allAreNumeric = false;
+            }
+            allValues.push({
+              componentName: component.componentName,
+              numericalValue,
+              textValue: component.stateValues.value.toString(),
+            });
+          } else if (
+            componentInfoObjects.isInheritedComponentType({
+              inheritedComponentType: component.componentType,
+              baseComponentType: "point",
+            })
+          ) {
+            let compValue =
+              component.stateValues[`x${dependencyValues.sortByComponent}`];
+            let numericalValue = NaN;
+            let textValue = "";
+            if (compValue) {
+              numericalValue = compValue.evaluate_to_constant();
+              if (Number.isNaN(numericalValue)) {
+                allAreNumeric = false;
+              }
+              textValue = compValue.toString();
+            }
+            allValues.push({
+              componentName: component.componentName,
+              numericalValue,
+              textValue,
+            });
+          } else if (
+            componentInfoObjects.isInheritedComponentType({
+              inheritedComponentType: component.componentType,
+              baseComponentType: "vector",
+            })
+          ) {
+            let numericalValue = NaN;
+            let textValue = "";
+            let compValue =
+              component.stateValues[`x${dependencyValues.sortByComponent}`];
+            if (dependencyValues.sortVectorsBy === "displacement") {
+              compValue =
+                component.stateValues[`x${dependencyValues.sortByComponent}`];
+            } else {
+              compValue =
+                component.stateValues[
+                  `tailX${dependencyValues.sortByComponent}`
+                ];
+            }
+            if (compValue) {
+              numericalValue = compValue.evaluate_to_constant();
+              if (Number.isNaN(numericalValue)) {
+                allAreNumeric = false;
+              }
+              textValue = compValue.toString();
+            }
+            allValues.push({
+              componentName: component.componentName,
+              numericalValue,
+              textValue,
+            });
+          }
+        }
+
+        if (allAreNumeric) {
+          allValues.sort((a, b) => a.numericalValue - b.numericalValue);
+        } else {
+          allValues.sort((a, b) =>
+            a.textValue > b.textValue ? 1 : a.textValue < b.textValue ? -1 : 0,
+          );
+        }
+
+        return {
+          setValue: {
+            sortedValues: allValues,
+          },
+        };
+      },
+    };
+
+    stateVariableDefinitions.readyToExpandWhenResolved = {
+      returnDependencies: () => ({
+        sortedValues: {
+          dependencyType: "stateVariable",
+          variableName: "sortedValues",
+        },
+      }),
+      markStale: () => ({ updateReplacements: true }),
+      definition: function () {
+        return { setValue: { readyToExpandWhenResolved: true } };
+      },
+    };
+
+    return stateVariableDefinitions;
+  }
+
+  static async createSerializedReplacements({
+    component,
+    components,
+    componentInfoObjects,
+    workspace,
+  }) {
+    let replacements = [];
+
+    let componentsCopied = [];
+
+    for (let valueObj of await component.stateValues.sortedValues) {
+      let replacementSource;
+
+      if (valueObj.listInd === undefined) {
+        replacementSource = components[valueObj.componentName];
+      } else {
+        let listComponent = components[valueObj.componentName];
+        replacementSource = listComponent.activeChildren[valueObj.listInd];
+      }
+
+      if (replacementSource) {
+        componentsCopied.push(replacementSource.componentName);
+
+        replacements.push(
+          await replacementSource.serialize({
+            sourceAttributesToIgnore: ["isResponse"],
+          }),
+        );
+      }
+    }
+
+    workspace.uniqueIdentifiersUsed = [];
+    replacements = postProcessCopy({
+      serializedComponents: replacements,
+      componentName: component.componentName,
+      uniqueIdentifiersUsed: workspace.uniqueIdentifiersUsed,
+      addShadowDependencies: true,
+      markAsPrimaryShadow: true,
+    });
+
+    let processResult = processAssignNames({
+      assignNames: component.doenetAttributes.assignNames,
+      serializedComponents: replacements,
+      parentName: component.componentName,
+      parentCreatesNewNamespace: await component.stateValues.newNamespace,
+      componentInfoObjects,
+    });
+
+    workspace.componentsCopied = componentsCopied;
+
+    return { replacements: processResult.serializedComponents };
+  }
+
+  static async calculateReplacementChanges({
+    component,
+    components,
+    componentInfoObjects,
+    workspace,
+  }) {
+    let componentsToCopy = [];
+
+    for (let valueObj of await component.stateValues.sortedValues) {
+      let replacementSource;
+
+      if (valueObj.listInd === undefined) {
+        replacementSource = components[valueObj.componentName];
+      } else {
+        let listComponent = components[valueObj.componentName];
+        replacementSource = listComponent.activeChildren[valueObj.listInd];
+      }
+
+      if (replacementSource) {
+        componentsToCopy.push(replacementSource.componentName);
+      }
+    }
+
+    if (
+      componentsToCopy.length == workspace.componentsCopied.length &&
+      workspace.componentsCopied.every((x, i) => x === componentsToCopy[i])
+    ) {
+      return [];
+    }
+
+    // for now, just recreated
+    let replacements = (
+      await this.createSerializedReplacements({
+        component,
+        components,
+        componentInfoObjects,
+        workspace,
+      })
+    ).replacements;
+
+    let replacementChanges = [
+      {
+        changeType: "add",
+        changeTopLevelReplacements: true,
+        firstReplacementInd: 0,
+        numberReplacementsToReplace: component.replacements.length,
+        serializedReplacements: replacements,
+      },
+    ];
+
+    return replacementChanges;
+  }
+}

package/src/Core/components/Sources.js

@@ -0,0 +1,108 @@
+import BaseComponent from "./abstract/BaseComponent";
+
+export default class Sources extends BaseComponent {
+  static componentType = "sources";
+  static rendererType = "containerInline";
+  static renderChildren = true;
+
+  static createAttributesObject() {
+    let attributes = super.createAttributesObject();
+    attributes.alias = {
+      createPrimitiveOfType: "string",
+      validationFunction: function (value) {
+        if (!/[a-zA-Z_]/.test(value.substring(0, 1))) {
+          throw Error("All aliases must begin with a letter or an underscore");
+        }
+        if (!/^[a-zA-Z0-9_\-]+$/.test(value)) {
+          throw Error(
+            "Aliases can contain only letters, numbers, hyphens, and underscores",
+          );
+        }
+        return value;
+      },
+    };
+
+    attributes.indexAlias = {
+      createPrimitiveOfType: "string",
+      validationFunction: function (value) {
+        if (!/[a-zA-Z_]/.test(value.substring(0, 1))) {
+          throw Error(
+            "All index aliases must begin with a letter or an underscore",
+          );
+        }
+        if (!/^[a-zA-Z0-9_\-]+$/.test(value)) {
+          throw Error(
+            "Index aliases can contain only letters, numbers, hyphens, and underscores",
+          );
+        }
+        return value;
+      },
+    };
+    return attributes;
+  }
+
+  static returnChildGroups() {
+    return [
+      {
+        group: "anything",
+        componentTypes: ["_base"],
+      },
+    ];
+  }
+
+  static returnStateVariableDefinitions() {
+    let stateVariableDefinitions = super.returnStateVariableDefinitions();
+
+    stateVariableDefinitions.alias = {
+      returnDependencies: () => ({
+        alias: {
+          dependencyType: "attributePrimitive",
+          attributeName: "alias",
+        },
+      }),
+      definition({ dependencyValues }) {
+        return { setValue: { alias: dependencyValues.alias } };
+      },
+    };
+
+    stateVariableDefinitions.indexAlias = {
+      returnDependencies: () => ({
+        indexAlias: {
+          dependencyType: "attributePrimitive",
+          attributeName: "indexAlias",
+        },
+      }),
+      definition({ dependencyValues }) {
+        return { setValue: { indexAlias: dependencyValues.indexAlias } };
+      },
+    };
+
+    stateVariableDefinitions.numChildren = {
+      additionalStateVariablesDefined: [
+        "childComponentNames",
+        "childIdentities",
+      ],
+      returnDependencies: () => ({
+        children: {
+          dependencyType: "child",
+          childGroups: ["anything"],
+        },
+      }),
+      definition: function ({ dependencyValues }) {
+        let numChildren = dependencyValues.children.length;
+        let childComponentNames = dependencyValues.children.map(
+          (x) => x.componentName,
+        );
+        return {
+          setValue: {
+            numChildren,
+            childComponentNames,
+            childIdentities: dependencyValues.children,
+          },
+        };
+      },
+    };
+
+    return stateVariableDefinitions;
+  }
+}

package/src/Core/components/Split.js

@@ -0,0 +1,205 @@
+import CompositeComponent from "./abstract/CompositeComponent";
+import { processAssignNames } from "../utils/serializedStateProcessing";
+
+export default class Split extends CompositeComponent {
+  static componentType = "split";
+
+  static assignNamesToReplacements = true;
+
+  static stateVariableToEvaluateAfterReplacements = "readyToExpandWhenResolved";
+
+  static createAttributesObject() {
+    let attributes = super.createAttributesObject();
+
+    attributes.assignNamesSkip = {
+      createPrimitiveOfType: "number",
+    };
+
+    // TODO: other types than text or eliminate type attribute
+    attributes.type = {
+      createPrimitiveOfType: "string",
+      createStateVariable: "type",
+      defaultPrimitiveValue: "text",
+      toLowerCase: true,
+      validValues: ["text"],
+    };
+
+    attributes.splitBy = {
+      createComponentOfType: "text",
+      createStateVariable: "splitBy",
+      defaultValue: "letter",
+      toLowerCase: true,
+      validValues: ["letter", "word", "comma"],
+    };
+
+    return attributes;
+  }
+
+  static returnSugarInstructions() {
+    let sugarInstructions = [];
+
+    function addType({ matchedChildren, componentAttributes }) {
+      let type = componentAttributes.type;
+      if (!["text"].includes(type)) {
+        type = "text";
+      }
+
+      return {
+        success: true,
+        newChildren: [
+          {
+            componentType: type,
+            children: matchedChildren,
+          },
+        ],
+      };
+    }
+
+    sugarInstructions.push({
+      replacementFunction: addType,
+    });
+
+    return sugarInstructions;
+  }
+
+  static returnChildGroups() {
+    return [
+      {
+        group: "anything",
+        componentTypes: ["_base"],
+      },
+    ];
+  }
+
+  static returnStateVariableDefinitions() {
+    let stateVariableDefinitions = super.returnStateVariableDefinitions();
+
+    stateVariableDefinitions.originalValue = {
+      returnDependencies: () => ({
+        child: {
+          dependencyType: "child",
+          childGroups: ["anything"],
+          variableNames: ["value"],
+        },
+      }),
+      definition({ dependencyValues }) {
+        if (dependencyValues.child.length > 0) {
+          return {
+            setValue: {
+              originalValue: dependencyValues.child[0].stateValues.value,
+            },
+          };
+        } else {
+          return { setValue: { originalValue: null } };
+        }
+      },
+      inverseDefinition({ desiredStateVariableValues, dependencyValues }) {
+        if (dependencyValues.child.length > 0) {
+          return {
+            success: true,
+            instructions: [
+              {
+                setDependency: "child",
+                desiredValue: desiredStateVariableValues.originalValue,
+                childIndex: 0,
+                variableIndex: 0,
+              },
+            ],
+          };
+        } else {
+          return { success: false };
+        }
+      },
+    };
+
+    stateVariableDefinitions.splitValues = {
+      returnDependencies: () => ({
+        type: {
+          dependencyType: "stateVariable",
+          variableName: "type",
+        },
+        originalValue: {
+          dependencyType: "stateVariable",
+          variableName: "originalValue",
+        },
+        splitBy: {
+          dependencyType: "stateVariable",
+          variableName: "splitBy",
+        },
+      }),
+      definition({ dependencyValues }) {
+        if (dependencyValues.originalValue === null) {
+          return {
+            setValue: { splitValues: [] },
+          };
+        }
+
+        let splitValues = [];
+
+        if (dependencyValues.splitBy === "letter") {
+          splitValues = [...dependencyValues.originalValue];
+        } else if (dependencyValues.splitBy === "word") {
+          splitValues = dependencyValues.originalValue.split(/\s+/);
+        } else if (dependencyValues.splitBy === "comma") {
+          splitValues = dependencyValues.originalValue.split(/\s*,\s*/);
+        } else {
+          splitValues = [dependencyValues.originalValue];
+        }
+
+        return {
+          setValue: { splitValues },
+        };
+      },
+    };
+
+    stateVariableDefinitions.readyToExpandWhenResolved = {
+      returnDependencies: () => ({
+        splitValues: {
+          dependencyType: "stateVariable",
+          variableName: "splitValues",
+        },
+      }),
+      // when this state variable is marked stale
+      // it indicates we should update replacement
+      // For this to work, must get value in replacement functions
+      // so that the variable is marked fresh
+      markStale: () => ({ updateReplacements: true }),
+      definition: function () {
+        return { setValue: { readyToExpandWhenResolved: true } };
+      },
+    };
+
+    return stateVariableDefinitions;
+  }
+
+  static async createSerializedReplacements({
+    component,
+    componentInfoObjects,
+  }) {
+    let newNamespace = component.attributes.newNamespace?.primitive;
+
+    let serializedReplacement = {
+      componentType: "textList",
+      state: { textsShadow: await component.stateValues.splitValues },
+      downstreamDependencies: {
+        [component.componentName]: [
+          {
+            dependencyType: "referenceShadow",
+            compositeName: component.componentName,
+            propVariable: "splitValues",
+          },
+        ],
+      },
+    };
+
+    let processResult = processAssignNames({
+      assignNames: component.doenetAttributes.assignNames,
+      serializedComponents: [serializedReplacement],
+      parentName: component.componentName,
+      parentCreatesNewNamespace: newNamespace,
+      componentInfoObjects,
+    });
+
+    return { replacements: processResult.serializedComponents };
+  }
+}