nebula-cms 0.1.3 → 0.1.4

package/src/client/js/storage/workers/yaml-parser.ts

@@ -1,132 +0,0 @@
-/*
- * 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';
-
-// Inbound message shape for a single YAML parse request.
-interface ParseMessage {
-  type: 'parse';
-  id: string;
-  content: string;
-}
-
-// A single item in a batch parse request.
-interface BatchItem {
-  key: string;
-  content: string;
-}
-
-// Inbound message shape for a batch YAML parse request.
-interface ParseBatchMessage {
-  type: 'parse-batch';
-  id: string;
-  items: BatchItem[];
-}
-
-// Inbound message shape for a YAML stringify request.
-interface StringifyMessage {
-  type: 'stringify';
-  id: string;
-  data: Record<string, unknown>;
-}
-
-// Union of all inbound message types.
-type InboundMessage = ParseMessage | ParseBatchMessage | StringifyMessage;
-
-/*
-//////////////////////////////
-// 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: ParseMessage): void {
-  try {
-    const data = load(msg.content) as Record<string, unknown>;
-    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: ParseBatchMessage): void {
-  try {
-    const results: Record<string, Record<string, unknown>> = {};
-    for (const item of msg.items) {
-      results[item.key] = load(item.content) as Record<string, unknown>;
-    }
-    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: StringifyMessage): void {
-  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: MessageEvent<InboundMessage>) => {
-  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/src/client/js/utils/frontmatter.ts

@@ -1,38 +0,0 @@
-// Result of splitting a file into frontmatter and body.
-export type SplitResult = {
-  rawFrontmatter: string;
-  body: string;
-};
-
-/**
- * Splits a markdown/MDX file into raw YAML frontmatter and body content.
- * Handles BOM stripping, CRLF normalization, and horizontal rule rejection.
- * @param {string} content - Raw file content
- * @return {SplitResult} The separated frontmatter and body strings
- */
-export function splitFrontmatter(content: string): SplitResult {
-  let str = content.startsWith('\uFEFF') ? content.slice(1) : content;
-  str = str.replace(/\r\n/g, '\n');
-
-  // Reject horizontal rules (----) and content not starting with frontmatter delimiter
-  if (str.startsWith('----') || !str.startsWith('---\n')) {
-    return { rawFrontmatter: '', body: str };
-  }
-
-  const closeIndex = str.indexOf('\n---\n', 3);
-  if (closeIndex === -1) {
-    // Check for --- at end of file with no trailing newline
-    if (str.endsWith('\n---')) {
-      return {
-        rawFrontmatter: str.slice(4, str.length - 4),
-        body: '',
-      };
-    }
-    return { rawFrontmatter: '', body: str };
-  }
-
-  return {
-    rawFrontmatter: str.slice(4, closeIndex),
-    body: str.slice(closeIndex + 5),
-  };
-}

package/src/client/js/utils/schema-utils.ts

@@ -1,295 +0,0 @@
-/*
- * Utilities for reading and resolving JSON Schema nodes.
- * Provides type resolution, path traversal, tab extraction, and
- * convenience accessors for common schema annotations.
- */
-
-import { toTitleCase } from './format';
-
-// A generic JSON Schema node represented as a plain object.
-export type SchemaNode = Record<string, unknown>;
-
-/**
- * Discriminated union describing the resolved type of a schema field. All variants carry an optional `nullable` flag set when the field was expressed as `anyOf: [<type>, { type: 'null' }]`.
- */
-export type FieldType =
-  | { kind: 'string'; nullable?: boolean }
-  | { kind: 'number'; nullable?: boolean }
-  | { kind: 'boolean'; nullable?: boolean }
-  | { kind: 'date'; nullable?: boolean }
-  | { kind: 'enum'; options: string[]; nullable?: boolean }
-  | { kind: 'array'; nullable?: boolean }
-  | { kind: 'object'; nullable?: boolean }
-  | { kind: 'unknown'; nullable?: boolean };
-
-/**
- * A path segment used to address nested values. Strings address object keys; numbers address array indices.
- */
-export type PathSegment = string | number;
-
-/*
-//////////////////////////////
-// resolveFieldType
-//////////////////////////////
-*/
-
-/**
- * Resolves a JSON Schema node to a `FieldType` discriminated union.
- * Handles anyOf nullable unwrapping, enum detection, and date-time format.
- * @param {SchemaNode} schema - The JSON Schema node to resolve
- * @return {FieldType} The resolved field type descriptor
- */
-export function resolveFieldType(schema: SchemaNode): FieldType {
-  // Unwrap nullable anyOf: [<innerType>, { type: 'null' }]
-  const anyOf = schema['anyOf'];
-  if (Array.isArray(anyOf)) {
-    const nonNull = (anyOf as SchemaNode[]).find((s) => s['type'] !== 'null');
-    if (nonNull) {
-      const inner = resolveFieldType(nonNull);
-      return { ...inner, nullable: true } as FieldType;
-    }
-  }
-
-  const type = schema['type'] as string | undefined;
-  const format = schema['format'] as string | undefined;
-  const enumValues = schema['enum'];
-
-  // date-time format takes precedence over plain string
-  if (type === 'string' && format === 'date-time') {
-    return { kind: 'date' };
-  }
-
-  // enum values present — treat as enum regardless of string subtype
-  if (type === 'string' && Array.isArray(enumValues)) {
-    return { kind: 'enum', options: enumValues as string[] };
-  }
-
-  if (type === 'string') return { kind: 'string' };
-  if (type === 'number' || type === 'integer') return { kind: 'number' };
-  if (type === 'boolean') return { kind: 'boolean' };
-  if (type === 'array') return { kind: 'array' };
-  if (type === 'object') return { kind: 'object' };
-
-  return { kind: 'unknown' };
-}
-
-/*
-//////////////////////////////
-// extractTabs
-//////////////////////////////
-*/
-
-/**
- * Scans an object schema's properties for `tab` arrays and returns a sorted, deduplicated list of all tab names found.
- * @param {SchemaNode} schema - A JSON Schema node with an optional `properties` map
- * @return {string[]} Sorted, deduplicated list of tab names
- */
-export function extractTabs(schema: SchemaNode): string[] {
-  const properties = getProperties(schema);
-  if (!properties) return [];
-
-  const tabs = new Set<string>();
-
-  for (const field of Object.values(properties)) {
-    const tab = field['tab'];
-    if (Array.isArray(tab)) {
-      for (const name of tab as string[]) {
-        tabs.add(name);
-      }
-    }
-  }
-
-  return Array.from(tabs).sort();
-}
-
-/*
-//////////////////////////////
-// createDefaultValue
-//////////////////////////////
-*/
-
-/**
- * Returns a type-appropriate default value for a given JSON Schema node.
- * Honors `schema.default` when present, returns null for nullable types, and recurses into object properties.
- * @param {SchemaNode} schema - The JSON Schema node to generate a default value for
- * @return {unknown} A default value appropriate for the schema type
- */
-export function createDefaultValue(schema: SchemaNode): unknown {
-  // Honour an explicit schema default first
-  if ('default' in schema) {
-    return schema['default'];
-  }
-
-  // Nullable anyOf — default to null
-  const anyOf = schema['anyOf'];
-  if (Array.isArray(anyOf)) {
-    const hasNull = (anyOf as SchemaNode[]).some((s) => s['type'] === 'null');
-    if (hasNull) return null;
-  }
-
-  const type = schema['type'] as string | undefined;
-
-  if (type === 'string') return '';
-  if (type === 'number' || type === 'integer') return 0;
-  if (type === 'boolean') return false;
-  if (type === 'array') return [];
-
-  if (type === 'object') {
-    const properties = getProperties(schema);
-    if (!properties) return {};
-    const result: Record<string, unknown> = {};
-    for (const [key, fieldSchema] of Object.entries(properties)) {
-      result[key] = createDefaultValue(fieldSchema);
-    }
-    return result;
-  }
-
-  return null;
-}
-
-/*
-//////////////////////////////
-// getByPath
-//////////////////////////////
-*/
-
-/**
- * Reads a deeply nested value from an object by following path segments.
- * Returns `undefined` if any segment along the path is missing.
- * @param {unknown} obj - The root object to traverse
- * @param {PathSegment[]} path - Ordered path segments (string keys or numeric indices)
- * @return {unknown} The value at the resolved path, or undefined if any segment is missing
- */
-export function getByPath(obj: unknown, path: PathSegment[]): unknown {
-  let current: unknown = obj;
-  for (const segment of path) {
-    if (current === null || current === undefined) return undefined;
-    current = (current as Record<string | number, unknown>)[segment];
-  }
-  return current;
-}
-
-/*
-//////////////////////////////
-// setByPath
-//////////////////////////////
-*/
-
-/**
- * Sets a deeply nested value in an object by following path segments, creating intermediate objects as needed.
- * @param {unknown} obj - The root object to mutate
- * @param {PathSegment[]} path - Ordered path segments (string keys or numeric indices)
- * @param {unknown} value - The value to assign at the resolved path
- * @return {void}
- */
-export function setByPath(
-  obj: unknown,
-  path: PathSegment[],
-  value: unknown,
-): void {
-  if (path.length === 0) return;
-
-  let current = obj as Record<string | number, unknown>;
-
-  // Walk down to the parent of the final segment, creating objects as needed
-  for (let i = 0; i < path.length - 1; i++) {
-    const segment = path[i];
-    if (current[segment] === null || current[segment] === undefined) {
-      current[segment] = {};
-    }
-    current = current[segment] as Record<string | number, unknown>;
-  }
-
-  current[path[path.length - 1]] = value;
-}
-
-/*
-//////////////////////////////
-// getFieldsForTab
-//////////////////////////////
-*/
-
-/**
- * Returns property names from a schema that belong to the given tab.
- * When `tab` is `null`, all property names are returned (no filtering — every field appears in the catch-all Metadata view).
- * @param {SchemaNode} schema - A JSON Schema node with an optional `properties` map
- * @param {string | null} tab - Tab name to filter by, or `null` to return all fields
- * @return {string[]} Array of property names belonging to the specified tab
- */
-export function getFieldsForTab(
-  schema: SchemaNode,
-  tab: string | null,
-): string[] {
-  const properties = getProperties(schema);
-  if (!properties) return [];
-
-  // Filter out $schema — it's a JSON Schema meta-property that Astro adds
-  // to every generated schema, not a user-editable frontmatter field
-  const keys = Object.keys(properties).filter((k) => k !== '$schema');
-
-  // null means "all fields" — no tab filtering applied
-  if (tab === null) {
-    return keys;
-  }
-
-  return keys.filter((key) => {
-    const fieldTab = properties[key]['tab'];
-    return Array.isArray(fieldTab) && (fieldTab as string[]).includes(tab);
-  });
-}
-
-/*
-//////////////////////////////
-// Schema property accessors
-//////////////////////////////
-*/
-
-/**
- * Extracts the `properties` map from a schema node, with a safe cast.
- * @param {SchemaNode} schema - A JSON Schema node
- * @return {Record<string, SchemaNode> | undefined} The properties map, or undefined if absent
- */
-export function getProperties(
-  schema: SchemaNode,
-): Record<string, SchemaNode> | undefined {
-  return schema['properties'] as Record<string, SchemaNode> | undefined;
-}
-
-/**
- * Extracts the `required` array from a schema node, returning an empty array if absent.
- * @param {SchemaNode} schema - A JSON Schema node
- * @return {string[]} Array of required property names
- */
-export function getRequiredFields(schema: SchemaNode): string[] {
-  return Array.isArray(schema['required'])
-    ? (schema['required'] as string[])
-    : [];
-}
-
-/**
- * Returns whether a schema node is marked as read-only.
- * @param {SchemaNode} schema - A JSON Schema node
- * @return {boolean} True if the schema has readOnly set to true
- */
-export function isReadOnly(schema: SchemaNode): boolean {
-  return !!(schema['readOnly'] as boolean | undefined);
-}
-
-/**
- * Returns whether a schema node was unwrapped from a nullable anyOf and flagged as nullable by SchemaField.
- * @param {SchemaNode} schema - A JSON Schema node (possibly annotated with _nullable)
- * @return {boolean} True if the schema has the _nullable annotation
- */
-export function isNullable(schema: SchemaNode): boolean {
-  return !!(schema['_nullable'] as boolean | undefined);
-}
-
-/**
- * Returns the display label for a schema field — the schema title if present, otherwise the property name converted to title case.
- * @param {SchemaNode} schema - A JSON Schema node
- * @param {string} name - The raw property name used as a fallback
- * @return {string} The human-readable label
- */
-export function getLabel(schema: SchemaNode, name: string): string {
-  return (schema['title'] as string | undefined) ?? toTitleCase(name);
-}

package/src/client/js/utils/sort.ts

@@ -1,84 +0,0 @@
-/*
- * Sorting utilities and types for admin sidebar content lists.
- * Handles sort mode persistence, date coercion, and comparator generation.
- */
-
-// Sidebar item displayed as a link in the admin navigation. Used by AdminSidebar for both collections and content lists.
-export type SidebarItem = {
-  label: string;
-  href: string;
-  subtitle?: string;
-  date?: Date;
-  // Draft-specific fields
-  draftId?: string;
-  isDraft?: boolean;
-  isOutdated?: boolean;
-};
-
-// Sort mode identifiers.
-export type SortMode = 'alpha' | 'date-asc' | 'date-desc';
-
-// Sort mode configuration: icon name and display label
-export const SORT_MODES: Record<SortMode, { icon: string; label: string }> = {
-  alpha: { icon: 'sort_by_alpha', label: 'Alphabetical' },
-  'date-asc': { icon: 'hourglass_arrow_down', label: 'Oldest first' },
-  'date-desc': { icon: 'hourglass_arrow_up', label: 'Newest first' },
-};
-
-// Fixed display order for sort options in the popover
-export const SORT_ORDER: SortMode[] = ['alpha', 'date-asc', 'date-desc'];
-
-/**
- * Reads the persisted sort mode from localStorage, defaulting to 'alpha' if absent or invalid.
- * @param {string} key - Collection name used to construct the storage key
- * @return {SortMode} The persisted sort mode, or 'alpha' if not set
- */
-export function readSortMode(key: string): SortMode {
-  const stored = localStorage.getItem(`cms-sort-${key}`);
-  if (stored === 'alpha' || stored === 'date-asc' || stored === 'date-desc') {
-    return stored;
-  }
-  return 'alpha';
-}
-
-/**
- * Persists the sort mode to localStorage.
- * @param {string} key - Collection name used to construct the storage key
- * @param {SortMode} mode - The sort mode to persist
- * @return {void}
- */
-export function writeSortMode(key: string, mode: SortMode): void {
-  localStorage.setItem(`cms-sort-${key}`, mode);
-}
-
-/**
- * Coerces a frontmatter published value (Date object or ISO string) into a Date for sorting. Returns undefined if the value is not a recognized date type.
- * @param {unknown} val - The published value from frontmatter
- * @return {Date | undefined} The resolved Date, or undefined
- */
-export function toSortDate(val: unknown): Date | undefined {
-  if (val instanceof Date) return val;
-  return typeof val === 'string' ? new Date(val) : undefined;
-}
-
-/**
- * Returns a comparator function for sorting SidebarItems by the given mode.
- * @param {SortMode} mode - The sort mode to use
- * @return {(a: SidebarItem, b: SidebarItem) => number} A comparator function suitable for Array.sort
- */
-export function createComparator(
-  mode: SortMode,
-): (a: SidebarItem, b: SidebarItem) => number {
-  return (a, b) => {
-    if (mode === 'date-asc' || mode === 'date-desc') {
-      // Items without a date sort to the top (e.g. new drafts without a published date)
-      if (!a.date && !b.date) return 0;
-      if (!a.date) return -1;
-      if (!b.date) return 1;
-      return mode === 'date-asc'
-        ? a.date.getTime() - b.date.getTime()
-        : b.date.getTime() - a.date.getTime();
-    }
-    return a.label.toLowerCase().localeCompare(b.label.toLowerCase());
-  };
-}

package/src/client/js/utils/stable-stringify.ts

@@ -1,27 +0,0 @@
-/*
- * Deterministic JSON serialization with sorted keys.
- * Prevents false-positive outdated detection when comparing snapshots.
- */
-
-/**
- * Recursively sorts object keys and serializes to JSON.
- * Produces deterministic output regardless of key insertion order.
- * @param {unknown} value - The value to serialize
- * @return {string} A JSON string with sorted keys at every nesting level
- */
-export function stableStringify(value: unknown): string {
-  return JSON.stringify(value, (_key, val) => {
-    if (val !== null && typeof val === 'object' && !Array.isArray(val)) {
-      return Object.keys(val as Record<string, unknown>)
-        .sort()
-        .reduce(
-          (sorted, k) => {
-            sorted[k] = (val as Record<string, unknown>)[k];
-            return sorted;
-          },
-          {} as Record<string, unknown>,
-        );
-    }
-    return val;
-  });
-}

package/src/types.ts

@@ -1,25 +0,0 @@
-/*
- * Configuration options for the nebula-cms Astro integration.
- */
-export interface NebulaCMSConfig {
-  /**
-   * URL prefix for the admin SPA.
-   * Accepts a relative or absolute path. Normalized automatically: leading `/`
-   * prepended if missing, consecutive slashes collapsed, trailing `/` stripped.
-   * After normalization, must contain only segments of letters, digits, hyphens,
-   * and underscores — or be `/` for root mount.
-   * @default '/admin'
-   */
-  basePath?: string;
-
-  /**
-   * URL prefix under which collection schema files are served.
-   * Accepts a relative or absolute path. Normalized automatically: leading `/`
-   * prepended if missing, consecutive slashes collapsed, trailing `/` stripped.
-   * After normalization, must contain only segments of letters, digits, hyphens,
-   * and underscores. Cannot be `/` (root) — collections require at least one
-   * path segment.
-   * @default '/collections'
-   */
-  collectionsPath?: string;
-}

package/svelte.config.js

@@ -1,4 +0,0 @@
-/** @type {import('@sveltejs/package').Config} */
-const config = {};
-
-export default config;

package/tests/astro/build.test.ts

@@ -1,63 +0,0 @@
-import { describe, it, expect, beforeAll, afterAll } from 'vitest';
-import { execFileSync } from 'node:child_process';
-import { resolve } from 'node:path';
-import { existsSync, readdirSync, readFileSync, rmSync } from 'node:fs';
-
-// Resolve playground path relative to this test file
-const playgroundDir = resolve(import.meta.dirname, '../../playground');
-const rootDir = resolve(playgroundDir, '..');
-
-describe('playground build integration', () => {
-  beforeAll(() => {
-    // Build root package so playground can resolve the nebula-cms integration.
-    // The prebuild script generates icons.css automatically before svelte-package runs.
-    execFileSync('pnpm', ['build'], { cwd: rootDir, stdio: 'pipe' });
-    // Generate collection schemas, then build the Astro site
-    execFileSync('pnpm', ['sync'], { cwd: playgroundDir, stdio: 'pipe' });
-    execFileSync('pnpm', ['build'], { cwd: playgroundDir, stdio: 'pipe' });
-  }, 60_000);
-
-  afterAll(() => {
-    const dist = resolve(playgroundDir, 'dist');
-    if (existsSync(dist)) rmSync(dist, { recursive: true });
-  });
-
-  it('copies schema files into dist/collections/ via astro:build:done', () => {
-    const distCollections = resolve(playgroundDir, 'dist/collections');
-    expect(existsSync(distCollections)).toBe(true);
-
-    const files = readdirSync(distCollections).filter((f) =>
-      f.endsWith('.schema.json'),
-    );
-    const names = files.map((f) => f.replace('.schema.json', ''));
-    expect(names).toContain('posts');
-    expect(names).toContain('authors');
-  });
-
-  it('generates .schema.json for all four collections', () => {
-    const collectionsDir = resolve(playgroundDir, '.astro/collections');
-    const files = readdirSync(collectionsDir).filter((f) =>
-      f.endsWith('.schema.json'),
-    );
-    const names = files.map((f) => f.replace('.schema.json', ''));
-
-    expect(names).toContain('posts');
-    expect(names).toContain('authors');
-    expect(names).toContain('products');
-    expect(names).toContain('courses');
-  });
-
-  it('bundles collection schema paths into the client JS', () => {
-    // Admin uses client:only="svelte", so collection data lives in the JS
-    // bundle via the virtual:collections module, not in the static HTML.
-    const assetDir = resolve(playgroundDir, 'dist/_astro');
-    const jsFiles = readdirSync(assetDir).filter((f) => f.endsWith('.js'));
-    const allJs = jsFiles
-      .map((f) => readFileSync(resolve(assetDir, f), 'utf-8'))
-      .join('\n');
-
-    for (const name of ['posts', 'authors', 'products', 'courses']) {
-      expect(allJs).toContain(`/collections/${name}.schema.json`);
-    }
-  });
-});