smoodly 0.0.6 → 0.0.8

package/dist/admin/ops.d.ts

@@ -1,6 +1,6 @@
 import type { PageRecord } from "../store.ts";
 import type { PageTree } from "../render.tsx";
-import type { EntryRecord } from "../entry-store.ts";
+import type { EntryRecord, EntryUsage } from "../entry-store.ts";
 import type { FieldError } from "./validate.ts";
 export type OpError = {
     ok: false;
@@ -14,7 +14,9 @@ export type OpResult<T> = {
 } | OpError;
 export type PageCreateInput = {
     parentId: string | null;
-    /** The default-locale segment. */
+    /** The one locale the page is created in; others are added with addLocale. */
+    locale: string;
+    /** The segment in that locale. */
     slug: string;
     /** Defaults to the slug. */
     title?: string;
@@ -22,24 +24,63 @@ export type PageCreateInput = {
     template: string | null;
 };
 export type PageGetResult = {
+    /** The node with ALL its locale rows — the switcher lists them. */
     record: PageRecord;
-    /** null for a folder. */
+    /** The locale this result was loaded for. */
+    locale: string;
+    /** That locale's draft tree; null for a folder, and null when the page has no row in `locale`. */
     draft: PageTree | null;
-    /** locale → locale-relative CMS path (the `paths` index). */
+    /** locale → locale-relative CMS path (the `paths` index), for the locales present. */
     paths: Record<string, string>;
     /** locale → site URL, `href` applied server-side (the canvas and "View live" use these). */
     urls: Record<string, string>;
+    /** The locales the PARENT exists in — a locale can only be added here
+     *  once the parent has it (DESIGN.md, Localization), so the editor
+     *  disables the rest with a reason. Every supported locale for a root
+     *  page: a root can be added to any locale. */
+    parentLocales: string[];
+};
+export type EntryCreateInput = {
+    /** The one locale the entry is created in; others are added with addLocale. */
+    locale: string;
+    parentId?: string | null;
+    /** The merged form: shared fields, that locale's localized fields and its slug. */
+    fields: Record<string, unknown>;
+};
+export type EntryGetResult = {
+    /** The node with ALL its locale rows — the switcher lists them. */
+    record: EntryRecord;
+    locale: string;
+    /** That locale's merged draft fields; null when the entry has no row in `locale`. */
+    fields: Record<string, unknown> | null;
+    /** The locales the PARENT exists in (every supported locale for a root) — the form disables the rest with a reason. */
+    parentLocales: string[];
+};
+export type SharedListItem = {
+    name: string;
+    record: EntryRecord;
+};
+export type SharedGetResult = {
+    name: string;
+    /** The node with ALL its locale rows (every supported one, by construction). */
+    record: EntryRecord;
+    locale: string;
+    /** That locale's merged draft fields — a visual item's styles under `$styles`. */
+    fields: Record<string, unknown>;
+    /** Who links it: "used on N pages". */
+    usage: EntryUsage[];
 };
 export type AdminOps = {
     pages: {
-        /** Lists every node, materializing fixed pages and collection mounts first. */
+        /** Lists every node, materializing fixed pages and collection mounts (in every supported locale) first. */
         list(): Promise<OpResult<PageRecord[]>>;
-        get(id: string): Promise<OpResult<PageGetResult>>;
+        /** not_found only when the page is missing; an absent locale comes back with `draft: null`. */
+        get(id: string, locale: string): Promise<OpResult<PageGetResult>>;
         create(input: PageCreateInput): Promise<OpResult<PageRecord>>;
-        saveDraft(id: string, tree: PageTree): Promise<OpResult<{
+        saveDraft(id: string, locale: string, tree: PageTree): Promise<OpResult<{
             versionId: string;
         }>>;
-        publish(id: string): Promise<OpResult<PageRecord>>;
+        publish(id: string, locale: string): Promise<OpResult<PageRecord>>;
         delete(id: string): Promise<OpResult<null>>;
         rename(id: string, patch: {
             locale: string;
@@ -52,18 +93,38 @@ export type AdminOps = {
         }): Promise<OpResult<PageRecord>>;
         /** "Add page here": a folder becomes a page. */
         setTemplate(id: string, template: string): Promise<OpResult<PageRecord>>;
+        /** Copies `from`'s draft tree, title and slug as the new locale's first draft (spec 2026-09-06 §4). */
+        addLocale(id: string, locale: string, options: {
+            from: string;
+        }): Promise<OpResult<PageRecord>>;
+        /** Deletes the locale's row, versions and paths. Never on fixed nodes or the site root. */
+        removeLocale(id: string, locale: string): Promise<OpResult<PageRecord>>;
     };
     entries: {
         list(collection: string): Promise<OpResult<EntryRecord[]>>;
-        get(collection: string, id: string): Promise<OpResult<EntryRecord>>;
-        create(collection: string, fields: Record<string, unknown>): Promise<OpResult<EntryRecord>>;
-        save(collection: string, id: string, fields: Record<string, unknown>): Promise<OpResult<EntryRecord>>;
-        setStatus(collection: string, id: string, status: "draft" | "published"): Promise<OpResult<EntryRecord>>;
+        /** not_found only when the entry is missing; an absent locale comes back with `fields: null`. */
+        get(collection: string, id: string, locale: string): Promise<OpResult<EntryGetResult>>;
+        create(collection: string, input: EntryCreateInput): Promise<OpResult<EntryRecord>>;
+        save(collection: string, id: string, locale: string, fields: Record<string, unknown>): Promise<OpResult<EntryRecord>>;
+        setStatus(collection: string, id: string, locale: string, status: "draft" | "published"): Promise<OpResult<EntryRecord>>;
         delete(collection: string, id: string): Promise<OpResult<null>>;
         move(collection: string, id: string, to: {
             parentId: string | null;
             index?: number;
         }): Promise<OpResult<EntryRecord>>;
+        /** Copies `from`'s localized fields and slug as the new locale's draft (spec 2026-09-06 §7). Expires nothing. */
+        addLocale(collection: string, id: string, locale: string, options: {
+            from: string;
+        }): Promise<OpResult<EntryRecord>>;
+        /** Deletes the locale's row, versions and paths; fans out like a save. */
+        removeLocale(collection: string, id: string, locale: string): Promise<OpResult<EntryRecord>>;
+    };
+    shared: {
+        /** Materializes every registered item in every supported locale, then lists them in registry order. */
+        list(): Promise<OpResult<SharedListItem[]>>;
+        get(name: string, locale: string): Promise<OpResult<SharedGetResult>>;
+        save(name: string, locale: string, fields: Record<string, unknown>): Promise<OpResult<EntryRecord>>;
+        setStatus(name: string, locale: string, status: "draft" | "published"): Promise<OpResult<EntryRecord>>;
     };
     preview: {
         enable(): Promise<OpResult<null>>;

package/dist/admin/serialize.d.ts

@@ -33,10 +33,21 @@ export type AdminPageTemplate = {
     slugs?: Record<string, string>;
     zones: Record<string, ZonePolicy>;
 };
+export type AdminShared = {
+    name: string;
+    title: string;
+    /** The section a visual item renders through; absent = an object item. */
+    section?: string;
+    versions: boolean;
+    fields: Record<string, AdminField>;
+    /** Resolved (the config's standard set merged in) for a visual item; empty for an object item. */
+    styles: Record<string, AdminField>;
+};
 export type AdminRegistry = {
     sections: AdminSection[];
     collections: AdminCollection[];
     pages: AdminPageTemplate[];
+    shared: AdminShared[];
     locales: {
         default: string;
         supported: string[];

package/dist/admin/serialize.js

@@ -53,6 +53,14 @@ export function serializeAdminConfig(config) {
                 zones: p.zones ?? {},
             };
         }),
+        shared: (config.registry.shared ?? []).map((s) => ({
+            name: s.name,
+            title: s.title,
+            ...(s.section !== undefined ? { section: s.section } : {}),
+            versions: s.versions === true,
+            fields: serializeMap(s.fields),
+            styles: serializeMap(s.section !== undefined ? config.resolvedStyles(s.section) : {}),
+        })),
         locales: config.locales,
         homePageSlug: config.homePageSlug,
         pageDepth: config.pageDepth,

package/dist/admin/shared-items.d.ts

@@ -0,0 +1,9 @@
+import type { ResolvedConfig } from "../config.ts";
+import type { Descriptor } from "../fields.ts";
+import type { EntryRecord, EntryStore } from "../entry-store.ts";
+import { type SharedSchema } from "../shared.ts";
+/** The merged fields a fresh item starts from: sampled field values, and
+ *  for a visual item `$styles` = the resolved style defaults with the
+ *  sample's style values on top. Unsampled fields stay absent. */
+export declare function initialSharedFields(item: SharedSchema, resolvedStyles: Record<string, Descriptor>): Record<string, unknown>;
+export declare function ensureSharedItems(entries: EntryStore, config: ResolvedConfig): Promise<Record<string, EntryRecord>>;

package/dist/admin/shared-items.js

@@ -0,0 +1,61 @@
+import { STYLES_KEY } from "../shared.js";
+/** The merged fields a fresh item starts from: sampled field values, and
+ *  for a visual item `$styles` = the resolved style defaults with the
+ *  sample's style values on top. Unsampled fields stay absent. */
+export function initialSharedFields(item, resolvedStyles) {
+    const out = {};
+    for (const key of Object.keys(item.fields)) {
+        const sampled = item.sample?.[key];
+        if (sampled !== undefined)
+            out[key] = sampled;
+    }
+    if (item.section !== undefined) {
+        const styles = {};
+        for (const [key, d] of Object.entries(resolvedStyles)) {
+            const value = item.sample?.[key] ?? d.default;
+            if (value !== undefined)
+                styles[key] = value;
+        }
+        out[STYLES_KEY] = styles;
+    }
+    return out;
+}
+export async function ensureSharedItems(entries, config) {
+    const { default: def, supported } = config.locales;
+    const out = {};
+    for (const item of config.registry.shared ?? []) {
+        let [record] = await entries.list(item.name);
+        if (!record) {
+            try {
+                const styles = item.section !== undefined ? config.resolvedStyles(item.section) : {};
+                record = await entries.create(item.name, initialSharedFields(item, styles), { locale: def });
+            }
+            catch (e) {
+                const message = e instanceof Error ? e.message : String(e);
+                // Another admin load won the create: read theirs. Anything else is
+                // worth saying out loud, and must not take the other items down.
+                if (message.includes("it is a singleton"))
+                    [record] = await entries.list(item.name);
+                else
+                    console.warn(`smoodly: could not materialize shared item "${item.name}": ${message}`);
+                if (!record)
+                    continue;
+            }
+        }
+        for (const locale of supported) {
+            if (record.locales[locale])
+                continue;
+            try {
+                record = await entries.addLocale(item.name, record.id, locale, { from: def });
+            }
+            catch (e) {
+                const message = e instanceof Error ? e.message : String(e);
+                if (!message.includes("already exists in locale")) {
+                    console.warn(`smoodly: could not materialize shared item "${item.name}" in "${locale}": ${message}`);
+                }
+            }
+        }
+        out[item.name] = record;
+    }
+    return out;
+}

package/dist/admin/shell/AdminApp.js

@@ -9,54 +9,27 @@ import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 // column whose views own their own 48px top bar (the editor adds the third,
 // its 300px inspector). The shell is viewport-height; every column scrolls
 // inside itself.
-import { useEffect, useState } from "react";
+import { useState } from "react";
 import { makeClientOps } from "../client-ops.js";
-import { ListView } from "./ListView.js";
 import { PagesList } from "./PagesList.js";
+import { EntriesList } from "./EntriesList.js";
 import { EntryForm } from "./EntryForm.js";
+import { SharedList } from "./SharedList.js";
+import { SharedForm } from "./SharedForm.js";
 import { EditorView } from "../editor/EditorView.js";
 import { LoginView } from "./LoginView.js";
 import { useAdminSession } from "./session.js";
-import { Button, Logo, StatusBadge, ThemeToggle } from "../ui/primitives.js";
-import { relativeTime } from "../ui/format.js";
+import { Logo, ThemeToggle } from "../ui/primitives.js";
 import { BASE } from "./base.js";
 import { ErrorPane } from "./ErrorPane.js";
 /** Nav items the registry can't produce yet: shown, disabled, so the shape
  *  of the product is visible — the same set the design system's SideNav has. */
-const PLANNED = ["Shared Content", "Media", "Settings"];
+const PLANNED = ["Media", "Settings"];
 function Nav({ registry, active, email, onSignOut }) {
     const item = (href, label, key) => (_jsx("a", { className: "sm-nav-item", href: href ?? undefined, "aria-disabled": href ? undefined : true, "aria-current": href && key === active ? "page" : undefined, children: label }, key));
     const name = email?.split("@")[0] ?? "Editor";
     const initials = name.slice(0, 2).toUpperCase();
-    return (_jsxs("nav", { className: "sm-nav", children: [_jsx(Logo, {}), _jsxs("div", { className: "sm-nav__list", children: [item(`${BASE}/pages`, "Pages", "pages"), registry.collections.map((c) => item(`${BASE}/${c.name}`, c.title, c.name)), PLANNED.map((label) => item(null, label, label))] }), _jsxs("div", { className: "sm-nav__foot", children: [_jsx(ThemeToggle, {}), _jsxs("div", { className: "sm-nav__user", children: [_jsx("span", { className: "sm-avatar", children: initials }), _jsxs("span", { style: { display: "flex", flexDirection: "column", minWidth: 0 }, children: [_jsx("span", { style: { fontWeight: 500, overflow: "hidden", textOverflow: "ellipsis", whiteSpace: "nowrap" }, children: name }), _jsx("span", { style: { fontSize: "var(--text-sm)", color: "var(--text-muted)" }, children: "Editor" })] })] }), _jsx("button", { className: "sm-nav-item", onClick: onSignOut, style: { color: "var(--text-muted)" }, children: "Sign out" })] })] }));
-}
-function EntriesList({ ops, registry, collection }) {
-    const meta = registry.collections.find((c) => c.name === collection);
-    const [rows, setRows] = useState(null);
-    const [error, setError] = useState(null);
-    useEffect(() => {
-        ops.entries.list(collection)
-            .then((r) => (r.ok ? setRows(r.data) : setError(r.message)))
-            .catch(() => setError("Couldn't reach the server."));
-    }, [ops, collection]);
-    if (!meta)
-        return _jsx(ErrorPane, { message: "No such collection." });
-    if (error)
-        return _jsx(ErrorPane, { message: error });
-    const title = (e) => String((meta.titleField && e.fields[meta.titleField]) ?? Object.values(e.fields).find((v) => typeof v === "string") ?? e.id);
-    return (_jsx(ListView, { title: meta.title, count: rows?.length, actions: _jsx(Button, { onClick: () => { window.location.href = `${BASE}/${collection}/new`; }, children: "+ New entry" }), columns: [
-            { label: "Title", width: "minmax(160px,1fr)" },
-            { label: "Updated", width: "minmax(110px,160px)" },
-            { label: "Status", width: "120px" },
-        ], empty: rows ? "Nothing here yet." : "Loading…", rows: (rows ?? []).map((e) => ({
-            key: e.id,
-            href: `${BASE}/${collection}/${encodeURIComponent(e.id)}`,
-            cells: [
-                _jsx("span", { className: "sm-cell sm-cell--title", children: title(e) }, "t"),
-                _jsx("span", { className: "sm-cell sm-cell--muted", children: relativeTime(e.updatedAt) }, "u"),
-                _jsx(StatusBadge, { status: e.status }, "c"),
-            ],
-        })) }));
+    return (_jsxs("nav", { className: "sm-nav", children: [_jsx(Logo, {}), _jsxs("div", { className: "sm-nav__list", children: [item(`${BASE}/pages`, "Pages", "pages"), registry.collections.map((c) => item(`${BASE}/${c.name}`, c.title, c.name)), registry.shared.length > 0 && item(`${BASE}/shared`, "Shared content", "shared"), PLANNED.map((label) => item(null, label, label))] }), _jsxs("div", { className: "sm-nav__foot", children: [_jsx(ThemeToggle, {}), _jsxs("div", { className: "sm-nav__user", children: [_jsx("span", { className: "sm-avatar", children: initials }), _jsxs("span", { style: { display: "flex", flexDirection: "column", minWidth: 0 }, children: [_jsx("span", { style: { fontWeight: 500, overflow: "hidden", textOverflow: "ellipsis", whiteSpace: "nowrap" }, children: name }), _jsx("span", { style: { fontSize: "var(--text-sm)", color: "var(--text-muted)" }, children: "Editor" })] })] }), _jsx("button", { className: "sm-nav-item", onClick: onSignOut, style: { color: "var(--text-muted)" }, children: "Sign out" })] })] }));
 }
 export function AdminApp({ registry, segments, op, auth }) {
     const session = useAdminSession(auth);
@@ -78,6 +51,10 @@ export function AdminApp({ registry, segments, op, auth }) {
         main = _jsx(EntriesList, { ops: ops, registry: registry, collection: head });
     else if (isCollection && tail)
         main = _jsx(EntryForm, { ops: ops, registry: registry, collection: head, id: tail === "new" ? "new" : decodeURIComponent(tail) });
+    else if (head === "shared" && !tail)
+        main = _jsx(SharedList, { ops: ops, registry: registry });
+    else if (head === "shared" && tail)
+        main = _jsx(SharedForm, { ops: ops, registry: registry, name: decodeURIComponent(tail) });
     else
         main = _jsx(ErrorPane, { message: "Not found." });
     return (_jsxs("div", { className: "sm-shell", children: [_jsx(Nav, { registry: registry, active: head, email: email, onSignOut: () => session.client.auth.signOut() }), _jsx("main", { className: "sm-main", children: main })] }));

package/dist/admin/shell/EntriesList.d.ts

@@ -0,0 +1,7 @@
+import type { AdminOps } from "../ops.ts";
+import type { AdminRegistry } from "../serialize.ts";
+export declare function EntriesList({ ops, registry, collection }: {
+    ops: AdminOps;
+    registry: AdminRegistry;
+    collection: string;
+}): import("react").JSX.Element;

package/dist/admin/shell/EntriesList.js

@@ -0,0 +1,95 @@
+"use client";
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+// A collection's list for ONE selected locale: every record is a row;
+// a record absent from the selected locale is dimmed and its click is
+// "Add <locale>" (a confirm, then addLocale copying the source locale).
+// Opening a present row opens the form in the selected locale.
+import { useCallback, useEffect, useState } from "react";
+import { ListView } from "./ListView.js";
+import { entryRows, entrySourceLocale } from "./entries-list.js";
+import { Button, Segmented, StatusBadge } from "../ui/primitives.js";
+import { relativeTime } from "../ui/format.js";
+import { BASE } from "./base.js";
+import { ErrorPane } from "./ErrorPane.js";
+const LOCALE_KEY = "smoodly.entries.locale";
+/** The selected locale survives a reload within the session; a stored
+ *  value that is no longer supported falls back to the default. */
+function rememberedLocale(registry) {
+    try {
+        const stored = window.sessionStorage.getItem(LOCALE_KEY);
+        if (stored && registry.locales.supported.includes(stored))
+            return stored;
+    }
+    catch {
+        // storage unavailable — the default is fine
+    }
+    return registry.locales.default;
+}
+export function EntriesList({ ops, registry, collection }) {
+    const meta = registry.collections.find((c) => c.name === collection);
+    const [records, setRecords] = useState(null);
+    const [error, setError] = useState(null);
+    const [locale, setLocale] = useState(() => rememberedLocale(registry));
+    const multilingual = registry.locales.supported.length > 1;
+    const pickLocale = (next) => {
+        setLocale(next);
+        try {
+            window.sessionStorage.setItem(LOCALE_KEY, next);
+        }
+        catch { /* see rememberedLocale */ }
+    };
+    const load = useCallback(() => {
+        ops.entries.list(collection)
+            .then((r) => (r.ok ? setRecords(r.data) : setError(r.message)))
+            .catch(() => setError("Couldn't reach the server."));
+    }, [ops, collection]);
+    useEffect(load, [load]);
+    if (!meta)
+        return _jsx(ErrorPane, { message: "No such collection." });
+    if (error)
+        return _jsx(ErrorPane, { message: error });
+    const open = (id) => {
+        window.location.href = `${BASE}/${collection}/${encodeURIComponent(id)}?locale=${encodeURIComponent(locale)}`;
+    };
+    const addLocale = async (row) => {
+        const record = records?.find((r) => r.id === row.id);
+        if (!record)
+            return;
+        const from = entrySourceLocale(record, registry);
+        if (!window.confirm(`Add "${row.title}" to ${locale}? Its ${from} fields are copied as the first ${locale} draft.`))
+            return;
+        let result;
+        try {
+            result = await ops.entries.addLocale(collection, row.id, locale, { from });
+        }
+        catch {
+            result = { ok: false, code: "internal", message: "Couldn't reach the server." };
+        }
+        if (!result.ok) {
+            window.alert(result.message);
+            return;
+        }
+        open(row.id);
+    };
+    const rows = records ? entryRows(records, meta, registry, locale) : [];
+    return (_jsx(ListView, { title: meta.title, count: records?.length, actions: _jsxs(_Fragment, { children: [multilingual && _jsx(Segmented, { options: registry.locales.supported, value: locale, onChange: pickLocale }), _jsx(Button, { onClick: () => { window.location.href = `${BASE}/${collection}/new?locale=${encodeURIComponent(locale)}`; }, children: "+ New entry" })] }), columns: [
+            { label: "Title", width: "minmax(160px,1fr)" },
+            { label: "Updated", width: "minmax(110px,160px)" },
+            { label: "Status", width: "120px" },
+        ], empty: records ? "Nothing here yet." : "Loading…", rows: rows.map((row) => {
+            const dim = row.present ? undefined : { opacity: 0.45 };
+            return {
+                key: row.id,
+                onClick: () => (row.present ? open(row.id) : void addLocale(row)),
+                cells: [
+                    _jsx("span", { className: "sm-cell sm-cell--title", style: dim, children: row.title }, "t"),
+                    row.present
+                        ? _jsx("span", { className: "sm-cell sm-cell--muted", children: relativeTime(row.updatedAt) }, "u")
+                        : _jsxs("span", { className: "sm-cell sm-cell--muted", children: ["not in ", locale, " \u2014 click to add"] }, "u"),
+                    row.status
+                        ? _jsx(StatusBadge, { status: row.status }, "c")
+                        : _jsx("span", { className: "sm-cell sm-cell--muted", children: "\u2014" }, "c"),
+                ],
+            };
+        }) }));
+}