@vit-foundation/ui 0.1.0

package/dist/config/context.js

@@ -0,0 +1,47 @@
+import { getContext, setContext } from 'svelte';
+import { defaultMessages } from './messages.js';
+import { BASE_LOCALE, LOCALES } from './types.js';
+const KEY = Symbol.for('@vit-foundation/ui:config');
+/**
+ * The provider-less config: identity hrefs, Catalan, no router. Complete on
+ * purpose — every component must render without a provider, which is what
+ * keeps stories and component tests free of app wiring.
+ */
+export const DEFAULT_UI_CONFIG = {
+    href: (path) => path,
+    locale: () => BASE_LOCALE,
+    locales: LOCALES,
+    url: () => undefined,
+    canonicalPathname: (url) => url.pathname,
+    siteName: 'ViT',
+    messages: defaultMessages
+};
+/**
+ * Installs the app's config for the subtree. Takes a *thunk* so a provider
+ * whose input is a reactive prop stays live: the resolved object delegates
+ * every read back through `input()`, and Svelte's reactivity flows through
+ * the getters. Called by UiProvider; call it directly only from a layout-like
+ * component's init.
+ */
+export function setUiConfig(input) {
+    const resolved = {
+        href: (path, options) => (input().href ?? DEFAULT_UI_CONFIG.href)(path, options),
+        locale: () => (input().locale ?? DEFAULT_UI_CONFIG.locale)(),
+        get locales() {
+            return input().locales ?? LOCALES;
+        },
+        url: () => input().url?.(),
+        canonicalPathname: (url) => (input().canonicalPathname ?? DEFAULT_UI_CONFIG.canonicalPathname)(url),
+        get siteName() {
+            return input().siteName ?? DEFAULT_UI_CONFIG.siteName;
+        },
+        get messages() {
+            return input().messages ?? defaultMessages;
+        }
+    };
+    return setContext(KEY, resolved);
+}
+/** The nearest provider's config, or the standalone defaults. */
+export function getUiConfig() {
+    return getContext(KEY) ?? DEFAULT_UI_CONFIG;
+}

package/dist/config/index.d.ts

@@ -0,0 +1,5 @@
+export { DEFAULT_UI_CONFIG, getUiConfig, setUiConfig } from './context.js';
+export { defaultMessages } from './messages.js';
+export { default as UiProvider } from './UiProvider.svelte';
+export { BASE_LOCALE, LOCALES } from './types.js';
+export type { Locale, SiteLink, UiConfig, UiConfigInput, UiMessages } from './types.js';

package/dist/config/index.js

@@ -0,0 +1,4 @@
+export { DEFAULT_UI_CONFIG, getUiConfig, setUiConfig } from './context.js';
+export { defaultMessages } from './messages.js';
+export { default as UiProvider } from './UiProvider.svelte';
+export { BASE_LOCALE, LOCALES } from './types.js';

package/dist/config/messages.d.ts

@@ -0,0 +1,7 @@
+import type { UiMessages } from './types.js';
+/**
+ * Catalan fallback copy — the foundation's default UI language. Used whole
+ * when no provider is mounted, and never merged key-by-key: `messages` is
+ * all-or-nothing so an app cannot ship a half-translated surface silently.
+ */
+export declare const defaultMessages: UiMessages;

package/dist/config/messages.js

@@ -0,0 +1,38 @@
+/**
+ * Catalan fallback copy — the foundation's default UI language. Used whole
+ * when no provider is mounted, and never merged key-by-key: `messages` is
+ * all-or-nothing so an app cannot ship a half-translated surface silently.
+ */
+export const defaultMessages = {
+    common_readMore: () => 'Llegeix més',
+    pagination_label: () => 'Paginació de weeklies',
+    pagination_previous: () => 'Anterior',
+    pagination_next: () => 'Següent',
+    pagination_status: ({ page, pages }) => `Pàgina ${page} de ${pages}`,
+    share_label: () => 'Comparteix',
+    share_copyLink: () => "Copia l'enllaç",
+    share_copied: () => 'Enllaç copiat!',
+    form_error_generic: () => 'Hi ha hagut un error. Torna-ho a provar.',
+    form_error_rateLimited: () => 'Has fet massa intents en poc temps. Espera uns minuts i torna-ho a provar.',
+    form_error_unauthenticated: () => 'Per continuar cal iniciar la sessió.',
+    form_error_forbidden: () => 'No tens permís per fer aquesta acció.',
+    form_error_unavailable: () => 'Aquesta acció no està disponible ara mateix. Torna-ho a provar més tard.',
+    weeklie_number: ({ number }) => `#${number}`,
+    weeklies_sortLabel: () => 'Ordena per',
+    weeklies_sortDesc: () => 'Data descendent',
+    weeklies_sortAsc: () => 'Data ascendent',
+    timeline_label: () => 'Cronologia de fites',
+    nav_mainLabel: () => 'Navegació principal',
+    nav_home: () => 'Inici',
+    nav_menuLabel: () => 'Menú',
+    account_navLabel: () => 'El teu compte',
+    lang_switcherLabel: () => 'Idioma',
+    footer_rights: () => 'Fundació Visualization for Transparency. Tots els drets reservats.',
+    jobs_empty: () => 'Ara mateix no tenim cap oferta oberta.',
+    jobs_newsletterNudge: () => 'Res que encaixi amb el teu perfil? Subscriu-te al butlletí per estar al dia.',
+    category_foundation: () => 'Fundació',
+    category_lab: () => 'Laboratori',
+    category_education: () => 'Educació',
+    category_collaboration: () => 'Col·laboració',
+    category_press: () => 'Premsa'
+};

package/dist/config/types.d.ts

@@ -0,0 +1,99 @@
+/**
+ * The site's locales and their canonical member. Fixed rather than generic:
+ * `ca` is load-bearing — it is the required key of every localized column
+ * (see LocalizedText in ../edit/types.js) and the fallback `localize()`
+ * resolves to — so widening the set is a deliberate package change, not a
+ * consumer option.
+ */
+export declare const LOCALES: readonly ["ca", "en", "es"];
+export type Locale = (typeof LOCALES)[number];
+export declare const BASE_LOCALE: Locale;
+/** One primary-navigation entry, rendered by Nav and repeated by Footer. */
+export interface SiteLink {
+    href: string;
+    label: string;
+}
+/**
+ * The strings the components render, as message *functions* so the app's
+ * i18n runtime resolves the active locale at call time. The shape is a
+ * structural subset of a Paraglide `messages` module — an app that compiles
+ * these keys can pass its `m` object wholesale.
+ *
+ * Keys consumed only through this package still count as used: an app
+ * pruning its message catalogue must keep every key named here.
+ */
+export interface UiMessages {
+    common_readMore(): string;
+    pagination_label(): string;
+    pagination_previous(): string;
+    pagination_next(): string;
+    pagination_status(params: {
+        page: number;
+        pages: number;
+    }): string;
+    share_label(): string;
+    share_copyLink(): string;
+    share_copied(): string;
+    form_error_generic(): string;
+    form_error_rateLimited(): string;
+    form_error_unauthenticated(): string;
+    form_error_forbidden(): string;
+    form_error_unavailable(): string;
+    weeklie_number(params: {
+        number: number;
+    }): string;
+    weeklies_sortLabel(): string;
+    weeklies_sortDesc(): string;
+    weeklies_sortAsc(): string;
+    timeline_label(): string;
+    nav_mainLabel(): string;
+    nav_home(): string;
+    nav_menuLabel(): string;
+    account_navLabel(): string;
+    lang_switcherLabel(): string;
+    footer_rights(): string;
+    jobs_empty(): string;
+    jobs_newsletterNudge(): string;
+    category_foundation(): string;
+    category_lab(): string;
+    category_education(): string;
+    category_collaboration(): string;
+    category_press(): string;
+}
+/**
+ * Everything the components read from their host app, resolved. Apps provide
+ * a partial (`UiConfigInput`) through UiProvider; components read this
+ * through `getUiConfig()`, which fills the gaps with identity/Catalan
+ * defaults so the package renders standalone (stories, tests, previews).
+ *
+ * `locale()` and `url()` are function reads, not snapshots, so the provider's
+ * reactive sources (an i18n runtime, the router's current URL) flow through:
+ * a provider that passes a captured value freezes locale switching and
+ * current-page highlighting.
+ */
+export interface UiConfig {
+    /** Resolve a canonical internal path to a final href (e.g. locale prefixing). */
+    href(path: string, options?: {
+        locale?: Locale;
+    }): string;
+    /** The locale being rendered. Reactive read. */
+    locale(): Locale;
+    locales: readonly Locale[];
+    /** The URL being rendered, when the app has a router to ask. Reactive read. */
+    url(): URL | undefined;
+    /** Canonical (de-localized) pathname of a URL, for current-page checks. */
+    canonicalPathname(url: URL): string;
+    /** Appended to document titles and shown as the wordmark. */
+    siteName: string;
+    messages: UiMessages;
+}
+/** What an app hands UiProvider: any subset; the rest keeps package defaults. */
+export interface UiConfigInput {
+    href?: UiConfig['href'];
+    locale?: UiConfig['locale'];
+    locales?: readonly Locale[];
+    url?: UiConfig['url'];
+    canonicalPathname?: UiConfig['canonicalPathname'];
+    siteName?: string;
+    messages?: UiMessages;
+}

package/dist/config/types.js

@@ -0,0 +1,9 @@
+/**
+ * The site's locales and their canonical member. Fixed rather than generic:
+ * `ca` is load-bearing — it is the required key of every localized column
+ * (see LocalizedText in ../edit/types.js) and the fallback `localize()`
+ * resolves to — so widening the set is a deliberate package change, not a
+ * consumer option.
+ */
+export const LOCALES = ['ca', 'en', 'es'];
+export const BASE_LOCALE = 'ca';

package/dist/content/index.d.ts

@@ -0,0 +1,3 @@
+export { renderBody } from './richtext.js';
+export type { RichTextBlock } from './richtext.js';
+export type { CollaboratorData, FieldConstraint, FormFailReason, JobOpeningData, MilestoneCategory, MilestoneData, ProjectCardData, ProjectKind, SortDirection, TeamMemberData, WeeklyCardData } from './types.js';

package/dist/content/index.js

@@ -0,0 +1 @@
+export { renderBody } from './richtext.js';

package/dist/content/richtext.d.ts

@@ -0,0 +1,10 @@
+export interface RichTextBlock {
+    type: 'h2' | 'p';
+    text: string;
+}
+/**
+ * Renders the lightweight markdown used for editorial body fields
+ * (paragraphs separated by blank lines, subheadings as `## ` lines)
+ * into typed blocks. Rendered with real elements — never `{@html}`.
+ */
+export declare function renderBody(body: string): RichTextBlock[];

package/dist/content/richtext.js

@@ -0,0 +1,14 @@
+/**
+ * Renders the lightweight markdown used for editorial body fields
+ * (paragraphs separated by blank lines, subheadings as `## ` lines)
+ * into typed blocks. Rendered with real elements — never `{@html}`.
+ */
+export function renderBody(body) {
+    return body
+        .split(/\n{2,}/)
+        .map((chunk) => chunk.trim())
+        .filter((chunk) => chunk.length > 0)
+        .map((chunk) => chunk.startsWith('## ')
+        ? { type: 'h2', text: chunk.slice(3).trim() }
+        : { type: 'p', text: chunk.replace(/\n/g, ' ') });
+}

package/dist/content/types.d.ts

@@ -0,0 +1,71 @@
+/**
+ * Structural shapes of the content the components render, one locale already
+ * applied. The website's zod-inferred types satisfy these structurally; the
+ * package states them itself so consumers owe it no schema library.
+ */
+/** The bounds of one form field; Field turns them into length attributes. */
+export interface FieldConstraint {
+    min?: number;
+    max: number;
+}
+/**
+ * Shared failure vocabulary of the foundation's form envelopes.
+ * FormErrorFeedback owns one sentence per member (minus 'error', which is
+ * the generic fallback itself).
+ */
+export type FormFailReason = 'rateLimited' | 'unauthenticated' | 'forbidden' | 'unavailable' | 'error';
+export type SortDirection = 'asc' | 'desc';
+/** A weekly as its listing card shows it. */
+export interface WeeklyCardData {
+    id: number;
+    number: number;
+    slug: string;
+    /** ISO date (2026-08-30). */
+    publishedOn: string;
+    title: string;
+    excerpt: string;
+    imageUrl: string;
+}
+export type ProjectKind = 'collaboration' | 'passion';
+/** A project as its card shows it. */
+export interface ProjectCardData {
+    id: number;
+    slug: string;
+    kind: ProjectKind;
+    publishedOn: string;
+    title: string;
+    excerpt: string;
+    imageUrl: string;
+    externalUrl: string | null;
+    hasStory: boolean;
+}
+export type MilestoneCategory = 'education' | 'lab' | 'foundation' | 'collaboration' | 'press';
+/** One timeline milestone. */
+export interface MilestoneData {
+    id: number;
+    occurredOn: string;
+    category: MilestoneCategory;
+    title: string;
+    body: string | null;
+    imageUrls: string[];
+    linkUrl: string | null;
+}
+export interface TeamMemberData {
+    slug: string;
+    name: string;
+    role: string;
+    bio: string | null;
+    photoUrl: string;
+    isBoard: boolean;
+}
+export interface CollaboratorData {
+    personName: string;
+    affiliation: string;
+    url: string | null;
+}
+export interface JobOpeningData {
+    slug: string;
+    title: string;
+    description: string | null;
+    postedOn: string;
+}

package/dist/content/types.js

@@ -0,0 +1,6 @@
+/**
+ * Structural shapes of the content the components render, one locale already
+ * applied. The website's zod-inferred types satisfy these structurally; the
+ * package states them itself so consumers owe it no schema library.
+ */
+export {};

package/dist/edit/Editable.svelte

@@ -0,0 +1,197 @@
+<script lang="ts">
+	import type { Snippet } from 'svelte';
+	import { getEditAdapter } from './context.js';
+	import type { EditDescriptor } from './types.js';
+
+	/**
+	 * The inline-edit primitive. It renders no element of its own: the child
+	 * snippet receives the text and a bag of attributes, and spreads both onto
+	 * whatever semantic element the call site owns —
+	 *
+	 *   <Editable edit={descriptor} value={title}>
+	 *     {#snippet children(text, attrs)}<h3 {...attrs}>{text}</h3>{/snippet}
+	 *   </Editable>
+	 *
+	 * — the same contract Field uses for its control attrs, and for the same
+	 * reason: the element (h1, p, span) is part of the document outline and
+	 * belongs to the caller, not behind a prop.
+	 *
+	 * Inactive — no `edit` descriptor, no adapter in context (a read-only
+	 * app), or the adapter's `isEditing` off — it renders the child with an
+	 * empty attribute bag: no listeners, no wrapper, no cost.
+	 *
+	 * Active, it makes the element a plain-text `contenteditable` textbox.
+	 * The DOM owns the draft while the reader types; this component reads it
+	 * back on commit. Enter commits single-line fields (Cmd/Ctrl+Enter for
+	 * 'multiline'), Escape reverts to the last saved value, blur commits a
+	 * dirty draft. A failed save keeps the draft on screen in the error state
+	 * so nothing typed is lost. State is announced through a visually hidden
+	 * `role="status"` region, the pattern ShareRow set for its copy action.
+	 *
+	 * Styling for the affordance lives in base.css (`[data-vit-editing]`):
+	 * the element is rendered by the *caller's* markup, which scoped styles
+	 * here could never reach.
+	 */
+	interface EditableAttrs {
+		contenteditable?: 'plaintext-only' | 'true';
+		role?: 'textbox';
+		'aria-label'?: string;
+		'aria-multiline'?: 'true';
+		'data-vit-editing'?: 'idle' | 'dirty' | 'saving' | 'error';
+		onbeforeinput?: (event: InputEvent) => void;
+		oninput?: (event: Event) => void;
+		onblur?: (event: FocusEvent) => void;
+		onkeydown?: (event: KeyboardEvent) => void;
+		onpaste?: (event: ClipboardEvent) => void;
+	}
+
+	interface Props {
+		/** Identity of the string. Omit it and this is a passthrough. */
+		edit?: EditDescriptor;
+		value: string;
+		children: Snippet<[string, EditableAttrs]>;
+	}
+
+	let { edit, value, children }: Props = $props();
+
+	const adapter = getEditAdapter();
+
+	let status = $state<'idle' | 'dirty' | 'saving' | 'error'>('idle');
+	/** Last persisted value: what Escape restores and blur diffs against. */
+	// svelte-ignore state_referenced_locally
+	let savedValue = $state(value);
+	/** What the child snippet renders. Only rewritten while the DOM is not
+	 * being typed in — Svelte and the reader must not fight over the node. */
+	// svelte-ignore state_referenced_locally
+	let renderText = $state(value);
+	let announcement = $state('');
+
+	// Follow the prop when the app reloads content underneath us — and only
+	// then. Diffing against savedValue instead would fire after every save,
+	// where savedValue has legitimately advanced past the prop, and repaint
+	// the committed draft with stale copy. Never over a draft being held.
+	// svelte-ignore state_referenced_locally
+	let lastPropValue = $state(value);
+	$effect(() => {
+		if (value !== lastPropValue) {
+			lastPropValue = value;
+			if (status === 'idle') {
+				savedValue = value;
+				renderText = value;
+			}
+		}
+	});
+
+	const active = $derived(edit !== undefined && (adapter?.isEditing ?? false));
+	const multiline = $derived(edit?.format === 'multiline' || edit?.format === 'richtext');
+
+	/** contenteditable text, innerText keeps line breaks; NBSPs become spaces. */
+	function textOf(element: HTMLElement): string {
+		return (element.innerText ?? element.textContent ?? '').replace(/\u00a0/g, ' ');
+	}
+
+	function handleBeforeInput(event: InputEvent): void {
+		// 'plaintext-only' is not universal (Firefox); strip rich insertions.
+		if (event.inputType === 'insertFromPaste' || event.inputType === 'insertFromDrop') return;
+		if (!multiline && event.inputType === 'insertParagraph') event.preventDefault();
+	}
+
+	function handlePaste(event: ClipboardEvent): void {
+		// Plain text only, whatever the clipboard holds.
+		event.preventDefault();
+		const text = event.clipboardData?.getData('text/plain') ?? '';
+		const selection = window.getSelection();
+		if (!selection || selection.rangeCount === 0) return;
+		const range = selection.getRangeAt(0);
+		range.deleteContents();
+		range.insertNode(document.createTextNode(multiline ? text : text.replace(/\s*\n\s*/g, ' ')));
+		selection.collapseToEnd();
+		status = 'dirty';
+	}
+
+	function handleInput(): void {
+		if (status !== 'saving') status = 'dirty';
+	}
+
+	async function commit(element: HTMLElement): Promise<void> {
+		if (!edit || !adapter) return;
+		const draft = textOf(element).trim();
+		if (draft === savedValue) {
+			status = 'idle';
+			return;
+		}
+		status = 'saving';
+		announcement = 'Desant…';
+		try {
+			await adapter.save(edit, draft);
+			savedValue = draft;
+			status = 'idle';
+			announcement = 'Desat';
+		} catch {
+			// Draft stays in the DOM; the reader decides whether to retry.
+			status = 'error';
+			announcement = 'Error en desar';
+		}
+	}
+
+	function handleBlur(event: FocusEvent): void {
+		if (status === 'dirty' || status === 'error') void commit(event.currentTarget as HTMLElement);
+	}
+
+	function handleKeydown(event: KeyboardEvent): void {
+		const element = event.currentTarget as HTMLElement;
+		if (event.key === 'Escape') {
+			// Svelte's cached text still equals renderText, so a state write
+			// alone cannot repaint a node the reader has mutated: restore the
+			// DOM directly, then settle.
+			element.textContent = savedValue;
+			status = 'idle';
+			announcement = '';
+			element.blur();
+			return;
+		}
+		const commitKey = multiline
+			? event.key === 'Enter' && (event.metaKey || event.ctrlKey)
+			: event.key === 'Enter';
+		if (commitKey) {
+			event.preventDefault();
+			void commit(element);
+		}
+	}
+
+	const attrs = $derived<EditableAttrs>(
+		active
+			? {
+					contenteditable: 'plaintext-only',
+					role: 'textbox',
+					'aria-label': edit?.label,
+					'aria-multiline': multiline ? 'true' : undefined,
+					'data-vit-editing': status,
+					onbeforeinput: handleBeforeInput,
+					oninput: handleInput,
+					onblur: handleBlur,
+					onkeydown: handleKeydown,
+					onpaste: handlePaste
+				}
+			: {}
+	);
+</script>
+
+{@render children(renderText, attrs)}
+{#if active}
+	<span class="status" role="status">{announcement}</span>
+{/if}
+
+<style>
+	.status {
+		position: absolute;
+		width: 1px;
+		height: 1px;
+		padding: 0;
+		margin: -1px;
+		overflow: hidden;
+		clip-path: inset(50%);
+		white-space: nowrap;
+		border: 0;
+	}
+</style>

package/dist/edit/Editable.svelte.d.ts

@@ -0,0 +1,52 @@
+import type { Snippet } from 'svelte';
+import type { EditDescriptor } from './types.js';
+/**
+ * The inline-edit primitive. It renders no element of its own: the child
+ * snippet receives the text and a bag of attributes, and spreads both onto
+ * whatever semantic element the call site owns —
+ *
+ *   <Editable edit={descriptor} value={title}>
+ *     {#snippet children(text, attrs)}<h3 {...attrs}>{text}</h3>{/snippet}
+ *   </Editable>
+ *
+ * — the same contract Field uses for its control attrs, and for the same
+ * reason: the element (h1, p, span) is part of the document outline and
+ * belongs to the caller, not behind a prop.
+ *
+ * Inactive — no `edit` descriptor, no adapter in context (a read-only
+ * app), or the adapter's `isEditing` off — it renders the child with an
+ * empty attribute bag: no listeners, no wrapper, no cost.
+ *
+ * Active, it makes the element a plain-text `contenteditable` textbox.
+ * The DOM owns the draft while the reader types; this component reads it
+ * back on commit. Enter commits single-line fields (Cmd/Ctrl+Enter for
+ * 'multiline'), Escape reverts to the last saved value, blur commits a
+ * dirty draft. A failed save keeps the draft on screen in the error state
+ * so nothing typed is lost. State is announced through a visually hidden
+ * `role="status"` region, the pattern ShareRow set for its copy action.
+ *
+ * Styling for the affordance lives in base.css (`[data-vit-editing]`):
+ * the element is rendered by the *caller's* markup, which scoped styles
+ * here could never reach.
+ */
+interface EditableAttrs {
+    contenteditable?: 'plaintext-only' | 'true';
+    role?: 'textbox';
+    'aria-label'?: string;
+    'aria-multiline'?: 'true';
+    'data-vit-editing'?: 'idle' | 'dirty' | 'saving' | 'error';
+    onbeforeinput?: (event: InputEvent) => void;
+    oninput?: (event: Event) => void;
+    onblur?: (event: FocusEvent) => void;
+    onkeydown?: (event: KeyboardEvent) => void;
+    onpaste?: (event: ClipboardEvent) => void;
+}
+interface Props {
+    /** Identity of the string. Omit it and this is a passthrough. */
+    edit?: EditDescriptor;
+    value: string;
+    children: Snippet<[string, EditableAttrs]>;
+}
+declare const Editable: import("svelte").Component<Props, {}, "">;
+type Editable = ReturnType<typeof Editable>;
+export default Editable;

package/dist/edit/context.d.ts

@@ -0,0 +1,10 @@
+import type { EditAdapter } from './types.js';
+/**
+ * Installs the app's persistence adapter for the subtree. An app that never
+ * calls this is read-only by construction: without an adapter every edit
+ * affordance renders as plain content, byte-identical to a build of the
+ * components with no edit mode at all.
+ */
+export declare function setEditAdapter(adapter: EditAdapter): EditAdapter;
+/** The nearest adapter, or undefined in a read-only app. */
+export declare function getEditAdapter(): EditAdapter | undefined;

package/dist/edit/context.js

@@ -0,0 +1,15 @@
+import { getContext, setContext } from 'svelte';
+const KEY = Symbol.for('@vit-foundation/ui:edit-adapter');
+/**
+ * Installs the app's persistence adapter for the subtree. An app that never
+ * calls this is read-only by construction: without an adapter every edit
+ * affordance renders as plain content, byte-identical to a build of the
+ * components with no edit mode at all.
+ */
+export function setEditAdapter(adapter) {
+    return setContext(KEY, adapter);
+}
+/** The nearest adapter, or undefined in a read-only app. */
+export function getEditAdapter() {
+    return getContext(KEY);
+}

package/dist/edit/helpers.d.ts

@@ -0,0 +1,18 @@
+import type { Locale } from '../config/types.js';
+import type { EditableEntity, EditDescriptor } from './types.js';
+/** Descriptor for one page-copy block (`page_content` row). */
+export declare function pageCopyEdit(page: string, sectionKey: string, locale: Locale, options?: {
+    format?: EditDescriptor['format'];
+    label?: string;
+}): EditDescriptor;
+/**
+ * Descriptor factory for one entity's fields, so a call site editing several
+ * fields of the same row names the row once:
+ *
+ *   const edit = entityEdit('weeklies', weekly.id, locale);
+ *   <WeeklieCard {weekly} edit={{ title: edit('title'), excerpt: edit('excerpt') }} />
+ */
+export declare function entityEdit(entity: EditableEntity, id: string | number, locale: Locale): (field: string, options?: {
+    format?: EditDescriptor['format'];
+    label?: string;
+}) => EditDescriptor;

package/dist/edit/helpers.js

@@ -0,0 +1,14 @@
+/** Descriptor for one page-copy block (`page_content` row). */
+export function pageCopyEdit(page, sectionKey, locale, options) {
+    return { ref: { kind: 'page-copy', page, sectionKey }, locale, ...options };
+}
+/**
+ * Descriptor factory for one entity's fields, so a call site editing several
+ * fields of the same row names the row once:
+ *
+ *   const edit = entityEdit('weeklies', weekly.id, locale);
+ *   <WeeklieCard {weekly} edit={{ title: edit('title'), excerpt: edit('excerpt') }} />
+ */
+export function entityEdit(entity, id, locale) {
+    return (field, options) => ({ ref: { kind: 'entity', entity, id, field }, locale, ...options });
+}

package/dist/edit/index.d.ts

@@ -0,0 +1,5 @@
+export { getEditAdapter, setEditAdapter } from './context.js';
+export { default as Editable } from './Editable.svelte';
+export { entityEdit, pageCopyEdit } from './helpers.js';
+export { localize } from './types.js';
+export type { ContentRef, EditableEntity, EditAdapter, EditDescriptor, LocalizedText } from './types.js';

package/dist/edit/index.js

@@ -0,0 +1,4 @@
+export { getEditAdapter, setEditAdapter } from './context.js';
+export { default as Editable } from './Editable.svelte';
+export { entityEdit, pageCopyEdit } from './helpers.js';
+export { localize } from './types.js';