nebula-cms 0.1.3 → 0.1.5

package/dist/client/js/state/state.svelte.js

@@ -0,0 +1,300 @@
+/*
+ * Global application state for the admin SPA.
+ * Manages backend connection, schema loading, collections, and navigation state.
+ */
+import schemas from 'virtual:nebula/collections';
+import { loadBackend, saveBackend, clearBackend, } from '../storage/storage';
+import { StorageClient } from '../storage/client';
+import { nav, navigate, adminPath } from './router.svelte';
+import { drafts, mergeDrafts, refreshDrafts, resetDraftMerge, } from '../drafts/merge.svelte';
+import { getSchemaExtensions } from './schema.svelte';
+export { drafts, refreshDrafts };
+// Sorted collection names derived from virtual:nebula/collections.
+export const collections = Object.keys(schemas).sort();
+/*
+ * Uses .js extension because svelte-package does not rewrite URL string literals;
+ * the dist output must reference the compiled .js file, not the source .ts file.
+ *
+ * Guarded for SSR: SharedWorker only exists in browsers. All code paths
+ * that use sharedWorker/storageClient run exclusively on the client
+ * (inside onMount, event handlers, or user-initiated actions).
+ */
+const sharedWorker = typeof SharedWorker !== 'undefined'
+    ? new SharedWorker(new URL('../storage/workers/storage.js', import.meta.url), { type: 'module', name: 'cms-storage' })
+    : null;
+/*
+ * Main-thread StorageClient for editor and draft-merge I/O.
+ * Null during SSR but typed as non-null because every caller is client-only.
+ */
+export const storageClient = (sharedWorker ? new StorageClient(sharedWorker.port) : null);
+let backendType = $state(null);
+let backendReady = $state(false);
+let permissionState = $state('denied');
+let contentList = $state([]);
+let error = $state(null);
+let loading = $state(false);
+export const backend = {
+    // Active backend type, or null if not connected.
+    get type() {
+        return backendType;
+    },
+    // True if a backend is initialized and ready.
+    get ready() {
+        return backendReady;
+    },
+    // FSA permission state for the re-auth flow in BackendPicker.
+    get permission() {
+        return permissionState;
+    },
+};
+export const content = {
+    // Parsed content items for the selected collection.
+    get list() {
+        return contentList;
+    },
+    // True if the frontmatter worker is actively parsing.
+    get loading() {
+        return loading;
+    },
+    // Error message for display in the sidebar.
+    get error() {
+        return error;
+    },
+};
+let worker = null;
+let loadedCollection = '';
+let initPromise = null;
+const contentCache = new Map();
+/**
+ * Initializes the frontmatter worker and bridges a port to the SharedWorker.
+ * @return {Worker}
+ */
+function ensureWorker() {
+    if (worker)
+        return worker;
+    // Uses .js extension because svelte-package does not rewrite URL string literals
+    worker = new Worker(new URL('../storage/workers/frontmatter.js', import.meta.url), { type: 'module' });
+    worker.addEventListener('message', (event) => {
+        const data = event.data;
+        if (data.type === 'result') {
+            const forCollection = data.collection;
+            // Always cache under the correct collection
+            contentCache.set(forCollection, data.items);
+            // Only update the visible list if this result is for the current collection
+            if (forCollection === loadedCollection) {
+                contentList = data.items;
+                loading = false;
+                error = null;
+                if (backendReady)
+                    mergeDrafts(forCollection);
+            }
+        }
+        else if (data.type === 'error') {
+            error = data.message;
+            loading = false;
+            contentList = [];
+        }
+    });
+    // Bridge a port so the frontmatter worker can talk to the storage SharedWorker
+    const channel = new MessageChannel();
+    worker.postMessage({ type: 'port' }, [channel.port1]);
+    sharedWorker.port.postMessage({ type: 'connect-port' }, [channel.port2]);
+    return worker;
+}
+/**
+ * Sends a parse request to the frontmatter worker. Refresh mode keeps current sidebar visible.
+ * @param {string} collection - The collection name to parse
+ * @param {boolean} refresh - If true, keep current contentList and skip loading state
+ * @return {Promise<void>}
+ */
+async function dispatchWorker(collection, refresh = false) {
+    if (!backendReady)
+        return;
+    if (!refresh) {
+        loading = true;
+        contentList = [];
+    }
+    error = null;
+    // Wait for the SharedWorker adapter to be ready before dispatching
+    if (initPromise)
+        await initPromise;
+    const w = ensureWorker();
+    const extensions = getSchemaExtensions(collection);
+    w.postMessage({ type: 'parse', collection, extensions });
+}
+/**
+ * Restores a stored backend config from IndexedDB and initializes the SharedWorker.
+ * @return {Promise<void>}
+ */
+export async function restoreBackend() {
+    try {
+        const config = await loadBackend();
+        if (!config) {
+            backendType = null;
+            backendReady = false;
+            return;
+        }
+        if (config.type === 'fsa') {
+            // Check FSA permission state
+            const perm = await config.handle.queryPermission({ mode: 'readwrite' });
+            permissionState = perm;
+            backendType = 'fsa';
+            if (perm === 'granted') {
+                await storageClient.init({ type: 'init', backend: config });
+                backendReady = true;
+                navigateToFirstCollectionIfHome();
+            }
+            // If perm is 'prompt', BackendPicker shows re-auth button
+        }
+        else {
+            // GitHub — show UI optimistically, validate in background
+            backendType = 'github';
+            backendReady = true;
+            navigateToFirstCollectionIfHome();
+            initPromise = storageClient
+                .init({ type: 'init', backend: config })
+                .catch(async () => {
+                await clearBackend();
+                backendType = null;
+                backendReady = false;
+                contentList = [];
+                contentCache.clear();
+                loadedCollection = '';
+                navigate(adminPath());
+            })
+                .finally(() => {
+                initPromise = null;
+            });
+        }
+    }
+    catch {
+        backendType = null;
+        backendReady = false;
+    }
+}
+/**
+ * Re-requests FSA permission. Must be called from a user gesture.
+ * @return {Promise<void>}
+ */
+export async function requestPermission() {
+    const config = await loadBackend();
+    if (!config || config.type !== 'fsa')
+        return;
+    try {
+        const perm = await config.handle.requestPermission({ mode: 'readwrite' });
+        permissionState = perm;
+        if (perm === 'granted') {
+            await storageClient.init({ type: 'init', backend: config });
+            backendReady = true;
+            navigateToFirstCollectionIfHome();
+        }
+    }
+    catch {
+        permissionState = 'denied';
+    }
+}
+/**
+ * Opens the directory picker and initializes the FSA backend. Must be called from a user gesture.
+ * @return {Promise<void>}
+ */
+export async function pickDirectory() {
+    try {
+        const handle = await window.showDirectoryPicker({ mode: 'readwrite' });
+        const config = { type: 'fsa', handle };
+        await storageClient.init({ type: 'init', backend: config });
+        await saveBackend(config);
+        backendType = 'fsa';
+        permissionState = 'granted';
+        backendReady = true;
+        navigateToFirstCollectionIfHome();
+    }
+    catch (err) {
+        if (err instanceof DOMException && err.name === 'AbortError')
+            return;
+        error = err instanceof Error ? err.message : String(err);
+    }
+}
+/**
+ * Connects to a GitHub repository via PAT and persists the config.
+ * @param {string} token - GitHub Personal Access Token
+ * @param {string} repo - Repository in "owner/repo" format
+ * @return {Promise<void>}
+ */
+export async function connectGitHub(token, repo) {
+    const config = { type: 'github', token, repo };
+    await storageClient.init({ type: 'init', backend: config });
+    await saveBackend(config);
+    backendType = 'github';
+    backendReady = true;
+    navigateToFirstCollectionIfHome();
+}
+/**
+ * Disconnects the backend, clears credentials, and resets all state.
+ * @return {Promise<void>}
+ */
+export async function disconnect() {
+    worker?.terminate();
+    worker = null;
+    resetDraftMerge();
+    await storageClient.teardown();
+    await clearBackend();
+    backendType = null;
+    backendReady = false;
+    permissionState = 'denied';
+    contentList = [];
+    contentCache.clear();
+    loadedCollection = '';
+    error = null;
+    loading = false;
+    navigate(adminPath());
+}
+/**
+ * Navigates to the first collection if currently on the home view.
+ * @return {void}
+ */
+function navigateToFirstCollectionIfHome() {
+    if (nav.route.view === 'home' && collections.length > 0) {
+        navigate(adminPath(collections[0]));
+    }
+}
+/**
+ * Loads a collection. Serves from cache instantly if available, then background refreshes.
+ * @param {string} collection - The collection name to load
+ * @return {void}
+ */
+export function loadCollection(collection) {
+    if (collection === loadedCollection)
+        return;
+    loadedCollection = collection;
+    const cached = contentCache.get(collection);
+    if (cached) {
+        // Serve cached items instantly, then refresh in background
+        contentList = cached;
+        refreshDrafts(collection);
+        dispatchWorker(collection, true);
+    }
+    else {
+        dispatchWorker(collection);
+    }
+}
+/**
+ * Forces a background reload, keeping the sidebar visible.
+ * @param {string} collection - The collection to reload
+ * @return {void}
+ */
+export function reloadCollection(collection) {
+    loadedCollection = collection;
+    dispatchWorker(collection, true);
+}
+/**
+ * Optimistically updates a single item's frontmatter in the content list and cache.
+ * @param {string} filename - The filename to update
+ * @param {Record<string, unknown>} data - The new frontmatter data
+ * @return {void}
+ */
+export function updateContentItem(filename, data) {
+    const updated = contentList.map((item) => item.filename === filename ? { ...item, data } : item);
+    contentList = updated;
+    if (loadedCollection)
+        contentCache.set(loadedCollection, updated);
+}

package/dist/client/js/state/theme.svelte.d.ts

@@ -0,0 +1,24 @@
+type ResolvedTheme = 'light' | 'dark';
+type ThemeIcon = 'light_mode' | 'dark_mode' | 'brightness_auto';
+type ThemeLabel = 'Light' | 'Dark' | 'Auto';
+export declare const theme: {
+    readonly resolved: ResolvedTheme;
+    readonly icon: ThemeIcon;
+    readonly label: ThemeLabel;
+};
+/**
+ * Starts listening to OS color scheme changes via matchMedia.
+ * Preference and initial system state are already read at module init,
+ * so this only needs to register the change listener. Call once on mount.
+ * Safe to call multiple times — registers the listener only once.
+ * @return {() => void} Cleanup function that removes the listener
+ */
+export declare function initTheme(): () => void;
+/**
+ * Cycles the preference through auto -> light -> dark -> auto.
+ * Persists the new value to localStorage.
+ * @return {void}
+ */
+export declare function cycleTheme(): void;
+export {};
+//# sourceMappingURL=theme.svelte.d.ts.map

package/dist/client/js/state/theme.svelte.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"theme.svelte.d.ts","sourceRoot":"","sources":["../../../../src/client/js/state/theme.svelte.ts"],"names":[],"mappings":"AAUA,KAAK,aAAa,GAAG,OAAO,GAAG,MAAM,CAAC;AAGtC,KAAK,SAAS,GAAG,YAAY,GAAG,WAAW,GAAG,iBAAiB,CAAC;AAGhE,KAAK,UAAU,GAAG,OAAO,GAAG,MAAM,GAAG,MAAM,CAAC;AAmF5C,eAAO,MAAM,KAAK;uBACA,aAAa;mBAGjB,SAAS;oBAGR,UAAU;CAGxB,CAAC;AAWF;;;;;;GAMG;AACH,wBAAgB,SAAS,IAAI,MAAM,IAAI,CAmBtC;AAQD;;;;GAIG;AACH,wBAAgB,UAAU,IAAI,IAAI,CAajC"}

package/{src/client/js/state/theme.svelte.ts → dist/client/js/state/theme.svelte.js}

@@ -3,121 +3,88 @@
  * Manages a three-way preference (light / dark / auto) and resolves the effective
  * theme by combining user preference with the OS-level color scheme.
  */
-
-// Tri-state preference: 'light', 'dark', or 'auto' (follow system)
-type ThemePreference = 'light' | 'dark' | 'auto';
-
-// Resolved theme applied to the DOM — always 'light' or 'dark'
-type ResolvedTheme = 'light' | 'dark';
-
-// Material Symbols icon name for each preference
-type ThemeIcon = 'light_mode' | 'dark_mode' | 'brightness_auto';
-
-// Human-readable label for each preference
-type ThemeLabel = 'Light' | 'Dark' | 'Auto';
-
 // localStorage key for persisting the user's preference
 const STORAGE_KEY = 'nebula-theme';
-
 /*
 //////////////////////////////
 // Preference → UI mapping
 //////////////////////////////
 */
-
 /*
  * Single source of truth for all preference-derived UI values.
  * Adding a new preference requires a new entry here — TypeScript
  * enforces exhaustiveness via the Record<ThemePreference, ...> type.
  */
-const THEME_MAP: Record<
-  ThemePreference,
-  { icon: ThemeIcon; label: ThemeLabel }
-> = {
-  light: { icon: 'light_mode', label: 'Light' },
-  dark: { icon: 'dark_mode', label: 'Dark' },
-  auto: { icon: 'brightness_auto', label: 'Auto' },
+const THEME_MAP = {
+    light: { icon: 'light_mode', label: 'Light' },
+    dark: { icon: 'dark_mode', label: 'Dark' },
+    auto: { icon: 'brightness_auto', label: 'Auto' },
 };
-
 /*
 //////////////////////////////
 // Module initialization
 //////////////////////////////
 */
-
 /*
  * Read preference from localStorage at module init to avoid a flash of wrong theme.
  * Safe because this module is only loaded client-side (client:only="svelte").
  */
-let stored: string | null = null;
+let stored = null;
 try {
-  if (typeof localStorage !== 'undefined') {
-    stored = localStorage.getItem(STORAGE_KEY);
-  }
-} catch {
-  // Storage access blocked (SecurityError, private browsing, etc.)
+    if (typeof localStorage !== 'undefined') {
+        stored = localStorage.getItem(STORAGE_KEY);
+    }
+}
+catch {
+    // Storage access blocked (SecurityError, private browsing, etc.)
 }
-
 /*
  * Read system preference at module init so the first render has the correct
  * resolved theme — deferring this to onMount would cause a flash for auto+dark users.
  */
-const mq =
-  typeof window !== 'undefined'
+const mq = typeof window !== 'undefined'
     ? window.matchMedia('(prefers-color-scheme: dark)')
     : null;
-
 // The user's explicit preference
-let preference = $state<ThemePreference>(
-  stored === 'light' || stored === 'dark' || stored === 'auto'
+let preference = $state(stored === 'light' || stored === 'dark' || stored === 'auto'
     ? stored
-    : 'auto',
-);
-
+    : 'auto');
 // Whether the OS prefers dark mode — updated via matchMedia listener
 let systemPrefersDark = $state(mq?.matches ?? false);
-
 /*
 //////////////////////////////
 // Derived state
 //////////////////////////////
 */
-
 /*
  * $derived can only be a variable declaration initializer, not an object
  * property — Svelte compiler restriction. These private derivations feed
  * the exported theme object via getters.
  */
-const resolved: ResolvedTheme = $derived(
-  preference === 'auto' ? (systemPrefersDark ? 'dark' : 'light') : preference,
-);
+const resolved = $derived(preference === 'auto' ? (systemPrefersDark ? 'dark' : 'light') : preference);
 const ui = $derived(THEME_MAP[preference]);
-
 /*
  * Reactive theme state. Consumers read properties directly: theme.resolved,
  * theme.icon, theme.label. The getters forward Svelte's reactive tracking.
  */
 export const theme = {
-  get resolved(): ResolvedTheme {
-    return resolved;
-  },
-  get icon(): ThemeIcon {
-    return ui.icon;
-  },
-  get label(): ThemeLabel {
-    return ui.label;
-  },
+    get resolved() {
+        return resolved;
+    },
+    get icon() {
+        return ui.icon;
+    },
+    get label() {
+        return ui.label;
+    },
 };
-
 /*
 //////////////////////////////
 // System preference tracking
 //////////////////////////////
 */
-
 // Guard against duplicate listener registration (e.g. HMR remount)
 let initialized = false;
-
 /**
  * Starts listening to OS color scheme changes via matchMedia.
  * Preference and initial system state are already read at module init,
@@ -125,49 +92,45 @@ let initialized = false;
  * Safe to call multiple times — registers the listener only once.
  * @return {() => void} Cleanup function that removes the listener
  */
-export function initTheme(): () => void {
-  if (initialized) return () => {};
-  initialized = true;
-
-  /**
-   * Updates the systemPrefersDark flag when the OS color scheme changes.
-   * @param {MediaQueryListEvent} e - The change event from matchMedia
-   * @return {void}
-   */
-  const handler = (e: MediaQueryListEvent): void => {
-    systemPrefersDark = e.matches;
-  };
-
-  mq?.addEventListener('change', handler);
-
-  return () => {
-    mq?.removeEventListener('change', handler);
-    initialized = false;
-  };
+export function initTheme() {
+    if (initialized)
+        return () => { };
+    initialized = true;
+    /**
+     * Updates the systemPrefersDark flag when the OS color scheme changes.
+     * @param {MediaQueryListEvent} e - The change event from matchMedia
+     * @return {void}
+     */
+    const handler = (e) => {
+        systemPrefersDark = e.matches;
+    };
+    mq?.addEventListener('change', handler);
+    return () => {
+        mq?.removeEventListener('change', handler);
+        initialized = false;
+    };
 }
-
 /*
 //////////////////////////////
 // Actions
 //////////////////////////////
 */
-
 /**
  * Cycles the preference through auto -> light -> dark -> auto.
  * Persists the new value to localStorage.
  * @return {void}
  */
-export function cycleTheme(): void {
-  const next: ThemePreference =
-    preference === 'auto' ? 'light' : preference === 'light' ? 'dark' : 'auto';
-  preference = next;
-  try {
-    localStorage.setItem(STORAGE_KEY, next);
-  } catch {
-    /*
-     * Persistence failed (quota exceeded, storage disabled, etc.).
-     * The in-memory preference is already updated, so the current
-     * session works correctly — it just won't survive a page reload.
-     */
-  }
+export function cycleTheme() {
+    const next = preference === 'auto' ? 'light' : preference === 'light' ? 'dark' : 'auto';
+    preference = next;
+    try {
+        localStorage.setItem(STORAGE_KEY, next);
+    }
+    catch {
+        /*
+         * Persistence failed (quota exceeded, storage disabled, etc.).
+         * The in-memory preference is already updated, so the current
+         * session works correctly — it just won't survive a page reload.
+         */
+    }
 }

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

@@ -0,0 +1,130 @@
+export type FileEntry = {
+    filename: string;
+    content: string;
+};
+export type FileWrite = {
+    collection: string;
+    filename: string;
+    content: string;
+};
+export interface StorageAdapter {
+    /**
+     * Lists files in a collection matching the given extensions, returning their names and content.
+     * @param {string} collection - The collection name
+     * @param {string[]} extensions - File extensions to include (e.g. ['.md', '.mdx', '.yaml'])
+     * @return {Promise<FileEntry[]>} Array of filename + content pairs
+     */
+    listFiles(collection: string, extensions: string[]): Promise<FileEntry[]>;
+    /**
+     * Deletes a single file from the collection. Used during file type conversion to remove the old file after the new one is written.
+     * @param {string} collection - The collection name
+     * @param {string} filename - The filename to delete
+     * @return {Promise<void>}
+     */
+    deleteFile(collection: string, filename: string): Promise<void>;
+    /**
+     * Reads a single file's content.
+     * @param {string} collection - The collection name
+     * @param {string} filename - The filename within the collection
+     * @return {Promise<string>} The file content as a string
+     */
+    readFile(collection: string, filename: string): Promise<string>;
+    /**
+     * Writes content to a single file, creating it if it doesn't exist.
+     * @param {string} collection - The collection name
+     * @param {string} filename - The filename within the collection
+     * @param {string} content - The content to write
+     * @return {Promise<void>}
+     */
+    writeFile(collection: string, filename: string, content: string): Promise<void>;
+    /**
+     * Writes multiple files atomically (single commit for GitHub, sequential for FSA).
+     * @param {FileWrite[]} files - Array of files to write
+     * @return {Promise<void>}
+     */
+    writeFiles(files: FileWrite[]): Promise<void>;
+}
+export type StorageRequest = {
+    type: 'init';
+    backend: {
+        type: 'fsa';
+        handle: FileSystemDirectoryHandle;
+    } | {
+        type: 'github';
+        token: string;
+        repo: string;
+    };
+} | {
+    type: 'listFiles';
+    collection: string;
+    extensions: string[];
+} | {
+    type: 'readFile';
+    collection: string;
+    filename: string;
+} | {
+    type: 'writeFile';
+    collection: string;
+    filename: string;
+    content: string;
+} | {
+    type: 'writeFiles';
+    files: FileWrite[];
+} | {
+    type: 'deleteFile';
+    collection: string;
+    filename: string;
+} | {
+    type: 'teardown';
+};
+export type StorageResponse = {
+    type: 'init';
+    ok: true;
+} | {
+    type: 'init';
+    ok: false;
+    error: string;
+} | {
+    type: 'listFiles';
+    ok: true;
+    files: FileEntry[];
+} | {
+    type: 'listFiles';
+    ok: false;
+    error: string;
+} | {
+    type: 'readFile';
+    ok: true;
+    content: string;
+} | {
+    type: 'readFile';
+    ok: false;
+    error: string;
+} | {
+    type: 'writeFile';
+    ok: true;
+} | {
+    type: 'writeFile';
+    ok: false;
+    error: string;
+} | {
+    type: 'writeFiles';
+    ok: true;
+} | {
+    type: 'writeFiles';
+    ok: false;
+    error: string;
+} | {
+    type: 'deleteFile';
+    ok: true;
+} | {
+    type: 'deleteFile';
+    ok: false;
+    error: string;
+} | {
+    type: 'teardown';
+    ok: true;
+} | {
+    type: 'port-connected';
+};
+//# sourceMappingURL=adapter.d.ts.map