@doenet/v06-to-v07 0.7.26-dev.547 → 0.7.26-dev.548

package/{index-CjWZS5b_.js → index-DJZickZD.js}

@@ -47285,7 +47285,7 @@ async function cidFromArrayBuffer(data) {
       await crypto.subtle.digest("SHA-256", new Uint8Array());
       digest = (data2) => crypto.subtle.digest("SHA-256", data2);
     } catch (e22) {
-      const sha256 = (await import("./sha256-DT5xJ2Hv-B3IOSUHf-IZrBz-rp.js").then((n2) => n2.s)).default;
+      const sha256 = (await import("./sha256-DT5xJ2Hv-BG3R96t1-BIoU3hjd.js").then((n2) => n2.s)).default;
       digest = (data2) => sha256(data2, {
         asBytes: true
       });
@@ -91167,8 +91167,33 @@ function returnBreakStringsIntoTypeSugarInstruction(componentName) {
   }
   return { replacementFunction: breakStringsMacrosIntoTypeBySpaces };
 }
-function diagnosticsForNoIndex(result2, componentType) {
-  switch (result2.reason) {
+function returnListTypeAttribute({ readsTarget = false } = {}) {
+  return {
+    createPrimitiveOfType: "string",
+    description: readsTarget ? "Component type to interpret bare string children as. Also decides how a `target` is read, since it has no type of its own." : "Component type to interpret bare string children as.",
+    highlighted: true,
+    validValues: [
+      {
+        value: "number",
+        description: "Read bare strings as numbers, ordered by value."
+      },
+      {
+        value: "math",
+        description: "Read bare strings as math expressions, ordered by value."
+      },
+      {
+        value: "text",
+        description: "Read bare strings as text, ordered alphabetically."
+      },
+      {
+        value: "boolean",
+        description: "Read bare strings as booleans, ordered with false before true."
+      }
+    ]
+  };
+}
+function diagnosticsForNoIndex(reason, componentType) {
+  switch (reason) {
     case "noTarget":
       return [
         codedDiagnostic({
@@ -91189,6 +91214,67 @@ function diagnosticsForNoIndex(result2, componentType) {
       return [];
   }
 }
+function diagnosticsForNoIndices(results, componentType) {
+  const reasons = /* @__PURE__ */ new Set();
+  for (const result2 of results) {
+    if (result2?.reason) {
+      reasons.add(result2.reason);
+    }
+  }
+  return [...reasons].flatMap(
+    (reason) => diagnosticsForNoIndex(reason, componentType)
+  );
+}
+function returnTargetAttribute(description) {
+  return {
+    createComponentOfType: "_componentListWithSelectableType",
+    description,
+    highlighted: true
+  };
+}
+function returnComparableTargetsStateVariableDefinition() {
+  return {
+    comparableTargets: {
+      returnDependencies: () => ({
+        targetAttr: {
+          dependencyType: "attributeComponent",
+          attributeName: "target",
+          variableNames: ["values"]
+        }
+      }),
+      definition({ dependencyValues }) {
+        if (dependencyValues.targetAttr === null) {
+          return { setValue: { comparableTargets: null } };
+        }
+        return {
+          setValue: {
+            comparableTargets: dependencyValues.targetAttr.stateValues.values.map(
+              comparableValueFromRaw
+            )
+          }
+        };
+      }
+    }
+  };
+}
+function locateEachTarget({ values: values2, targets, numeric: numeric2, locate }) {
+  if (targets === null) {
+    return [{ index: 0, reason: "noTarget" }];
+  }
+  return targets.map((target) => {
+    if (target === null) {
+      return { index: 0, reason: "noTarget" };
+    }
+    if (values2.length === 0) {
+      return { index: 0, reason: "noValues" };
+    }
+    return locate({
+      values: values2,
+      target,
+      numeric: numeric2 && target.isNumeric
+    });
+  });
+}
 class ListIndexBaseOperator extends MathComponent {
   static componentType = "_listIndexOperator";
   static rendererType = "math";
@@ -91197,29 +91283,7 @@ class ListIndexBaseOperator extends MathComponent {
   static descendantCompositesMustHaveAReplacement = false;
   static createAttributesObject() {
     let attributes = super.createAttributesObject();
-    attributes.type = {
-      createPrimitiveOfType: "string",
-      description: "Component type to interpret bare string children as. Also decides how a `target` is read, since it has no type of its own.",
-      highlighted: true,
-      validValues: [
-        {
-          value: "number",
-          description: "Read bare strings as numbers, ordered by value."
-        },
-        {
-          value: "math",
-          description: "Read bare strings as math expressions, ordered by value."
-        },
-        {
-          value: "text",
-          description: "Read bare strings as text, ordered alphabetically."
-        },
-        {
-          value: "boolean",
-          description: "Read bare strings as booleans, ordered with false before true."
-        }
-      ]
-    };
+    attributes.type = returnListTypeAttribute();
     for (const attrName of ["format", "simplify", "displayDigits"]) {
       if (attributes[attrName]) {
         const { highlighted: _highlighted, ...rest2 } = attributes[attrName];
@@ -91301,11 +91365,10 @@ class ListIndexBaseOperator extends MathComponent {
           values: dependencyValues.listValues,
           numeric: dependencyValues.allAreNumeric
         });
-        const index2 = result2.index;
         return {
-          setValue: { unnormalizedValue: Context.fromAst(index2) },
+          setValue: { unnormalizedValue: Context.fromAst(result2.index) },
           sendDiagnostics: diagnosticsForNoIndex(
-            result2,
+            result2.reason,
             componentType
           )
         };
@@ -91314,50 +91377,167 @@ class ListIndexBaseOperator extends MathComponent {
     return stateVariableDefinitions;
   }
 }
-function returnTargetAttribute(description) {
-  return {
-    createComponentOfType: "_componentWithSelectableType",
-    createStateVariable: "target",
-    defaultValue: null,
-    description,
-    highlighted: true
-  };
-}
-function returnTargetStateVariableDefinition() {
-  return {
-    comparableTarget: {
+class ListIndexBaseListOperator extends CompositeComponent {
+  static componentType = "_listIndexListOperator";
+  static takesIndex = true;
+  static stateVariableToEvaluateAfterReplacements = "readyToExpandWhenResolved";
+  static allowInSchemaAsComponent = ["math"];
+  // Since the operator treats each child as a separate argument,
+  // composites with no replacement should be ignored.
+  static descendantCompositesMustHaveAReplacement = false;
+  // The reference pages show this text, and the two operators do not mean
+  // the same thing by `target`: `<indexOf>` looks its target up in the list,
+  // which is the wording below, while `<searchSorted>` places a target that
+  // need not be in the list at all and overrides it.
+  static targetDescription = "The value, or list of values, to look for.";
+  static createAttributesObject() {
+    let attributes = super.createAttributesObject();
+    attributes.type = {
+      ...returnListTypeAttribute({ readsTarget: true }),
+      createStateVariable: "type",
+      defaultValue: null
+    };
+    attributes.target = returnTargetAttribute(this.targetDescription);
+    Object.assign(attributes, returnPassThroughAttributeDeclarations());
+    attributes.asList = {
+      createPrimitiveOfType: "boolean",
+      createStateVariable: "asList",
+      defaultValue: true,
+      highlighted: true,
+      description: "Whether to render the items separated by commas (true) or with no separator (false)."
+    };
+    return attributes;
+  }
+  // Include children that can be added due to sugar
+  static additionalSchemaChildren = ["string"];
+  static returnSugarInstructions() {
+    let sugarInstructions = super.returnSugarInstructions();
+    sugarInstructions.push(
+      returnBreakStringsIntoTypeSugarInstruction(this.componentType)
+    );
+    return sugarInstructions;
+  }
+  static returnChildGroups() {
+    return [
+      {
+        group: "anything",
+        componentTypes: ["_base"]
+      }
+    ];
+  }
+  static returnStateVariableDefinitions() {
+    let stateVariableDefinitions = super.returnStateVariableDefinitions();
+    const componentType = this.componentType;
+    Object.assign(
+      stateVariableDefinitions,
+      returnListValueStateVariableDefinitions({
+        componentName: this.componentType,
+        supportProps: false
+      }),
+      returnComparableTargetsStateVariableDefinition()
+    );
+    stateVariableDefinitions.locate = {
+      returnDependencies: () => ({}),
+      definition: () => ({
+        setValue: { locate: () => ({ index: 0 }) }
+      })
+    };
+    stateVariableDefinitions.operatorResults = {
       returnDependencies: () => ({
-        target: {
+        listValues: {
           dependencyType: "stateVariable",
-          variableName: "target"
+          variableName: "listValues"
+        },
+        allAreNumeric: {
+          dependencyType: "stateVariable",
+          variableName: "allAreNumeric"
+        },
+        comparableTargets: {
+          dependencyType: "stateVariable",
+          variableName: "comparableTargets"
+        },
+        locate: {
+          dependencyType: "stateVariable",
+          variableName: "locate"
         }
       }),
       definition({ dependencyValues }) {
+        const results = locateEachTarget({
+          values: dependencyValues.listValues,
+          targets: dependencyValues.comparableTargets,
+          numeric: dependencyValues.allAreNumeric,
+          locate: dependencyValues.locate
+        });
         return {
           setValue: {
-            comparableTarget: comparableValueFromRaw(
-              dependencyValues.target
+            operatorResults: results.map(
+              (result2) => Context.fromAst(result2.index)
             )
-          }
+          },
+          sendDiagnostics: diagnosticsForNoIndices(
+            results,
+            componentType
+          )
         };
       }
-    }
-  };
-}
-function returnTargetSearchingIndexOperator(target, locate) {
-  return ({ values: values2, numeric: numeric2 }) => {
-    if (target === null) {
-      return { index: 0, reason: "noTarget" };
-    }
-    if (values2.length === 0) {
-      return { index: 0, reason: "noValues" };
-    }
-    return locate({
-      values: values2,
-      target,
-      numeric: numeric2 && target.isNumeric
+    };
+    stateVariableDefinitions.readyToExpandWhenResolved = {
+      returnDependencies: () => ({
+        operatorResults: {
+          dependencyType: "stateVariable",
+          variableName: "operatorResults"
+        }
+      }),
+      // When this state variable is marked stale it indicates we should
+      // update replacements. For this to work, we must get its value in
+      // the 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: componentInfoObjects2,
+    workspace,
+    nComponents
+  }) {
+    return createValueListReplacements({
+      component,
+      values: await component.stateValues.operatorResults,
+      componentType: "math",
+      attributesToConvert: returnPassThroughAttributes(component),
+      componentInfoObjects: componentInfoObjects2,
+      workspace,
+      nComponents
     });
-  };
+  }
+  static async calculateReplacementChanges({
+    component,
+    componentInfoObjects: componentInfoObjects2,
+    workspace,
+    nComponents
+  }) {
+    return calculateValueListReplacementChanges({
+      component,
+      values: await component.stateValues.operatorResults,
+      componentType: "math",
+      attributesToConvert: returnPassThroughAttributes(component),
+      componentInfoObjects: componentInfoObjects2,
+      workspace,
+      nComponents
+    });
+  }
+  addOwnPotentialRendererTypes(rendererTypes, visited) {
+    super.addOwnPotentialRendererTypes(rendererTypes, visited);
+    addReplacementRendererType({
+      component: this,
+      componentType: "math",
+      rendererTypes
+    });
+  }
 }
 function returnConstantIndexOperatorDefinition(indexOperator) {
   return {
@@ -91365,22 +91545,13 @@ function returnConstantIndexOperatorDefinition(indexOperator) {
     definition: () => ({ setValue: { indexOperator } })
   };
 }
-function returnTargetSearchingIndexOperatorDefinition(locate, extraDependencies = {}) {
+function returnLocateDefinition(locate, extraDependencies = {}) {
   return {
-    returnDependencies: () => ({
-      comparableTarget: {
-        dependencyType: "stateVariable",
-        variableName: "comparableTarget"
-      },
-      ...extraDependencies
-    }),
+    returnDependencies: () => ({ ...extraDependencies }),
     definition({ dependencyValues }) {
       return {
         setValue: {
-          indexOperator: returnTargetSearchingIndexOperator(
-            dependencyValues.comparableTarget,
-            (args) => locate({ ...args, dependencyValues })
-          )
+          locate: (args) => locate({ ...args, dependencyValues })
         }
       };
     }
@@ -91429,49 +91600,32 @@ class ArgMax extends ListIndexBaseOperator {
     });
   }
 }
-class IndexOf extends ListIndexBaseOperator {
+class IndexOf extends ListIndexBaseListOperator {
   static componentType = "indexOf";
   static componentDocs = {
-    summary: "The index of the first value in a list equal to a target, or 0 if there is none"
+    summary: "The index of the first value in a list equal to each target, or 0 where there is none"
   };
-  static createAttributesObject() {
-    let attributes = super.createAttributesObject();
-    attributes.target = returnTargetAttribute("The value to look for.");
-    return attributes;
-  }
   static returnStateVariableDefinitions() {
-    return Object.assign(
-      super.returnStateVariableDefinitions(),
-      returnTargetStateVariableDefinition(),
-      {
-        indexOperator: returnTargetSearchingIndexOperatorDefinition(
-          ({ values: values2, target, numeric: numeric2 }) => {
-            for (let [ind, value] of values2.entries()) {
-              if (compareExtractedValues(
-                value,
-                target,
-                numeric2
-              ) === 0) {
-                return { index: ind + 1 };
-              }
-            }
-            return { index: 0 };
+    return Object.assign(super.returnStateVariableDefinitions(), {
+      locate: returnLocateDefinition(({ values: values2, target, numeric: numeric2 }) => {
+        for (let [ind, value] of values2.entries()) {
+          if (compareExtractedValues(value, target, numeric2) === 0) {
+            return { index: ind + 1 };
           }
-        )
-      }
-    );
+        }
+        return { index: 0 };
+      })
+    });
   }
 }
-class SearchSorted extends ListIndexBaseOperator {
+class SearchSorted extends ListIndexBaseListOperator {
   static componentType = "searchSorted";
   static componentDocs = {
-    summary: "The position at which a target would be inserted to keep a sorted list sorted"
+    summary: "The position at which each target would be inserted to keep a sorted list sorted"
   };
+  static targetDescription = "The value, or list of values, to locate within the sorted list.";
   static createAttributesObject() {
     let attributes = super.createAttributesObject();
-    attributes.target = returnTargetAttribute(
-      "The value to locate within the sorted list."
-    );
     attributes.side = {
       createComponentOfType: "text",
       createStateVariable: "side",
@@ -91494,34 +91648,30 @@ class SearchSorted extends ListIndexBaseOperator {
     return attributes;
   }
   static returnStateVariableDefinitions() {
-    return Object.assign(
-      super.returnStateVariableDefinitions(),
-      returnTargetStateVariableDefinition(),
-      {
-        indexOperator: returnTargetSearchingIndexOperatorDefinition(
-          ({ values: values2, target, numeric: numeric2, dependencyValues }) => {
-            let count = 0;
-            for (let value of values2) {
-              let comparison = compareExtractedValues(
-                value,
-                target,
-                numeric2
-              );
-              if (comparison < 0 || dependencyValues.side === "right" && comparison === 0) {
-                count++;
-              }
-            }
-            return { index: count + 1 };
-          },
-          {
-            side: {
-              dependencyType: "stateVariable",
-              variableName: "side"
+    return Object.assign(super.returnStateVariableDefinitions(), {
+      locate: returnLocateDefinition(
+        ({ values: values2, target, numeric: numeric2, dependencyValues }) => {
+          let count = 0;
+          for (let value of values2) {
+            let comparison = compareExtractedValues(
+              value,
+              target,
+              numeric2
+            );
+            if (comparison < 0 || dependencyValues.side === "right" && comparison === 0) {
+              count++;
             }
           }
-        )
-      }
-    );
+          return { index: count + 1 };
+        },
+        {
+          side: {
+            dependencyType: "stateVariable",
+            variableName: "side"
+          }
+        }
+      )
+    });
   }
 }
 const ListIndexOperators = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
@@ -241751,4 +241901,4 @@ export {
   getDefaultExportFromCjs$1 as g,
   updateSyntaxFromV06toV07 as u
 };
-//# sourceMappingURL=index-CjWZS5b_.js.map
+//# sourceMappingURL=index-DJZickZD.js.map