@superbuilders/primer-tives 0.3.2 → 0.5.0

package/dist/index.js

@@ -1,5 +1,5 @@
 // src/client.ts
-import * as errors8 from "@superbuilders/errors";
+import * as errors10 from "@superbuilders/errors";
 
 // src/errors.ts
 import * as errors from "@superbuilders/errors";
@@ -131,7 +131,7 @@ function createTransport(tc) {
 }
 
 // src/session.ts
-import * as errors7 from "@superbuilders/errors";
+import * as errors9 from "@superbuilders/errors";
 
 // src/consumed.ts
 function poisonToJSON() {
@@ -173,7 +173,45 @@ function validateChoiceSubmission(log, selectedKeys, options, maxChoices, minCho
   return null;
 }
 function choiceState(ctx, stimulus, interaction, options, maxChoices, minChoices) {
-  let pending;
+  let submitPending;
+  let submitKey;
+  let timeoutPending;
+  function beginSubmit(selectedKeys) {
+    const submission = { type: "choice", selectedKeys };
+    const key = JSON.stringify(submission);
+    if (timeoutPending) {
+      return Promise.resolve(ctx.errored(errors3.wrap(ErrConflict, "cannot submit while timeout is in flight"), "interaction", { kind: "interaction", submission }));
+    }
+    if (submitPending) {
+      if (submitKey === key) {
+        return submitPending;
+      }
+      return Promise.resolve(ctx.errored(errors3.wrap(ErrConflict, "cannot submit a different choice payload while submit is in flight"), "interaction", { kind: "interaction", submission }));
+    }
+    const validationError = validateChoiceSubmission(ctx.log, selectedKeys, options, maxChoices, minChoices);
+    if (validationError) {
+      return Promise.resolve(ctx.errored(validationError, "interaction", { kind: "interaction", submission }));
+    }
+    submitKey = key;
+    submitPending = ctx.execute({ kind: "interaction", submission }, "interaction").finally(function clearPending() {
+      submitPending = undefined;
+      submitKey = undefined;
+    });
+    return submitPending;
+  }
+  function beginTimeout() {
+    const intent = { kind: "timeout" };
+    if (submitPending) {
+      return Promise.resolve(ctx.errored(errors3.wrap(ErrConflict, "cannot timeout while submission is in flight"), "timeout", intent));
+    }
+    if (timeoutPending) {
+      return timeoutPending;
+    }
+    timeoutPending = ctx.execute(intent, "timeout").finally(function clearPending() {
+      timeoutPending = undefined;
+    });
+    return timeoutPending;
+  }
   return {
     phase: "interaction",
     kind: "choice",
@@ -182,27 +220,8 @@ function choiceState(ctx, stimulus, interaction, options, maxChoices, minChoices
     options,
     maxChoices,
     minChoices,
-    submitChoice: function submitChoice(selectedKeys) {
-      if (pending) {
-        return pending;
-      }
-      const validationError = validateChoiceSubmission(ctx.log, selectedKeys, options, maxChoices, minChoices);
-      if (validationError) {
-        return Promise.resolve(ctx.errored(validationError, "interaction", {
-          kind: "interaction",
-          submission: { type: "choice", selectedKeys }
-        }));
-      }
-      pending = ctx.execute({ kind: "interaction", submission: { type: "choice", selectedKeys } }, "interaction");
-      return pending;
-    },
-    timeout: function timeout() {
-      if (pending) {
-        return pending;
-      }
-      pending = ctx.execute({ kind: "timeout" }, "timeout");
-      return pending;
-    },
+    submitChoice: beginSubmit,
+    timeout: beginTimeout,
     toJSON: poisonToJSON
   };
 }
@@ -222,66 +241,107 @@ function validateExtendedTextSubmission(log, values, minStrings, maxStrings) {
 }
 function extendedTextState(ctx, stimulus, interaction) {
   if (interaction.cardinality === "single") {
-    let pending2;
+    let submitText = function(value) {
+      const submission = { type: "extended-text", values: [value] };
+      const key = JSON.stringify(submission);
+      if (timeoutPending2) {
+        return Promise.resolve(ctx.errored(errors4.wrap(ErrConflict, "cannot submit while timeout is in flight"), "interaction", { kind: "interaction", submission }));
+      }
+      if (submitPending2) {
+        if (submitKey2 === key) {
+          return submitPending2;
+        }
+        return Promise.resolve(ctx.errored(errors4.wrap(ErrConflict, "cannot submit a different extended-text payload while submit is in flight"), "interaction", { kind: "interaction", submission }));
+      }
+      submitKey2 = key;
+      submitPending2 = ctx.execute({ kind: "interaction", submission }, "interaction").finally(function clearPending() {
+        submitPending2 = undefined;
+        submitKey2 = undefined;
+      });
+      return submitPending2;
+    }, timeout2 = function() {
+      const intent = { kind: "timeout" };
+      if (submitPending2) {
+        return Promise.resolve(ctx.errored(errors4.wrap(ErrConflict, "cannot timeout while submission is in flight"), "timeout", intent));
+      }
+      if (timeoutPending2) {
+        return timeoutPending2;
+      }
+      timeoutPending2 = ctx.execute(intent, "timeout").finally(function clearPending() {
+        timeoutPending2 = undefined;
+      });
+      return timeoutPending2;
+    };
+    let submitPending2;
+    let submitKey2;
+    let timeoutPending2;
     return {
       phase: "interaction",
       kind: "extended-text",
       cardinality: "single",
       stimulus,
       interaction,
-      submitText: function submitText(value) {
-        if (pending2) {
-          return pending2;
-        }
-        pending2 = ctx.execute({ kind: "interaction", submission: { type: "extended-text", values: [value] } }, "interaction");
-        return pending2;
-      },
-      timeout: function timeout() {
-        if (pending2) {
-          return pending2;
-        }
-        pending2 = ctx.execute({ kind: "timeout" }, "timeout");
-        return pending2;
-      },
+      submitText,
+      timeout: timeout2,
       toJSON: poisonToJSON
     };
   }
-  let pending;
+  const multi = interaction;
+  let submitPending;
+  let submitKey;
+  let timeoutPending;
+  function submitTexts(values) {
+    const submission = { type: "extended-text", values };
+    const key = JSON.stringify(submission);
+    if (timeoutPending) {
+      return Promise.resolve(ctx.errored(errors4.wrap(ErrConflict, "cannot submit while timeout is in flight"), "interaction", { kind: "interaction", submission }));
+    }
+    if (submitPending) {
+      if (submitKey === key) {
+        return submitPending;
+      }
+      return Promise.resolve(ctx.errored(errors4.wrap(ErrConflict, "cannot submit a different extended-text payload while submit is in flight"), "interaction", { kind: "interaction", submission }));
+    }
+    const validationError = validateExtendedTextSubmission(ctx.log, values, multi.minStrings, multi.maxStrings);
+    if (validationError) {
+      return Promise.resolve(ctx.errored(validationError, "interaction", { kind: "interaction", submission }));
+    }
+    submitKey = key;
+    submitPending = ctx.execute({ kind: "interaction", submission }, "interaction").finally(function clearPending() {
+      submitPending = undefined;
+      submitKey = undefined;
+    });
+    return submitPending;
+  }
+  function timeout() {
+    const intent = { kind: "timeout" };
+    if (submitPending) {
+      return Promise.resolve(ctx.errored(errors4.wrap(ErrConflict, "cannot timeout while submission is in flight"), "timeout", intent));
+    }
+    if (timeoutPending) {
+      return timeoutPending;
+    }
+    timeoutPending = ctx.execute(intent, "timeout").finally(function clearPending() {
+      timeoutPending = undefined;
+    });
+    return timeoutPending;
+  }
   return {
     phase: "interaction",
     kind: "extended-text",
     cardinality: "multiple",
     stimulus,
-    interaction,
-    maxStrings: interaction.maxStrings,
-    minStrings: interaction.minStrings,
-    submitTexts: function submitTexts(values) {
-      if (pending) {
-        return pending;
-      }
-      const validationError = validateExtendedTextSubmission(ctx.log, values, interaction.minStrings, interaction.maxStrings);
-      if (validationError) {
-        return Promise.resolve(ctx.errored(validationError, "interaction", {
-          kind: "interaction",
-          submission: { type: "extended-text", values }
-        }));
-      }
-      pending = ctx.execute({ kind: "interaction", submission: { type: "extended-text", values } }, "interaction");
-      return pending;
-    },
-    timeout: function timeout() {
-      if (pending) {
-        return pending;
-      }
-      pending = ctx.execute({ kind: "timeout" }, "timeout");
-      return pending;
-    },
+    interaction: multi,
+    maxStrings: multi.maxStrings,
+    minStrings: multi.minStrings,
+    submitTexts,
+    timeout,
     toJSON: poisonToJSON
   };
 }
 
 // src/feedback-state.ts
-function feedbackState(ctx, stimulus, interaction, submission, isCorrect, feedbackContent, correctAnswer) {
+function feedbackState(ctx, stimulus, interaction, submission, isCorrect, feedbackContent, review) {
   let pending;
   return {
     phase: "feedback",
@@ -290,7 +350,7 @@ function feedbackState(ctx, stimulus, interaction, submission, isCorrect, feedba
     submission,
     isCorrect,
     feedbackContent,
-    correctAnswer,
+    review,
     advance: function advance() {
       if (pending) {
         return pending;
@@ -391,7 +451,45 @@ function validateMatchSubmission(log, pairs, sourceChoices, targetChoices, minAs
   return null;
 }
 function matchState(ctx, stimulus, interaction) {
-  let pending;
+  let submitPending;
+  let submitKey;
+  let timeoutPending;
+  function submitMatch(pairs) {
+    const submission = { type: "match", pairs };
+    const key = JSON.stringify(submission);
+    if (timeoutPending) {
+      return Promise.resolve(ctx.errored(errors5.wrap(ErrConflict, "cannot submit while timeout is in flight"), "interaction", { kind: "interaction", submission }));
+    }
+    if (submitPending) {
+      if (submitKey === key) {
+        return submitPending;
+      }
+      return Promise.resolve(ctx.errored(errors5.wrap(ErrConflict, "cannot submit a different match payload while submit is in flight"), "interaction", { kind: "interaction", submission }));
+    }
+    const validationError = validateMatchSubmission(ctx.log, pairs, interaction.sourceChoices, interaction.targetChoices, interaction.minAssociations, interaction.maxAssociations);
+    if (validationError) {
+      return Promise.resolve(ctx.errored(validationError, "interaction", { kind: "interaction", submission }));
+    }
+    submitKey = key;
+    submitPending = ctx.execute({ kind: "interaction", submission }, "interaction").finally(function clearPending() {
+      submitPending = undefined;
+      submitKey = undefined;
+    });
+    return submitPending;
+  }
+  function timeout() {
+    const intent = { kind: "timeout" };
+    if (submitPending) {
+      return Promise.resolve(ctx.errored(errors5.wrap(ErrConflict, "cannot timeout while submission is in flight"), "timeout", intent));
+    }
+    if (timeoutPending) {
+      return timeoutPending;
+    }
+    timeoutPending = ctx.execute(intent, "timeout").finally(function clearPending() {
+      timeoutPending = undefined;
+    });
+    return timeoutPending;
+  }
   return {
     phase: "interaction",
     kind: "match",
@@ -401,27 +499,8 @@ function matchState(ctx, stimulus, interaction) {
     targetChoices: interaction.targetChoices,
     minAssociations: interaction.minAssociations,
     maxAssociations: interaction.maxAssociations,
-    submitMatch: function submitMatch(pairs) {
-      if (pending) {
-        return pending;
-      }
-      const validationError = validateMatchSubmission(ctx.log, pairs, interaction.sourceChoices, interaction.targetChoices, interaction.minAssociations, interaction.maxAssociations);
-      if (validationError) {
-        return Promise.resolve(ctx.errored(validationError, "interaction", {
-          kind: "interaction",
-          submission: { type: "match", pairs }
-        }));
-      }
-      pending = ctx.execute({ kind: "interaction", submission: { type: "match", pairs } }, "interaction");
-      return pending;
-    },
-    timeout: function timeout() {
-      if (pending) {
-        return pending;
-      }
-      pending = ctx.execute({ kind: "timeout" }, "timeout");
-      return pending;
-    },
+    submitMatch,
+    timeout,
     toJSON: poisonToJSON
   };
 }
@@ -478,7 +557,45 @@ function validateOrderSubmission(log, orderedKeys, choices, minChoices, maxChoic
   return null;
 }
 function orderState(ctx, stimulus, interaction) {
-  let pending;
+  let submitPending;
+  let submitKey;
+  let timeoutPending;
+  function submitOrder(orderedKeys) {
+    const submission = { type: "order", orderedKeys };
+    const key = JSON.stringify(submission);
+    if (timeoutPending) {
+      return Promise.resolve(ctx.errored(errors6.wrap(ErrConflict, "cannot submit while timeout is in flight"), "interaction", { kind: "interaction", submission }));
+    }
+    if (submitPending) {
+      if (submitKey === key) {
+        return submitPending;
+      }
+      return Promise.resolve(ctx.errored(errors6.wrap(ErrConflict, "cannot submit a different order payload while submit is in flight"), "interaction", { kind: "interaction", submission }));
+    }
+    const validationError = validateOrderSubmission(ctx.log, orderedKeys, interaction.choices, interaction.minChoices, interaction.maxChoices);
+    if (validationError) {
+      return Promise.resolve(ctx.errored(validationError, "interaction", { kind: "interaction", submission }));
+    }
+    submitKey = key;
+    submitPending = ctx.execute({ kind: "interaction", submission }, "interaction").finally(function clearPending() {
+      submitPending = undefined;
+      submitKey = undefined;
+    });
+    return submitPending;
+  }
+  function timeout() {
+    const intent = { kind: "timeout" };
+    if (submitPending) {
+      return Promise.resolve(ctx.errored(errors6.wrap(ErrConflict, "cannot timeout while submission is in flight"), "timeout", intent));
+    }
+    if (timeoutPending) {
+      return timeoutPending;
+    }
+    timeoutPending = ctx.execute(intent, "timeout").finally(function clearPending() {
+      timeoutPending = undefined;
+    });
+    return timeoutPending;
+  }
   return {
     phase: "interaction",
     kind: "order",
@@ -487,51 +604,52 @@ function orderState(ctx, stimulus, interaction) {
     choices: interaction.choices,
     minChoices: interaction.minChoices,
     maxChoices: interaction.maxChoices,
-    submitOrder: function submitOrder(orderedKeys) {
-      if (pending) {
-        return pending;
-      }
-      const validationError = validateOrderSubmission(ctx.log, orderedKeys, interaction.choices, interaction.minChoices, interaction.maxChoices);
-      if (validationError) {
-        return Promise.resolve(ctx.errored(validationError, "interaction", {
-          kind: "interaction",
-          submission: { type: "order", orderedKeys }
-        }));
-      }
-      pending = ctx.execute({ kind: "interaction", submission: { type: "order", orderedKeys } }, "interaction");
-      return pending;
-    },
-    timeout: function timeout() {
-      if (pending) {
-        return pending;
-      }
-      pending = ctx.execute({ kind: "timeout" }, "timeout");
-      return pending;
-    },
+    submitOrder,
+    timeout,
     toJSON: poisonToJSON
   };
 }
 
 // src/pci-state.ts
+import * as errors7 from "@superbuilders/errors";
 function pciInteractionState(ctx, stimulus, interaction) {
-  let pending;
+  let submitPending;
+  let submitKey;
+  let timeoutPending;
   const { pciId, properties } = interaction;
   function submit(value) {
-    if (pending) {
-      return pending;
+    const submission = { type: "portable-custom", pciId, value };
+    const key = JSON.stringify(submission);
+    if (timeoutPending) {
+      return Promise.resolve(ctx.errored(errors7.wrap(ErrConflict, "cannot submit while timeout is in flight"), "interaction", { kind: "interaction", submission }));
+    }
+    if (submitPending) {
+      if (submitKey === key) {
+        return submitPending;
+      }
+      return Promise.resolve(ctx.errored(errors7.wrap(ErrConflict, "cannot submit a different pci payload while submit is in flight"), "interaction", { kind: "interaction", submission }));
     }
     ctx.log?.debug("pci submit", { pciId });
-    const submission = { type: "portable-custom", pciId, value };
-    pending = ctx.execute({ kind: "interaction", submission }, "interaction");
-    return pending;
+    submitKey = key;
+    submitPending = ctx.execute({ kind: "interaction", submission }, "interaction").finally(function clearPending() {
+      submitPending = undefined;
+      submitKey = undefined;
+    });
+    return submitPending;
   }
   function timeout() {
-    if (pending) {
-      return pending;
+    const intent = { kind: "timeout" };
+    if (submitPending) {
+      return Promise.resolve(ctx.errored(errors7.wrap(ErrConflict, "cannot timeout while submission is in flight"), "timeout", intent));
+    }
+    if (timeoutPending) {
+      return timeoutPending;
     }
     ctx.log?.debug("pci timeout", { pciId });
-    pending = ctx.execute({ kind: "timeout" }, "timeout");
-    return pending;
+    timeoutPending = ctx.execute(intent, "timeout").finally(function clearPending() {
+      timeoutPending = undefined;
+    });
+    return timeoutPending;
   }
   return {
     phase: "interaction",
@@ -547,27 +665,50 @@ function pciInteractionState(ctx, stimulus, interaction) {
 }
 
 // src/text-entry-state.ts
+import * as errors8 from "@superbuilders/errors";
 function textEntryState(ctx, stimulus, interaction) {
-  let pending;
+  let submitPending;
+  let submitKey;
+  let timeoutPending;
+  function submitText(value) {
+    const submission = { type: "text-entry", value };
+    const key = JSON.stringify(submission);
+    if (timeoutPending) {
+      return Promise.resolve(ctx.errored(errors8.wrap(ErrConflict, "cannot submit while timeout is in flight"), "interaction", { kind: "interaction", submission }));
+    }
+    if (submitPending) {
+      if (submitKey === key) {
+        return submitPending;
+      }
+      return Promise.resolve(ctx.errored(errors8.wrap(ErrConflict, "cannot submit a different text payload while submit is in flight"), "interaction", { kind: "interaction", submission }));
+    }
+    submitKey = key;
+    submitPending = ctx.execute({ kind: "interaction", submission }, "interaction").finally(function clearPending() {
+      submitPending = undefined;
+      submitKey = undefined;
+    });
+    return submitPending;
+  }
+  function timeout() {
+    const intent = { kind: "timeout" };
+    if (submitPending) {
+      return Promise.resolve(ctx.errored(errors8.wrap(ErrConflict, "cannot timeout while submission is in flight"), "timeout", intent));
+    }
+    if (timeoutPending) {
+      return timeoutPending;
+    }
+    timeoutPending = ctx.execute(intent, "timeout").finally(function clearPending() {
+      timeoutPending = undefined;
+    });
+    return timeoutPending;
+  }
   return {
     phase: "interaction",
     kind: "text-entry",
     stimulus,
     interaction,
-    submitText: function submitText(value) {
-      if (pending) {
-        return pending;
-      }
-      pending = ctx.execute({ kind: "interaction", submission: { type: "text-entry", value } }, "interaction");
-      return pending;
-    },
-    timeout: function timeout() {
-      if (pending) {
-        return pending;
-      }
-      pending = ctx.execute({ kind: "timeout" }, "timeout");
-      return pending;
-    },
+    submitText,
+    timeout,
     toJSON: poisonToJSON
   };
 }
@@ -582,12 +723,15 @@ var FATAL_SENTINELS = [
 ];
 function isFatalError(err) {
   for (const sentinel of FATAL_SENTINELS) {
-    if (errors7.is(err, sentinel)) {
+    if (errors9.is(err, sentinel)) {
       return true;
     }
   }
   return false;
 }
+function isRetriableError(err) {
+  return !errors9.is(err, ErrInvalidSubmission);
+}
 function makeSession(sc) {
   const log = sc.log;
   function resolve(result) {
@@ -595,18 +739,23 @@ function makeSession(sc) {
       case "advanced":
         return fromAdvanced(result.stimulus, result.interaction);
       case "submitted":
-        return feedbackState(ctx, result.stimulus, result.interaction, result.submission, result.isCorrect, result.feedbackContent, result.correctAnswer);
+        return feedbackState(ctx, result.stimulus, result.interaction, result.submission, result.isCorrect, result.feedbackContent, result.review);
       case "completed":
         return { phase: "completed", toJSON: poisonToJSON };
     }
   }
   function errored(error, failedPhase, intent) {
     let pending;
-    return {
+    const retriable = isRetriableError(error);
+    const state = {
       phase: "errored",
       error,
-      failedPhase,
+      retriable,
       retry: function retry() {
+        if (!retriable) {
+          log?.debug("retry ignored for non-retriable error", { failedPhase });
+          return Promise.resolve(state);
+        }
         if (pending) {
           return pending;
         }
@@ -616,6 +765,7 @@ function makeSession(sc) {
       },
       toJSON: poisonToJSON
     };
+    return state;
   }
   async function execute(intent, phase) {
     const body = {
@@ -627,7 +777,7 @@ function makeSession(sc) {
     if (!result.ok) {
       if (isFatalError(result.error)) {
         log?.error("fatal transport error", { error: result.error, phase });
-        return { phase: "fatal", error: result.error, toJSON: poisonToJSON };
+        return { phase: "fatal", error: result.error, retriable: false, toJSON: poisonToJSON };
       }
       return errored(result.error, phase, intent);
     }
@@ -650,7 +800,8 @@ function makeSession(sc) {
         log?.error("unsupported pci in frame", { pciId: interaction.pciId });
         return {
           phase: "fatal",
-          error: errors7.wrap(ErrUnsupportedPci, `pci '${interaction.pciId}'`),
+          error: errors9.wrap(ErrUnsupportedPci, `pci '${interaction.pciId}'`),
+          retriable: false,
           toJSON: poisonToJSON
         };
       }
@@ -683,7 +834,7 @@ function create(config) {
   const log = config.logger;
   if (!config.publishableKey.startsWith(PK_PREFIX)) {
     log?.error("malformed publishable key", { prefix: PK_PREFIX });
-    throw errors8.wrap(ErrMalformedPublishableKey, `key must start with '${PK_PREFIX}'`);
+    throw errors10.wrap(ErrMalformedPublishableKey, `key must start with '${PK_PREFIX}'`);
   }
   const transport = createTransport({
     publishableKey: config.publishableKey,
@@ -724,7 +875,10 @@ function inlinesToPlainText(nodes) {
         parts.push(node.value);
         break;
       case "italic":
-        parts.push(inlinesToPlainText(node.children));
+        parts.push(node.value);
+        break;
+      case "latex":
+        parts.push(node.value);
         break;
     }
   }
@@ -758,4 +912,4 @@ export {
   ADVANCE_PATH
 };
 
-//# debugId=1EA25D8C44F28E9064756E2164756E21
+//# debugId=EEA07DF4CC0D714664756E2164756E21