nebula-cms 0.1.3 → 0.1.5

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":""}

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

@@ -0,0 +1,100 @@
+/*
+ * YAML Parser Worker
+ *
+ * Handles YAML parsing and serialization on behalf of the main thread.
+ * Messages are dispatched by type: 'parse', 'parse-batch', 'stringify'.
+ * Each handler wraps its logic in try/catch and always posts a typed result.
+ */
+import { load, dump } from 'js-yaml';
+/*
+//////////////////////////////
+// Message handler
+//////////////////////////////
+*/
+/**
+ * Handles a single YAML parse request. Parses the provided content string
+ * and posts a parse-result message with the resulting data object or error.
+ * @param {ParseMessage} msg - The inbound parse message
+ * @return {void}
+ */
+function handleParse(msg) {
+    try {
+        const data = load(msg.content);
+        self.postMessage({ type: 'parse-result', id: msg.id, ok: true, data });
+    }
+    catch (err) {
+        const error = err instanceof Error ? err.message : String(err);
+        self.postMessage({ type: 'parse-result', id: msg.id, ok: false, error });
+    }
+}
+/**
+ * Handles a batch YAML parse request. Iterates over all items, parses each
+ * one, and posts a parse-batch-result with a key-to-data results map.
+ * If any item fails to parse, the entire batch result is marked as failed.
+ * @param {ParseBatchMessage} msg - The inbound parse-batch message
+ * @return {void}
+ */
+function handleParseBatch(msg) {
+    try {
+        const results = {};
+        for (const item of msg.items) {
+            results[item.key] = load(item.content);
+        }
+        self.postMessage({
+            type: 'parse-batch-result',
+            id: msg.id,
+            ok: true,
+            results,
+        });
+    }
+    catch (err) {
+        const error = err instanceof Error ? err.message : String(err);
+        self.postMessage({
+            type: 'parse-batch-result',
+            id: msg.id,
+            ok: false,
+            error,
+        });
+    }
+}
+/**
+ * Handles a YAML stringify request. Serializes the provided data object to
+ * a YAML string and posts a stringify-result message with the content.
+ * lineWidth: -1 disables js-yaml's automatic line folding so long values
+ * are not wrapped across lines, which would corrupt multi-line string values.
+ * @param {StringifyMessage} msg - The inbound stringify message
+ * @return {void}
+ */
+function handleStringify(msg) {
+    try {
+        const content = dump(msg.data, { lineWidth: -1 });
+        self.postMessage({
+            type: 'stringify-result',
+            id: msg.id,
+            ok: true,
+            content,
+        });
+    }
+    catch (err) {
+        const error = err instanceof Error ? err.message : String(err);
+        self.postMessage({
+            type: 'stringify-result',
+            id: msg.id,
+            ok: false,
+            error,
+        });
+    }
+}
+// Listen for messages from the main thread and dispatch 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/utils/file-types.d.ts

@@ -0,0 +1,58 @@
+export type FileTypeConfig = {
+    extensions: string[];
+    hasBody: boolean;
+    category: 'frontmatter' | 'data';
+    dataFormat?: 'json' | 'yaml' | 'toml';
+};
+export declare const FILE_TYPES: Record<string, FileTypeConfig>;
+/**
+ * Resolves a schema's `files` array of type identifiers to a flat list of file extensions.
+ * Used by storage adapters for file discovery filtering.
+ * @param {Record<string, unknown>} schema - A collection JSON Schema with an optional `files` array
+ * @return {string[]} Ordered list of extensions (e.g. ['.md', '.markdown', '.json'])
+ */
+export declare function getExtensionsForSchema(schema: Record<string, unknown>): string[];
+/**
+ * Returns whether a file should show the body editor panel.
+ * True for markdown, MDX, and Markdoc files; false for pure data files.
+ * @param {string} filename - The filename to check
+ * @return {boolean} True if the file type has a body editor
+ */
+export declare function hasBodyEditor(filename: string): boolean;
+/**
+ * Returns the category of a file based on its extension.
+ * Used to determine whether to render frontmatter fields or data-only fields.
+ * @param {string} filename - The filename to categorise
+ * @return {'frontmatter' | 'data' | null} The file category, or null for unrecognised extensions
+ */
+export declare function getFileCategory(filename: string): 'frontmatter' | 'data' | null;
+/**
+ * Returns the serialization format for a data file.
+ * Returns null for frontmatter files and unrecognised extensions.
+ * @param {string} filename - The filename to inspect
+ * @return {'json' | 'yaml' | 'toml' | null} The data format, or null if not a data file
+ */
+export declare function getDataFormat(filename: string): 'json' | 'yaml' | 'toml' | null;
+/**
+ * Strips the file extension from a filename when the extension is a known type.
+ * Returns the filename unchanged if the extension is not recognised.
+ * Used for generating URL slugs from filenames.
+ * @param {string} filename - The filename to strip the extension from
+ * @return {string} The filename without its known extension, or the original filename
+ */
+export declare function stripExtension(filename: string): string;
+/**
+ * Returns the default (first) file extension for a given type identifier.
+ * Used when creating new files to pick the canonical extension for a format.
+ * @param {string} type - A type identifier (e.g. 'md', 'yaml', 'toml')
+ * @return {string | null} The default extension including the leading dot, or null for unknown types
+ */
+export declare function getDefaultExtension(type: string): string | null;
+/**
+ * Returns the type identifier for a given filename by looking up its extension.
+ * Used when the active file's type must be determined for the format selector.
+ * @param {string} filename - The filename to look up
+ * @return {string | null} The type identifier (e.g. 'md', 'yaml'), or null for unrecognised extensions
+ */
+export declare function getTypeForFilename(filename: string): string | null;
+//# sourceMappingURL=file-types.d.ts.map

package/dist/client/js/utils/file-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"file-types.d.ts","sourceRoot":"","sources":["../../../../src/client/js/utils/file-types.ts"],"names":[],"mappings":"AAQA,MAAM,MAAM,cAAc,GAAG;IAE3B,UAAU,EAAE,MAAM,EAAE,CAAC;IAErB,OAAO,EAAE,OAAO,CAAC;IAEjB,QAAQ,EAAE,aAAa,GAAG,MAAM,CAAC;IAEjC,UAAU,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,CAAC;CACvC,CAAC;AAGF,eAAO,MAAM,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,cAAc,CAkCrD,CAAC;AA6CF;;;;;GAKG;AACH,wBAAgB,sBAAsB,CACpC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC9B,MAAM,EAAE,CAYV;AAED;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAGvD;AAED;;;;;GAKG;AACH,wBAAgB,eAAe,CAC7B,QAAQ,EAAE,MAAM,GACf,aAAa,GAAG,MAAM,GAAG,IAAI,CAG/B;AAED;;;;;GAKG;AACH,wBAAgB,aAAa,CAC3B,QAAQ,EAAE,MAAM,GACf,MAAM,GAAG,MAAM,GAAG,MAAM,GAAG,IAAI,CAGjC;AAED;;;;;;GAMG;AACH,wBAAgB,cAAc,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAMvD;AAED;;;;;GAKG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAE/D;AAED;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAElE"}