@examplary/cli 1.15.0 → 1.17.0

package/dist/commands/preview.js

@@ -1,195 +0,0 @@
-#! /usr/bin/env node
-import { watch } from "fs";
-import { readFile } from "fs/promises";
-import { createServer as createHttpServer } from "http";
-import { resolve } from "path";
-import { cwd, exit } from "process";
-import { serve } from "@hono/node-server";
-import { serveStatic } from "@hono/node-server/serve-static";
-import { Hono } from "hono";
-import open from "open";
-import { WebSocketServer } from "ws";
-import { setApiHost, setApiKey } from "../lib/api.js";
-import { buildComponent } from "../lib/bundle.js";
-import { readJsonOrYamlFile, readMetaFile } from "../lib/read-meta.js";
-import { resolveInside } from "../lib/safe-path.js";
-import { buildStyles } from "../lib/styles.js";
-export const previewCommand = async (argv) => {
-    setApiHost(argv.host);
-    setApiKey(argv.key);
-    const dir = cwd();
-    // Verify a question-type file exists (json or yml)
-    try {
-        await readMetaFile();
-    }
-    catch (e) {
-        console.error(`🚫 ${e.message}`);
-        exit(1);
-    }
-    // Let's start a Vite server to preview the question type
-    const root = resolve(import.meta.dirname, "..", "preview-ui");
-    const app = new Hono();
-    app.get("/api/bundle", async (c) => {
-        const path = c.req.query("path");
-        const sourcemap = c.req.query("sourcemap") === "1";
-        const componentName = c.req.query("componentName");
-        try {
-            const componentOutput = await buildComponent(resolveInside(dir, path));
-            if (sourcemap) {
-                return c.body(componentOutput.sourcemap, 200, {
-                    "Content-Type": "application/json",
-                });
-            }
-            else {
-                const sizeInKb = componentOutput.js.length / 1000;
-                if (sizeInKb > 100) {
-                    console.warn(`⚠️ Component ${componentName} is larger than 100 kB! Consider optimizing it.`);
-                }
-                let output = componentOutput.js;
-                if (componentOutput.sourcemap) {
-                    output += `\n//# sourceMappingURL=/api/bundle?componentName=${componentName}&path=${encodeURIComponent(path || "")}&sourcemap=1`;
-                }
-                return c.body(output, 200, {
-                    "Content-Type": "application/javascript",
-                });
-            }
-        }
-        catch (error) {
-            console.error(`🚫 Error bundling component ${componentName} from ${path}: ${error.message}`);
-            return c.text(`Error bundling component ${componentName}: ${error.message}`, 500);
-        }
-    });
-    app.get("/api/icon", async (c) => {
-        const path = c.req.query("path") || "";
-        let icon;
-        try {
-            icon = await readFile(resolveInside(dir, path), "utf-8");
-        }
-        catch (error) {
-            return c.text(`Error reading icon from ${path}: ${error.message}`, 400);
-        }
-        return c.body(icon, 200, {
-            "Content-Type": "image/svg+xml",
-        });
-    });
-    app.get("/api/stylesheet", async (c) => {
-        const componentName = c.req.query("componentName");
-        try {
-            const componentOutput = await buildStyles();
-            return c.body(componentOutput || "", 200, {
-                "Content-Type": "text/css",
-            });
-        }
-        catch (error) {
-            console.error(`🚫 Error building CSS for component ${componentName}: ${error.message}`);
-            return c.text(`Error building CSS for component ${componentName}: ${error.message}`, 500);
-        }
-    });
-    app.get("/__reload", async (c) => {
-        if (wss) {
-            wss.clients.forEach((client) => {
-                if (client.readyState === 1) {
-                    // WebSocket.OPEN
-                    client.send(JSON.stringify({ type: "reload" }));
-                }
-            });
-        }
-        return c.body(null, 201);
-    });
-    let wsPort; // WebSocket port will be set when server starts
-    app.get("/", async (c) => {
-        let questionType;
-        try {
-            ({ definition: questionType } = await readMetaFile());
-            questionType.components = questionType.components
-                ? Object.entries(questionType.components).reduce((acc, [componentName, componentPath]) => ({
-                    ...acc,
-                    [componentName]: `/api/bundle?componentName=${componentName}&path=${encodeURIComponent(componentPath)}`,
-                }), {})
-                : questionType.components;
-        }
-        catch (e) {
-            return c.text(`Error reading question type definition: ${e.message}`, 500);
-        }
-        // Default question/answer payloads for the preview, if a preview file exists
-        let previewData = null;
-        try {
-            previewData = (await readJsonOrYamlFile(dir, "preview"))?.data ?? null;
-        }
-        catch (e) {
-            console.warn(`⚠️ ${e.message}`);
-        }
-        let template = await readFile(resolve(root, "index.html"), "utf-8");
-        // Inject hot reload script
-        const hotReloadScript = `
-      <script>
-        (function() {
-          const wsPort = ${wsPort || "null"};
-          if (wsPort) {
-            const ws = new WebSocket('ws://localhost:' + wsPort);
-            ws.onmessage = function(event) {
-              const data = JSON.parse(event.data);
-              if (data.type === 'reload') {
-                console.log('🔄 Reloading page due to file change...');
-                window.location.reload();
-              }
-            };
-            ws.onopen = function() {
-              console.log('🔗 Hot reload connected');
-            };
-            ws.onclose = function() {
-              console.log('🔌 Hot reload disconnected');
-            };
-            ws.onerror = function(error) {
-              console.log('❌ Hot reload error:', error);
-            };
-          }
-        })();
-      </script>
-    `;
-        template =
-            "<script>window._questionType = " +
-                JSON.stringify(questionType) +
-                ";window._previewData = " +
-                JSON.stringify(previewData) +
-                `;</script>${template}${hotReloadScript}`;
-        return c.html(template);
-    });
-    app.use("/assets/*", serveStatic({ root }));
-    // Set up file watcher
-    const watchDir = cwd();
-    console.log(`📁 Watching ${watchDir} for changes...`);
-    let wss; // Will be initialized after server starts
-    const watcher = watch(watchDir, { recursive: true }, (filename) => {
-        if (filename && !filename.startsWith(".")) {
-            // Broadcast reload message to all connected clients
-            if (wss) {
-                wss.clients.forEach((client) => {
-                    if (client.readyState === 1) {
-                        // WebSocket.OPEN
-                        client.send(JSON.stringify({ type: "reload" }));
-                    }
-                });
-            }
-        }
-    });
-    // Clean up watcher on process exit
-    process.on("SIGINT", () => {
-        watcher.close();
-        process.exit(0);
-    });
-    serve({
-        fetch: app.fetch,
-        hostname: "localhost",
-        port: 5777,
-    }, (address) => {
-        const port = address.port;
-        wsPort = port + 1234;
-        const wsServer = createHttpServer();
-        wss = new WebSocketServer({ server: wsServer });
-        wsServer.listen(wsPort);
-        const url = `http://localhost:${port}`;
-        console.log(`🚀 Preview server running at ${url}`);
-        open(url);
-    });
-};

package/dist/commands/upload.d.ts

@@ -1,5 +0,0 @@
-#! /usr/bin/env node
-export declare const uploadCommand: (argv: {
-    host: string;
-    key: string;
-}) => Promise<void>;

package/dist/commands/upload.js

@@ -1,125 +0,0 @@
-#! /usr/bin/env node
-import { readdir, readFile } from "fs/promises";
-import { join } from "path";
-import { cwd, exit } from "process";
-import { setApiHost, setApiKey, uploadFile } from "../lib/api.js";
-import { readJsonOrYamlFile, readMetaFile } from "../lib/read-meta.js";
-import { isValid, printValidationResult, validateDefinition, } from "../lib/validate.js";
-/**
- * Uploads e.g. `README.md` (English) and its translations like `README.nl.md`,
- * returning their URLs keyed by language code.
- */
-const uploadLocalizedFiles = async (dir, baseName, extension, contentType) => {
-    const pattern = new RegExp(`^${baseName}(?:\\.([a-z]{2}))?\\.${extension}$`);
-    const urls = {};
-    for (const file of await readdir(dir)) {
-        const match = file.match(pattern);
-        if (!match)
-            continue;
-        const contents = await readFile(join(dir, file));
-        if (!contents.length)
-            continue;
-        urls[match[1] || "en"] = await uploadFile(file, contents, contentType);
-        console.log(`• Uploaded ${file}`);
-    }
-    return Object.keys(urls).length ? urls : undefined;
-};
-export const uploadCommand = async (argv) => {
-    setApiHost(argv.host);
-    setApiKey(argv.key);
-    const dir = cwd();
-    let definition = {};
-    try {
-        ({ definition } = await readMetaFile());
-    }
-    catch (e) {
-        console.error(`🚫 ${e.message}`);
-        exit(1);
-    }
-    console.log(`Uploading question type: ${definition.id}...`);
-    // Run all checks (incl. response processing test cases) before uploading
-    const result = await validateDefinition(definition, dir);
-    printValidationResult(result);
-    if (!isValid(result)) {
-        console.error(`\n🚫 Validation failed, aborting upload`);
-        exit(1);
-    }
-    // Upload the bundled components produced during validation
-    const components = {};
-    for (const [componentType, output] of Object.entries(result.bundles)) {
-        // Upload source map first if it exists
-        let sourceMapStatement = "";
-        if (output.sourcemap) {
-            const url = await uploadFile(`component-${componentType}.js.map`, output.sourcemap, "application/json");
-            sourceMapStatement = `\n//# sourceMappingURL=${url}`;
-        }
-        components[componentType] = await uploadFile(`component-${componentType}.js`, output.js + sourceMapStatement, "application/javascript");
-        console.log(`• Uploaded component ${componentType}`);
-    }
-    definition.components = components;
-    // Upload the bundled functions
-    const functions = {};
-    for (const [functionName, output] of Object.entries(result.functions)) {
-        // Upload source map first if it exists
-        let sourceMapStatement = "";
-        if (output.sourcemap) {
-            const url = await uploadFile(`function-${functionName}.js.map`, output.sourcemap, "application/json");
-            sourceMapStatement = `\n//# sourceMappingURL=${url}`;
-        }
-        functions[functionName] = await uploadFile(`function-${functionName}.js`, output.js + sourceMapStatement, "application/javascript");
-        console.log(`• Uploaded function ${functionName}`);
-    }
-    definition.functions = functions;
-    // Upload styles if present
-    if (result.styles) {
-        definition.stylesheet = await uploadFile("styles.css", result.styles, "text/css");
-        const sizeInKb = (result.styles.length / 1000).toFixed(2);
-        console.log(`• Uploaded styles (${sizeInKb} kB)`);
-    }
-    // Upload icon if specified
-    if (definition.icon && result.iconContents) {
-        definition.icon = await uploadFile("icon.svg", result.iconContents, "image/svg+xml");
-        console.log(`• Uploaded icon`);
-    }
-    definition.readmeUrls = await uploadLocalizedFiles(dir, "README", "md", "text/markdown");
-    definition.readme = definition.readmeUrls?.en;
-    definition.previewImageUrls = await uploadLocalizedFiles(dir, "preview", "png", "image/png");
-    definition.previewImage = definition.previewImageUrls?.en;
-    // Upload the preview data if present, always converted to JSON
-    try {
-        const preview = await readJsonOrYamlFile(dir, "preview");
-        if (preview) {
-            definition.previewData = await uploadFile("preview.json", JSON.stringify(preview.data), "application/json");
-            console.log(`• Uploaded preview data`);
-        }
-    }
-    catch (e) {
-        console.error(`🚫 ${e.message}`);
-        exit(1);
-    }
-    // Test cases have already run during validation, no need to store them
-    if (definition.responseProcessing?.testCases) {
-        delete definition.responseProcessing?.testCases;
-    }
-    // Upload the main question type definition
-    const res = await fetch(`${argv.host}/question-types`, {
-        headers: {
-            Authorization: `Bearer ${argv.key}`,
-            "Content-Type": "application/json",
-        },
-        method: "POST",
-        body: JSON.stringify(definition),
-    });
-    if (!res.ok) {
-        console.error(`🚫 Uploading question type failed`);
-        try {
-            const errorResponse = await res.json();
-            console.log(errorResponse);
-        }
-        catch (e) {
-            console.log(e);
-        }
-        exit(1);
-    }
-    console.log(`• Finished uploading definition\n`);
-};

package/dist/lib/read-meta.d.ts

@@ -1,20 +0,0 @@
-import type { QuestionType } from "@examplary/schemas";
-export type QuestionTypeDefinition = Partial<QuestionType> & {
-    $schema?: string;
-};
-/**
- * Reads and parses a `<baseName>.json` or `<baseName>.yml` file from the
- * given directory, preferring JSON over YAML. Returns null if neither exists.
- */
-export declare const readJsonOrYamlFile: (dir: string, baseName: string) => Promise<{
-    data: any;
-    path: string;
-} | null>;
-/**
- * Reads and parses the question-type definition file.
- * Prefers question-type.json over question-type.yml.
- */
-export declare const readMetaFile: () => Promise<{
-    definition: QuestionTypeDefinition;
-    path: string;
-}>;

package/dist/lib/read-meta.js

@@ -1,44 +0,0 @@
-import { readFile } from "fs/promises";
-import { join } from "path";
-import { cwd } from "process";
-import yaml from "yaml";
-/**
- * Reads and parses a `<baseName>.json` or `<baseName>.yml` file from the
- * given directory, preferring JSON over YAML. Returns null if neither exists.
- */
-export const readJsonOrYamlFile = async (dir, baseName) => {
-    for (const { ext, parse, format } of [
-        { ext: "json", parse: (v) => JSON.parse(v), format: "JSON" },
-        { ext: "yml", parse: (v) => yaml.parse(v), format: "YAML" },
-    ]) {
-        const path = join(dir, `${baseName}.${ext}`);
-        let contents;
-        try {
-            contents = await readFile(path, "utf-8");
-        }
-        catch {
-            continue;
-        }
-        try {
-            return { data: parse(contents), path };
-        }
-        catch (error) {
-            throw new Error(`Invalid ${format} in ${path}: ${error.message}`);
-        }
-    }
-    return null;
-};
-/**
- * Reads and parses the question-type definition file.
- * Prefers question-type.json over question-type.yml.
- */
-export const readMetaFile = async () => {
-    const result = await readJsonOrYamlFile(cwd(), "question-type");
-    if (!result) {
-        throw new Error("No question-type.json or question-type.yml found in the current directory");
-    }
-    const definition = result.data;
-    if (definition.$schema)
-        delete definition.$schema;
-    return { definition, path: result.path };
-};

package/dist/lib/safe-path.d.ts

@@ -1,5 +0,0 @@
-/**
- * Resolves `path` against `dir` and throws if the result escapes `dir`,
- * preventing path traversal via `../` segments or absolute paths.
- */
-export declare const resolveInside: (dir: string, path: string) => string;

package/dist/lib/safe-path.js

@@ -1,13 +0,0 @@
-import { resolve, sep } from "path";
-/**
- * Resolves `path` against `dir` and throws if the result escapes `dir`,
- * preventing path traversal via `../` segments or absolute paths.
- */
-export const resolveInside = (dir, path) => {
-    const base = resolve(dir);
-    const resolved = resolve(base, path);
-    if (resolved !== base && !resolved.startsWith(base + sep)) {
-        throw new Error(`Path "${path}" is outside of the question type directory`);
-    }
-    return resolved;
-};