vestrycms 0.0.0-stage → 0.2.0

package/dist/ui/api.d.ts

@@ -0,0 +1,83 @@
+import type { ClientConfig } from "../core/api.js";
+import type { PublicUser, Role } from "../core/roles.js";
+import type { AssetItem, EntryDetail, EntrySummary, SaveEntryInput } from "../core/service.js";
+export type { ClientConfig, AssetItem, EntryDetail, EntrySummary, SaveEntryInput, PublicUser, Role, };
+/** Fired on `window` when the API answers 401, so the app can return to sign-in. */
+export declare const UNAUTHORIZED_EVENT = "vestry:unauthorized";
+export declare class ApiError extends Error {
+    status: number;
+    code: string;
+    constructor(message: string, status: number, code: string);
+}
+export declare function createClient(basePath: string): {
+    prefix: string;
+    fileUrl: (path: string, sha?: string) => string;
+    config: () => Promise<ClientConfig>;
+    status: () => Promise<{
+        head: string;
+    }>;
+    listUsers: () => Promise<{
+        users: PublicUser[];
+    }>;
+    inviteUser: (input: {
+        email: string;
+        name?: string;
+        role: Role;
+    }) => Promise<{
+        user: PublicUser;
+        mailError?: string;
+    }>;
+    updateUser: (id: string, patch: {
+        name?: string;
+        role?: Role;
+    }) => Promise<{
+        user: PublicUser;
+    }>;
+    removeUser: (id: string) => Promise<{
+        ok: true;
+    }>;
+    resendInvite: (id: string) => Promise<{
+        user: PublicUser;
+    }>;
+    listEntries: (collection: string) => Promise<{
+        entries: EntrySummary[];
+        head: string;
+    }>;
+    getEntry: (collection: string, slug: string) => Promise<EntryDetail>;
+    createEntry: (collection: string, input: SaveEntryInput) => Promise<{
+        slug: string;
+        sha: string;
+        commit: string;
+        path: string;
+    }>;
+    updateEntry: (collection: string, slug: string, input: SaveEntryInput) => Promise<{
+        slug: string;
+        sha: string;
+        commit: string;
+        path: string;
+    }>;
+    deleteEntry: (collection: string, slug: string) => Promise<{
+        commit: string;
+    }>;
+    getSingleton: (key: string) => Promise<EntryDetail>;
+    saveSingleton: (key: string, input: SaveEntryInput) => Promise<{
+        sha: string;
+        commit: string;
+    }>;
+    listAssets: (container: string, dir?: string) => Promise<{
+        items: AssetItem[];
+        folders: string[];
+    }>;
+    uploadAssets: (container: string, dir: string, files: {
+        name: string;
+        base64: string;
+    }[]) => Promise<{
+        commit: string;
+        paths: string[];
+    }>;
+    deleteAsset: (container: string, path: string) => Promise<{
+        commit: string;
+    }>;
+};
+export type ApiClient = ReturnType<typeof createClient>;
+export declare function fileToBase64(file: File): Promise<string>;

package/dist/ui/api.js

@@ -0,0 +1,97 @@
+/** Fired on `window` when the API answers 401, so the app can return to sign-in. */
+export const UNAUTHORIZED_EVENT = "vestry:unauthorized";
+export class ApiError extends Error {
+    status;
+    code;
+    constructor(message, status, code) {
+        super(message);
+        this.status = status;
+        this.code = code;
+        this.name = "ApiError";
+    }
+}
+export function createClient(basePath) {
+    const prefix = `${basePath.replace(/\/$/, "")}/api`;
+    async function request(path, init = {}) {
+        const res = await fetch(`${prefix}${path}`, {
+            ...init,
+            headers: {
+                Accept: "application/json",
+                ...(init.body ? { "Content-Type": "application/json" } : {}),
+                ...(init.headers ?? {}),
+            },
+            credentials: "same-origin",
+        });
+        if (res.status === 204)
+            return undefined;
+        let data = null;
+        const text = await res.text();
+        try {
+            data = text ? JSON.parse(text) : null;
+        }
+        catch {
+            data = null;
+        }
+        if (!res.ok) {
+            const err = data?.error;
+            if (res.status === 401 && err?.code === "unauthorized") {
+                window.dispatchEvent(new Event(UNAUTHORIZED_EVENT));
+            }
+            throw new ApiError(err?.message ?? `Request failed (${res.status})`, res.status, err?.code ?? "error");
+        }
+        return data;
+    }
+    const enc = (s) => s.split("/").map(encodeURIComponent).join("/");
+    return {
+        prefix,
+        fileUrl: (path, sha) => `${prefix}/file?path=${encodeURIComponent(path)}${sha ? `&v=${sha}` : ""}`,
+        config: () => request("/config"),
+        status: () => request("/status"),
+        listUsers: () => request("/users"),
+        inviteUser: (input) => request("/users", {
+            method: "POST",
+            body: JSON.stringify(input),
+        }),
+        updateUser: (id, patch) => request(`/users/${enc(id)}`, {
+            method: "PATCH",
+            body: JSON.stringify(patch),
+        }),
+        removeUser: (id) => request(`/users/${enc(id)}`, { method: "DELETE" }),
+        resendInvite: (id) => request(`/users/${enc(id)}/invite`, {
+            method: "POST",
+        }),
+        listEntries: (collection) => request(`/collections/${enc(collection)}`),
+        getEntry: (collection, slug) => request(`/collections/${enc(collection)}/entries/${enc(slug)}`),
+        createEntry: (collection, input) => request(`/collections/${enc(collection)}/entries`, {
+            method: "POST",
+            body: JSON.stringify(input),
+        }),
+        updateEntry: (collection, slug, input) => request(`/collections/${enc(collection)}/entries/${enc(slug)}`, { method: "PUT", body: JSON.stringify(input) }),
+        deleteEntry: (collection, slug) => request(`/collections/${enc(collection)}/entries/${enc(slug)}`, { method: "DELETE" }),
+        getSingleton: (key) => request(`/singletons/${enc(key)}`),
+        saveSingleton: (key, input) => request(`/singletons/${enc(key)}`, {
+            method: "PUT",
+            body: JSON.stringify(input),
+        }),
+        listAssets: (container, dir = "") => request(`/assets/${enc(container)}?dir=${encodeURIComponent(dir)}`),
+        uploadAssets: (container, dir, files) => request(`/assets/${enc(container)}`, {
+            method: "POST",
+            body: JSON.stringify({ dir, files }),
+        }),
+        deleteAsset: (container, path) => request(`/assets/${enc(container)}`, {
+            method: "DELETE",
+            body: JSON.stringify({ path }),
+        }),
+    };
+}
+export function fileToBase64(file) {
+    return new Promise((resolve, reject) => {
+        const reader = new FileReader();
+        reader.onload = () => {
+            const result = String(reader.result);
+            resolve(result.slice(result.indexOf(",") + 1));
+        };
+        reader.onerror = () => reject(reader.error);
+        reader.readAsDataURL(file);
+    });
+}

package/dist/ui/auth-client.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Better Auth's browser client, mounted where the API serves `auth/*`. Only
+ * sign-in and sign-out go through it; users are managed via Vestry's API.
+ */
+export declare function createVestryAuthClient(basePath: string): import("better-auth/client").AuthClient<{
+    baseURL: string;
+    plugins: {
+        id: "email-otp";
+        version: string;
+        $InferServerPlugin: ReturnType<typeof import("better-auth/plugins").emailOTP>;
+        atomListeners: {
+            matcher: (path: string) => path is "/email-otp/verify-email" | "/sign-in/email-otp" | "/email-otp/request-email-change";
+            signal: "$sessionSignal";
+        }[];
+        $ERROR_CODES: {
+            OTP_EXPIRED: import("better-auth").RawError<"OTP_EXPIRED">;
+            INVALID_OTP: import("better-auth").RawError<"INVALID_OTP">;
+            TOO_MANY_ATTEMPTS: import("better-auth").RawError<"TOO_MANY_ATTEMPTS">;
+        };
+    }[];
+}>;
+export type VestryAuthClient = ReturnType<typeof createVestryAuthClient>;
+/** Turns a Better Auth client error into something to show the user. */
+export declare function authErrorMessage(error: {
+    code?: string;
+    message?: string;
+} | null | undefined, fallback?: string): string;

package/dist/ui/auth-client.js

@@ -0,0 +1,29 @@
+import { createAuthClient } from "better-auth/client";
+import { emailOTPClient } from "better-auth/client/plugins";
+/**
+ * Better Auth's browser client, mounted where the API serves `auth/*`. Only
+ * sign-in and sign-out go through it; users are managed via Vestry's API.
+ */
+export function createVestryAuthClient(basePath) {
+    return createAuthClient({
+        baseURL: `${window.location.origin}${basePath.replace(/\/$/, "")}/api/auth`,
+        plugins: [emailOTPClient()],
+    });
+}
+/** Turns a Better Auth client error into something to show the user. */
+export function authErrorMessage(error, fallback = "Something went wrong. Please try again.") {
+    switch (error?.code) {
+        case "INVALID_OTP":
+            return "That code isn't right. Check the email and try again.";
+        case "OTP_EXPIRED":
+            return "That code has expired. Request a new one.";
+        case "TOO_MANY_ATTEMPTS":
+            return "Too many incorrect codes. Request a new one.";
+        case "INVALID_EMAIL":
+            return "Enter a valid email address.";
+        default:
+            if (error?.message?.toLowerCase().includes("too many requests"))
+                return "Too many sign-in attempts. Please wait a minute and try again.";
+            return error?.message || fallback;
+    }
+}

package/dist/ui/components/AssetPicker.d.ts

@@ -0,0 +1,27 @@
+import type { AssetFieldOptions } from "../../config/types.js";
+/**
+ * Browse (and upload to) a repository directory and pick a file. Used by
+ * image/file fields and the editor's image button.
+ */
+export declare function AssetPicker({ directory, accept, allowUpload, onPick, onClose, title, 
+/** Instead of committing immediately, hand uploads back to the caller (saved with the entry). */
+deferUploads, }: {
+    directory: string;
+    accept?: string[];
+    allowUpload?: boolean;
+    onPick: (path: string, pending?: {
+        path: string;
+        base64: string;
+        previewUrl: string;
+    }) => void;
+    onClose: () => void;
+    title?: string;
+    deferUploads?: boolean;
+}): import("react").JSX.Element;
+export declare function safeName(name: string): string;
+export type PendingUpload = {
+    path: string;
+    base64: string;
+    previewUrl: string;
+};
+export type AssetOptions = AssetFieldOptions;

package/dist/ui/components/AssetPicker.js

@@ -0,0 +1,97 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { useQuery, useQueryClient } from "@tanstack/react-query";
+import { ChevronRight, File as FileIcon, Folder, Upload } from "lucide-react";
+import { useRef, useState } from "react";
+import { fileToBase64 } from "../api.js";
+import { useVestry } from "../context.js";
+import { cx, formatBytes } from "../lib/utils.js";
+import { Alert, Button, Loading, Modal, Spinner, useToast } from "./ui.js";
+/**
+ * Browse (and upload to) a repository directory and pick a file. Used by
+ * image/file fields and the editor's image button.
+ */
+export function AssetPicker({ directory, accept, allowUpload = true, onPick, onClose, title = "Choose a file", 
+/** Instead of committing immediately, hand uploads back to the caller (saved with the entry). */
+deferUploads, }) {
+    const { api, config } = useVestry();
+    const toast = useToast();
+    const qc = useQueryClient();
+    const [subdir, setSubdir] = useState("");
+    const [selected, setSelected] = useState(null);
+    const [uploading, setUploading] = useState(false);
+    const [over, setOver] = useState(false);
+    const fileInput = useRef(null);
+    // Find a configured container whose directory contains this one so the
+    // API authorises the listing; fall back to an ad-hoc listing by directory.
+    const containerKey = Object.entries(config.assets ?? {}).find(([, c]) => directory === c.directory || directory.startsWith(`${c.directory}/`))?.[0] ?? null;
+    const containerDir = containerKey
+        ? config.assets[containerKey].directory
+        : directory;
+    const baseSub = directory.slice(containerDir.length).replace(/^\//, "");
+    const dir = [baseSub, subdir].filter(Boolean).join("/");
+    const query = useQuery({
+        queryKey: ["assets", containerKey ?? directory, dir],
+        queryFn: () => api.listAssets(containerKey ?? "", dir),
+        enabled: containerKey !== null,
+    });
+    async function upload(files) {
+        const list = Array.from(files).filter((f) => !accept || accept.includes(f.name.split(".").pop().toLowerCase()));
+        if (!list.length) {
+            toast("error", "That file type isn't accepted here.");
+            return;
+        }
+        setUploading(true);
+        try {
+            if (deferUploads) {
+                const f = list[0];
+                const base64 = await fileToBase64(f);
+                const name = safeName(f.name);
+                const path = `${[containerDir, dir].filter(Boolean).join("/")}/${name}`;
+                onPick(path, { path, base64, previewUrl: URL.createObjectURL(f) });
+                return;
+            }
+            const payload = await Promise.all(list.map(async (f) => ({
+                name: f.name,
+                base64: await fileToBase64(f),
+            })));
+            const res = await api.uploadAssets(containerKey, dir, payload);
+            await qc.invalidateQueries({
+                queryKey: ["assets", containerKey ?? directory],
+            });
+            toast("success", `Uploaded ${res.paths.length} file${res.paths.length === 1 ? "" : "s"}`);
+            if (res.paths.length === 1) {
+                onPick(res.paths[0]);
+            }
+        }
+        catch (e) {
+            toast("error", e.message);
+        }
+        finally {
+            setUploading(false);
+        }
+    }
+    const crumbs = subdir ? subdir.split("/") : [];
+    return (_jsxs(Modal, { title: title, onClose: onClose, wide: true, footer: _jsxs(_Fragment, { children: [_jsx(Button, { onClick: onClose, children: "Cancel" }), _jsx(Button, { variant: "primary", disabled: !selected, onClick: () => selected && onPick(selected), children: "Choose" })] }), children: [!containerKey && (_jsxs(Alert, { kind: "warning", children: ["No asset container covers ", _jsx("code", { children: directory }), ". Add one under", " ", _jsx("code", { children: "assets" }), " in the Vestry config to browse it."] })), containerKey && (_jsxs(_Fragment, { children: [_jsxs("div", { className: "v-row", style: { marginBottom: 14 }, children: [_jsxs("div", { className: "v-breadcrumbs", children: [_jsx("button", { type: "button", onClick: () => setSubdir(""), children: directory }), crumbs.map((c, i) => (_jsxs("span", { className: "v-row", style: { gap: 6 }, children: [_jsx(ChevronRight, { size: 14 }), _jsx("button", { type: "button", onClick: () => setSubdir(crumbs.slice(0, i + 1).join("/")), children: c })] }, i)))] }), _jsx("div", { className: "v-grow" }), allowUpload && (_jsxs(_Fragment, { children: [_jsx("input", { ref: fileInput, type: "file", hidden: true, multiple: !deferUploads, accept: accept?.map((a) => `.${a}`).join(","), onChange: (e) => e.target.files && upload(e.target.files) }), _jsxs(Button, { size: "sm", onClick: () => fileInput.current?.click(), disabled: uploading, children: [uploading ? _jsx(Spinner, {}) : _jsx(Upload, {}), " Upload"] })] }))] }), allowUpload && (_jsxs("div", { className: cx("v-dropzone", over && "is-over"), onDragOver: (e) => {
+                            e.preventDefault();
+                            setOver(true);
+                        }, onDragLeave: () => setOver(false), onDrop: (e) => {
+                            e.preventDefault();
+                            setOver(false);
+                            if (e.dataTransfer.files.length)
+                                upload(e.dataTransfer.files);
+                        }, children: ["Drop files here to upload", accept ? ` (${accept.join(", ")})` : ""] })), query.isLoading && _jsx(Loading, {}), query.error && (_jsx(Alert, { kind: "error", children: query.error.message })), query.data && (_jsxs(_Fragment, { children: [query.data.folders.length > 0 && (_jsx("div", { className: "v-asset-grid", style: { marginBottom: 14 }, children: query.data.folders.map((f) => (_jsxs("button", { type: "button", className: "v-folder", onClick: () => setSubdir([subdir, f].filter(Boolean).join("/")), children: [_jsx(Folder, {}), " ", f] }, f))) })), _jsx("div", { className: "v-asset-grid", children: query.data.items
+                                    .filter((i) => !accept || accept.includes(i.ext))
+                                    .map((item) => (_jsxs("button", { type: "button", className: cx("v-asset", selected === item.path && "is-selected"), onClick: () => setSelected(item.path), onDoubleClick: () => onPick(item.path), children: [_jsx("div", { className: "v-asset__preview", children: item.kind === "image" ? (_jsx("img", { src: api.fileUrl(item.path, item.sha), alt: "", loading: "lazy" })) : (_jsx(FileIcon, {})) }), _jsx("div", { className: "v-asset__name", title: item.name, children: item.name }), _jsx("div", { className: "v-asset__meta", children: formatBytes(item.size) })] }, item.path))) }), query.data.items.length === 0 &&
+                                query.data.folders.length === 0 && (_jsx("p", { className: "v-muted", style: { textAlign: "center", padding: 24 }, children: "This folder is empty." }))] }))] }))] }));
+}
+export function safeName(name) {
+    const i = name.lastIndexOf(".");
+    const ext = i === -1 ? "" : name.slice(i + 1).toLowerCase();
+    const stem = (i === -1 ? name : name.slice(0, i))
+        .normalize("NFKD")
+        .replace(/[̀-ͯ]/g, "")
+        .replace(/[^A-Za-z0-9._-]+/g, "-")
+        .replace(/^-+|-+$/g, "")
+        .toLowerCase();
+    return ext ? `${stem || "file"}.${ext}` : stem || "file";
+}

package/dist/ui/components/Icon.d.ts

@@ -0,0 +1,11 @@
+import { type LucideProps } from "lucide-react";
+type IconComponent = React.ComponentType<LucideProps>;
+/**
+ * Icons available by name in config (`icon: "book-open"`). A curated set
+ * keeps the control panel bundle small; unknown names fall back to a file.
+ */
+export declare const ICONS: Record<string, IconComponent>;
+export declare function Icon({ name, ...props }: {
+    name?: string;
+} & LucideProps): import("react").JSX.Element;
+export {};

package/dist/ui/components/Icon.js

@@ -0,0 +1,46 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { AlignLeft, AppWindow, BookOpen, Box, Clapperboard, Columns2, File, FileText, Files, Folder, GalleryHorizontal, Heading, Image, Images, LayoutGrid, Link, List, ListOrdered, Mail, Map, MapPin, Menu, MousePointerClick, Newspaper, Palette, Quote, Rows3, ScrollText, Settings2, Sparkles, Table, Tag, Users, Video, } from "lucide-react";
+/**
+ * Icons available by name in config (`icon: "book-open"`). A curated set
+ * keeps the control panel bundle small; unknown names fall back to a file.
+ */
+export const ICONS = {
+    "align-left": AlignLeft,
+    "app-window": AppWindow,
+    "book-open": BookOpen,
+    box: Box,
+    clapperboard: Clapperboard,
+    "columns-2": Columns2,
+    file: File,
+    "file-text": FileText,
+    files: Files,
+    folder: Folder,
+    "gallery-horizontal": GalleryHorizontal,
+    heading: Heading,
+    image: Image,
+    images: Images,
+    "layout-grid": LayoutGrid,
+    link: Link,
+    list: List,
+    "list-ordered": ListOrdered,
+    mail: Mail,
+    map: Map,
+    "map-pin": MapPin,
+    menu: Menu,
+    "mouse-pointer-click": MousePointerClick,
+    newspaper: Newspaper,
+    palette: Palette,
+    quote: Quote,
+    "rows-3": Rows3,
+    "scroll-text": ScrollText,
+    "settings-2": Settings2,
+    sparkles: Sparkles,
+    table: Table,
+    tag: Tag,
+    users: Users,
+    video: Video,
+};
+export function Icon({ name, ...props }) {
+    const Cmp = (name && ICONS[name]) || File;
+    return _jsx(Cmp, { strokeWidth: 1.9, ...props });
+}

package/dist/ui/components/Layout.d.ts

@@ -0,0 +1,15 @@
+import { type ReactNode } from "react";
+export interface Crumb {
+    label: string;
+    to?: string;
+}
+export declare function Shell({ children }: {
+    children: ReactNode;
+}): import("react").JSX.Element;
+export declare function TopBar({ title, crumbs, actions, status, }: {
+    title: ReactNode;
+    crumbs?: Crumb[];
+    actions?: ReactNode;
+    /** Shows a status dot before the title. */
+    status?: "published" | "draft" | null;
+}): import("react").JSX.Element;

package/dist/ui/components/Layout.js

@@ -0,0 +1,87 @@
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import { ExternalLink, GitBranch, LayoutDashboard, LogOut, Users, } from "lucide-react";
+import { createContext, useContext, useEffect, useState, } from "react";
+import { Link, NavLink, useNavigate } from "react-router";
+import { useVestry } from "../context.js";
+import { Icon } from "./Icon.js";
+import { Menu } from "./ui.js";
+import { initials } from "../lib/utils.js";
+/** Lets pages publish their breadcrumb trail into the dark top bar. */
+const CrumbsContext = createContext(() => { });
+export function Shell({ children }) {
+    const { client, config, name, api, authClient, refresh } = useVestry();
+    const navigate = useNavigate();
+    const [crumbs, setCrumbs] = useState([]);
+    const collections = Object.entries(config.collections ?? {});
+    const singletons = Object.entries(config.singletons ?? {});
+    const assets = Object.entries(config.assets ?? {});
+    const groups = config.navigation ??
+        [
+            collections.length && {
+                label: "Collections",
+                items: collections.map(([k]) => `collections.${k}`),
+            },
+            singletons.length && {
+                label: "Globals",
+                items: singletons.map(([k]) => `singletons.${k}`),
+            },
+            assets.length && {
+                label: "Assets",
+                items: assets.map(([k]) => `assets.${k}`),
+            },
+        ].filter(Boolean);
+    const itemFor = (ref) => {
+        const [kind, key] = ref.split(".");
+        if (kind === "collections" && config.collections?.[key]) {
+            return {
+                to: `/collections/${key}`,
+                label: config.collections[key].label,
+                icon: config.collections[key].icon ?? "files",
+            };
+        }
+        if (kind === "singletons" && config.singletons?.[key]) {
+            return {
+                to: `/singletons/${key}`,
+                label: config.singletons[key].label,
+                icon: config.singletons[key].icon ?? "settings-2",
+            };
+        }
+        if (kind === "assets" && config.assets?.[key]) {
+            return {
+                to: `/assets/${key}`,
+                label: config.assets[key].label,
+                icon: config.assets[key].icon ?? "image",
+            };
+        }
+        return null;
+    };
+    return (_jsxs("div", { className: "v-app", children: [_jsxs("header", { className: "v-chrome", children: [_jsx(Link, { to: "/", className: "v-chrome__brand", title: name, children: config.logo ? (_jsx("img", { className: "v-chrome__logo", src: /^https?:\/\//.test(config.logo)
+                                ? config.logo
+                                : api.fileUrl(config.logo), alt: name })) : (_jsxs(_Fragment, { children: [_jsx("span", { className: "v-chrome__mark", children: "V" }), _jsx("span", { className: "v-chrome__name", children: name })] })) }), crumbs.map((c, i) => (_jsxs("span", { className: "v-chrome__crumb", children: [_jsx("span", { className: "v-chrome__sep", children: "/" }), c.to ? _jsx(Link, { to: c.to, children: c.label }) : _jsx("span", { children: c.label })] }, i))), _jsx("div", { className: "v-chrome__spacer" }), client.source.url ? (_jsxs("a", { className: "v-chrome__chip", href: client.source.url, target: "_blank", rel: "noreferrer", title: client.source.label, children: [_jsx(GitBranch, {}), _jsx("span", { children: client.source.branch ?? client.source.label })] })) : (_jsxs("span", { className: "v-chrome__chip", title: client.source.label, children: [_jsx(GitBranch, {}), _jsx("span", { children: client.mode === "local" ? "Local files" : client.source.label })] })), config.siteUrl && (_jsxs("a", { className: "v-chrome__chip", href: config.siteUrl, target: "_blank", rel: "noreferrer", title: "Open the site", children: [_jsx(ExternalLink, {}), _jsx("span", { children: "View site" })] })), client.user && (_jsx(Menu, { align: "right", trigger: ({ toggle }) => (_jsx("button", { type: "button", className: "v-chrome__avatar", onClick: toggle, title: client.user.name, children: initials(client.user.name || client.user.email || "?") })), children: (close) => (_jsxs(_Fragment, { children: [_jsxs("div", { className: "v-menu__heading", children: [client.user.name, client.user.email && (_jsx("span", { className: "v-menu__sub", children: client.user.email }))] }), _jsxs("div", { className: "v-menu__item v-menu__item--static", children: [_jsx(GitBranch, {}), _jsx("span", { children: client.mode === "local"
+                                                ? "Editing local files"
+                                                : client.source.label })] }), client.auth && (_jsxs("button", { className: "v-menu__item", onClick: async () => {
+                                        close();
+                                        await authClient.signOut();
+                                        await refresh();
+                                        navigate("/login");
+                                    }, children: [_jsx(LogOut, {}), _jsx("span", { children: "Sign out" })] }))] })) }))] }), _jsxs("div", { className: "v-shell", children: [_jsx("aside", { className: "v-sidebar", children: _jsxs("nav", { className: "v-nav", children: [_jsx("div", { className: "v-nav__group", children: _jsxs(NavLink, { to: "/", end: true, className: ({ isActive }) => `v-nav__link${isActive ? " is-active" : ""}`, children: [_jsx(LayoutDashboard, {}), " Dashboard"] }) }), groups.map((g) => (_jsxs("div", { className: "v-nav__group", children: [_jsx("h3", { className: "v-nav__heading", children: g.label }), g.items.map((ref) => {
+                                            const item = itemFor(ref);
+                                            if (!item)
+                                                return null;
+                                            return (_jsxs(NavLink, { to: item.to, className: ({ isActive }) => `v-nav__link${isActive ? " is-active" : ""}`, children: [_jsx(Icon, { name: item.icon }), " ", item.label] }, ref));
+                                        })] }, g.label))), client.auth && client.user?.role === "admin" && (_jsxs("div", { className: "v-nav__group", children: [_jsx("h3", { className: "v-nav__heading", children: "System" }), _jsxs(NavLink, { to: "/users", className: ({ isActive }) => `v-nav__link${isActive ? " is-active" : ""}`, children: [_jsx(Users, {}), " Users"] })] }))] }) }), _jsx("div", { className: "v-main", children: _jsx(CrumbsContext.Provider, { value: setCrumbs, children: children }) })] })] }));
+}
+export function TopBar({ title, crumbs, actions, status, }) {
+    const setCrumbs = useContext(CrumbsContext);
+    const key = JSON.stringify(crumbs ?? []);
+    useEffect(() => {
+        setCrumbs(crumbs ?? []);
+        return () => setCrumbs([]);
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [key, setCrumbs]);
+    return (_jsxs("header", { className: "v-topbar", children: [_jsxs("h1", { className: "v-topbar__title", children: [status && (_jsx("span", { className: `v-status-dot v-status-dot--${status}`, title: status === "published" ? "Published" : "Draft" })), _jsx("span", { style: {
+                            overflow: "hidden",
+                            textOverflow: "ellipsis",
+                            whiteSpace: "nowrap",
+                        }, children: title })] }), actions && _jsx("div", { className: "v-topbar__actions", children: actions })] }));
+}

package/dist/ui/components/editor/EditorContext.d.ts

@@ -0,0 +1,15 @@
+import type { ComponentConfig } from "../../../config/types.js";
+export interface EditorEnv {
+    /** Components that may be inserted, keyed by name. */
+    components: Record<string, ComponentConfig>;
+    /** Resolve an image/file reference in the document to a repository path. */
+    toRepoPath: (src: string) => string | null;
+    /** Repository path → reference to write into the document. */
+    toDocPath: (repoPath: string) => string;
+    /** Image directory for uploads from the body editor. */
+    imageDirectory?: string;
+    /** Resolve a document image src to a URL the browser can display. */
+    resolveImage?: (src: string) => string;
+}
+export declare const EditorEnvContext: import("react").Context<EditorEnv>;
+export declare function useEditorEnv(): EditorEnv;

package/dist/ui/components/editor/EditorContext.js

@@ -0,0 +1,9 @@
+import { createContext, useContext } from "react";
+export const EditorEnvContext = createContext({
+    components: {},
+    toRepoPath: () => null,
+    toDocPath: (p) => p,
+});
+export function useEditorEnv() {
+    return useContext(EditorEnvContext);
+}

package/dist/ui/components/editor/NodeViews.d.ts

@@ -0,0 +1,4 @@
+import { type ReactNodeViewProps } from "@tiptap/react";
+export declare function ComponentNodeView({ node, updateAttributes, deleteNode, selected, }: ReactNodeViewProps): import("react").JSX.Element;
+export declare function InlineComponentNodeView({ node, updateAttributes, deleteNode, }: ReactNodeViewProps): import("react").JSX.Element;
+export declare function RawBlockNodeView({ node, updateAttributes, deleteNode, selected, }: ReactNodeViewProps): import("react").JSX.Element;