@doenet/doenetml 0.6.0-alpha1

package/src/Core/utils/retrieveTextFile.js

@@ -0,0 +1,140 @@
+import { cidFromText } from "./cid";
+
+const textByCid = {};
+
+export function retrieveTextFileForCid(cid, ext = "doenet") {
+  if (textByCid[cid] !== undefined) {
+    return Promise.resolve(textByCid[cid]);
+  }
+
+  return new Promise((resolve, reject) => {
+    // immediately start trying to retrieve from IPFS
+    let resultIPFS = retrieveTextFileFromIPFS(cid);
+
+    let promiseIPFS = resultIPFS.promise;
+    let controllerIPFS = resultIPFS.controller;
+
+    let controllerServer;
+
+    let rejectedIPFS = false;
+    let rejectedServer = false;
+
+    let timeoutId;
+
+    promiseIPFS
+      .then((res) => {
+        // if successfully retrieve from IPFS
+        // then cancel timer (for either starting the server request or waiting 5 seconds at end)
+        // and abort the server request if it is in progress
+        clearTimeout(timeoutId);
+        if (controllerServer && !rejectedServer) {
+          controllerServer.abort();
+        }
+        textByCid[cid] = res;
+        resolve(res);
+      })
+      .catch((e) => {
+        rejectedIPFS = true;
+        if (rejectedServer) {
+          // rejected from both server and IPFS
+          // so cancel the 5 second wait at the end and reject
+          clearTimeout(timeoutId);
+          reject(e);
+        }
+      });
+
+    timeoutId = setTimeout(() => {
+      // if the timer wasn't cleared then IPFS has not yet retrieved
+      // so start retrieving from the server
+      let resultServer = retrieveTextFileFromServer(cid, ext);
+
+      let promiseServer = resultServer.promise;
+      controllerServer = resultServer.controller;
+
+      promiseServer
+        .then((res) => {
+          if (!rejectedIPFS) {
+            controllerIPFS.abort();
+          }
+          textByCid[cid] = res;
+          resolve(res);
+        })
+        .catch((e) => {
+          rejectedServer = true;
+
+          if (rejectedIPFS) {
+            reject(e);
+          } else {
+            // give IPFS server 5 more seconds to retrieve
+            timeoutId = setTimeout(() => {
+              controllerIPFS.abort();
+              reject(e);
+            }, 5000);
+          }
+        });
+    }, 100);
+  });
+}
+
+function retrieveTextFileFromIPFS(cid) {
+  let controller = new AbortController();
+  let signal = controller.signal;
+
+  let retrieveFromIPFS = async function () {
+    try {
+      let response = await fetch(`https://${cid}.ipfs.dweb.link/`, { signal });
+
+      if (response.ok) {
+        let doenetML = await response.text();
+
+        let CidRetrieved = await cidFromText(doenetML);
+
+        if (CidRetrieved === cid) {
+          return doenetML;
+        } else {
+          return Promise.reject(new Error("cid mismatch"));
+        }
+      } else {
+        return Promise.reject(new Error(`cid not found: ${cid}`));
+      }
+    } catch (e) {
+      return Promise.reject(new Error(`cid not found: ${cid}`));
+    }
+  };
+
+  let promise = retrieveFromIPFS();
+
+  return { promise, controller };
+}
+
+function retrieveTextFileFromServer(cid, ext) {
+  let controller = new AbortController();
+  let signal = controller.signal;
+
+  let retrieveFromServer = async function () {
+    try {
+      let response = await fetch(`/media/${cid}.${ext}`, { signal });
+
+      if (response.ok) {
+        let doenetML = await response.text();
+
+        let CidRetrieved = await cidFromText(doenetML);
+
+        if (CidRetrieved === cid) {
+          return doenetML;
+        } else {
+          console.warn(`cid mismatch, ${cid}, ${CidRetrieved}`);
+          return Promise.reject(new Error("cid mismatch"));
+        }
+      } else {
+        return Promise.reject(new Error(`cid not found: ${cid}`));
+      }
+    } catch (e) {
+      return Promise.reject(new Error(`cid not found: ${cid}`));
+    }
+  };
+
+  let promise = retrieveFromServer();
+
+  return { promise, controller };
+}

package/src/Core/utils/returnAllPossibleVariants.js

@@ -0,0 +1,73 @@
+import { numberToLetters } from "./sequence.js";
+import * as serializeFunctions from "./serializedStateProcessing.js";
+import createComponentInfoObjects from "./componentInfoObjects.js";
+import { retrieveTextFileForCid } from "./retrieveTextFile.js";
+import { cidFromText } from "./cid.js";
+import { getNumberOfVariants } from "./variants.js";
+
+export async function returnAllPossibleVariants({ cid, doenetML }) {
+  if (doenetML === undefined) {
+    doenetML = await retrieveTextFileForCid(cid, "doenet");
+  } else if (!cid) {
+    cid = await cidFromText(doenetML);
+  }
+
+  let componentInfoObjects = createComponentInfoObjects();
+
+  let { fullSerializedComponents } =
+    await serializeFunctions.expandDoenetMLsToFullSerializedComponents({
+      contentIds: [cid],
+      doenetMLs: [doenetML],
+      componentInfoObjects,
+    });
+
+  let serializedComponents = fullSerializedComponents[0];
+
+  serializeFunctions.addDocumentIfItsMissing(serializedComponents);
+
+  let document = serializedComponents[0];
+
+  let results = getNumberOfVariants({
+    serializedComponent: document,
+    componentInfoObjects,
+  });
+
+  let numVariants = results.numberOfVariants;
+
+  let allPossibleVariants;
+
+  if (results.variantNames) {
+    let variantNames = [...results.variantNames];
+
+    if (variantNames.length >= numVariants) {
+      variantNames = variantNames.slice(0, numVariants);
+    } else {
+      let originalVariantNames = [...variantNames];
+      let variantNumber = variantNames.length;
+      let variantValue = variantNumber;
+      let variantString;
+      while (variantNumber < numVariants) {
+        variantNumber++;
+        variantValue++;
+        variantString = indexToLowercaseLetters(variantValue);
+        while (originalVariantNames.includes(variantString)) {
+          variantValue++;
+          variantString = indexToLowercaseLetters(variantValue);
+        }
+        variantNames.push(variantString);
+      }
+    }
+
+    allPossibleVariants = variantNames;
+  } else {
+    allPossibleVariants = [...Array(numVariants).keys()].map((x) =>
+      indexToLowercaseLetters(x + 1),
+    );
+  }
+
+  return { allPossibleVariants, doenetML, cid };
+}
+
+function indexToLowercaseLetters(index) {
+  return numberToLetters(index, true);
+}

package/src/Core/utils/rounding.js

@@ -0,0 +1,316 @@
+export function returnRoundingStateVariableDefinitions({
+  childsGroupIfSingleMatch = [],
+  childGroupsToStopSingleMatch = [],
+  includeListParents = false,
+  additionalAttributeComponent = null,
+  displayDigitsDefault = 3,
+  displaySmallAsZeroDefault = 1e-14,
+} = {}) {
+  let stateVariableDefinitions = {};
+
+  stateVariableDefinitions.displayDigits = {
+    public: true,
+    shadowingInstructions: {
+      createComponentOfType: "integer",
+    },
+    hasEssential: true,
+    defaultValue: displayDigitsDefault,
+    returnDependencies: roundingDependencies({
+      stateVariable: "displayDigits",
+      childsGroupIfSingleMatch,
+      childGroupsToStopSingleMatch,
+      includeIgnore: true,
+      includeListParents,
+      additionalAttributeComponent,
+    }),
+    definition: roundingDefinition({
+      stateVariable: "displayDigits",
+      valueIfIgnore: 0,
+      includeListParents,
+    }),
+  };
+
+  stateVariableDefinitions.displayDecimals = {
+    public: true,
+    shadowingInstructions: {
+      createComponentOfType: "integer",
+    },
+    hasEssential: true,
+    defaultValue: 2,
+    returnDependencies: roundingDependencies({
+      stateVariable: "displayDecimals",
+      childsGroupIfSingleMatch,
+      childGroupsToStopSingleMatch,
+      includeIgnore: true,
+      includeListParents,
+      additionalAttributeComponent,
+    }),
+    definition: roundingDefinition({
+      stateVariable: "displayDecimals",
+      valueIfIgnore: -Infinity,
+      includeListParents,
+    }),
+  };
+
+  stateVariableDefinitions.displaySmallAsZero = {
+    public: true,
+    shadowingInstructions: {
+      createComponentOfType: "number",
+    },
+    hasEssential: true,
+    defaultValue: displaySmallAsZeroDefault,
+    returnDependencies: roundingDependencies({
+      stateVariable: "displaySmallAsZero",
+      childsGroupIfSingleMatch,
+      childGroupsToStopSingleMatch,
+      includeListParents,
+      additionalAttributeComponent,
+    }),
+    definition: roundingDefinition({
+      stateVariable: "displaySmallAsZero",
+      includeListParents,
+    }),
+  };
+
+  stateVariableDefinitions.padZeros = {
+    public: true,
+    shadowingInstructions: {
+      createComponentOfType: "boolean",
+    },
+    hasEssential: true,
+    defaultValue: false,
+    returnDependencies: roundingDependencies({
+      stateVariable: "padZeros",
+      childsGroupIfSingleMatch,
+      childGroupsToStopSingleMatch,
+      includeListParents,
+      additionalAttributeComponent,
+    }),
+    definition: roundingDefinition({
+      stateVariable: "padZeros",
+      includeListParents,
+    }),
+  };
+
+  return stateVariableDefinitions;
+}
+
+function roundingDependencies({
+  stateVariable,
+  childsGroupIfSingleMatch,
+  childGroupsToStopSingleMatch,
+  includeIgnore = false,
+  includeListParents = false,
+  additionalAttributeComponent = null,
+}) {
+  return function () {
+    let dependencies = {
+      attribute: {
+        dependencyType: "attributeComponent",
+        attributeName: stateVariable,
+        variableNames: ["value"],
+      },
+      singleMatchChildren: {
+        dependencyType: "child",
+        childGroups: childsGroupIfSingleMatch,
+        variableNames: [stateVariable],
+        variablesOptional: true,
+      },
+      stopSingleMatchChildren: {
+        dependencyType: "child",
+        childGroups: childGroupsToStopSingleMatch,
+      },
+    };
+
+    if (includeListParents) {
+      dependencies.fromMathListParent = {
+        dependencyType: "parentStateVariable",
+        parentComponentType: "mathList",
+        variableName: stateVariable,
+      };
+      dependencies.fromNumberListParent = {
+        dependencyType: "parentStateVariable",
+        parentComponentType: "numberList",
+        variableName: stateVariable,
+      };
+    }
+
+    if (includeIgnore) {
+      let ignoreVariable =
+        "ignore" + stateVariable[0].toUpperCase() + stateVariable.slice(1);
+      dependencies.attributeIgnore = {
+        dependencyType: "attributeComponent",
+        attributeName: ignoreVariable,
+        variableNames: ["value"],
+        dontRecurseToShadowsIfHaveAttribute: stateVariable,
+      };
+
+      dependencies.attribute.dontRecurseToShadowsIfHaveAttribute =
+        ignoreVariable;
+    }
+
+    if (additionalAttributeComponent) {
+      dependencies.additionalAttribute = {
+        dependencyType: "attributeComponent",
+        attributeName: additionalAttributeComponent,
+        variableNames: [stateVariable],
+      };
+    }
+    return dependencies;
+  };
+}
+
+function roundingDefinition({
+  stateVariable,
+  valueIfIgnore = null,
+  includeListParents,
+}) {
+  return function ({ dependencyValues, usedDefault }) {
+    let foundDefaultValue = false;
+    let theDefaultValueFound;
+
+    if (includeListParents) {
+      if (dependencyValues.fromMathListParent !== null) {
+        if (usedDefault.fromMathListParent) {
+          foundDefaultValue = true;
+          theDefaultValueFound = dependencyValues.fromMathListParent;
+        } else {
+          // Have a mathlist parent that prescribed rounding.
+          // This overrides everything else.
+          return {
+            setValue: {
+              [stateVariable]: dependencyValues.fromMathListParent,
+            },
+          };
+        }
+      }
+
+      if (dependencyValues.fromNumberListParent !== null) {
+        if (usedDefault.fromNumberListParent) {
+          foundDefaultValue = true;
+          theDefaultValueFound = dependencyValues.fromNumberListParent;
+        } else {
+          // Have a numberlist parent that prescribed rounding.
+          // This overrides everything else.
+          return {
+            setValue: {
+              [stateVariable]: dependencyValues.fromNumberListParent,
+            },
+          };
+        }
+      }
+    }
+
+    if (dependencyValues.attribute) {
+      if (usedDefault.attribute?.value) {
+        foundDefaultValue = true;
+        theDefaultValueFound = dependencyValues.attribute.stateValues.value;
+      } else {
+        return {
+          setValue: {
+            [stateVariable]: dependencyValues.attribute.stateValues.value,
+          },
+        };
+      }
+    } else if (dependencyValues.attributeIgnore?.stateValues.value) {
+      if (usedDefault.attributeIgnore?.value) {
+        foundDefaultValue = true;
+        theDefaultValueFound = valueIfIgnore;
+      } else {
+        return {
+          setValue: {
+            [stateVariable]: valueIfIgnore,
+          },
+        };
+      }
+    } else if (dependencyValues.additionalAttribute) {
+      if (usedDefault.additionalAttribute?.[stateVariable]) {
+        foundDefaultValue = true;
+        theDefaultValueFound =
+          dependencyValues.additionalAttribute.stateValues[stateVariable];
+      } else {
+        return {
+          setValue: {
+            [stateVariable]:
+              dependencyValues.additionalAttribute.stateValues[stateVariable],
+          },
+        };
+      }
+    }
+
+    if (
+      dependencyValues.singleMatchChildren.length === 1 &&
+      dependencyValues.stopSingleMatchChildren.length === 0 &&
+      dependencyValues.singleMatchChildren[0].stateValues[stateVariable] !==
+        undefined
+    ) {
+      if (usedDefault.singleMatchChildren[0]?.[stateVariable]) {
+        foundDefaultValue = true;
+        theDefaultValueFound =
+          dependencyValues.singleMatchChildren[0].stateValues[stateVariable];
+      } else {
+        return {
+          setValue: {
+            [stateVariable]:
+              dependencyValues.singleMatchChildren[0].stateValues[
+                stateVariable
+              ],
+          },
+        };
+      }
+    }
+
+    if (foundDefaultValue) {
+      return {
+        useEssentialOrDefaultValue: {
+          [stateVariable]: { defaultValue: theDefaultValueFound },
+        },
+      };
+    } else {
+      return { useEssentialOrDefaultValue: { [stateVariable]: true } };
+    }
+  };
+}
+
+export function returnRoundingAttributes() {
+  return {
+    displayDigits: {
+      createComponentOfType: "integer",
+    },
+    ignoreDisplayDigits: {
+      createComponentOfType: "boolean",
+    },
+    displayDecimals: {
+      createComponentOfType: "integer",
+    },
+    ignoreDisplayDecimals: {
+      createComponentOfType: "boolean",
+    },
+    displaySmallAsZero: {
+      createComponentOfType: "number",
+      valueForTrue: 1e-14,
+      valueForFalse: 0,
+    },
+    padZeros: {
+      createComponentOfType: "boolean",
+    },
+  };
+}
+
+// since state variable values are computed using more than attributes,
+// (such as children or parents)
+// we need to send the actual state variables as the attributes
+// when shadowing public state variables
+export function returnRoundingAttributeComponentShadowing() {
+  let shadowing = {};
+  for (let stateVariable in returnRoundingStateVariableDefinitions()) {
+    shadowing[stateVariable] = {
+      stateVariableToShadow: stateVariable,
+      // if used in an array state variable that has wrapping components
+      // add the attribute to the outer component
+      // rather than the inner components (the default)
+      addToOuterIfWrappedArray: true,
+    };
+  }
+  return shadowing;
+}