@pluv/crdt-loro 0.0.0-canary-20261027014949

package/dist/browser.mjs

@@ -0,0 +1,592 @@
+import { t as __exportAll } from "./rolldown-runtime-D8jQpDG7.mjs";
+import { LoroCounter, LoroDoc, LoroList, LoroMap, LoroMovableList, LoroText, LoroTree, UndoManager, VersionVector, decodeImportBlobMeta, isContainer } from "loro-crdt";
+import { fromUint8Array, toUint8Array } from "js-base64";
+import { AbstractCrdtDocFactory, CrdtSchemaError, assertJsonValue, assertNotOptional, createSchemaNode, flattenObjectShape, fromJSON, isJsonKind, isLoroCrdtKind, isSchemaNode, isUnseedableKind, isYjsCrdtKind, pickUnionOption, unwrapOptional } from "@pluv/crdt";
+// src/counter.ts
+const counter = () => {
+	return new LoroCounter();
+};
+// src/schema/hydrate.ts
+const isPlainObject = (value) => {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+};
+const insertIntoList = (list, index, value) => {
+	if (isContainer(value)) list.insertContainer(index, value);
+	else list.insert(index, value);
+};
+const setOnMap = (map, key, value) => {
+	if (isContainer(value)) map.setContainer(key, value);
+	else map.set(key, value);
+};
+const getLoroShare = (doc, key, kind) => {
+	switch (kind) {
+		case "loroList": return doc.getList(key);
+		case "loroMap": return doc.getMap(key);
+		case "loroText": return doc.getText(key);
+		case "loroMovableList": return doc.getMovableList(key);
+		case "loroCounter": return doc.getCounter(key);
+		case "loroTree": return doc.getTree(key);
+		default: throw new CrdtSchemaError(`Cannot bind Loro share for kind "${kind}"`);
+	}
+};
+const hydrateValue = (node, json) => {
+	const current = unwrapOptional(node);
+	if (current.kind === "union" || current.kind === "discriminatedUnion") {
+		const option = pickUnionOption(current, json);
+		if (!option) throw new CrdtSchemaError(`No ${current.kind} option matched`);
+		return hydrateValue(option, json);
+	}
+	if (current.kind === "intersection") {
+		const shape = flattenObjectShape(current);
+		return hydrateValue({
+			...current,
+			kind: "object",
+			shape
+		}, json);
+	}
+	if (current.kind === "object") {
+		assertJsonValue(current, json, "JSON object");
+		const shape = current.shape;
+		const source = json;
+		return Object.entries(shape).reduce((acc, [key, field]) => {
+			if (!(key in source)) return acc;
+			acc[key] = hydrateValue(unwrapOptional(field), source[key]);
+			return acc;
+		}, {});
+	}
+	if (current.kind === "array") {
+		assertJsonValue(current, json, "JSON array");
+		const item = current.item;
+		return json.map((entry) => hydrateValue(item, entry));
+	}
+	if (current.kind === "record") {
+		assertJsonValue(current, json, "JSON record");
+		const value = current.value;
+		return Object.entries(json).reduce((acc, [key, entry]) => {
+			acc[key] = hydrateValue(value, entry);
+			return acc;
+		}, {});
+	}
+	if (isJsonKind(current.kind)) {
+		assertJsonValue(current, json, `JSON ${current.kind}`);
+		return json;
+	}
+	switch (current.kind) {
+		case "loroList":
+		case "loroMovableList": {
+			if (!Array.isArray(json)) throw new CrdtSchemaError(`Expected an array to hydrate ${current.kind}`);
+			const item = current.item;
+			const list = current.kind === "loroList" ? new LoroList() : new LoroMovableList();
+			json.forEach((entry, index) => {
+				insertIntoList(list, index, hydrateValue(item, entry));
+			});
+			return list;
+		}
+		case "loroMap": {
+			if (!isPlainObject(json)) throw new CrdtSchemaError("Expected an object to hydrate loroMap");
+			const value = current.value;
+			const map = new LoroMap();
+			Object.entries(json).forEach(([key, entry]) => {
+				setOnMap(map, key, hydrateValue(value, entry));
+			});
+			return map;
+		}
+		case "loroText": {
+			if (typeof json !== "string") throw new CrdtSchemaError("Expected a string to hydrate loroText");
+			const text = new LoroText();
+			if (json) text.insert(0, json);
+			return text;
+		}
+		case "loroCounter": {
+			if (typeof json !== "number" || !Number.isFinite(json)) throw new CrdtSchemaError("Expected a number to hydrate loroCounter");
+			const counter = new LoroCounter();
+			if (json !== 0) counter.increment(json);
+			return counter;
+		}
+		default: throw new CrdtSchemaError(`Cannot hydrate schema kind "${current.kind}" from JSON`);
+	}
+};
+const fillShare = (share, node, json) => {
+	switch (node.kind) {
+		case "loroList":
+		case "loroMovableList": {
+			if (!Array.isArray(json)) throw new CrdtSchemaError(`Expected an array to seed ${node.kind}`);
+			const item = node.item;
+			const list = share;
+			json.forEach((entry, index) => {
+				insertIntoList(list, index, hydrateValue(item, entry));
+			});
+			return;
+		}
+		case "loroMap": {
+			if (!isPlainObject(json)) throw new CrdtSchemaError("Expected an object to seed loroMap");
+			const value = node.value;
+			const map = share;
+			Object.entries(json).forEach(([key, entry]) => {
+				setOnMap(map, key, hydrateValue(value, entry));
+			});
+			return;
+		}
+		case "loroText": {
+			if (typeof json !== "string") throw new CrdtSchemaError("Expected a string to seed loroText");
+			const text = share;
+			if (json) text.insert(0, json);
+			return;
+		}
+		case "loroCounter": {
+			if (typeof json !== "number" || !Number.isFinite(json)) throw new CrdtSchemaError("Expected a number to seed loroCounter");
+			const counter = share;
+			if (json !== 0) counter.increment(json);
+			return;
+		}
+		default: throw new CrdtSchemaError(`Cannot seed kind "${node.kind}"`);
+	}
+};
+const hydrateTopLevel = (doc, schema, seed) => {
+	if (seed) {
+		const extra = Object.keys(seed).filter((key) => !(key in schema.shape));
+		if (extra.length) throw new CrdtSchemaError(`Unexpected seed keys: ${extra.join(", ")}`);
+	}
+	return Object.entries(schema.shape).reduce((acc, [key, node]) => {
+		const share = getLoroShare(doc, key, node.kind);
+		const value = seed?.[key];
+		if (value !== void 0) {
+			if (isUnseedableKind(node.kind)) throw new CrdtSchemaError(`Cannot JSON-seed "${key}" (${node.kind})`);
+			fillShare(share, node, value);
+		}
+		acc[key] = share;
+		return acc;
+	}, {});
+};
+// src/doc/PendingSpans.ts
+/**
+* Counter ranges from Loro imports that are still waiting on earlier changes.
+*/
+var PendingSpans = class {
+	_spans = /* @__PURE__ */ new Map();
+	get isPending() {
+		return this._spans.size > 0;
+	}
+	record(status) {
+		status.pending?.forEach((span, peer) => {
+			const key = String(peer);
+			const existing = this._spans.get(key) ?? [];
+			this._spans.set(key, this._mergeSpans([...existing, span]));
+		});
+		status.success.forEach((span, peer) => {
+			const key = String(peer);
+			const existing = this._spans.get(key);
+			if (!existing) return;
+			const remaining = existing.flatMap((pending) => this._subtractSpan(pending, span));
+			if (remaining.length) this._spans.set(key, remaining);
+			else this._spans.delete(key);
+		});
+	}
+	_mergeSpans(spans) {
+		return spans.filter((span) => span.end > span.start).toSorted((left, right) => left.start - right.start).reduce((merged, span) => {
+			const last = merged.at(-1);
+			if (!last || span.start > last.end) {
+				merged.push({
+					start: span.start,
+					end: span.end
+				});
+				return merged;
+			}
+			last.end = Math.max(last.end, span.end);
+			return merged;
+		}, []);
+	}
+	_subtractSpan(span, cover) {
+		if (cover.end <= span.start || cover.start >= span.end) return [span];
+		const remaining = [];
+		if (cover.start > span.start) remaining.push({
+			start: span.start,
+			end: cover.start
+		});
+		if (cover.end < span.end) remaining.push({
+			start: cover.end,
+			end: span.end
+		});
+		return remaining;
+	}
+};
+// src/doc/CrdtLoroDoc.ts
+const MAX_UNDO_STEPS = 100;
+const MERGE_INTERVAL_MS = 1e3;
+const PLUV_ID_FIELD = "__$pluv";
+const clocksFromVector = (clocks) => [...clocks].map(([id, clock]) => [String(id), clock]).sort((left, right) => left[0] < right[0] ? -1 : left[0] > right[0] ? 1 : 0);
+var CrdtLoroDoc = class {
+	value = new LoroDoc();
+	#_importOrigin = null;
+	#_pendingSpans = new PendingSpans();
+	#_schema;
+	#_storage;
+	#_undoManager = null;
+	constructor(schema, seed, hydrate = false) {
+		this.#_schema = schema;
+		if (hydrate) {
+			this.#_storage = hydrateTopLevel(this.value, schema, seed);
+			if (Object.keys(schema.shape).length) this.#_setPluvId();
+		} else this.#_storage = {};
+		this.value.commit();
+	}
+	applyEncodedState(params) {
+		const update = typeof params.update === "string" ? toUint8Array(params.update) : params.update;
+		if (!update) return this;
+		this.#_import(update, params.origin);
+		return this;
+	}
+	batchApplyEncodedState(params) {
+		const filtered = (params.updates ?? []).reduce((acc, update) => {
+			if (!update) return acc;
+			if (typeof update === "string") {
+				acc.push(toUint8Array(update));
+				return acc;
+			}
+			if (typeof update === "object") {
+				acc.push(update);
+				return acc;
+			}
+			return acc;
+		}, []);
+		if (!filtered.length) return this;
+		const [first] = filtered;
+		if (filtered.length === 1 && first) {
+			this.#_import(first, params.origin);
+			return this;
+		}
+		this.#_importOrigin = params.origin ?? null;
+		try {
+			this.#_pendingSpans.record(this.value.importBatch(filtered));
+		} finally {
+			this.#_importOrigin = null;
+		}
+		return this;
+	}
+	captureUpdate(fn) {
+		const from = this.value.oplogVersion();
+		try {
+			fn();
+			this.value.commit();
+			const after = this.value.oplogVersion();
+			try {
+				if (from.compare(after) === 0) return null;
+				const update = fromUint8Array(this.value.export({
+					mode: "update",
+					from
+				}));
+				return update === "" ? null : update;
+			} finally {
+				after.free();
+			}
+		} finally {
+			from.free();
+		}
+	}
+	canRedo() {
+		if (!this.#_undoManager) return false;
+		return this.#_undoManager.canRedo();
+	}
+	canUndo() {
+		if (!this.#_undoManager) return false;
+		return this.#_undoManager.canUndo();
+	}
+	destroy() {}
+	get(key) {
+		if (typeof key === "undefined") return this.#_storage;
+		return this.#_storage[key];
+	}
+	encodeDiff(stateVector) {
+		if (!stateVector) return fromUint8Array(this.value.export({ mode: "update" }));
+		const from = VersionVector.decode(toUint8Array(stateVector));
+		try {
+			return fromUint8Array(this.value.export({
+				mode: "update",
+				from
+			}));
+		} finally {
+			from.free();
+		}
+	}
+	getEncodedState() {
+		return fromUint8Array(this.value.export({ mode: "snapshot" }));
+	}
+	getStateVector() {
+		const version = this.value.oplogVersion();
+		try {
+			return fromUint8Array(version.encode());
+		} finally {
+			version.free();
+		}
+	}
+	readStateVersion(encoded) {
+		if (!encoded) return [];
+		const version = VersionVector.decode(toUint8Array(encoded));
+		try {
+			return clocksFromVector(version.toJSON());
+		} finally {
+			version.free();
+		}
+	}
+	readUpdateVersion(update) {
+		if (!update) return [];
+		const meta = decodeImportBlobMeta(toUint8Array(update), false);
+		try {
+			return clocksFromVector(meta.partialEndVersionVector.toJSON());
+		} finally {
+			meta.partialStartVersionVector.free();
+			meta.partialEndVersionVector.free();
+		}
+	}
+	containsUpdate(_update) {
+		return true;
+	}
+	hasPending() {
+		return this.#_pendingSpans.isPending;
+	}
+	canDetectPending() {
+		return true;
+	}
+	toJson(type) {
+		const serialized = this.value.toJSON();
+		if (typeof type === "string") {
+			const container = this.#_storage[type];
+			if (container) return container instanceof LoroText ? container.toString() : container instanceof LoroCounter ? container.value : container.toJSON();
+			return serialized[type] ?? null;
+		}
+		const { [PLUV_ID_FIELD]: _pluvId, ...json } = serialized;
+		return json;
+	}
+	isDirty() {
+		return !!this.value.oplogFrontiers().length;
+	}
+	isEmpty() {
+		const serialized = this.value.toJSON();
+		return !serialized || !Object.keys(serialized).length;
+	}
+	rebuildStorage() {
+		if (!!Object.keys(this.#_storage).length) {
+			console.warn("Attempted to rebuild storage multiple times");
+			return this;
+		}
+		this.#_storage = Object.entries(this.#_schema.shape).reduce((acc, [key, node]) => {
+			Object.assign(acc, { [key]: getLoroShare(this.value, key, node.kind) });
+			return acc;
+		}, {});
+		return this.track();
+	}
+	redo() {
+		this.#_undoManager?.redo();
+		return this;
+	}
+	subscribe(listener) {
+		return this.value.subscribe((event) => {
+			const from = this.value.frontiersToVV(event.from);
+			let update;
+			try {
+				update = fromUint8Array(this.value.export({
+					mode: "update",
+					from
+				}));
+			} finally {
+				from.free();
+			}
+			const origin = event.by === "import" ? this.#_importOrigin ?? (event.origin || null) : event.origin || null;
+			listener({
+				doc: this,
+				local: event.by === "local",
+				origin,
+				update
+			});
+		});
+	}
+	#_import(update, origin) {
+		this.#_importOrigin = origin ?? null;
+		try {
+			this.#_pendingSpans.record(this.value.import(update));
+		} finally {
+			this.#_importOrigin = null;
+		}
+	}
+	track() {
+		if (this.#_undoManager) {
+			this.#_undoManager.clear();
+			this.#_undoManager.free();
+			this.#_undoManager = null;
+		}
+		this.#_undoManager = new UndoManager(this.value, {
+			maxUndoSteps: MAX_UNDO_STEPS,
+			mergeInterval: MERGE_INTERVAL_MS
+		});
+		return this;
+	}
+	/**
+	* @description Unlike Yjs, this method is required to be called after each loro operation.
+	* @date January 12, 2025
+	*/
+	transact(fn) {
+		fn();
+		this.value.commit();
+		return this;
+	}
+	undo() {
+		this.#_undoManager?.undo();
+		return this;
+	}
+	#_setPluvId() {
+		const text = this.value.getText(PLUV_ID_FIELD);
+		const id = typeof crypto !== "undefined" ? crypto.randomUUID() : Math.random().toString();
+		text.insert(0, id);
+	}
+};
+// src/doc/LoroSchema.ts
+var LoroSchema = class LoroSchema extends AbstractCrdtDocFactory {
+	kind = "loro.doc";
+	shape;
+	_seed;
+	constructor(shape, seed) {
+		super();
+		this.shape = shape;
+		this._seed = seed;
+	}
+	toJSON() {
+		return createSchemaNode("loro.doc", { shape: this.shape }).toJSON();
+	}
+	getEmpty() {
+		return new CrdtLoroDoc(this);
+	}
+	getFactory(seed) {
+		return new LoroSchema(this.shape, seed ?? this._seed);
+	}
+	getInitialized(seed) {
+		return new CrdtLoroDoc(this, seed ?? this._seed, true);
+	}
+};
+// src/schema/nodes.ts
+const loroList = (item) => {
+	assertNotOptional(item, "loro.loroList item");
+	return createSchemaNode("loroList", { item });
+};
+const loroMap = (value) => {
+	assertNotOptional(value, "loro.loroMap value");
+	return createSchemaNode("loroMap", { value });
+};
+const loroText = () => {
+	return createSchemaNode("loroText", {});
+};
+const loroMovableList = (item) => {
+	assertNotOptional(item, "loro.loroMovableList item");
+	return createSchemaNode("loroMovableList", { item });
+};
+const loroCounter = () => {
+	return createSchemaNode("loroCounter", {});
+};
+const loroTree = () => {
+	return createSchemaNode("loroTree", {});
+};
+// src/schema/fromJSON.ts
+const fromJSON$1 = (ast) => {
+	switch (ast.kind) {
+		case "loroList": return loroList(fromJSON$1(ast.item));
+		case "loroMap": return loroMap(fromJSON$1(ast.value));
+		case "loroText": return loroText();
+		case "loroMovableList": return loroMovableList(fromJSON$1(ast.item));
+		case "loroCounter": return loroCounter();
+		case "loroTree": return loroTree();
+		default:
+			if (isLoroCrdtKind(ast.kind)) throw new CrdtSchemaError(`Unhandled Loro schema kind "${ast.kind}"`);
+			return fromJSON(ast);
+	}
+};
+// src/schema/schema.ts
+const schema = (shape) => {
+	Object.entries(shape).forEach(([key, node]) => {
+		if (!isSchemaNode(node)) throw new CrdtSchemaError(`loro.schema field "${key}" must be a schema node`);
+		if (isYjsCrdtKind(node.kind)) throw new CrdtSchemaError(`loro.schema field "${key}" cannot be a Yjs node`);
+		if (!isLoroCrdtKind(node.kind)) throw new CrdtSchemaError(`loro.schema field "${key}" must be a Loro CRDT node`);
+	});
+	return new LoroSchema(shape);
+};
+schema.fromJSON = (ast) => {
+	if (ast.kind !== "loro.doc") throw new CrdtSchemaError(`Expected kind "loro.doc", received "${ast.kind}"`);
+	const shapeAst = ast.shape ?? {};
+	const shape = Object.entries(shapeAst).reduce((acc, [key, value]) => {
+		acc[key] = fromJSON$1(value);
+		return acc;
+	}, {});
+	return schema(shape);
+};
+// src/doc/doc.ts
+const doc = (_value) => {
+	return schema({});
+};
+// src/list.ts
+const list = (value = []) => {
+	const container = new LoroList();
+	value.forEach((item, i) => {
+		if (isContainer(item)) container.insertContainer(i, item);
+		else container.insert(i, item);
+	});
+	return container;
+};
+// src/map.ts
+const map = (value = []) => {
+	const container = new LoroMap();
+	value.forEach(([key, item]) => {
+		if (isContainer(item)) container.setContainer(key, item);
+		else container.set(key, item);
+	});
+	return container;
+};
+// src/movableList.ts
+const movableList = (value = []) => {
+	const container = new LoroMovableList();
+	value.forEach((item, i) => {
+		if (isContainer(item)) container.insertContainer(i, item);
+		else container.insert(i, item);
+	});
+	return container;
+};
+// src/object.ts
+const object = (value) => {
+	const container = new LoroMap();
+	Object.entries(value).forEach(([key, item]) => {
+		if (isContainer(item)) container.setContainer(key, item);
+		else container.set(key, item);
+	});
+	return container;
+};
+// src/text.ts
+const text = (value = "") => {
+	const container = new LoroText();
+	if (value) container.insert(0, value);
+	return container;
+};
+// src/tree.ts
+const tree = () => {
+	return new LoroTree();
+};
+// src/loro.ts
+var loro_exports = /* @__PURE__ */ __exportAll({
+	CrdtLoroDoc: () => CrdtLoroDoc,
+	counter: () => counter,
+	doc: () => doc,
+	kind: () => kind,
+	list: () => list,
+	loroCounter: () => loroCounter,
+	loroList: () => loroList,
+	loroMap: () => loroMap,
+	loroMovableList: () => loroMovableList,
+	loroText: () => loroText,
+	loroTree: () => loroTree,
+	map: () => map,
+	movableList: () => movableList,
+	object: () => object,
+	schema: () => schema,
+	text: () => text,
+	tree: () => tree
+});
+const kind = "loro";
+export { loro_exports as loro };
+
+//# sourceMappingURL=browser.mjs.map