@pie-qti/element-schemas 0.1.1

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "@pie-qti/element-schemas",
+  "version": "0.1.1",
+  "description": "JSON schemas for PIE element validation",
+  "type": "module",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "scripts": {
+    "build": "tsc && bun run copy-schemas",
+    "copy-schemas": "mkdir -p dist/schemas && cp src/schemas/*.json dist/schemas/",
+    "clean": "rm -rf dist",
+    "sync": "bun run scripts/sync-schemas.ts",
+    "check-updates": "bun run scripts/check-schema-versions.ts",
+    "typecheck": "tsc --noEmit"
+  },
+  "keywords": [
+    "pie",
+    "schemas",
+    "validation",
+    "json-schema"
+  ],
+  "author": "Renaissance Learning",
+  "license": "ISC",
+  "devDependencies": {
+    "typescript": "^5.9.3"
+  }
+}

package/schema-versions.json

@@ -0,0 +1,80 @@
+{
+  "multiple-choice": {
+    "version": "11.4.3",
+    "schemaHash": "e7ead176068039d5",
+    "syncedAt": "2025-12-24T16:34:02.207Z",
+    "sourcePath": "/Users/eelco.hillenius/dev/prj/pie/pie-elements/packages/multiple-choice/docs/pie-schema.json"
+  },
+  "extended-text-entry": {
+    "version": "13.4.0",
+    "schemaHash": "0a22fb0f93b3f1ea",
+    "syncedAt": "2025-12-24T16:34:02.223Z",
+    "sourcePath": "/Users/eelco.hillenius/dev/prj/pie/pie-elements/packages/extended-text-entry/docs/pie-schema.json"
+  },
+  "placement-ordering": {
+    "version": "12.3.3",
+    "schemaHash": "0b5c0addd725dcde",
+    "syncedAt": "2025-12-24T17:09:04.941Z",
+    "sourcePath": "/Users/eelco.hillenius/dev/prj/pie/pie-elements/packages/placement-ordering/docs/pie-schema.json"
+  },
+  "match": {
+    "version": "10.3.3",
+    "schemaHash": "31b9998c4211e68c",
+    "syncedAt": "2025-12-24T17:21:48.119Z",
+    "sourcePath": "/Users/eelco.hillenius/dev/prj/pie/pie-elements/packages/match/docs/pie-schema.json"
+  },
+  "explicit-constructed-response": {
+    "version": "9.3.3",
+    "schemaHash": "a5243e3342e779de",
+    "syncedAt": "2025-12-24T17:23:54.274Z",
+    "sourcePath": "/Users/eelco.hillenius/dev/prj/pie/pie-elements/packages/explicit-constructed-response/docs/pie-schema.json"
+  },
+  "select-text": {
+    "version": "11.3.3",
+    "schemaHash": "6fa72bc0ae8b034c",
+    "syncedAt": "2025-12-24T17:33:19.489Z",
+    "sourcePath": "/Users/eelco.hillenius/dev/prj/pie/pie-elements/packages/select-text/docs/pie-schema.json"
+  },
+  "inline-dropdown": {
+    "version": "8.3.3",
+    "schemaHash": "05633d1a5f56813b",
+    "syncedAt": "2025-12-24T17:37:02.971Z",
+    "sourcePath": "/Users/eelco.hillenius/dev/prj/pie/pie-elements/packages/inline-dropdown/docs/pie-schema.json"
+  },
+  "drag-in-the-blank": {
+    "version": "8.3.3",
+    "schemaHash": "7e5e4f8d87b70510",
+    "syncedAt": "2025-12-24T18:40:10.126Z",
+    "sourcePath": "/Users/eelco.hillenius/dev/prj/pie/pie-elements/packages/drag-in-the-blank/docs/pie-schema.json"
+  },
+  "ebsr": {
+    "version": "12.3.3",
+    "schemaHash": "197c46f303507beb",
+    "syncedAt": "2025-12-24T18:53:19.334Z",
+    "sourcePath": "/Users/eelco.hillenius/dev/prj/pie/pie-elements/packages/ebsr/docs/pie-schema.json"
+  },
+  "hotspot": {
+    "version": "9.3.3",
+    "schemaHash": "cdbeab1ad844be95",
+    "syncedAt": "2025-12-24T19:44:36.088Z",
+    "sourcePath": "/Users/eelco.hillenius/dev/prj/pie/pie-elements/packages/hotspot/docs/pie-schema.json"
+  },
+  "image-cloze-association": {
+    "version": "8.3.3",
+    "schemaHash": "ade9a4ee89e5c3a8",
+    "syncedAt": "2025-12-24T19:51:00.860Z",
+    "sourcePath": "/Users/eelco.hillenius/dev/prj/pie/pie-elements/packages/image-cloze-association/docs/pie-schema.json"
+  },
+  "match-list": {
+    "version": "5.3.3",
+    "schemaHash": "da21e978152d1fb8",
+    "syncedAt": "2025-12-24T19:53:09.293Z",
+    "sourcePath": "/Users/eelco.hillenius/dev/prj/pie/pie-elements/packages/match-list/docs/pie-schema.json"
+  },
+  "passage": {
+    "version": "5.3.3",
+    "schemaHash": "b3a3989106088973",
+    "syncedAt": "2025-12-24T19:55:22.498Z",
+    "sourcePath": "/Users/eelco.hillenius/dev/prj/pie/pie-elements/packages/passage/docs/pie-schema.json"
+  }
+}

package/scripts/check-schema-versions.ts

@@ -0,0 +1,112 @@
+/**
+ * Schema Version Checker
+ *
+ * Checks if local schemas are up-to-date with pie-elements repository.
+ * Useful for CI to detect schema drift.
+ */
+
+import { createHash } from 'node:crypto';
+import { existsSync } from 'node:fs';
+import { readFile } from 'node:fs/promises';
+import { resolve } from 'node:path';
+
+const PIE_ELEMENTS_PATH = resolve(import.meta.dirname, '../../../../pie-elements/packages');
+const SCHEMAS_OUTPUT = resolve(import.meta.dirname, '../src/schemas');
+const VERSIONS_FILE = resolve(import.meta.dirname, '../schema-versions.json');
+
+interface SchemaVersion {
+  version: string;
+  schemaHash: string;
+  syncedAt: string;
+  sourcePath: string;
+}
+
+interface SchemaVersions {
+  [elementName: string]: SchemaVersion;
+}
+
+function calculateHash(content: string): string {
+  return createHash('sha256').update(content).digest('hex').substring(0, 16);
+}
+
+async function loadVersions(): Promise<SchemaVersions> {
+  if (!existsSync(VERSIONS_FILE)) {
+    console.warn('⚠️  No schema-versions.json found. Run `bun run sync` first.');
+    return {};
+  }
+  const content = await readFile(VERSIONS_FILE, 'utf-8');
+  return JSON.parse(content);
+}
+
+async function checkSchemas() {
+  console.log('🔍 Checking schema versions...\n');
+
+  if (!existsSync(PIE_ELEMENTS_PATH)) {
+    console.error(`❌ PIE elements repository not found at: ${PIE_ELEMENTS_PATH}`);
+    process.exit(1);
+  }
+
+  const versions = await loadVersions();
+  const elements = Object.keys(versions);
+
+  if (elements.length === 0) {
+    console.error('❌ No schemas tracked. Run `bun run sync` first.');
+    process.exit(1);
+  }
+
+  let outdatedCount = 0;
+  let upToDateCount = 0;
+  let missingCount = 0;
+
+  for (const element of elements) {
+    const info = versions[element];
+    const schemaPath = resolve(PIE_ELEMENTS_PATH, element, 'docs/pie-schema.json');
+    const localPath = resolve(SCHEMAS_OUTPUT, `${element}.json`);
+
+    // Check if local schema exists
+    if (!existsSync(localPath)) {
+      console.error(`❌ ${element}: Local schema missing at ${localPath}`);
+      missingCount++;
+      continue;
+    }
+
+    // Check if source schema exists
+    if (!existsSync(schemaPath)) {
+      console.warn(`⚠️  ${element}: Source schema not found at ${schemaPath}`);
+      continue;
+    }
+
+    try {
+      // Check if source has changed
+      const sourceContent = await readFile(schemaPath, 'utf-8');
+      const sourceHash = calculateHash(sourceContent);
+
+      if (sourceHash !== info.schemaHash) {
+        console.warn(`⚠️  ${element}: Schema out of date (local: ${info.schemaHash}, remote: ${sourceHash})`);
+        outdatedCount++;
+      } else {
+        console.log(`✅ ${element}: Up-to-date (v${info.version})`);
+        upToDateCount++;
+      }
+    } catch (error) {
+      console.error(`❌ ${element}: Error checking schema - ${(error as Error).message}`);
+    }
+  }
+
+  console.log('\n📊 Status:');
+  console.log(`   ✅ Up-to-date: ${upToDateCount}`);
+  console.log(`   ⚠️  Outdated: ${outdatedCount}`);
+  console.log(`   ❌ Missing: ${missingCount}`);
+
+  if (outdatedCount > 0 || missingCount > 0) {
+    console.log('\n💡 Run `bun run sync` to update schemas.');
+    process.exit(1);
+  }
+
+  console.log('\n✨ All schemas are up-to-date!');
+}
+
+checkSchemas().catch((error) => {
+  console.error('Fatal error:', error);
+  process.exit(1);
+});

package/scripts/sync-schemas.ts

@@ -0,0 +1,171 @@
+/**
+ * Schema Sync Script
+ *
+ * Syncs PIE element schemas from the pie-elements repository.
+ * Assumes pie-elements is checked out as a sibling directory.
+ */
+
+import { createHash } from 'node:crypto';
+import { existsSync } from 'node:fs';
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
+import { resolve } from 'node:path';
+
+// Relative path to pie-elements repository
+const PIE_ELEMENTS_PATH = resolve(import.meta.dirname, '../../../../pie-elements/packages');
+const SCHEMAS_OUTPUT = resolve(import.meta.dirname, '../src/schemas');
+const VERSIONS_FILE = resolve(import.meta.dirname, '../schema-versions.json');
+
+// Elements to sync schemas for
+const ELEMENTS_TO_SYNC = [
+  'multiple-choice',
+  'extended-text-entry',
+  'placement-ordering',
+  'match',
+  'explicit-constructed-response',
+  'select-text',
+  'inline-dropdown',
+  'drag-in-the-blank',
+  'ebsr',
+  'hotspot',
+  'image-cloze-association',
+  'match-list',
+  'passage',
+  // Add more elements as needed
+];
+interface SchemaVersion {
+  version: string;
+  schemaHash: string;
+  syncedAt: string;
+  sourcePath: string;
+}
+
+interface SchemaVersions {
+  [elementName: string]: SchemaVersion;
+}
+
+/**
+ * Calculate SHA-256 hash of schema content
+ */
+function calculateHash(content: string): string {
+  return createHash('sha256').update(content).digest('hex').substring(0, 16);
+}
+
+/**
+ * Load existing schema versions
+ */
+async function loadVersions(): Promise<SchemaVersions> {
+  if (!existsSync(VERSIONS_FILE)) {
+    return {};
+  }
+  const content = await readFile(VERSIONS_FILE, 'utf-8');
+  return JSON.parse(content);
+}
+
+/**
+ * Save schema versions
+ */
+async function saveVersions(versions: SchemaVersions): Promise<void> {
+  const content = JSON.stringify(versions, null, 2);
+  await writeFile(VERSIONS_FILE, content, 'utf-8');
+}
+
+/**
+ * Get package version from package.json
+ */
+async function getPackageVersion(elementPath: string): Promise<string> {
+  try {
+    const pkgPath = resolve(elementPath, 'package.json');
+    const pkgContent = await readFile(pkgPath, 'utf-8');
+    const pkg = JSON.parse(pkgContent);
+    return pkg.version || 'unknown';
+  } catch {
+    return 'unknown';
+  }
+}
+
+/**
+ * Sync schemas from pie-elements
+ */
+async function syncSchemas() {
+  console.log('🔄 Syncing PIE element schemas...\n');
+
+  // Check if pie-elements exists
+  if (!existsSync(PIE_ELEMENTS_PATH)) {
+    console.error(`❌ PIE elements repository not found at: ${PIE_ELEMENTS_PATH}`);
+    console.error('   Please ensure pie-elements is checked out as a sibling directory.');
+    process.exit(1);
+  }
+
+  // Load existing versions
+  const versions = await loadVersions();
+  const updatedVersions: SchemaVersions = {};
+  let syncCount = 0;
+  let skipCount = 0;
+  let errorCount = 0;
+
+  // Create output directory
+  await mkdir(SCHEMAS_OUTPUT, { recursive: true });
+
+  for (const element of ELEMENTS_TO_SYNC) {
+    const elementPath = resolve(PIE_ELEMENTS_PATH, element);
+    const schemaPath = resolve(elementPath, 'docs/pie-schema.json');
+    const outputPath = resolve(SCHEMAS_OUTPUT, `${element}.json`);
+
+    try {
+      // Check if schema exists
+      if (!existsSync(schemaPath)) {
+        console.warn(`⚠️  ${element}: Schema not found at ${schemaPath}`);
+        errorCount++;
+        continue;
+      }
+
+      // Read schema
+      const schemaContent = await readFile(schemaPath, 'utf-8');
+      const schemaHash = calculateHash(schemaContent);
+      const version = await getPackageVersion(elementPath);
+
+      // Check if schema has changed
+      const existing = versions[element];
+      if (existing && existing.schemaHash === schemaHash) {
+        console.log(`⏭️  ${element}: Already up-to-date (v${version})`);
+        updatedVersions[element] = existing;
+        skipCount++;
+        continue;
+      }
+
+      // Write schema
+      await writeFile(outputPath, schemaContent, 'utf-8');
+
+      // Update version info
+      updatedVersions[element] = {
+        version,
+        schemaHash,
+        syncedAt: new Date().toISOString(),
+        sourcePath: schemaPath,
+      };
+
+      console.log(`✅ ${element}: Synced v${version} (hash: ${schemaHash})`);
+      syncCount++;
+
+    } catch (error) {
+      console.error(`❌ ${element}: ${(error as Error).message}`);
+      errorCount++;
+    }
+  }
+
+  // Save version metadata
+  await saveVersions(updatedVersions);
+
+  // Summary
+  console.log('\n📊 Sync Summary:');
+  console.log(`   ✅ Synced: ${syncCount}`);
+  console.log(`   ⏭️  Skipped (up-to-date): ${skipCount}`);
+  console.log(`   ❌ Errors: ${errorCount}`);
+  console.log(`\n✨ Schema versions saved to: ${VERSIONS_FILE}`);
+}
+
+// Run sync
+syncSchemas().catch((error) => {
+  console.error('Fatal error:', error);
+  process.exit(1);
+});

package/src/index.ts

@@ -0,0 +1,94 @@
+/**
+ * @pie-qti/element-schemas
+ *
+ * PIE element JSON schemas for validation
+ */
+
+import { readFile } from 'node:fs/promises';
+import { dirname, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+/**
+ * Available PIE element schemas
+ */
+export const AVAILABLE_SCHEMAS = [
+  'multiple-choice',
+  'extended-text-entry',
+  'placement-ordering',
+  'match',
+  'explicit-constructed-response',
+  'select-text',
+  'inline-dropdown',
+  'drag-in-the-blank',
+  'ebsr',
+  'hotspot',
+  'image-cloze-association',
+  'match-list',
+  'passage',
+] as const;
+
+export type ElementType = typeof AVAILABLE_SCHEMAS[number];
+
+/**
+ * Schema cache
+ */
+const schemaCache = new Map<string, object>();
+
+/**
+ * Load a PIE element schema
+ * @param elementType - Element type (e.g., 'multiple-choice')
+ * @returns JSON schema object
+ */
+export async function loadSchema(elementType: ElementType): Promise<object> {
+  // Check cache first
+  if (schemaCache.has(elementType)) {
+    return schemaCache.get(elementType)!;
+  }
+
+  const schemaPath = resolve(__dirname, `schemas/${elementType}.json`);
+
+  try {
+    const content = await readFile(schemaPath, 'utf-8');
+    const schema = JSON.parse(content);
+    schemaCache.set(elementType, schema);
+    return schema;
+  } catch (error) {
+    throw new Error(
+      `Failed to load schema for ${elementType}: ${(error as Error).message}`
+    );
+  }
+}
+
+/**
+ * Load all available schemas
+ * @returns Map of element type to schema
+ */
+export async function loadAllSchemas(): Promise<Map<string, object>> {
+  const schemas = new Map<string, object>();
+
+  for (const elementType of AVAILABLE_SCHEMAS) {
+    const schema = await loadSchema(elementType);
+    schemas.set(`@pie-element/${elementType}`, schema);
+  }
+
+  return schemas;
+}
+
+/**
+ * Get schema synchronously (must be loaded first)
+ * @param elementType - Element type
+ * @returns Cached schema or undefined
+ */
+export function getSchema(elementType: ElementType): object | undefined {
+  return schemaCache.get(elementType);
+}
+
+/**
+ * Check if a schema is available
+ * @param elementType - Element type to check
+ */
+export function hasSchema(elementType: string): elementType is ElementType {
+  return AVAILABLE_SCHEMAS.includes(elementType as ElementType);
+}