@p10node/office-engine 0.1.1 → 0.2.0

package/dist/office-engine.worker.js

@@ -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/embed.d.ts

@@ -11,7 +11,7 @@ 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 / thumbnails / save / download / file-menu / open ("false" to hide);
- * real-time collaboration: collab (hub WebSocket URL), room, user (display name).
+ * 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/react/xlsx/fit.d.ts

@@ -0,0 +1,4 @@
+/** px size of a CSS font size ('11pt', px number), `base` when unset */
+export declare const fontPx: (v: string | number | undefined, base: number) => number;
+/** Excel-like: shrink General decimals to fit, otherwise show ### when a number is too wide. */
+export declare function fitNumber(text: string, width: number, px: number): string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@p10node/office-engine",
-  "version": "0.1.1",
+  "version": "0.2.0",
   "description": "Browser engine to view DOCX, XLSX, PPTX progressively (worker-based, range-loading, virtualized React views)",
   "type": "module",
   "license": "MIT",