@conform-ed/qti-react 0.0.12 → 0.0.13

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 } 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 = 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 = 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 = 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 = 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 = 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 = 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 } 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 = defineInteraction({
+  kind: "hottextInteraction",
+  schema: hottextInteractionNodeSchema,
+  scoring: "qti-standard",
+  initialResponse(): ResponseValue {
+    return null;
+  },
+});

package/src/interactions/index.ts

@@ -1,16 +1,71 @@
 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/match.ts

@@ -0,0 +1,27 @@
+import { z } from "zod";
+
+import { defineInteraction } 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 = 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 } 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 = 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 } 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 = 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 } 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 = defineInteraction({
+  kind: "sliderInteraction",
+  schema: sliderInteractionNodeSchema,
+  scoring: "qti-standard",
+  initialResponse(): ResponseValue {
+    return null;
+  },
+});

package/src/interactions/upload.ts

@@ -0,0 +1,19 @@
+import { z } from "zod";
+
+import { defineInteraction } 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 = defineInteraction({
+  kind: "uploadInteraction",
+  schema: uploadInteractionNodeSchema,
+  scoring: "qti-standard",
+  initialResponse(): ResponseValue {
+    return null;
+  },
+});