@cosmicdrift/kumiko-bundled-features 0.394.0 → 0.396.0

package/dist/template-resolver/web/client-plugin.js

@@ -1,358 +1,9 @@
-import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { EMPTY_VALUE_PLACEHOLDER } from "@cosmicdrift/kumiko-renderer/headless";
-// Client feature factory for the text-block content tree. Apps mount it via
-// createKumikoApp({ clientFeatures: [textBlocksClient()] }); it loads the
-// blocks from the by-tenant query, groups them by their `folder` field and
-// emits them as TreeNode[], plus the editor behind the edit action.
-//
-// **Folder grouping**: block.folder !== null puts the node under a container
-// node labelled with the folder; folder === null keeps it at the root.
-//
-// **State**: TreeNode.state = "filled" when content is set, otherwise "stub"
-// (a hint that the slug exists but is empty).
-import { useShellUser } from "@cosmicdrift/kumiko-bundled-features/auth-email-password/web";
-import { isUiAccessGranted } from "@cosmicdrift/kumiko-framework/ui-types";
-import { ContentPreview, useAppFeatures, useContentEditor, useDispatcher, usePrimitives, useQuery, useTranslation, } from "@cosmicdrift/kumiko-renderer";
-import { CSRF_HEADER_NAME, readCsrfToken } from "@cosmicdrift/kumiko-renderer/live";
-import { PlainContentEditor, RichContentEditor, } from "@cosmicdrift/kumiko-renderer/web";
-import { useEffect, useId, useState } from "react";
-import { DEFAULT_COLLECTION_ACCESS } from "./constants.js";
-import { DocumentBlocksContext, DocumentContentEditor } from "./document-editor.js";
-import { documentBlocksForKind } from "./document-toolbar-blocks.js";
+import { PlainContentEditor } from "@cosmicdrift/kumiko-renderer/web";
+import { createCollectionEntryCreateForm } from "./collection-entry-create-form.js";
+import { makeTreeProvider } from "./content-tree-provider.js";
+import { DocumentContentEditor } from "./document-editor.js";
 import { defaultTranslations } from "./i18n.js";
-import { collectionHandlerName, collectionQueryName, TemplateResolverHandlers, TemplateResolverQueries, } from "./qualified-names.js";
-function newFolderNode() {
-    return { leaves: [], subFolders: new Map() };
-}
-function attachBlock(root, block, tenantIdOverride, collectionId) {
-    const leaf = {
-        label: block.title || block.slug,
-        icon: "file",
-        target: {
-            featureId: "template-resolver",
-            action: "edit",
-            // tenantIdOverride and collectionId travel with the node → the editor
-            // reads and writes through the same tenant and the same collection the
-            // tree was loaded from. Omitted → session tenant, public text-blocks.
-            args: {
-                slug: block.slug,
-                locale: block.locale,
-                ...(tenantIdOverride !== undefined && { tenantIdOverride }),
-                ...(collectionId !== undefined && { collectionId }),
-            },
-        },
-        state: block.content ? "filled" : "stub",
-    };
-    if (block.folder === null) {
-        root.leaves.push(leaf);
-        return;
-    }
-    let cur = root;
-    for (const segment of block.folder.split("/")) {
-        let next = cur.subFolders.get(segment);
-        if (next === undefined) {
-            next = newFolderNode();
-            cur.subFolders.set(segment, next);
-        }
-        cur = next;
-    }
-    cur.leaves.push(leaf);
-}
-function renderFolderNode(node) {
-    // Leaves first (root items), then folders alphabetically.
-    const result = [...node.leaves];
-    for (const folderName of [...node.subFolders.keys()].sort()) {
-        const subNode = node.subFolders.get(folderName);
-        if (subNode === undefined)
-            continue;
-        result.push({
-            label: folderName,
-            icon: "folder",
-            state: "filled",
-            children: renderFolderNode(subNode),
-        });
-    }
-    return result;
-}
-export function groupBlocksByFolder(blocks, tenantIdOverride, collectionId) {
-    const root = newFolderNode();
-    for (const block of blocks) {
-        attachBlock(root, block, tenantIdOverride, collectionId);
-    }
-    const rendered = renderFolderNode(root);
-    if (rendered.length === 0)
-        return [];
-    return [
-        {
-            label: "Content",
-            icon: "folder",
-            state: "filled",
-            children: rendered,
-        },
-    ];
-}
-// A save in the editor re-fires the tree of the collection it wrote to. The
-// SSE refresh does not cover every collection: per-user entries carry no
-// entity signal, because naming their ids to every collection reader would
-// reveal when colleagues change their own entries.
-const TEXT_BLOCK_TREE_KEY = "";
-const treeRefreshListeners = new Map();
-function onTreeRefresh(treeKey, listener) {
-    const listeners = treeRefreshListeners.get(treeKey) ?? new Set();
-    listeners.add(listener);
-    treeRefreshListeners.set(treeKey, listeners);
-    return () => listeners.delete(listener);
-}
-function refreshTree(treeKey) {
-    for (const listener of treeRefreshListeners.get(treeKey) ?? [])
-        listener();
-}
-async function postBlockList(queryType, tenantIdOverride) {
-    // CSRF header is mandatory on authenticated requests (auth-middleware
-    // double-submit pattern). Anonymous/pre-login has no token → header
-    // omitted → the server takes the anonymous path.
-    const headers = { "content-type": "application/json" };
-    const csrf = readCsrfToken();
-    if (csrf !== undefined)
-        headers[CSRF_HEADER_NAME] = csrf;
-    // kumiko-lint-ignore no-raw-hooks not yet converted to the framework hook set
-    const response = await fetch("/api/query", {
-        method: "POST",
-        headers,
-        body: JSON.stringify({
-            type: queryType,
-            payload: tenantIdOverride !== undefined ? { tenantIdOverride } : {},
-        }),
-    });
-    if (!response.ok) {
-        return {
-            ok: false,
-            status: response.status,
-            body: await response.text().catch(() => response.statusText),
-        };
-    }
-    const data = await response.json();
-    return { ok: true, blocks: data.data.blocks };
-}
-const TENANT_OVERRIDE_DENIED_REASON = "tenant_override_requires_system_admin";
-// The dispatcher accepts tenantIdOverride from a SystemAdmin only, and the
-// provider cannot see the session roles. Everyone else gets this exact denial
-// and reads their session tenant instead, which is the only tenant they may
-// edit anyway.
-function isTenantOverrideDenied(result) {
-    return !result.ok && result.status === 403 && result.body.includes(TENANT_OVERRIDE_DENIED_REASON);
-}
-async function loadBlocks(queryType, tenantIdOverride) {
-    let result = await postBlockList(queryType, tenantIdOverride);
-    let effectiveOverride = tenantIdOverride;
-    if (tenantIdOverride !== undefined && isTenantOverrideDenied(result)) {
-        result = await postBlockList(queryType, undefined);
-        effectiveOverride = undefined;
-    }
-    if (!result.ok) {
-        // 403 (CSRF/auth) or 5xx — explicit error instead of silent empty.
-        throw new Error(`text-block load failed: ${result.status} ${result.body}`);
-    }
-    return {
-        blocks: result.blocks,
-        ...(effectiveOverride !== undefined && { tenantIdOverride: effectiveOverride }),
-    };
-}
-// tenantIdOverride (SystemAdmin-only) lets an app point the content tree at a
-// tenant other than the session's — publicstatus seeds marketing/legal blocks
-// on SYSTEM_TENANT_ID, so its SystemAdmin must read that tenant, not their own.
-// Without a collection: the anonymous-capable by-tenant query, so a public
-// page keeps its content sidebar without a session. With one: that
-// collection's own list handler, which carries the collection's access rule.
-function makeTreeProvider(tenantIdOverride, collection) {
-    const collectionId = collection?.id;
-    const queryType = collectionId === undefined
-        ? TemplateResolverQueries.byTenant
-        : collectionQueryName(collectionId, "list");
-    // A per-user entry belongs to its author in the session tenant; pointing the
-    // tree at another tenant would only hide the author's own entries.
-    const requestedOverride = collection?.ownership === "user" ? undefined : tenantIdOverride;
-    return () => (emit, emitError) => {
-        let active = true;
-        // Each denial logs a client-fault warning on the server, so a reload after a
-        // save does not ask again once this subscription learned the answer.
-        let override = requestedOverride;
-        const load = () => {
-            loadBlocks(queryType, override)
-                .then(({ blocks, tenantIdOverride: effectiveOverride }) => {
-                if (!active)
-                    return;
-                override = effectiveOverride;
-                // The app-side r.nav node IS the "Content" container → the provider's
-                // children are the folders/leaves below it, not the wrapper.
-                const content = groupBlocksByFolder(blocks, effectiveOverride, collectionId)[0];
-                emit(content !== undefined && Array.isArray(content.children) ? content.children : []);
-            })
-                .catch((e) => {
-                if (!active)
-                    return;
-                // Explicit error signal via emitError; ProviderBranch shows a banner
-                // plus retry. Falls back to emit([]) for consumers without emitError.
-                if (emitError) {
-                    emitError(e instanceof Error ? e : new Error(String(e)));
-                }
-                else {
-                    emit([]);
-                }
-            });
-        };
-        load();
-        const unsubscribe = onTreeRefresh(collectionId ?? TEXT_BLOCK_TREE_KEY, load);
-        return () => {
-            active = false;
-            unsubscribe();
-        };
-    };
-}
-// A node without a collectionId (the hand-wired text-block tree) has no
-// collection to look up — contentFormat/variableSchema then fall back to
-// their own callers' defaults.
-function findCollection(features, collectionId) {
-    if (collectionId === undefined)
-        return undefined;
-    for (const feature of features) {
-        const match = feature.contentCollections?.find((c) => c.id === collectionId);
-        if (match !== undefined)
-            return match;
-    }
-    return undefined;
-}
-function findContentFormat(features, collectionId) {
-    return findCollection(features, collectionId)?.contentFormat;
-}
-// The collection's fixed variable names (ContentCollectionDefinition.
-// variableSchema) — the chip bar's data source and, keyed, the example
-// values the Preview substitutes in for `{{name}}`.
-function findVariableExamples(features, collectionId) {
-    return findCollection(features, collectionId)?.variableSchema ?? {};
-}
-// Edit form: loads the current values, dispatches set on submit. Who may save
-// follows the server: a collection's set handler carries the collection's own
-// access rule (one rule for list, item and set), the public text-block pair
-// stays TenantAdmin/SystemAdmin. Other users see the form read-only.
-export function canWriteContent(collection, roles) {
-    if (collection !== undefined) {
-        return isUiAccessGranted(collection.access ?? DEFAULT_COLLECTION_ACCESS, roles);
-    }
-    return roles?.includes("TenantAdmin") === true || roles?.includes("SystemAdmin") === true;
-}
-// The collection's declared contentFormat ("plain" | "rich" | "markdown" |
-// "document", see ContentCollectionDefinition.contentFormat) uses a different vocabulary
-// than the stored entry's contentFormat ("plain" | "html" | "markdown" |
-// "mjml", see CONTENT_FORMATS) — "rich" and "document" always store HTML. Without this,
-// handleSave omitting contentFormat let the write schema's
-// contentFormatSchema.default("markdown") silently stamp every save as
-// markdown, clobbering e.g. a "plain" entry. Undefined (no collection, or
-// the collection didn't declare a format) keeps whatever was already saved
-// instead of guessing.
-// Exported for the unit test — resolveWriteContentFormat is a pure function.
-export function resolveWriteContentFormat(collectionContentFormat, loadedContentFormat) {
-    if (collectionContentFormat === "plain")
-        return "plain";
-    if (collectionContentFormat === "rich" || collectionContentFormat === "document")
-        return "html";
-    if (collectionContentFormat === "markdown")
-        return "markdown";
-    return loadedContentFormat;
-}
-function TextBlockEditor({ target, }) {
-    // @cast-boundary visual-tree-args — TargetRef.args is erased to
-    // Record<string, unknown>; the resolver knows the action shape (see the
-    // treeActions.edit definition in feature.ts) and de-erases per action, the
-    // same way event payloads do. Optional chaining absorbs missing fields so a
-    // hand-edited URL cannot crash the editor.
-    const args = target.args;
-    const slug = args?.slug ?? "";
-    const locale = args?.locale ?? "";
-    const tenantIdOverride = args?.tenantIdOverride;
-    // Which collection the node came from. Absent → the public text-block pair,
-    // which is what the hand-wired content tree uses.
-    const collectionId = args?.collectionId;
-    const { Form, Field, Input, Button, Banner, PageHeader } = usePrimitives();
-    const dispatcher = useDispatcher();
-    const user = useShellUser();
-    const t = useTranslation();
-    const contentEditorId = useId();
-    const features = useAppFeatures();
-    const contentFormat = findContentFormat(features, collectionId);
-    const variableExamples = findVariableExamples(features, collectionId);
-    const variables = Object.keys(variableExamples);
-    const collection = findCollection(features, collectionId);
-    const documentBlocks = documentBlocksForKind(collection?.kind);
-    const ContentEditor = useContentEditor(contentFormat);
-    const canWrite = canWriteContent(collection, user?.roles);
-    // Same split as the tree provider: a node without a collection reads through
-    // the public by-slug, a collection node through that collection's handlers.
-    const readQuery = collectionId === undefined
-        ? TemplateResolverQueries.bySlug
-        : collectionQueryName(collectionId, "item");
-    const writeHandler = collectionId === undefined ? TemplateResolverHandlers.set : collectionHandlerName(collectionId);
-    const { data: loaded, loading, error: loadError, } = useQuery(readQuery, { slug, locale, ...(tenantIdOverride !== undefined && { tenantIdOverride }) }, { enabled: slug !== "" && locale !== "" });
-    const [title, setTitle] = useState("");
-    const [content, setContent] = useState("");
-    const [previewing, setPreviewing] = useState(false);
-    const [submitting, setSubmitting] = useState(false);
-    const [saveError, setSaveError] = useState(null);
-    const [savedMsg, setSavedMsg] = useState(null);
-    // Sync loaded data into the form state. loaded === null means the block does
-    // not exist yet — empty form for the create flow.
-    // kumiko-lint-ignore no-raw-hooks not yet converted to the framework hook set
-    useEffect(() => {
-        if (loading)
-            return;
-        setTitle(loaded?.title ?? "");
-        setContent(loaded?.content ?? "");
-        setSaveError(null);
-        setSavedMsg(null);
-    }, [loading, loaded]);
-    const handleSave = async () => {
-        setSubmitting(true);
-        setSaveError(null);
-        setSavedMsg(null);
-        try {
-            const resolvedContentFormat = resolveWriteContentFormat(contentFormat, loaded?.contentFormat);
-            const result = await dispatcher.write(writeHandler, {
-                slug,
-                locale,
-                title,
-                content: content.length > 0 ? content : null,
-                folder: loaded?.folder ?? null,
-                ...(resolvedContentFormat !== undefined && { contentFormat: resolvedContentFormat }),
-                ...(tenantIdOverride !== undefined && { tenantIdOverride }),
-            });
-            if (result.isSuccess) {
-                refreshTree(collectionId ?? TEXT_BLOCK_TREE_KEY);
-                setSavedMsg(result.data.isNew
-                    ? t("template-resolver.editor.created")
-                    : t("template-resolver.editor.saved"));
-                return;
-            }
-            setSaveError(result.error.message ?? result.error.code ?? t("template-resolver.editor.saveFailed"));
-        }
-        catch (e) {
-            // Network blip / dispatcher throw — otherwise submitting stays true and
-            // the save button is locked forever with no feedback.
-            setSaveError(e instanceof Error ? e.message : t("template-resolver.editor.networkError"));
-        }
-        finally {
-            setSubmitting(false);
-        }
-    };
-    const onSubmit = (e) => {
-        e?.preventDefault();
-        void handleSave();
-    };
-    const disabled = submitting || loading || !canWrite;
-    const headerTitle = title || slug || undefined;
-    return (_jsxs(_Fragment, { children: [PageHeader !== undefined && headerTitle !== undefined && _jsx(PageHeader, { title: headerTitle }), _jsxs(Form, { onSubmit: onSubmit, testId: "text-block-editor", title: title || slug || EMPTY_VALUE_PLACEHOLDER, subtitle: locale !== "" ? `${slug} · (${locale})` : slug, actions: canWrite ? (_jsx(Button, { type: "submit", loading: submitting, disabled: disabled, children: submitting
-                        ? t("template-resolver.editor.saving")
-                        : t("template-resolver.editor.save") })) : undefined, children: [loading && _jsx(Banner, { variant: "loading", children: t("template-resolver.editor.loading") }), loadError !== null && (_jsxs(Banner, { variant: "error", children: [t("template-resolver.editor.loadFailed"), ": ", loadError.code] })), !canWrite && !loading && (_jsx(Banner, { variant: "info", children: t("template-resolver.editor.readOnly") })), _jsx(Field, { id: "text-block-title", label: t("template-resolver.editor.titleLabel"), required: true, children: _jsx(Input, { kind: "text", id: "text-block-title", name: "text-block-title", value: title, onChange: setTitle, disabled: disabled, required: true }) }), _jsx(Field, { id: contentEditorId, label: t("template-resolver.editor.contentLabel"), labelAppendix: _jsx(Button, { type: "button", variant: "secondary", size: "sm", onClick: () => setPreviewing((p) => !p), children: previewing ? t("kumiko.contentEditor.editMode") : t("kumiko.contentEditor.preview") }), children: previewing ? (_jsx(ContentPreview, { content: content, variables: variableExamples, contentFormat: contentFormat })) : (_jsx(DocumentBlocksContext.Provider, { value: documentBlocks, children: _jsx(ContentEditor, { id: contentEditorId, value: content, onChange: setContent, variables: variables, readOnly: disabled }) })) }), saveError !== null && _jsx(Banner, { variant: "error", children: saveError }), savedMsg !== null && _jsx(Banner, { variant: "info", children: savedMsg })] })] }));
-}
+import { TextBlockEditor } from "./text-block-editor.js";
 // `navId` = the QN of the r.nav({ provider: true }) node the app registers for
 // the content tree (e.g. "publicstatus:nav:content"). The app owns the node's
 // label/icon/access, the feature only supplies children plus the editor.
@@ -386,19 +37,13 @@ export function textBlocksClient(opts) {
         }),
         resolvers: {
             "template-resolver:edit": TextBlockEditor,
+            "template-resolver:create": createCollectionEntryCreateForm(tenantId),
         },
-        // The default for every "plain" collection (ai-prompt, mail without
-        // an explicit rich override) — an app-registered "plain" editor on
-        // another clientFeature still wins, last-wins same as columnRenderers.
+        // An app-registered editor for a format on another clientFeature still wins,
+        // last-wins same as columnRenderers.
         contentEditors: {
             plain: PlainContentEditor,
-            rich: RichContentEditor,
             document: DocumentContentEditor,
-            // ponytail: same textarea+chips as "plain" — markdown is stored as
-            // text either way. Shares PlainContentEditor's fixed-DOM-id ceiling
-            // (see its own file comment); swap for a live-preview widget or a
-            // forwarded-ref variant if a collection actually needs one.
-            markdown: PlainContentEditor,
         },
         translations: defaultTranslations,
     };

package/dist/template-resolver/web/collection-entry-create-form.d.ts

@@ -0,0 +1,11 @@
+import type { TargetRef } from "@cosmicdrift/kumiko-framework/engine";
+import type { ReactNode } from "react";
+export declare function createCollectionEntryCreateForm(tenantId: string | undefined): (props: {
+    readonly target: TargetRef;
+    readonly onClose: () => void;
+}) => ReactNode;
+export declare function CollectionEntryCreateForm({ target, tenantId, }: {
+    readonly target: TargetRef;
+    readonly onClose: () => void;
+    readonly tenantId?: string | undefined;
+}): ReactNode;

package/dist/template-resolver/web/collection-entry-create-form.js

@@ -0,0 +1,31 @@
+import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { FormScreenLayout, usePrimitives, useTranslation } from "@cosmicdrift/kumiko-renderer";
+import { ContentField } from "./content-field.js";
+import { useCollectionEntryCreate } from "./use-collection-entry-create.js";
+const SLUG_INVALID_ISSUE = {
+    path: "slug",
+    code: "slug_invalid",
+    i18nKey: "template-resolver.editor.slugInvalid",
+};
+// A new entry in the app's own locale; the tree then lists it under that locale like any other.
+// `tenantId` is the plugin's SystemAdmin tenant, the one the collection tree lists, so a new entry
+// lands where the tree looks. Same rule as the tree: per-user collections stay on the session tenant.
+export function createCollectionEntryCreateForm(tenantId) {
+    return function BoundCollectionEntryCreateForm(props) {
+        return _jsx(CollectionEntryCreateForm, { ...props, tenantId: tenantId });
+    };
+}
+function CreateFields({ state }) {
+    const { Field, Input, Banner } = usePrimitives();
+    const t = useTranslation();
+    const { canWrite } = state.editorContext;
+    return (_jsxs(_Fragment, { children: [!canWrite && _jsx(Banner, { variant: "info", children: t("template-resolver.editor.readOnly") }), _jsx(Field, { id: "create-entry-slug", label: t("template-resolver.editor.slugLabel"), required: true, ...(state.slugInvalid && { issues: [SLUG_INVALID_ISSUE] }), children: _jsx(Input, { kind: "text", id: "create-entry-slug", name: "create-entry-slug", value: state.slug, onChange: state.setSlug, disabled: state.disabled, required: true }) }), _jsx(Field, { id: "create-entry-title", label: t("template-resolver.editor.titleLabel"), required: true, children: _jsx(Input, { kind: "text", id: "create-entry-title", name: "create-entry-title", value: state.title, onChange: state.setTitle, disabled: state.disabled, required: true }) }), _jsx(ContentField, { editorContext: state.editorContext, value: state.content, onChange: state.setContent, disabled: state.disabled }), state.error !== null && _jsx(Banner, { variant: "error", children: state.error })] }));
+}
+export function CollectionEntryCreateForm({ target, tenantId, }) {
+    const { Button, PageHeader, Section } = usePrimitives();
+    const t = useTranslation();
+    const state = useCollectionEntryCreate(target, tenantId);
+    return (_jsxs(_Fragment, { children: [PageHeader !== undefined && _jsx(PageHeader, { title: state.headerTitle }), _jsx(FormScreenLayout, { onSubmit: () => {
+                    void state.create();
+                }, testId: "collection-entry-create", actions: state.editorContext.canWrite ? (_jsx(Button, { type: "submit", loading: state.submitting, disabled: state.createDisabled, children: t("template-resolver.editor.create") })) : undefined, children: _jsx(Section, { children: _jsx(CreateFields, { state: state }) }) })] }));
+}

package/dist/template-resolver/web/collection-lookup.d.ts

@@ -0,0 +1,4 @@
+import type { FeatureSchema } from "@cosmicdrift/kumiko-renderer";
+export type ContentCollectionSchema = NonNullable<FeatureSchema["contentCollections"]>[number];
+export declare function findCollection(features: readonly FeatureSchema[], collectionId?: string): ContentCollectionSchema | undefined;
+export declare function canWriteContent(collection: Pick<ContentCollectionSchema, "access"> | undefined, roles: readonly string[] | undefined): boolean;

package/dist/template-resolver/web/collection-lookup.js

@@ -0,0 +1,24 @@
+import { isUiAccessGranted } from "@cosmicdrift/kumiko-framework/ui-types";
+import { DEFAULT_COLLECTION_ACCESS } from "./constants.js";
+// A node without a collectionId (the hand-wired text-block tree) has no
+// collection to look up — contentFormat/variableSchema then fall back to
+// their own callers' defaults.
+export function findCollection(features, collectionId) {
+    if (collectionId === undefined)
+        return undefined;
+    for (const feature of features) {
+        const match = feature.contentCollections?.find((c) => c.id === collectionId);
+        if (match !== undefined)
+            return match;
+    }
+    return undefined;
+}
+// Who may save follows the server: a collection's set handler carries the
+// collection's own access rule (one rule for list, item and set), the public
+// text-block pair stays TenantAdmin/SystemAdmin. Other users see the form read-only.
+export function canWriteContent(collection, roles) {
+    if (collection !== undefined) {
+        return isUiAccessGranted(collection.access ?? DEFAULT_COLLECTION_ACCESS, roles);
+    }
+    return roles?.includes("TenantAdmin") === true || roles?.includes("SystemAdmin") === true;
+}

package/dist/template-resolver/web/constants.d.ts

@@ -11,6 +11,8 @@ export type UpsertKind = (typeof UPSERT_KINDS)[number];
 export declare const TEXT_BLOCK_KIND: "text-block";
 export declare const COLLECTION_REFUSED_KINDS: readonly ["mail", "mail-layout", "pdf-layout"];
 export declare function isCollectionRefusedKind(kind: unknown): kind is (typeof COLLECTION_REFUSED_KINDS)[number];
+export declare const SLUG_PATTERN: RegExp;
+export declare const SLUG_MAX_LENGTH = 80;
 export declare const CONTENT_FORMATS: readonly ["markdown", "mjml", "html", "plain"];
 export type ContentFormat = (typeof CONTENT_FORMATS)[number];
 export declare const TEMPLATE_SCOPES: readonly ["system", "tenant"];

package/dist/template-resolver/web/constants.js

@@ -47,6 +47,8 @@ export const COLLECTION_REFUSED_KINDS = [
 export function isCollectionRefusedKind(kind) {
     return isOneOf(COLLECTION_REFUSED_KINDS, kind);
 }
+export const SLUG_PATTERN = /^[a-z0-9][a-z0-9-]*$/;
+export const SLUG_MAX_LENGTH = 80;
 export const CONTENT_FORMATS = ["markdown", "mjml", "html", "plain"];
 export const TEMPLATE_SCOPES = ["system", "tenant"];
 export const TEMPLATE_STATUSES = ["draft", "active", "archived"];

package/dist/template-resolver/web/content-field.d.ts

@@ -0,0 +1,9 @@
+import { type ReactNode } from "react";
+import type { CollectionEditorContext } from "./use-collection-editor-context.ts";
+export type ContentFieldProps = {
+    readonly editorContext: CollectionEditorContext;
+    readonly value: string;
+    readonly onChange: (value: string) => void;
+    readonly disabled: boolean;
+};
+export declare function ContentField({ editorContext, value, onChange, disabled, }: ContentFieldProps): ReactNode;

package/dist/template-resolver/web/content-field.js

@@ -0,0 +1,14 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { ContentPreview, usePrimitives, useTranslation } from "@cosmicdrift/kumiko-renderer";
+import { useId, useState } from "react";
+import { DocumentBlocksContext } from "./document-editor.js";
+// The content input shared by the edit and create forms: the collection's editor
+// plus a toggle to its preview with the example variables substituted.
+export function ContentField({ editorContext, value, onChange, disabled, }) {
+    const { Field, Button } = usePrimitives();
+    const t = useTranslation();
+    const contentEditorId = useId();
+    const [previewing, setPreviewing] = useState(false);
+    const { ContentEditor, contentFormat, documentBlocks, variableExamples, variables } = editorContext;
+    return (_jsx(Field, { id: contentEditorId, label: t("template-resolver.editor.contentLabel"), labelAppendix: _jsx(Button, { type: "button", variant: "secondary", size: "sm", onClick: () => setPreviewing((p) => !p), children: previewing ? t("kumiko.contentEditor.editMode") : t("kumiko.contentEditor.preview") }), children: previewing ? (_jsx(ContentPreview, { content: value, variables: variableExamples, contentFormat: contentFormat })) : (_jsx(DocumentBlocksContext.Provider, { value: documentBlocks, children: _jsx(ContentEditor, { id: contentEditorId, value: value, onChange: onChange, variables: variables, readOnly: disabled }) })) }));
+}

package/dist/template-resolver/web/content-tree-provider.d.ts

@@ -0,0 +1,14 @@
+import type { TreeChildrenSubscribe, TreeNode } from "@cosmicdrift/kumiko-framework/engine";
+import type { ContentCollectionSchema } from "./collection-lookup.ts";
+export type BlockSummary = {
+    readonly slug: string;
+    readonly locale: string;
+    readonly title: string | null;
+    readonly content: string | null;
+    readonly folder: string | null;
+    readonly modifiedAt: string | null;
+};
+export declare function groupBlocksByFolder(blocks: readonly BlockSummary[], tenantIdOverride?: string, collectionId?: string): readonly TreeNode[];
+export declare const TEXT_BLOCK_TREE_KEY = "";
+export declare function refreshTree(treeKey: string): void;
+export declare function makeTreeProvider(tenantIdOverride?: string, collection?: Pick<ContentCollectionSchema, "id" | "ownership">): TreeChildrenSubscribe;