nebula-cms 0.1.0 → 0.1.4

package/dist/client/js/storage/storage.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Backend configuration stored in IndexedDB. Tagged union discriminated on `type`.
+ * Security note: the GitHub token is stored in plaintext in IndexedDB. This is a
+ * deliberate trade-off for a client-only app with no server to proxy through.
+ * Same-origin policy protects it from other sites, but any XSS vulnerability
+ * would expose the token.
+ */
+export type BackendConfig = {
+    type: 'fsa';
+    handle: FileSystemDirectoryHandle;
+} | {
+    type: 'github';
+    token: string;
+    repo: string;
+};
+/**
+ * Stores backend configuration in IndexedDB for persistence across sessions.
+ * @param {BackendConfig} config - The backend config to store
+ * @return {Promise<void>}
+ */
+export declare function saveBackend(config: BackendConfig): Promise<void>;
+/**
+ * Retrieves stored backend configuration from IndexedDB. Handles migration from the old format where a bare FileSystemDirectoryHandle was stored.
+ * @return {Promise<BackendConfig | null>} The stored config, or null if none exists
+ */
+export declare function loadBackend(): Promise<BackendConfig | null>;
+/**
+ * Removes the stored backend configuration from IndexedDB. Also clears the legacy key if present.
+ * @return {Promise<void>}
+ */
+export declare function clearBackend(): Promise<void>;
+//# sourceMappingURL=storage.d.ts.map

package/dist/client/js/storage/storage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"storage.d.ts","sourceRoot":"","sources":["../../../../src/client/js/storage/storage.ts"],"names":[],"mappings":"AAUA;;;;;;GAMG;AACH,MAAM,MAAM,aAAa,GACrB;IAAE,IAAI,EAAE,KAAK,CAAC;IAAC,MAAM,EAAE,yBAAyB,CAAA;CAAE,GAClD;IAAE,IAAI,EAAE,QAAQ,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CAAC;AAEpD;;;;GAIG;AACH,wBAAsB,WAAW,CAAC,MAAM,EAAE,aAAa,GAAG,OAAO,CAAC,IAAI,CAAC,CAQtE;AAED;;;GAGG;AACH,wBAAsB,WAAW,IAAI,OAAO,CAAC,aAAa,GAAG,IAAI,CAAC,CAyBjE;AAED;;;GAGG;AACH,wBAAsB,YAAY,IAAI,OAAO,CAAC,IAAI,CAAC,CAWlD"}

package/dist/client/js/storage/storage.js

@@ -0,0 +1,68 @@
+/*
+ * Backend configuration persistence using IndexedDB.
+ * Stores and retrieves the active storage backend (FSA or GitHub).
+ */
+import { openDB } from './db';
+// Fixed key for the backend config
+const BACKEND_KEY = 'backend';
+/**
+ * Stores backend configuration in IndexedDB for persistence across sessions.
+ * @param {BackendConfig} config - The backend config to store
+ * @return {Promise<void>}
+ */
+export async function saveBackend(config) {
+    const db = await openDB();
+    return new Promise((resolve, reject) => {
+        const tx = db.transaction('handles', 'readwrite');
+        tx.objectStore('handles').put(config, BACKEND_KEY);
+        tx.oncomplete = () => resolve();
+        tx.onerror = () => reject(tx.error);
+    });
+}
+/**
+ * Retrieves stored backend configuration from IndexedDB. Handles migration from the old format where a bare FileSystemDirectoryHandle was stored.
+ * @return {Promise<BackendConfig | null>} The stored config, or null if none exists
+ */
+export async function loadBackend() {
+    const db = await openDB();
+    return new Promise((resolve, reject) => {
+        const tx = db.transaction('handles', 'readonly');
+        const request = tx.objectStore('handles').get(BACKEND_KEY);
+        request.onsuccess = () => {
+            const result = request.result;
+            if (!result) {
+                // Check for old-format handle stored under the legacy key
+                const legacyRequest = tx.objectStore('handles').get('projectRoot');
+                legacyRequest.onsuccess = () => {
+                    const legacy = legacyRequest.result;
+                    if (legacy && legacy instanceof FileSystemDirectoryHandle) {
+                        resolve({ type: 'fsa', handle: legacy });
+                    }
+                    else {
+                        resolve(null);
+                    }
+                };
+                legacyRequest.onerror = () => resolve(null);
+                return;
+            }
+            resolve(result);
+        };
+        request.onerror = () => reject(request.error);
+    });
+}
+/**
+ * Removes the stored backend configuration from IndexedDB. Also clears the legacy key if present.
+ * @return {Promise<void>}
+ */
+export async function clearBackend() {
+    const db = await openDB();
+    return new Promise((resolve, reject) => {
+        const tx = db.transaction('handles', 'readwrite');
+        const store = tx.objectStore('handles');
+        store.delete(BACKEND_KEY);
+        // Clean up legacy key if present
+        store.delete('projectRoot');
+        tx.oncomplete = () => resolve();
+        tx.onerror = () => reject(tx.error);
+    });
+}

package/dist/client/js/storage/workers/frontmatter.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=frontmatter.d.ts.map

package/dist/client/js/storage/workers/frontmatter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"frontmatter.d.ts","sourceRoot":"","sources":["../../../../../src/client/js/storage/workers/frontmatter.ts"],"names":[],"mappings":""}

package/dist/client/js/storage/workers/frontmatter.js

@@ -0,0 +1,253 @@
+/*
+ * Orchestrator Worker
+ *
+ * Routes file parsing by category: frontmatter files have their YAML block
+ * extracted via string manipulation and sent to the YAML parser worker;
+ * JSON data files are parsed inline; YAML/TOML data files are sent to their
+ * respective parser workers. Parser workers are lazily spawned on first need.
+ */
+import { StorageClient } from '../client';
+import { getFileCategory, getDataFormat } from '../../utils/file-types';
+import { splitFrontmatter } from '../../utils/frontmatter';
+/**
+ * Extracts the raw YAML block from a frontmatter-delimited file (markdown/MDX/Markdoc).
+ * Delegates BOM stripping, CRLF normalization, and delimiter logic to splitFrontmatter.
+ * Returns the raw YAML string without parsing it — parsing is delegated to the YAML parser worker.
+ * @param {string} content - Raw file content
+ * @return {string | null} The raw YAML string between --- delimiters, or null if none found
+ */
+function extractYamlBlock(content) {
+    const { rawFrontmatter } = splitFrontmatter(content);
+    return rawFrontmatter.trim() ? rawFrontmatter : null;
+}
+/*
+//////////////////////////////
+// Parser worker management
+//////////////////////////////
+*/
+// Lazily-spawned parser workers
+let yamlWorker = null;
+let tomlWorker = null;
+// Incrementing ID for correlating batch requests with responses
+let batchIdCounter = 0;
+// Pending batch response promises keyed by ID
+const pendingBatches = new Map();
+/**
+ * Returns the lazily-spawned YAML parser worker, creating it on first call.
+ * Uses `.js` extension in the URL because svelte-package doesn't rewrite URL strings.
+ * @return {Worker} The YAML parser worker instance
+ */
+function getYamlWorker() {
+    if (!yamlWorker) {
+        yamlWorker = new Worker(new URL('./yaml-parser.js', import.meta.url), {
+            type: 'module',
+        });
+        yamlWorker.onmessage = handleParserResponse;
+        yamlWorker.onerror = handleWorkerError;
+    }
+    return yamlWorker;
+}
+/**
+ * Returns the lazily-spawned TOML parser worker, creating it on first call.
+ * Uses `.js` extension in the URL because svelte-package doesn't rewrite URL strings.
+ * @return {Worker} The TOML parser worker instance
+ */
+function getTomlWorker() {
+    if (!tomlWorker) {
+        tomlWorker = new Worker(new URL('./toml-parser.js', import.meta.url), {
+            type: 'module',
+        });
+        tomlWorker.onmessage = handleParserResponse;
+        tomlWorker.onerror = handleWorkerError;
+    }
+    return tomlWorker;
+}
+/**
+ * Handles fatal errors from parser workers by rejecting all pending batch promises
+ * so callers don't hang indefinitely waiting for a response that will never arrive.
+ * @param {ErrorEvent} e - The error event from the worker
+ * @return {void}
+ */
+function handleWorkerError(e) {
+    for (const [id, { reject }] of pendingBatches) {
+        reject(new Error(`Parser worker error: ${e.message}`));
+        pendingBatches.delete(id);
+    }
+}
+/**
+ * Handles responses from parser workers by resolving/rejecting the corresponding
+ * pending batch promise based on the response ID.
+ * @param {MessageEvent} event - The message event from the parser worker
+ * @return {void}
+ */
+function handleParserResponse(event) {
+    const { type, id, ok, results, error } = event.data;
+    // Ignore messages that aren't batch results (e.g. single parse results, stringify results)
+    if (type !== 'parse-batch-result')
+        return;
+    const pending = pendingBatches.get(id);
+    if (!pending)
+        return;
+    pendingBatches.delete(id);
+    if (ok) {
+        pending.resolve(results);
+    }
+    else {
+        pending.reject(new Error(error));
+    }
+}
+/**
+ * Sends a batch of key/content pairs to a parser worker and returns a promise
+ * that resolves with the parsed results map. Uses an incrementing ID for
+ * request/response correlation, following the same pattern as StorageClient.
+ * @param {Worker} worker - The parser worker to send the batch to
+ * @param {BatchItem[]} items - Array of key/content pairs to parse
+ * @return {Promise<Record<string, Record<string, unknown>>>} Map of key to parsed data
+ */
+function sendBatch(worker, items) {
+    const id = String(++batchIdCounter);
+    return new Promise((resolve, reject) => {
+        pendingBatches.set(id, { resolve, reject });
+        worker.postMessage({ type: 'parse-batch', id, items });
+    });
+}
+/*
+//////////////////////////////
+// File categorization and parsing
+//////////////////////////////
+*/
+/**
+ * Processes a list of files by categorizing each file, collecting batch items
+ * for YAML/TOML parser workers, parsing JSON inline, and assembling the final
+ * items array with parsed data.
+ * @param {FileEntry[]} files - The files returned by the storage adapter
+ * @return {Promise<Array<{ filename: string; data: Record<string, unknown> }>>} Parsed items
+ */
+async function processFiles(files) {
+    // Inline-parsed results (JSON files)
+    const inlineResults = [];
+    // Batch items for YAML worker (frontmatter YAML blocks + YAML data files)
+    const yamlBatch = [];
+    // Batch items for TOML worker
+    const tomlBatch = [];
+    // Files with no frontmatter get empty data
+    const emptyDataFiles = [];
+    for (const file of files) {
+        const category = getFileCategory(file.filename);
+        if (category === 'frontmatter') {
+            const yamlBlock = extractYamlBlock(file.content);
+            if (yamlBlock) {
+                yamlBatch.push({ key: file.filename, content: yamlBlock });
+            }
+            else {
+                // No frontmatter found — include with empty data
+                emptyDataFiles.push(file.filename);
+            }
+            continue;
+        }
+        if (category === 'data') {
+            const format = getDataFormat(file.filename);
+            if (format === 'json') {
+                try {
+                    const data = JSON.parse(file.content);
+                    inlineResults.push({ filename: file.filename, data });
+                }
+                catch {
+                    // Invalid JSON — include with empty data
+                    inlineResults.push({ filename: file.filename, data: {} });
+                }
+                continue;
+            }
+            if (format === 'yaml') {
+                yamlBatch.push({ key: file.filename, content: file.content });
+                continue;
+            }
+            if (format === 'toml') {
+                tomlBatch.push({ key: file.filename, content: file.content });
+                continue;
+            }
+        }
+        // Unrecognised file type — include with empty data
+        emptyDataFiles.push(file.filename);
+    }
+    // Send batches to parser workers in parallel
+    const promises = [];
+    let yamlPromiseIdx = -1;
+    let tomlPromiseIdx = -1;
+    if (yamlBatch.length > 0) {
+        yamlPromiseIdx = promises.length;
+        promises.push(sendBatch(getYamlWorker(), yamlBatch));
+    }
+    if (tomlBatch.length > 0) {
+        tomlPromiseIdx = promises.length;
+        promises.push(sendBatch(getTomlWorker(), tomlBatch));
+    }
+    const batchResults = await Promise.all(promises);
+    // Assemble final items from all sources
+    const items = [];
+    // Add inline results (JSON)
+    items.push(...inlineResults);
+    // Add YAML results — filenames are derived from the batch result keys
+    if (yamlPromiseIdx >= 0) {
+        const yamlResults = batchResults[yamlPromiseIdx];
+        for (const [filename, data] of Object.entries(yamlResults)) {
+            items.push({ filename, data });
+        }
+    }
+    // Add TOML results — filenames are derived from the batch result keys
+    if (tomlPromiseIdx >= 0) {
+        const tomlResults = batchResults[tomlPromiseIdx];
+        for (const [filename, data] of Object.entries(tomlResults)) {
+            items.push({ filename, data });
+        }
+    }
+    // Add empty-data files
+    for (const filename of emptyDataFiles) {
+        items.push({ filename, data: {} });
+    }
+    return items;
+}
+/*
+//////////////////////////////
+// Main message handler
+//////////////////////////////
+*/
+// Storage client, initialized when the main thread transfers a port
+let storageClient = null;
+// Handle messages from main thread
+self.addEventListener('message', async (event) => {
+    const { type } = event.data;
+    if (type === 'port') {
+        // Main thread is transferring a MessagePort connected to the storage SharedWorker
+        const port = event.ports[0];
+        storageClient = new StorageClient(port);
+        return;
+    }
+    if (type === 'parse') {
+        const { collection } = event.data;
+        if (!storageClient) {
+            self.postMessage({
+                type: 'error',
+                message: 'Storage port not initialized',
+            });
+            return;
+        }
+        try {
+            // Pass extensions from the message, defaulting to markdown for backward compatibility
+            const extensions = event.data.extensions ?? ['.md', '.mdx'];
+            const files = await storageClient.listFiles(collection, extensions);
+            const items = await processFiles(files);
+            // Sort alphabetically by title, falling back to filename
+            items.sort((a, b) => {
+                const aTitle = typeof a.data.title === 'string' ? a.data.title : a.filename;
+                const bTitle = typeof b.data.title === 'string' ? b.data.title : b.filename;
+                return aTitle.toLowerCase().localeCompare(bTitle.toLowerCase());
+            });
+            self.postMessage({ type: 'result', collection, items });
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            self.postMessage({ type: 'error', message });
+        }
+    }
+});

package/dist/client/js/storage/workers/storage.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=storage.d.ts.map

package/dist/client/js/storage/workers/storage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"storage.d.ts","sourceRoot":"","sources":["../../../../../src/client/js/storage/workers/storage.ts"],"names":[],"mappings":""}

package/dist/client/js/storage/workers/storage.js

@@ -0,0 +1,167 @@
+/*
+ * SharedWorker entry point for storage operations.
+ * Receives requests over MessagePort, dispatches to the active StorageAdapter,
+ * and posts responses back to each connected client.
+ */
+// The single active adapter instance shared across all connected ports
+let adapter = null;
+/**
+ * Handles a request message and returns the appropriate response.
+ * @param {StorageRequest} msg - The incoming request message
+ * @return {Promise<StorageResponse>} The response to send back
+ */
+async function handleMessage(msg) {
+    switch (msg.type) {
+        case 'init': {
+            try {
+                if (msg.backend.type === 'fsa') {
+                    const { FsaAdapter } = await import('../fsa');
+                    adapter = new FsaAdapter(msg.backend.handle);
+                }
+                else {
+                    const { GitHubAdapter } = await import('../github');
+                    const gh = new GitHubAdapter(msg.backend.token, msg.backend.repo);
+                    await gh.validate();
+                    adapter = gh;
+                }
+                return { type: 'init', ok: true };
+            }
+            catch (err) {
+                const error = err instanceof Error ? err.message : String(err);
+                return { type: 'init', ok: false, error };
+            }
+        }
+        case 'listFiles': {
+            if (!adapter)
+                return {
+                    type: 'listFiles',
+                    ok: false,
+                    error: 'No backend initialized',
+                };
+            try {
+                const files = await adapter.listFiles(msg.collection, msg.extensions);
+                return { type: 'listFiles', ok: true, files };
+            }
+            catch (err) {
+                return {
+                    type: 'listFiles',
+                    ok: false,
+                    error: err instanceof Error ? err.message : String(err),
+                };
+            }
+        }
+        case 'readFile': {
+            if (!adapter)
+                return { type: 'readFile', ok: false, error: 'No backend initialized' };
+            try {
+                const content = await adapter.readFile(msg.collection, msg.filename);
+                return { type: 'readFile', ok: true, content };
+            }
+            catch (err) {
+                return {
+                    type: 'readFile',
+                    ok: false,
+                    error: err instanceof Error ? err.message : String(err),
+                };
+            }
+        }
+        case 'writeFile': {
+            if (!adapter)
+                return {
+                    type: 'writeFile',
+                    ok: false,
+                    error: 'No backend initialized',
+                };
+            try {
+                await adapter.writeFile(msg.collection, msg.filename, msg.content);
+                return { type: 'writeFile', ok: true };
+            }
+            catch (err) {
+                return {
+                    type: 'writeFile',
+                    ok: false,
+                    error: err instanceof Error ? err.message : String(err),
+                };
+            }
+        }
+        case 'writeFiles': {
+            if (!adapter)
+                return {
+                    type: 'writeFiles',
+                    ok: false,
+                    error: 'No backend initialized',
+                };
+            try {
+                await adapter.writeFiles(msg.files);
+                return { type: 'writeFiles', ok: true };
+            }
+            catch (err) {
+                return {
+                    type: 'writeFiles',
+                    ok: false,
+                    error: err instanceof Error ? err.message : String(err),
+                };
+            }
+        }
+        case 'deleteFile': {
+            if (!adapter)
+                return {
+                    type: 'deleteFile',
+                    ok: false,
+                    error: 'No backend initialized',
+                };
+            try {
+                await adapter.deleteFile(msg.collection, msg.filename);
+                return { type: 'deleteFile', ok: true };
+            }
+            catch (err) {
+                return {
+                    type: 'deleteFile',
+                    ok: false,
+                    error: err instanceof Error ? err.message : String(err),
+                };
+            }
+        }
+        case 'teardown': {
+            adapter = null;
+            return { type: 'teardown', ok: true };
+        }
+        default: {
+            // Prevents silent hangs if an unrecognized message type arrives
+            const exhaustive = msg;
+            return {
+                type: exhaustive.type,
+                ok: false,
+                error: 'Unknown message type',
+            };
+        }
+    }
+}
+/**
+ * Wires up message handling for a connected port. Passes through `_id` from requests so the StorageClient can correlate responses.
+ * @param {MessagePort} port - The port to listen on
+ * @return {void}
+ */
+function setupPort(port) {
+    port.addEventListener('message', async (event) => {
+        const { _id, ...msg } = event.data;
+        // Handle port bridging — main thread transfers ports for dedicated workers
+        if (msg.type === 'connect-port') {
+            const transferredPort = event.ports[0];
+            if (transferredPort)
+                setupPort(transferredPort);
+            return;
+        }
+        const response = await handleMessage(msg);
+        port.postMessage({ ...response, _id });
+    });
+    port.start();
+    // Acknowledge the connection so the caller knows the port is ready
+    port.postMessage({ type: 'port-connected' });
+}
+// SharedWorker entry — handle direct connections from Window contexts
+self.addEventListener('connect', (event) => {
+    const port = event.ports[0];
+    setupPort(port);
+});
+export {};

package/dist/client/js/storage/workers/toml-parser.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=toml-parser.d.ts.map

package/dist/client/js/storage/workers/toml-parser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"toml-parser.d.ts","sourceRoot":"","sources":["../../../../../src/client/js/storage/workers/toml-parser.ts"],"names":[],"mappings":""}

package/dist/client/js/storage/workers/toml-parser.js

@@ -0,0 +1,75 @@
+/*
+ * TOML parser worker
+ *
+ * Runs as a dedicated Worker. Handles three message types — parse, parse-batch,
+ * stringify — and posts results back to the main thread via self.postMessage.
+ * All handlers are wrapped in try/catch so errors are returned as structured
+ * failure messages rather than unhandled rejections.
+ */
+import { parse, stringify } from 'smol-toml';
+/**
+ * Handles a 'parse' request: parses a single TOML string and posts the result.
+ * @param {ParseMessage} msg - The inbound parse message
+ * @return {void}
+ */
+function handleParse(msg) {
+    const { id, content } = msg;
+    try {
+        const data = parse(content);
+        self.postMessage({ type: 'parse-result', id, ok: true, data });
+    }
+    catch (err) {
+        const error = err instanceof Error ? err.message : String(err);
+        self.postMessage({ type: 'parse-result', id, ok: false, error });
+    }
+}
+/**
+ * Handles a 'parse-batch' request: parses multiple TOML strings keyed by
+ * a caller-supplied key, and posts a single result containing all parsed values.
+ * @param {ParseBatchMessage} msg - The inbound parse-batch message
+ * @return {void}
+ */
+function handleParseBatch(msg) {
+    const { id, items } = msg;
+    try {
+        const results = {};
+        for (const item of items) {
+            results[item.key] = parse(item.content);
+        }
+        self.postMessage({ type: 'parse-batch-result', id, ok: true, results });
+    }
+    catch (err) {
+        const error = err instanceof Error ? err.message : String(err);
+        self.postMessage({ type: 'parse-batch-result', id, ok: false, error });
+    }
+}
+/**
+ * Handles a 'stringify' request: serializes a plain object to a TOML string
+ * and posts the result.
+ * @param {StringifyMessage} msg - The inbound stringify message
+ * @return {void}
+ */
+function handleStringify(msg) {
+    const { id, data } = msg;
+    try {
+        const content = stringify(data);
+        self.postMessage({ type: 'stringify-result', id, ok: true, content });
+    }
+    catch (err) {
+        const error = err instanceof Error ? err.message : String(err);
+        self.postMessage({ type: 'stringify-result', id, ok: false, error });
+    }
+}
+// Dispatch incoming messages by type
+self.addEventListener('message', (event) => {
+    const msg = event.data;
+    if (msg.type === 'parse') {
+        handleParse(msg);
+    }
+    else if (msg.type === 'parse-batch') {
+        handleParseBatch(msg);
+    }
+    else if (msg.type === 'stringify') {
+        handleStringify(msg);
+    }
+});

package/dist/client/js/storage/workers/yaml-parser.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=yaml-parser.d.ts.map

package/dist/client/js/storage/workers/yaml-parser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"yaml-parser.d.ts","sourceRoot":"","sources":["../../../../../src/client/js/storage/workers/yaml-parser.ts"],"names":[],"mappings":""}