mobx-keystone-yjs
Version:
Yjs bindings for mobx-keystone
742 lines • 97.8 kB
JavaScript
var __defProp = Object.defineProperty;
var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
import { createAtom, reaction, observe, computed, action, remove } from "mobx";
import { createContext, Model, tProp, types, frozen, getParentToChildPath, onSnapshot, model, frozenKey, modelTypeKey, DeepChangeType, modelSnapshotOutWithMetadata, resolvePath, runUnprotected, isModel, getSnapshot, getSnapshotModelId, isFrozenSnapshot, fromSnapshot, onGlobalDeepChange, onDeepChange, isTreeNode } from "mobx-keystone";
import * as Y from "yjs";
class MobxKeystoneYjsError extends Error {
constructor(msg) {
super(msg);
Object.setPrototypeOf(this, MobxKeystoneYjsError.prototype);
}
}
function failure(msg) {
return new MobxKeystoneYjsError(msg);
}
const yjsCollectionAtoms = /* @__PURE__ */ new WeakMap();
const getYjsCollectionAtom = (yjsCollection) => {
return yjsCollectionAtoms.get(yjsCollection);
};
const getOrCreateYjsCollectionAtom = (yjsCollection) => {
let atom = yjsCollectionAtoms.get(yjsCollection);
if (!atom) {
atom = createAtom(`yjsCollectionAtom`);
yjsCollectionAtoms.set(yjsCollection, atom);
}
return atom;
};
function isYjsValueDeleted(yjsValue) {
var _a, _b;
if (yjsValue instanceof Y.AbstractType) {
return !!((_a = yjsValue._item) == null ? void 0 : _a.deleted) || !!((_b = yjsValue.doc) == null ? void 0 : _b.isDestroyed);
}
return false;
}
function resolveYjsPath(yjsObject, path) {
let currentYjsObject = yjsObject;
let i = -1;
for (const pathPart of path) {
i++;
if (currentYjsObject instanceof Y.Text) {
return currentYjsObject;
}
if (currentYjsObject instanceof Y.Map) {
getOrCreateYjsCollectionAtom(currentYjsObject).reportObserved();
const key = String(pathPart);
currentYjsObject = currentYjsObject.get(key);
} else if (currentYjsObject instanceof Y.Array) {
getOrCreateYjsCollectionAtom(currentYjsObject).reportObserved();
const key = Number(pathPart);
currentYjsObject = currentYjsObject.get(key);
} else {
throw failure(
`Y.Map or Y.Array was expected at path ${JSON.stringify(
path.slice(0, i)
)} in order to resolve path ${JSON.stringify(path)}, but got ${currentYjsObject} instead`
);
}
}
return currentYjsObject;
}
const yjsBindingContext = createContext(void 0);
var __defProp2 = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __decorateClass = (decorators, target, key, kind) => {
var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
for (var i = decorators.length - 1, decorator; i >= 0; i--)
if (decorator = decorators[i])
result = (kind ? decorator(target, key, result) : decorator(result)) || result;
if (kind && result) __defProp2(target, key, result);
return result;
};
const deltaListType = types.array(types.frozen(types.unchecked()));
const yjsTextModelId = "mobx-keystone-yjs/YjsTextModel";
let YjsTextModel = class extends Model({
deltaList: tProp(deltaListType, () => [])
}) {
constructor() {
super(...arguments);
/**
* Atom that gets changed when the associated Y.js text changes.
*/
__publicField(this, "yjsTextChangedAtom", createAtom("yjsTextChangedAtom"));
}
/**
* Helper function to create a YjsTextModel instance with a simple text.
*/
static withText(text) {
return new DecoratedYjsTextModel({
deltaList: [
frozen([
{
insert: text
}
])
]
});
}
get _yjsObjectPath() {
const ctx = yjsBindingContext.get(this);
if ((ctx == null ? void 0 : ctx.boundObject) == null) {
throw failure(
"the YjsTextModel instance must be part of a bound object before it can be accessed"
);
}
const path = getParentToChildPath(ctx.boundObject, this);
if (!path) {
throw failure("a path from the bound object to the YjsTextModel instance is not available");
}
return path;
}
get _yjsObjectAtPath() {
const path = this._yjsObjectPath;
const ctx = yjsBindingContext.get(this);
return resolveYjsPath(ctx.yjsObject, path);
}
get yjsText() {
const yjsObject = this._yjsObjectAtPath;
if (!(yjsObject instanceof Y.Text)) {
throw failure(`Y.Text was expected at path ${JSON.stringify(this._yjsObjectPath)}`);
}
return yjsObject;
}
get text() {
this.yjsTextChangedAtom.reportObserved();
const ctx = yjsBindingContext.get(this);
if ((ctx == null ? void 0 : ctx.boundObject) != null) {
try {
const yjsTextString = this.yjsText.toString();
if (yjsTextString !== "" || this.deltaList.length === 0) {
return yjsTextString;
}
} catch {
}
}
return this.deltaListToText();
}
deltaListToText() {
const doc = new Y.Doc();
const text = doc.getText();
this.deltaList.forEach((d) => {
text.applyDelta(d.data);
});
return text.toString();
}
onInit() {
const shouldReplicateToYjs = (ctx) => {
return !!ctx && !!ctx.boundObject && !ctx.isApplyingYjsChangesToMobxKeystone;
};
let reapplyDeltasToYjsText = false;
const newDeltas = [];
let disposeObserveDeltaList;
const disposeReactionToDeltaListRefChange = reaction(
() => this.$.deltaList,
(deltaList) => {
disposeObserveDeltaList == null ? void 0 : disposeObserveDeltaList();
disposeObserveDeltaList = void 0;
disposeObserveDeltaList = observe(deltaList, (change) => {
if (reapplyDeltasToYjsText) {
return;
}
if (!shouldReplicateToYjs(yjsBindingContext.get(this))) {
return;
}
if (change.type === "splice" && change.removedCount === 0 && change.addedCount > 0 && change.index === this.deltaList.length) {
newDeltas.push(...change.added);
} else {
reapplyDeltasToYjsText = true;
}
});
},
{ fireImmediately: true }
);
const disposeOnSnapshot = onSnapshot(this, () => {
try {
if (reapplyDeltasToYjsText) {
const ctx = yjsBindingContext.get(this);
if (shouldReplicateToYjs(ctx)) {
const { yjsText } = this;
if (isYjsValueDeleted(yjsText)) {
throw failure("cannot reapply deltas to deleted Yjs.Text");
}
ctx.yjsDoc.transact(() => {
if (yjsText.length > 0) {
yjsText.delete(0, yjsText.length);
}
this.deltaList.forEach((frozenDeltas) => {
yjsText.applyDelta(frozenDeltas.data);
});
}, ctx.yjsOrigin);
}
} else if (newDeltas.length > 0) {
const ctx = yjsBindingContext.get(this);
if (shouldReplicateToYjs(ctx)) {
const { yjsText } = this;
if (isYjsValueDeleted(yjsText)) {
throw failure("cannot reapply deltas to deleted Yjs.Text");
}
ctx.yjsDoc.transact(() => {
newDeltas.forEach((frozenDeltas) => {
yjsText.applyDelta(frozenDeltas.data);
});
}, ctx.yjsOrigin);
}
}
} finally {
reapplyDeltasToYjsText = false;
newDeltas.length = 0;
}
});
const diposeYjsTextChangedAtom = hookYjsTextChangedAtom(
() => this.yjsText,
this.yjsTextChangedAtom
);
return () => {
disposeOnSnapshot();
disposeReactionToDeltaListRefChange();
disposeObserveDeltaList == null ? void 0 : disposeObserveDeltaList();
disposeObserveDeltaList = void 0;
diposeYjsTextChangedAtom();
};
}
};
__decorateClass([
computed
], YjsTextModel.prototype, "_yjsObjectPath", 1);
__decorateClass([
computed
], YjsTextModel.prototype, "_yjsObjectAtPath", 1);
__decorateClass([
computed
], YjsTextModel.prototype, "yjsText", 1);
__decorateClass([
computed
], YjsTextModel.prototype, "text", 1);
YjsTextModel = __decorateClass([
model(yjsTextModelId)
], YjsTextModel);
const DecoratedYjsTextModel = YjsTextModel;
function hookYjsTextChangedAtom(getYjsText, textChangedAtom) {
let disposeObserveYjsText;
const observeFn = () => {
textChangedAtom.reportChanged();
};
const disposeReactionToYTextChange = reaction(
() => {
try {
const yjsText = getYjsText();
return isYjsValueDeleted(yjsText) ? void 0 : yjsText;
} catch {
return void 0;
}
},
(yjsText) => {
disposeObserveYjsText == null ? void 0 : disposeObserveYjsText();
disposeObserveYjsText = void 0;
if (yjsText) {
yjsText.observe(observeFn);
disposeObserveYjsText = () => {
yjsText.unobserve(observeFn);
};
}
textChangedAtom.reportChanged();
},
{
fireImmediately: true
}
);
return () => {
disposeReactionToYTextChange();
disposeObserveYjsText == null ? void 0 : disposeObserveYjsText();
disposeObserveYjsText = void 0;
};
}
const yjsContainerToSnapshot = /* @__PURE__ */ new WeakMap();
function setYjsContainerSnapshot(container, snapshot) {
yjsContainerToSnapshot.set(container, snapshot);
}
function isYjsContainerUpToDate(container, snapshot) {
return yjsContainerToSnapshot.get(container) === snapshot;
}
function isPlainPrimitive(v) {
const t = typeof v;
return t === "string" || t === "number" || t === "boolean" || v === null || v === void 0;
}
function isPlainArray(v) {
return Array.isArray(v);
}
function isPlainObject(v) {
return typeof v === "object" && v !== null && !Array.isArray(v);
}
function convertJsonToYjsData(v) {
if (isPlainPrimitive(v)) {
return v;
}
if (isPlainArray(v)) {
const arr = new Y.Array();
applyJsonArrayToYArray(arr, v);
return arr;
}
if (isPlainObject(v)) {
if (v[frozenKey] === true) {
return v;
}
if (v[modelTypeKey] === yjsTextModelId) {
const text = new Y.Text();
const yjsTextModel = v;
yjsTextModel.deltaList.forEach((frozenDeltas) => {
text.applyDelta(frozenDeltas.data);
});
return text;
}
const map = new Y.Map();
applyJsonObjectToYMap(map, v);
return map;
}
throw new Error(`unsupported value type: ${v}`);
}
const applyJsonArrayToYArray = (dest, source, options = {}) => {
const { mode = "add" } = options;
if (mode === "merge" && isYjsContainerUpToDate(dest, source)) {
return;
}
const srcLen = source.length;
if (mode === "add") {
for (let i = 0; i < srcLen; i++) {
dest.push([convertJsonToYjsData(source[i])]);
}
return;
}
const destLen = dest.length;
if (destLen > srcLen) {
dest.delete(srcLen, destLen - srcLen);
}
const minLen = Math.min(destLen, srcLen);
for (let i = 0; i < minLen; i++) {
const srcItem = source[i];
const destItem = dest.get(i);
if (isPlainObject(srcItem) && destItem instanceof Y.Map) {
applyJsonObjectToYMap(destItem, srcItem, options);
continue;
}
if (isPlainArray(srcItem) && destItem instanceof Y.Array) {
applyJsonArrayToYArray(destItem, srcItem, options);
continue;
}
if (isPlainPrimitive(srcItem) && destItem === srcItem) {
continue;
}
dest.delete(i, 1);
dest.insert(i, [convertJsonToYjsData(srcItem)]);
}
for (let i = destLen; i < srcLen; i++) {
dest.push([convertJsonToYjsData(source[i])]);
}
setYjsContainerSnapshot(dest, source);
};
const applyJsonObjectToYMap = (dest, source, options = {}) => {
const { mode = "add" } = options;
if (mode === "merge" && isYjsContainerUpToDate(dest, source)) {
return;
}
if (mode === "add") {
for (const k of Object.keys(source)) {
const v = source[k];
if (v !== void 0) {
dest.set(k, convertJsonToYjsData(v));
}
}
return;
}
const sourceKeysWithValues = new Set(Object.keys(source).filter((k) => source[k] !== void 0));
for (const key of dest.keys()) {
if (!sourceKeysWithValues.has(key)) {
dest.delete(key);
}
}
for (const k of Object.keys(source)) {
const v = source[k];
if (v === void 0) {
continue;
}
const existing = dest.get(k);
if (isPlainObject(v) && existing instanceof Y.Map) {
applyJsonObjectToYMap(existing, v, options);
continue;
}
if (isPlainArray(v) && existing instanceof Y.Array) {
applyJsonArrayToYArray(existing, v, options);
continue;
}
if (isPlainPrimitive(v) && existing === v) {
continue;
}
dest.set(k, convertJsonToYjsData(v));
}
setYjsContainerSnapshot(dest, source);
};
function convertValue(v) {
if (v === null || v === void 0 || typeof v !== "object") {
return v;
}
if (Array.isArray(v) && v.length === 0) {
return new Y.Array();
}
return convertJsonToYjsData(v);
}
function applyMobxChangeToYjsObject(change, yjsObject) {
if (isYjsValueDeleted(yjsObject)) {
throw failure("cannot apply patch to deleted Yjs value");
}
const yjsContainer = resolveYjsPath(yjsObject, change.path);
if (!yjsContainer) {
return;
}
if (yjsContainer instanceof Y.Array) {
if (change.type === DeepChangeType.ArraySplice) {
yjsContainer.delete(change.index, change.removedValues.length);
if (change.addedValues.length > 0) {
const valuesToInsert = change.addedValues.map(convertValue);
yjsContainer.insert(change.index, valuesToInsert);
}
} else if (change.type === DeepChangeType.ArrayUpdate) {
yjsContainer.delete(change.index, 1);
yjsContainer.insert(change.index, [convertValue(change.newValue)]);
} else {
throw failure(`unsupported array change type: ${change.type}`);
}
} else if (yjsContainer instanceof Y.Map) {
if (change.type === DeepChangeType.ObjectAdd || change.type === DeepChangeType.ObjectUpdate) {
const key = change.key;
if (change.newValue === void 0) {
yjsContainer.delete(key);
} else {
yjsContainer.set(key, convertValue(change.newValue));
}
} else if (change.type === DeepChangeType.ObjectRemove) {
const key = change.key;
yjsContainer.delete(key);
} else {
throw failure(`unsupported object change type: ${change.type}`);
}
} else if (yjsContainer instanceof Y.Text) {
return;
} else {
throw failure(`unsupported Yjs container type: ${yjsContainer}`);
}
}
const convertYjsDataToJson = action((yjsData) => {
if (yjsData instanceof Y.Array) {
return yjsData.map((v) => convertYjsDataToJson(v));
}
if (yjsData instanceof Y.Map) {
const obj = {};
yjsData.forEach((v, k) => {
obj[k] = convertYjsDataToJson(v);
});
return obj;
}
if (yjsData instanceof Y.Text) {
const deltas = yjsData.toDelta();
return modelSnapshotOutWithMetadata(YjsTextModel, {
deltaList: deltas.length > 0 ? [{ $frozen: true, data: deltas }] : []
});
}
return yjsData;
});
function applyYjsEventToMobx(event, boundObject, reconciliationMap) {
const path = event.path;
const { value: target } = resolvePath(boundObject, path);
if (!target) {
throw failure(`cannot resolve path ${JSON.stringify(path)}`);
}
runUnprotected(() => {
if (event instanceof Y.YMapEvent) {
applyYMapEventToMobx(event, target, reconciliationMap);
} else if (event instanceof Y.YArrayEvent) {
applyYArrayEventToMobx(event, target, reconciliationMap);
} else if (event instanceof Y.YTextEvent) {
applyYTextEventToMobx(event, target);
}
});
}
function processDeletedValue(val, reconciliationMap) {
if (val && typeof val === "object" && isModel(val)) {
const sn = getSnapshot(val);
const id = getSnapshotModelId(sn);
if (id) {
reconciliationMap.set(id, val);
}
}
}
function reviveValue(jsonValue, reconciliationMap) {
if (jsonValue === null || typeof jsonValue !== "object") {
return jsonValue;
}
if (isFrozenSnapshot(jsonValue)) {
return frozen(jsonValue.data);
}
if (reconciliationMap && jsonValue && typeof jsonValue === "object") {
const modelId = getSnapshotModelId(jsonValue);
if (modelId) {
const existing = reconciliationMap.get(modelId);
if (existing) {
reconciliationMap.delete(modelId);
return existing;
}
}
}
return fromSnapshot(jsonValue);
}
function applyYMapEventToMobx(event, target, reconciliationMap) {
const source = event.target;
event.changes.keys.forEach((change, key) => {
switch (change.action) {
case "add":
case "update": {
const yjsValue = source.get(key);
const jsonValue = convertYjsDataToJson(yjsValue);
if (change.action === "update") {
processDeletedValue(target[key], reconciliationMap);
}
target[key] = reviveValue(jsonValue, reconciliationMap);
break;
}
case "delete": {
processDeletedValue(target[key], reconciliationMap);
if (isModel(target)) {
remove(target.$, key);
} else {
remove(target, key);
}
break;
}
default:
throw failure(`unsupported Yjs map event action: ${change.action}`);
}
});
}
function applyYArrayEventToMobx(event, target, reconciliationMap) {
let currentIndex = 0;
for (const change of event.changes.delta) {
if (change.retain) {
currentIndex += change.retain;
}
if (change.delete) {
const deletedItems = target.slice(currentIndex, currentIndex + change.delete);
deletedItems.forEach((item) => {
processDeletedValue(item, reconciliationMap);
});
target.splice(currentIndex, change.delete);
}
if (change.insert) {
const insertedItems = Array.isArray(change.insert) ? change.insert : [change.insert];
const values = insertedItems.map((yjsValue) => {
const jsonValue = convertYjsDataToJson(yjsValue);
return reviveValue(jsonValue, reconciliationMap);
});
target.splice(currentIndex, 0, ...values);
currentIndex += values.length;
}
}
}
function applyYTextEventToMobx(event, target) {
if (target == null ? void 0 : target.deltaList) {
target.deltaList.push(frozen(event.delta));
}
}
function captureChangeSnapshots(change) {
if (change.type === DeepChangeType.ArraySplice && change.addedValues.length > 0) {
const snapshots = change.addedValues.map((v) => isTreeNode(v) ? getSnapshot(v) : v);
return { ...change, addedValues: snapshots };
} else if (change.type === DeepChangeType.ArrayUpdate) {
const snapshot = isTreeNode(change.newValue) ? getSnapshot(change.newValue) : change.newValue;
return { ...change, newValue: snapshot };
} else if (change.type === DeepChangeType.ObjectAdd || change.type === DeepChangeType.ObjectUpdate) {
const snapshot = isTreeNode(change.newValue) ? getSnapshot(change.newValue) : change.newValue;
return { ...change, newValue: snapshot };
}
return change;
}
function bindYjsToMobxKeystone({
yjsDoc,
yjsObject,
mobxKeystoneType
}) {
const yjsOrigin = /* @__PURE__ */ Symbol("bindYjsToMobxKeystoneTransactionOrigin");
let applyingYjsChangesToMobxKeystone = 0;
const bindingContext = {
yjsDoc,
yjsObject,
mobxKeystoneType,
yjsOrigin,
boundObject: void 0,
// not yet created
get isApplyingYjsChangesToMobxKeystone() {
return applyingYjsChangesToMobxKeystone > 0;
}
};
if (isYjsValueDeleted(yjsObject)) {
throw failure("cannot apply patch to deleted Yjs value");
}
const yjsJson = convertYjsDataToJson(yjsObject);
let boundObject;
let hasInitChanges = false;
const createBoundObject = () => {
const disposeGlobalListener = onGlobalDeepChange((_target, change) => {
if (change.isInit) {
hasInitChanges = true;
}
});
try {
const result = yjsBindingContext.apply(
() => fromSnapshot(mobxKeystoneType, yjsJson),
bindingContext
);
yjsBindingContext.set(result, { ...bindingContext, boundObject: result });
return result;
} finally {
disposeGlobalListener();
}
};
boundObject = createBoundObject();
const observeDeepCb = action((events) => {
const eventsToApply = [];
events.forEach((event) => {
var _a;
if (event.transaction.origin !== yjsOrigin) {
eventsToApply.push(event);
}
if (event.target instanceof Y.Map || event.target instanceof Y.Array) {
(_a = getYjsCollectionAtom(event.target)) == null ? void 0 : _a.reportChanged();
}
});
if (eventsToApply.length > 0) {
applyingYjsChangesToMobxKeystone++;
try {
const reconciliationMap = /* @__PURE__ */ new Map();
const initChanges = [];
const disposeGlobalListener = onGlobalDeepChange((target, change) => {
if (change.isInit) {
initChanges.push({ target, change: captureChangeSnapshots(change) });
}
});
try {
eventsToApply.forEach((event) => {
applyYjsEventToMobx(event, boundObject, reconciliationMap);
});
} finally {
disposeGlobalListener();
}
if (initChanges.length > 0 && !isYjsValueDeleted(yjsObject)) {
yjsDoc.transact(() => {
for (const { target, change } of initChanges) {
const pathToTarget = getParentToChildPath(boundObject, target);
if (pathToTarget !== void 0) {
const changeWithCorrectPath = {
...change,
path: [...pathToTarget, ...change.path]
};
applyMobxChangeToYjsObject(changeWithCorrectPath, yjsObject);
}
}
}, yjsOrigin);
}
if (yjsObject instanceof Y.Map || yjsObject instanceof Y.Array) {
setYjsContainerSnapshot(yjsObject, getSnapshot(boundObject));
}
} finally {
applyingYjsChangesToMobxKeystone--;
}
}
});
yjsObject.observeDeep(observeDeepCb);
let pendingChanges = [];
const disposeOnDeepChange = onDeepChange(boundObject, (change) => {
if (applyingYjsChangesToMobxKeystone > 0) {
return;
}
if (change.isInit) {
return;
}
pendingChanges.push(captureChangeSnapshots(change));
});
const disposeOnSnapshot = onSnapshot(boundObject, (boundObjectSnapshot) => {
if (pendingChanges.length === 0) {
return;
}
const changesToApply = pendingChanges;
pendingChanges = [];
if (isYjsValueDeleted(yjsObject)) {
return;
}
yjsDoc.transact(() => {
changesToApply.forEach((change) => {
applyMobxChangeToYjsObject(change, yjsObject);
});
}, yjsOrigin);
if (yjsObject instanceof Y.Map || yjsObject instanceof Y.Array) {
setYjsContainerSnapshot(yjsObject, boundObjectSnapshot);
}
});
const finalSnapshot = getSnapshot(boundObject);
if (hasInitChanges) {
yjsDoc.transact(() => {
if (yjsObject instanceof Y.Map) {
applyJsonObjectToYMap(yjsObject, finalSnapshot, {
mode: "merge"
});
} else if (yjsObject instanceof Y.Array) {
applyJsonArrayToYArray(yjsObject, finalSnapshot, {
mode: "merge"
});
}
}, yjsOrigin);
}
if (yjsObject instanceof Y.Map || yjsObject instanceof Y.Array) {
setYjsContainerSnapshot(yjsObject, finalSnapshot);
}
const dispose = () => {
yjsDoc.off("destroy", dispose);
disposeOnDeepChange();
disposeOnSnapshot();
yjsObject.unobserveDeep(observeDeepCb);
};
yjsDoc.on("destroy", dispose);
return {
boundObject,
dispose,
yjsOrigin
};
}
export {
MobxKeystoneYjsError,
YjsTextModel,
applyJsonArrayToYArray,
applyJsonObjectToYMap,
bindYjsToMobxKeystone,
convertJsonToYjsData,
yjsBindingContext,
yjsTextModelId
};
//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"mobx-keystone-yjs.esm.mjs","sources":["../src/utils/error.ts","../src/utils/getOrCreateYjsCollectionAtom.ts","../src/utils/isYjsValueDeleted.ts","../src/binding/resolveYjsPath.ts","../src/binding/yjsBindingContext.ts","../src/binding/YjsTextModel.ts","../src/binding/yjsSnapshotTracking.ts","../src/binding/convertJsonToYjsData.ts","../src/binding/applyMobxChangeToYjsObject.ts","../src/binding/convertYjsDataToJson.ts","../src/binding/applyYjsEventToMobx.ts","../src/binding/bindYjsToMobxKeystone.ts"],"sourcesContent":["/**\r\n * A mobx-keystone-yjs error.\r\n */\r\nexport class MobxKeystoneYjsError extends Error {\r\n  constructor(msg: string) {\r\n    super(msg)\r\n\r\n    // Set the prototype explicitly.\r\n    Object.setPrototypeOf(this, MobxKeystoneYjsError.prototype)\r\n  }\r\n}\r\n\r\n/**\r\n * @internal\r\n */\r\nexport function failure(msg: string) {\r\n  return new MobxKeystoneYjsError(msg)\r\n}\r\n","import { createAtom, IAtom } from \"mobx\"\nimport * as Y from \"yjs\"\n\nconst yjsCollectionAtoms = new WeakMap<Y.Map<unknown> | Y.Array<unknown>, IAtom>()\n\n/**\n * @internal\n */\nexport const getYjsCollectionAtom = (\n  yjsCollection: Y.Map<unknown> | Y.Array<unknown>\n): IAtom | undefined => {\n  return yjsCollectionAtoms.get(yjsCollection)\n}\n\n/**\n * @internal\n */\nexport const getOrCreateYjsCollectionAtom = (\n  yjsCollection: Y.Map<unknown> | Y.Array<unknown>\n): IAtom => {\n  let atom = yjsCollectionAtoms.get(yjsCollection)\n  if (!atom) {\n    atom = createAtom(`yjsCollectionAtom`)\n    yjsCollectionAtoms.set(yjsCollection, atom)\n  }\n  return atom\n}\n","import * as Y from \"yjs\"\n\n/**\n * Checks if a Y.js value has been deleted or its document destroyed.\n *\n * @param yjsValue The Y.js value to check.\n * @returns `true` if the value is deleted or destroyed, `false` otherwise.\n */\nexport function isYjsValueDeleted(yjsValue: unknown): boolean {\n  if (yjsValue instanceof Y.AbstractType) {\n    return !!(yjsValue as any)._item?.deleted || !!yjsValue.doc?.isDestroyed\n  }\n  return false\n}\n","import * as Y from \"yjs\"\nimport { failure } from \"../utils/error\"\nimport { getOrCreateYjsCollectionAtom } from \"../utils/getOrCreateYjsCollectionAtom\"\n\n/**\n * Resolves a path within a Yjs object structure.\n * Returns the Yjs container at the specified path.\n *\n * When a Y.Text is encountered during path resolution (either at the start\n * or mid-path), it is returned immediately since Y.Text doesn't support\n * nested path traversal.\n *\n * @param yjsObject The root Yjs object\n * @param path Array of keys/indices to traverse\n * @returns The Yjs container at the path, or Y.Text if encountered during traversal\n */\nexport function resolveYjsPath(\n  yjsObject: Y.Map<unknown> | Y.Array<unknown> | Y.Text,\n  path: readonly (string | number)[]\n): unknown {\n  let currentYjsObject: unknown = yjsObject\n\n  let i = -1\n  for (const pathPart of path) {\n    i++\n    // If we encounter a Y.Text during path resolution, return it immediately.\n    // Y.Text objects don't support nested path traversal, and their updates\n    // are handled separately by YjsTextModel's own synchronization mechanism.\n    if (currentYjsObject instanceof Y.Text) {\n      return currentYjsObject\n    }\n\n    if (currentYjsObject instanceof Y.Map) {\n      getOrCreateYjsCollectionAtom(currentYjsObject).reportObserved()\n      const key = String(pathPart)\n      currentYjsObject = currentYjsObject.get(key)\n    } else if (currentYjsObject instanceof Y.Array) {\n      getOrCreateYjsCollectionAtom(currentYjsObject).reportObserved()\n      const key = Number(pathPart)\n      currentYjsObject = currentYjsObject.get(key)\n    } else {\n      throw failure(\n        `Y.Map or Y.Array was expected at path ${JSON.stringify(\n          path.slice(0, i)\n        )} in order to resolve path ${JSON.stringify(path)}, but got ${currentYjsObject} instead`\n      )\n    }\n  }\n\n  return currentYjsObject\n}\n","import { AnyType, createContext } from \"mobx-keystone\"\nimport * as Y from \"yjs\"\n\n/**\n * Context with info on how a mobx-keystone model is bound to a Y.js data structure.\n */\nexport interface YjsBindingContext {\n  /**\n   * The Y.js document.\n   */\n  yjsDoc: Y.Doc\n\n  /**\n   * The bound Y.js data structure.\n   */\n  yjsObject: Y.Map<unknown> | Y.Array<unknown> | Y.Text\n\n  /**\n   * The mobx-keystone model type.\n   */\n  mobxKeystoneType: AnyType\n\n  /**\n   * The origin symbol used for transactions.\n   */\n  yjsOrigin: symbol\n\n  /**\n   * The bound mobx-keystone instance.\n   */\n  boundObject: unknown\n\n  /**\n   * Whether we are currently applying Y.js changes to the mobx-keystone model.\n   */\n  isApplyingYjsChangesToMobxKeystone: boolean\n}\n\n/**\n * Context with info on how a mobx-keystone model is bound to a Y.js data structure.\n */\nexport const yjsBindingContext = createContext<YjsBindingContext | undefined>(undefined)\n","import { computed, createAtom, IAtom, observe, reaction } from \"mobx\"\nimport {\n  Frozen,\n  frozen,\n  getParentToChildPath,\n  Model,\n  model,\n  onSnapshot,\n  tProp,\n  types,\n} from \"mobx-keystone\"\nimport * as Y from \"yjs\"\nimport { failure } from \"../utils/error\"\nimport { isYjsValueDeleted } from \"../utils/isYjsValueDeleted\"\nimport { resolveYjsPath } from \"./resolveYjsPath\"\nimport { YjsBindingContext, yjsBindingContext } from \"./yjsBindingContext\"\n\n// Delta[][], since each single change is a Delta[]\n// we use frozen so that we can reuse each delta change\nconst deltaListType = types.array(types.frozen(types.unchecked<unknown[]>()))\n\nexport const yjsTextModelId = \"mobx-keystone-yjs/YjsTextModel\"\n\n/**\n * A mobx-keystone model that represents a Yjs.Text object.\n */\n@model(yjsTextModelId)\nexport class YjsTextModel extends Model({\n  deltaList: tProp(deltaListType, () => []),\n}) {\n  /**\n   * Helper function to create a YjsTextModel instance with a simple text.\n   */\n  static withText(text: string): YjsTextModel {\n    return new DecoratedYjsTextModel({\n      deltaList: [\n        frozen([\n          {\n            insert: text,\n          },\n        ]),\n      ],\n    })\n  }\n\n  /**\n   * The Y.js path from the bound object to the YjsTextModel instance.\n   */\n  @computed\n  private get _yjsObjectPath() {\n    const ctx = yjsBindingContext.get(this)\n    if (ctx?.boundObject == null) {\n      throw failure(\n        \"the YjsTextModel instance must be part of a bound object before it can be accessed\"\n      )\n    }\n\n    const path = getParentToChildPath(ctx.boundObject, this)\n    if (!path) {\n      throw failure(\"a path from the bound object to the YjsTextModel instance is not available\")\n    }\n\n    return path\n  }\n\n  /**\n   * The Yjs.Text object present at this mobx-keystone node's path.\n   */\n  @computed\n  private get _yjsObjectAtPath(): unknown {\n    const path = this._yjsObjectPath\n\n    const ctx = yjsBindingContext.get(this)!\n\n    return resolveYjsPath(ctx.yjsObject, path)\n  }\n\n  /**\n   * The Yjs.Text object represented by this mobx-keystone node.\n   */\n  @computed\n  get yjsText(): Y.Text {\n    const yjsObject = this._yjsObjectAtPath\n\n    if (!(yjsObject instanceof Y.Text)) {\n      throw failure(`Y.Text was expected at path ${JSON.stringify(this._yjsObjectPath)}`)\n    }\n\n    return yjsObject\n  }\n\n  /**\n   * Atom that gets changed when the associated Y.js text changes.\n   */\n  yjsTextChangedAtom = createAtom(\"yjsTextChangedAtom\")\n\n  /**\n   * The text value of the Yjs.Text object.\n   * Shortcut for `yjsText.toString()`, but computed.\n   */\n  @computed\n  get text(): string {\n    this.yjsTextChangedAtom.reportObserved()\n\n    const ctx = yjsBindingContext.get(this)\n    if (ctx?.boundObject != null) {\n      try {\n        const yjsTextString = this.yjsText.toString()\n        // if the yjsText is detached, toString() returns an empty string\n        // in that case we should use the deltaList as a fallback\n        if (yjsTextString !== \"\" || this.deltaList.length === 0) {\n          return yjsTextString\n        }\n      } catch {\n        // fall back\n      }\n    }\n\n    // fall back to deltaList\n    return this.deltaListToText()\n  }\n\n  private deltaListToText(): string {\n    const doc = new Y.Doc()\n    const text = doc.getText()\n    this.deltaList.forEach((d) => {\n      text.applyDelta(d.data)\n    })\n    return text.toString()\n  }\n\n  protected onInit() {\n    const shouldReplicateToYjs = (ctx: YjsBindingContext | undefined): ctx is YjsBindingContext => {\n      return !!ctx && !!ctx.boundObject && !ctx.isApplyingYjsChangesToMobxKeystone\n    }\n\n    let reapplyDeltasToYjsText = false\n    const newDeltas: Frozen<unknown[]>[] = []\n\n    let disposeObserveDeltaList: (() => void) | undefined\n\n    const disposeReactionToDeltaListRefChange = reaction(\n      () => this.$.deltaList,\n      (deltaList) => {\n        disposeObserveDeltaList?.()\n        disposeObserveDeltaList = undefined\n\n        disposeObserveDeltaList = observe(deltaList, (change) => {\n          if (reapplyDeltasToYjsText) {\n            // already gonna replace them all\n            return\n          }\n          if (!shouldReplicateToYjs(yjsBindingContext.get(this))) {\n            // yjs text is already up to date with these changes\n            return\n          }\n\n          if (\n            change.type === \"splice\" &&\n            change.removedCount === 0 &&\n            change.addedCount > 0 &&\n            change.index === this.deltaList.length\n          ) {\n            // optimization, just adding new ones to the end\n            newDeltas.push(...change.added)\n          } else {\n            // any other change, we need to reapply all deltas\n            reapplyDeltasToYjsText = true\n          }\n        })\n      },\n      { fireImmediately: true }\n    )\n\n    const disposeOnSnapshot = onSnapshot(this, () => {\n      try {\n        if (reapplyDeltasToYjsText) {\n          const ctx = yjsBindingContext.get(this)\n\n          if (shouldReplicateToYjs(ctx)) {\n            const { yjsText } = this\n            if (isYjsValueDeleted(yjsText)) {\n              throw failure(\"cannot reapply deltas to deleted Yjs.Text\")\n            }\n\n            ctx.yjsDoc.transact(() => {\n              // didn't find a better way than this to reapply all deltas\n              // without having to re-create the Y.Text object\n              if (yjsText.length > 0) {\n                yjsText.delete(0, yjsText.length)\n              }\n\n              this.deltaList.forEach((frozenDeltas) => {\n                yjsText.applyDelta(frozenDeltas.data)\n              })\n            }, ctx.yjsOrigin)\n          }\n        } else if (newDeltas.length > 0) {\n          const ctx = yjsBindingContext.get(this)\n\n          if (shouldReplicateToYjs(ctx)) {\n            const { yjsText } = this\n            if (isYjsValueDeleted(yjsText)) {\n              throw failure(\"cannot reapply deltas to deleted Yjs.Text\")\n            }\n\n            ctx.yjsDoc.transact(() => {\n              newDeltas.forEach((frozenDeltas) => {\n                yjsText.applyDelta(frozenDeltas.data)\n              })\n            }, ctx.yjsOrigin)\n          }\n        }\n      } finally {\n        reapplyDeltasToYjsText = false\n        newDeltas.length = 0\n      }\n    })\n\n    const diposeYjsTextChangedAtom = hookYjsTextChangedAtom(\n      () => this.yjsText,\n      this.yjsTextChangedAtom\n    )\n\n    return () => {\n      disposeOnSnapshot()\n      disposeReactionToDeltaListRefChange()\n      disposeObserveDeltaList?.()\n      disposeObserveDeltaList = undefined\n\n      diposeYjsTextChangedAtom()\n    }\n  }\n}\n\n// we use this trick just to avoid a babel bug that causes classes used inside classes not to be overriden\n// by the decorator\nconst DecoratedYjsTextModel = YjsTextModel\n\nfunction hookYjsTextChangedAtom(getYjsText: () => Y.Text, textChangedAtom: IAtom) {\n  let disposeObserveYjsText: (() => void) | undefined\n\n  const observeFn = () => {\n    textChangedAtom.reportChanged()\n  }\n\n  const disposeReactionToYTextChange = reaction(\n    () => {\n      try {\n        const yjsText = getYjsText()\n        return isYjsValueDeleted(yjsText) ? undefined : yjsText\n      } catch {\n        return undefined\n      }\n    },\n    (yjsText) => {\n      disposeObserveYjsText?.()\n      disposeObserveYjsText = undefined\n\n      if (yjsText) {\n        yjsText.observe(observeFn)\n\n        disposeObserveYjsText = () => {\n          yjsText.unobserve(observeFn)\n        }\n      }\n\n      textChangedAtom.reportChanged()\n    },\n    {\n      fireImmediately: true,\n    }\n  )\n\n  return () => {\n    disposeReactionToYTextChange()\n    disposeObserveYjsText?.()\n    disposeObserveYjsText = undefined\n  }\n}\n","import * as Y from \"yjs\"\n\n/**\n * WeakMap that tracks which snapshot each Y.js container was last synced from.\n * This is used during reconciliation to skip containers that are already up-to-date.\n *\n * The key is the Y.js container (Y.Map or Y.Array).\n * The value is the snapshot (plain object or array) that was last synced to it.\n */\nexport const yjsContainerToSnapshot = new WeakMap<Y.Map<any> | Y.Array<any>, unknown>()\n\n/**\n * Updates the snapshot tracking for a Y.js container.\n * Call this after syncing a snapshot to a Y.js container.\n */\nexport function setYjsContainerSnapshot(\n  container: Y.Map<any> | Y.Array<any>,\n  snapshot: unknown\n): void {\n  yjsContainerToSnapshot.set(container, snapshot)\n}\n\n/**\n * Gets the last synced snapshot for a Y.js container.\n * Returns undefined if the container has never been synced.\n */\nexport function getYjsContainerSnapshot(container: Y.Map<any> | Y.Array<any>): unknown {\n  return yjsContainerToSnapshot.get(container)\n}\n\n/**\n * Checks if a Y.js container is up-to-date with the given snapshot.\n * Uses reference equality to check if the snapshot is the same.\n */\nexport function isYjsContainerUpToDate(\n  container: Y.Map<any> | Y.Array<any>,\n  snapshot: unknown\n): boolean {\n  return yjsContainerToSnapshot.get(container) === snapshot\n}\n","import { frozenKey, modelTypeKey, SnapshotOutOf } from \"mobx-keystone\"\nimport * as Y from \"yjs\"\nimport { PlainArray, PlainObject, PlainPrimitive, PlainValue } from \"../plainTypes\"\nimport { YjsData } from \"./convertYjsDataToJson\"\nimport { YjsTextModel, yjsTextModelId } from \"./YjsTextModel\"\nimport { isYjsContainerUpToDate, setYjsContainerSnapshot } from \"./yjsSnapshotTracking\"\n\n/**\n * Options for applying JSON data to Y.js data structures.\n */\nexport interface ApplyJsonToYjsOptions {\n  /**\n   * The mode to use when applying JSON data to Y.js data structures.\n   * - `add`: Creates new Y.js containers for objects/arrays (default, backwards compatible)\n   * - `merge`: Recursively merges values, preserving existing container references where possible\n   */\n  mode?: \"add\" | \"merge\"\n}\n\nfunction isPlainPrimitive(v: PlainValue): v is PlainPrimitive {\n  const t = typeof v\n  return t === \"string\" || t === \"number\" || t === \"boolean\" || v === null || v === undefined\n}\n\nfunction isPlainArray(v: PlainValue): v is PlainArray {\n  return Array.isArray(v)\n}\n\nfunction isPlainObject(v: PlainValue): v is PlainObject {\n  return typeof v === \"object\" && v !== null && !Array.isArray(v)\n}\n\n/**\n * Converts a plain value to a Y.js data structure.\n * Objects are converted to Y.Maps, arrays to Y.Arrays, primitives are untouched.\n * Frozen values are a special case and they are kept as immutable plain values.\n */\nexport function convertJsonToYjsData(v: PlainValue): YjsData {\n  if (isPlainPrimitive(v)) {\n    return v\n  }\n\n  if (isPlainArray(v)) {\n    const arr = new Y.Array()\n    applyJsonArrayToYArray(arr, v)\n    return arr\n  }\n\n  if (isPlainObject(v)) {\n    if (v[frozenKey] === true) {\n      // frozen value, save as immutable object\n      return v\n    }\n\n    if (v[modelTypeKey] === yjsTextModelId) {\n      const text = new Y.Text()\n      const yjsTextModel = v as unknown as SnapshotOutOf<YjsTextModel>\n      yjsTextModel.deltaList.forEach((frozenDeltas) => {\n        text.applyDelta(frozenDeltas.data)\n      })\n      return text\n    }\n\n    const map = new Y.Map()\n    applyJsonObjectToYMap(map, v)\n    return map\n  }\n\n  throw new Error(`unsupported value type: ${v}`)\n}\n\n/**\n * Applies a JSON array to a Y.Array, using the convertJsonToYjsData to convert the values.\n *\n * @param dest The destination Y.Array.\n * @param source The source JSON array.\n * @param options Options for applying the JSON data.\n */\nexport const applyJsonArrayToYArray = (\n  dest: Y.Array<any>,\n  source: PlainArray,\n  options: ApplyJsonToYjsOptions = {}\n) => {\n  const { mode = \"add\" } = options\n\n  // In merge mode, check if the container is already up-to-date with this snapshot\n  if (mode === \"merge\" && isYjsContainerUpToDate(dest, source)) {\n    return\n  }\n\n  const srcLen = source.length\n\n  if (mode === \"add\") {\n    // Add mode: just push all items to the end\n    for (let i = 0; i < srcLen; i++) {\n      dest.push([convertJsonToYjsData(source[i])])\n    }\n    return\n  }\n\n  // Merge mode: recursively merge values, preserving existing container references\n  const destLen = dest.length\n\n  // Remove extra items from the end\n  if (destLen > srcLen) {\n    dest.delete(srcLen, destLen - srcLen)\n  }\n\n  // Update existing items\n  const minLen = Math.min(destLen, srcLen)\n  for (let i = 0; i < minLen; i++) {\n    const srcItem = source[i]\n    const destItem = dest.get(i)\n\n    // If both are objects, merge recursively\n    if (isPlainObject(srcItem) && destItem instanceof Y.Map) {\n      applyJsonObjectToYMap(destItem, srcItem, options)\n      continue\n    }\n\n    // If both are arrays, merge recursively\n    if (isPlainArray(srcItem) && destItem instanceof Y.Array) {\n      applyJsonArrayToYArray(destItem, srcItem, options)\n      continue\n    }\n\n    // Skip if primitive value is unchanged (optimization)\n    if (isPlainPrimitive(srcItem) && destItem === srcItem) {\n      continue\n    }\n\n    // Otherwise, replace the item\n    dest.delete(i, 1)\n    dest.insert(i, [convertJsonToYjsData(srcItem)])\n  }\n\n  // Add new items at the end\n  for (let i = destLen; i < srcLen; i++) {\n    dest.push([convertJsonToYjsData(source[i])])\n  }\n\n  // Update snapshot tracking after successful merge\n  setYjsContainerSnapshot(dest, source)\n}\n\n/**\n * Applies a JSON object to a Y.Map, using the convertJsonToYjsData to convert the values.\n *\n * @param dest The destination Y.Map.\n * @param source The source JSON object.\n * @param options Options for applying the JSON data.\n */\nexport const applyJsonObjectToYMap = (\n  dest: Y.Map<any>,\n  source: PlainObject,\n  options: ApplyJsonToYjsOptions = {}\n) => {\n  const { mode = \"add\" } = options\n\n  // In merge mode, check if the container is already up-to-date with this snapshot\n  if (mode === \"merge\" && isYjsContainerUpToDate(dest, source)) {\n    return\n  }\n\n  if (mode === \"add\") {\n    // Add mode: just set all values\n    for (const k of Object.keys(source)) {\n      const v = source[k]\n      if (v !== undefined) {\