@conform-ed/qti-react 0.0.12 → 0.0.14

package/src/index.ts

@@ -12,9 +12,70 @@ export {
   type V0InteractionKind,
 } from "./content-model";
 
-export { foldString, mapResponse, matchCorrect, scoreResponse } from "./response-processing";
+export { foldString, mapResponse, matchCorrect, mapResponsePoint, scoreResponse } from "./response-processing";
 
-export { createAttemptStore, type AttemptSnapshot, type AttemptStore } from "./store";
+export { assessmentItemViewFromNormalized, assessmentTestViewFromNormalized } from "./normalized-item";
+
+export { formatPoint, parseCoords, parsePoint, pointInShape, type Point, type QtiShape } from "./graphic";
+
+export {
+  applyCorrectResponseOverrides,
+  collectRpIssues,
+  collectTemplateIssues,
+  executeResponseProcessing,
+  executeTemplateProcessing,
+  mulberry32,
+  resolveTemplate,
+} from "./rp";
+
+export type {
+  CustomOperatorImplementation,
+  MaybeRpValue,
+  OutcomeDeclarationView,
+  OutcomeValue,
+  ResponseNormalization,
+  ResponseProcessingContext,
+  ResponseProcessingResult,
+  ResponseProcessingView,
+  RpConditionBranch,
+  RpExpressionView,
+  RpRecordField,
+  RpRuleView,
+  RpScalar,
+  RpValue,
+  TemplateConditionBranch,
+  TemplateDeclarationView,
+  TemplateProcessingContext,
+  TemplateProcessingResult,
+  TemplateProcessingView,
+  TemplateRuleView,
+} from "./rp";
+
+export { createAttemptStore, type AttemptSnapshot, type AttemptStore, type AttemptStoreOptions } from "./store";
+
+export {
+  createTestController,
+  createTestSessionStore,
+  type TestSessionSnapshot,
+  type TestSessionStore,
+  type TestSessionStoreOptions,
+  type AssessmentItemRefView,
+  type AssessmentSectionView,
+  type AssessmentTestView,
+  type BranchRuleView,
+  type ItemSessionControlView,
+  type OutcomeConditionBranch,
+  type OutcomeRuleView,
+  type TestController,
+  type TestFeedbackView,
+  type TestItemResult,
+  type TestPartView,
+  type TestPlan,
+  type TestPlanItem,
+  type TestPlanPart,
+  type TestSessionState,
+  type TimeLimitsView,
+} from "./test";
 
 export {
   createQtiRuntime,
@@ -22,12 +83,18 @@ export {
   type AssessmentItemView,
   type AttemptController,
   type BodyNode,
+  type CapabilityIssue,
+  type CapabilityIssueType,
+  type CapabilityReport,
+  type ContentRendererProps,
+  type FeedbackView,
   type InteractionDescriptor,
   type InteractionNode,
   type InteractionRenderProps,
   type InteractionSkin,
   type InteractionStatus,
   type ItemRendererProps,
+  type NodeOverrides,
   type OptionProps,
   type OptionStatus,
   type QtiRuntime,
@@ -36,9 +103,78 @@ export {
   type XmlContentNode,
 } from "./runtime";
 
-export { choiceInteraction, inlineChoiceInteraction, qtiCoreInteractions, textEntryInteraction } from "./interactions";
+export {
+  createPciModuleRegistry,
+  createPciSkin,
+  mountPci,
+  pciResponseToValue,
+  portableCustomInteraction,
+  serializePciMarkup,
+  valueToPciResponse,
+  type PciConfiguration,
+  type PciInstance,
+  type PciInteractionNode,
+  type PciModule,
+  type PciModuleRegistry,
+  type PciModuleRegistryOptions,
+  type PciMountHandle,
+  type PciMountOptions,
+  type PciSkinOptions,
+} from "./pci";
+
+export {
+  associateInteraction,
+  choiceInteraction,
+  drawingInteraction,
+  endAttemptInteraction,
+  extendedTextInteraction,
+  gapMatchInteraction,
+  graphicAssociateInteraction,
+  graphicGapMatchInteraction,
+  graphicOrderInteraction,
+  hotspotInteraction,
+  hottextInteraction,
+  inlineChoiceInteraction,
+  matchInteraction,
+  mediaInteraction,
+  orderInteraction,
+  positionObjectStage,
+  qtiCoreInteractions,
+  selectPointInteraction,
+  sliderInteraction,
+  textEntryInteraction,
+  uploadInteraction,
+} from "./interactions";
+
+export {
+  AssociateReferenceSkin,
+  ChoiceReferenceSkin,
+  DrawingReferenceSkin,
+  EndAttemptReferenceSkin,
+  ExtendedTextReferenceSkin,
+  GapMatchReferenceSkin,
+  GraphicAssociateReferenceSkin,
+  GraphicGapMatchReferenceSkin,
+  GraphicOrderReferenceSkin,
+  GraphicStage,
+  HotspotReferenceSkin,
+  HottextReferenceSkin,
+  InlineChoiceReferenceSkin,
+  MatchReferenceSkin,
+  MediaReferenceSkin,
+  OrderReferenceSkin,
+  PositionObjectReferenceSkin,
+  SelectPointReferenceSkin,
+  SliderReferenceSkin,
+  TextEntryReferenceSkin,
+  UploadReferenceSkin,
+  referenceSkin,
+  textOf,
+} from "./reference-skin";
 
 export type {
+  AreaMapEntryView,
+  AreaMappingView,
   Cardinality,
   CorrectResponseView,
   MapEntryView,

package/src/interactions/associate.ts

@@ -0,0 +1,22 @@
+import { z } from "zod";
+
+import { defineInteraction, type InteractionDescriptor } from "../runtime";
+import type { ResponseValue } from "../types";
+
+const associateInteractionNodeSchema = z.object({
+  kind: z.literal("associateInteraction"),
+  responseIdentifier: z.string().min(1),
+  simpleAssociableChoices: z
+    .array(z.looseObject({ identifier: z.string().min(1), matchMax: z.number().int().optional() }))
+    .min(2),
+  maxAssociations: z.number().int().optional(),
+});
+
+export const associateInteraction: InteractionDescriptor<"associateInteraction"> = defineInteraction({
+  kind: "associateInteraction",
+  schema: associateInteractionNodeSchema,
+  scoring: "qti-standard",
+  initialResponse(): ResponseValue {
+    return null;
+  },
+});

package/src/interactions/choice.ts

@@ -1,6 +1,6 @@
 import { z } from "zod";
 
-import { defineInteraction } from "../runtime";
+import { defineInteraction, type InteractionDescriptor } from "../runtime";
 import type { ResponseValue } from "../types";
 
 /** Minimal node shape the runtime/skin rely on; whole-item validation uses the contract. */
@@ -11,7 +11,7 @@ const choiceInteractionNodeSchema = z.object({
   maxChoices: z.number().int().optional(),
 });
 
-export const choiceInteraction = defineInteraction({
+export const choiceInteraction: InteractionDescriptor<"choiceInteraction"> = defineInteraction({
   kind: "choiceInteraction",
   schema: choiceInteractionNodeSchema,
   scoring: "qti-standard",

package/src/interactions/drawing.ts

@@ -0,0 +1,24 @@
+import { z } from "zod";
+
+import { defineInteraction, type InteractionDescriptor } from "../runtime";
+import type { ResponseValue } from "../types";
+
+const drawingInteractionNodeSchema = z.object({
+  kind: z.literal("drawingInteraction"),
+  responseIdentifier: z.string().min(1),
+  object: z.object({
+    data: z.string().min(1),
+    width: z.number().optional(),
+    height: z.number().optional(),
+    type: z.string().optional(),
+  }),
+});
+
+export const drawingInteraction: InteractionDescriptor<"drawingInteraction"> = defineInteraction({
+  kind: "drawingInteraction",
+  schema: drawingInteractionNodeSchema,
+  scoring: "qti-standard",
+  initialResponse(): ResponseValue {
+    return null;
+  },
+});

package/src/interactions/end-attempt.ts

@@ -0,0 +1,19 @@
+import { z } from "zod";
+
+import { defineInteraction, type InteractionDescriptor } from "../runtime";
+import type { ResponseValue } from "../types";
+
+const endAttemptInteractionNodeSchema = z.object({
+  kind: z.literal("endAttemptInteraction"),
+  responseIdentifier: z.string().min(1),
+  title: z.string().min(1),
+});
+
+export const endAttemptInteraction: InteractionDescriptor<"endAttemptInteraction"> = defineInteraction({
+  kind: "endAttemptInteraction",
+  schema: endAttemptInteractionNodeSchema,
+  scoring: "qti-standard",
+  initialResponse(): ResponseValue {
+    return null;
+  },
+});

package/src/interactions/extended-text.ts

@@ -0,0 +1,21 @@
+import { z } from "zod";
+
+import { defineInteraction, type InteractionDescriptor } from "../runtime";
+import type { ResponseValue } from "../types";
+
+const extendedTextInteractionNodeSchema = z.object({
+  kind: z.literal("extendedTextInteraction"),
+  responseIdentifier: z.string().min(1),
+  expectedLength: z.number().int().optional(),
+  expectedLines: z.number().int().optional(),
+  placeholderText: z.string().optional(),
+});
+
+export const extendedTextInteraction: InteractionDescriptor<"extendedTextInteraction"> = defineInteraction({
+  kind: "extendedTextInteraction",
+  schema: extendedTextInteractionNodeSchema,
+  scoring: "qti-standard",
+  initialResponse(): ResponseValue {
+    return null;
+  },
+});

package/src/interactions/gap-match.ts

@@ -0,0 +1,22 @@
+import { z } from "zod";
+
+import { defineInteraction, type InteractionDescriptor } from "../runtime";
+import type { ResponseValue } from "../types";
+
+const gapMatchInteractionNodeSchema = z.object({
+  kind: z.literal("gapMatchInteraction"),
+  responseIdentifier: z.string().min(1),
+  gapTexts: z.array(z.looseObject({ identifier: z.string().min(1), matchMax: z.number().int().optional() })).min(1),
+  // Flow content with `kind: "gap"` nodes nested anywhere inside it. Responses are
+  // directedPairs gapText→gap.
+  content: z.array(z.looseObject({ kind: z.string().min(1) })).min(1),
+});
+
+export const gapMatchInteraction: InteractionDescriptor<"gapMatchInteraction"> = defineInteraction({
+  kind: "gapMatchInteraction",
+  schema: gapMatchInteractionNodeSchema,
+  scoring: "qti-standard",
+  initialResponse(): ResponseValue {
+    return null;
+  },
+});

package/src/interactions/graphic.ts

@@ -0,0 +1,104 @@
+/**
+ * The graphic interaction family: descriptors share the object (stage image) and
+ * hotspot (shape/coords) schemas. Coordinates are numbers in image space, normalized
+ * upstream from the QTI coords attribute.
+ */
+
+import { z } from "zod";
+
+import { defineInteraction, type InteractionDescriptor } from "../runtime";
+import type { ResponseValue } from "../types";
+
+const objectSchema = z.object({
+  data: z.string().min(1),
+  width: z.number().optional(),
+  height: z.number().optional(),
+  type: z.string().optional(),
+});
+
+const hotspotSchema = z.looseObject({
+  identifier: z.string().min(1),
+  shape: z.string().min(1),
+  coords: z.array(z.number()),
+});
+
+function nullInitial(): ResponseValue {
+  return null;
+}
+
+export const hotspotInteraction: InteractionDescriptor<"hotspotInteraction"> = defineInteraction({
+  kind: "hotspotInteraction",
+  schema: z.object({
+    kind: z.literal("hotspotInteraction"),
+    responseIdentifier: z.string().min(1),
+    object: objectSchema,
+    hotspotChoices: z.array(hotspotSchema).min(1),
+    maxChoices: z.number().int().optional(),
+  }),
+  scoring: "qti-standard",
+  initialResponse: nullInitial,
+});
+
+export const graphicOrderInteraction: InteractionDescriptor<"graphicOrderInteraction"> = defineInteraction({
+  kind: "graphicOrderInteraction",
+  schema: z.object({
+    kind: z.literal("graphicOrderInteraction"),
+    responseIdentifier: z.string().min(1),
+    object: objectSchema,
+    hotspotChoices: z.array(hotspotSchema).min(1),
+  }),
+  scoring: "qti-standard",
+  initialResponse: nullInitial,
+});
+
+export const graphicAssociateInteraction: InteractionDescriptor<"graphicAssociateInteraction"> = defineInteraction({
+  kind: "graphicAssociateInteraction",
+  schema: z.object({
+    kind: z.literal("graphicAssociateInteraction"),
+    responseIdentifier: z.string().min(1),
+    object: objectSchema,
+    associableHotspots: z.array(hotspotSchema).min(2),
+    maxAssociations: z.number().int().optional(),
+  }),
+  scoring: "qti-standard",
+  initialResponse: nullInitial,
+});
+
+export const graphicGapMatchInteraction: InteractionDescriptor<"graphicGapMatchInteraction"> = defineInteraction({
+  kind: "graphicGapMatchInteraction",
+  schema: z.object({
+    kind: z.literal("graphicGapMatchInteraction"),
+    responseIdentifier: z.string().min(1),
+    object: objectSchema,
+    gapImgs: z.array(z.looseObject({ identifier: z.string().min(1), object: objectSchema.optional() })).min(1),
+    associableHotspots: z.array(hotspotSchema).min(1),
+  }),
+  scoring: "qti-standard",
+  initialResponse: nullInitial,
+});
+
+export const selectPointInteraction: InteractionDescriptor<"selectPointInteraction"> = defineInteraction({
+  kind: "selectPointInteraction",
+  schema: z.object({
+    kind: z.literal("selectPointInteraction"),
+    responseIdentifier: z.string().min(1),
+    object: objectSchema,
+    maxChoices: z.number().int().optional(),
+  }),
+  scoring: "qti-standard",
+  initialResponse: nullInitial,
+});
+
+/** The common single-interaction stage; multi-interaction stages fail validation. */
+export const positionObjectStage: InteractionDescriptor<"positionObjectStage"> = defineInteraction({
+  kind: "positionObjectStage",
+  schema: z.object({
+    kind: z.literal("positionObjectStage"),
+    responseIdentifier: z.string().min(1),
+    stageObject: objectSchema,
+    object: objectSchema,
+    maxChoices: z.number().int().optional(),
+  }),
+  scoring: "qti-standard",
+  initialResponse: nullInitial,
+});

package/src/interactions/hottext.ts

@@ -0,0 +1,21 @@
+import { z } from "zod";
+
+import { defineInteraction, type InteractionDescriptor } from "../runtime";
+import type { ResponseValue } from "../types";
+
+const hottextInteractionNodeSchema = z.object({
+  kind: z.literal("hottextInteraction"),
+  responseIdentifier: z.string().min(1),
+  maxChoices: z.number().int().optional(),
+  // Flow content with `kind: "hottext"` nodes nested anywhere inside it.
+  content: z.array(z.looseObject({ kind: z.string().min(1) })).min(1),
+});
+
+export const hottextInteraction: InteractionDescriptor<"hottextInteraction"> = defineInteraction({
+  kind: "hottextInteraction",
+  schema: hottextInteractionNodeSchema,
+  scoring: "qti-standard",
+  initialResponse(): ResponseValue {
+    return null;
+  },
+});

package/src/interactions/index.ts

@@ -1,16 +1,70 @@
 import type { InteractionDescriptor } from "../runtime";
-
+import { associateInteraction } from "./associate";
 import { choiceInteraction } from "./choice";
+import { drawingInteraction } from "./drawing";
+import { endAttemptInteraction } from "./end-attempt";
+import { extendedTextInteraction } from "./extended-text";
+import { gapMatchInteraction } from "./gap-match";
+import {
+  graphicAssociateInteraction,
+  graphicGapMatchInteraction,
+  graphicOrderInteraction,
+  hotspotInteraction,
+  positionObjectStage,
+  selectPointInteraction,
+} from "./graphic";
+import { hottextInteraction } from "./hottext";
 import { inlineChoiceInteraction } from "./inline-choice";
+import { matchInteraction } from "./match";
+import { mediaInteraction } from "./media";
+import { orderInteraction } from "./order";
+import { sliderInteraction } from "./slider";
 import { textEntryInteraction } from "./text-entry";
+import { uploadInteraction } from "./upload";
 
+export { associateInteraction } from "./associate";
 export { choiceInteraction } from "./choice";
+export { drawingInteraction } from "./drawing";
+export { endAttemptInteraction } from "./end-attempt";
+export { extendedTextInteraction } from "./extended-text";
+export { gapMatchInteraction } from "./gap-match";
+export {
+  graphicAssociateInteraction,
+  graphicGapMatchInteraction,
+  graphicOrderInteraction,
+  hotspotInteraction,
+  positionObjectStage,
+  selectPointInteraction,
+} from "./graphic";
+export { hottextInteraction } from "./hottext";
 export { inlineChoiceInteraction } from "./inline-choice";
+export { matchInteraction } from "./match";
+export { mediaInteraction } from "./media";
+export { orderInteraction } from "./order";
+export { sliderInteraction } from "./slider";
 export { textEntryInteraction } from "./text-entry";
+export { uploadInteraction } from "./upload";
 
-/** The v0 interaction set conform-ed ships; emergent assembles these plus its extensions. */
+/** The interaction set conform-ed ships; consumers assemble these plus their extensions. */
 export const qtiCoreInteractions: readonly InteractionDescriptor[] = [
+  associateInteraction,
   choiceInteraction,
-  textEntryInteraction,
+  drawingInteraction,
+  endAttemptInteraction,
+  extendedTextInteraction,
+  gapMatchInteraction,
+  graphicAssociateInteraction,
+  graphicGapMatchInteraction,
+  graphicOrderInteraction,
+  hotspotInteraction,
+  hottextInteraction,
   inlineChoiceInteraction,
+  matchInteraction,
+  mediaInteraction,
+  orderInteraction,
+  positionObjectStage,
+  selectPointInteraction,
+  sliderInteraction,
+  textEntryInteraction,
+  uploadInteraction,
 ];

package/src/interactions/inline-choice.ts

@@ -1,6 +1,6 @@
 import { z } from "zod";
 
-import { defineInteraction } from "../runtime";
+import { defineInteraction, type InteractionDescriptor } from "../runtime";
 import type { ResponseValue } from "../types";
 
 const inlineChoiceInteractionNodeSchema = z.object({
@@ -9,7 +9,7 @@ const inlineChoiceInteractionNodeSchema = z.object({
   inlineChoices: z.array(z.object({ identifier: z.string().min(1) })).min(1),
 });
 
-export const inlineChoiceInteraction = defineInteraction({
+export const inlineChoiceInteraction: InteractionDescriptor<"inlineChoiceInteraction"> = defineInteraction({
   kind: "inlineChoiceInteraction",
   schema: inlineChoiceInteractionNodeSchema,
   scoring: "qti-standard",

package/src/interactions/match.ts

@@ -0,0 +1,27 @@
+import { z } from "zod";
+
+import { defineInteraction, type InteractionDescriptor } from "../runtime";
+import type { ResponseValue } from "../types";
+
+const simpleMatchSetSchema = z.object({
+  simpleAssociableChoices: z
+    .array(z.looseObject({ identifier: z.string().min(1), matchMax: z.number().int().optional() }))
+    .min(1),
+});
+
+const matchInteractionNodeSchema = z.object({
+  kind: z.literal("matchInteraction"),
+  responseIdentifier: z.string().min(1),
+  // QTI: exactly two match sets; responses are directedPairs source→target.
+  simpleMatchSets: z.array(simpleMatchSetSchema).length(2),
+  maxAssociations: z.number().int().optional(),
+});
+
+export const matchInteraction: InteractionDescriptor<"matchInteraction"> = defineInteraction({
+  kind: "matchInteraction",
+  schema: matchInteractionNodeSchema,
+  scoring: "qti-standard",
+  initialResponse(): ResponseValue {
+    return null;
+  },
+});

package/src/interactions/media.ts

@@ -0,0 +1,24 @@
+import { z } from "zod";
+
+import { defineInteraction, type InteractionDescriptor } from "../runtime";
+import type { ResponseValue } from "../types";
+
+const mediaInteractionNodeSchema = z.object({
+  kind: z.literal("mediaInteraction"),
+  responseIdentifier: z.string().min(1),
+  autostart: z.boolean().optional(),
+  minPlays: z.number().int().optional(),
+  maxPlays: z.number().int().optional(),
+  loop: z.boolean().optional(),
+  // Flow content containing the audio/video element the interaction wraps.
+  content: z.array(z.looseObject({ kind: z.string().min(1) })).min(1),
+});
+
+export const mediaInteraction: InteractionDescriptor<"mediaInteraction"> = defineInteraction({
+  kind: "mediaInteraction",
+  schema: mediaInteractionNodeSchema,
+  scoring: "qti-standard",
+  initialResponse(): ResponseValue {
+    return null;
+  },
+});

package/src/interactions/order.ts

@@ -0,0 +1,21 @@
+import { z } from "zod";
+
+import { defineInteraction, type InteractionDescriptor } from "../runtime";
+import type { ResponseValue } from "../types";
+
+const orderInteractionNodeSchema = z.object({
+  kind: z.literal("orderInteraction"),
+  responseIdentifier: z.string().min(1),
+  simpleChoices: z.array(z.looseObject({ identifier: z.string().min(1) })).min(1),
+  shuffle: z.boolean().optional(),
+  orientation: z.enum(["horizontal", "vertical"]).optional(),
+});
+
+export const orderInteraction: InteractionDescriptor<"orderInteraction"> = defineInteraction({
+  kind: "orderInteraction",
+  schema: orderInteractionNodeSchema,
+  scoring: "qti-standard",
+  initialResponse(): ResponseValue {
+    return null;
+  },
+});

package/src/interactions/slider.ts

@@ -0,0 +1,24 @@
+import { z } from "zod";
+
+import { defineInteraction, type InteractionDescriptor } from "../runtime";
+import type { ResponseValue } from "../types";
+
+const sliderInteractionNodeSchema = z.object({
+  kind: z.literal("sliderInteraction"),
+  responseIdentifier: z.string().min(1),
+  lowerBound: z.number(),
+  upperBound: z.number(),
+  step: z.number().optional(),
+  stepLabel: z.boolean().optional(),
+  orientation: z.enum(["horizontal", "vertical"]).optional(),
+  reverse: z.boolean().optional(),
+});
+
+export const sliderInteraction: InteractionDescriptor<"sliderInteraction"> = defineInteraction({
+  kind: "sliderInteraction",
+  schema: sliderInteractionNodeSchema,
+  scoring: "qti-standard",
+  initialResponse(): ResponseValue {
+    return null;
+  },
+});

package/src/interactions/text-entry.ts

@@ -1,6 +1,6 @@
 import { z } from "zod";
 
-import { defineInteraction } from "../runtime";
+import { defineInteraction, type InteractionDescriptor } from "../runtime";
 import type { ResponseValue } from "../types";
 
 const textEntryInteractionNodeSchema = z.object({
@@ -11,7 +11,7 @@ const textEntryInteractionNodeSchema = z.object({
   patternMask: z.string().optional(),
 });
 
-export const textEntryInteraction = defineInteraction({
+export const textEntryInteraction: InteractionDescriptor<"textEntryInteraction"> = defineInteraction({
   kind: "textEntryInteraction",
   schema: textEntryInteractionNodeSchema,
   scoring: "qti-standard",

package/src/interactions/upload.ts

@@ -0,0 +1,19 @@
+import { z } from "zod";
+
+import { defineInteraction, type InteractionDescriptor } from "../runtime";
+import type { ResponseValue } from "../types";
+
+const uploadInteractionNodeSchema = z.object({
+  kind: z.literal("uploadInteraction"),
+  responseIdentifier: z.string().min(1),
+  type: z.string().optional(),
+});
+
+export const uploadInteraction: InteractionDescriptor<"uploadInteraction"> = defineInteraction({
+  kind: "uploadInteraction",
+  schema: uploadInteractionNodeSchema,
+  scoring: "qti-standard",
+  initialResponse(): ResponseValue {
+    return null;
+  },
+});