@pie-players/pie-assessment-toolkit 0.3.73 → 0.3.75

package/dist/tools/response-discovery.js

@@ -1,113 +0,0 @@
-/**
- * Response Discovery Service
- * Finds and manages PIE response components for tool-to-response integration
- *
- * Enables tools (e.g., calculator) to insert content into response fields
- * Based on capability-based interface pattern (inspired by VS Code extension API)
- */
-export class ResponseDiscoveryServiceImpl {
-    responses = new Map();
-    activeResponseId = null;
-    activeResponseListeners = [];
-    /**
-     * Get currently active (focused) response component
-     */
-    getActiveResponse() {
-        if (!this.activeResponseId) {
-            return null;
-        }
-        return this.responses.get(this.activeResponseId) || null;
-    }
-    /**
-     * Get response by ID
-     */
-    getResponse(responseId) {
-        return this.responses.get(responseId) || null;
-    }
-    /**
-     * Get all registered responses
-     */
-    getAllResponses() {
-        return Array.from(this.responses.values());
-    }
-    /**
-     * Get responses that accept a specific content format
-     */
-    getResponsesAccepting(format) {
-        return this.getAllResponses().filter((response) => {
-            const capabilities = response.getCapabilities();
-            return capabilities.supportedFormats.includes(format);
-        });
-    }
-    /**
-     * Register a response component
-     */
-    registerResponse(response) {
-        this.responses.set(response.responseId, response);
-        console.log(`[ResponseDiscovery] Registered response: ${response.responseId}`);
-        // If this is the first response and no active response, set it as active
-        if (!this.activeResponseId && this.responses.size === 1) {
-            this.setActiveResponse(response.responseId);
-        }
-    }
-    /**
-     * Unregister a response component
-     */
-    unregisterResponse(responseId) {
-        this.responses.delete(responseId);
-        console.log(`[ResponseDiscovery] Unregistered response: ${responseId}`);
-        // If active response was removed, clear it
-        if (this.activeResponseId === responseId) {
-            this.setActiveResponse(null);
-        }
-    }
-    /**
-     * Explicitly signal that a registered response is active.
-     */
-    signalActive(responseId) {
-        if (!this.responses.has(responseId)) {
-            console.warn(`[ResponseDiscovery] Cannot mark active: unknown response ${responseId}`);
-            return;
-        }
-        this.setActiveResponse(responseId);
-    }
-    /**
-     * Explicitly signal that a response is no longer active.
-     */
-    signalInactive(responseId) {
-        if (this.activeResponseId !== responseId)
-            return;
-        this.setActiveResponse(null);
-    }
-    /**
-     * Set active response (internal use)
-     */
-    setActiveResponse(responseId) {
-        if (this.activeResponseId === responseId)
-            return;
-        this.activeResponseId = responseId;
-        const response = responseId ? this.getResponse(responseId) : null;
-        // Notify listeners
-        for (const listener of this.activeResponseListeners) {
-            listener(response);
-        }
-    }
-    /**
-     * Listen for active response changes
-     */
-    onActiveResponseChanged(listener) {
-        this.activeResponseListeners.push(listener);
-    }
-    /**
-     * Clear all responses (for cleanup)
-     */
-    clear() {
-        this.responses.clear();
-        this.activeResponseId = null;
-        this.activeResponseListeners = [];
-    }
-}
-/**
- * Singleton instance
- */
-export const responseDiscovery = new ResponseDiscoveryServiceImpl();

package/dist/tools/types.d.ts

@@ -1,337 +0,0 @@
-/**
- * Tool system type definitions
- */
-export type { CalculationHistoryEntry, Calculator, CalculatorProvider, CalculatorProviderCapabilities, CalculatorProviderConfig, CalculatorState, CalculatorType, } from "@pie-players/pie-calculator";
-export type ToolId = string;
-export interface ToolState {
-    id: ToolId;
-    name: string;
-    isVisible: boolean;
-    isActive: boolean;
-    zIndex: number;
-    element?: HTMLElement;
-}
-export interface ToolPosition {
-    x: number;
-    y: number;
-}
-export interface ToolSize {
-    width: number;
-    height: number;
-}
-export interface ToolConfig {
-    id: ToolId;
-    name: string;
-    icon?: string;
-    enabled: boolean;
-    alwaysAvailable?: boolean;
-}
-export interface AssessmentToolConfig {
-    enabledTools: ToolId[];
-    toolSettings?: Record<ToolId, any>;
-}
-/**
- * Tool allowance: "0" = blocked, "1" = allowed
- * Based on existing platform patterns
- */
-export type ToolAllowance = "0" | "1";
-/**
- * Roster/Test-level tool configuration
- * Defines default tool availability for an assessment
- */
-export interface RosterToolConfiguration {
-    rosterId: string;
-    testId?: string;
-    toolAllowances: Record<string, ToolAllowance>;
-    defaultToolConfigs?: Record<string, ToolConfig>;
-}
-/**
- * Configuration source for tool resolution
- */
-export type ConfigurationSource = "roster-block" | "item-restriction" | "item-requirement" | "student-accommodation" | "roster-default" | "system-default";
-/**
- * Resolved tool configuration with source tracking
- */
-export interface ResolvedToolConfig extends ToolConfig {
-    resolvedFrom: ConfigurationSource;
-    required: boolean;
-    reason: string;
-}
-/**
- * Tool resolution result
- */
-export interface ToolResolutionResult {
-    allowed: boolean;
-    reason: string;
-    source: ConfigurationSource;
-    config?: ToolConfig;
-}
-/**
- * Item-level tool configuration
- */
-export interface ItemToolConfig {
-    itemId: string;
-    requiredTools?: string[];
-    restrictedTools?: string[];
-    toolParameters?: Record<string, ItemToolParameters>;
-    variantConfig?: ItemVariantConfig;
-}
-/**
- * Item tool parameters
- */
-export interface ItemToolParameters {
-    config?: Partial<ToolConfig>;
-    hint?: string;
-    preOpen?: boolean;
-    variants?: Record<string, ItemToolParametersVariant>;
-}
-/**
- * Item tool parameters variant
- */
-export interface ItemToolParametersVariant {
-    config?: Partial<ToolConfig>;
-    hint?: string;
-    preOpen?: boolean;
-}
-/**
- * Item variant configuration for A/B testing and scaffolding
- */
-export interface ItemVariantConfig {
-    variantId?: string;
-    toolOverrides?: Record<string, ItemToolOverride>;
-    adaptations?: ContentAdaptation[];
-    experimental?: Record<string, any>;
-}
-/**
- * Tool override for item variants
- */
-export interface ItemToolOverride {
-    config?: Partial<ToolConfig>;
-    uiVariant?: string;
-    parameters?: Record<string, any>;
-    replacementTool?: string;
-}
-/**
- * Content adaptation types
- */
-export interface ContentAdaptation {
-    type: "scaffolding" | "difficulty" | "language" | "modality" | "custom";
-    level: string | number;
-    affectedTools?: string[];
-    config?: Record<string, any>;
-}
-/**
- * Variant context for resolution
- */
-export interface VariantContext {
-    studentId: string;
-    sessionId: string;
-    language?: string;
-    scaffoldingLevel?: number;
-    difficultyLevel?: string;
-    custom?: Record<string, any>;
-}
-/**
- * Resolved item configuration with variants applied
- */
-export interface ResolvedItemConfig {
-    itemId: string;
-    requiredTools: string[];
-    restrictedTools: string[];
-    toolParameters: Record<string, ResolvedItemToolParameters>;
-    appliedVariant?: string;
-    appliedAdaptations?: ContentAdaptation[];
-}
-/**
- * Resolved item tool parameters
- */
-export interface ResolvedItemToolParameters extends ItemToolParameters {
-    finalConfig: ToolConfig;
-}
-/**
- * Base interface that all tool components should implement
- */
-export interface Tool {
-    /** Unique identifier for this tool */
-    id: ToolId;
-    /** Display name */
-    name: string;
-    /** Show the tool */
-    show(): void;
-    /** Hide the tool */
-    hide(): void;
-    /** Toggle visibility */
-    toggle(): void;
-    /** Cleanup when tool is destroyed */
-    destroy?(): void;
-}
-/**
- * Tool categories for organizational purposes
- */
-export declare enum ToolCategory {
-    STANDALONE = "standalone",
-    CONTENT_INTERACTIVE = "content-interactive",
-    SERVICE_DEPENDENT = "service-dependent"
-}
-/**
- * Tool metadata
- */
-export interface ToolMetadata {
-    id: ToolId;
-    name: string;
-    description: string;
-    category: ToolCategory;
-    icon?: string;
-    dependencies?: string[];
-}
-/**
- * Accommodation Resolver Service
- * Resolves final tool configuration by merging roster, student, and item configs
- * Precedence: Roster block > Item restriction > Item requirement > Student accommodation > Roster default
- */
-export interface AccommodationResolver {
-    /**
-     * Resolve final tools for an item given all configuration sources
-     */
-    resolveToolsForItem(student: AccommodationProfile, roster: RosterToolConfiguration, item: ItemToolConfig): ResolvedToolConfig[];
-    /**
-     * Check if a specific tool is allowed
-     */
-    isToolAllowed(toolType: string, student: AccommodationProfile, roster: RosterToolConfiguration, item: ItemToolConfig): ToolResolutionResult;
-    /**
-     * Get resolution trace for debugging
-     */
-    getResolutionTrace(toolType: string, student: AccommodationProfile, roster: RosterToolConfiguration, item: ItemToolConfig): ResolutionTrace;
-}
-/**
- * Accommodation profile (student-level tool permissions)
- */
-export interface AccommodationProfile {
-    studentId: string;
-    testId?: string;
-    rosterId?: string;
-    accommodations: Record<string, boolean>;
-}
-/**
- * Resolution trace for debugging
- */
-export interface ResolutionTrace {
-    toolType: string;
-    steps: ResolutionStep[];
-    finalDecision: ToolResolutionResult;
-}
-/**
- * Resolution step in trace
- */
-export interface ResolutionStep {
-    source: ConfigurationSource;
-    decision: "allow" | "block" | "require" | "skip";
-    reason: string;
-    config?: Partial<ToolConfig>;
-}
-/**
- * Variant Resolver Service
- * Resolves item configuration considering variants
- */
-export interface VariantResolver {
-    /**
-     * Resolve variant configuration for an item
-     */
-    resolveVariant(itemConfig: ItemToolConfig, context: VariantContext): ResolvedItemConfig;
-}
-/**
- * PIE Response Component Interface
- * For tool-to-response integration (e.g., calculator inserting into text field)
- */
-export interface PIEResponseComponent {
-    readonly responseId: string;
-    readonly responseType: PIEResponseType;
-    getCapabilities(): ResponseCapabilities;
-    canAccept(content: string, format: ContentFormat): boolean;
-    insertContent(content: string, options: InsertionOptions): Promise<InsertionResult>;
-    getContent(format?: ContentFormat): string;
-    getCursorPosition(): number | null;
-    setCursorPosition(position: number): void;
-    focus(): void;
-    isFocused(): boolean;
-    validate(content: string, format: ContentFormat): ValidationResult;
-}
-/**
- * PIE response types
- */
-export type PIEResponseType = "text-entry" | "extended-text-entry" | "math-inline" | "math-block" | "numeric" | "multiple-choice" | "custom";
-/**
- * Response capabilities
- */
-export interface ResponseCapabilities {
-    acceptsPlainText?: boolean;
-    acceptsLatex?: boolean;
-    acceptsNumeric?: boolean;
-    acceptsHtml?: boolean;
-    acceptsFormattedText?: boolean;
-    supportedFormats: ContentFormat[];
-    supportsReplacement?: boolean;
-    supportsInsertion?: boolean;
-    supportsAppend?: boolean;
-    maxLength?: number;
-    allowedCharacters?: string;
-}
-/**
- * Content formats
- */
-export type ContentFormat = "plain-text" | "latex" | "mathml" | "numeric" | "html" | "markdown" | "formatted-text";
-/**
- * Insertion options for response content
- */
-export interface InsertionOptions {
-    mode: "replace" | "insert" | "append";
-    format: ContentFormat;
-    position?: number;
-    select?: boolean;
-    focus?: boolean;
-    source?: {
-        toolId: string;
-        toolType: string;
-        timestamp: number;
-    };
-}
-/**
- * Insertion result
- */
-export interface InsertionResult {
-    success: boolean;
-    error?: string;
-    insertedLength?: number;
-    finalCursorPosition?: number;
-}
-/**
- * Validation result
- */
-export interface ValidationResult {
-    valid: boolean;
-    errors?: ValidationError[];
-    warnings?: string[];
-}
-/**
- * Validation error
- */
-export interface ValidationError {
-    code: string;
-    message: string;
-    position?: number;
-}
-/**
- * Response Discovery Service
- * Finds and manages PIE response components for tool integration
- */
-export interface ResponseDiscoveryService {
-    getActiveResponse(): PIEResponseComponent | null;
-    getResponse(responseId: string): PIEResponseComponent | null;
-    getAllResponses(): PIEResponseComponent[];
-    getResponsesAccepting(format: ContentFormat): PIEResponseComponent[];
-    registerResponse(response: PIEResponseComponent): void;
-    unregisterResponse(responseId: string): void;
-    signalActive(responseId: string): void;
-    signalInactive(responseId: string): void;
-    onActiveResponseChanged(listener: (response: PIEResponseComponent | null) => void): void;
-}

package/dist/tools/types.js

@@ -1,12 +0,0 @@
-/**
- * Tool system type definitions
- */
-/**
- * Tool categories for organizational purposes
- */
-export var ToolCategory;
-(function (ToolCategory) {
-    ToolCategory["STANDALONE"] = "standalone";
-    ToolCategory["CONTENT_INTERACTIVE"] = "content-interactive";
-    ToolCategory["SERVICE_DEPENDENT"] = "service-dependent";
-})(ToolCategory || (ToolCategory = {}));

package/dist/tools/variant-resolver.d.ts

@@ -1,41 +0,0 @@
-/**
- * Variant Resolver Service
- * Resolves item configuration considering variants for A/B testing, scaffolding, and adaptations
- *
- * Based on architectural enhancements for item-level variant configuration
- */
-import type { ItemToolConfig, ResolvedItemConfig, VariantContext, VariantResolver } from "./types.js";
-export declare class VariantResolverImpl implements VariantResolver {
-    /**
-     * Resolve variant configuration for an item
-     */
-    resolveVariant(itemConfig: ItemToolConfig, context: VariantContext): ResolvedItemConfig;
-    /**
-     * Resolve tool parameters considering variant and context
-     */
-    private _resolveToolParameters;
-    /**
-     * Select variant parameters based on context
-     */
-    private _selectVariantParameters;
-    /**
-     * Create tool parameters from override
-     */
-    private _createToolParametersFromOverride;
-    /**
-     * Resolve required tools considering overrides
-     */
-    private _resolveRequiredTools;
-    /**
-     * Filter adaptations based on context
-     */
-    private _filterAdaptations;
-    /**
-     * Build resolved config without variants
-     */
-    private _buildResolvedConfig;
-    /**
-     * Convert tool type to human-readable name
-     */
-    private _humanizeName;
-}

package/dist/tools/variant-resolver.js

@@ -1,207 +0,0 @@
-/**
- * Variant Resolver Service
- * Resolves item configuration considering variants for A/B testing, scaffolding, and adaptations
- *
- * Based on architectural enhancements for item-level variant configuration
- */
-export class VariantResolverImpl {
-    /**
-     * Resolve variant configuration for an item
-     */
-    resolveVariant(itemConfig, context) {
-        // If no variant config, return item as-is
-        if (!itemConfig.variantConfig) {
-            return this._buildResolvedConfig(itemConfig, null, []);
-        }
-        const { variantConfig } = itemConfig;
-        const { variantId, toolOverrides, adaptations } = variantConfig;
-        // Apply tool overrides if variant specified
-        const resolvedToolParameters = {};
-        if (itemConfig.toolParameters) {
-            for (const [toolType, params] of Object.entries(itemConfig.toolParameters)) {
-                resolvedToolParameters[toolType] = this._resolveToolParameters(toolType, params, toolOverrides, context);
-            }
-        }
-        // Apply tool overrides that aren't in original tool parameters
-        if (toolOverrides) {
-            for (const [toolType, override] of Object.entries(toolOverrides)) {
-                if (!resolvedToolParameters[toolType]) {
-                    resolvedToolParameters[toolType] =
-                        this._createToolParametersFromOverride(toolType, override);
-                }
-            }
-        }
-        // Build final resolved config
-        return {
-            itemId: itemConfig.itemId,
-            requiredTools: this._resolveRequiredTools(itemConfig, toolOverrides),
-            restrictedTools: itemConfig.restrictedTools || [],
-            toolParameters: resolvedToolParameters,
-            appliedVariant: variantId,
-            appliedAdaptations: this._filterAdaptations(adaptations, context),
-        };
-    }
-    /**
-     * Resolve tool parameters considering variant and context
-     */
-    _resolveToolParameters(toolType, params, toolOverrides, context) {
-        // Start with base parameters
-        let finalConfig = params.config || {};
-        let finalHint = params.hint;
-        let finalPreOpen = params.preOpen;
-        // Apply variant-specific parameters if they exist
-        if (params.variants) {
-            const variantParams = this._selectVariantParameters(params.variants, context);
-            if (variantParams) {
-                finalConfig = { ...finalConfig, ...variantParams.config };
-                if (variantParams.hint !== undefined)
-                    finalHint = variantParams.hint;
-                if (variantParams.preOpen !== undefined)
-                    finalPreOpen = variantParams.preOpen;
-            }
-        }
-        // Apply tool override from variant config
-        if (toolOverrides && toolOverrides[toolType]) {
-            const override = toolOverrides[toolType];
-            if (override.config) {
-                finalConfig = { ...finalConfig, ...override.config };
-            }
-            if (override.parameters) {
-                // Merge additional parameters
-                finalConfig = { ...finalConfig, ...override.parameters };
-            }
-        }
-        return {
-            config: params.config,
-            hint: finalHint,
-            preOpen: finalPreOpen,
-            variants: params.variants,
-            finalConfig: finalConfig,
-        };
-    }
-    /**
-     * Select variant parameters based on context
-     */
-    _selectVariantParameters(variants, context) {
-        // Strategy: Select based on context properties
-        // 1. Check for scaffolding level match
-        if (context.scaffoldingLevel !== undefined) {
-            const scaffoldKey = `scaffolding-${context.scaffoldingLevel}`;
-            if (variants[scaffoldKey])
-                return variants[scaffoldKey];
-        }
-        // 2. Check for difficulty level match
-        if (context.difficultyLevel) {
-            const difficultyKey = `difficulty-${context.difficultyLevel}`;
-            if (variants[difficultyKey])
-                return variants[difficultyKey];
-        }
-        // 3. Check for language match
-        if (context.language) {
-            const langKey = `lang-${context.language}`;
-            if (variants[langKey])
-                return variants[langKey];
-        }
-        // 4. Check custom context keys
-        if (context.custom) {
-            for (const [key, value] of Object.entries(context.custom)) {
-                const customKey = `${key}-${value}`;
-                if (variants[customKey])
-                    return variants[customKey];
-            }
-        }
-        // 5. Check for default variant
-        if (variants.default)
-            return variants.default;
-        return null;
-    }
-    /**
-     * Create tool parameters from override
-     */
-    _createToolParametersFromOverride(toolType, override) {
-        return {
-            config: override.config,
-            hint: override.hint,
-            preOpen: override.preOpen,
-            finalConfig: {
-                id: toolType,
-                name: this._humanizeName(toolType),
-                enabled: true,
-                ...override.config,
-            },
-        };
-    }
-    /**
-     * Resolve required tools considering overrides
-     */
-    _resolveRequiredTools(itemConfig, toolOverrides) {
-        const required = new Set(itemConfig.requiredTools || []);
-        // Add tools that have replacements via overrides
-        if (toolOverrides) {
-            for (const [toolType, override] of Object.entries(toolOverrides)) {
-                if (override.replacementTool) {
-                    required.delete(toolType);
-                    required.add(override.replacementTool);
-                }
-            }
-        }
-        return Array.from(required);
-    }
-    /**
-     * Filter adaptations based on context
-     */
-    _filterAdaptations(adaptations, context) {
-        if (!adaptations)
-            return [];
-        return adaptations.filter((adaptation) => {
-            // Check if adaptation matches context
-            if (adaptation.type === "scaffolding" &&
-                context.scaffoldingLevel !== undefined) {
-                return adaptation.level === context.scaffoldingLevel;
-            }
-            if (adaptation.type === "difficulty" && context.difficultyLevel) {
-                return adaptation.level === context.difficultyLevel;
-            }
-            if (adaptation.type === "language" && context.language) {
-                return adaptation.level === context.language;
-            }
-            // Include custom adaptations by default
-            return true;
-        });
-    }
-    /**
-     * Build resolved config without variants
-     */
-    _buildResolvedConfig(itemConfig, variantId, adaptations) {
-        const resolvedToolParameters = {};
-        if (itemConfig.toolParameters) {
-            for (const [toolType, params] of Object.entries(itemConfig.toolParameters)) {
-                resolvedToolParameters[toolType] = {
-                    ...params,
-                    finalConfig: {
-                        id: toolType,
-                        name: this._humanizeName(toolType),
-                        enabled: true,
-                        ...params.config,
-                    },
-                };
-            }
-        }
-        return {
-            itemId: itemConfig.itemId,
-            requiredTools: itemConfig.requiredTools || [],
-            restrictedTools: itemConfig.restrictedTools || [],
-            toolParameters: resolvedToolParameters,
-            appliedVariant: variantId || undefined,
-            appliedAdaptations: adaptations,
-        };
-    }
-    /**
-     * Convert tool type to human-readable name
-     */
-    _humanizeName(toolType) {
-        return toolType
-            .replace(/[-_]/g, " ")
-            .replace(/\b\w/g, (char) => char.toUpperCase());
-    }
-}