nebula-cms 0.1.0 → 0.1.4

package/src/client/js/state/state.svelte.ts

@@ -1,334 +0,0 @@
-/*
- * 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,
-  type BackendConfig,
-} 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 };
-
-// Content item with full frontmatter data returned by the worker.
-export type ContentItem = {
-  filename: string;
-  data: Record<string, unknown>;
-};
-
-// Permission state for the stored FSA directory handle.
-type PermissionState = 'granted' | 'prompt' | 'denied';
-// Backend type discriminator.
-type BackendType = 'fsa' | 'github' | null;
-// 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.
- */
-const sharedWorker = new SharedWorker(
-  new URL('../storage/workers/storage.js', import.meta.url),
-  { type: 'module', name: 'cms-storage' },
-);
-// Main-thread StorageClient for editor and draft-merge I/O.
-export const storageClient = new StorageClient(sharedWorker.port);
-let backendType = $state<BackendType>(null);
-let backendReady = $state(false);
-let permissionState = $state<PermissionState>('denied');
-let contentList = $state<ContentItem[]>([]);
-let error = $state<string | null>(null);
-let loading = $state(false);
-
-export const backend = {
-  // Active backend type, or null if not connected.
-  get type(): BackendType {
-    return backendType;
-  },
-  // True if a backend is initialized and ready.
-  get ready(): boolean {
-    return backendReady;
-  },
-  // FSA permission state for the re-auth flow in BackendPicker.
-  get permission(): PermissionState {
-    return permissionState;
-  },
-};
-
-export const content = {
-  // Parsed content items for the selected collection.
-  get list(): ContentItem[] {
-    return contentList;
-  },
-  // True if the frontmatter worker is actively parsing.
-  get loading(): boolean {
-    return loading;
-  },
-  // Error message for display in the sidebar.
-  get error(): string | null {
-    return error;
-  },
-};
-let worker: Worker | null = null;
-let loadedCollection = '';
-let initPromise: Promise<void> | null = null;
-const contentCache = new Map<string, ContentItem[]>();
-
-/**
- * Initializes the frontmatter worker and bridges a port to the SharedWorker.
- * @return {Worker}
- */
-function ensureWorker(): Worker {
-  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 as string;
-      // 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: string,
-  refresh = false,
-): Promise<void> {
-  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(): Promise<void> {
-  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(): Promise<void> {
-  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(): Promise<void> {
-  try {
-    const handle = await window.showDirectoryPicker({ mode: 'readwrite' });
-    const config: BackendConfig = { 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: string,
-  repo: string,
-): Promise<void> {
-  const config: BackendConfig = { 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(): Promise<void> {
-  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(): void {
-  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: string): void {
-  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: string): void {
-  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: string,
-  data: Record<string, unknown>,
-): void {
-  const updated = contentList.map((item) =>
-    item.filename === filename ? { ...item, data } : item,
-  );
-  contentList = updated;
-  if (loadedCollection) contentCache.set(loadedCollection, updated);
-}

package/src/client/js/storage/adapter.ts

@@ -1,102 +0,0 @@
-/*
- * Storage adapter interface and shared types.
- * Defines the contract that FSA and GitHub storage backends implement.
- */
-
-// A single file's name and content as returned by listFiles.
-export type FileEntry = {
-  filename: string;
-  content: string;
-};
-
-// A file write target with collection path, filename, and content.
-export type FileWrite = {
-  collection: string;
-  filename: string;
-  content: string;
-};
-
-// Contract for storage backend adapters. Both FSA and GitHub adapters implement this.
-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>;
-}
-
-/*
-//////////////////////////////
-// Message types for SharedWorker communication
-//////////////////////////////
-*/
-
-// Union of all request messages that can be sent to the storage SharedWorker.
-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' };
-
-// Union of all response messages from the storage SharedWorker.
-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' };

package/src/client/js/storage/client.ts

@@ -1,150 +0,0 @@
-/*
- * Typed client for communicating with the storage SharedWorker over a MessagePort.
- * Wraps postMessage/onmessage into async request/response calls.
- */
-
-import type {
-  StorageRequest,
-  StorageResponse,
-  FileEntry,
-  FileWrite,
-} from './adapter';
-
-export class StorageClient {
-  private port: MessagePort;
-  private pending = new Map<
-    string,
-    { resolve: (v: any) => void; reject: (e: Error) => void }
-  >();
-  private idCounter = 0;
-
-  /**
-   * Creates a client wrapping the given port.
-   * @param {MessagePort} port - The port connected to the storage SharedWorker
-   */
-  constructor(port: MessagePort) {
-    this.port = port;
-    this.port.addEventListener('message', (event) => {
-      this.handleResponse(event.data);
-    });
-    this.port.start();
-  }
-
-  /**
-   * Routes responses to their pending promises. Responses without an _id are broadcast (like port-connected) and are ignored here.
-   * @param {StorageResponse & { _id?: string }} data - The response data
-   * @return {void}
-   */
-  private handleResponse(data: StorageResponse & { _id?: string }): void {
-    if (!data._id) return;
-    const entry = this.pending.get(data._id);
-    if (!entry) return;
-    this.pending.delete(data._id);
-    if ('ok' in data && data.ok === false && 'error' in data) {
-      entry.reject(new Error((data as any).error));
-    } else {
-      entry.resolve(data);
-    }
-  }
-
-  /**
-   * Sends a request and waits for the matching response.
-   * @param {StorageRequest} msg - The request to send
-   * @return {Promise<StorageResponse>} The matched response
-   */
-  private send<T extends StorageResponse>(msg: StorageRequest): Promise<T> {
-    const _id = String(++this.idCounter);
-    return new Promise((resolve, reject) => {
-      this.pending.set(_id, { resolve, reject });
-      this.port.postMessage({ ...msg, _id });
-    });
-  }
-
-  /**
-   * Initializes the backend adapter in the SharedWorker.
-   * @param {StorageRequest & { type: 'init' }} config - The init config
-   * @return {Promise<void>}
-   */
-  async init(config: StorageRequest & { type: 'init' }): Promise<void> {
-    await this.send(config);
-  }
-
-  /**
-   * Lists files in a collection matching the given extensions.
-   * @param {string} collection - The collection name
-   * @param {string[]} extensions - File extensions to include (e.g. ['.md', '.mdx'])
-   * @return {Promise<FileEntry[]>} Array of file entries
-   */
-  async listFiles(
-    collection: string,
-    extensions: string[],
-  ): Promise<FileEntry[]> {
-    const res = await this.send<
-      Extract<StorageResponse, { type: 'listFiles'; ok: true }>
-    >({
-      type: 'listFiles',
-      collection,
-      extensions,
-    });
-    return res.files;
-  }
-
-  /**
-   * Reads a single file's content.
-   * @param {string} collection - The collection name
-   * @param {string} filename - The filename
-   * @return {Promise<string>} The file content
-   */
-  async readFile(collection: string, filename: string): Promise<string> {
-    const res = await this.send<
-      Extract<StorageResponse, { type: 'readFile'; ok: true }>
-    >({
-      type: 'readFile',
-      collection,
-      filename,
-    });
-    return res.content;
-  }
-
-  /**
-   * Writes a single file.
-   * @param {string} collection - The collection name
-   * @param {string} filename - The filename
-   * @param {string} content - The content to write
-   * @return {Promise<void>}
-   */
-  async writeFile(
-    collection: string,
-    filename: string,
-    content: string,
-  ): Promise<void> {
-    await this.send({ type: 'writeFile', collection, filename, content });
-  }
-
-  /**
-   * Writes multiple files atomically.
-   * @param {FileWrite[]} files - Array of files to write
-   * @return {Promise<void>}
-   */
-  async writeFiles(files: FileWrite[]): Promise<void> {
-    await this.send({ type: 'writeFiles', files });
-  }
-
-  /**
-   * Deletes a file from a 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>}
-   */
-  async deleteFile(collection: string, filename: string): Promise<void> {
-    await this.send({ type: 'deleteFile', collection, filename });
-  }
-
-  /**
-   * Tears down the active backend adapter.
-   * @return {Promise<void>}
-   */
-  async teardown(): Promise<void> {
-    await this.send({ type: 'teardown' });
-  }
-}

package/src/client/js/storage/db.ts

@@ -1,36 +0,0 @@
-// Database name for admin CMS persistence
-const DB_NAME = 'cms-admin';
-// Current database version — bumped from 1 to add the drafts store
-const DB_VERSION = 2;
-
-// Cached database promise — opened once, reused by all callers
-let dbPromise: Promise<IDBDatabase> | null = null;
-
-/**
- * Opens (or returns the cached) shared IndexedDB database, creating or upgrading stores as needed.
- * The connection is opened once and reused, avoiding a new indexedDB.open() round-trip per call.
- * Version 1: handles store only. Version 2: adds drafts store.
- * @return {Promise<IDBDatabase>} Promise resolving to the database instance
- */
-export function openDB(): Promise<IDBDatabase> {
-  if (dbPromise) return dbPromise;
-  dbPromise = new Promise((resolve, reject) => {
-    const request = indexedDB.open(DB_NAME, DB_VERSION);
-    request.onupgradeneeded = () => {
-      const db = request.result;
-      if (!db.objectStoreNames.contains('handles')) {
-        db.createObjectStore('handles');
-      }
-      if (!db.objectStoreNames.contains('drafts')) {
-        db.createObjectStore('drafts', { keyPath: 'id' });
-      }
-    };
-    request.onsuccess = () => resolve(request.result);
-    request.onerror = () => {
-      // Reset cache so the next caller retries instead of getting a stale rejection
-      dbPromise = null;
-      reject(request.error);
-    };
-  });
-  return dbPromise;
-}