@citolab/qti-components 7.16.0 → 7.16.1

package/dist/processing.d.ts

@@ -1 +1,393 @@
-export * from '@qti-components/processing';
+import * as lit from 'lit';
+import { LitElement, nothing } from 'lit';
+import { c as QtiRuleBase, b as QtiExpression, a as QtiExpressionBase, Q as QtiConditionExpression } from './qti-rule-base-dL4opfvi.js';
+import { I as ItemContext } from './item.context-BRKXBC3m.js';
+import { B as BaseType, k as ResponseVariable, h as VariableDeclaration } from './variables-CusMRnyJ.js';
+import { T as TestContext } from './test.context-Bpw1HNAZ.js';
+
+declare class QtiRule extends LitElement implements QtiRuleBase {
+    render(): lit.TemplateResult<1>;
+    process(): void;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'qti-rule': QtiRule;
+    }
+}
+
+/**
+ * The lookupOutcomeValue rule sets the value of an outcome variable to the value obtained
+ * by looking up the value of the associated expression in the lookupTable associated
+ * with the outcome's declaration.
+ */
+declare class QtiLookupOutcomeValue extends QtiRule {
+    identifier: string;
+    protected context?: ItemContext;
+    get childExpression(): QtiExpression<string>;
+    process(): number;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'qti-lookup-outcome-value': QtiLookupOutcomeValue;
+    }
+}
+
+declare class QtiResponseCondition extends QtiRule {
+    render(): lit.TemplateResult<1>;
+    process(): void;
+}
+
+/**
+ * Web component that processes `setOutcomeValue` in QTI.
+ */
+declare class QtiSetOutcomeValue extends QtiRule {
+    /**
+     * Processes the QTI rule and dispatches a custom event with the computed outcome value.
+     */
+    process(): void;
+    /**
+     * Formats the computed value before dispatching.
+     * Ensures numbers are converted to a universal format.
+     */
+    private formatValue;
+}
+/**
+ * Encapsulates the logic for processing QTI setOutcomeValue expressions.
+ */
+declare class QtiSetOutcomeValueRule<T> implements QtiRuleBase {
+    private expression;
+    constructor(expression: QtiExpressionBase<T>);
+    /**
+     * Evaluates the expression and returns its value.
+     */
+    process(): string | string[] | null;
+}
+
+declare class QtiResponseElse extends LitElement {
+    render(): lit.TemplateResult<1>;
+    calculate(): boolean;
+    getSubRules(): QtiRule[];
+    process(): void;
+}
+
+declare class QtiResponseIf extends QtiResponseElse {
+    calculate(): boolean;
+    getSubRules(): QtiRule[];
+}
+
+declare class QtiResponseElseIf extends QtiResponseIf {
+    render(): lit.TemplateResult<1>;
+}
+
+type Constructor$1<T> = new (...args: any[]) => T;
+declare const QtiAnd_base: {
+    new (...args: any[]): {
+        calculateChildren(children: Array<MockQtiExpression$1<any>>): boolean;
+    };
+} & Constructor$1<QtiConditionExpression>;
+declare class QtiAnd extends QtiAnd_base {
+    calculate(): boolean;
+}
+type MockQtiExpression$1<T> = {
+    calculate: () => T;
+};
+type MockConstructor$1 = new (...args: any[]) => {};
+declare function qtiAndMixin<TBase extends MockConstructor$1>(Base: TBase): {
+    new (...args: any[]): {
+        calculateChildren(children: Array<MockQtiExpression$1<any>>): boolean;
+    };
+} & TBase;
+
+declare class QtiBaseValue extends QtiExpression<string> {
+    baseType: BaseType;
+    getResult(): string;
+}
+
+/**
+ * @summary The qti-container-size operator returns the number of values in a container.
+ * @documentation https://www.imsglobal.org/spec/qti/v3p0/impl#h.container-size
+ *
+ * Takes a sub-expression with any base-type and either multiple or ordered cardinality.
+ * Returns an integer giving the number of values in the container.
+ * Returns 0 if the sub-expression is NULL.
+ */
+declare class QtiContainerSize extends QtiExpression<number> {
+    getResult(): number;
+}
+
+declare class QtiContains extends QtiConditionExpression {
+    getResult(): boolean;
+}
+
+declare class QtiCorrect extends QtiExpression<string | string[]> {
+    get interpretation(): string;
+    getResult(): string | string[];
+}
+
+/**
+ * @summary The qti-default expression returns the default value of a declared variable.
+ * @documentation https://www.imsglobal.org/spec/qti/v3p0/impl#h.default
+ *
+ * Looks up the declaration of an itemVariable and returns the associated defaultValue
+ * or NULL if no default value was declared. Supports item identifier prefixing
+ * for obtaining default values from individual items in outcomes processing.
+ */
+declare class QtiDefault extends QtiExpression<any> {
+    identifier: string;
+    protected context?: ItemContext;
+    protected _testContext?: TestContext;
+    getResult(): any;
+}
+
+declare class QtiEqualRounded extends QtiExpression<boolean> {
+    roundingMode: 'decimalPlaces' | 'significantFigures';
+    get figures(): number;
+    getResult(): boolean;
+}
+
+/**
+ * @summary The qti-round operator rounds a numerical value to the nearest integer.
+ * @documentation https://www.imsglobal.org/spec/qti/v3p0/impl#h.round
+ *
+ * Takes a single sub-expression with single cardinality and numerical base-type.
+ * Returns an integer formed by rounding the value using the rule: n for all input
+ * values in the range [n-0.5, n+0.5). For example, 6.8 and 6.5 both round to 7,
+ * 6.49 rounds to 6, and -6.5 rounds to -6.
+ */
+declare class QtiRound extends QtiExpression<number | null> {
+    getResult(): number | null;
+}
+
+/**
+ * @summary The qti-round-to operator rounds a numerical value to specified precision.
+ * @documentation https://www.imsglobal.org/spec/qti/v3p0/impl#h.round-to
+ *
+ * Takes one sub-expression with single cardinality and numerical base-type.
+ * Returns a single float rounded by the specified method to the specified precision.
+ * Supports rounding to decimal places or significant figures.
+ */
+declare class QtiRoundTo extends QtiExpression<number | null> {
+    roundingMode: 'decimalPlaces' | 'significantFigures';
+    figures: number;
+    getResult(): number | null;
+    /**
+     * Round to specified number of decimal places
+     */
+    private _roundToDecimalPlaces;
+    /**
+     * Round to specified number of significant figures
+     */
+    private _roundToSignificantFigures;
+}
+
+declare class QtiEqual extends QtiExpression<boolean> {
+    toleranceMode: 'exact' | 'relative' | 'absolute';
+    getResult(): boolean;
+}
+
+/**
+ * @summary The qti-gcd operator calculates the greatest common divisor of integer values.
+ * @documentation https://www.imsglobal.org/spec/qti/v3p0/impl#h.gcd
+ *
+ * Takes 1 or more sub-expressions with base-type integer and any cardinality.
+ * Returns a single integer equal to the greatest common divisor of all argument values.
+ * Special cases: gcd(0,0)=0, gcd(0,n)=n if n≠0, returns NULL if any argument is NULL or non-numerical.
+ */
+declare class QtiGcd extends QtiExpression<number | null> {
+    getResult(): number | null;
+    /**
+     * Calculate the greatest common divisor of an array of integers
+     */
+    private _calculateGcd;
+    /**
+     * Calculate GCD of two numbers using Euclidean algorithm
+     */
+    private _gcdTwoNumbers;
+}
+
+declare class QtiGt extends QtiExpression<boolean> {
+    getResult(): boolean;
+}
+
+declare class QtiGte extends QtiConditionExpression {
+    getResult(): boolean;
+}
+
+/**
+ * @summary The qti-null expression returns the NULL value.
+ * @documentation https://www.imsglobal.org/spec/qti/v3p0/impl#h.null
+ *
+ * A simple expression that returns the NULL value. The null value is treated
+ * as if it is of any desired base-type.
+ */
+declare class QtiNull extends QtiExpression<null> {
+    getResult(): null;
+}
+
+declare class QtiIsNull extends QtiExpression<boolean> {
+    getResult(): boolean;
+}
+
+declare class QtiFieldValue extends QtiExpression<string | string[]> {
+    getResult(): any;
+}
+
+declare class QtiLt extends QtiExpression<boolean> {
+    getResult(): boolean;
+}
+
+declare class QtiLte extends QtiConditionExpression {
+    getResult(): boolean;
+}
+
+declare class QtiMapResponse extends QtiExpression<number> {
+    identifier: string;
+    getResult(): number;
+}
+
+declare class QtiMapResponsePoint extends QtiExpression<number> {
+    identifier: string;
+    getResult(): number;
+}
+
+/**
+ * @summary The qti-math-operator performs mathematical operations on numerical values.
+ * @documentation https://www.imsglobal.org/spec/qti/v3p0/impl#h.math-operator
+ *
+ * Takes 1 or more sub-expressions with single cardinality and numerical base-types.
+ * The result is a single float, except for signum, floor and ceil which return integers.
+ * Returns NULL if any argument is NULL or falls outside the function's natural domain.
+ */
+declare class QtiMathOperator extends QtiExpression<number | null> {
+    name: string;
+    getResult(): number | null;
+    private _performOperation;
+}
+
+declare class QtiMatch extends QtiExpression<boolean> {
+    getResult(): boolean;
+    static match(valueToMap: ResponseVariable, correctValueInfo: ResponseVariable): boolean;
+}
+
+declare class QtiMember extends QtiExpression<boolean | null> {
+    getResult(): boolean;
+}
+
+declare class QtiMultiple extends QtiExpression<VariableDeclaration<string | string[]>[]> {
+    getResult(): ResponseVariable[];
+}
+
+declare class QtiNot extends QtiExpression<boolean> {
+    render(): lit.TemplateResult<1>;
+    getResult(): boolean;
+}
+
+declare class QtiOr extends QtiConditionExpression {
+    getResult(): boolean;
+}
+
+declare class QtiOrdered extends QtiExpression<ResponseVariable[]> {
+    getResult(): ResponseVariable[];
+}
+
+/**
+ * @summary The qti-power operator raises the first expression to the power of the second.
+ * @documentation https://www.imsglobal.org/spec/qti/v3p0/impl#h.power
+ *
+ * Takes 2 sub-expressions with single cardinality and numerical base-types.
+ * Returns a single float corresponding to the first expression raised to the power of the second.
+ * Returns NULL if either expression is NULL or if the result is outside the float value set.
+ */
+declare class QtiPower extends QtiExpression<number | null> {
+    getResult(): number | null;
+}
+
+declare class QtiPrintedVariable extends LitElement {
+    identifier: string;
+    protected context?: ItemContext;
+    render(): lit.TemplateResult<1> | typeof nothing;
+    calculate(): VariableDeclaration<string | string[]>;
+}
+
+declare class QtiProduct extends QtiExpression<number> {
+    getResult(): number;
+}
+
+type Constructor<T> = new (...args: any[]) => T;
+declare const QtiSubtract_base: {
+    new (...args: any[]): {
+        calculateChildren(children: Array<MockQtiExpression<any>>): number;
+    };
+} & Constructor<QtiExpression<number>>;
+declare class QtiSubtract extends QtiSubtract_base {
+    getResult(): number;
+}
+type MockQtiExpression<T> = {
+    calculate: () => T;
+};
+type MockConstructor = new (...args: any[]) => {};
+declare function qtiSubtractMixin<TBase extends MockConstructor>(Base: TBase): {
+    new (...args: any[]): {
+        calculateChildren(children: Array<MockQtiExpression<any>>): number;
+    };
+} & TBase;
+
+declare global {
+    interface HTMLElementTagNameMap {
+        'qti-subtract': QtiSubtract;
+    }
+}
+
+declare class QtiStringMatch extends QtiExpression<boolean> {
+    caseSensitive: string;
+    getResult(): boolean;
+}
+
+declare class QtiSum extends QtiExpression<number> {
+    private _expression;
+    constructor();
+    getResult(): number;
+}
+declare class QtiSumExpression implements QtiExpressionBase<number> {
+    private expressions;
+    constructor(expressions: QtiExpressionBase<number>[]);
+    calculate(): number;
+}
+
+declare class QtiVariable extends QtiExpression<string | string[]> {
+    getResult(): Readonly<string | string[]>;
+}
+
+/**
+ * @summary The qti-random-integer operator selects a random integer from a specified range.
+ * @documentation https://www.imsglobal.org/spec/qti/v3p0/impl#h.random-integer
+ *
+ * Selects a random integer from the range [min,max] satisfying min + step * n for some integer n.
+ * For example, with min=2, max=11 and step=3 the values {2,5,8,11} are possible.
+ */
+declare class QtiRandomInteger extends QtiExpression<number> {
+    min: number;
+    max: number;
+    step: number;
+    getResult(): number;
+    /**
+     * Get all possible values for testing purposes
+     */
+    getPossibleValues(): number[];
+}
+
+declare class QtiRandom extends QtiExpression<string> {
+    getResult(): any;
+}
+
+declare class QtiDelete extends QtiExpression<string[] | null> {
+    getResult(): string[] | null;
+}
+
+declare class QtiIndex extends QtiExpression<any> {
+    n: string;
+    getResult(): any;
+    private lookupVariableValue;
+}
+
+export { QtiAnd, QtiBaseValue, QtiContainerSize, QtiContains, QtiCorrect, QtiDefault, QtiDelete, QtiEqual, QtiEqualRounded, QtiFieldValue, QtiGcd, QtiGt, QtiGte, QtiIndex, QtiIsNull, QtiLookupOutcomeValue, QtiLt, QtiLte, QtiMapResponse, QtiMapResponsePoint, QtiMatch, QtiMathOperator, QtiMember, QtiMultiple, QtiNot, QtiNull, QtiOr, QtiOrdered, QtiPower, QtiPrintedVariable, QtiProduct, QtiRandom, QtiRandomInteger, QtiResponseCondition, QtiResponseElse, QtiResponseElseIf, QtiResponseIf, QtiRound, QtiRoundTo, QtiSetOutcomeValue, QtiSetOutcomeValueRule, QtiStringMatch, QtiSubtract, QtiSum, QtiSumExpression, QtiVariable, qtiAndMixin, qtiSubtractMixin };

package/dist/processing.js

@@ -1,3 +1,103 @@
-// src/processing.ts
-export * from "@qti-components/processing";
+import {
+  QtiAnd,
+  QtiBaseValue,
+  QtiContainerSize,
+  QtiContains,
+  QtiCorrect,
+  QtiDefault,
+  QtiDelete,
+  QtiEqual,
+  QtiEqualRounded,
+  QtiFieldValue,
+  QtiGcd,
+  QtiGt,
+  QtiGte,
+  QtiIndex,
+  QtiIsNull,
+  QtiLookupOutcomeValue,
+  QtiLt,
+  QtiLte,
+  QtiMapResponse,
+  QtiMapResponsePoint,
+  QtiMatch,
+  QtiMathOperator,
+  QtiMember,
+  QtiMultiple,
+  QtiNot,
+  QtiNull,
+  QtiOr,
+  QtiOrdered,
+  QtiPower,
+  QtiPrintedVariable,
+  QtiProduct,
+  QtiRandom,
+  QtiRandomInteger,
+  QtiResponseCondition,
+  QtiResponseElse,
+  QtiResponseElseIf,
+  QtiResponseIf,
+  QtiRound,
+  QtiRoundTo,
+  QtiSetOutcomeValue,
+  QtiSetOutcomeValueRule,
+  QtiStringMatch,
+  QtiSubtract,
+  QtiSum,
+  QtiSumExpression,
+  QtiVariable,
+  qtiAndMixin,
+  qtiSubtractMixin
+} from "./chunk-RI47B4ZT.js";
+import "./chunk-JEUY3MYB.js";
+import "./chunk-EUXUH3YW.js";
+export {
+  QtiAnd,
+  QtiBaseValue,
+  QtiContainerSize,
+  QtiContains,
+  QtiCorrect,
+  QtiDefault,
+  QtiDelete,
+  QtiEqual,
+  QtiEqualRounded,
+  QtiFieldValue,
+  QtiGcd,
+  QtiGt,
+  QtiGte,
+  QtiIndex,
+  QtiIsNull,
+  QtiLookupOutcomeValue,
+  QtiLt,
+  QtiLte,
+  QtiMapResponse,
+  QtiMapResponsePoint,
+  QtiMatch,
+  QtiMathOperator,
+  QtiMember,
+  QtiMultiple,
+  QtiNot,
+  QtiNull,
+  QtiOr,
+  QtiOrdered,
+  QtiPower,
+  QtiPrintedVariable,
+  QtiProduct,
+  QtiRandom,
+  QtiRandomInteger,
+  QtiResponseCondition,
+  QtiResponseElse,
+  QtiResponseElseIf,
+  QtiResponseIf,
+  QtiRound,
+  QtiRoundTo,
+  QtiSetOutcomeValue,
+  QtiSetOutcomeValueRule,
+  QtiStringMatch,
+  QtiSubtract,
+  QtiSum,
+  QtiSumExpression,
+  QtiVariable,
+  qtiAndMixin,
+  qtiSubtractMixin
+};
 //# sourceMappingURL=processing.js.map

package/dist/processing.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/processing.ts"],"sourcesContent":["export * from '@qti-components/processing';\n"],"mappings":";AAAA,cAAc;","names":[]}
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/qti-feedback-B4cMzOcq.d.ts

@@ -0,0 +1,21 @@
+import * as lit from 'lit';
+import { LitElement } from 'lit';
+import { a as Cardinality } from './variables-CusMRnyJ.js';
+
+declare abstract class QtiVariableDeclaration extends LitElement {
+    render(): lit.TemplateResult<1>;
+    protected defaultValues(cardinality: Cardinality): string | string[];
+}
+
+declare abstract class QtiFeedback extends LitElement {
+    protected showHide: string;
+    outcomeIdentifier: string;
+    protected identifier: string;
+    showStatus: string;
+    private _context?;
+    connectedCallback(): void;
+    checkShowFeedback(outcomeIdentifier: string): void;
+    private showFeedback;
+}
+
+export { QtiVariableDeclaration as Q, QtiFeedback as a };

package/dist/qti-rule-base-dL4opfvi.d.ts

@@ -0,0 +1,39 @@
+import * as lit from 'lit';
+import { LitElement } from 'lit';
+import { a as QtiContext, Q as QtiContextType } from './test.context-Bpw1HNAZ.js';
+import { k as ResponseVariable, h as VariableDeclaration } from './variables-CusMRnyJ.js';
+import { I as ItemContext } from './item.context-BRKXBC3m.js';
+
+interface QtiExpressionBase<T> {
+    calculate(): Readonly<T>;
+}
+declare abstract class QtiExpression<T> extends LitElement implements QtiExpressionBase<T> {
+    protected result: any;
+    static styles: lit.CSSResult;
+    render(): lit.TemplateResult<1>;
+    calculate(): Readonly<T>;
+    protected getResult(): Readonly<T>;
+    protected context?: ItemContext;
+    protected qtiContext?: QtiContext;
+    getVariables: () => (ResponseVariable | VariableDeclaration<QtiContextType>)[];
+}
+
+declare abstract class QtiConditionExpression extends QtiExpression<boolean> {
+    calculate(): Readonly<boolean>;
+    getResult(): Readonly<boolean>;
+}
+
+/**
+ * Interface for any object that can process QTI rules
+ */
+interface QtiRuleBase {
+    process(): any;
+}
+/**
+ * Abstract base class for QTI rule DOM elements
+ */
+declare abstract class QtiRuleElement extends LitElement implements QtiRuleBase {
+    abstract process(): any;
+}
+
+export { QtiConditionExpression as Q, type QtiExpressionBase as a, QtiExpression as b, type QtiRuleBase as c, QtiRuleElement as d };

package/dist/qti-transform-test-Bz9A3hmD.d.ts

@@ -0,0 +1,63 @@
+interface ModuleResolutionConfig {
+    waitSeconds?: number;
+    context?: string;
+    catchError?: boolean;
+    urlArgs?: string;
+    paths: {
+        [key: string]: string | string[];
+    };
+    shim?: {
+        [key: string]: {
+            deps?: string[];
+            exports?: string;
+        };
+    };
+}
+type transformItemApi = {
+    load: (uri: string, signal?: AbortSignal) => Promise<transformItemApi>;
+    parse: (xmlString: string) => transformItemApi;
+    path: (location: string) => transformItemApi;
+    fn: (fn: (xmlFragment: XMLDocument) => void) => transformItemApi;
+    pciHooks: (uri: string) => transformItemApi;
+    configurePci: (baseUrl: string, getModuleResolutionConfig: (baseUrl: string, fileUrl: string) => Promise<ModuleResolutionConfig>, selector?: string) => Promise<transformItemApi>;
+    extendElementName: (elementName: string, extend: string) => transformItemApi;
+    extendElementsWithClass: (param?: string) => transformItemApi;
+    customInteraction: (baseRef: string, baseItem: string) => transformItemApi;
+    convertCDATAtoComment: () => transformItemApi;
+    shuffleInteractions: () => transformItemApi;
+    stripStyleSheets: () => transformItemApi;
+    html: () => string;
+    xml: () => string;
+    htmlDoc: () => DocumentFragment;
+    xmlDoc: () => XMLDocument;
+};
+declare const qtiTransformItem: (cache?: boolean) => transformItemApi;
+
+/**
+ * Returns an object with methods to load, parse and transform QTI tests.
+ * @returns An object with methods to load, parse and transform QTI tests.
+ * @example
+ * const qtiTransformer = qtiTransformTest();
+ * await qtiTransformer.load('https://example.com/test.xml');
+ * const items = qtiTransformer.items();
+ * const html = qtiTransformer.html();
+ * const xml = qtiTransformer.xml();
+ */
+type transformTestApi = {
+    load: (uri: string, signal?: AbortSignal) => Promise<transformTestApi>;
+    parse: (xmlString: string) => transformTestApi;
+    path: (location: string) => transformTestApi;
+    fn: (fn: (xmlFragment: XMLDocument) => void) => transformTestApi;
+    items: () => {
+        identifier: string;
+        href: string;
+        category: string;
+    }[];
+    html: () => string;
+    xml: () => string;
+    htmlDoc: () => DocumentFragment;
+    xmlDoc: () => XMLDocument;
+};
+declare const qtiTransformTest: () => transformTestApi;
+
+export { type ModuleResolutionConfig as M, type transformTestApi as a, qtiTransformTest as b, qtiTransformItem as q, type transformItemApi as t };

package/dist/test.context-Bpw1HNAZ.d.ts

@@ -0,0 +1,28 @@
+import { I as ItemContext } from './item.context-BRKXBC3m.js';
+import { h as VariableDeclaration } from './variables-CusMRnyJ.js';
+
+type QtiContextType = {
+    testIdentifier: string;
+    candidateIdentifier: string;
+    environmentIdentifier: string;
+    [key: string]: string | string[];
+};
+interface QtiContext {
+    QTI_CONTEXT: QtiContextType;
+}
+declare const qtiContext: {
+    __context__: Readonly<QtiContext>;
+};
+
+interface TestContext {
+    items: (ItemContext & {
+        category?: string;
+    })[];
+    testOutcomeVariables?: VariableDeclaration<string | string[] | null>[];
+}
+declare const INITIAL_TEST_CONTEXT: Readonly<TestContext>;
+declare const testContext: {
+    __context__: Readonly<TestContext>;
+};
+
+export { INITIAL_TEST_CONTEXT as I, type QtiContextType as Q, type TestContext as T, type QtiContext as a, qtiContext as q, testContext as t };