@doenet/doenetml 0.6.0-alpha1

package/src/utils/array.js

@@ -0,0 +1,17 @@
+
+// from: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/flat
+export function flattenDeep(arr1) {
+  return arr1.reduce((acc, val) => Array.isArray(val) ? acc.concat(flattenDeep(val)) : acc.concat(val), []);
+}
+
+export function flattenLevels(arr1, levels) {
+  console.log(`levels: ${levels}`)
+  return arr1.reduce((acc, val) => Array.isArray(val) && levels > 1 ? acc.concat(flattenLevels(val, levels - 1)) : acc.concat(val), []);
+}
+
+export function mapDeep(arr, f, iprefix = [], origArr) {
+  if(!origArr) {
+    origArr = arr;
+  }
+  return arr.map((v, i) => Array.isArray(v) ? mapDeep(v, f, [...iprefix, i], origArr) : f(v, [...iprefix, i], origArr));
+}

package/src/utils/cid.js

@@ -0,0 +1,34 @@
+import base32 from 'hi-base32';
+
+
+export async function cidFromText(text) {
+
+  let encoder = new TextEncoder();
+  let data = encoder.encode(text);
+
+  return await cidFromArrayBuffer(data);
+
+}
+
+export async function cidFromArrayBuffer(data) {
+
+  let hashBuffer = await crypto.subtle.digest("SHA-256", data);
+
+  let cidArray = new Uint8Array(36);
+
+  // 0x01: cidV1
+  // 0x55: raw binary IPLD
+  // 0x12: code for SHA256
+  // 0x20: 32 bytes (or 256 bits)
+  cidArray.set([0x01, 0x55, 0x12, 0x20]);
+
+  cidArray.set(new Uint8Array(hashBuffer), 4);
+
+  // b: prefix for base 32
+  // base32: hi-base uses RFC 4648 encoding
+  // cid uses lowercase letter and does not include the padding at the end
+  let cid = 'b' + base32.encode(cidArray).toLowerCase().replace(/=+/, "");
+
+  return cid;
+
+}

package/src/utils/componentInfoObjects.js

@@ -0,0 +1,89 @@
+// import * as ComponentTypes from '../ComponentTypes'
+let ComponentTypes= {};
+
+export default function createComponentInfoObjects() {
+
+  let allComponentClasses = ComponentTypes.allComponentClasses();
+  let componentTypesCreatingVariants = ComponentTypes.componentTypesCreatingVariants();
+
+  let componentTypeLowerCaseMapping = {};
+  for (let componentType in allComponentClasses) {
+    componentTypeLowerCaseMapping[componentType.toLowerCase()] = componentType;
+  }
+
+  let stateVariableInfo = {};
+  for (let componentType in allComponentClasses) {
+    Object.defineProperty(stateVariableInfo, componentType, {
+      get: function () {
+        let info = allComponentClasses[componentType].returnStateVariableInfo();
+        delete stateVariableInfo[componentType];
+        return stateVariableInfo[componentType] = info;
+      }.bind(this),
+      configurable: true
+    })
+  }
+
+  let publicStateVariableInfo = {};
+  for (let componentType in allComponentClasses) {
+    Object.defineProperty(publicStateVariableInfo, componentType, {
+      get: function () {
+        let info = allComponentClasses[componentType].returnStateVariableInfo({
+          onlyPublic: true
+        });
+        delete publicStateVariableInfo[componentType];
+        return publicStateVariableInfo[componentType] = info;
+      }.bind(this),
+      configurable: true
+    })
+  }
+
+
+  function isInheritedComponentType({ inheritedComponentType, baseComponentType }) {
+    if (inheritedComponentType === baseComponentType) {
+      return true;
+    }
+    if (inheritedComponentType === "string") {
+      return baseComponentType === "_base" || baseComponentType === "_inline";
+    } else if (baseComponentType === "string") {
+      return false;
+    }
+
+    let baseClass = allComponentClasses[baseComponentType];
+    if (!baseClass) {
+      return false;
+    }
+    return baseClass.isPrototypeOf(
+      allComponentClasses[inheritedComponentType]
+    );
+  }
+
+
+  function isCompositeComponent({ componentType, includeNonStandard = true }) {
+    let componentClass = allComponentClasses[componentType];
+    if (!componentClass) {
+      return false;
+    }
+
+    let isComposite = isInheritedComponentType({
+      inheritedComponentType: componentType,
+      baseComponentType: "_composite"
+    })
+
+    return isComposite &&
+      (includeNonStandard || !componentClass.treatAsComponentForRecursiveReplacements)
+  }
+
+
+  return {
+    allComponentClasses,
+    componentTypesCreatingVariants,
+    componentTypeLowerCaseMapping,
+    isInheritedComponentType,
+    isCompositeComponent,
+    stateVariableInfo,
+    publicStateVariableInfo
+  };
+
+
+}
+

package/src/utils/deepFunctions.js

@@ -0,0 +1,165 @@
+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/utils/enumeration.js

@@ -0,0 +1,226 @@
+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;
+}