@a-company/university 3.1.2

package/dist/chunk-3ZAP26AP.js

@@ -0,0 +1,292 @@
+// src/server/index.ts
+import express from "express";
+import * as path3 from "path";
+import * as fs3 from "fs";
+import { fileURLToPath } from "url";
+import chalk from "chalk";
+
+// src/server/routes/courses.ts
+import { Router } from "express";
+import * as fs from "fs";
+import * as path from "path";
+function createCoursesRouter(contentDir) {
+  const router = Router();
+  router.get("/", (_req, res) => {
+    const coursesDir = path.join(contentDir, "courses");
+    if (!fs.existsSync(coursesDir)) {
+      return res.json({ courses: [] });
+    }
+    const files = fs.readdirSync(coursesDir).filter((f) => f.endsWith(".json"));
+    const courses = files.map((f) => {
+      const data = JSON.parse(fs.readFileSync(path.join(coursesDir, f), "utf-8"));
+      return {
+        id: data.id,
+        title: data.title,
+        description: data.description,
+        lessonCount: data.lessons?.length || 0,
+        lessons: (data.lessons || []).map((l) => ({
+          id: l.id,
+          title: l.title
+        }))
+      };
+    });
+    courses.sort((a, b) => a.id.localeCompare(b.id));
+    return res.json({ courses });
+  });
+  router.get("/:id", (req, res) => {
+    const courseFile = path.join(contentDir, "courses", `${req.params.id}.json`);
+    if (!fs.existsSync(courseFile)) {
+      return res.status(404).json({ error: `Course '${req.params.id}' not found` });
+    }
+    const data = JSON.parse(fs.readFileSync(courseFile, "utf-8"));
+    return res.json(data);
+  });
+  router.get("/:id/lessons/:lessonId", (req, res) => {
+    const courseFile = path.join(contentDir, "courses", `${req.params.id}.json`);
+    if (!fs.existsSync(courseFile)) {
+      return res.status(404).json({ error: `Course '${req.params.id}' not found` });
+    }
+    const data = JSON.parse(fs.readFileSync(courseFile, "utf-8"));
+    const lesson = (data.lessons || []).find((l) => l.id === req.params.lessonId);
+    if (!lesson) {
+      return res.status(404).json({ error: `Lesson '${req.params.lessonId}' not found` });
+    }
+    return res.json(lesson);
+  });
+  return router;
+}
+
+// src/server/routes/plsat.ts
+import { Router as Router2 } from "express";
+import * as fs2 from "fs";
+import * as path2 from "path";
+function pickVariant(variants) {
+  return variants[Math.floor(Math.random() * variants.length)];
+}
+function fisherYatesShuffle(arr) {
+  for (let i = arr.length - 1; i > 0; i--) {
+    const j = Math.floor(Math.random() * (i + 1));
+    [arr[i], arr[j]] = [arr[j], arr[i]];
+  }
+  return arr;
+}
+function resolveV3(data) {
+  const passages = {};
+  const blocks = [];
+  for (const item of data.items) {
+    if (item.type === "standalone") {
+      const v = pickVariant(item.variants);
+      blocks.push([{
+        id: v.id,
+        course: item.course,
+        scenario: v.scenario,
+        question: v.question,
+        choices: v.choices,
+        correct: v.correct,
+        explanation: v.explanation
+      }]);
+    } else {
+      passages[item.slot] = item.passage;
+      const group = item.questions.map((pq) => {
+        const v = pickVariant(pq.variants);
+        return {
+          id: v.id,
+          course: item.course,
+          scenario: v.scenario,
+          question: v.question,
+          choices: v.choices,
+          correct: v.correct,
+          explanation: v.explanation,
+          passageId: item.slot
+        };
+      });
+      blocks.push(group);
+    }
+  }
+  fisherYatesShuffle(blocks);
+  return { questions: blocks.flat(), passages };
+}
+function countV3Questions(data) {
+  let count = 0;
+  for (const item of data.items) {
+    if (item.type === "standalone") {
+      count += 1;
+    } else {
+      count += item.questions.length;
+    }
+  }
+  return count;
+}
+function createPlsatRouter(contentDir) {
+  const router = Router2();
+  router.get("/", (_req, res) => {
+    const plsatDir = path2.join(contentDir, "plsat");
+    if (!fs2.existsSync(plsatDir)) {
+      return res.json({ versions: [] });
+    }
+    const files = fs2.readdirSync(plsatDir).filter((f) => f.endsWith(".json"));
+    const versions = files.map((f) => {
+      const data = JSON.parse(fs2.readFileSync(path2.join(plsatDir, f), "utf-8"));
+      const questionCount = data.items ? countV3Questions(data) : data.questions?.length || 0;
+      return {
+        version: data.version,
+        frameworkVersion: data.frameworkVersion,
+        questionCount,
+        timeLimit: data.timeLimit,
+        passThreshold: data.passThreshold
+      };
+    });
+    versions.sort((a, b) => b.version.localeCompare(a.version));
+    return res.json({ versions });
+  });
+  router.get("/:version", (req, res) => {
+    const examFile = path2.join(contentDir, "plsat", `v${req.params.version}.json`);
+    if (!fs2.existsSync(examFile)) {
+      return res.status(404).json({ error: `PLSAT version '${req.params.version}' not found` });
+    }
+    const data = JSON.parse(fs2.readFileSync(examFile, "utf-8"));
+    if (data.items) {
+      const { questions, passages } = resolveV3(data);
+      return res.json({
+        version: data.version,
+        frameworkVersion: data.frameworkVersion,
+        timeLimit: data.timeLimit,
+        passThreshold: data.passThreshold,
+        title: data.title,
+        description: data.description,
+        questions,
+        ...Object.keys(passages).length > 0 ? { passages } : {}
+      });
+    }
+    const shuffled = [...data.questions].sort(() => Math.random() - 0.5);
+    return res.json({
+      ...data,
+      questions: shuffled
+    });
+  });
+  return router;
+}
+
+// src/server/index.ts
+var __filename = fileURLToPath(import.meta.url);
+var __dirname = path3.dirname(__filename);
+function findPackageRoot(startDir) {
+  let dir = startDir;
+  while (dir !== path3.dirname(dir)) {
+    if (fs3.existsSync(path3.join(dir, "package.json"))) {
+      const pkg = JSON.parse(fs3.readFileSync(path3.join(dir, "package.json"), "utf-8"));
+      if (pkg.name === "@a-company/university") return dir;
+    }
+    dir = path3.dirname(dir);
+  }
+  return startDir;
+}
+var log = {
+  component(name) {
+    const symbol = chalk.magenta(`#${name}`);
+    return {
+      info: (msg, data) => {
+        const dataStr = data ? chalk.gray(` ${Object.entries(data).map(([k, v]) => `${k}=${v}`).join(" ")}`) : "";
+        console.log(`${chalk.blue("\u2139")} ${symbol} ${msg}${dataStr}`);
+      },
+      success: (msg, data) => {
+        const dataStr = data ? chalk.gray(` ${Object.entries(data).map(([k, v]) => `${k}=${v}`).join(" ")}`) : "";
+        console.log(`${chalk.green("\u2714")} ${symbol} ${msg}${dataStr}`);
+      },
+      warn: (msg, data) => {
+        const dataStr = data ? chalk.gray(` ${Object.entries(data).map(([k, v]) => `${k}=${v}`).join(" ")}`) : "";
+        console.log(`${chalk.yellow("\u26A0")} ${symbol} ${msg}${dataStr}`);
+      },
+      error: (msg, data) => {
+        const dataStr = data ? chalk.gray(` ${Object.entries(data).map(([k, v]) => `${k}=${v}`).join(" ")}`) : "";
+        console.error(`${chalk.red("\u2716")} ${symbol} ${msg}${dataStr}`);
+      }
+    };
+  }
+};
+function resolveAssetPaths(options) {
+  if (options?.contentDir && options?.uiDistPath) {
+    return { contentDir: options.contentDir, uiDistPath: options.uiDistPath };
+  }
+  const bundledContent = path3.join(__dirname, "university-content");
+  const bundledUi = path3.join(__dirname, "university-ui");
+  if (fs3.existsSync(bundledContent) && fs3.existsSync(bundledUi)) {
+    return {
+      contentDir: options?.contentDir || bundledContent,
+      uiDistPath: options?.uiDistPath || bundledUi
+    };
+  }
+  const packageRoot = findPackageRoot(__dirname);
+  return {
+    contentDir: options?.contentDir || path3.join(packageRoot, "src", "content"),
+    uiDistPath: options?.uiDistPath || path3.join(packageRoot, "ui", "dist")
+  };
+}
+function createApp(options) {
+  const app = express();
+  app.use(express.json());
+  app.use((_req, res, next) => {
+    res.header("Access-Control-Allow-Origin", "*");
+    res.header("Access-Control-Allow-Methods", "GET, POST, PUT, DELETE, OPTIONS");
+    res.header("Access-Control-Allow-Headers", "Content-Type");
+    next();
+  });
+  const { contentDir, uiDistPath } = resolveAssetPaths(options);
+  app.use("/api/courses", createCoursesRouter(contentDir));
+  app.use("/api/plsat", createPlsatRouter(contentDir));
+  app.get("/api/reference", (_req, res) => {
+    const refPath = path3.join(contentDir, "reference.json");
+    if (fs3.existsSync(refPath)) {
+      const data = JSON.parse(fs3.readFileSync(refPath, "utf-8"));
+      res.json(data);
+    } else {
+      res.status(404).json({ error: "Reference data not found" });
+    }
+  });
+  app.get("/api/health", (_req, res) => {
+    res.json({ status: "ok", timestamp: (/* @__PURE__ */ new Date()).toISOString() });
+  });
+  if (fs3.existsSync(uiDistPath)) {
+    app.use(express.static(uiDistPath));
+    app.get("{*path}", (req, res) => {
+      if (!req.path.startsWith("/api")) {
+        res.sendFile(path3.join(uiDistPath, "index.html"));
+      }
+    });
+  }
+  return app;
+}
+async function startServer(options) {
+  const app = createApp({
+    contentDir: options.contentDir,
+    uiDistPath: options.uiDistPath
+  });
+  log.component("university-server").info("Starting server", { port: options.port });
+  return new Promise((resolve, reject) => {
+    const server = app.listen(options.port, () => {
+      log.component("university-server").success("Server running", { url: `http://localhost:${options.port}` });
+      if (options.open) {
+        import("open").then((openModule) => {
+          openModule.default(`http://localhost:${options.port}`);
+          log.component("university-server").info("Opened browser");
+        }).catch(() => {
+          log.component("university-server").warn("Could not open browser automatically");
+        });
+      }
+      resolve();
+    });
+    server.on("error", (err) => {
+      if (err.code === "EADDRINUSE") {
+        log.component("university-server").error("Port already in use", { port: options.port });
+      } else {
+        log.component("university-server").error("Server error", { error: err.message });
+      }
+      reject(err);
+    });
+  });
+}
+
+export {
+  createApp,
+  startServer
+};

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export { ServerOptions, createApp, startServer } from './server/index.js';
+import 'express';

package/dist/index.js

@@ -0,0 +1,8 @@
+import {
+  createApp,
+  startServer
+} from "./chunk-3ZAP26AP.js";
+export {
+  createApp,
+  startServer
+};

package/dist/server/index.d.ts

@@ -0,0 +1,25 @@
+import { Express } from 'express';
+
+/**
+ * University Server - Express server for the learning platform UI
+ */
+
+interface ServerOptions {
+    port: number;
+    open?: boolean;
+    contentDir?: string;
+    uiDistPath?: string;
+}
+/**
+ * Create the Express application with all routes configured
+ */
+declare function createApp(options?: {
+    contentDir?: string;
+    uiDistPath?: string;
+}): Express;
+/**
+ * Start the University server
+ */
+declare function startServer(options: ServerOptions): Promise<void>;
+
+export { type ServerOptions, createApp, startServer };

package/dist/server/index.js

@@ -0,0 +1,8 @@
+import {
+  createApp,
+  startServer
+} from "../chunk-3ZAP26AP.js";
+export {
+  createApp,
+  startServer
+};

package/package.json

@@ -0,0 +1,69 @@
+{
+  "name": "@a-company/university",
+  "version": "3.1.2",
+  "description": "Interactive learning platform for the Paradigm framework — courses, quizzes, and the PLSAT certification exam",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./server": {
+      "types": "./dist/server/index.d.ts",
+      "import": "./dist/server/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "src/content",
+    "ui/dist"
+  ],
+  "scripts": {
+    "build": "npm run build:core && npm run build:ui",
+    "build:core": "tsup src/index.ts src/server/index.ts --format esm --dts --clean",
+    "build:ui": "cd ui && npm run build",
+    "dev": "tsup src/index.ts src/server/index.ts --format esm --dts --watch",
+    "dev:ui": "cd ui && npm run dev",
+    "typecheck": "tsc --noEmit",
+    "prepublishOnly": "npm run build"
+  },
+  "dependencies": {
+    "chalk": "^5.3.0",
+    "express": "^4.18.2",
+    "open": "^10.0.0"
+  },
+  "devDependencies": {
+    "@types/express": "^4.17.21",
+    "@types/node": "^20.10.0",
+    "tsup": "^8.0.1",
+    "typescript": "^5.3.3"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "author": "ascend42",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ascend42/a-paradigm.git",
+    "directory": "packages/university"
+  },
+  "bugs": {
+    "url": "https://github.com/ascend42/a-paradigm/issues"
+  },
+  "homepage": "https://github.com/ascend42/a-paradigm#readme",
+  "keywords": [
+    "paradigm",
+    "university",
+    "learning",
+    "courses",
+    "plsat",
+    "certification",
+    "interactive"
+  ],
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}