uncial-cms 0.0.0

package/dist/mount.js

@@ -0,0 +1,151 @@
+import 'uncial/web-components';
+// The editor's own chrome: tokens, shell layout and controls. The host page's
+// stylesheets are mirrored in below for prose parity, but they style the
+// document, not the toolbar and panels around it — nothing else loads these.
+import 'uncial/styles/chrome';
+import {} from './editor-controller.js';
+import { createEditorSession, defaultSessionProvider } from './editor-session.js';
+import { UNCIAL_CMS_RUNTIME_SENTINEL } from './sentinel.js';
+import { clearActiveForge } from './upload-context.js';
+function mirrorPageStylesIntoEditor(editor, explicit) {
+    if (explicit) {
+        editor.stylesheet = explicit.join(' ');
+        return;
+    }
+    const links = Array.from(document.querySelectorAll('link[rel="stylesheet"]'), (link) => link.href);
+    if (links.length > 0)
+        editor.stylesheet = links.join(' ');
+    // Dev servers inject <style> tags instead of links; clone those too.
+    for (const style of document.querySelectorAll('style')) {
+        editor.shadowRoot?.append(style.cloneNode(true));
+    }
+}
+export function mountEditorPage(target, opts) {
+    const { config, sourcePath } = opts;
+    const sessionProvider = opts.sessionProvider ?? defaultSessionProvider(config);
+    const blocks = opts.blocks;
+    const schema = opts.schema;
+    const root = document.createElement('div');
+    root.className = 'uncial-cms-editor-page';
+    root.dataset.uncialCmsRuntime = UNCIAL_CMS_RUNTIME_SENTINEL;
+    const chrome = document.createElement('div');
+    chrome.className = 'uncial-cms-chrome';
+    const manualSave = opts.autosaveMs === undefined;
+    const saveButton = document.createElement('button');
+    saveButton.type = 'button';
+    saveButton.textContent = 'Save';
+    saveButton.disabled = true;
+    const status = document.createElement('span');
+    status.className = 'uncial-cms-status';
+    status.setAttribute('role', 'status');
+    // Conflict recovery banner (ticket 05): blocking, offers download + reload,
+    // and must never lose the unsaved document.
+    const banner = document.createElement('div');
+    banner.className = 'uncial-cms-banner';
+    banner.setAttribute('role', 'alert');
+    banner.hidden = true;
+    const bannerText = document.createElement('p');
+    bannerText.className = 'uncial-cms-banner-message';
+    bannerText.textContent =
+        `This page changed on ${config.forge === 'github' ? config.branch : 'the local checkout'} since you loaded it. ` +
+            'Your unsaved changes are safe — choose how to proceed.';
+    const downloadButton = document.createElement('button');
+    downloadButton.type = 'button';
+    downloadButton.textContent = 'Download my version';
+    const reloadButton = document.createElement('button');
+    reloadButton.type = 'button';
+    reloadButton.textContent = 'Reload latest';
+    const dismissButton = document.createElement('button');
+    dismissButton.type = 'button';
+    dismissButton.textContent = 'Dismiss';
+    const bannerActions = document.createElement('div');
+    bannerActions.className = 'uncial-cms-banner-actions';
+    bannerActions.append(downloadButton, reloadButton, dismissButton);
+    banner.append(bannerText, bannerActions);
+    const editor = document.createElement('uncial-editor');
+    mirrorPageStylesIntoEditor(editor, opts.editorStylesheets);
+    if (opts.attributesPanel !== undefined)
+        editor.attributesPanel = opts.attributesPanel;
+    if (opts.presentation !== undefined)
+        editor.presentation = opts.presentation;
+    editor.blocks = blocks;
+    editor.schema = schema;
+    // Forward the schema's declared meta fields so the editor renders (and edits)
+    // them in its "Edit document metadata" panel. Without this a consumer whose
+    // schema declares metaFields gets no metadata UI.
+    editor.metaFields = schema.metaFields;
+    if (manualSave)
+        chrome.append(saveButton);
+    chrome.append(status);
+    root.append(chrome, banner, editor);
+    target.append(root);
+    let destroyed = false;
+    const ui = {
+        status(view) {
+            status.replaceChildren(document.createTextNode(view.text));
+            status.dataset.tone = view.tone;
+            if (view.href) {
+                status.append(document.createTextNode(' '));
+                const link = document.createElement('a');
+                link.href = view.href;
+                link.target = '_blank';
+                link.rel = 'noopener';
+                link.textContent = 'View commit';
+                status.append(link);
+            }
+        },
+        setDocument(doc) {
+            editor.json = doc;
+            // Seed the metadata panel from the loaded document's meta. Without this
+            // the panel shows schema defaults, so committing metadata would clobber
+            // the document's existing meta (e.g. reset title to its default).
+            editor.meta = doc.meta ?? {};
+        },
+        saveEnabled(enabled) {
+            saveButton.disabled = !enabled;
+        },
+        conflictVisible(visible) {
+            banner.hidden = !visible;
+        }
+    };
+    const controller = createEditorSession({
+        config,
+        sourcePath,
+        pagePath: opts.pagePath,
+        blocks,
+        schema,
+        sessionProvider,
+        autosaveMs: opts.autosaveMs,
+        ui,
+        isDestroyed: () => destroyed
+    });
+    const onChange = (event) => {
+        controller.documentChanged(event.detail);
+    };
+    editor.addEventListener('uncial-change', onChange);
+    if (manualSave)
+        saveButton.addEventListener('click', () => void controller.save());
+    downloadButton.addEventListener('click', () => controller.downloadMyVersion());
+    reloadButton.addEventListener('click', () => void controller.reloadLatest());
+    dismissButton.addEventListener('click', () => controller.dismissConflict());
+    void controller.load().catch((error) => {
+        if (destroyed)
+            return;
+        ui.status({
+            tone: 'error',
+            text: error instanceof Error ? error.message : 'Failed to load the document.'
+        });
+    });
+    return {
+        destroy() {
+            destroyed = true;
+            controller.stop();
+            clearActiveForge();
+            editor.removeEventListener('uncial-change', onChange);
+            root.remove();
+        },
+        isDirty() {
+            return controller.isDirty();
+        }
+    };
+}

package/dist/paths/index.d.ts

@@ -0,0 +1,17 @@
+/** Site-relative URL path (base already stripped) → repo-root-relative JSON path. */
+export declare function defaultMapPathToSource(sitePath: string, contentDir: string, locale?: string): string;
+/** Repo-root-relative JSON path → site-relative URL path (no leading/trailing slash). */
+export declare function defaultMapSourceToPath(source: string, contentDir: string, locale?: string): string;
+export type PagePathValidation = {
+    ok: true;
+    path: string;
+} | {
+    ok: false;
+    message: string;
+};
+/** Validate a user-typed page path; strips surrounding whitespace and slashes. */
+export declare function validatePagePath(input: string): PagePathValidation;
+/** `'about'` → `'#/about/'`; the site root (`''`) → `'#/'`. */
+export declare function hashForPagePath(path: string): string;
+/** `'#/about/'` → `'about'`; `'#/'` → `''` (site root); no hash → null (list view). */
+export declare function pagePathFromHash(hash: string): string | null;

package/dist/paths/index.js

@@ -0,0 +1,47 @@
+function normalizeSitePath(sitePath) {
+    return sitePath.replace(/^\/+/, '').replace(/\/+$/, '');
+}
+function contentDirForLocale(contentDir, locale) {
+    return locale === 'en' ? contentDir : `${contentDir}/${locale}`;
+}
+/** Site-relative URL path (base already stripped) → repo-root-relative JSON path. */
+export function defaultMapPathToSource(sitePath, contentDir, locale = 'en') {
+    const path = normalizeSitePath(sitePath);
+    return `${contentDirForLocale(contentDir, locale)}/${path === '' ? 'index' : path}.json`;
+}
+/** Repo-root-relative JSON path → site-relative URL path (no leading/trailing slash). */
+export function defaultMapSourceToPath(source, contentDir, locale = 'en') {
+    const prefix = `${contentDirForLocale(contentDir, locale)}/`;
+    if (!source.startsWith(prefix) || !source.endsWith('.json')) {
+        throw new Error(`Source "${source}" is not a JSON file under "${contentDir}".`);
+    }
+    const path = source.slice(prefix.length, -'.json'.length);
+    return path === 'index' ? '' : path;
+}
+const SEGMENT = /^[a-z0-9-]+$/;
+/** Validate a user-typed page path; strips surrounding whitespace and slashes. */
+export function validatePagePath(input) {
+    const path = input.trim().replace(/^\/+/, '').replace(/\/+$/, '');
+    if (path === '') {
+        return { ok: false, message: 'Enter a page path, e.g. team/new-page.' };
+    }
+    if (!path.split('/').every((segment) => SEGMENT.test(segment))) {
+        return {
+            ok: false,
+            message: 'Page paths must be lowercase segments of letters, digits, and hyphens separated by "/", e.g. team/new-page.'
+        };
+    }
+    return { ok: true, path };
+}
+/** `'about'` → `'#/about/'`; the site root (`''`) → `'#/'`. */
+export function hashForPagePath(path) {
+    return path === '' ? '#/' : `#/${path}/`;
+}
+/** `'#/about/'` → `'about'`; `'#/'` → `''` (site root); no hash → null (list view). */
+export function pagePathFromHash(hash) {
+    if (hash === '' || hash === '#')
+        return null;
+    if (!hash.startsWith('#/'))
+        return null;
+    return hash.slice(2).replace(/\/+$/, '');
+}

package/dist/sentinel.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Embedded verbatim in every bundle that includes the editor runtime (see
+ * mount.ts). The clean-pages build assertion greps content-page HTML and its
+ * JS chunks for this string to prove production pages ship zero CMS code.
+ */
+export declare const UNCIAL_CMS_RUNTIME_SENTINEL = "uncial-cms-runtime-sentinel-v1";

package/dist/sentinel.js

@@ -0,0 +1,6 @@
+/**
+ * Embedded verbatim in every bundle that includes the editor runtime (see
+ * mount.ts). The clean-pages build assertion greps content-page HTML and its
+ * JS chunks for this string to prove production pages ship zero CMS code.
+ */
+export const UNCIAL_CMS_RUNTIME_SENTINEL = 'uncial-cms-runtime-sentinel-v1';

package/dist/served-url.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Map a committed repo path to the URL the built site serves it from.
+ */
+import type { Site } from './define-site.js';
+/**
+ * Everything under the site's static directory is copied to the site root at
+ * build time, so a committed asset path becomes a served URL by dropping that
+ * prefix. `staticDir` is repo-root-relative, like `mediaDir`; a `mediaDir` that
+ * does not sit under it is not served by the copy, so the path is returned
+ * site-root-absolute unchanged.
+ *
+ * The result carries no base path: a stored `src` must stay correct at every
+ * `paths.base` the same content is built at, so the site prepends its base at
+ * render time.
+ */
+export declare function servedUrl(site: Site, repoPath: string, staticDir?: string): string;

package/dist/served-url.js

@@ -0,0 +1,19 @@
+/**
+ * Everything under the site's static directory is copied to the site root at
+ * build time, so a committed asset path becomes a served URL by dropping that
+ * prefix. `staticDir` is repo-root-relative, like `mediaDir`; a `mediaDir` that
+ * does not sit under it is not served by the copy, so the path is returned
+ * site-root-absolute unchanged.
+ *
+ * The result carries no base path: a stored `src` must stay correct at every
+ * `paths.base` the same content is built at, so the site prepends its base at
+ * render time.
+ */
+export function servedUrl(site, repoPath, staticDir = 'static') {
+    const prefix = `${staticDir.replace(/\/+$/, '')}/`;
+    const mediaDir = site.config.mediaDir;
+    if (mediaDir?.startsWith(prefix) && repoPath.startsWith(prefix)) {
+        return repoPath.slice(prefix.length - 1);
+    }
+    return `/${repoPath.replace(/^\/+/, '')}`;
+}

package/dist/session.d.ts

@@ -0,0 +1,4 @@
+import type { ForgeSession } from './types.js';
+export declare function readCachedSession(repo: string): ForgeSession | null;
+export declare function writeCachedSession(session: ForgeSession): void;
+export declare function clearCachedSession(repo: string): void;

package/dist/session.js

@@ -0,0 +1,30 @@
+function storageKey(repo) {
+    return `uncial-cms:session:${repo}`;
+}
+function storage() {
+    return typeof sessionStorage === 'undefined' ? null : sessionStorage;
+}
+export function readCachedSession(repo) {
+    const raw = storage()?.getItem(storageKey(repo));
+    if (!raw)
+        return null;
+    let session;
+    try {
+        session = JSON.parse(raw);
+    }
+    catch {
+        clearCachedSession(repo);
+        return null;
+    }
+    if (session.expiresAt !== null && session.expiresAt <= Date.now()) {
+        clearCachedSession(repo);
+        return null;
+    }
+    return session;
+}
+export function writeCachedSession(session) {
+    storage()?.setItem(storageKey(session.repo), JSON.stringify(session));
+}
+export function clearCachedSession(repo) {
+    storage()?.removeItem(storageKey(repo));
+}

package/dist/svelte/EditorPage.svelte

@@ -0,0 +1,178 @@
+<script lang="ts">
+	/**
+	 * The SvelteKit door onto an Editor variant: Uncial's `Editor` rendered in
+	 * the host's own tree and cascade, with the whole editing surface
+	 * `mountEditorPage` owns — status line, conflict banner, metadata seeding,
+	 * Save or autosave — around it.
+	 *
+	 * `mountEditorPage` builds a custom element with a shadow root, which is the
+	 * right shape for a host with no component model. It is the wrong shape for a
+	 * SvelteKit site whose Editor variant exists to show an author the measure,
+	 * face and ground a reader will see: no rule the site sets on `body` crosses
+	 * that boundary, so the site has to restate every one of them.
+	 */
+	import { onMount } from 'svelte';
+	import type { BlockRegistry, ContentDocument, ContentSchema } from 'uncial/core';
+	import type { Site } from '../define-site.js';
+	import type { EditorController, StatusView } from '../editor-controller.js';
+	import { UNCIAL_CMS_RUNTIME_SENTINEL } from '../sentinel.js';
+	import type { SessionProvider } from '../types.js';
+	import { clearActiveForge } from '../upload-context.js';
+
+	interface Props {
+		/** The site object from `defineSite`. */
+		site: Site;
+		/** Repo-root-relative JSON path, from the editor route's payload. */
+		sourcePath: string;
+		/** Site-relative page path, from the editor route's payload. */
+		pagePath: string;
+		blocks: BlockRegistry;
+		/** One schema for the site, or the schema this page path is written against. */
+		schema: ContentSchema | ((path: string) => ContentSchema);
+		/** Defaults to the provider the resolved forge implies. */
+		sessionProvider?: SessionProvider;
+		/** Forwarded to `Editor`; `'overlay'` keeps the document at the host's width. */
+		attributesPanel?: 'docked' | 'overlay' | 'off';
+		/** Forwarded to `Editor`; `'bare'` draws no surface of the editor's own. */
+		presentation?: 'card' | 'bare';
+	}
+
+	let {
+		site,
+		sourcePath,
+		pagePath,
+		blocks,
+		schema,
+		sessionProvider,
+		attributesPanel = 'overlay',
+		presentation = 'bare'
+	}: Props = $props();
+
+	const resolvedSchema = $derived(typeof schema === 'function' ? schema(pagePath) : schema);
+	// Autosave leaves nothing to press; a forge commit is never autosaved, so a
+	// Save button and autosave are exactly the two modes.
+	const manualSave = $derived(site.autosaveMs === undefined);
+	const branch = $derived(
+		site.config.forge === 'github' ? site.config.branch : 'the local checkout'
+	);
+
+	type EditorComponent = (typeof import('uncial/editor'))['Editor'];
+
+	let Editor = $state<EditorComponent | undefined>(undefined);
+	let doc = $state<ContentDocument | undefined>(undefined);
+	let meta = $state<Record<string, unknown>>({});
+	let status = $state<StatusView | undefined>(undefined);
+	let conflict = $state(false);
+	let saveEnabled = $state(false);
+	let controller: EditorController | undefined;
+	let root: HTMLDivElement;
+
+	onMount(() => {
+		// The editor stack hangs off dynamic imports behind a statically decidable
+		// condition, so a local-only production build has no reachable path to it
+		// and drops it rather than merely leaving it unrouted. Vite replaces both
+		// operands with literals at build time.
+		if (!import.meta.env.DEV && import.meta.env.UNCIAL_CMS_FORGE === 'none') return;
+
+		// Marked here rather than in the markup so that the gate above leaves the
+		// sentinel unreferenced in a local-only production build, and Rollup drops
+		// it with the rest of the editor stack.
+		root.dataset.uncialCmsRuntime = UNCIAL_CMS_RUNTIME_SENTINEL;
+
+		let cancelled = false;
+
+		void Promise.all([
+			import('uncial/editor'),
+			// The package's own session module, not the `uncial-cms/session`
+			// subpath: this file is inside the package.
+			import('../editor-session.js'),
+			// The editor's chrome — tokens, shell layout and controls. Loaded here
+			// so the host never has to know the component has a stylesheet.
+			import('uncial/styles/chrome')
+		]).then(([editor, session]) => {
+			if (cancelled) return;
+			Editor = editor.Editor;
+			controller = session.createEditorSession({
+				config: site.config,
+				sourcePath,
+				pagePath,
+				blocks,
+				schema: resolvedSchema,
+				sessionProvider,
+				autosaveMs: site.autosaveMs,
+				isDestroyed: () => cancelled,
+				ui: {
+					status: (view) => (status = view),
+					setDocument: (next) => {
+						doc = next;
+						// Seed the metadata panel from the loaded document. Without
+						// this it shows schema defaults, and committing metadata
+						// would clobber the document's own.
+						meta = next.meta ?? {};
+					},
+					saveEnabled: (enabled) => (saveEnabled = enabled),
+					conflictVisible: (visible) => (conflict = visible)
+				}
+			});
+			void controller.load().catch((error: unknown) => {
+				if (cancelled) return;
+				status = {
+					tone: 'error',
+					text: error instanceof Error ? error.message : 'Failed to load the document.'
+				};
+			});
+		});
+
+		return () => {
+			cancelled = true;
+			controller?.stop();
+			clearActiveForge();
+		};
+	});
+</script>
+
+<div class="uncial-cms-editor-page" bind:this={root}>
+	<div class="uncial-cms-chrome">
+		{#if manualSave}
+			<button type="button" disabled={!saveEnabled} onclick={() => void controller?.save()}>
+				Save
+			</button>
+		{/if}
+		{#if status}
+			<p class="uncial-cms-status" role="status" data-tone={status.tone}>
+				{status.text}{#if status.href}&nbsp;<a href={status.href} target="_blank" rel="noopener"
+						>View commit</a
+					>{/if}
+			</p>
+		{/if}
+	</div>
+
+	{#if conflict}
+		<div class="uncial-cms-banner" role="alert">
+			<p class="uncial-cms-banner-message">
+				This page changed on {branch} since you loaded it. Your unsaved changes are safe — choose how
+				to proceed.
+			</p>
+			<div class="uncial-cms-banner-actions">
+				<button type="button" onclick={() => controller?.downloadMyVersion()}>
+					Download my version
+				</button>
+				<button type="button" onclick={() => void controller?.reloadLatest()}>Reload latest</button>
+				<button type="button" onclick={() => controller?.dismissConflict()}>Dismiss</button>
+			</div>
+		</div>
+	{/if}
+
+	{#if Editor && doc}
+		<Editor
+			{blocks}
+			schema={resolvedSchema}
+			metaFields={resolvedSchema.metaFields}
+			bind:json={doc}
+			bind:meta
+			{attributesPanel}
+			{presentation}
+			onChange={(next) => controller?.documentChanged(next as ContentDocument)}
+		/>
+	{/if}
+</div>

package/dist/svelte/EditorPage.svelte.d.ts

@@ -0,0 +1,23 @@
+import type { BlockRegistry, ContentSchema } from 'uncial/core';
+import type { Site } from '../define-site.js';
+import type { SessionProvider } from '../types.js';
+interface Props {
+    /** The site object from `defineSite`. */
+    site: Site;
+    /** Repo-root-relative JSON path, from the editor route's payload. */
+    sourcePath: string;
+    /** Site-relative page path, from the editor route's payload. */
+    pagePath: string;
+    blocks: BlockRegistry;
+    /** One schema for the site, or the schema this page path is written against. */
+    schema: ContentSchema | ((path: string) => ContentSchema);
+    /** Defaults to the provider the resolved forge implies. */
+    sessionProvider?: SessionProvider;
+    /** Forwarded to `Editor`; `'overlay'` keeps the document at the host's width. */
+    attributesPanel?: 'docked' | 'overlay' | 'off';
+    /** Forwarded to `Editor`; `'bare'` draws no surface of the editor's own. */
+    presentation?: 'card' | 'bare';
+}
+declare const EditorPage: import("svelte").Component<Props, {}, "">;
+type EditorPage = ReturnType<typeof EditorPage>;
+export default EditorPage;

package/dist/svelte/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * `uncial-cms/svelte` — the SvelteKit door. `svelte` is a peer of this subpath
+ * only; the runtime root still imports no Svelte.
+ */
+export { default as EditorPage } from './EditorPage.svelte';

package/dist/svelte/index.js

@@ -0,0 +1,5 @@
+/**
+ * `uncial-cms/svelte` — the SvelteKit door. `svelte` is a peer of this subpath
+ * only; the runtime root still imports no Svelte.
+ */
+export { default as EditorPage } from './EditorPage.svelte';

package/dist/svelte/styles.d.ts

@@ -0,0 +1,4 @@
+// `uncial/styles/chrome` is a stylesheet, imported for its effect. Vite resolves
+// it; TypeScript needs telling it exists. Ships with the package so a consumer
+// type-checking this component resolves it too.
+declare module 'uncial/styles/chrome';

package/dist/sveltekit/index.d.ts

@@ -0,0 +1,68 @@
+import type { BlockRegistry, ContentDocument, ContentSchema } from 'uncial/core';
+import type { Site } from '../define-site.js';
+import type { UncialCmsSiteConfig } from '../types.js';
+export { defaultMapPathToSource, defaultMapSourceToPath } from '../paths/index.js';
+/** A content file as the factories see it: site-relative path, repo-root-relative source. */
+export interface ContentEntry {
+    path: string;
+    source: string;
+}
+interface HandlerOptionsBase {
+    blocks: BlockRegistry;
+    /** One schema for the whole site, or the schema this page path is written against. */
+    schema: ContentSchema | ((path: string) => ContentSchema);
+    /** Site-relative URL path → repo-root-relative JSON path. */
+    mapPathToSource?: (path: string) => string;
+    /** Keep a non-page file — site settings, a manifest — out of the routes. */
+    exclude?: (entry: ContentEntry) => boolean;
+}
+/** The site object from `defineSite`, or the resolved config plus its build-time FS path. */
+interface SiteSource {
+    site: Site;
+    config?: never;
+    localContentDir?: never;
+}
+interface ConfigSource {
+    site?: never;
+    config: UncialCmsSiteConfig;
+    /** FS path of the content dir at build time (differs from config.contentDir,
+     * which is repo-root-relative for the forge API). */
+    localContentDir: string;
+}
+export type ContentHandlerOptions = HandlerOptionsBase & (SiteSource | ConfigSource);
+export type IndexHandlerOptions = HandlerOptionsBase & (SiteSource | (Omit<ConfigSource, 'localContentDir'> & {
+    localContentDir?: string;
+}));
+interface RouteEntry {
+    path: string;
+}
+export declare function createContentHandlers(opts: ContentHandlerOptions): {
+    entries: () => RouteEntry[];
+    load: (event: {
+        params: {
+            path: string;
+        };
+    }) => Promise<{
+        document: ContentDocument;
+        meta: Record<string, unknown>;
+        path: string;
+    }>;
+};
+export declare function createEditorHandlers(opts: ContentHandlerOptions & {
+    devOnly?: boolean;
+}): {
+    entries: () => RouteEntry[];
+    load: (event: {
+        params: {
+            path: string;
+        };
+    }) => Promise<{
+        sourcePath: string;
+        pagePath: string;
+    }>;
+};
+export declare function createIndexHandlers(opts: IndexHandlerOptions): {
+    load: () => Promise<{
+        config: UncialCmsSiteConfig;
+    }>;
+};