@qti-editor/interaction-choice 0.1.0

package/dist/attributes/choice-interaction-class-editor.d.ts

@@ -0,0 +1,63 @@
+import type { AttributeFriendlyEditorDefinition } from '@qti-editor/interfaces';
+export type ChoiceInteractionClassGroupId = 'labels' | 'labelsSuffix' | 'orientation' | 'inputControlHidden' | 'choicesStacking';
+export interface ChoiceInteractionClassOption {
+    value: string;
+    label: string;
+    description?: string;
+}
+export interface ChoiceInteractionClassGroup {
+    id: ChoiceInteractionClassGroupId;
+    title: string;
+    description?: string;
+    selection: 'single' | 'boolean';
+    options: readonly ChoiceInteractionClassOption[];
+}
+export interface ChoiceInteractionClassState {
+    labels: string | null;
+    labelsSuffix: string | null;
+    orientation: string | null;
+    inputControlHidden: boolean;
+    choicesStacking: string | null;
+    unknownClasses: string[];
+}
+export interface ChoiceInteractionClassFriendlyEditorDefinition extends AttributeFriendlyEditorDefinition {
+    kind: 'choiceInteractionClass';
+}
+export declare const choiceInteractionClassGroups: readonly [{
+    readonly id: "labels";
+    readonly title: "Labels";
+    readonly description: "Choose how simple choices are labeled.";
+    readonly selection: "single";
+    readonly options: readonly ChoiceInteractionClassOption[];
+}, {
+    readonly id: "labelsSuffix";
+    readonly title: "Label suffix";
+    readonly description: "Choose the suffix appended to each label.";
+    readonly selection: "single";
+    readonly options: readonly ChoiceInteractionClassOption[];
+}, {
+    readonly id: "orientation";
+    readonly title: "Orientation";
+    readonly description: "Choose whether choices are laid out horizontally or vertically.";
+    readonly selection: "single";
+    readonly options: readonly ChoiceInteractionClassOption[];
+}, {
+    readonly id: "inputControlHidden";
+    readonly title: "Input control";
+    readonly description: "Toggle visibility of the built-in input control.";
+    readonly selection: "boolean";
+    readonly options: readonly ChoiceInteractionClassOption[];
+}, {
+    readonly id: "choicesStacking";
+    readonly title: "Stacking";
+    readonly description: "Choose how many columns choices are stacked into.";
+    readonly selection: "single";
+    readonly options: readonly ChoiceInteractionClassOption[];
+}];
+export declare const choiceInteractionClassFriendlyEditor: {
+    readonly attribute: "class";
+    readonly kind: "choiceInteractionClass";
+};
+export declare function parseChoiceInteractionClasses(classValue: string | null | undefined): ChoiceInteractionClassState;
+export declare function serializeChoiceInteractionClasses(state: Partial<ChoiceInteractionClassState>): string | null;
+//# sourceMappingURL=choice-interaction-class-editor.d.ts.map

package/dist/attributes/choice-interaction-class-editor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"choice-interaction-class-editor.d.ts","sourceRoot":"","sources":["../../src/attributes/choice-interaction-class-editor.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iCAAiC,EAAE,MAAM,wBAAwB,CAAC;AAEhF,MAAM,MAAM,6BAA6B,GACrC,QAAQ,GACR,cAAc,GACd,aAAa,GACb,oBAAoB,GACpB,iBAAiB,CAAC;AAEtB,MAAM,WAAW,4BAA4B;IAC3C,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;IACd,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED,MAAM,WAAW,2BAA2B;IAC1C,EAAE,EAAE,6BAA6B,CAAC;IAClC,KAAK,EAAE,MAAM,CAAC;IACd,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,SAAS,EAAE,QAAQ,GAAG,SAAS,CAAC;IAChC,OAAO,EAAE,SAAS,4BAA4B,EAAE,CAAC;CAClD;AAED,MAAM,WAAW,2BAA2B;IAC1C,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;IACtB,YAAY,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5B,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3B,kBAAkB,EAAE,OAAO,CAAC;IAC5B,eAAe,EAAE,MAAM,GAAG,IAAI,CAAC;IAC/B,cAAc,EAAE,MAAM,EAAE,CAAC;CAC1B;AAED,MAAM,WAAW,8CACf,SAAQ,iCAAiC;IACzC,IAAI,EAAE,wBAAwB,CAAC;CAChC;AAgCD,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAoCkB,CAAC;AAE5D,eAAO,MAAM,oCAAoC;;;CAGkB,CAAC;AAwBpE,wBAAgB,6BAA6B,CAC3C,UAAU,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GACpC,2BAA2B,CAqB7B;AAED,wBAAgB,iCAAiC,CAC/C,KAAK,EAAE,OAAO,CAAC,2BAA2B,CAAC,GAC1C,MAAM,GAAG,IAAI,CAsBf"}

package/dist/attributes/choice-interaction-class-editor.js

@@ -0,0 +1,124 @@
+const LABEL_OPTIONS = [
+    { value: 'qti-labels-none', label: 'No labels' },
+    { value: 'qti-labels-decimal', label: 'Decimal labels' },
+    { value: 'qti-labels-lower-alpha', label: 'Lower alpha labels' },
+    { value: 'qti-labels-upper-alpha', label: 'Upper alpha labels' },
+];
+const LABEL_SUFFIX_OPTIONS = [
+    { value: 'qti-labels-suffix-none', label: 'No suffix' },
+    { value: 'qti-labels-suffix-period', label: 'Period suffix' },
+    { value: 'qti-labels-suffix-parenthesis', label: 'Parenthesis suffix' },
+];
+const ORIENTATION_OPTIONS = [
+    { value: 'qti-orientation-horizontal', label: 'Horizontal' },
+    { value: 'qti-orientation-vertical', label: 'Vertical' },
+];
+const INPUT_CONTROL_OPTIONS = [
+    { value: 'qti-input-control-hidden', label: 'Hide input control' },
+];
+const STACKING_OPTIONS = [
+    { value: 'qti-choices-stacking-1', label: '1 column' },
+    { value: 'qti-choices-stacking-2', label: '2 columns' },
+    { value: 'qti-choices-stacking-3', label: '3 columns' },
+    { value: 'qti-choices-stacking-4', label: '4 columns' },
+    { value: 'qti-choices-stacking-5', label: '5 columns' },
+];
+export const choiceInteractionClassGroups = [
+    {
+        id: 'labels',
+        title: 'Labels',
+        description: 'Choose how simple choices are labeled.',
+        selection: 'single',
+        options: LABEL_OPTIONS,
+    },
+    {
+        id: 'labelsSuffix',
+        title: 'Label suffix',
+        description: 'Choose the suffix appended to each label.',
+        selection: 'single',
+        options: LABEL_SUFFIX_OPTIONS,
+    },
+    {
+        id: 'orientation',
+        title: 'Orientation',
+        description: 'Choose whether choices are laid out horizontally or vertically.',
+        selection: 'single',
+        options: ORIENTATION_OPTIONS,
+    },
+    {
+        id: 'inputControlHidden',
+        title: 'Input control',
+        description: 'Toggle visibility of the built-in input control.',
+        selection: 'boolean',
+        options: INPUT_CONTROL_OPTIONS,
+    },
+    {
+        id: 'choicesStacking',
+        title: 'Stacking',
+        description: 'Choose how many columns choices are stacked into.',
+        selection: 'single',
+        options: STACKING_OPTIONS,
+    },
+];
+export const choiceInteractionClassFriendlyEditor = {
+    attribute: 'class',
+    kind: 'choiceInteractionClass',
+};
+const managedTokensByGroup = {
+    labels: new Set(LABEL_OPTIONS.map(option => option.value)),
+    labelsSuffix: new Set(LABEL_SUFFIX_OPTIONS.map(option => option.value)),
+    orientation: new Set(ORIENTATION_OPTIONS.map(option => option.value)),
+    inputControlHidden: new Set(INPUT_CONTROL_OPTIONS.map(option => option.value)),
+    choicesStacking: new Set(STACKING_OPTIONS.map(option => option.value)),
+};
+const managedTokens = new Set(Object.values(managedTokensByGroup).flatMap(groupTokens => Array.from(groupTokens)));
+function tokenizeClassValue(classValue) {
+    if (!classValue)
+        return [];
+    return classValue
+        .split(/\s+/)
+        .map(token => token.trim())
+        .filter(Boolean)
+        .filter((token, index, tokens) => tokens.indexOf(token) === index);
+}
+export function parseChoiceInteractionClasses(classValue) {
+    const tokens = tokenizeClassValue(classValue);
+    const getLastManagedToken = (groupId) => {
+        let selected = null;
+        for (const token of tokens) {
+            if (managedTokensByGroup[groupId].has(token)) {
+                selected = token;
+            }
+        }
+        return selected;
+    };
+    return {
+        labels: getLastManagedToken('labels'),
+        labelsSuffix: getLastManagedToken('labelsSuffix'),
+        orientation: getLastManagedToken('orientation'),
+        inputControlHidden: tokens.includes('qti-input-control-hidden'),
+        choicesStacking: getLastManagedToken('choicesStacking'),
+        unknownClasses: tokens.filter(token => !managedTokens.has(token)),
+    };
+}
+export function serializeChoiceInteractionClasses(state) {
+    const tokens = [];
+    for (const token of state.unknownClasses ?? []) {
+        if (!token || managedTokens.has(token) || tokens.includes(token))
+            continue;
+        tokens.push(token);
+    }
+    const managedSelections = [
+        state.labels ?? null,
+        state.labelsSuffix ?? null,
+        state.orientation ?? null,
+        state.inputControlHidden ? 'qti-input-control-hidden' : null,
+        state.choicesStacking ?? null,
+    ];
+    for (const token of managedSelections) {
+        if (!token || tokens.includes(token))
+            continue;
+        tokens.push(token);
+    }
+    return tokens.length > 0 ? tokens.join(' ') : null;
+}

package/dist/components/qti-choice-interaction/commands/convert-selection-to-choice.commands.d.ts

@@ -0,0 +1,4 @@
+import type { EditorView } from 'prosekit/pm/view';
+export declare function canConvertFlatListToChoiceInteraction(view: EditorView): boolean;
+export declare function convertFlatListToChoiceInteraction(view: EditorView): boolean;
+//# sourceMappingURL=convert-selection-to-choice.commands.d.ts.map

package/dist/components/qti-choice-interaction/commands/convert-selection-to-choice.commands.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"convert-selection-to-choice.commands.d.ts","sourceRoot":"","sources":["../../../../src/components/qti-choice-interaction/commands/convert-selection-to-choice.commands.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAiInD,wBAAgB,qCAAqC,CAAC,IAAI,EAAE,UAAU,GAAG,OAAO,CAmB/E;AAED,wBAAgB,kCAAkC,CAAC,IAAI,EAAE,UAAU,GAAG,OAAO,CAmD5E"}

package/dist/components/qti-choice-interaction/commands/convert-selection-to-choice.commands.js

@@ -0,0 +1,169 @@
+function isFlatList(listNode, listType) {
+    let hasNestedList = false;
+    listNode.descendants((node, pos) => {
+        if (pos > 0 && node.type === listType) {
+            hasNestedList = true;
+            return false;
+        }
+        return !hasNestedList;
+    });
+    return !hasNestedList;
+}
+function isConvertibleRootBlock(node, schema) {
+    const paragraphType = schema.nodes.paragraph;
+    const listType = schema.nodes.list;
+    if (paragraphType && node.type === paragraphType) {
+        return 'paragraph';
+    }
+    if (listType && node.type === listType) {
+        const listKind = node.attrs?.kind;
+        if (!['bullet', 'ordered'].includes(listKind))
+            return null;
+        if (!isFlatList(node, listType))
+            return null;
+        return 'list';
+    }
+    return null;
+}
+function getSelectedConvertibleBlocks(view) {
+    const { state } = view;
+    const { selection } = state;
+    const schema = state.schema;
+    const blocks = [];
+    const seenPositions = new Set();
+    const addBlockIfConvertible = (node, start) => {
+        if (seenPositions.has(start))
+            return;
+        const kind = isConvertibleRootBlock(node, schema);
+        if (!kind)
+            return;
+        seenPositions.add(start);
+        blocks.push({
+            kind,
+            pos: start,
+            end: start + node.nodeSize,
+            node,
+        });
+    };
+    const getRootBlockAt = (pos) => {
+        const safePos = Math.max(0, Math.min(pos, state.doc.content.size));
+        const nodeAtPos = state.doc.nodeAt(safePos);
+        if (nodeAtPos?.isBlock) {
+            return {
+                node: nodeAtPos,
+                start: safePos,
+            };
+        }
+        const $pos = state.doc.resolve(safePos);
+        if ($pos.depth < 1) {
+            const after = $pos.nodeAfter;
+            if (after?.isBlock) {
+                return {
+                    node: after,
+                    start: $pos.pos,
+                };
+            }
+            return null;
+        }
+        return {
+            node: $pos.node(1),
+            start: $pos.start(1) - 1,
+        };
+    };
+    if (selection.empty) {
+        const rootBlock = getRootBlockAt(selection.from);
+        if (!rootBlock)
+            return blocks;
+        addBlockIfConvertible(rootBlock.node, rootBlock.start);
+        return blocks;
+    }
+    // Block-select plugin uses a custom "node-range" selection with explicit block ranges.
+    // Prefer those exact ranges to avoid text-range quirks across custom elements/shadow DOM.
+    const selectionJSON = selection.toJSON();
+    if (selectionJSON.type === 'node-range' && Array.isArray(selection.ranges)) {
+        for (const range of selection.ranges) {
+            const rootBlock = getRootBlockAt(range.$from.pos);
+            if (!rootBlock)
+                continue;
+            addBlockIfConvertible(rootBlock.node, rootBlock.start);
+        }
+        if (blocks.length > 0)
+            return blocks;
+    }
+    state.doc.forEach((node, offset) => {
+        const start = offset;
+        const end = start + node.nodeSize;
+        const intersectsSelection = end > selection.from && start < selection.to;
+        if (!intersectsSelection)
+            return;
+        addBlockIfConvertible(node, start);
+    });
+    return blocks;
+}
+function getChoiceInlineContent(block, schema) {
+    if (block.kind === 'paragraph') {
+        return block.node.content;
+    }
+    const paragraphType = schema.nodes.paragraph;
+    if (!paragraphType)
+        return null;
+    const firstChild = block.node.firstChild;
+    if (firstChild && firstChild.type === paragraphType) {
+        return firstChild.content;
+    }
+    return null;
+}
+export function canConvertFlatListToChoiceInteraction(view) {
+    const { state } = view;
+    const schema = state.schema;
+    const interactionType = schema.nodes.qtiChoiceInteraction;
+    const promptType = schema.nodes.qtiPrompt;
+    const promptParagraphType = schema.nodes.qtiPromptParagraph;
+    const choiceType = schema.nodes.qtiSimpleChoice;
+    const choiceParagraphType = schema.nodes.qtiSimpleChoiceParagraph;
+    if (!interactionType || !promptType || !promptParagraphType || !choiceType || !choiceParagraphType) {
+        return false;
+    }
+    const selectedBlocks = getSelectedConvertibleBlocks(view);
+    if (selectedBlocks.length === 0)
+        return false;
+    const firstBlock = selectedBlocks[0];
+    const $pos = state.doc.resolve(firstBlock.pos);
+    return $pos.parent.canReplaceWith($pos.index(), $pos.index() + 1, interactionType);
+}
+export function convertFlatListToChoiceInteraction(view) {
+    const { state } = view;
+    const schema = state.schema;
+    const interactionType = schema.nodes.qtiChoiceInteraction;
+    const promptType = schema.nodes.qtiPrompt;
+    const promptParagraphType = schema.nodes.qtiPromptParagraph;
+    const choiceType = schema.nodes.qtiSimpleChoice;
+    const choiceParagraphType = schema.nodes.qtiSimpleChoiceParagraph;
+    if (!interactionType || !promptType || !promptParagraphType || !choiceType || !choiceParagraphType) {
+        return false;
+    }
+    const selectedBlocks = getSelectedConvertibleBlocks(view);
+    if (selectedBlocks.length === 0)
+        return false;
+    const prompt = promptType.create(null, promptParagraphType.create(null, schema.text('Select one option')));
+    const choices = selectedBlocks.map(block => {
+        const inlineContent = getChoiceInlineContent(block, schema);
+        const paragraphContent = inlineContent ?? schema.text(block.node.textContent.trim() || 'Option');
+        return choiceType.create({ identifier: `SIMPLE_CHOICE_${crypto.randomUUID()}` }, choiceParagraphType.create(null, paragraphContent));
+    });
+    const interaction = interactionType.create({ responseIdentifier: `RESPONSE_${crypto.randomUUID()}`, maxChoices: 1 }, [prompt, ...choices]);
+    const firstBlock = selectedBlocks[0];
+    const $pos = state.doc.resolve(firstBlock.pos);
+    if (!$pos.parent.canReplaceWith($pos.index(), $pos.index() + 1, interactionType)) {
+        return false;
+    }
+    const tr = state.tr;
+    for (let i = selectedBlocks.length - 1; i >= 0; i -= 1) {
+        const block = selectedBlocks[i];
+        tr.delete(block.pos, block.end);
+    }
+    tr.insert(firstBlock.pos, interaction);
+    view.dispatch(tr);
+    view.focus();
+    return true;
+}

package/dist/components/qti-choice-interaction/commands/insert-choice-interaction.commands.d.ts

@@ -0,0 +1,17 @@
+import type { Command } from 'prosemirror-state';
+/**
+ * Command to insert a choice interaction at the current selection
+ */
+export declare const insertChoiceInteraction: Command;
+/**
+ * Handles Enter inside qti-simple-choice paragraphs by inserting a new empty
+ * sibling qti-simple-choice directly after the current one.
+ */
+export declare const insertSimpleChoiceOnEnter: Command;
+/**
+ * Enter command chain for choice interactions.
+ * 1) Insert new simple choice when inside qti-simple-choice.
+ * 2) Fallback to regular block split behavior elsewhere.
+ */
+export declare const qtiChoiceEnterCommand: Command;
+//# sourceMappingURL=insert-choice-interaction.commands.d.ts.map

package/dist/components/qti-choice-interaction/commands/insert-choice-interaction.commands.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"insert-choice-interaction.commands.d.ts","sourceRoot":"","sources":["../../../../src/components/qti-choice-interaction/commands/insert-choice-interaction.commands.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,mBAAmB,CAAC;AAEjD;;GAEG;AACH,eAAO,MAAM,uBAAuB,EAAE,OAoCrC,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,yBAAyB,EAAE,OAcvC,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,qBAAqB,EAAE,OAA8D,CAAC"}

package/dist/components/qti-choice-interaction/commands/insert-choice-interaction.commands.js

@@ -0,0 +1,51 @@
+import { chainCommands, splitBlock } from 'prosemirror-commands';
+import { createInsertSiblingOnEnterCommand } from '@qti-editor/interaction-shared/commands/enter.js';
+import { createInsertBlockInteractionCommand } from '@qti-editor/interaction-shared/commands/insert.js';
+/**
+ * Command to insert a choice interaction at the current selection
+ */
+export const insertChoiceInteraction = (state, dispatch) => {
+    return createInsertBlockInteractionCommand({
+        createNode: currentState => {
+            const { schema } = currentState;
+            const promptType = schema.nodes.qtiPrompt;
+            const promptParagraphType = schema.nodes.qtiPromptParagraph;
+            const choiceType = schema.nodes.qtiSimpleChoice;
+            const choiceParagraphType = schema.nodes.qtiSimpleChoiceParagraph;
+            const interactionType = schema.nodes.qtiChoiceInteraction;
+            if (!promptType || !promptParagraphType || !choiceType || !choiceParagraphType || !interactionType) {
+                return null;
+            }
+            const responseIdentifier = `RESPONSE_${crypto.randomUUID()}`;
+            const prompt = promptType.create(null, promptParagraphType.create(null, schema.text('Which option is correct?')));
+            const choices = [
+                choiceType.create({ identifier: `SIMPLE_CHOICE_${crypto.randomUUID()}` }, choiceParagraphType.create(null, schema.text('Option A'))),
+                choiceType.create({ identifier: `SIMPLE_CHOICE_${crypto.randomUUID()}` }, choiceParagraphType.create(null, schema.text('Option B'))),
+                choiceType.create({ identifier: `SIMPLE_CHOICE_${crypto.randomUUID()}` }, choiceParagraphType.create(null, schema.text('Option C')))
+            ];
+            return interactionType.create({ responseIdentifier, maxChoices: 1 }, [prompt, ...choices]);
+        },
+        selectionOffset: 2,
+    })(state, dispatch);
+};
+/**
+ * Handles Enter inside qti-simple-choice paragraphs by inserting a new empty
+ * sibling qti-simple-choice directly after the current one.
+ */
+export const insertSimpleChoiceOnEnter = (state, dispatch) => {
+    const choiceType = state.schema.nodes.qtiSimpleChoice;
+    const paragraphType = state.schema.nodes.qtiSimpleChoiceParagraph;
+    if (!choiceType || !paragraphType)
+        return false;
+    return createInsertSiblingOnEnterCommand({
+        ancestorNodeName: 'qtiSimpleChoice',
+        selectionOffset: 2,
+        createSiblingNode: () => choiceType.create({ identifier: `SIMPLE_CHOICE_${crypto.randomUUID()}` }, paragraphType.create()),
+    })(state, dispatch);
+};
+/**
+ * Enter command chain for choice interactions.
+ * 1) Insert new simple choice when inside qti-simple-choice.
+ * 2) Fallback to regular block split behavior elsewhere.
+ */
+export const qtiChoiceEnterCommand = chainCommands(insertSimpleChoiceOnEnter, splitBlock);

package/dist/components/qti-choice-interaction/qti-choice-interaction.commands.d.ts

@@ -0,0 +1,8 @@
+/**
+ * QTI Choice Interaction Commands
+ *
+ * Backward-compatible command barrel that re-exports insert and convert commands.
+ */
+export { insertChoiceInteraction, insertSimpleChoiceOnEnter, qtiChoiceEnterCommand } from './commands/insert-choice-interaction.commands.js';
+export { canConvertFlatListToChoiceInteraction, convertFlatListToChoiceInteraction } from './commands/convert-selection-to-choice.commands.js';
+//# sourceMappingURL=qti-choice-interaction.commands.d.ts.map

package/dist/components/qti-choice-interaction/qti-choice-interaction.commands.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"qti-choice-interaction.commands.d.ts","sourceRoot":"","sources":["../../../src/components/qti-choice-interaction/qti-choice-interaction.commands.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EACL,uBAAuB,EACvB,yBAAyB,EACzB,qBAAqB,EACtB,MAAM,kDAAkD,CAAC;AAE1D,OAAO,EACL,qCAAqC,EACrC,kCAAkC,EACnC,MAAM,oDAAoD,CAAC"}

package/dist/components/qti-choice-interaction/qti-choice-interaction.commands.js

@@ -0,0 +1,7 @@
+/**
+ * QTI Choice Interaction Commands
+ *
+ * Backward-compatible command barrel that re-exports insert and convert commands.
+ */
+export { insertChoiceInteraction, insertSimpleChoiceOnEnter, qtiChoiceEnterCommand } from './commands/insert-choice-interaction.commands.js';
+export { canConvertFlatListToChoiceInteraction, convertFlatListToChoiceInteraction } from './commands/convert-selection-to-choice.commands.js';

package/dist/components/qti-choice-interaction/qti-choice-interaction.compose.d.ts

@@ -0,0 +1,3 @@
+import type { InteractionComposeResult } from '@qti-editor/interaction-shared/composer/types.js';
+export declare function composeChoiceInteractionElement(sourceElement: Element, xmlDoc: Document): InteractionComposeResult;
+//# sourceMappingURL=qti-choice-interaction.compose.d.ts.map

package/dist/components/qti-choice-interaction/qti-choice-interaction.compose.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"qti-choice-interaction.compose.d.ts","sourceRoot":"","sources":["../../../src/components/qti-choice-interaction/qti-choice-interaction.compose.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAmB,wBAAwB,EAAkC,MAAM,kDAAkD,CAAC;AAclJ,wBAAgB,+BAA+B,CAAC,aAAa,EAAE,OAAO,EAAE,MAAM,EAAE,QAAQ,GAAG,wBAAwB,CAgDlH"}

package/dist/components/qti-choice-interaction/qti-choice-interaction.compose.js

@@ -0,0 +1,58 @@
+import { choiceInteractionComposerMetadata } from '../../composer/metadata.js';
+function toFiniteNumber(value, fallback) {
+    if (value == null || value.trim().length === 0)
+        return fallback;
+    const parsed = Number(value);
+    return Number.isFinite(parsed) ? parsed : fallback;
+}
+function toNonEmptyString(value) {
+    if (!value)
+        return null;
+    const trimmed = value.trim();
+    return trimmed.length > 0 ? trimmed : null;
+}
+export function composeChoiceInteractionElement(sourceElement, xmlDoc) {
+    const metadata = choiceInteractionComposerMetadata;
+    const warnings = [];
+    const normalizedElement = xmlDoc.importNode(sourceElement, true);
+    const responseIdentifier = toNonEmptyString(sourceElement.getAttribute('response-identifier'));
+    const correctResponse = toNonEmptyString(sourceElement.getAttribute('correct-response'));
+    const maxChoices = toFiniteNumber(sourceElement.getAttribute('max-choices'), 1);
+    const minChoices = toFiniteNumber(sourceElement.getAttribute('min-choices'), 0);
+    const editorOnlyAttributes = [...metadata.editorOnlyAttributes];
+    editorOnlyAttributes.forEach(attr => normalizedElement.removeAttribute(attr));
+    normalizedElement.setAttribute('max-choices', String(maxChoices));
+    if (minChoices > 0) {
+        normalizedElement.setAttribute('min-choices', String(minChoices));
+    }
+    else {
+        normalizedElement.removeAttribute('min-choices');
+    }
+    // QTI spec: max-choices=0 means unlimited, max-choices=1 means single selection
+    const isMultiple = maxChoices !== 1;
+    let responseDeclaration;
+    if (!responseIdentifier) {
+        warnings.push({
+            code: 'MISSING_RESPONSE_IDENTIFIER',
+            message: 'qti-choice-interaction is missing response-identifier; declaration will be skipped.',
+            tagName: metadata.tagName,
+        });
+    }
+    else {
+        responseDeclaration = {
+            identifier: responseIdentifier,
+            cardinality: isMultiple ? 'multiple' : 'single',
+            baseType: 'identifier',
+            correctResponse: correctResponse ?? undefined,
+            sourceTag: metadata.tagName,
+        };
+    }
+    return {
+        normalizedElement,
+        responseDeclaration,
+        responseProcessingTemplate: metadata.responseProcessingTemplate,
+        responseProcessingKind: metadata.responseProcessing.internalKind,
+        editorOnlyAttributes,
+        warnings,
+    };
+}

package/dist/components/qti-choice-interaction/qti-choice-interaction.d.ts

@@ -0,0 +1,18 @@
+import { Interaction } from '@qti-editor/interaction-shared/components/interaction.js';
+export type Orientation = 'horizontal' | 'vertical' | undefined;
+declare const ChoiceInteractionBase: typeof Interaction;
+export declare class QtiChoiceInteractionEdit extends ChoiceInteractionBase {
+    #private;
+    static get styles(): import("lit").CSSResult[];
+    minChoices: number;
+    maxChoices: number;
+    classes: 'qti-orientation-vertical' | 'qti-orientation-horizontal' | undefined;
+    protected _internals: ElementInternals;
+    constructor();
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    updated(changedProperties: Map<string, unknown>): void;
+    render(): import("lit").TemplateResult<1>;
+}
+export {};
+//# sourceMappingURL=qti-choice-interaction.d.ts.map

package/dist/components/qti-choice-interaction/qti-choice-interaction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"qti-choice-interaction.d.ts","sourceRoot":"","sources":["../../../src/components/qti-choice-interaction/qti-choice-interaction.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,WAAW,EAAE,MAAM,0DAA0D,CAAC;AAKvF,MAAM,MAAM,WAAW,GAAG,YAAY,GAAG,UAAU,GAAG,SAAS,CAAC;AAChE,QAAA,MAAM,qBAAqB,EAAwD,OAAO,WAAW,CAAC;AAEtG,qBAAa,wBAAyB,SAAQ,qBAAqB;;IACjE,WAAoB,MAAM,8BASzB;IAGM,UAAU,SAAK;IAGf,UAAU,SAAK;IAGf,OAAO,EAAE,0BAA0B,GAAG,4BAA4B,GAAG,SAAS,CAAC;IAEtF,SAAS,CAAC,UAAU,EAAE,gBAAgB,CAAC;;IAQvC,iBAAiB,IAAI,IAAI;IAOzB,oBAAoB,IAAI,IAAI;IAMnB,OAAO,CAAC,iBAAiB,EAAE,GAAG,CAAC,MAAM,EAAE,OAAO,CAAC;IAiB/C,MAAM;CAGhB"}

package/dist/components/qti-choice-interaction/qti-choice-interaction.js

@@ -0,0 +1,85 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var _QtiChoiceInteractionEdit_instances, _QtiChoiceInteractionEdit_mutationObserver, _QtiChoiceInteractionEdit_updateChoices;
+import { css, html } from 'lit';
+import { property } from 'lit/decorators.js';
+import { Interaction } from '@qti-editor/interaction-shared/components/interaction.js';
+import styles from '@qti-components/choice-interaction/styles';
+import { VocabularyMixin } from '@qti-components/interactions-core';
+const ChoiceInteractionBase = VocabularyMixin(Interaction, 'qti-simple-choice');
+export class QtiChoiceInteractionEdit extends ChoiceInteractionBase {
+    static get styles() {
+        return [
+            styles,
+            css `
+        :host {
+          white-space: nowrap;
+        }
+      `
+        ];
+    }
+    constructor() {
+        super();
+        _QtiChoiceInteractionEdit_instances.add(this);
+        this.minChoices = 0;
+        this.maxChoices = 1;
+        _QtiChoiceInteractionEdit_mutationObserver.set(this, null);
+        this._internals = this.attachInternals();
+    }
+    connectedCallback() {
+        super.connectedCallback();
+        __classPrivateFieldGet(this, _QtiChoiceInteractionEdit_instances, "m", _QtiChoiceInteractionEdit_updateChoices).call(this);
+        __classPrivateFieldSet(this, _QtiChoiceInteractionEdit_mutationObserver, new MutationObserver(() => __classPrivateFieldGet(this, _QtiChoiceInteractionEdit_instances, "m", _QtiChoiceInteractionEdit_updateChoices).call(this)), "f");
+        __classPrivateFieldGet(this, _QtiChoiceInteractionEdit_mutationObserver, "f").observe(this, { childList: true, subtree: true });
+    }
+    disconnectedCallback() {
+        super.disconnectedCallback();
+        __classPrivateFieldGet(this, _QtiChoiceInteractionEdit_mutationObserver, "f")?.disconnect();
+        __classPrivateFieldSet(this, _QtiChoiceInteractionEdit_mutationObserver, null, "f");
+    }
+    updated(changedProperties) {
+        super.updated(changedProperties);
+        if (changedProperties.has('maxChoices')) {
+            __classPrivateFieldGet(this, _QtiChoiceInteractionEdit_instances, "m", _QtiChoiceInteractionEdit_updateChoices).call(this);
+        }
+    }
+    render() {
+        return html `<slot part="prompt" name="prompt"></slot><slot part="slot"></slot>`;
+    }
+}
+_QtiChoiceInteractionEdit_mutationObserver = new WeakMap(), _QtiChoiceInteractionEdit_instances = new WeakSet(), _QtiChoiceInteractionEdit_updateChoices = function _QtiChoiceInteractionEdit_updateChoices() {
+    this._internals.role = this.maxChoices === 1 ? 'radiogroup' : null;
+    const role = this.maxChoices === 1 ? 'radio' : 'checkbox';
+    this.querySelectorAll('qti-simple-choice').forEach((choice) => {
+        choice.internals.role = role;
+        choice.internals.states.delete(role === 'radio' ? 'checkbox' : 'radio');
+        choice.internals.states.add(role);
+    });
+};
+__decorate([
+    property({ type: Number, attribute: 'min-choices' })
+], QtiChoiceInteractionEdit.prototype, "minChoices", void 0);
+__decorate([
+    property({ type: Number, attribute: 'max-choices' })
+], QtiChoiceInteractionEdit.prototype, "maxChoices", void 0);
+__decorate([
+    property({ type: String, attribute: 'class' })
+], QtiChoiceInteractionEdit.prototype, "classes", void 0);
+if (!customElements.get('qti-choice-interaction')) {
+    customElements.define('qti-choice-interaction', QtiChoiceInteractionEdit);
+}

package/dist/components/qti-choice-interaction/qti-choice-interaction.schema.d.ts

@@ -0,0 +1,3 @@
+import type { NodeSpec } from 'prosemirror-model';
+export declare const qtiChoiceInteractionNodeSpec: NodeSpec;
+//# sourceMappingURL=qti-choice-interaction.schema.d.ts.map

package/dist/components/qti-choice-interaction/qti-choice-interaction.schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"qti-choice-interaction.schema.d.ts","sourceRoot":"","sources":["../../../src/components/qti-choice-interaction/qti-choice-interaction.schema.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAiB,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAEjE,eAAO,MAAM,4BAA4B,EAAE,QAkC1C,CAAC"}

package/dist/components/qti-choice-interaction/qti-choice-interaction.schema.js

@@ -0,0 +1,39 @@
+export const qtiChoiceInteractionNodeSpec = {
+    group: 'block',
+    content: 'qtiPrompt qtiSimpleChoice+',
+    attrs: {
+        maxChoices: { default: 0 },
+        class: { default: null },
+        correctResponse: { default: null },
+        responseIdentifier: { default: null }
+    },
+    parseDOM: [
+        {
+            tag: 'qti-choice-interaction',
+            getAttrs: (node) => {
+                if (!(node instanceof HTMLElement))
+                    return {};
+                const maxChoices = node.getAttribute('max-choices');
+                const className = node.getAttribute('class');
+                return {
+                    maxChoices: maxChoices ? parseInt(maxChoices, 10) : 0,
+                    class: className || null,
+                    correctResponse: node.getAttribute('correct-response'),
+                    responseIdentifier: node.getAttribute('response-identifier')
+                };
+            }
+        }
+    ],
+    toDOM(node) {
+        const attrs = { 'max-choices': String(node.attrs.maxChoices) };
+        if (node.attrs.class)
+            attrs.class = node.attrs.class;
+        if (node.attrs.correctResponse)
+            attrs['correct-response'] = node.attrs.correctResponse;
+        if (node.attrs.responseIdentifier)
+            attrs['response-identifier'] = node.attrs.responseIdentifier;
+        return ['qti-choice-interaction', attrs, 0];
+    },
+    defining: true,
+    isolating: true
+};

package/dist/composer/handler.d.ts

@@ -0,0 +1,3 @@
+import type { InteractionComposerHandler } from '@qti-editor/interaction-shared/composer/types.js';
+export declare const choiceComposerHandler: InteractionComposerHandler;
+//# sourceMappingURL=handler.d.ts.map

package/dist/composer/handler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"handler.d.ts","sourceRoot":"","sources":["../../src/composer/handler.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,kDAAkD,CAAC;AAEnG,eAAO,MAAM,qBAAqB,EAAE,0BAGnC,CAAC"}

package/dist/composer/handler.js

@@ -0,0 +1,6 @@
+import { composeChoiceInteractionElement } from '../components/qti-choice-interaction/qti-choice-interaction.compose.js';
+import { CHOICE_INTERACTION_TAG } from './metadata.js';
+export const choiceComposerHandler = {
+    tagName: CHOICE_INTERACTION_TAG,
+    compose: composeChoiceInteractionElement,
+};

package/dist/composer/metadata.d.ts

@@ -0,0 +1,27 @@
+export declare const MATCH_CORRECT_TEMPLATE = "https://purl.imsglobal.org/spec/qti/v3p0/rptemplates/match_correct";
+export declare const CHOICE_INTERACTION_TAG: "qti-choice-interaction";
+export declare const CHOICE_INTERACTION_NODE_TYPE: "qtiChoiceInteraction";
+export declare const choiceInteractionComposerMetadata: {
+    tagName: "qti-choice-interaction";
+    nodeTypeName: "qtiChoiceInteraction";
+    responseProcessingTemplate: string;
+    responseProcessing: {
+        templateUri: string;
+        internalKind: "match_correct";
+        internalSourceXml: string;
+    };
+    editorOnlyAttributes: string[];
+    userEditableAttributes: string[];
+};
+export declare const choiceNodeAttributePanelMetadataByNodeTypeName: {
+    [x: string]: {
+        nodeTypeName: "qtiChoiceInteraction";
+        editableAttributes: string[];
+        hiddenAttributes: string[];
+        friendlyEditors: {
+            readonly attribute: "class";
+            readonly kind: "choiceInteractionClass";
+        }[];
+    };
+};
+//# sourceMappingURL=metadata.d.ts.map

package/dist/composer/metadata.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"metadata.d.ts","sourceRoot":"","sources":["../../src/composer/metadata.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,sBAAsB,uEAAuE,CAAC;AAmB3G,eAAO,MAAM,sBAAsB,EAAG,wBAAiC,CAAC;AACxE,eAAO,MAAM,4BAA4B,EAAG,sBAA+B,CAAC;AAE5E,eAAO,MAAM,iCAAiC;;;;;;;;;;;CAYP,CAAC;AAExC,eAAO,MAAM,8CAA8C;;;;;;;;;;CAOL,CAAC"}

package/dist/composer/metadata.js

@@ -0,0 +1,41 @@
+import { choiceInteractionClassFriendlyEditor } from '../attributes/choice-interaction-class-editor.js';
+export const MATCH_CORRECT_TEMPLATE = 'https://purl.imsglobal.org/spec/qti/v3p0/rptemplates/match_correct';
+const MATCH_CORRECT_INTERNAL_TEMPLATE = `
+  <qti-response-condition>
+    <qti-response-if>
+      <qti-match>
+        <qti-variable identifier="$responseIdentifier"/>
+        <qti-correct identifier="$responseIdentifier"/>
+      </qti-match>
+      <qti-set-outcome-value identifier="SCORE">
+        <qti-sum>
+          <qti-variable identifier="SCORE"/>
+          <qti-base-value base-type="float">1</qti-base-value>
+        </qti-sum>
+      </qti-set-outcome-value>
+    </qti-response-if>
+  </qti-response-condition>
+`;
+export const CHOICE_INTERACTION_TAG = 'qti-choice-interaction';
+export const CHOICE_INTERACTION_NODE_TYPE = 'qtiChoiceInteraction';
+export const choiceInteractionComposerMetadata = {
+    tagName: CHOICE_INTERACTION_TAG,
+    nodeTypeName: CHOICE_INTERACTION_NODE_TYPE,
+    responseProcessingTemplate: MATCH_CORRECT_TEMPLATE,
+    responseProcessing: {
+        templateUri: MATCH_CORRECT_TEMPLATE,
+        internalKind: 'match_correct',
+        internalSourceXml: MATCH_CORRECT_INTERNAL_TEMPLATE,
+    },
+    editorOnlyAttributes: ['class'],
+    // maxChoices and correctResponse are set by clicking choices, not edited directly
+    userEditableAttributes: ['class'],
+};
+export const choiceNodeAttributePanelMetadataByNodeTypeName = {
+    [CHOICE_INTERACTION_NODE_TYPE.toLowerCase()]: {
+        nodeTypeName: CHOICE_INTERACTION_NODE_TYPE,
+        editableAttributes: choiceInteractionComposerMetadata.userEditableAttributes,
+        hiddenAttributes: ['class'],
+        friendlyEditors: [choiceInteractionClassFriendlyEditor],
+    },
+};

package/dist/descriptor.d.ts

@@ -0,0 +1,36 @@
+export declare const choiceInteractionDescriptor: {
+    tagName: string;
+    nodeTypeName: string;
+    nodeSpecs: {
+        name: string;
+        spec: import("prosemirror-model").NodeSpec;
+    }[];
+    insertCommand: import("prosemirror-state").Command;
+    keyboardShortcut: string;
+    enterCommand: import("prosemirror-state").Command;
+    composerMetadata: {
+        tagName: "qti-choice-interaction";
+        nodeTypeName: "qtiChoiceInteraction";
+        responseProcessingTemplate: string;
+        responseProcessing: {
+            templateUri: string;
+            internalKind: "match_correct";
+            internalSourceXml: string;
+        };
+        editorOnlyAttributes: string[];
+        userEditableAttributes: string[];
+    };
+    composerHandler: import("@qti-editor/interfaces").InteractionComposerHandler;
+    attributePanelMetadata: {
+        [x: string]: {
+            nodeTypeName: "qtiChoiceInteraction";
+            editableAttributes: string[];
+            hiddenAttributes: string[];
+            friendlyEditors: {
+                readonly attribute: "class";
+                readonly kind: "choiceInteractionClass";
+            }[];
+        };
+    };
+};
+//# sourceMappingURL=descriptor.d.ts.map

package/dist/descriptor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"descriptor.d.ts","sourceRoot":"","sources":["../src/descriptor.ts"],"names":[],"mappings":"AAeA,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgBP,CAAC"}

package/dist/descriptor.js

@@ -0,0 +1,22 @@
+import { qtiPromptNodeSpec, qtiPromptParagraphNodeSpec, qtiSimpleChoiceNodeSpec, qtiSimpleChoiceParagraphNodeSpec, } from '@qti-editor/interaction-shared';
+import { insertChoiceInteraction, insertSimpleChoiceOnEnter } from './components/qti-choice-interaction/qti-choice-interaction.commands.js';
+import { qtiChoiceInteractionNodeSpec } from './components/qti-choice-interaction/qti-choice-interaction.schema.js';
+import { choiceInteractionComposerMetadata, choiceNodeAttributePanelMetadataByNodeTypeName } from './composer/metadata.js';
+import { choiceComposerHandler } from './composer/handler.js';
+export const choiceInteractionDescriptor = {
+    tagName: 'qti-choice-interaction',
+    nodeTypeName: 'qtiChoiceInteraction',
+    nodeSpecs: [
+        { name: 'qtiChoiceInteraction', spec: qtiChoiceInteractionNodeSpec },
+        { name: 'qtiPrompt', spec: qtiPromptNodeSpec },
+        { name: 'qtiPromptParagraph', spec: qtiPromptParagraphNodeSpec },
+        { name: 'qtiSimpleChoice', spec: qtiSimpleChoiceNodeSpec },
+        { name: 'qtiSimpleChoiceParagraph', spec: qtiSimpleChoiceParagraphNodeSpec },
+    ],
+    insertCommand: insertChoiceInteraction,
+    keyboardShortcut: 'Mod-Shift-q',
+    enterCommand: insertSimpleChoiceOnEnter,
+    composerMetadata: choiceInteractionComposerMetadata,
+    composerHandler: choiceComposerHandler,
+    attributePanelMetadata: choiceNodeAttributePanelMetadataByNodeTypeName,
+};

package/dist/extensions/correct-response-click.d.ts

@@ -0,0 +1,24 @@
+import { type Extension } from 'prosekit/core';
+/**
+ * Event name for correct response changes at the interaction level.
+ * Dispatched when selections change to update the ProseMirror document.
+ */
+export declare const QTI_CORRECT_RESPONSE_CHANGE_EVENT = "qti:correct-response:change";
+/**
+ * Detail payload for the change event.
+ */
+export interface QtiCorrectResponseChangeDetail {
+    maxChoices: number;
+    correctResponse: string | null;
+    interactionElement: HTMLElement;
+}
+/**
+ * Creates a ProseMirror extension that handles correct response clicks.
+ *
+ * When a qti-simple-choice is clicked (on part="ch"), this extension:
+ * 1. Aggregates all selected choices in the parent interaction
+ * 2. Computes maxChoices (1 for single, 0 for multiple)
+ * 3. Updates the interaction node's attributes
+ */
+export declare function defineCorrectResponseClickExtension(): Extension;
+//# sourceMappingURL=correct-response-click.d.ts.map

package/dist/extensions/correct-response-click.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"correct-response-click.d.ts","sourceRoot":"","sources":["../../src/extensions/correct-response-click.ts"],"names":[],"mappings":"AAAA,OAAO,EAAgB,KAAK,SAAS,EAAE,MAAM,eAAe,CAAC;AAW7D;;;GAGG;AACH,eAAO,MAAM,iCAAiC,gCAAgC,CAAC;AAE/E;;GAEG;AACH,MAAM,WAAW,8BAA8B;IAC7C,UAAU,EAAE,MAAM,CAAC;IACnB,eAAe,EAAE,MAAM,GAAG,IAAI,CAAC;IAC/B,kBAAkB,EAAE,WAAW,CAAC;CACjC;AAqDD;;;;;;;GAOG;AACH,wBAAgB,mCAAmC,IAAI,SAAS,CAmD/D"}

package/dist/extensions/correct-response-click.js

@@ -0,0 +1,104 @@
+import { definePlugin } from 'prosekit/core';
+import { Plugin, PluginKey } from 'prosekit/pm/state';
+import { QTI_CORRECT_RESPONSE_TOGGLE_EVENT, } from '@qti-editor/interaction-shared';
+const correctResponseClickPluginKey = new PluginKey('correct-response-click');
+/**
+ * Event name for correct response changes at the interaction level.
+ * Dispatched when selections change to update the ProseMirror document.
+ */
+export const QTI_CORRECT_RESPONSE_CHANGE_EVENT = 'qti:correct-response:change';
+/**
+ * Finds the parent qti-choice-interaction element from a choice element.
+ */
+function findParentInteraction(element) {
+    return element.closest('qti-choice-interaction');
+}
+/**
+ * Gets all selected choice identifiers from an interaction element.
+ */
+function getSelectedIdentifiers(interactionElement) {
+    const choices = interactionElement.querySelectorAll('qti-simple-choice');
+    const selected = [];
+    choices.forEach((choice) => {
+        const choiceElement = choice;
+        if (choiceElement.selected) {
+            const identifier = choice.getAttribute('identifier');
+            if (identifier) {
+                selected.push(identifier);
+            }
+        }
+    });
+    return selected;
+}
+/**
+ * Finds the ProseMirror node position for an interaction element.
+ */
+function findInteractionNodePos(view, interactionElement) {
+    const { state } = view;
+    let foundPos = null;
+    state.doc.descendants((node, pos) => {
+        if (foundPos !== null)
+            return false; // Already found, stop searching
+        if (node.type.name === 'qtiChoiceInteraction') {
+            // Check if this node corresponds to the DOM element
+            const domNode = view.nodeDOM(pos);
+            if (domNode === interactionElement || (domNode && domNode.contains(interactionElement))) {
+                foundPos = pos;
+                return false;
+            }
+        }
+        return true;
+    });
+    return foundPos;
+}
+/**
+ * Creates a ProseMirror extension that handles correct response clicks.
+ *
+ * When a qti-simple-choice is clicked (on part="ch"), this extension:
+ * 1. Aggregates all selected choices in the parent interaction
+ * 2. Computes maxChoices (1 for single, 0 for multiple)
+ * 3. Updates the interaction node's attributes
+ */
+export function defineCorrectResponseClickExtension() {
+    return definePlugin(() => new Plugin({
+        key: correctResponseClickPluginKey,
+        view(view) {
+            const handleToggle = (event) => {
+                const choiceElement = event.target;
+                // Find the parent interaction
+                const interactionElement = findParentInteraction(choiceElement);
+                if (!interactionElement)
+                    return;
+                // Get all selected identifiers
+                const selectedIdentifiers = getSelectedIdentifiers(interactionElement);
+                // Compute maxChoices and correctResponse
+                const maxChoices = selectedIdentifiers.length <= 1 ? 1 : 0;
+                const correctResponse = selectedIdentifiers.length > 0
+                    ? selectedIdentifiers.join(',')
+                    : null;
+                // Find the node position
+                const pos = findInteractionNodePos(view, interactionElement);
+                if (pos === null)
+                    return;
+                // Update the node attributes
+                const { state, dispatch } = view;
+                const node = state.doc.nodeAt(pos);
+                if (!node)
+                    return;
+                const nextAttrs = {
+                    ...node.attrs,
+                    maxChoices,
+                    correctResponse,
+                };
+                dispatch(state.tr.setNodeMarkup(pos, undefined, nextAttrs));
+            };
+            // Listen for toggle events on the editor DOM
+            view.dom.addEventListener(QTI_CORRECT_RESPONSE_TOGGLE_EVENT, handleToggle);
+            return {
+                destroy() {
+                    view.dom.removeEventListener(QTI_CORRECT_RESPONSE_TOGGLE_EVENT, handleToggle);
+                },
+            };
+        },
+    }));
+}

package/dist/extensions/index.d.ts

@@ -0,0 +1,2 @@
+export { defineCorrectResponseClickExtension, QTI_CORRECT_RESPONSE_CHANGE_EVENT, type QtiCorrectResponseChangeDetail, } from './correct-response-click.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/extensions/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/extensions/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,mCAAmC,EACnC,iCAAiC,EACjC,KAAK,8BAA8B,GACpC,MAAM,6BAA6B,CAAC"}

package/dist/extensions/index.js

@@ -0,0 +1 @@
+export { defineCorrectResponseClickExtension, QTI_CORRECT_RESPONSE_CHANGE_EVENT, } from './correct-response-click.js';

package/dist/index.d.ts

@@ -0,0 +1,10 @@
+export * from './components/qti-choice-interaction/qti-choice-interaction.js';
+export * from './components/qti-choice-interaction/qti-choice-interaction.schema.js';
+export * from './components/qti-choice-interaction/qti-choice-interaction.commands.js';
+export * from './components/qti-choice-interaction/qti-choice-interaction.compose.js';
+export * from './composer/metadata.js';
+export * from './composer/handler.js';
+export * from './attributes/choice-interaction-class-editor.js';
+export * from './extensions/index.js';
+export * from './descriptor.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,+DAA+D,CAAC;AAC9E,cAAc,sEAAsE,CAAC;AACrF,cAAc,wEAAwE,CAAC;AACvF,cAAc,uEAAuE,CAAC;AAEtF,cAAc,wBAAwB,CAAC;AACvC,cAAc,uBAAuB,CAAC;AACtC,cAAc,iDAAiD,CAAC;AAEhE,cAAc,uBAAuB,CAAC;AACtC,cAAc,iBAAiB,CAAC"}

package/dist/index.js

@@ -0,0 +1,9 @@
+export * from './components/qti-choice-interaction/qti-choice-interaction.js';
+export * from './components/qti-choice-interaction/qti-choice-interaction.schema.js';
+export * from './components/qti-choice-interaction/qti-choice-interaction.commands.js';
+export * from './components/qti-choice-interaction/qti-choice-interaction.compose.js';
+export * from './composer/metadata.js';
+export * from './composer/handler.js';
+export * from './attributes/choice-interaction-class-editor.js';
+export * from './extensions/index.js';
+export * from './descriptor.js';

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "@qti-editor/interaction-choice",
+  "description": "QTI choice interaction schemas, components, commands, and composer",
+  "version": "0.1.0",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./*": {
+      "types": "./dist/*",
+      "default": "./dist/*"
+    }
+  },
+  "dependencies": {
+    "@qti-components/base": "^1.4.1",
+    "@qti-components/choice-interaction": "^1.1.0",
+    "@qti-components/interactions": "^1.10.1",
+    "@qti-components/interactions-core": "^1.1.0",
+    "@qti-components/utilities": "^1.3.1",
+    "@qti-editor/interfaces": "0.1.0",
+    "@qti-editor/interaction-shared": "0.1.0"
+  },
+  "peerDependencies": {
+    "lit": "^3.3.1"
+  },
+  "devDependencies": {
+    "lit": "^3.3.1",
+    "prosemirror-commands": "^1.7.1",
+    "prosemirror-model": "^1.25.4",
+    "prosemirror-state": "^1.4.4"
+  },
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "typecheck": "tsc --noEmit",
+    "build": "tsc",
+    "clean": "rm -rf dist"
+  }
+}