@doenet/doenetml 0.6.0-alpha1

package/src/Core/components/CodeViewer.js

@@ -0,0 +1,294 @@
+import BlockComponent from "./abstract/BlockComponent";
+
+export default class CodeViewer extends BlockComponent {
+  constructor(args) {
+    super(args);
+
+    Object.assign(this.actions, {
+      updateComponents: this.updateComponents.bind(this),
+      recordVisibilityChange: this.recordVisibilityChange.bind(this),
+    });
+  }
+  static componentType = "codeViewer";
+  static renderChildren = true;
+
+  static includeBlankStringChildren = true;
+
+  static createAttributesObject() {
+    let attributes = super.createAttributesObject();
+
+    attributes.codeSource = {
+      createTargetComponentNames: true,
+    };
+
+    attributes.width = {
+      createComponentOfType: "_componentSize",
+    };
+
+    attributes.height = {
+      createComponentOfType: "_componentSize",
+    };
+
+    attributes.hasCodeEditorParent = {
+      createComponentOfType: "boolean",
+    };
+
+    attributes.renderedName = {
+      createPrimitiveOfType: "string",
+    };
+
+    return attributes;
+  }
+
+  static returnSugarInstructions() {
+    let sugarInstructions = super.returnSugarInstructions();
+
+    let addRenderDoenetML = function ({
+      matchedChildren,
+      componentAttributes,
+    }) {
+      if (matchedChildren.length > 0) {
+        return { success: false };
+      }
+
+      let renderDoenetML = {
+        componentType: "renderDoenetML",
+      };
+
+      if (componentAttributes.codeSource) {
+        renderDoenetML.attributes = {
+          codeSource: {
+            targetComponentNames: componentAttributes.codeSource,
+          },
+        };
+      }
+
+      if (componentAttributes.renderedName) {
+        renderDoenetML.props = { name: componentAttributes.renderedName };
+      }
+
+      return {
+        success: true,
+        newChildren: [renderDoenetML],
+      };
+    };
+    sugarInstructions.push({
+      replacementFunction: addRenderDoenetML,
+    });
+    return sugarInstructions;
+  }
+
+  static returnChildGroups() {
+    return [
+      {
+        group: "children",
+        componentTypes: ["_base"],
+      },
+    ];
+  }
+
+  static returnStateVariableDefinitions() {
+    let stateVariableDefinitions = super.returnStateVariableDefinitions();
+
+    stateVariableDefinitions.hasCodeEditorParent = {
+      public: true,
+      shadowingInstructions: {
+        createComponentOfType: "boolean",
+      },
+      forRenderer: true,
+      returnDependencies: () => ({
+        codeEditorParent: {
+          dependencyType: "parentIdentity",
+          parentComponentType: "codeEditor",
+        },
+      }),
+      definition: function ({ dependencyValues }) {
+        if (dependencyValues.codeEditorParent) {
+          return { setValue: { hasCodeEditorParent: true } };
+        } else {
+          //Default
+          return { setValue: { hasCodeEditorParent: false } };
+        }
+      },
+    };
+
+    stateVariableDefinitions.locationFromParent = {
+      public: true,
+      shadowingInstructions: {
+        createComponentOfType: "text",
+      },
+      forRenderer: true,
+      returnDependencies: () => ({
+        locationFromParent: {
+          dependencyType: "parentStateVariable",
+          parentComponentType: "codeEditor",
+          variableName: "resultsLocation",
+        },
+      }),
+      definition: function ({ dependencyValues }) {
+        return {
+          setValue: {
+            locationFromParent: dependencyValues.locationFromParent || null,
+          },
+        };
+      },
+    };
+
+    stateVariableDefinitions.width = {
+      public: true,
+      shadowingInstructions: {
+        createComponentOfType: "_componentSize",
+      },
+      hasEssential: true,
+      forRenderer: true,
+      defaultValue: { size: 600, isAbsolute: true },
+      returnDependencies: () => ({
+        widthAttr: {
+          dependencyType: "attributeComponent",
+          attributeName: "width",
+          variableNames: ["componentSize"],
+        },
+        parentWidth: {
+          dependencyType: "parentStateVariable",
+          variableName: "width",
+          parentComponentType: "codeEditor",
+        },
+      }),
+      definition: function ({ dependencyValues }) {
+        if (dependencyValues.widthAttr) {
+          //Author specified width
+          return {
+            setValue: {
+              width: dependencyValues.widthAttr.stateValues.componentSize,
+            },
+          };
+        } else if (dependencyValues.parentWidth) {
+          //Parent component specified viewerWidth
+          return { setValue: { width: dependencyValues.parentWidth } };
+        } else {
+          //Default
+          return { useEssentialOrDefaultValue: { width: true } };
+        }
+      },
+    };
+
+    stateVariableDefinitions.height = {
+      public: true,
+      shadowingInstructions: {
+        createComponentOfType: "_componentSize",
+      },
+      hasEssential: true,
+      forRenderer: true,
+      defaultValue: { size: 400, isAbsolute: true },
+      returnDependencies: () => ({
+        heightAttr: {
+          dependencyType: "attributeComponent",
+          attributeName: "height",
+          variableNames: ["componentSize"],
+        },
+        parentViewerHeight: {
+          dependencyType: "parentStateVariable",
+          variableName: "viewerHeight",
+          parentComponentType: "codeEditor",
+        },
+      }),
+      definition: function ({ dependencyValues }) {
+        if (dependencyValues.heightAttr) {
+          //Author specified height
+          return {
+            setValue: {
+              height: dependencyValues.heightAttr.stateValues.componentSize,
+            },
+          };
+        } else if (dependencyValues.parentViewerHeight) {
+          //Parent component specified viewerheight
+          return { setValue: { height: dependencyValues.parentViewerHeight } };
+        } else {
+          //Default
+          return { useEssentialOrDefaultValue: { height: true } };
+        }
+      },
+    };
+
+    stateVariableDefinitions.codeSourceComponentName = {
+      returnDependencies: () => ({
+        codeSource: {
+          dependencyType: "attributeTargetComponentNames",
+          attributeName: "codeSource",
+        },
+      }),
+      definition({ dependencyValues }) {
+        let codeSourceComponentName;
+
+        if (dependencyValues.codeSource?.length === 1) {
+          codeSourceComponentName = dependencyValues.codeSource[0].absoluteName;
+        } else {
+          codeSourceComponentName = null;
+        }
+
+        return { setValue: { codeSourceComponentName } };
+      },
+    };
+
+    stateVariableDefinitions.codeSource = {
+      returnDependencies: () => ({
+        codeSourceComponentName: {
+          dependencyType: "stateVariable",
+          variableName: "codeSourceComponentName",
+        },
+        codeEditorParent: {
+          dependencyType: "parentIdentity",
+          parentComponentType: "codeEditor",
+        },
+      }),
+      definition: function ({ dependencyValues }) {
+        if (dependencyValues.codeSourceComponentName) {
+          return {
+            setValue: { codeSource: dependencyValues.codeSourceComponentName },
+          };
+        } else if (dependencyValues.codeEditorParent) {
+          return {
+            setValue: {
+              codeSource: dependencyValues.codeEditorParent.componentName,
+            },
+          };
+        } else {
+          return { setValue: { codeSource: null } };
+        }
+      },
+    };
+
+    return stateVariableDefinitions;
+  }
+
+  async updateComponents() {
+    if (
+      this.definingChildren.length === 1 &&
+      this.definingChildren[0].componentType === "renderDoenetML"
+    ) {
+      await this.coreFunctions.performAction({
+        componentName: this.definingChildren[0].componentName,
+        actionName: "updateComponents",
+        // event: {
+        //   verb: "selected",
+        //   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 });
+  }
+}

package/src/Core/components/CollaborateGroupSetup.js

@@ -0,0 +1,46 @@
+import BaseComponent from "./abstract/BaseComponent";
+
+export default class CollaborateGroupSetup extends BaseComponent {
+  static componentType = "collaborateGroupSetup";
+
+  static returnChildLogic(args) {
+    let childLogic = super.returnChildLogic(args);
+
+    childLogic.newLeaf({
+      name: "atMostOnePossibleNumberOfGroups",
+      componentType: "possibleNumberOfGroups",
+      comparison: "atMost",
+      number: 1,
+      setAsBase: true,
+    });
+    return childLogic;
+  }
+
+  static returnStateVariableDefinitions() {
+    let stateVariableDefinitions = super.returnStateVariableDefinitions();
+
+    stateVariableDefinitions.possibleNumberOfGroups = {
+      returnDependencies: () => ({
+        pngChild: {
+          dependencyType: "child",
+          childLogicName: "atMostOnePossibleNumberOfGroups",
+          variableNames: ["numbers"],
+        },
+      }),
+      definition: function ({ dependencyValues }) {
+        if (dependencyValues.pngChild.length === 0) {
+          return { setValue: { possibleNumberOfGroups: [1] } };
+        }
+
+        return {
+          setValue: {
+            possibleNumberOfGroups:
+              dependencyValues.pngChild[0].stateValues.numbers,
+          },
+        };
+      },
+    };
+
+    return stateVariableDefinitions;
+  }
+}

package/src/Core/components/CollaborateGroups.js

@@ -0,0 +1,119 @@
+import BaseComponent from "./abstract/BaseComponent";
+import { breakStringsAndOthersIntoComponentsByStringCommas } from "./commonsugar/breakstrings";
+
+export default class CollaborateGroups extends BaseComponent {
+  static componentType = "collaborateGroups";
+  static rendererType = undefined;
+
+  static stateVariableForAttributeValue = "collaborateGroups";
+
+  static returnChildLogic(args) {
+    let childLogic = super.returnChildLogic(args);
+
+    let atLeastZeroPoints = childLogic.newLeaf({
+      name: "atLeastZeroPoints",
+      componentType: "point",
+      comparison: "atLeast",
+      number: 0,
+    });
+
+    let breakIntoPointsByCommas =
+      breakStringsAndOthersIntoComponentsByStringCommas((x) => ({
+        componentType: "point",
+        children: [
+          {
+            componentType: "coords",
+            children: x,
+          },
+        ],
+      }));
+
+    let exactlyOneString = childLogic.newLeaf({
+      name: "exactlyOneString",
+      componentType: "string",
+      number: 1,
+      isSugar: true,
+      logicToWaitOnSugar: ["atLeastZeroPoints"],
+      replacementFunction: breakIntoPointsByCommas,
+    });
+
+    childLogic.newOperator({
+      name: "pointsXorSugar",
+      operator: "xor",
+      propositions: [exactlyOneString, atLeastZeroPoints],
+      setAsBase: true,
+    });
+
+    return childLogic;
+  }
+
+  static returnStateVariableDefinitions() {
+    let stateVariableDefinitions = super.returnStateVariableDefinitions();
+
+    stateVariableDefinitions.collaborateGroups = {
+      returnDependencies: () => ({
+        pointChildren: {
+          dependencyType: "child",
+          childLogicName: "atLeastZeroPoints",
+          variableNames: ["xs", "coords", "numDimensions"],
+        },
+      }),
+      definition: function ({ dependencyValues }) {
+        let groups = {};
+
+        for (let point of dependencyValues.pointChildren) {
+          if (point.stateValues.numDimensions !== 2) {
+            console.warn(
+              `invalid collaborate group: ${point.stateValues.coords.toString()}`,
+            );
+          } else {
+            let numberOfGroups = point.stateValues.xs[0].evaluate_to_constant();
+            let group = point.stateValues.xs[1].evaluate_to_constant();
+
+            if (
+              !(
+                Number.isInteger(numberOfGroups) &&
+                numberOfGroups > 0 &&
+                Number.isInteger(group) &&
+                group > 0
+              )
+            ) {
+              console.warn(
+                `invalid collaborate group: ${point.stateValues.coords.toString()}`,
+              );
+            } else {
+              if (groups[numberOfGroups] === undefined) {
+                groups[numberOfGroups] = [];
+              }
+              groups[numberOfGroups].push(group);
+            }
+          }
+        }
+
+        let matchGroup = function ({ groupNumber, numberOfGroups } = {}) {
+          if (numberOfGroups > 1) {
+            let collaborationAssignment = groups[numberOfGroups];
+            if (collaborationAssignment === undefined) {
+              return false;
+            } else {
+              return collaborationAssignment.includes(groupNumber);
+            }
+          } else {
+            return true;
+          }
+        };
+
+        return {
+          setValue: {
+            collaborateGroups: {
+              groups,
+              matchGroup,
+            },
+          },
+        };
+      },
+    };
+
+    return stateVariableDefinitions;
+  }
+}