@mathscan/math-exercise-engine 1.2.0 → 1.2.1

package/dist/index.js

@@ -394,13 +394,9 @@ const MATCHER = chevrotain.createToken({
   name: "MATCHER",
   pattern: /MATCHER/
 });
-const TOP_ROW = chevrotain.createToken({
-  name: "TOP_ROW",
-  pattern: /TOP_ROW/
-});
-const BOTTOM_ROW = chevrotain.createToken({
-  name: "BOTTOM_ROW",
-  pattern: /BOTTOM_ROW/
+const GROUP = chevrotain.createToken({
+  name: "GROUP",
+  pattern: /GROUP/
 });
 const ITEM = chevrotain.createToken({
   name: "ITEM",
@@ -556,8 +552,7 @@ const allTokens = [
   ARROW,
   TABLE,
   ROW,
-  TOP_ROW,
-  BOTTOM_ROW,
+  GROUP,
   CELL,
   COUNTER,
   CLOCK,
@@ -1065,39 +1060,19 @@ class MathExerciseParser extends chevrotain.CstParser {
       this.MANY3(() => {
         this.OR3([{ ALT: () => this.CONSUME3(Space) }, { ALT: () => this.CONSUME3(Newline) }]);
       });
-      this.SUBRULE(this.pairMatcherTopSection);
-      this.SUBRULE(this.pairMatcherBottomSection);
+      this.SUBRULE(this.pairMatcherGroupSection);
+      this.SUBRULE2(this.pairMatcherGroupSection);
       this.SUBRULE(this.matcherAnswers);
       this.CONSUME(RBrace);
       this.MANY4(() => {
         this.OR4([{ ALT: () => this.CONSUME4(Newline) }, { ALT: () => this.CONSUME4(Space) }]);
       });
     });
-    this.pairMatcherTopSection = this.RULE("pairMatcherTopSection", () => {
-      this.MANY(() => {
-        this.OR([{ ALT: () => this.CONSUME(Space) }, { ALT: () => this.CONSUME(Newline) }]);
-      });
-      this.CONSUME(TOP_ROW);
-      this.MANY2(() => {
-        this.OR2([{ ALT: () => this.CONSUME2(Space) }, { ALT: () => this.CONSUME2(Newline) }]);
-      });
-      this.CONSUME(LBrace);
-      this.MANY3(() => {
-        this.OR3([{ ALT: () => this.CONSUME3(Space) }, { ALT: () => this.CONSUME3(Newline) }]);
-      });
-      this.AT_LEAST_ONE(() => {
-        this.SUBRULE(this.matcherItem);
-      });
-      this.CONSUME(RBrace);
-      this.MANY4(() => {
-        this.OR4([{ ALT: () => this.CONSUME4(Space) }, { ALT: () => this.CONSUME4(Newline) }]);
-      });
-    });
-    this.pairMatcherBottomSection = this.RULE("pairMatcherBottomSection", () => {
+    this.pairMatcherGroupSection = this.RULE("pairMatcherGroupSection", () => {
       this.MANY(() => {
         this.OR([{ ALT: () => this.CONSUME(Space) }, { ALT: () => this.CONSUME(Newline) }]);
       });
-      this.CONSUME(BOTTOM_ROW);
+      this.CONSUME(GROUP);
       this.MANY2(() => {
         this.OR2([{ ALT: () => this.CONSUME2(Space) }, { ALT: () => this.CONSUME2(Newline) }]);
       });
@@ -2590,20 +2565,24 @@ function isMatcherBlock(value) {
 const PairMatcherBlockSchema = zod.z.object({
   type: zod.z.literal(AST_TYPES.PAIR_MATCHER_BLOCK),
   name: zod.z.string().min(1),
-  /** Items in the top row — at least one required */
-  topItems: zod.z.array(MatcherItemSchema).min(1),
-  /** Items in the bottom row — at least one required */
-  bottomItems: zod.z.array(MatcherItemSchema).min(1),
+  /** Row layout (top/bottom, default) or column layout (left/right). */
+  layout: zod.z.enum(["rows", "columns"]).optional(),
+  /** Exactly two groups, in declaration order — neither more nor fewer. */
+  groups: zod.z.tuple([
+    zod.z.array(MatcherItemSchema).min(1),
+    zod.z.array(MatcherItemSchema).min(1)
+  ]),
   /**
-   * Each answer pair is [topId, bottomId].
+   * Each answer pair is [groups[0] id, groups[1] id].
    * At least one pair is required.
    */
   answers: zod.z.array(zod.z.tuple([zod.z.string().min(1), zod.z.string().min(1)])).min(1)
 }).superRefine((data, ctx) => {
+  const [groupAItems, groupBItems] = data.groups;
   const idRegistry = /* @__PURE__ */ new Map();
   const sections = [
-    { key: "topItems", items: data.topItems },
-    { key: "bottomItems", items: data.bottomItems }
+    { key: 0, items: groupAItems },
+    { key: 1, items: groupBItems }
   ];
   for (const { key: key2, items } of sections) {
     for (let i = 0; i < items.length; i++) {
@@ -2613,59 +2592,59 @@ const PairMatcherBlockSchema = zod.z.object({
         const isCrossSection = existing.section !== key2;
         ctx.addIssue({
           code: zod.z.ZodIssueCode.custom,
-          message: isCrossSection ? `itemId "${itemId}" appears in both TOP and BOTTOM — ids must be globally unique` : `Duplicate itemId "${itemId}" in ${key2 === "topItems" ? "TOP" : "BOTTOM"} section`,
-          path: [key2, i, "itemId"]
+          message: isCrossSection ? `itemId "${itemId}" appears in both groups — ids must be globally unique` : `Duplicate itemId "${itemId}" in group ${key2}`,
+          path: ["groups", key2, i, "itemId"]
         });
       } else {
         idRegistry.set(itemId, { section: key2, index: i });
       }
     }
   }
-  const topIds = new Set(data.topItems.map((it) => it.itemId));
-  const bottomIds = new Set(data.bottomItems.map((it) => it.itemId));
-  const usedTopIds = /* @__PURE__ */ new Set();
-  const usedBottomIds = /* @__PURE__ */ new Set();
-  data.answers.forEach(([topId, bottomId], i) => {
-    if (!topIds.has(topId)) {
+  const groupAIds = new Set(groupAItems.map((it) => it.itemId));
+  const groupBIds = new Set(groupBItems.map((it) => it.itemId));
+  const usedGroupAIds = /* @__PURE__ */ new Set();
+  const usedGroupBIds = /* @__PURE__ */ new Set();
+  data.answers.forEach(([aId, bId], i) => {
+    if (!groupAIds.has(aId)) {
       ctx.addIssue({
         code: zod.z.ZodIssueCode.custom,
-        message: `Answer pair [${topId}, ${bottomId}]: "${topId}" is not declared in TOP section`,
+        message: `Answer pair [${aId}, ${bId}]: "${aId}" is not declared in groups[0]`,
         path: ["answers", i, 0]
       });
     }
-    if (!bottomIds.has(bottomId)) {
+    if (!groupBIds.has(bId)) {
       ctx.addIssue({
         code: zod.z.ZodIssueCode.custom,
-        message: `Answer pair [${topId}, ${bottomId}]: "${bottomId}" is not declared in BOTTOM section`,
+        message: `Answer pair [${aId}, ${bId}]: "${bId}" is not declared in groups[1]`,
         path: ["answers", i, 1]
       });
     }
-    if (usedTopIds.has(topId)) {
+    if (usedGroupAIds.has(aId)) {
       ctx.addIssue({
         code: zod.z.ZodIssueCode.custom,
-        message: `topId "${topId}" appears in more than one answer pair`,
+        message: `id "${aId}" appears in more than one answer pair`,
         path: ["answers", i, 0]
       });
     } else {
-      usedTopIds.add(topId);
+      usedGroupAIds.add(aId);
     }
-    if (usedBottomIds.has(bottomId)) {
+    if (usedGroupBIds.has(bId)) {
       ctx.addIssue({
         code: zod.z.ZodIssueCode.custom,
-        message: `bottomId "${bottomId}" appears in more than one answer pair`,
+        message: `id "${bId}" appears in more than one answer pair`,
         path: ["answers", i, 1]
       });
     } else {
-      usedBottomIds.add(bottomId);
+      usedGroupBIds.add(bId);
     }
   });
 });
-function createPairMatcherBlock(name, topItems, bottomItems, answers) {
+function createPairMatcherBlock(name, groups, answers, layout) {
   return PairMatcherBlockSchema.parse({
     type: AST_TYPES.PAIR_MATCHER_BLOCK,
     name,
-    topItems,
-    bottomItems,
+    layout,
+    groups,
     answers
   });
 }
@@ -2852,7 +2831,7 @@ const ExerciseDocumentSchema = zod.z.object({
     } else if (block.type === AST_TYPES.PAIR_MATCHER_BLOCK) {
       const pm = block;
       record(pm.name, ["lines", bi, "name"]);
-      [...pm.topItems, ...pm.bottomItems].forEach((item, ii) => {
+      pm.groups.flat().forEach((item, ii) => {
         visitInlines(item.inlines, ["lines", bi, "items", ii, "inlines"]);
       });
     } else if (block.type === AST_TYPES.RADIO_OPTIONS) {
@@ -3065,24 +3044,14 @@ class NaturalDSLVisitor extends BaseCstVisitor {
   pairMatcher(ctx) {
     const params = this.visit(ctx.parameterList);
     const name = params.name;
-    const topItems = this.visit(ctx.pairMatcherTopSection);
-    const bottomItems = this.visit(ctx.pairMatcherBottomSection);
+    const layout = params.layout;
+    const [firstGroup, secondGroup] = ctx.pairMatcherGroupSection;
+    const groupAItems = this.visit(firstGroup);
+    const groupBItems = this.visit(secondGroup);
     const rawAnswers = this.visit(ctx.matcherAnswers);
-    return createPairMatcherBlock(name, topItems, bottomItems, rawAnswers);
+    return createPairMatcherBlock(name, [groupAItems, groupBItems], rawAnswers, layout);
   }
-  pairMatcherTopSection(ctx) {
-    return this.visitMatcherItemList(ctx);
-  }
-  pairMatcherBottomSection(ctx) {
-    return this.visitMatcherItemList(ctx);
-  }
-  /**
-   * Maps `ctx.matcherItem` CST nodes to MatcherItem AST nodes.
-   * Shared by pairMatcherTopSection and pairMatcherBottomSection because their
-   * grammar rules are structurally identical — both are `matcherItem+` lists
-   * wrapped in a labelled section keyword.
-   */
-  visitMatcherItemList(ctx) {
+  pairMatcherGroupSection(ctx) {
     return ctx.matcherItem ? ctx.matcherItem.map((i) => this.visit(i)) : [];
   }
   // ═══════════════════════════════════════════════════════════════════════════
@@ -3874,8 +3843,12 @@ const MatcherWidgetJSONSchema = zod.z.object({
 });
 const PairMatcherWidgetJSONSchema = zod.z.object({
   type: zod.z.literal(JSON_TYPES.PAIR_MATCHER),
-  topItems: zod.z.array(MatcherItemContentSchema).min(1),
-  bottomItems: zod.z.array(MatcherItemContentSchema).min(1)
+  /** Row layout (top/bottom, default) or column layout (left/right). */
+  layout: zod.z.enum(["rows", "columns"]).optional(),
+  groups: zod.z.tuple([
+    zod.z.array(MatcherItemContentSchema).min(1),
+    zod.z.array(MatcherItemContentSchema).min(1)
+  ])
 });
 const VisualFractionJSONSchema = zod.z.object({
   type: zod.z.literal(JSON_TYPES.VISUAL_FRACTION),
@@ -9835,7 +9808,7 @@ function collectAllInlines(blocks) {
       }
     } else if (block.type === AST_TYPES.PAIR_MATCHER_BLOCK) {
       const pm = block;
-      for (const item of [...pm.topItems, ...pm.bottomItems]) {
+      for (const item of pm.groups.flat()) {
         result.push(...item.inlines);
       }
     }
@@ -9942,10 +9915,14 @@ function buildMatcherWidget(matcher, idGenerator, inlineDragIds) {
   return result;
 }
 function buildPairMatcherWidget(pm, idGenerator, inlineDragIds) {
+  const [groupAItems, groupBItems] = pm.groups;
   return {
     type: JSON_TYPES.PAIR_MATCHER,
-    topItems: mapMatcherItemList(pm.topItems, idGenerator, inlineDragIds),
-    bottomItems: mapMatcherItemList(pm.bottomItems, idGenerator, inlineDragIds)
+    ...pm.layout !== void 0 && { layout: pm.layout },
+    groups: [
+      mapMatcherItemList(groupAItems, idGenerator, inlineDragIds),
+      mapMatcherItemList(groupBItems, idGenerator, inlineDragIds)
+    ]
   };
 }
 function transformVerticalOperation(vop, idGenerator) {
@@ -16740,7 +16717,9 @@ const PairMatcherWidget = ({
   widgets,
   shuffleItems = true
 }) => {
-  const { topItems, bottomItems } = widget;
+  const { groups, layout } = widget;
+  const [topItems, bottomItems] = groups;
+  const isColumns = layout === "columns";
   const exerciseLocked = useExerciseLocked();
   const [shuffledTop] = React.useState(
     () => shuffleItems ? lodashExports.shuffle([...topItems]) : [...topItems]
@@ -16917,8 +16896,8 @@ const PairMatcherWidget = ({
     pairStatusByTopId
   });
   const cols = React.useMemo(
-    () => Math.max(topItems.length, bottomItems.length, 1),
-    [topItems.length, bottomItems.length]
+    () => isColumns ? null : Math.max(topItems.length, bottomItems.length, 1),
+    [isColumns, topItems.length, bottomItems.length]
   );
   const renderCard = (item, isTop) => {
     const isRtl = shouldItemsUseRTL(item.content);
@@ -16964,8 +16943,8 @@ const PairMatcherWidget = ({
   return /* @__PURE__ */ jsxRuntime.jsxs(
     "div",
     {
-      className: `pair-matcher-widget${validationStatus ? ` pair-matcher-widget--${validationStatus}` : ""}`,
-      style: { "--pm-cols": cols },
+      className: `pair-matcher-widget${isColumns ? " pair-matcher-widget--columns" : ""}${validationStatus ? ` pair-matcher-widget--${validationStatus}` : ""}`,
+      style: cols === null ? {} : { "--pm-cols": cols },
       ref: containerRef,
       role: "group",
       "aria-label": "Pair matcher exercise",