@dou-ui/sheet 0.0.0-stage → 0.1.0-alpha.0

package/dist/collaboration/index.js

@@ -0,0 +1,770 @@
+import { boundsOf } from "../core/address.js";
+import { colCountOf, rowCountOf } from "../core/model.js";
+import { defineSheetExtension } from "../core/extension.js";
+import { sheetKey } from "../core/transaction.js";
+import { SheetLayout, anchorCell, hasRefs, lineOf, resolveCell } from "./anchor.js";
+import { createPeers } from "./peers.js";
+import { ANCHORED_META, anchorMeta, cellAt, cellKey, cellOfKey, fillBook, increasingRun, isBookKey, isMetaKey, layoutSheet, makeIds, partsOf, readBook, readLayout, readSheet, resolveMeta, sheetParts, splitThread, syncList, threadKey, withThread, writeSheet } from "./shared.js";
+import { applySharedCommentAction, collaborationColors, readSharedComments } from "dou-ui";
+import { nextTick, shallowRef, watch } from "vue";
+import * as Y from "yjs";
+// src/collaboration/index.ts
+var same = (a, b) => a === b || (a == null || a === "") && (b == null || b === "") || typeof a === "object" && typeof b === "object" && JSON.stringify(a) === JSON.stringify(b);
+var selectionOf = (active, ranges) => ({
+	active,
+	ranges: ranges.map((b) => ({
+		start: {
+			row: b.top,
+			col: b.left
+		},
+		end: {
+			row: b.bottom,
+			col: b.right
+		}
+	}))
+});
+/** Writes the named styles or types a change touched. */
+function writeNamed(names, map, own) {
+	for (const name of names) {
+		const value = own?.[name];
+		if (value === void 0) map.delete(name);
+		else if (!same(map.get(name), value)) map.set(name, value);
+	}
+}
+/** Writes the sizes of the lines a change touched, by line id. */
+function writeSizes(keys, map, lines, own) {
+	for (const line of keys) {
+		const at = lines.indexOf(line);
+		if (at < 0) continue;
+		const size = own?.[at];
+		if (size == null) map.delete(line);
+		else if (map.get(line) !== size) map.set(line, size);
+	}
+}
+var isEmpty = (cell) => cell == null || cell === "";
+var dirtyNone = () => ({
+	all: false,
+	sheets: false,
+	whole: /* @__PURE__ */ new Set(),
+	names: false,
+	styles: /* @__PURE__ */ new Set(),
+	types: /* @__PURE__ */ new Set(),
+	bySheet: /* @__PURE__ */ new Map()
+});
+var isDirty = (d) => d.all || d.sheets || d.whole.size > 0 || d.styles.size > 0 || d.types.size > 0 || d.bySheet.size > 0;
+function sheetDirty(dirty, id) {
+	let entry = dirty.bySheet.get(id);
+	if (!entry) dirty.bySheet.set(id, entry = {
+		lines: {
+			row: false,
+			col: false
+		},
+		cells: /* @__PURE__ */ new Set(),
+		rowSizes: /* @__PURE__ */ new Set(),
+		colSizes: /* @__PURE__ */ new Set(),
+		meta: /* @__PURE__ */ new Set()
+	});
+	return entry;
+}
+/** Notes what a Yjs event changed. Paths are from the `book` map. */
+function collect(dirty, event) {
+	const path = event.path;
+	const keys = event instanceof Y.YMapEvent ? event.keysChanged : /* @__PURE__ */ new Set();
+	if (path.length === 0) return void (dirty.all = true);
+	const [top, id, part] = path;
+	if (top === "styles") for (const key of keys) dirty.styles.add(key);
+	else if (top === "types") for (const key of keys) dirty.types.add(key);
+	else if (top === "order") dirty.sheets = true;
+	else if (top === "sheets") {
+		if (path.length === 1) {
+			dirty.sheets = true;
+			for (const key of keys) dirty.whole.add(key);
+		} else if (path.length === 2) dirty.whole.add(id);
+		else {
+			const entry = sheetDirty(dirty, id);
+			if (part === "rows") entry.lines.row = true;
+			else if (part === "cols") entry.lines.col = true;
+			else if (part === "cells") for (const key of keys) entry.cells.add(key);
+			else if (part === "rowSizes") for (const key of keys) entry.rowSizes.add(key);
+			else if (part === "colSizes") for (const key of keys) entry.colSizes.add(key);
+			else if (part === "meta") for (const key of keys) {
+				entry.meta.add(key);
+				if (key === "name") dirty.names = true;
+			}
+		}
+	}
+}
+/**
+* Steps that bring a sheet's lines from `from` to `to`, both lists of ids:
+* removed lines first, then the fewest moves, then the new lines. The
+* cells move with their lines; the new lines are empty.
+*/
+function stepLines(tr, sheet, axis, from, to) {
+	const ids = from.slice();
+	let changed = false;
+	const wanted = new Set(to);
+	for (let i = ids.length - 1; i >= 0;) {
+		if (wanted.has(ids[i])) {
+			i--;
+			continue;
+		}
+		let start = i;
+		while (start > 0 && !wanted.has(ids[start - 1])) start--;
+		tr.step({
+			type: "removeLines",
+			sheet,
+			axis,
+			index: start,
+			count: i - start + 1
+		});
+		ids.splice(start, i - start + 1);
+		changed = true;
+		i = start - 1;
+	}
+	const present = new Set(ids);
+	const target = to.filter((id) => present.has(id));
+	const rank = new Map(target.map((id, i) => [id, i]));
+	const run = increasingRun(ids.map((id) => rank.get(id)));
+	const placed = new Set(ids.filter((_, i) => run.has(i)));
+	target.forEach((id, k) => {
+		if (placed.has(id)) return;
+		const at = ids.indexOf(id);
+		ids.splice(at, 1);
+		const dest = k === 0 ? 0 : ids.indexOf(target[k - 1]) + 1;
+		ids.splice(dest, 0, id);
+		placed.add(id);
+		tr.step({
+			type: "moveLines",
+			sheet,
+			axis,
+			from: at,
+			count: 1,
+			to: dest >= at ? dest + 1 : dest
+		});
+		changed = true;
+	});
+	for (let k = 0; k < to.length;) {
+		if (present.has(to[k])) {
+			k++;
+			continue;
+		}
+		let end = k;
+		while (end < to.length && !present.has(to[end])) end++;
+		tr.step({
+			type: "insertLines",
+			sheet,
+			axis,
+			index: k,
+			count: end - k
+		});
+		changed = true;
+		k = end;
+	}
+	return changed;
+}
+/**
+* Edit a workbook together through a Yjs document. Every row and column
+* has an id there; cells, sizes, formulas and rules are kept by those ids,
+* so two people inserting, deleting or moving lines at once keep each
+* other's cells in place, and formulas still point at the cells they were
+* written for. The grid's `v-model` only mirrors the shared workbook: a
+* workbook set through `v-model` from outside is not written back. Undo
+* only takes back this user's own changes. With `awareness`, each person
+* sees the others' selections and the cells they edit, in their colors.
+*/
+function collaboration(options) {
+	const { book, awareness, user } = options;
+	const ydoc = book.doc;
+	if (!ydoc) throw new Error("[@dou-ui/sheet] the book map must be in a Y.Doc");
+	if (awareness && user) {
+		const color = user.color ?? collaborationColors[ydoc.clientID % collaborationColors.length];
+		awareness.setLocalStateField("user", {
+			name: user.name,
+			color
+		});
+	}
+	/** This grid's own changes, which undo can take back. */
+	const tracked = { sheet: "tracked" };
+	/** Changes undo leaves alone, e.g. filling the shared workbook. */
+	const untracked = { sheet: "untracked" };
+	const undoManager = new Y.UndoManager(book, {
+		trackedOrigins: /* @__PURE__ */ new Set([tracked]),
+		captureTimeout: 500
+	});
+	const ids = makeIds(ydoc);
+	let context;
+	let parts = null;
+	/** The sheets and lines the grid shows, by id: the shared workbook as last applied. */
+	let layout = new SheetLayout();
+	/** Set while shared changes are applied to the grid, so they aren't written back. */
+	let applying = false;
+	/** What undo or redo is running, to name the change. */
+	let travelling = null;
+	let restore;
+	let lastGroup;
+	/** Counts the changes applied from the shared workbook, for what draws by line ids. */
+	const revision = shallowRef(0);
+	function storeView(sheet, selection) {
+		const here = layout.sheets.get(sheet);
+		if (!here) return void 0;
+		const row = (n) => here.rows.ids[n] ?? n;
+		const col = (n) => here.cols.ids[n] ?? n;
+		return {
+			sheet,
+			active: [row(selection.active.row), col(selection.active.col)],
+			ranges: selection.ranges.slice(0, 20).map((range) => {
+				const b = boundsOf(range);
+				return [
+					row(b.top),
+					col(b.left),
+					row(b.bottom),
+					col(b.right)
+				];
+			})
+		};
+	}
+	function readView(view) {
+		const here = layout.sheets.get(view.sheet);
+		if (!here) return null;
+		const ranges = [];
+		for (const [top, left, bottom, right] of view.ranges) {
+			const b = {
+				top: lineOf(here.rows, top),
+				left: lineOf(here.cols, left),
+				bottom: lineOf(here.rows, bottom),
+				right: lineOf(here.cols, right)
+			};
+			if (b.top >= 0 && b.left >= 0 && b.bottom >= 0 && b.right >= 0) ranges.push({
+				top: Math.min(b.top, b.bottom),
+				left: Math.min(b.left, b.right),
+				bottom: Math.max(b.top, b.bottom),
+				right: Math.max(b.left, b.right)
+			});
+		}
+		const row = lineOf(here.rows, view.active[0]);
+		const col = lineOf(here.cols, view.active[1]);
+		return {
+			active: row >= 0 && col >= 0 ? {
+				row,
+				col
+			} : ranges[0] ? {
+				row: ranges[0].top,
+				col: ranges[0].left
+			} : null,
+			ranges
+		};
+	}
+	undoManager.on("stack-item-added", (event) => {
+		const id = context?.sheet.value.id;
+		const view = id != null && context ? storeView(id, context.selection.value) : void 0;
+		if (view) event.stackItem.meta.set("view", view);
+	});
+	undoManager.on("stack-item-popped", (event) => {
+		restore = event.stackItem.meta.get("view");
+	});
+	/** Writes what a transaction changed into the shared workbook. */
+	function writeChanges(tr, shared) {
+		const touched = /* @__PURE__ */ new Map();
+		const touch = (id) => {
+			let entry = touched.get(id);
+			if (!entry) touched.set(id, entry = {
+				cells: /* @__PURE__ */ new Set(),
+				rowSizes: /* @__PURE__ */ new Set(),
+				colSizes: /* @__PURE__ */ new Set(),
+				meta: /* @__PURE__ */ new Set(),
+				lines: {
+					row: false,
+					col: false
+				},
+				removed: {
+					row: [],
+					col: []
+				}
+			});
+			return entry;
+		};
+		let sheetsChanged = false;
+		/** Sheets added in this change, also ones taken out and put back: written whole. */
+		const fresh = /* @__PURE__ */ new Set();
+		const styles = /* @__PURE__ */ new Set();
+		const types = /* @__PURE__ */ new Set();
+		/** The workbook's own settings that changed, such as `protect`. */
+		const bookKeys = /* @__PURE__ */ new Set();
+		for (const step of tr.steps) if (step.type === "setStyle") styles.add(step.name);
+		else if (step.type === "setType") types.add(step.name);
+		else if (step.type === "insertSheet") {
+			sheetsChanged = true;
+			if (step.data.id != null) fresh.add(step.data.id);
+		} else if (step.type === "removeSheet" || step.type === "moveSheet") sheetsChanged = true;
+		else if (step.type === "updateBook") for (const key of Object.keys(step.patch)) bookKeys.add(key);
+		else {
+			const here = fresh.has(step.sheet) ? void 0 : layout.sheets.get(step.sheet);
+			if (!here) continue;
+			const t = touch(here.id);
+			const lineAt = (axis, index) => {
+				const lines = axis === "row" ? here.rows : here.cols;
+				if (index >= lines.ids.length) {
+					lines.ids.push(...ids.many(index + 1 - lines.ids.length));
+					lines.changed();
+					t.lines[axis] = true;
+				}
+				return lines.ids[index];
+			};
+			if (step.type === "setCell") t.cells.add(cellKey(lineAt("row", step.row), lineAt("col", step.col)));
+			else if (step.type === "setSize") (step.axis === "row" ? t.rowSizes : t.colSizes).add(lineAt(step.axis, step.index));
+			else if (step.type === "updateSheet") for (const key of Object.keys(step.patch)) t.meta.add(key);
+			else {
+				const { axis } = step;
+				const lines = axis === "row" ? here.rows : here.cols;
+				t.lines[axis] = true;
+				if (step.type === "insertLines") {
+					if (step.index > 0) lineAt(axis, step.index - 1);
+					const added = ids.many(step.count);
+					lines.ids.splice(step.index, 0, ...added);
+					lines.changed();
+					step.cells?.forEach((part, r) => part?.forEach((cell, c) => {
+						if (isEmpty(cell)) return;
+						t.cells.add(axis === "row" ? cellKey(added[r], lineAt("col", c)) : cellKey(lineAt("row", r), added[c]));
+					}));
+					step.sizes?.forEach((size, i) => {
+						if (size != null) (axis === "row" ? t.rowSizes : t.colSizes).add(added[i]);
+					});
+				} else if (step.type === "removeLines") {
+					t.removed[axis].push(...lines.ids.splice(step.index, step.count));
+					lines.changed();
+				} else {
+					lineAt(axis, Math.max(step.from + step.count, step.to) - 1);
+					const block = lines.ids.splice(step.from, step.count);
+					lines.ids.splice(step.to > step.from ? step.to - step.count : step.to, 0, ...block);
+					lines.changed();
+				}
+			}
+		}
+		const sheets = tr.doc.sheets;
+		const byId = new Map(sheets.map((sheet) => [sheet.id, sheet]));
+		if (sheetsChanged || sheets.some((sheet) => !layout.sheets.has(sheet.id))) {
+			for (const id of Array.from(layout.sheets.keys())) if (!byId.has(id) || fresh.has(id)) {
+				shared.sheets.delete(id);
+				layout.sheets.delete(id);
+				touched.delete(id);
+			}
+			const added = [];
+			for (const sheet of sheets) if (!layout.sheets.has(sheet.id)) {
+				layout.sheets.set(sheet.id, layoutSheet(sheet, sheet.id, ids));
+				added.push(sheet);
+			}
+			for (const sheet of sheets) layout.sheets.get(sheet.id).name = sheet.name;
+			for (const sheet of added) writeSheet(shared.sheets, sheet, layout.sheets.get(sheet.id), layout);
+			syncList(shared.order, sheets.map((sheet) => sheet.id));
+		}
+		for (const sheet of sheets) {
+			const here = layout.sheets.get(sheet.id);
+			if (here) here.name = sheet.name;
+		}
+		for (const [id, t] of touched) {
+			const here = layout.sheets.get(id);
+			const sheet = byId.get(id);
+			const lists = sheetParts(shared.sheets.get(id));
+			if (!here || !sheet || !lists) continue;
+			const fit = (axis, count) => {
+				const lines = axis === "row" ? here.rows : here.cols;
+				if (lines.ids.length < count) lines.ids.push(...ids.many(count - lines.ids.length));
+				else if (lines.ids.length > count) t.removed[axis].push(...lines.ids.splice(count));
+				else return;
+				lines.changed();
+				t.lines[axis] = true;
+			};
+			if (t.lines.row || t.meta.has("rowCount")) fit("row", rowCountOf(sheet));
+			if (t.lines.col || t.meta.has("colCount")) fit("col", colCountOf(sheet));
+			if (t.lines.row) syncList(lists.rows, here.rows.ids);
+			if (t.lines.col) syncList(lists.cols, here.cols.ids);
+			const drop = (key) => {
+				lists.cells.delete(key);
+				lists.cells.delete(threadKey(key));
+			};
+			for (const row of t.removed.row) {
+				for (const col of here.cols.ids) drop(cellKey(row, col));
+				for (const col of t.removed.col) drop(cellKey(row, col));
+				lists.rowSizes.delete(row);
+			}
+			for (const col of t.removed.col) {
+				for (const row of here.rows.ids) drop(cellKey(row, col));
+				lists.colSizes.delete(col);
+			}
+			for (const key of t.cells) {
+				const { row, col } = cellAt(key, here);
+				if (row < 0 || col < 0) continue;
+				const [own, thread] = splitThread(sheet.cells[row]?.[col]);
+				if (thread !== lists.cells.get(threadKey(key))) {
+					if (thread) lists.cells.set(threadKey(key), thread);
+					else lists.cells.delete(threadKey(key));
+				}
+				const existing = lists.cells.get(key);
+				if (same(resolveCell(existing, here, layout), own)) continue;
+				const stored = anchorCell(own, here, layout);
+				if (isEmpty(stored)) lists.cells.delete(key);
+				else lists.cells.set(key, stored);
+			}
+			writeSizes(t.rowSizes, lists.rowSizes, here.rows, sheet.rowSizes);
+			writeSizes(t.colSizes, lists.colSizes, here.cols, sheet.colSizes);
+			for (const key of t.meta) {
+				if (!isMetaKey(key)) continue;
+				const value = sheet[key];
+				const existing = lists.meta.get(key);
+				if (key !== "name" && same(resolveMeta(key, existing, here, layout), value)) continue;
+				if (value === void 0) lists.meta.delete(key);
+				else {
+					const stored = anchorMeta(key, value, here, layout);
+					if (!same(existing, stored)) lists.meta.set(key, stored);
+				}
+			}
+		}
+		writeNamed(styles, shared.styles, tr.doc.styles);
+		writeNamed(types, shared.types, tr.doc.types);
+		for (const key of bookKeys) {
+			if (!isBookKey(key)) continue;
+			const value = tr.doc[key];
+			if (value === void 0) book.delete(key);
+			else if (!same(book.get(key), value)) book.set(key, value);
+		}
+	}
+	/** Steps that bring the grid in line with the shared workbook, as `next` lays it out. */
+	function applyShared(tr, shared, dirty, next) {
+		const before = layout;
+		const inserted = /* @__PURE__ */ new Set();
+		let refs = dirty.all || dirty.names;
+		const wanted = Array.from(next.sheets.keys());
+		if ((dirty.all || dirty.sheets || dirty.whole.size) && wanted.length) {
+			for (let i = tr.doc.sheets.length - 1; i >= 0; i--) {
+				const sheet = tr.doc.sheets[i];
+				const id = sheet.id;
+				if (id == null || dirty.all || dirty.whole.has(id) || !next.sheets.has(id)) tr.step({
+					type: "removeSheet",
+					sheet: sheetKey(sheet)
+				});
+			}
+			wanted.forEach((id, index) => {
+				const at = tr.indexOf(id);
+				if (at === -1) {
+					const here = next.sheets.get(id);
+					tr.step({
+						type: "insertSheet",
+						index,
+						data: readSheet(sheetParts(shared.sheets.get(id)), here, next)
+					});
+					inserted.add(id);
+				} else if (at !== index) tr.step({
+					type: "moveSheet",
+					sheet: id,
+					index
+				});
+			});
+			refs = true;
+		}
+		for (const [id, here] of next.sheets) {
+			if (inserted.has(id)) continue;
+			const d = dirty.bySheet.get(id);
+			const old = before.sheets.get(id);
+			const lists = sheetParts(shared.sheets.get(id));
+			if (!d || !old || !lists || tr.indexOf(id) === -1) continue;
+			if (d.lines.row && stepLines(tr, id, "row", old.rows.ids, here.rows.ids)) refs = true;
+			if (d.lines.col && stepLines(tr, id, "col", old.cols.ids, here.cols.ids)) refs = true;
+			const counts = {};
+			if (rowCountOf(tr.getSheet(id)) !== here.rows.ids.length) counts.rowCount = here.rows.ids.length;
+			if (colCountOf(tr.getSheet(id)) !== here.cols.ids.length) counts.colCount = here.cols.ids.length;
+			if (Object.keys(counts).length) tr.updateSheet(counts, id);
+			for (const key of new Set(Array.from(d.cells, cellOfKey))) {
+				const { row, col } = cellAt(key, here);
+				if (row < 0 || col < 0) continue;
+				const cell = withThread(resolveCell(lists.cells.get(key), here, next), lists.cells.get(threadKey(key)));
+				const at = {
+					sheet: id,
+					row,
+					col
+				};
+				if (!same(tr.getCell(at), cell)) tr.setCell(at, cell);
+			}
+			const sizes = (axis, keys, map, lines) => {
+				for (const line of keys) {
+					const at = lines.indexOf(line);
+					if (at < 0) continue;
+					const size = map.get(line);
+					if (tr.getSheet(id)[axis === "row" ? "rowSizes" : "colSizes"]?.[at] !== size) tr.setSize(axis, at, typeof size === "number" ? size : void 0, id);
+				}
+			};
+			sizes("row", d.rowSizes, lists.rowSizes, here.rows);
+			sizes("col", d.colSizes, lists.colSizes, here.cols);
+			const patch = {};
+			for (const key of d.meta) {
+				if (!isMetaKey(key)) continue;
+				const value = key === "name" ? here.name : resolveMeta(key, lists.meta.get(key), here, next);
+				if (!same(tr.getSheet(id)[key], value)) patch[key] = value;
+			}
+			if (Object.keys(patch).length) tr.updateSheet(patch, id);
+		}
+		if (refs) for (const [id, here] of next.sheets) {
+			if (inserted.has(id) || tr.indexOf(id) === -1) continue;
+			const lists = sheetParts(shared.sheets.get(id));
+			if (!lists) continue;
+			lists.cells.forEach((stored, key) => {
+				if (!hasRefs(stored)) return;
+				const { row, col } = cellAt(key, here);
+				if (row < 0 || col < 0) return;
+				const cell = withThread(resolveCell(stored, here, next), lists.cells.get(threadKey(key)));
+				const at = {
+					sheet: id,
+					row,
+					col
+				};
+				if (!same(tr.getCell(at), cell)) tr.setCell(at, cell);
+			});
+			const patch = {};
+			for (const key of ANCHORED_META) {
+				const value = resolveMeta(key, lists.meta.get(key), here, next);
+				if (!same(tr.getSheet(id)[key], value)) patch[key] = value;
+			}
+			if (Object.keys(patch).length) tr.updateSheet(patch, id);
+		}
+		const styleNames = dirty.all ? /* @__PURE__ */ new Set([...Object.keys(tr.doc.styles ?? {}), ...shared.styles.keys()]) : dirty.styles;
+		for (const name of styleNames) {
+			const value = shared.styles.get(name);
+			if (!same(tr.doc.styles?.[name], value)) tr.setStyle(name, value);
+		}
+		const typeNames = dirty.all ? /* @__PURE__ */ new Set([...Object.keys(tr.doc.types ?? {}), ...shared.types.keys()]) : dirty.types;
+		for (const name of typeNames) {
+			const value = shared.types.get(name);
+			if (!same(tr.doc.types?.[name], value)) tr.setType(name, value);
+		}
+		if (dirty.all) {
+			const patch = {};
+			const keys = /* @__PURE__ */ new Set([...Object.keys(tr.doc), ...book.keys()]);
+			for (const key of keys) {
+				if (!isBookKey(key)) continue;
+				const value = book.get(key);
+				if (!same(tr.doc[key], value)) patch[key] = value;
+			}
+			if (Object.keys(patch).length) tr.updateBook(patch);
+		}
+	}
+	/** Brings the grid in line with the shared workbook. */
+	function pull(dirty) {
+		parts = partsOf(book);
+		if (!context || !parts) return;
+		const shared = parts;
+		const next = readLayout(shared);
+		const meta = {
+			history: false,
+			origin: travelling ?? "remote"
+		};
+		const shown = context.sheet.value.id;
+		const selected = shown != null ? storeView(shown, context.selection.value) : void 0;
+		const kept = context.selection.value;
+		applying = true;
+		try {
+			context.transact((tr) => applyShared(tr, shared, dirty, next), meta);
+		} catch (error) {
+			console.error("[@dou-ui/sheet] could not apply a shared change; reading the workbook again", error);
+			try {
+				context.transact((tr) => applyShared(tr, shared, {
+					...dirtyNone(),
+					all: true
+				}, next), meta);
+			} catch (again) {
+				console.error("[@dou-ui/sheet] could not read the shared workbook", again);
+			}
+		} finally {
+			applying = false;
+		}
+		layout = next;
+		if (dirty.all) {
+			const sheet = context;
+			nextTick(() => {
+				const now = sheet.selection.value;
+				if (now.active.row !== kept.active.row || now.active.col !== kept.active.col) sheet.select(kept);
+			});
+		} else if (selected && !travelling && context.sheet.value.id === selected.sheet) {
+			const view = readView(selected);
+			const current = context.selection.value;
+			if (view?.active && view.ranges.length && (view.active.row !== current.active.row || view.active.col !== current.active.col)) context.select(selectionOf(view.active, view.ranges));
+		}
+		revision.value++;
+		tidyLists(shared);
+	}
+	function tidyLists(shared) {
+		const repeated = [];
+		const check = (list, known) => {
+			if (list.length !== known.length) repeated.push([list, known]);
+		};
+		check(shared.order, Array.from(layout.sheets.keys()));
+		for (const here of layout.sheets.values()) {
+			const sheet = sheetParts(shared.sheets.get(here.id));
+			if (!sheet) continue;
+			check(sheet.rows, here.rows.ids);
+			check(sheet.cols, here.cols.ids);
+		}
+		if (!repeated.length) return;
+		queueMicrotask(() => ydoc.transact(() => {
+			for (const [list] of repeated) {
+				const items = list.toArray();
+				const first = /* @__PURE__ */ new Map();
+				items.forEach((id, i) => first.has(id) || first.set(id, i));
+				for (let i = items.length - 1; i >= 0; i--) if (first.get(items[i]) !== i) list.delete(i, 1);
+			}
+		}, untracked));
+	}
+	function run(action) {
+		if (!(action === "undo" ? undoManager.undoStack : undoManager.redoStack).length) return false;
+		travelling = action;
+		restore = void 0;
+		try {
+			undoManager[action]();
+		} finally {
+			travelling = null;
+		}
+		const popped = restore;
+		restore = void 0;
+		const view = popped && readView(popped);
+		if (view && context && popped) {
+			context.showSheet(popped.sheet);
+			if (view.active && view.ranges.length) context.select(selectionOf(view.active, view.ranges));
+		}
+		return true;
+	}
+	const peers = shallowRef([]);
+	const commentMap = options.comments;
+	const sharedThreads = commentMap;
+	const threads = shallowRef([]);
+	const readThreads = () => {
+		if (sharedThreads) threads.value = readSharedComments(sharedThreads);
+	};
+	readThreads();
+	return defineSheetExtension({
+		name: "collaboration",
+		priority: 0,
+		transaction(tr) {
+			if (applying || !parts) return;
+			tr.doc.sheets.forEach((sheet, index) => {
+				if (sheet.id != null) return;
+				let id = ids.next();
+				while (tr.indexOf(id) !== -1) id = ids.next();
+				tr.updateSheet({ id }, index);
+			});
+			const tracking = tr.meta.history !== false;
+			if (tracking && (!tr.meta.group || tr.meta.group !== lastGroup)) undoManager.stopCapturing();
+			if (tracking) lastGroup = tr.meta.group;
+			const shared = parts;
+			ydoc.transact(() => writeChanges(tr, shared), tracking ? tracked : untracked);
+			if (tr.steps.some((step) => step.type.endsWith("Lines") || step.type.endsWith("Sheet"))) revision.value++;
+		},
+		comments: sharedThreads ? () => ({
+			threads,
+			apply: (action) => applySharedCommentAction(sharedThreads, action, untracked)
+		}) : void 0,
+		history: () => ({
+			undo: () => run("undo"),
+			redo: () => run("redo"),
+			canUndo: () => undoManager.undoStack.length > 0,
+			canRedo: () => undoManager.redoStack.length > 0
+		}),
+		layers: awareness ? { below: [createPeers(peers)] } : void 0,
+		setup(sheet) {
+			context = sheet;
+			commentMap?.observe(readThreads);
+			readThreads();
+			parts = partsOf(book);
+			if (!parts) {
+				applying = true;
+				try {
+					sheet.transact((tr) => tr.doc.sheets.forEach((data, index) => {
+						if (data.id == null) tr.updateSheet({ id: ids.next() }, index);
+					}), { history: false });
+				} finally {
+					applying = false;
+				}
+				ydoc.transact(() => fillBook(book, sheet.doc.value), untracked);
+				parts = partsOf(book);
+				if (parts) layout = readLayout(parts);
+			} else {
+				layout = new SheetLayout();
+				pull({
+					...dirtyNone(),
+					all: true
+				});
+			}
+			let dirty = dirtyNone();
+			const observe = (events, transaction) => {
+				if (transaction.origin === tracked || transaction.origin === untracked) return;
+				for (const event of events) collect(dirty, event);
+			};
+			const flush = () => {
+				if (!isDirty(dirty)) return;
+				const changes = dirty;
+				dirty = dirtyNone();
+				pull(changes);
+			};
+			book.observeDeep(observe);
+			ydoc.on("afterTransaction", flush);
+			let stopPresence;
+			let readPeers;
+			if (awareness) {
+				readPeers = () => {
+					const list = [];
+					awareness.getStates().forEach((state, client) => {
+						if (client === awareness.clientID) return;
+						const who = state.user;
+						const presence = state.sheet;
+						if (!who || !presence) return;
+						const view = readView(presence);
+						if (!view) return;
+						list.push({
+							client,
+							name: who.name ?? "",
+							color: who.color ?? "currentColor",
+							sheet: presence.sheet,
+							active: view.active,
+							ranges: view.ranges,
+							editing: !!presence.editing
+						});
+					});
+					peers.value = list;
+				};
+				readPeers();
+				awareness.on("change", readPeers);
+				const stopRevision = watch(revision, () => readPeers?.());
+				let arrived = false;
+				const stopShare = watch(() => [
+					sheet.focused.value,
+					sheet.sheet.value.id,
+					sheet.selection.value,
+					sheet.editor.cell.value,
+					revision.value
+				], () => {
+					arrived ||= sheet.focused.value || !!sheet.editor.cell.value;
+					if (!arrived) return;
+					const id = sheet.sheet.value.id;
+					const view = id != null ? storeView(id, sheet.selection.value) : void 0;
+					awareness.setLocalStateField("sheet", view ? {
+						...view,
+						editing: !!sheet.editor.cell.value
+					} : null);
+				}, { immediate: true });
+				stopPresence = () => {
+					stopRevision();
+					stopShare();
+				};
+			}
+			return () => {
+				commentMap?.unobserve(readThreads);
+				book.unobserveDeep(observe);
+				ydoc.off("afterTransaction", flush);
+				stopPresence?.();
+				if (readPeers) awareness?.off("change", readPeers);
+				awareness?.setLocalStateField("sheet", null);
+				context = void 0;
+			};
+		}
+	});
+}
+export { collaboration, collaborationColors, fillBook, readBook };
+
+//# sourceMappingURL=index.js.map