coursecode 0.1.0

package/framework/js/core/component-catalog.js

@@ -0,0 +1,121 @@
+/**
+ * Component Catalog
+ * 
+ * Single source of truth for all UI components (built-in and custom).
+ * Uses import.meta.glob for auto-discovery - just drop a file in the folder.
+ * 
+ * Mirrors the interaction-catalog.js pattern for consistency.
+ */
+
+const catalog = new Map();
+
+/**
+ * Register a component type
+ * @param {string} type - Component type name (kebab-case, matches data-component value)
+ * @param {object} definition - { init?, metadata?, schema, styles? }
+ */
+export function catalogComponent(type, { init, metadata, schema, styles }) {
+    if (!schema) {
+        throw new Error(`[ComponentCatalog] Cannot register "${type}" without a schema`);
+    }
+    catalog.set(type, { init, metadata, schema, styles });
+}
+
+/**
+ * Get the init function for a component type
+ * @param {string} type - Component type name
+ * @returns {function|undefined}
+ */
+export function getComponentInit(type) {
+    return catalog.get(type)?.init;
+}
+
+/**
+ * Get metadata for a component type
+ * @param {string} type - Component type name
+ * @returns {object|undefined}
+ */
+export function getComponentMetadata(type) {
+    return catalog.get(type)?.metadata;
+}
+
+/**
+ * Get schema for a component type
+ * @param {string} type - Component type name
+ * @returns {object|undefined}
+ */
+export function getComponentSchema(type) {
+    return catalog.get(type)?.schema;
+}
+
+/**
+ * Get styles for a component type (for custom components with CSS-in-JS)
+ * @param {string} type - Component type name
+ * @returns {string|undefined}
+ */
+export function getComponentStyles(type) {
+    return catalog.get(type)?.styles;
+}
+
+/**
+ * Get all registered schemas
+ * @returns {object} Map of type -> schema
+ */
+export function getAllComponentSchemas() {
+    const schemas = {};
+    for (const [type, def] of catalog) {
+        if (def.schema) {
+            schemas[type] = def.schema;
+        }
+    }
+    return schemas;
+}
+
+/**
+ * Get all registered type names
+ * @returns {string[]}
+ */
+export function getRegisteredComponentTypes() {
+    return [...catalog.keys()];
+}
+
+/**
+ * Check if a type is registered
+ * @param {string} type
+ * @returns {boolean}
+ */
+export function isComponentRegistered(type) {
+    return catalog.has(type);
+}
+
+// =============================================================================
+// Auto-discover Components (Built-in UI + Custom)
+// =============================================================================
+
+// Built-in UI components
+const uiComponentModules = import.meta.glob('../components/ui-components/*.js', { eager: true });
+
+// Course-specific custom components
+const customComponentModules = import.meta.glob('../../../course/components/*.js', { eager: true });
+
+/**
+ * Register all discovered modules.
+ * Convention: per-element initializer is exported as `init`.
+ */
+function registerModules(modules) {
+    for (const [path, module] of Object.entries(modules)) {
+        // Skip index/base files
+        if (path.includes('index.js') || path.includes('-base')) continue;
+        
+        // Each component exports: schema (required), metadata (optional), init (optional), styles (optional)
+        const { schema, metadata, styles, init } = module;
+        
+        if (!schema?.type) continue;
+        
+        catalogComponent(schema.type, { init, metadata, schema, styles });
+    }
+}
+
+// Register synchronously - modules are eagerly loaded
+registerModules(uiComponentModules);
+registerModules(customComponentModules);

package/framework/js/core/event-bus.js

@@ -0,0 +1,178 @@
+import { generateId } from '../utilities/utilities.js';
+import { logger } from '../utilities/logger.js';
+
+class EventBus {
+  constructor() {
+    // Event listeners registry
+    this.events = {};
+  }
+
+  /**
+   * Subscribe to an event
+   * 
+   * @param {string} event - Event name
+   * @param {Function} callback - Callback function
+   * @param {Object} options - Optional configuration
+   * @returns {Function} Unsubscribe function
+   */
+  on(event, callback, options = {}) {
+    if (!event || typeof callback !== 'function') {
+      throw new Error('Event name and callback are required');
+    }
+
+    if (!this.events[event]) {
+      this.events[event] = [];
+    }
+
+    const listener = {
+      callback,
+      once: options.once || false,
+      id: generateId('listener')
+    };
+
+    this.events[event].push(listener);
+
+    // Return unsubscribe function
+    return () => this.off(event, listener.id);
+  }
+
+  /**
+   * Subscribe to an event once (auto-unsubscribe after first trigger)
+   * 
+   * @param {string} event - Event name
+   * @param {Function} callback - Callback function
+   * @returns {Function} Unsubscribe function
+   */
+  once(event, callback) {
+    return this.on(event, callback, { once: true });
+  }
+
+  /**
+   * Unsubscribe from an event
+   * 
+   * @param {string} event - Event name
+   * @param {string|Function} listenerIdOrCallback - Listener ID or callback function
+   */
+  off(event, listenerIdOrCallback) {
+    if (!this.events[event]) return;
+
+    if (typeof listenerIdOrCallback === 'string') {
+      // Remove by ID
+      this.events[event] = this.events[event].filter(
+        listener => listener.id !== listenerIdOrCallback
+      );
+    } else if (typeof listenerIdOrCallback === 'function') {
+      // Remove by callback reference
+      this.events[event] = this.events[event].filter(
+        listener => listener.callback !== listenerIdOrCallback
+      );
+    }
+
+    // Clean up empty event arrays
+    if (this.events[event].length === 0) {
+      delete this.events[event];
+    }
+  }
+
+  /**
+   * Emit an event
+   * 
+   * @param {string} event - Event name
+   * @param {*} data - Event data
+   * @returns {boolean} True if event had listeners
+   */
+  emit(event, data) {
+    if (!this.events[event] || this.events[event].length === 0) {
+      return false;
+    }
+
+    // Automatically log events that follow the ':error' naming convention
+    if (event.endsWith(':error')) {
+      logger.error(`[EventBus Error] ${event}:`, JSON.stringify(data, null, 2));
+    }
+
+    // Create a copy of listeners to avoid issues if listeners modify the array
+    const listeners = [...this.events[event]];
+    const onceListeners = [];
+
+    listeners.forEach(listener => {
+      try {
+        listener.callback(data);
+
+        // Track once listeners for removal
+        if (listener.once) {
+          onceListeners.push(listener.id);
+        }
+      } catch (error) {
+        // Log the error but don't break other listeners
+        logger.error(`[EventBus] Error in listener for '${event}':`, error);
+      }
+    });
+
+    // Remove once listeners
+    onceListeners.forEach(id => this.off(event, id));
+
+    return true;
+  }
+
+  /**
+   * Emit an event asynchronously
+   * 
+   * @param {string} event - Event name
+   * @param {*} data - Event data
+   * @returns {Promise} Resolves when all listeners have been called
+   */
+  async emitAsync(event, data) {
+    if (!this.events[event] || this.events[event].length === 0) {
+      return false;
+    }
+
+    const listeners = [...this.events[event]];
+    const onceListeners = [];
+
+    for (const listener of listeners) {
+      try {
+        await listener.callback(data);
+
+        if (listener.once) {
+          onceListeners.push(listener.id);
+        }
+      } catch (error) {
+        logger.error(`[EventBus] Error in async listener for '${event}':`, error);
+      }
+    }
+
+    // Remove once listeners
+    onceListeners.forEach(id => this.off(event, id));
+
+    return true;
+  }
+
+  /**
+   * Remove all listeners for an event or all events
+   * 
+   * @param {string} event - Optional event name (if omitted, clears all)
+   */
+  clear(event) {
+    if (event) {
+      delete this.events[event];
+    } else {
+      this.events = {};
+    }
+  }
+
+  /**
+   * Get listener count for an event
+   * 
+   * @param {string} event - Event name
+   * @returns {number} Number of listeners
+   */
+  getListenerCount(event) {
+    return this.events[event] ? this.events[event].length : 0;
+  }
+}
+
+// Create global event bus instance
+const eventBus = new EventBus();
+
+export { EventBus, eventBus };

package/framework/js/core/interaction-catalog.js

@@ -0,0 +1,149 @@
+/**
+ * Interaction Catalog
+ * 
+ * Single source of truth for all interaction types (built-in and custom).
+ * Uses import.meta.glob for auto-discovery - just drop a file in the folder.
+ */
+
+const catalog = new Map();
+
+/**
+ * Register an interaction type
+ * @param {string} type - Interaction type name (kebab-case)
+ * @param {object} definition - { creator, metadata?, schema? }
+ */
+export function catalogInteraction(type, { creator, metadata, schema }) {
+    if (!creator) {
+        throw new Error(`[InteractionCatalog] Cannot register "${type}" without a creator function`);
+    }
+    catalog.set(type, { creator, metadata, schema });
+}
+
+/**
+ * Get the creator function for an interaction type
+ * @param {string} type - Interaction type name
+ * @returns {function|undefined}
+ */
+export function getCreator(type) {
+    return catalog.get(type)?.creator;
+}
+
+/**
+ * Get metadata for an interaction type
+ * @param {string} type - Interaction type name
+ * @returns {object|undefined}
+ */
+export function getMetadata(type) {
+    return catalog.get(type)?.metadata;
+}
+
+/**
+ * Get schema for an interaction type
+ * @param {string} type - Interaction type name
+ * @returns {object|undefined}
+ */
+export function getSchema(type) {
+    return catalog.get(type)?.schema;
+}
+
+/**
+ * Get all registered schemas
+ * @returns {object} Map of type -> schema
+ */
+export function getAllSchemas() {
+    const schemas = {};
+    for (const [type, def] of catalog) {
+        if (def.schema) {
+            schemas[type] = def.schema;
+        }
+    }
+    return schemas;
+}
+
+/**
+ * Get all registered type names
+ * @returns {string[]}
+ */
+export function getRegisteredTypes() {
+    return [...catalog.keys()];
+}
+
+/**
+ * Check if a type is registered
+ * @param {string} type
+ * @returns {boolean}
+ */
+export function isRegistered(type) {
+    return catalog.has(type);
+}
+
+/**
+ * Get merged schema with base properties
+ * @param {string} type - Interaction type name
+ * @returns {object} Full schema with base properties merged
+ */
+export function getFullSchema(type) {
+    const schema = getSchema(type);
+    if (!schema) return null;
+
+    return {
+        ...schema,
+        properties: {
+            ...baseSchema,
+            ...schema.properties
+        }
+    };
+}
+
+// =============================================================================
+// Base Schema (shared properties for all interactions)
+// =============================================================================
+
+export const baseSchema = {
+    id: { type: 'string', required: true, description: 'Unique identifier for the interaction' },
+    prompt: { type: 'string', required: true, description: 'Question or instruction text' },
+    controlled: { type: 'boolean', default: false, description: 'If true, interaction is managed externally (e.g., by assessment)' },
+    feedback: { type: 'object', description: 'Custom feedback messages' }
+};
+
+// =============================================================================
+// Auto-discover Interactions (Built-in + Custom)
+// =============================================================================
+
+// Built-in framework interactions
+const builtInModules = import.meta.glob('../components/interactions/*.js', { eager: true });
+
+// Course-specific custom interactions  
+const customModules = import.meta.glob('../../../course/interactions/*.js', { eager: true });
+
+// Register all discovered modules
+function registerModules(modules) {
+    for (const [path, module] of Object.entries(modules)) {
+        // Skip base module
+        if (path.includes('interaction-base')) continue;
+        
+        // Each interaction exports: schema, metadata, and a create* function
+        const { schema, metadata } = module;
+        
+        if (!schema?.type) continue;
+        
+        // Find the creator function by export key name (not function.name which gets minified)
+        const creator = Object.entries(module)
+            .filter(([key, v]) => typeof v === 'function' && key.startsWith('create'))
+            .map(([, v]) => v)[0];
+        
+        if (!creator) continue;
+        
+        catalogInteraction(schema.type, { creator, metadata, schema });
+    }
+}
+
+// Register synchronously - modules are eagerly loaded
+registerModules(builtInModules);
+registerModules(customModules);
+
+// Multiple-choice-single is an alias for multiple-choice
+if (catalog.has('multiple-choice')) {
+    const mc = catalog.get('multiple-choice');
+    catalog.set('multiple-choice-single', mc);
+}