@vespercms/admin 0.0.0-stage → 0.1.0-next.1

package/dist/cloud/storage.d.ts

@@ -0,0 +1,45 @@
+import { type BlobCache, type ChangeSet, type CloudClient, type CommitResult, type Draft, type StorageAdapter, type StorageEntry, type StoredFile } from '@vespercms/core';
+export type CloudStorageOptions = {
+    client: CloudClient;
+    cache?: BlobCache;
+    /** How long a snapshot of the tree and drafts is trusted. */
+    snapshotTtlMs?: number;
+    /** Told whenever the drafts change, here or as the API reports them. */
+    onDrafts?: (drafts: readonly Draft[], version: string) => void;
+    now?: () => number;
+};
+export declare class CloudStorage implements StorageAdapter {
+    readonly kind: "cloud";
+    private readonly client;
+    private readonly cache;
+    private readonly ttl;
+    private readonly onDrafts;
+    private readonly now;
+    private snapshotting;
+    private current;
+    /** New files waiting for the next save (`ChangeSet.defer`): an upload goes out with its entry. */
+    private readonly pending;
+    private wanted;
+    private batch;
+    constructor(options: CloudStorageOptions);
+    /** Forgets the snapshot, so the next read asks the cloud again. */
+    invalidate(): void;
+    private snapshot;
+    /** The drafts as of the latest snapshot, asking the cloud when that's old. */
+    drafts(): Promise<{
+        drafts: Draft[];
+        version: string;
+        commit: string;
+    }>;
+    head(): Promise<{
+        version: string;
+    }>;
+    list(options?: {
+        prefix?: string;
+    }): Promise<StorageEntry[]>;
+    read(path: string): Promise<StoredFile | null>;
+    /** Bytes by version: the cache first, then batched requests to the API. */
+    private bytes;
+    private fetchWanted;
+    commit(changeSet: ChangeSet): Promise<CommitResult>;
+}

package/dist/editor/Field.d.ts

@@ -0,0 +1,24 @@
+import type { FieldModel } from '@vespercms/core';
+import { type ValuePath } from './values.ts';
+export type FieldProps = {
+    field: FieldModel;
+    /** Where the value lives in the entry (concrete indexes for array items). */
+    path: ValuePath;
+    /** Replaces the field's label, e.g. "Speaker 2" for an array item. */
+    label?: string;
+    /**
+     * A list item. An item of objects or images sits in its row's panel, which
+     * names and frames it, so its legend is for screen readers only. An item is
+     * never marked optional: it exists or it doesn't.
+     */
+    item?: 'row' | 'inline';
+    /** A top-level object or list is a section, except where the place already has its own heading (Details). */
+    asSection?: boolean;
+};
+/**
+ * One field: its label, help and error text, and the widget that edits it
+ * (spec §6.3.3: the editor renders the label, the widget the control).
+ * Group widgets (objects, lists, choices) render as a fieldset whose legend
+ * is the label. Errors are linked to the control with aria-describedby.
+ */
+export declare function Field({ field, path, label, item, asSection }: FieldProps): import("react").JSX.Element;

package/dist/editor/PagePicker.d.ts

@@ -0,0 +1,20 @@
+import type { PageLink } from '@vespercms/core';
+/** Every page with a URL on the site, loaded once per studio. Empty until it arrives, or if it fails. */
+export declare function usePages(): PageLink[];
+/** Pages as link suggestions: found by title, inserted as their address. */
+export declare function pageSuggestions(pages: readonly PageLink[]): {
+    value: string;
+    label: string;
+    detail: string;
+}[];
+/**
+ * "Choose a page…" beside a URL field: a dialog with a searchable list of
+ * pages. `absolute` puts the site's address in front, for fields whose
+ * schema accepts only full URLs.
+ */
+export declare function ChoosePageButton({ onPick, absolute, fieldLabel, isDisabled, }: {
+    onPick: (url: string) => void;
+    absolute?: string;
+    fieldLabel: string;
+    isDisabled?: boolean;
+}): import("react").JSX.Element | null;

package/dist/editor/arrange.d.ts

@@ -0,0 +1,13 @@
+import type { CollectionManifest, FieldModel } from '@vespercms/core';
+export type ArrangedFields = {
+    title: FieldModel | undefined;
+    main: FieldModel[];
+    details: FieldModel[];
+    /** The collection's own tabs, in the order it declares them, each with its fields. */
+    tabs: {
+        id: string;
+        label: string;
+        fields: FieldModel[];
+    }[];
+};
+export declare function arrangeFields(collection: CollectionManifest): ArrangedFields;

package/dist/editor/context.d.ts

@@ -0,0 +1,23 @@
+import type { A11yNote, CollectionManifest, DataObject, DataValue } from '@vespercms/core';
+import type { ValuePath } from './values.ts';
+/** What every field in the open entry shares. */
+export type EditorState = {
+    collection: CollectionManifest;
+    values: DataObject;
+    setValue: (path: ValuePath, value: DataValue) => void;
+    /** Validation messages by `pathKey`, from the last save. */
+    issues: ReadonlyMap<string, readonly string[]>;
+    /** Accessibility notes by `pathKey` of the field they're shown under (spec §6.18). */
+    notes?: ReadonlyMap<string, readonly A11yNote[]>;
+    disabled: boolean;
+    /** The entry hasn't been saved yet. */
+    isNew: boolean;
+    /** The entry's file, site-relative; for a new entry, where it will most likely be saved. */
+    entryPath: string;
+    /** The open entry's ID (`null` until a new entry is saved). */
+    entryId: string | null;
+    /** Prefix for field ids in a form that isn't the entry's own (a block's settings). */
+    idPrefix?: string;
+};
+export declare const EditorContext: import("react").Context<EditorState | null>;
+export declare function useEditor(): EditorState;

package/dist/editor/copy.d.ts

@@ -0,0 +1,9 @@
+import type { CollectionManifest, DataObject } from '@vespercms/core';
+/**
+ * A copy's starting values (Duplicate, spec §10.3): every value as it is,
+ * " (copy)" after the title, and the fields that hold the entry's own address
+ * left empty so the copy gets its own. Those are the slug widget's, which then
+ * follow the new title, and a top-level `slug`, which Astro takes as the
+ * entry's ID. Images are shared, so their focal points and crops come along.
+ */
+export declare function copiedValues(collection: CollectionManifest, values: DataObject): DataObject;

package/dist/editor/reveal.d.ts

@@ -0,0 +1,7 @@
+export declare const REVEAL_EVENT = "vesper:reveal";
+/**
+ * Focuses an element as soon as it's on screen (a field on another tab
+ * shows once its tab is chosen; one inside a closed list item, once the
+ * item opens), and scrolls it into view.
+ */
+export declare function focusWhenShown(id: string, tries?: number, asked?: boolean): void;

package/dist/editor/target.d.ts

@@ -0,0 +1,21 @@
+import { type DataValue, type FieldIssue, type FieldModel } from '@vespercms/core';
+import { type ValuePath } from './values.ts';
+/**
+ * Where an issue is shown: the deepest field on screen along its path. An
+ * issue inside a raw field, or in a nested value no control shows, lands on
+ * the nearest field that is shown.
+ */
+export declare function issueTarget(fields: readonly FieldModel[], path: FieldIssue['path']): {
+    path: ValuePath;
+    focusId: string;
+    label: string;
+};
+/**
+ * Where an issue is, in words, for a list of notes away from the form:
+ * "Section 2 (Showcase) › Image, alt". Beside its field, the field's own
+ * label is enough, but in the notes drawer two images in blocks would both
+ * read "Image, alt". A list item is named by its place and, in blocks, its
+ * kind, which says the list's name too ("Section 2"), so the list's own
+ * label is left out before it.
+ */
+export declare function issuePlace(fields: readonly FieldModel[], path: FieldIssue['path'], values: DataValue): string;

package/dist/editor/values.d.ts

@@ -0,0 +1,18 @@
+import { type DataObject, type DataValue, type FieldModel } from '@vespercms/core';
+/** A concrete path into an entry's values: keys and array indexes. */
+export type ValuePath = readonly (string | number)[];
+export declare function getIn(root: DataValue, path: ValuePath): DataValue;
+/**
+ * Returns a copy of `root` with the value at `path` replaced. `undefined`
+ * removes an object key (the file then loses that line) and leaves array
+ * items in place. Missing parents are created.
+ */
+export declare function setIn(root: DataObject, path: ValuePath, value: DataValue): DataObject;
+/** A DOM id for the control at `path`: stable, unique per entry, and safe in selectors. */
+export declare function fieldId(path: ValuePath, prefix?: string): string;
+/** Key for matching validation issues to fields. */
+export declare function pathKey(path: ValuePath): string;
+/** A field model's own key: the last segment of its path (`'[]'` for array items). */
+export declare function keyOf(field: FieldModel): string;
+/** The value a new entry starts with: each field's static default, where it has one. */
+export declare function initialValues(fields: readonly FieldModel[] | null): DataObject;

package/dist/geo-map-CT3OGD7O.js

@@ -0,0 +1,110 @@
+import { useEffect as e, useRef as t, useState as n } from "react";
+import { jsx as r, jsxs as i } from "react/jsx-runtime";
+import "maplibre-gl/dist/maplibre-gl.css";
+import { Map as a, Marker as o, setWorkerUrl as s } from "maplibre-gl";
+import c from "maplibre-gl/dist/maplibre-gl-worker.mjs?url";
+//#region src/widgets/geo-map.tsx
+s(c);
+var l = "https://tiles.openfreemap.org/styles/liberty", u = {
+	lat: 20,
+	lng: 0
+};
+function d({ label: s, point: c, center: d, zoom: p, disabled: m, onChange: h }) {
+	let g = t(null), _ = t(null), v = t(null), y = t(h), [b, x] = n(!1), [S, C] = n("");
+	return e(() => {
+		y.current = h;
+	}), e(() => {
+		if (!g.current) return;
+		let e = c ?? d ?? u, t;
+		try {
+			t = new a({
+				container: g.current,
+				style: l,
+				center: [e.lng, e.lat],
+				zoom: p ?? (c || d ? 13 : 1),
+				attributionControl: { compact: !0 },
+				keyboard: !1
+			});
+		} catch {
+			Promise.resolve().then(() => {
+				x(!0);
+			});
+			return;
+		}
+		t.on("error", () => {
+			x(!0);
+		}), t.getCanvas().setAttribute("tabindex", "-1"), t.getCanvas().setAttribute("aria-hidden", "true"), _.current = t;
+		let n = document.createElement("button");
+		n.type = "button", n.className = "vesper-map-pin", n.setAttribute("aria-label", `${s} pin. Use the arrow keys to move it.`);
+		let r = new o({
+			element: n,
+			draggable: !m
+		}).setLngLat([e.lng, e.lat]).addTo(t);
+		v.current = r;
+		let i = (e, t) => {
+			let n = {
+				lat: f(e.lat),
+				lng: f(e.lng)
+			};
+			r.setLngLat([n.lng, n.lat]), y.current(n), t && C(`Latitude ${String(n.lat)}, longitude ${String(n.lng)}.`);
+		};
+		return r.on("dragend", () => {
+			let { lat: e, lng: t } = r.getLngLat();
+			i({
+				lat: e,
+				lng: t
+			}, !0);
+		}), t.on("click", (e) => {
+			m || i({
+				lat: e.lngLat.lat,
+				lng: e.lngLat.lng
+			}, !0);
+		}), n.addEventListener("keydown", (e) => {
+			let n = {
+				ArrowUp: [1, 0],
+				ArrowDown: [-1, 0],
+				ArrowRight: [0, 1],
+				ArrowLeft: [0, -1]
+			}[e.key];
+			if (!n || m) return;
+			e.preventDefault();
+			let a = 360 / 2 ** t.getZoom() / 512 * 20 * (e.shiftKey ? 10 : 1), { lat: o, lng: s } = r.getLngLat(), c = {
+				lat: Math.max(-85, Math.min(85, o + n[0] * a)),
+				lng: (s + n[1] * a + 540) % 360 - 180
+			};
+			i(c, !0), t.panTo([c.lng, c.lat]);
+		}), () => {
+			r.remove(), t.remove(), _.current = null, v.current = null;
+		};
+	}, []), e(() => {
+		if (!c || !v.current) return;
+		let e = v.current.getLngLat();
+		(e.lat !== c.lat || e.lng !== c.lng) && (v.current.setLngLat([c.lng, c.lat]), _.current?.panTo([c.lng, c.lat]));
+	}, [c]), /* @__PURE__ */ i("div", {
+		className: "flex flex-col gap-2",
+		children: [
+			/* @__PURE__ */ r("div", {
+				ref: g,
+				className: "h-64 w-full overflow-hidden rounded-md border border-border-strong"
+			}),
+			b && /* @__PURE__ */ r("p", {
+				className: "text-small text-content-muted",
+				children: "The map couldn’t load (it needs an internet connection). The number fields above work without it."
+			}),
+			/* @__PURE__ */ r("p", {
+				className: "text-small text-content-muted",
+				children: "Drag the pin, click the map, or focus the pin and use the arrow keys."
+			}),
+			/* @__PURE__ */ r("p", {
+				role: "status",
+				className: "sr-only",
+				children: S
+			})
+		]
+	});
+}
+function f(e) {
+	return Math.round(e * 1e6) / 1e6;
+}
+//#endregion
+export { d as default };

package/dist/github/GitHubGate.d.ts

@@ -0,0 +1,15 @@
+import type { StudioOptions } from '../types.ts';
+import { type GitHubStudioSettings } from './session.ts';
+type GateOptions = Omit<StudioOptions, 'api' | 'github' | 'account' | 'cloud'>;
+export declare function GitHubGate({ settings, options, fetcher, }: {
+    settings: GitHubStudioSettings;
+    options: GateOptions;
+    fetcher?: typeof fetch;
+}): import("react").JSX.Element;
+/**
+ * GitHub's picture at a size (`s`), or nothing when GitHub gave no address.
+ * It loads from GitHub's image host, which GitHub mode already trusts with
+ * every read and save (DECISIONS.md, "GitHub mode loads the editor's picture from GitHub").
+ */
+export declare function avatarAt(address: string, size: number): string;
+export {};

package/dist/github/api.d.ts

@@ -0,0 +1,20 @@
+import { type BlobCache, type Manifest, type UrlEntry } from '@vespercms/core';
+import { type StudioApi } from '../app/api.ts';
+import type { GitHubStudioSettings } from './session.ts';
+export type GitHubApiOptions = {
+    settings: GitHubStudioSettings;
+    /** The current token. */
+    token: () => string;
+    manifest: Manifest;
+    loadMdxProps: () => Promise<Readonly<Record<string, unknown>>>;
+    loadUrlFunctions?: () => Promise<Readonly<Record<string, (entry: UrlEntry) => unknown>>>;
+    /** The site's static routes at build, for collision checks. */
+    routes?: readonly (readonly [string, string])[];
+    cache?: BlobCache;
+    /** Called when GitHub says the sign-in has expired. */
+    onExpired?: () => void;
+    fetch?: typeof fetch;
+};
+export declare function createGitHubApi(options: GitHubApiOptions): StudioApi;
+/** GitHub's errors as the studio shows them: plain words, and a status the screens understand. */
+export declare function apiError(error: unknown, onExpired?: () => void): unknown;

package/dist/github/cache.d.ts

@@ -0,0 +1,2 @@
+import type { BlobCache } from '@vespercms/core';
+export declare function indexedDbCache(): BlobCache;

package/dist/github/session.d.ts

@@ -0,0 +1,35 @@
+/** GitHub mode's settings, as the build writes them into the studio. */
+export type GitHubStudioSettings = {
+    owner: string;
+    repo: string;
+    branch: string;
+    /** The site's folder inside the repository. */
+    root: string;
+    /** The OAuth relay's address. */
+    relay: string;
+    /** GitHub Enterprise Server's API, or a test double; GitHub's own when absent. */
+    apiUrl?: string;
+    /** The site's schemas built for the browser. */
+    schemas: string;
+};
+export type Session = {
+    token: string;
+    expiresAt: number;
+};
+export declare function readSession(): Session | null;
+export declare function signOut(): void;
+/** Goes to the relay, then GitHub. `route` is the studio's hash route to come back to. */
+export declare function startSignIn(settings: GitHubStudioSettings, route: string): Promise<void>;
+export type Finished = {
+    ok: true;
+    session: Session;
+    route: string;
+} | {
+    ok: false;
+    message: string;
+};
+/**
+ * Finishes a sign-in when GitHub sent the browser back here, or returns
+ * null when it didn't. The code leaves the address either way.
+ */
+export declare function finishSignIn(settings: GitHubStudioSettings, fetcher?: typeof fetch): Promise<Finished | null>;

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export { mountStudio } from './mount.tsx';
+export { createLocalApi, ApiError, STUDIO_HEADER, type StudioApi } from './app/api.ts';
+export type { StudioOptions, WidgetProps, WidgetComponent, WidgetLoader } from './types.ts';

package/dist/markdown-4fVeej3c.js

@@ -0,0 +1,211 @@
+import { B as e, V as t, ht as n, n as r, x as i, z as a } from "./shortcuts-CarKeDqp.js";
+import { LinkDialog as o, n as s, t as c } from "./BodyEditor-_mkh0BSQ.js";
+import { useEffect as l, useRef as u, useState as d } from "react";
+import { Fragment as f, jsx as p, jsxs as m } from "react/jsx-runtime";
+import { Extension as h } from "@tiptap/core";
+import { Markdown as g } from "@tiptap/markdown";
+import { EditorContent as _, useEditor as v, useEditorState as y } from "@tiptap/react";
+import b from "@tiptap/starter-kit";
+//#region src/widgets/markdown.tsx
+var x = /* @__PURE__ */ new Set([
+	"doc",
+	"paragraph",
+	"text",
+	"hardBreak",
+	"bulletList",
+	"orderedList",
+	"listItem"
+]), S = /* @__PURE__ */ new Set([
+	"doc",
+	"paragraph",
+	"text",
+	"hardBreak"
+]);
+function C(e, t = /* @__PURE__ */ new Set()) {
+	e.type && t.add(e.type);
+	for (let n of e.content ?? []) C(n, t);
+	return t;
+}
+var w = /* @__PURE__ */ new Set([
+	"space",
+	"paragraph",
+	"text",
+	"escape",
+	"strong",
+	"em",
+	"codespan",
+	"link",
+	"br"
+]), T = /* @__PURE__ */ new Set([
+	...w,
+	"list",
+	"list_item"
+]), E = /\[\^|&(?!(?:lt|gt|quot|amp);)[A-Za-z][A-Za-z0-9]*;/;
+function D(e, t) {
+	return e.every((e) => t.has(e.type ?? "") && !(e.type === "text" && !e.tokens && E.test(e.raw ?? "")) && D(e.tokens ?? [], t) && D(e.items ?? [], t));
+}
+function O(e, t, n) {
+	try {
+		if (!D(e.instance.lexer(t), n ? w : T)) return !1;
+		let r = e.parse(t), i = n ? S : x;
+		if (![...C(r)].every((e) => i.has(e)) || n && (r.content?.length ?? 0) > 1) return !1;
+		let a = e.parse(e.serialize(r));
+		return JSON.stringify(a) === JSON.stringify(r);
+	} catch {
+		return !1;
+	}
+}
+function k(x) {
+	let { value: S, onChange: C, field: w, id: T, describedBy: E, invalid: D, disabled: k } = x, A = w.widgetOptions?.inline === !0, [j, M] = d(!1), [N, P] = d(!1), F = u(C);
+	l(() => {
+		F.current = C;
+	});
+	let I = u(null), [L] = d(() => h.create({
+		name: "vesperCompactKeys",
+		addKeyboardShortcuts() {
+			return {
+				"Mod-k": () => (P(!0), !0),
+				Escape: () => (I.current?.querySelector("button")?.focus(), !0),
+				...A ? {
+					Enter: () => !0,
+					"Shift-Enter": () => !0
+				} : {}
+			};
+		}
+	})), R = v({
+		immediatelyRender: !0,
+		shouldRerenderOnTransaction: !1,
+		editable: !k,
+		extensions: [
+			b.configure({
+				heading: !1,
+				blockquote: !1,
+				codeBlock: !1,
+				horizontalRule: !1,
+				strike: !1,
+				underline: !1,
+				trailingNode: !1,
+				...A ? {
+					bulletList: !1,
+					orderedList: !1,
+					listItem: !1,
+					listKeymap: !1
+				} : {},
+				link: {
+					openOnClick: !1,
+					autolink: !0,
+					defaultProtocol: "https"
+				}
+			}),
+			g,
+			L
+		],
+		editorProps: {
+			handleScrollToSelection: (e) => c(e, I.current),
+			attributes: {
+				id: T,
+				role: "textbox",
+				"aria-multiline": A ? "false" : "true",
+				"aria-labelledby": `${T}-label`,
+				"aria-describedby": [E, `${T}-md`].filter(Boolean).join(" "),
+				...D ? { "aria-invalid": "true" } : {},
+				...w.required ? { "aria-required": "true" } : {},
+				class: n("vesper-body w-full px-3 py-2 text-body text-content outline-none", A ? "min-h-10" : "min-h-24")
+			}
+		},
+		onCreate: ({ editor: e }) => {
+			let t = typeof S == "string" ? S : "", n = e.markdown;
+			t !== "" && !O(n, t, A) ? M(!0) : e.commands.setContent(n.parse(t), { emitUpdate: !1 });
+		},
+		onUpdate: ({ editor: e }) => {
+			let t = e.getMarkdown().trim();
+			F.current(t === "" && !w.required ? void 0 : t);
+		}
+	}), z = y({
+		editor: R,
+		selector: ({ editor: e }) => ({
+			bold: e.isActive("bold"),
+			italic: e.isActive("italic"),
+			code: e.isActive("code"),
+			link: e.isActive("link")
+		})
+	});
+	return j ? /* @__PURE__ */ m(f, { children: [/* @__PURE__ */ p("textarea", {
+		id: T,
+		rows: A ? 2 : 5,
+		value: typeof S == "string" ? S : "",
+		onChange: (e) => {
+			C(e.target.value === "" && !w.required ? void 0 : e.target.value);
+		},
+		"aria-describedby": [E, `${T}-md`].filter(Boolean).join(" "),
+		"aria-invalid": D || void 0,
+		"aria-required": w.required || void 0,
+		disabled: k,
+		className: n(i, "resize-y font-mono text-small")
+	}), /* @__PURE__ */ p("p", {
+		id: `${T}-md`,
+		className: "text-small text-content-muted",
+		children: "This uses Markdown the compact editor can’t show, so it’s edited as text."
+	})] }) : /* @__PURE__ */ m("div", {
+		className: "flex flex-col gap-2",
+		children: [
+			/* @__PURE__ */ m("div", {
+				className: n("rounded-md border border-border-strong bg-surface-raised", D && "border-danger", k && "opacity-60", "has-[.ProseMirror-focused]:outline-2 has-[.ProseMirror-focused]:outline-solid has-[.ProseMirror-focused]:outline-offset-2 has-[.ProseMirror-focused]:outline-focus", "has-[.ProseMirror-focused]:ring-6 has-[.ProseMirror-focused]:ring-(color:--glow-focus)"),
+				children: [/* @__PURE__ */ p("div", {
+					ref: I,
+					className: s,
+					children: /* @__PURE__ */ m(t, {
+						label: `Formatting for ${w.label}`,
+						children: [
+							/* @__PURE__ */ p(a, {
+								icon: "bold",
+								label: "Bold",
+								shortcut: r("Mod", "B"),
+								isDisabled: k,
+								isSelected: z.bold,
+								onChange: () => R.chain().focus().toggleBold().run()
+							}),
+							/* @__PURE__ */ p(a, {
+								icon: "italic",
+								label: "Italic",
+								shortcut: r("Mod", "I"),
+								isDisabled: k,
+								isSelected: z.italic,
+								onChange: () => R.chain().focus().toggleItalic().run()
+							}),
+							/* @__PURE__ */ p(a, {
+								icon: "code",
+								label: "Code",
+								shortcut: r("Mod", "E"),
+								isDisabled: k,
+								isSelected: z.code,
+								onChange: () => R.chain().focus().toggleCode().run()
+							}),
+							/* @__PURE__ */ p(e, {
+								icon: "link",
+								label: z.link ? "Edit link" : "Link",
+								shortcut: r("Mod", "K"),
+								isDisabled: k,
+								onPress: () => {
+									P(!0);
+								}
+							})
+						]
+					})
+				}), /* @__PURE__ */ p(_, { editor: R })]
+			}),
+			/* @__PURE__ */ p("p", {
+				id: `${T}-md`,
+				className: "text-small text-content-muted",
+				children: "Saved as Markdown. Escape moves to the formatting buttons."
+			}),
+			/* @__PURE__ */ p(o, {
+				editor: R,
+				isOpen: N,
+				onOpenChange: P
+			})
+		]
+	});
+}
+//#endregion
+export { k as MarkdownWidget };

package/dist/media/MediaPicker.d.ts

@@ -0,0 +1,28 @@
+import { type UploadStep } from './upload.ts';
+export type MediaPickerProps = {
+    isOpen: boolean;
+    onOpenChange: (open: boolean) => void;
+    kind: 'image' | 'file';
+    /** File extensions a file field accepts, lower case without dots. Empty for any. */
+    extensions?: readonly string[];
+    /** Where a new upload goes, site-relative. */
+    folder: string;
+    /** Called with the chosen file's site-relative path, and what hygiene did to a new upload. */
+    onChoose: (path: string, notes?: readonly string[]) => void;
+};
+/**
+ * Choose a file: upload a new one (after hygiene and a duplicate check) or
+ * pick one already in the site. One dialog, two plain sections.
+ */
+export declare function MediaPicker({ isOpen, onOpenChange, kind, extensions, folder, onChoose, }: MediaPickerProps): import("react").JSX.Element;
+export declare function UploadStatus({ step, onUpload, onReuse, onCancel, }: {
+    step: UploadStep | {
+        step: 'working';
+        text: string;
+    } | null;
+    onUpload: (ready: Extract<UploadStep, {
+        upload: unknown;
+    }>) => void;
+    onReuse: (path: string) => void;
+    onCancel: () => void;
+}): import("react").JSX.Element | null;

package/dist/media/file-icon.d.ts

@@ -0,0 +1,3 @@
+import type { IconName } from '@vespercms/ui';
+/** The icon for a file that isn't an image, by its extension; a plain page when unknown. */
+export declare function fileIcon(extension: string): IconName;

package/dist/media/formats.d.ts

@@ -0,0 +1,23 @@
+export type DetectedType = 'jpeg' | 'png' | 'gif' | 'webp' | 'avif' | 'heic' | 'svg' | 'pdf' | 'other';
+/** What a file is, from its first bytes rather than its name. */
+export declare function detectType(bytes: Uint8Array): DetectedType;
+export type ImageFacts = {
+    width?: number;
+    height?: number;
+    /** EXIF orientation, 1–8. 1 (or absent) means the pixels are already upright. */
+    orientation?: number;
+    /** EXIF GPS data is present. */
+    hasLocation: boolean;
+    /** Any metadata a lossless strip would remove. */
+    hasMetadata: boolean;
+};
+export declare function jpegFacts(bytes: Uint8Array): ImageFacts;
+/** The same JPEG without EXIF, XMP, IPTC or comments. The image data is untouched. */
+export declare function stripJpeg(bytes: Uint8Array): Uint8Array;
+export declare function pngFacts(bytes: Uint8Array): ImageFacts;
+/** The same PNG without text, time or EXIF chunks. */
+export declare function stripPng(bytes: Uint8Array): Uint8Array;
+export declare function webpFacts(bytes: Uint8Array): ImageFacts;
+/** The same WebP without EXIF or XMP, with the header flags and size fixed up. */
+export declare function stripWebp(bytes: Uint8Array): Uint8Array;
+export declare function imageFacts(type: DetectedType, bytes: Uint8Array): ImageFacts;