@doenet/doenetml 0.6.0-alpha1

package/src/Core/utils/deepFunctions.js

@@ -0,0 +1,173 @@
+import me from "math-expressions";
+import subsets from "./subset-of-reals";
+
+// from https://stackoverflow.com/a/40293777
+export function deepClone(obj, BaseComponent, hash) {
+  // Do not try to clone primitives or functions
+  if (Object(obj) !== obj || obj instanceof Function) return obj;
+
+  // Do not try to clone Doenet components
+  if (BaseComponent !== undefined && obj instanceof BaseComponent) return obj;
+
+  if (obj instanceof me.class || obj instanceof subsets.Subset) {
+    return obj.copy();
+  }
+
+  if (hash === undefined) {
+    hash = new WeakMap();
+  }
+
+  if (Array.isArray(obj)) {
+    return [...obj.map((x) => deepClone(x, BaseComponent, hash))];
+  }
+
+  // seem to get empty object a lot, so short circuit it
+  if (obj.constructor === Object && Object.entries(obj).length === 0) {
+    return {};
+  }
+
+  if (hash.has(obj)) return hash.get(obj); // Cyclic reference
+  try {
+    // Try to run constructor (without arguments, as we don't know them)
+    var result = new obj.constructor();
+  } catch (e) {
+    // Constructor failed, create object without running the constructor
+    result = Object.create(Object.getPrototypeOf(obj));
+  }
+  // Optional: support for some standard constructors (extend as desired)
+  if (obj instanceof Map)
+    Array.from(obj, ([key, val]) =>
+      result.set(
+        deepClone(key, BaseComponent, hash),
+        deepClone(val, BaseComponent, hash),
+      ),
+    );
+  else if (obj instanceof Set) {
+    // result.values = result.values.bind(result);
+    Array.from(obj, (key) => result.add(deepClone(key, BaseComponent, hash)));
+  }
+  // Register in hash
+  hash.set(obj, result);
+  // Clone and assign enumerable own properties recursively
+  return Object.assign(
+    result,
+    ...Object.keys(obj).map((key) => ({
+      [key]: deepClone(obj[key], BaseComponent, hash),
+    })),
+  );
+}
+
+// based on https://stackoverflow.com/a/1144249
+export function deepCompare(a, b, BaseComponent) {
+  var leftChain, rightChain;
+
+  function compare2Objects(x, y) {
+    var p;
+
+    // remember that NaN === NaN returns false
+    if (Number.isNaN(x) && Number.isNaN(y)) {
+      return true;
+    }
+
+    if (x === y) {
+      return true;
+    }
+
+    // if components, equal if same component name
+    if (
+      BaseComponent !== undefined &&
+      x instanceof BaseComponent &&
+      y instanceof BaseComponent
+    ) {
+      return x.componentName === y.componentName;
+    }
+
+    // if math-expressions, equal if exact same syntax tree
+    if (x instanceof me.class && y instanceof me.class) {
+      return compare2Objects(x.tree, y.tree);
+    }
+
+    // Works in case when functions are created in constructor.
+    // Comparing dates is a common scenario. Another built-ins?
+    // We can even handle functions passed across iframes
+    if (
+      (typeof x === "function" && typeof y === "function") ||
+      (x instanceof Date && y instanceof Date) ||
+      (x instanceof RegExp && y instanceof RegExp) ||
+      (x instanceof String && y instanceof String) ||
+      (x instanceof Number && y instanceof Number)
+    ) {
+      return x.toString() === y.toString();
+    }
+
+    // At last checking prototypes as good as we can
+    if (!(x instanceof Object && y instanceof Object)) {
+      return false;
+    }
+
+    if (x.isPrototypeOf(y) || y.isPrototypeOf(x)) {
+      return false;
+    }
+
+    if (x.constructor !== y.constructor) {
+      return false;
+    }
+
+    if (x.prototype !== y.prototype) {
+      return false;
+    }
+
+    // Check for infinitive linking loops
+    if (leftChain.indexOf(x) > -1 || rightChain.indexOf(y) > -1) {
+      return false;
+    }
+
+    // Quick checking of one object being a subset of another.
+    for (p in y) {
+      if (y.hasOwnProperty(p) !== x.hasOwnProperty(p)) {
+        return false;
+      } else if (typeof y[p] !== typeof x[p]) {
+        return false;
+      }
+    }
+
+    for (p in x) {
+      if (y.hasOwnProperty(p) !== x.hasOwnProperty(p)) {
+        return false;
+      } else if (typeof y[p] !== typeof x[p]) {
+        return false;
+      }
+
+      switch (typeof x[p]) {
+        case "object":
+        case "function":
+          leftChain.push(x);
+          rightChain.push(y);
+
+          if (!compare2Objects(x[p], y[p])) {
+            // console.log(`false because objects weren't equal`);
+            // console.log(x[p])
+            // console.log(y[p])
+            return false;
+          }
+
+          leftChain.pop();
+          rightChain.pop();
+          break;
+
+        default:
+          if (x[p] !== y[p] && !(Number.isNaN(x[p]) && Number.isNaN(y[p]))) {
+            return false;
+          }
+          break;
+      }
+    }
+
+    return true;
+  }
+
+  leftChain = [];
+  rightChain = [];
+
+  return compare2Objects(a, b);
+}

package/src/Core/utils/descendants.js

@@ -0,0 +1,252 @@
+export function gatherDescendants({
+  ancestor,
+  descendantTypes,
+  recurseToMatchedChildren = true,
+  useReplacementsForComposites = false,
+  includeNonActiveChildren = false,
+  skipOverAdapters = false,
+  ignoreReplacementsOfMatchedComposites = false,
+  ignoreReplacementsOfEncounteredComposites = false,
+  init = true,
+  componentInfoObjects,
+}) {
+  // Note: ignoreReplacementsOfEncounteredComposites means ignore replacements
+  // of all composites except copies of external content
+
+  let matchChildToTypes = (child) =>
+    descendantTypes.some((ct) =>
+      componentInfoObjects.isInheritedComponentType({
+        inheritedComponentType: child.componentType,
+        baseComponentType: ct,
+      }),
+    );
+
+  let childrenToCheck = [];
+
+  if (
+    useReplacementsForComposites &&
+    componentInfoObjects.isInheritedComponentType({
+      inheritedComponentType: ancestor.componentType,
+      baseComponentType: "_composite",
+    })
+  ) {
+    if (init) {
+      // if not init, parent will also be checked.
+      // Since replacements will be children of parent,
+      // don't need to gather them here
+      childrenToCheck.push(
+        ...replacementsForComposites({
+          composite: ancestor,
+          componentInfoObjects,
+          includeComposites: includeNonActiveChildren,
+        }).filter((x) => typeof x === "object"),
+      );
+    }
+  } else {
+    // add children in the order of allChildren ordered
+    for (let childName of ancestor.allChildrenOrdered) {
+      let childObj = ancestor.allChildren[childName];
+      let child;
+      let childIsActive = false;
+      let childIsAdapter = false;
+      if (childObj) {
+        child = childObj.component;
+        if (child.adaptedFrom) {
+          childIsAdapter = true;
+        }
+        if (ancestor.activeChildren.includes(child)) {
+          childIsActive = true;
+        }
+      } else {
+        // must have a placeholder
+        // look in activeChildren
+        // include the placedholders adapted into the activeChildren
+        for (let aChild of ancestor.activeChildren) {
+          if (aChild.placeholderInd === childName) {
+            child = aChild;
+            childIsActive = true;
+            if (
+              typeof childName === "string" &&
+              childName.substring(childName.length - 5, childName.length) ===
+                "adapt"
+            ) {
+              childIsAdapter = true;
+            }
+            break;
+          } else if (
+            aChild.adaptedFrom &&
+            achild.adaptedFrom.placeholderInd === childName
+          ) {
+            child = aChild.adaptedFrom;
+            break;
+          }
+        }
+      }
+
+      if (child) {
+        if (childIsAdapter && skipOverAdapters) {
+          if (!childrenToCheck.includes(child.adaptedFrom)) {
+            childrenToCheck.push(child.adaptedFrom);
+          }
+        } else if (childIsActive || includeNonActiveChildren) {
+          childrenToCheck.push(child);
+        }
+      }
+    }
+  }
+
+  if (
+    ignoreReplacementsOfMatchedComposites ||
+    ignoreReplacementsOfEncounteredComposites
+  ) {
+    // first check if have matched any composites, so can ignore their replacements
+    let namesToIgnore = [];
+    for (let child of childrenToCheck) {
+      let checkChildForReplacements = matchChildToTypes(child);
+      if (
+        ignoreReplacementsOfEncounteredComposites &&
+        !checkChildForReplacements
+      ) {
+        // we explicitly will not ignore replacements of copies of external content
+        checkChildForReplacements = !(
+          child.componentType === "copy" && child.doenetAttributes.copiedURI
+        );
+      }
+      if (
+        checkChildForReplacements &&
+        componentInfoObjects.isInheritedComponentType({
+          inheritedComponentType: child.componentType,
+          baseComponentType: "_composite",
+        })
+      ) {
+        namesToIgnore = [
+          ...namesToIgnore,
+          ...replacementsForComposites({
+            composite: child,
+            componentInfoObjects,
+            includeComposites: true,
+          })
+            .filter((x) => typeof x === "object")
+            .map((x) => (x.componentName ? x.componentName : x.placeholderInd)),
+        ];
+      }
+    }
+
+    if (namesToIgnore.length > 0) {
+      childrenToCheck = childrenToCheck.filter(
+        (x) =>
+          !(
+            namesToIgnore.includes(x.componentName) ||
+            namesToIgnore.includes(x.placeholderInd)
+          ),
+      );
+    }
+  }
+
+  let descendants = [];
+
+  for (let child of childrenToCheck) {
+    let matchedChild = matchChildToTypes(child);
+    if (matchedChild) {
+      descendants.push({
+        componentName: child.componentName
+          ? child.componentName
+          : child.placeholderInd,
+        componentType: child.componentType,
+      });
+    }
+
+    if (
+      (!matchedChild || recurseToMatchedChildren) &&
+      child.placeholderInd === undefined
+    ) {
+      // recurse
+      let additionalDescendants = gatherDescendants({
+        ancestor: child,
+        descendantTypes,
+        recurseToMatchedChildren,
+        useReplacementsForComposites,
+        includeNonActiveChildren,
+        skipOverAdapters,
+        ignoreReplacementsOfMatchedComposites,
+        ignoreReplacementsOfEncounteredComposites,
+        init: false,
+        componentInfoObjects,
+      });
+      descendants.push(...additionalDescendants);
+    }
+  }
+
+  return descendants;
+}
+
+function replacementsForComposites({
+  composite,
+  includeComposites = false,
+  componentInfoObjects,
+}) {
+  let replacements = [];
+
+  if (composite.replacements) {
+    let originalReplacements;
+    if (composite.replacementsToWithhold) {
+      let numReplacements =
+        composite.replacements.length - composite.replacementsToWithhold;
+      originalReplacements = composite.replacements.slice(0, numReplacements);
+    } else {
+      originalReplacements = composite.replacements;
+    }
+
+    for (let replacement of originalReplacements) {
+      if (
+        componentInfoObjects.isInheritedComponentType({
+          inheritedComponentType: replacement.componentType,
+          baseComponentType: "_composite",
+        })
+      ) {
+        if (includeComposites) {
+          replacements.push(replacement);
+        }
+        replacements.push(
+          ...replacementsForComposites({
+            composite: replacement,
+            componentInfoObjects,
+            includeComposites,
+          }),
+        );
+      } else {
+        replacements.push(replacement);
+      }
+    }
+  }
+
+  return replacements;
+}
+
+export function ancestorsIncludingComposites(comp, components) {
+  if (comp.ancestors === undefined || comp.ancestors.length === 0) {
+    return [];
+  }
+
+  let comps = [comp.ancestors[0].componentName];
+
+  let parent = components[comp.ancestors[0].componentName];
+  if (parent) {
+    comps.push(...ancestorsIncludingComposites(parent, components));
+  }
+
+  if (comp.replacementOf) {
+    comps.push(comp.replacementOf.componentName);
+    let replacementAs = ancestorsIncludingComposites(
+      comp.replacementOf,
+      components,
+    );
+    for (let a of replacementAs) {
+      if (!comps.includes(a)) {
+        comps.push(a);
+      }
+    }
+  }
+
+  return comps;
+}

package/src/Core/utils/enumeration.js

@@ -0,0 +1,234 @@
+import me from "math-expressions";
+
+// Enumerates the unique combinations of repeeated selecting an index
+// from the same set of options, with or without replacement
+// The number of options to choose from is numberOfOptions
+// so that each index is an integer between 0 and numberOfOptions-1
+// The number of indices to choose for each combination is numberOfIndices.
+// Begins with combinations that contain distinct indices, if possible
+// Returns a maximum of maxNumber
+export function enumerateSelectionCombinations({
+  numberOfIndices,
+  numberOfOptions,
+  maxNumber = Infinity,
+  withReplacement = false,
+  skipZero = false, // for case when generating offsets but without replacement
+}) {
+  if (numberOfIndices === 1) {
+    let options = [...Array(numberOfOptions).keys()];
+    // remove zero
+    options = options.slice(1);
+    if (!skipZero) {
+      // but put 0 last (so in recursion where the numbers are offsets, repeated combination is last)
+      options = [...options, 0];
+    }
+    options = options.slice(0, maxNumber);
+    // convert to array of arrays
+    options = options.map((x) => [x]);
+    return options;
+  }
+
+  let allOffsetsCombinations = enumerateSelectionCombinations({
+    numberOfIndices: numberOfIndices - 1,
+    numberOfOptions: numberOfOptions,
+    maxNumber,
+    withReplacement,
+    skipZero: !withReplacement,
+  });
+
+  let results = [];
+  let numberSoFar = 0;
+  for (let offsets of allOffsetsCombinations) {
+    for (let ind0 = 1; ind0 <= numberOfOptions; ind0++) {
+      let combination = [
+        ind0 % numberOfOptions,
+        ...offsets.map((x) => (ind0 + x) % numberOfOptions),
+      ];
+      if (skipZero && combination.includes(0)) {
+        continue;
+      }
+      results.push(combination);
+      numberSoFar++;
+      if (numberSoFar >= maxNumber) {
+        return results;
+      }
+    }
+  }
+
+  return results;
+}
+
+// Enumerate the unique combinations of picking a set of indices
+// The number of possible options for each index is given
+// by the array numberOfOptionsByIndex
+// whose length gives the total number of options
+// Returns an array of arrays, where each array gives an index for each option
+// Returns at most maxNumber of combinations
+export function enumerateCombinations({
+  numberOfOptionsByIndex,
+  maxNumber = Infinity,
+}) {
+  let numberOfIndices = numberOfOptionsByIndex.length;
+
+  if (numberOfIndices === 0) {
+    return [];
+  }
+
+  let gcds = [];
+  for (let ind1 = 0; ind1 < numberOfIndices; ind1++) {
+    let g = [];
+    for (let ind2 = 0; ind2 < ind1; ind2++) {
+      g.push(
+        me.math.gcd(numberOfOptionsByIndex[ind1], numberOfOptionsByIndex[ind2]),
+      );
+    }
+    gcds.push(g);
+  }
+
+  // flatten and take max
+  let maxGCD = gcds
+    .reduce((a, c) => [...c, ...a], [])
+    .reduce((a, c) => Math.max(a, c), 1);
+
+  // if maxGCD is one, then can just sequentially pick the same component for each index
+  // (mod the size)
+  // and we encounter every possibility
+  if (maxGCD === 1) {
+    let totalCombinations = numberOfOptionsByIndex.reduce((a, c) => a * c);
+    totalCombinations = Math.min(totalCombinations, maxNumber);
+    let results = [];
+    for (let ind = 0; ind < totalCombinations; ind++) {
+      let r = numberOfOptionsByIndex.map((x) => ind % x);
+      results.push(r);
+    }
+    return results;
+  }
+
+  // if have two indices, then run sequentially for lcm,
+  // then shift second index and run sequentially for another lcm
+  // if continue gcd times, will have all combinations
+  if (numberOfIndices === 2) {
+    let gcd = maxGCD;
+    let lcm = me.math.lcm(...numberOfOptionsByIndex);
+
+    let results = [];
+    let numberSoFar = 0;
+    for (let offset = 0; offset < gcd; offset++) {
+      for (let ind = 0; ind < lcm; ind++) {
+        let r = [
+          ind % numberOfOptionsByIndex[0],
+          (ind + offset) % numberOfOptionsByIndex[1],
+        ];
+        results.push(r);
+        numberSoFar++;
+        if (numberSoFar >= maxNumber) {
+          return results;
+        }
+      }
+    }
+    return results;
+  }
+
+  // if have more than 2 indices and gcd isn't one
+  // then combine two together (which can treat with above case)
+  // and recurse with the result that has one fewer index
+  // (will need to splice together final result)
+
+  // will combine the first pair encountered that, along with gcd > 1,
+  // has the smallest least common multiple
+  let lcms = [];
+  for (let ind1 = 0; ind1 < numberOfIndices; ind1++) {
+    let m = [];
+    for (let ind2 = 0; ind2 < ind1; ind2++) {
+      if (gcds[ind1][ind2] > 1) {
+        m.push(
+          me.math.lcm(
+            numberOfOptionsByIndex[ind1],
+            numberOfOptionsByIndex[ind2],
+          ),
+        );
+      } else {
+        m.push(null); // be sure to skip those with gcd == 1
+      }
+    }
+    lcms.push(m);
+  }
+
+  // flatten and take min, filering out the nulls
+  let minLCM = lcms
+    .reduce((a, c) => [...c, ...a], [])
+    .filter((x) => x !== null)
+    .reduce((a, c) => Math.min(a, c), Infinity);
+
+  // find indices where minimum occurs
+  let matchInds;
+
+  for (let ind1 = 0; ind1 < numberOfIndices; ind1++) {
+    for (let ind2 = 0; ind2 < ind1; ind2++) {
+      if (lcms[ind1][ind2] === minLCM) {
+        matchInds = [ind2, ind1]; // want lowest index first
+        break;
+      }
+    }
+    if (matchInds) {
+      break;
+    }
+  }
+
+  // create new options of just the matched results
+  let n0 = numberOfOptionsByIndex[matchInds[0]];
+  let n1 = numberOfOptionsByIndex[matchInds[1]];
+
+  let innerOptions = [n0, n1];
+
+  // create new options where replace matched results with single one
+  // that has number of options set equal to the total number of inner options (n1*n2)
+  let outerOptions = [...numberOfOptionsByIndex];
+  outerOptions[matchInds[0]] = n0 * n1; // replace first with total number of combinations
+  outerOptions.splice(matchInds[1], 1); // delete second matched ind
+
+  let outerResult = enumerateCombinations({
+    numberOfOptionsByIndex: outerOptions,
+    maxNumber: maxNumber,
+  });
+  let innerResult = enumerateCombinations({
+    numberOfOptionsByIndex: innerOptions,
+    maxNumber: maxNumber,
+  });
+
+  // to splice back together
+  // - replace the combined entry (which is at the lower index)
+  //   with the first inner result
+  // - insert in the second inner result at the larger index
+  for (let r of outerResult) {
+    let ires = innerResult[r[matchInds[0]]];
+    r.splice(matchInds[0], 1, ires[0]);
+    r.splice(matchInds[1], 0, ires[1]);
+  }
+
+  return outerResult;
+}
+
+// from https://stackoverflow.com/a/20871714
+export function enumeratePermutations({ values, maxNumber }) {
+  let result = [];
+
+  const permute = (arr, m = []) => {
+    if (arr.length === 0) {
+      result.push(m);
+    } else {
+      for (let i = 0; i < arr.length; i++) {
+        let curr = arr.slice();
+        let next = curr.splice(i, 1);
+        permute(curr.slice(), m.concat(next));
+        if (result.length >= maxNumber) {
+          return;
+        }
+      }
+    }
+  };
+
+  permute(values);
+
+  return result;
+}