@p10node/office-engine 0.1.0 → 0.2.0

package/dist/office-engine.worker.js

@@ -344,7 +344,7 @@ async function ce(e, t, n = "application/zip") {
 		let n = await ae(oe(t)), { time: r, date: i } = se();
 		l(e, 8, n.crc, n.csize, n.size, r, i, n.chunks);
 	};
-	for (let t of e.list()) {
+	for (let t of e?.list() ?? []) {
 		let n = E(t.name), r = c.get(n);
 		if (r) {
 			c.delete(n), r.data !== null && await u(t.name, r.data);
@@ -6222,7 +6222,7 @@ var Wa = (e, t) => `${e}:${t}`, Ga = class {
 				let a = this.sheetIndex(n, this.cur);
 				if (a < 0) return new I("#REF!");
 				let o = Wa(a, r * Q + i);
-				return e.has(o) && this.compute(o, e, t), this.value(a, r, i);
+				return t.has(o) ? new I("#REF!") : (e.has(o) && this.compute(o, e, t), this.value(a, r, i));
 			},
 			bounds: (e) => {
 				let t = this.wb.sheetsData.get(this.sheetIndex(e, this.cur));
@@ -7479,6 +7479,7 @@ var zo = class {
 	root;
 	P;
 	cache = /* @__PURE__ */ new Map();
+	found = /* @__PURE__ */ new Map();
 	changed = !1;
 	constructor(e) {
 		this.nodes = t(e), this.root = a(this.nodes), this.P = i(this.root.q);
@@ -7493,6 +7494,23 @@ var zo = class {
 		let r = o(n).length;
 		return u(n, "count", String(r)), this.changed = !0, r - 1;
 	}
+	lookup(e) {
+		let t = this.found.get(e);
+		if (!t) {
+			let r = /* @__PURE__ */ new Map();
+			o(s(this.root, e)).forEach((e, t) => {
+				let i = n([e]);
+				r.has(i) || r.set(i, t);
+			}), this.found.set(e, t = r);
+		}
+		return t;
+	}
+	intern(e, t) {
+		let r = n([t]), i = this.lookup(e), a = i.get(r);
+		if (a !== void 0) return a;
+		let o = this.append(e, t);
+		return i.set(r, o), o;
+	}
 	numFmtId(e) {
 		for (let [t, n] of Object.entries(qa)) if (n === e) return Number(t);
 		let t = s(this.root, "numFmts"), n = 163;
@@ -7525,13 +7543,13 @@ var zo = class {
 			"font"
 		].some((e) => e in n)) {
 			let e = o(this.section("fonts"), "font"), t = f(e[Number(l(p, "fontId") ?? 0)] ?? e[0] ?? d(a + "font")), r = (e, n) => m(t, n, e, Mo);
-			n.b !== void 0 && r("b", n.b ? d(a + "b") : void 0), n.i !== void 0 && r("i", n.i ? d(a + "i") : void 0), n.strike !== void 0 && r("strike", n.strike ? d(a + "strike") : void 0), n.u !== void 0 && r("u", n.u ? d(a + "u") : void 0), n.sz !== void 0 && r("sz", d(a + "sz", { val: String(n.sz) })), "color" in n && r("color", n.color ? d(a + "color", { rgb: "FF" + n.color.replace("#", "").toUpperCase() }) : void 0), n.font && (r("name", d(a + "name", { val: n.font })), r("scheme", void 0)), u(p, "fontId", String(this.append("fonts", t))), u(p, "applyFont", "1");
+			n.b !== void 0 && r("b", n.b ? d(a + "b") : void 0), n.i !== void 0 && r("i", n.i ? d(a + "i") : void 0), n.strike !== void 0 && r("strike", n.strike ? d(a + "strike") : void 0), n.u !== void 0 && r("u", n.u ? d(a + "u") : void 0), n.sz !== void 0 && r("sz", d(a + "sz", { val: String(n.sz) })), "color" in n && r("color", n.color ? d(a + "color", { rgb: "FF" + n.color.replace("#", "").toUpperCase() }) : void 0), n.font && (r("name", d(a + "name", { val: n.font })), r("scheme", void 0)), u(p, "fontId", String(this.intern("fonts", t))), u(p, "applyFont", "1");
 		}
 		if ("fill" in n) {
 			if (!n.fill) u(p, "fillId", "0");
 			else {
 				let e = t(`<${a}fill><${a}patternFill patternType="solid"><${a}fgColor rgb="FF${n.fill.replace("#", "").toUpperCase()}"/><${a}bgColor indexed="64"/></${a}patternFill></${a}fill>`)[0];
-				u(p, "fillId", String(this.append("fills", e)));
+				u(p, "fillId", String(this.intern("fills", e)));
 			}
 			u(p, "applyFill", "1");
 		}
@@ -7553,7 +7571,7 @@ var zo = class {
 				"top",
 				"bottom"
 			]) t in e && m(r, e[t] ? d(a + t, { style: n.borderStyle ?? "thin" }, [d(a + "color", { rgb: "FF" + i })]) : d(a + t), t, c);
-			s(r, "diagonal") || m(r, d(a + "diagonal"), "diagonal", c), u(p, "borderId", String(this.append("borders", r))), u(p, "applyBorder", "1");
+			s(r, "diagonal") || m(r, d(a + "diagonal"), "diagonal", c), u(p, "borderId", String(this.intern("borders", r))), u(p, "applyBorder", "1");
 		}
 		if ("align" in n || "wrap" in n || "valign" in n || "rotate" in n) {
 			let e = f(s(p, "alignment") ?? d(a + "alignment"));
@@ -7568,7 +7586,7 @@ var zo = class {
 			]), u(p, "applyAlignment", "1");
 		}
 		n.numFmt !== void 0 && (u(p, "numFmtId", String(this.numFmtId(n.numFmt))), u(p, "applyNumberFormat", "1"));
-		let h = this.append("cellXfs", p);
+		let h = this.intern("cellXfs", p);
 		return this.cache.set(r, h), h;
 	}
 	xml() {
@@ -7591,6 +7609,8 @@ var zo = class {
 			if (!e || r.length <= n) continue;
 			let i = new Set(r.slice(n));
 			e.c = e.c.filter((e) => !i.has(e)), u(e, "count", String(n));
+			let a = this.found.get(t);
+			if (a) for (let [e, t] of a) t >= n && a.delete(e);
 		}
 		for (let [t, n] of this.cache) n >= e.cellXfs && this.cache.delete(t);
 	}

package/dist/types/collab/compact.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Server-side snapshots: replays shared history onto a document headlessly, exactly the way a
+ * collaborator applies it, so the result can be saved as the room's new base file.
+ *
+ *   const client = await DocumentClient.open(snapshotFile, { worker: false })
+ *   const snap = await compact(client, { from: snapshotMeta, batches })
+ *   const file = await client.call('save')        // store it, then hub.snapshot(room, snap)
+ */
+import type { DocumentClient } from '../core/worker/client';
+import type { Batch, Snapshot } from './protocol';
+export interface CompactOptions {
+    /** the snapshot `client` was opened from (default: the original upload, seq 0) */
+    from?: Snapshot;
+    /** batches to apply: every batch after `from.seq`, in order (older ones are ignored) */
+    batches: Batch[];
+    /** canonical batches kept as the new snapshot's context (default 1000) */
+    window?: number;
+}
+/**
+ * Applies `batches` to `client` (opened on the file of snapshot `from`) and returns the snapshot it
+ * now holds. Save the document afterwards with `client.call('save')`.
+ */
+export declare function compact(client: DocumentClient, opts: CompactOptions): Promise<Snapshot>;

package/dist/types/collab/hub.d.ts

@@ -5,26 +5,46 @@
  *   const conn = hub.connect((msg) => socket.send(encode(msg)))
  *   socket.onmessage = (e) => conn.receive(decode(e.data))
  *   socket.onclose = () => conn.close()
+ *
+ * Snapshots (see `compact`) bound the history: register one with `hub.snapshot()` and new clients
+ * open its file and only replay the batches after it, while the hub drops older batches.
  */
-import { type Batch, type ClientMsg, type HubMsg, type PeerInfo } from './protocol';
+import { type Batch, type ClientMsg, type Entry, type HubMsg, type PeerInfo, type Snapshot } from './protocol';
 export interface RoomState {
     id: string;
     seq: number;
+    /** every batch with seq > `start`, in order */
     log: Batch[];
+    /** batches older than this were dropped (after a snapshot) */
+    start: number;
     ids: Set<string>;
     peers: Map<number, {
         info: PeerInfo;
         send: (m: HubMsg) => void;
     }>;
     nextSite: number;
+    /** snapshots clients can join from: seq → context */
+    snaps: Map<number, Entry[]>;
+}
+/** A persisted room: its latest snapshot and the batches after it (and possibly some before). */
+export interface RoomLog {
+    log: Batch[];
+    snapshot?: Snapshot & {
+        sites?: number;
+    };
 }
+type Loaded = Batch[] | RoomLog | undefined;
 export interface HubOptions {
     /** called for every sequenced batch (persist it to rebuild rooms after a restart) */
     onBatch?: (room: string, batch: Batch) => void;
-    /** rebuilds a room log (e.g. from storage) the first time the room is used */
-    loadLog?: (room: string) => Batch[] | undefined;
+    /** rebuilds a room (e.g. from storage) the first time it is used */
+    loadLog?: (room: string) => Loaded | Promise<Loaded>;
     /** called when the last peer left a room */
     onIdle?: (room: string) => void;
+    /** batches kept below the latest snapshot for clients reconnecting from older states (default 1000) */
+    retain?: number;
+    /** most recent snapshots clients can still join from (default 3) */
+    keep?: number;
 }
 export interface HubConnection {
     receive(msg: ClientMsg): void;
@@ -33,9 +53,20 @@ export interface HubConnection {
 export declare class CollabHub {
     private opts;
     readonly rooms: Map<string, RoomState>;
+    private loading;
     constructor(opts?: HubOptions);
-    room(id: string): RoomState;
+    /** the room, loaded through `loadLog` the first time */
+    room(id: string): Promise<RoomState>;
     /** forgets a room (its log and peers) — e.g. when a new base file is uploaded */
     reset(id: string): void;
+    /** drops an idle room from memory (it is loaded again on the next join); false while peers are connected */
+    unload(id: string): boolean;
+    /**
+     * Registers a snapshot of a loaded room (`compact` output, its file stored where clients can open
+     * it): clients may join from it, and batches older than `retain` below it are dropped.
+     * Returns false when the snapshot doesn't fit the room (e.g. it was reset meanwhile).
+     */
+    snapshot(id: string, snap: Snapshot): boolean;
     connect(send: (m: HubMsg) => void): HubConnection;
 }
+export {};

package/dist/types/collab/index.d.ts

@@ -19,6 +19,11 @@ export interface CollabOptions {
     /** shared document id */
     room: string;
     user: UserInfo;
+    /**
+     * Sequence number of the snapshot `src` was opened from (see `compact`); default 0, the original
+     * upload. The hub then only sends the batches after it.
+     */
+    base?: number;
 }
 export interface Collab {
     readonly session: CollabSession<unknown>;
@@ -36,8 +41,10 @@ export interface Collab {
     close(): void;
 }
 export declare function startCollab(client: DocumentClient, opts: CollabOptions): Collab;
-export { CollabHub, type HubOptions, type HubConnection } from './hub';
+export { CollabHub, type HubOptions, type HubConnection, type RoomLog, type RoomState } from './hub';
+export { compact, type CompactOptions } from './compact';
+export { RoomStore, MemoryBlobStore, type BlobStore, type RoomHead, type RoomStoreOptions, type Version } from './store';
 export { CollabSession, type Adapter, type CollabStatus } from './session';
 export { MemoryTransport, WebSocketTransport, type Transport, type TransportStatus } from './transport';
-export type { Batch, ClientMsg, HubMsg, PeerInfo, UserInfo } from './protocol';
+export type { Batch, ClientMsg, Entry, HubMsg, PeerInfo, Snapshot, UserInfo } from './protocol';
 export { encode, decode } from './codec';

package/dist/types/collab/protocol.d.ts

@@ -28,15 +28,38 @@ export interface Batch<Op = unknown> {
     /** client generated id (dedupes resends after reconnects) */
     id: string;
     ops: Op[];
+    /** when the hub sequenced it (ms since epoch) */
+    time?: number;
+    /** author: user id, else name */
+    user?: string;
+}
+/** A batch the way every client applies it: its ops transformed against the concurrent batches sequenced before it. */
+export interface Entry<Op = unknown> {
+    seq: number;
+    site: number;
+    ops: Op[];
+}
+/**
+ * The document materialized at `seq` (see `compact`): a file containing every batch up to `seq`,
+ * plus the canonical batches right before it (`ctx`) that clients joining from that file need to
+ * merge batches still based on older states.
+ */
+export interface Snapshot<Op = unknown> {
+    seq: number;
+    ctx: Entry<Op>[];
 }
 export type ClientMsg = 
-/** join a room; `have`/`site` on reconnect */
+/**
+ * join a room; `have`/`site` on reconnect. `base`: on the first join, the snapshot the client
+ * opened (default 0, the original upload)
+ */
 {
     t: 'hello';
     room: string;
     user: UserInfo;
     have?: number;
     site?: number;
+    base?: number;
 } | {
     t: 'ops';
     id: string;
@@ -47,7 +70,10 @@ export type ClientMsg =
     data: unknown;
 };
 export type HubMsg = 
-/** `log` holds every batch with seq > `from`; `reset` when the hub lost history newer than `have` */
+/**
+ * `log` holds every batch with seq > `from`; `ctx` the joined snapshot's context (first join from a
+ * snapshot); `reset` when the hub can't continue from the client's state (history lost or dropped)
+ */
 {
     t: 'welcome';
     site: number;
@@ -56,6 +82,7 @@ export type HubMsg =
     log: Batch[];
     peers: PeerInfo[];
     reset?: boolean;
+    ctx?: Entry[];
 } | {
     t: 'batch';
     b: Batch;

package/dist/types/collab/session.d.ts

@@ -14,7 +14,7 @@
  * to rebase, like deleting a sheet) are not applied locally until the hub has
  * sequenced them.
  */
-import type { PeerInfo, UserInfo } from './protocol';
+import type { Entry, PeerInfo, UserInfo } from './protocol';
 import type { Transport } from './transport';
 export interface ApplyResult {
     /** whatever `revert` needs to undo the op exactly (local ops only) */
@@ -60,6 +60,8 @@ export interface SessionOptions {
     user: UserInfo;
     /** canonical batches kept to transform late batches (default 5000) */
     logWindow?: number;
+    /** sequence number the opened file already contains: a snapshot (default 0, the original upload) */
+    base?: number;
 }
 export declare class CollabSession<Op = unknown> {
     private transport;
@@ -94,6 +96,8 @@ export declare class CollabSession<Op = unknown> {
     push(op: Op, undo: unknown): void;
     setPresence(data: unknown): void;
     on<K extends keyof SessionEvents>(event: K, fn: (d: SessionEvents[K]) => void): () => void;
+    /** the last `limit` batches as applied here (the context of a snapshot taken at `rev`) */
+    context(limit?: number): Entry<Op>[];
     /** resolves once everything queued so far was processed */
     idle(): Promise<void>;
     close(): void;

package/dist/types/collab/store.d.ts

@@ -0,0 +1,94 @@
+import type { RoomLog } from './hub';
+import type { Batch, Snapshot } from './protocol';
+/** Minimal object storage. Keys use `/` separators. */
+export interface BlobStore {
+    /** null when missing */
+    get(key: string): Promise<Uint8Array | null>;
+    put(key: string, data: Uint8Array): Promise<void>;
+    /** every key starting with `prefix` (any order) */
+    list(prefix: string): Promise<string[]>;
+    delete(key: string): Promise<void>;
+}
+export declare class MemoryBlobStore implements BlobStore {
+    readonly data: Map<string, Uint8Array<ArrayBufferLike>>;
+    get(key: string): Promise<Uint8Array<ArrayBufferLike> | null>;
+    put(key: string, data: Uint8Array): Promise<void>;
+    list(prefix: string): Promise<string[]>;
+    delete(key: string): Promise<void>;
+}
+export interface RoomHead {
+    /** changes with every upload: stale writes of an older upload are ignored */
+    epoch: string;
+    /** latest snapshot */
+    seq: number;
+    size: number;
+    name: string;
+    type: string;
+    time: number;
+}
+/** a stored snapshot */
+export interface Version {
+    seq: number;
+    size: number;
+    time: number;
+}
+export interface RoomStoreOptions {
+    /** key prefix, e.g. `collab/` */
+    prefix?: string;
+    /** batches are buffered and written as one segment at most this often (ms, default 250) */
+    flushMs?: number;
+    /** snapshots kept per room (default: all — the version history); older ones and their batches are deleted */
+    keep?: number;
+    /** batches below the latest snapshot loaded for clients reconnecting from older states (default 1000) */
+    retain?: number;
+    /** a write failed (it is retried) */
+    onError?: (error: Error, room: string) => void;
+}
+type SnapMeta = Version & {
+    sites?: number;
+};
+export declare class RoomStore {
+    readonly blobs: BlobStore;
+    private opts;
+    private heads;
+    private buffers;
+    private queues;
+    constructor(blobs: BlobStore, opts?: RoomStoreOptions);
+    private dir;
+    private epochDir;
+    /** runs `fn` after every earlier operation on `room` */
+    private run;
+    private readHead;
+    /** sets a room's document (snapshot 0 of a new epoch) and forgets its history */
+    create(room: string, file: Uint8Array, info: {
+        name: string;
+        type: string;
+    }): Promise<RoomHead>;
+    /** latest snapshot of the room (null: no such room) */
+    head(room: string): Promise<RoomHead | null>;
+    /** the document of snapshot `seq` */
+    file(room: string, seq: number, epoch?: string): Promise<Uint8Array | null>;
+    /** snapshot `seq` with its merge context */
+    snapshot(room: string, seq: number, epoch?: string): Promise<(Snapshot & SnapMeta) | null>;
+    /** stored snapshots, oldest first */
+    versions(room: string, epoch?: string): Promise<Version[]>;
+    /** stored batches with `after` < seq ≤ `upTo` (flushed ones only), in order */
+    batches(room: string, after: number, upTo?: number, epoch?: string): Promise<Batch[]>;
+    /** hub `onBatch`: buffers the batch, written with the next segment */
+    append(room: string, batch: Batch): void;
+    /** writes buffered batches now (all rooms when `room` is omitted) */
+    flush(room?: string): Promise<void>;
+    private flushRoom;
+    /** hub `loadLog`: the latest snapshot and the batches after it (plus `retain` before it) */
+    load(room: string): Promise<RoomLog | undefined>;
+    /**
+     * Stores a snapshot taken from `base` (the head it was compacted from) and makes it the latest.
+     * Returns the new head, or null when the room changed meanwhile (new upload, newer snapshot).
+     */
+    save(room: string, base: RoomHead, snap: Snapshot & {
+        sites?: number;
+    }, file: Uint8Array): Promise<RoomHead | null>;
+    /** drops snapshots beyond `keep` and the segments no remaining snapshot needs */
+    private prune;
+}
+export {};

package/dist/types/core/convert.d.ts

@@ -0,0 +1,29 @@
+import type { RunSet } from './docx/types';
+/** Separator of a delimited text file: tab, semicolon (European CSV) or comma. */
+export declare function detectSeparator(text: string): string;
+/** RFC 4180 parser (quoted fields, escaped quotes, CRLF / LF, newlines inside quotes). */
+export declare function parseCsv(text: string, sep?: string): string[][];
+/**
+ * Builds a one-sheet workbook from rows of text.
+ * `decimalComma`: "12,5" is a number (semicolon-separated files from comma-decimal locales).
+ */
+export declare function rowsToXlsx(rows: string[][], sheetName?: string, decimalComma?: boolean): Promise<Blob>;
+export interface ImportRun {
+    text: string;
+    set?: RunSet;
+    href?: string;
+}
+export interface ImportPara {
+    runs: ImportRun[];
+    /** heading level 1-6 */
+    heading?: number;
+    list?: 'bullet' | 'number';
+}
+/** One paragraph per line. */
+export declare function textToParas(text: string): ImportPara[];
+/** Small CommonMark subset → HTML: headings, paragraphs, lists, quotes, code blocks, rules, tables. */
+export declare function markdownToHtml(md: string): string;
+/** Builds a document (Letter, 1" margins, Calibri 11) from paragraphs of formatted runs. */
+export declare function parasToDocx(paras: ImportPara[]): Promise<Blob>;
+/** One empty title slide, 16:9, Office theme; layouts: title, title and content, blank. */
+export declare function blankPptx(): Promise<Blob>;

package/dist/types/core/zipwrite.d.ts

@@ -6,4 +6,6 @@ export type PartData = Uint8Array | string | (() => ReadableStream<Uint8Array>);
  * zero-copy when the source is a Blob); changed/added entries are deflated.
  * `changes`: path → new data, or null to delete.
  */
-export declare function rebuildZip(zip: ZipArchive, changes: Map<string, PartData | null>, type?: string): Promise<Blob>;
+export declare function rebuildZip(zip: ZipArchive | null, changes: Map<string, PartData | null>, type?: string): Promise<Blob>;
+/** Writes a new archive (all entries deflated). */
+export declare function writeZip(entries: Map<string, PartData>, type?: string): Promise<Blob>;

package/dist/types/embed.d.ts

@@ -10,8 +10,8 @@ export declare function mount(el: HTMLElement, options: MountOptions): MountedVi
 /**
  * `<office-viewer src="/file.xlsx" style="height:600px"></office-viewer>`
  * Rendered inside a shadow root so host page CSS cannot leak in.
- * Attributes: src, name, editable, toolbar ("false" to hide), thumbnails ("false" to hide);
- * real-time collaboration: collab (hub WebSocket URL), room, user (display name).
+ * Attributes: src, name, editable, toolbar / thumbnails / save / download / file-menu / open ("false" to hide);
+ * real-time collaboration: collab (hub WebSocket URL), room, user (display name), base (snapshot seq `src` was opened at).
  * Property: `file` (File/Blob/ArrayBuffer) for local data.
  */
 export declare class OfficeViewerElement extends HTMLElement {

package/dist/types/index.d.ts

@@ -1,5 +1,6 @@
 import './core/default-worker';
 export { DocViewer, type DocViewerProps } from './react/DocViewer';
+export type { FileMenuItem } from './react/file/FileMenu';
 export { DocxView, type DocxViewProps } from './react/docx/DocxView';
 export { XlsxView, type XlsxViewProps } from './react/xlsx/XlsxView';
 export { PptxView, type PptxViewProps } from './react/pptx/PptxView';

package/dist/types/react/DocViewer.d.ts

@@ -2,6 +2,7 @@ import { type CSSProperties, type ReactNode } from 'react';
 import type { DocSource } from '../core/source';
 import type { DocumentClient, OpenOptions } from '../core/worker/client';
 import type { Zoom } from './common/ZoomControl';
+import { type FileMenuItem } from './file/FileMenu';
 import type { CollabOptions } from '../collab';
 export interface DocViewerProps {
     /** File, Blob, ArrayBuffer, Uint8Array or URL (HTTP Range requests are used when the server supports them). */
@@ -30,6 +31,23 @@ export interface DocViewerProps {
     editable?: boolean;
     /** Show the Edit/View toggle. Default true. */
     allowEdit?: boolean;
+    /** Show the Save/Download button and enable Ctrl+S. Default true. */
+    allowSave?: boolean;
+    /**
+     * Allow downloading files to the user's device (the save fallback without `onSave`, "Download image").
+     * With `onSave`, saving still works when this is false. Default true.
+     */
+    allowDownload?: boolean;
+    /** Show the File menu (new, open, save, rename, download as PDF / HTML / text…, details, print) and its shortcuts. Default true. */
+    fileMenu?: boolean;
+    /** File → New / Open: replace the document with a blank one or a local file (Office, CSV, text, Markdown, HTML). Default true. */
+    allowOpen?: boolean;
+    /** Extra File menu entries (Share, Version history…), shown before Close. */
+    fileMenuItems?: FileMenuItem[];
+    /** File → Rename: called with the new name (extension included). Rename is shown when `fileMenu` is on. */
+    onRename?: (name: string) => void;
+    /** Adds File → Close. */
+    onClose?: () => void;
     /** Receives the saved file instead of downloading it. */
     onSave?: (file: Blob, name: string) => void | Promise<void>;
     /** Called when the document gets / loses unsaved changes. */

package/dist/types/react/common/Dialog.d.ts

@@ -20,6 +20,14 @@ export declare function PromptDialog({ spec, onClose }: {
     spec: PromptSpec;
     onClose: () => void;
 }): import("react").JSX.Element;
+/** Yes / no question (no window.confirm: works in sandboxed / embedded pages). */
+export declare function ConfirmDialog(props: {
+    title: string;
+    message: ReactNode;
+    ok: string;
+    onOk: () => void;
+    onClose: () => void;
+}): import("react").JSX.Element;
 /** Short-lived message at the bottom of the viewer. */
 export declare function Toast({ text, onDone }: {
     text: string;

package/dist/types/react/common/Slots.d.ts

@@ -1,5 +1,17 @@
 import { type ReactNode } from 'react';
 import type { DocumentClient } from '../../core/worker/client';
+import type { Printable } from '../file/print';
+/** What the active view offers to the File menu. */
+export interface FileOps {
+    /** all pages, for PDF / print and HTML */
+    printable(): Promise<Printable>;
+    /** text formats: 'txt' / 'md' (documents, presentations), 'csv' / 'tsv' (current sheet) */
+    text(format: string): Promise<string>;
+    /** File → Document details: [label, value] rows */
+    stats(): [string, string][];
+    /** File → Import (spreadsheets): rows into a new sheet */
+    importTable?(rows: string[][], name: string): Promise<void>;
+}
 export interface ViewerApi {
     /** editor bar mount point (null when the viewer toolbar is hidden) */
     bar: HTMLElement | null;
@@ -8,10 +20,18 @@ export interface ViewerApi {
     setDirty: (dirty: boolean) => void;
     /** build + hand off the edited file */
     save: () => Promise<void>;
+    /** whether files may be downloaded to the user's device */
+    canDownload: boolean;
     client: DocumentClient | null;
+    /** set by the mounted view (see useFileOps) */
+    fileOps: {
+        current: FileOps | null;
+    };
 }
 export declare const ViewerContext: import("react").Context<ViewerApi>;
 export declare const useViewer: () => ViewerApi;
+/** Publishes the view's file operations (latest closure each render) to the File menu. */
+export declare function useFileOps(ops: FileOps): void;
 /** Renders the editor bar into the viewer's toolbar row. */
 export declare function EditorBar({ children }: {
     children: ReactNode;

package/dist/types/react/docx/DocxToolbar.d.ts

@@ -4,7 +4,8 @@ export interface ImageActions {
     original: () => void;
     replace: () => void;
     alt: () => void;
-    download: () => void;
+    /** undefined when downloads are disabled */
+    download?: () => void;
 }
 export declare function DocxToolbar(props: {
     editor: DocxEditor;

package/dist/types/react/edit/Toolbar.d.ts

@@ -26,6 +26,8 @@ export interface DropOption<T> {
     disabled?: boolean;
     /** separator above this option */
     sep?: boolean;
+    /** group heading above this option */
+    head?: string;
 }
 /**
  * Styled dropdown (listbox). Never takes focus from the editor: mouse down is prevented and,
@@ -46,6 +48,8 @@ export declare function Dropdown<T extends string | number>(props: {
     disabled?: boolean;
     /** popup aligned to the trigger's right edge */
     alignRight?: boolean;
+    /** extra class of the trigger button */
+    className?: string;
 }): import("react").JSX.Element;
 /** Value picker (fonts, styles, formats…). */
 export declare function Select<T extends string | number>(props: {

package/dist/types/react/file/DetailsDialog.d.ts

@@ -0,0 +1,7 @@
+import type { DocumentClient } from '../../core/worker/client';
+export declare function DetailsDialog(props: {
+    client: DocumentClient;
+    file: [string, string][];
+    stats: [string, string][];
+    onClose: () => void;
+}): import("react").JSX.Element;

package/dist/types/react/file/FileMenu.d.ts

@@ -0,0 +1,48 @@
+import type { DocKind } from '../../core/opc';
+import type { FileOps } from '../common/Slots';
+import { type DropOption } from '../edit/Toolbar';
+export declare const KIND_LABEL: Record<DocKind, string>;
+/** Host-provided File menu entry (Share, Version history…). */
+export interface FileMenuItem {
+    label: string;
+    /** built-in icon name */
+    icon?: string;
+    /** shortcut / note on the right */
+    hint?: string;
+    disabled?: boolean;
+    onClick: () => void;
+}
+export interface FileActionsOptions {
+    kind: DocKind | undefined;
+    /** file name without extension */
+    base: string;
+    /** New / Open (replace the document) */
+    canOpen: boolean;
+    /** Import into the document (spreadsheets) */
+    canImport: boolean;
+    canSave: boolean;
+    canDownload: boolean;
+    ops: {
+        current: FileOps | null;
+    };
+    create: (kind: DocKind) => void;
+    open: (file: File) => void;
+    save: () => Promise<void>;
+    /** the document in its own format */
+    downloadOriginal: () => Promise<void>;
+    rename?: () => void;
+    details?: () => void;
+    close?: () => void;
+    extra: FileMenuItem[];
+    notify: (message: string) => void;
+}
+export interface FileActions {
+    options: DropOption<string>[];
+    busy: boolean;
+    run: (action: string) => void;
+}
+/** File menu entries and their actions (also used by the Ctrl+O / Ctrl+P shortcuts). */
+export declare function useFileActions(o: FileActionsOptions): FileActions;
+export declare function FileMenu({ actions }: {
+    actions: FileActions;
+}): import("react").JSX.Element | null;

package/dist/types/react/file/importFile.d.ts

@@ -0,0 +1,10 @@
+/** `accept` of the File → Open picker */
+export declare const OPEN_ACCEPT: string;
+export interface Imported {
+    src: Blob;
+    name: string;
+    /** built from another format: not saved as an Office file yet */
+    converted: boolean;
+}
+/** Office files open as they are; CSV / TSV become a workbook, text / Markdown / HTML a document. */
+export declare function importFile(file: File): Promise<Imported>;

package/dist/types/react/file/print.d.ts

@@ -0,0 +1,16 @@
+import type { ReactNode } from 'react';
+/** Content laid out for paper: PDF / print and standalone HTML. */
+export interface Printable {
+    /** the pages (`.de-print-page` elements) or flowing content */
+    node: ReactNode;
+    /** CSS `@page` size: '612pt 792pt', 'landscape', 'auto' */
+    size: string;
+    /** CSS `@page` margin */
+    margin: string;
+    /** shown to the user (e.g. output was truncated) */
+    notice?: string;
+}
+/** Opens the browser print dialog for the content (choose "Save as PDF" there). */
+export declare function printDocument(p: Printable, title: string): Promise<void>;
+/** Standalone web page of the content (pictures embedded). */
+export declare function exportHtml(p: Printable, title: string): Promise<Blob>;