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

package/dist/media/hygiene.d.ts

@@ -0,0 +1,37 @@
+import { type DetectedType } from './formats.ts';
+export type PreparedUpload = {
+    bytes: Uint8Array;
+    name: string;
+    type: DetectedType;
+    /** What hygiene did, in words, for the editor ("Removed location data"). */
+    notes: string[];
+    /** Larger than the warning size: the editor confirms before uploading. */
+    large: boolean;
+    width?: number;
+    height?: number;
+};
+export type PrepareResult = {
+    ok: true;
+    upload: PreparedUpload;
+} | {
+    ok: false;
+    message: string;
+};
+export type HygieneOptions = {
+    maxEdge?: number;
+    /** Only images are accepted (an image field), or anything (a file field). */
+    accept?: 'image' | 'any';
+};
+export declare function prepareUpload(file: File, options?: HygieneOptions): Promise<PrepareResult>;
+export declare function megabytes(n: number): string;
+/** "812 bytes", "48 KB", "3.2 MB". */
+export declare function fileSize(n: number): string;
+/**
+ * Removes anything that can run or navigate: scripts, event handlers,
+ * javascript: and data: links, embedded HTML, and animations that rewrite
+ * links or handlers. Drawing content is kept as it was.
+ */
+export declare function sanitizeSvg(svg: string): {
+    svg: string;
+    removed: boolean;
+};

package/dist/media/upload.d.ts

@@ -0,0 +1,31 @@
+import { type MediaItem } from '@vespercms/core';
+import type { StudioApi } from '../app/api.ts';
+import { type HygieneOptions, type PreparedUpload } from './hygiene.ts';
+export type UploadStep = {
+    step: 'refused';
+    message: string;
+}
+/** The same bytes are already in the site: reuse that file, or upload a copy. */
+ | {
+    step: 'duplicate';
+    upload: PreparedUpload;
+    existing: string;
+}
+/** Large after processing: the editor confirms first. */
+ | {
+    step: 'confirm-large';
+    upload: PreparedUpload;
+} | {
+    step: 'ready';
+    upload: PreparedUpload;
+};
+export declare function checkUpload(file: File, media: readonly MediaItem[], options: HygieneOptions): Promise<UploadStep>;
+export declare function sendUpload(api: StudioApi, upload: PreparedUpload, folder: string, options?: {
+    withNextSave?: boolean;
+}): Promise<{
+    ok: true;
+    path: string;
+} | {
+    ok: false;
+    message: string;
+}>;

package/dist/mount.d.ts

@@ -0,0 +1,3 @@
+import type { StudioOptions } from './types.ts';
+/** Renders the studio into `element`. Returns a function that unmounts it. */
+export declare function mountStudio(element: Element, options: StudioOptions): () => void;

package/dist/pdf-m5s_uXJ3.js

@@ -0,0 +1,24 @@
+import { GlobalWorkerOptions as e, getDocument as t } from "pdfjs-dist/legacy/build/pdf.mjs";
+import n from "pdfjs-dist/legacy/build/pdf.worker.min.mjs?url";
+//#region src/a11y/pdf.ts
+e.workerSrc = n;
+async function r(e) {
+	let n = t({
+		data: e instanceof Uint8Array ? e : new Uint8Array(e),
+		enableXfa: !1,
+		disableFontFace: !0,
+		verbosity: 0
+	});
+	try {
+		let e = await n.promise, [t, r] = await Promise.all([e.getMarkInfo(), e.getMetadata()]), i = e.numPages > 0 ? await (await e.getPage(1)).getStructTree() : null, a = r.info, o = r.metadata?.get("dc:title"), s = (e) => typeof e == "string" && e.trim() !== "" ? e.trim() : null;
+		return {
+			tagged: (t instanceof Map ? t.get("Marked") : t?.Marked) === !0 && i !== null,
+			title: s(a.Title) ?? s(o),
+			language: s(a.Language)
+		};
+	} finally {
+		await n.destroy();
+	}
+}
+//#endregion
+export { r as readPdfFacts };

package/dist/run-y4XRkg17.js

@@ -0,0 +1,7 @@
+import { entryChecker as e, pdfNotes as t } from "@vespercms/core";
+//#region src/a11y/run.ts
+function n(t) {
+	return e(t);
+}
+//#endregion
+export { n as a11yChecker, t as pdfNotes };

package/dist/schedule/ScheduleDialog.d.ts

@@ -0,0 +1,28 @@
+import { type CollectionManifest } from '@vespercms/core';
+import { type ScheduleTimes } from './times.ts';
+export type ScheduleDialogProps = {
+    isOpen: boolean;
+    onOpenChange: (open: boolean) => void;
+    collection: CollectionManifest;
+    initial: ScheduleTimes;
+    /** Already live: only when it comes down can be set (call 8). */
+    live: boolean;
+    /**
+     * `publish`: Schedule… from Publish ▾, which saves or publishes with the
+     * times. `set`: Change schedule… from Details, which only sets them.
+     */
+    purpose: 'publish' | 'set';
+    /** What going live without a time is called here: "Publish now", or "Save now" in local mode. */
+    nowLabel: string;
+    onSubmit: (times: ScheduleTimes) => void;
+    /** Goes live now instead, when the chosen time has passed. */
+    onNow?: () => void;
+};
+export declare function ScheduleDialog(props: ScheduleDialogProps): import("react").JSX.Element;
+/**
+ * What a daylight-saving change does to a wall time: a skipped one moves
+ * forward ("2:30 AM doesn't happen on Sun, Mar 14; this is 3:30 AM."), and
+ * a repeated one is the first ("1:30 AM happens twice that night; this is
+ * the first, EDT.").
+ */
+export declare function dstNote(wall: string, zone: string, now: Date): string | null;

package/dist/schedule/ScheduleSummary.d.ts

@@ -0,0 +1,12 @@
+import { type CollectionManifest, type DataObject } from '@vespercms/core';
+/**
+ * The schedule in Details (spec §6.17), in place of its raw fields: "Goes
+ * live Sat, Oct 31, 8:00 AM · Comes down Sun, Nov 8, 12:00 AM", in the site's
+ * zone, and Change schedule… to set the times in the Schedule dialog.
+ */
+export declare function ScheduleSummary({ collection, values, zone, onChange, }: {
+    collection: CollectionManifest;
+    values: DataObject;
+    zone: string;
+    onChange: () => void;
+}): import("react").JSX.Element;

package/dist/schedule/ScheduledView.d.ts

@@ -0,0 +1,8 @@
+export declare function ScheduledView(): import("react").JSX.Element;
+/**
+ * "3 scheduled changes", linking to the Scheduled view: on Home, and among
+ * panes at the top of the collections. Absent when nothing is scheduled.
+ */
+export declare function ScheduledLine({ className }: {
+    className?: string;
+}): import("react").JSX.Element | null;

package/dist/schedule/cloud.d.ts

@@ -0,0 +1,21 @@
+import type { CloudScheduledEvent, ScheduleResponse } from '@vespercms/core';
+/** The cloud's own word on a change in the files, matched by file, change and instant. */
+export declare function cloudEventOf(schedule: ScheduleResponse | undefined, change: {
+    path: string;
+    change: 'publish' | 'unpublish';
+    at: string;
+}): CloudScheduledEvent | undefined;
+/**
+ * Where a change still to come stands, in words: "Waiting in Vesper until
+ * 8:00 AM" for held drafts, "Rebuild at 8:00 AM" with a trigger, and "Next
+ * build after 8:00 AM" without one.
+ */
+export declare function cloudStateWords(schedule: ScheduleResponse, event: CloudScheduledEvent | undefined, at: Date, zone: string): string;
+/**
+ * True when the cloud keeps the time exactly: it asks for a rebuild then,
+ * or it publishes held drafts then, which starts the host's build. Only the
+ * publish waits in the cloud; a time to come down is a plain field.
+ */
+export declare function cloudKeepsTime(schedule: ScheduleResponse | undefined, change: 'publish' | 'unpublish'): boolean;
+/** When the cloud should hold a draft rather than publish it: the site holds, and its time is still to come. */
+export declare function holdUntil(schedule: ScheduleResponse | undefined, publishAt: Date | undefined, now?: Date): Date | null;

package/dist/schedule/now.d.ts

@@ -0,0 +1,5 @@
+/**
+ * The time, again each minute, so words that depend on it ("Scheduled ·
+ * …") change on their own once a time passes, and a render stays pure.
+ */
+export declare function useNow(): Date;

package/dist/schedule/times.d.ts

@@ -0,0 +1,35 @@
+import { type CollectionManifest, type DataObject, type Manifest, type SchedulePresentation } from '@vespercms/core';
+/** When an entry goes live and comes down, and where its page sends visitors after. */
+export type ScheduleTimes = {
+    publishAt?: Date;
+    unpublishAt?: Date;
+    redirect?: string;
+};
+/** The site's zone, for showing and entering times, or the viewer's own when it has none. */
+export declare function siteZone(manifest: Manifest): {
+    zone: string;
+    isSite: boolean;
+};
+/** The field that holds where visitors go after, when the collection's schema has one. */
+export declare function redirectField(collection: CollectionManifest): string | null;
+/** The schedule's field names, the redirect's when the schema has it. */
+export declare function scheduleKeys(collection: CollectionManifest): string[];
+export declare function timesOf(collection: CollectionManifest, values: DataObject): ScheduleTimes;
+/**
+ * The values with these times in place of the old ones: a time left out is
+ * removed. A time stored as a quoted string stays a string, with its offset
+ * written out, as the date-time field keeps it.
+ */
+export declare function withTimes(collection: CollectionManifest, values: DataObject, times: ScheduleTimes): DataObject;
+/** An entry row's schedule (ISO times) as values under the schedule's field names. */
+export declare function rowData(schedule: SchedulePresentation | undefined, times: {
+    publishAt?: string;
+    unpublishAt?: string;
+} | undefined): DataObject;
+/** Whether a row has a change still to come: it goes live or comes down later. */
+export declare function hasUpcoming(times: {
+    publishAt?: string;
+    unpublishAt?: string;
+} | undefined, now?: Date): boolean;
+/** "every hour", "every 15 minutes", "every 2 hours". */
+export declare function everyText(minutes: number): string;

package/dist/screens/EntryEditor.d.ts

@@ -0,0 +1,13 @@
+import { type CollectionManifest } from '@vespercms/core';
+/**
+ * Opens an entry (or starts a new one when `id` is null) and hands it to the
+ * form. A reload after a conflict remounts the form with the new version.
+ * With `copy`, the entry is the original of a new one (Duplicate).
+ */
+export declare function EntryEditor({ collection, id, parent, copy, }: {
+    collection: CollectionManifest;
+    id: string | null;
+    /** New pages in a tree collection: the parent page's path (spec §6.15.2). */
+    parent?: string;
+    copy?: boolean;
+}): import("react").JSX.Element;

package/dist/screens/EntryList.d.ts

@@ -0,0 +1,16 @@
+import { type CollectionManifest, type EntrySummary } from '@vespercms/core';
+import type { SortDescriptor } from 'react-aria-components';
+/**
+ * A collection's entries (spec §10.3): one row per entry with its title,
+ * the collection's list fields, when it was edited, and its status in
+ * words. One search box and one status filter; sort by column header.
+ */
+export declare function EntryList({ collection }: {
+    collection: CollectionManifest;
+}): import("react").JSX.Element;
+export declare const TITLE_KEYS: Set<string>;
+/** A list field's value as short text. Dates at midnight UTC are calendar dates. */
+export declare function formatListValue(encoded: unknown): string;
+export declare function labelFor(collection: CollectionManifest, key: string): string;
+export declare function defaultSort(collection: CollectionManifest): SortDescriptor;
+export declare function compareBy(sort: SortDescriptor): (a: EntrySummary, b: EntrySummary) => number;

package/dist/screens/Home.d.ts

@@ -0,0 +1,6 @@
+/**
+ * The home screen (spec §10.3): a plain list of collections and singletons,
+ * with entry counts and when each was last edited. Nothing else. One screen
+ * at a time only: among panes, the structure pane lists them (app/panes.tsx).
+ */
+export declare function Home(): import("react").JSX.Element;

package/dist/screens/ListPane.d.ts

@@ -0,0 +1,6 @@
+import type { CollectionManifest } from '@vespercms/core';
+export declare function ListPane({ collection, currentId, }: {
+    collection: CollectionManifest;
+    /** The entry open beside the list, or null. */
+    currentId: string | null;
+}): import("react").JSX.Element;

package/dist/screens/MediaBrowser.d.ts

@@ -0,0 +1,7 @@
+/**
+ * The media browser (spec §6.6.6): every image and file in the site's
+ * assets folders, with where each is used. Search by name, filter by
+ * folder, and an "Unused" view for cleaning up. Deleting is confirmed, and
+ * only possible for files nothing uses.
+ */
+export declare function MediaBrowser(): import("react").JSX.Element;

package/dist/screens/NotFound.d.ts

@@ -0,0 +1,3 @@
+export declare function NotFound({ message, }: {
+    message?: string;
+}): import("react").JSX.Element;

package/dist/screens/PageTree.d.ts

@@ -0,0 +1,10 @@
+import type { CollectionManifest, MoveResult } from '@vespercms/core';
+export declare function PageTree({ collection, currentId, }: {
+    collection: CollectionManifest;
+    /** The page open beside the outline, among panes. */
+    currentId?: string | null;
+}): import("react").JSX.Element;
+/** The confirmation's words (spec §6.15.4): what moves, what changes with it. */
+export declare function planText(plan: Extract<MoveResult, {
+    ok: true;
+}>): string;

package/dist/screens/Redirects.d.ts

@@ -0,0 +1 @@
+export declare function Redirects(): import("react").JSX.Element;

package/dist/screens/Unavailable.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Shown when this build of the studio has no storage back end: a deployed
+ * site before GitHub mode (Phase 3) exists. It's outside the studio context,
+ * so it draws its own landmarks.
+ */
+export declare function Unavailable({ siteName }: {
+    siteName: string;
+}): import("react").JSX.Element;

package/dist/screens/status.d.ts

@@ -0,0 +1,36 @@
+import { type CollectionManifest, type DataValue, type Draft, type EntryStatus } from '@vespercms/core';
+import { type StatusTone } from '@vespercms/ui';
+export type EntryState = {
+    tone: StatusTone;
+    /** "Draft", "Scheduled", "Live" or "Unpublished". */
+    word: string;
+    /** What follows the word, its joiner included: " · Sat, Oct 31, 8:00 AM". */
+    rest: string;
+};
+/**
+ * What an entry is now. `times` is the entry's data with its schedule's
+ * fields, or null where they aren't known (a page tree's rows), which then
+ * never claims Live. Live is said only where an entry could be something
+ * else: a collection with a schedule or a `draft` field, or any in the cloud,
+ * where a new entry starts as a draft. Elsewhere every entry is live, and
+ * saying so on every row would only be noise.
+ */
+export declare function entryState(collection: CollectionManifest, entry: {
+    draft: boolean;
+    times: DataValue | null;
+    newDraft?: boolean;
+}, options: {
+    zone: string;
+    cloud: boolean;
+    now?: Date;
+}): EntryState | null;
+/** Whether a file is in a draft that would create it: in the cloud, an entry never published. */
+export declare function isNewInDraft(drafts: readonly Draft[], path: string | undefined): boolean;
+/** "Read only" or "Edit as YAML": what can be done with the entry, after its state. */
+export declare function kindText(status: EntryStatus | undefined): string;
+/** The state as plain words, for names and type-ahead. */
+export declare function stateText(state: EntryState | null): string;
+/** The state's word on its colour, then the words after it as text. */
+export declare function StateWords({ state }: {
+    state: EntryState | null;
+}): import("react").JSX.Element | null;