@pluv/crdt-yjs 0.15.0 → 0.16.1

package/dist/index.mjs

@@ -17,52 +17,366 @@ var __spreadValues = (a, b) => {
   return a;
 };
 var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/yjs.ts
+var yjs_exports = {};
+__export(yjs_exports, {
+  CrdtYjsArray: () => CrdtYjsArray,
+  CrdtYjsDoc: () => CrdtYjsDoc,
+  CrdtYjsMap: () => CrdtYjsMap,
+  CrdtYjsObject: () => CrdtYjsObject,
+  CrdtYjsText: () => CrdtYjsText,
+  CrdtYjsXmlElement: () => CrdtYjsXmlElement,
+  CrdtYjsXmlFragment: () => CrdtYjsXmlFragment,
+  CrdtYjsXmlText: () => CrdtYjsXmlText,
+  array: () => array,
+  doc: () => doc,
+  map: () => map,
+  object: () => object,
+  xmlElement: () => xmlElement,
+  xmlFragment: () => xmlFragment,
+  xmlText: () => xmlText
+});
 
-// src/array.ts
+// src/array/CrdtYjsArray.ts
+import { AbstractCrdtType as AbstractCrdtType7 } from "@pluv/crdt";
 import { Array as YArray } from "yjs";
+
+// src/map/CrdtYjsMap.ts
+import { AbstractCrdtType } from "@pluv/crdt";
+import { Map as YMap } from "yjs";
+var CrdtYjsMap = class extends AbstractCrdtType {
+  constructor(value = []) {
+    super();
+    this.initialValue = value.map(([k, v]) => [k, toYjsValue(v)]);
+    this.value = new YMap(this.initialValue);
+  }
+  get size() {
+    return this.value.size;
+  }
+  delete(prop) {
+    this.value.delete(prop);
+    return this;
+  }
+  set(prop, value) {
+    this.value.set(prop, toYjsValue(value));
+    return this;
+  }
+  toJson() {
+    return this.value.toJSON();
+  }
+};
+
+// src/object/CrdtYjsObject.ts
+import { AbstractCrdtType as AbstractCrdtType2 } from "@pluv/crdt";
+import { Map as YMap2 } from "yjs";
+var CrdtYjsObject = class extends AbstractCrdtType2 {
+  constructor(value = {}) {
+    super();
+    this.initialValue = Object.entries(value).map(([k, v]) => [
+      k,
+      toYjsValue(v)
+    ]);
+    this.value = new YMap2(this.initialValue);
+  }
+  set(prop, value) {
+    this.value.set(prop.toString(), toYjsValue(value));
+    return this;
+  }
+  toJson() {
+    return this.value.toJSON();
+  }
+};
+
+// src/text/CrdtYjsText.ts
+import { AbstractCrdtType as AbstractCrdtType3 } from "@pluv/crdt";
+import { Text as YText } from "yjs";
+var CrdtYjsText = class extends AbstractCrdtType3 {
+  constructor(value = "") {
+    super();
+    this.initialValue = value;
+    this.value = new YText(value);
+  }
+  get length() {
+    return this.value.length;
+  }
+  delete(index, length = 1) {
+    this.value.delete(index, length);
+    return this;
+  }
+  insert(index, text2) {
+    this.value.insert(index, text2);
+    return this;
+  }
+  toJson() {
+    return this.value.toJSON();
+  }
+};
+
+// src/xmlElement/CrdtYjsXmlElement.ts
+import { AbstractCrdtType as AbstractCrdtType4 } from "@pluv/crdt";
+import { XmlElement as YXmlElement } from "yjs";
+var CrdtYjsXmlElement = class extends AbstractCrdtType4 {
+  constructor(name, children) {
+    super();
+    this.initialValue = children.map((item) => item.value);
+    this.name = name;
+    this.value = new YXmlElement(name);
+    this.push(...children);
+  }
+  get length() {
+    return this.value.length;
+  }
+  delete(index, length = 1) {
+    this.value.delete(index, length);
+    return this;
+  }
+  insert(index, ...children) {
+    const converted = children.map((child) => toYjsValue(child));
+    this.value.insert(index, converted);
+    return this;
+  }
+  push(...children) {
+    return this.insert(this.length, ...children);
+  }
+  unshift(...children) {
+    return this.insert(0, ...children);
+  }
+  toJson() {
+    return this.value.toJSON();
+  }
+};
+
+// src/xmlElement/xmlElement.ts
+var xmlElement = (name, children) => {
+  return new CrdtYjsXmlElement(name, children);
+};
+
+// src/xmlFragment/CrdtYjsXmlFragment.ts
+import { AbstractCrdtType as AbstractCrdtType5 } from "@pluv/crdt";
+import { XmlFragment as YXmlFragment } from "yjs";
+var CrdtYjsXmlFragment = class extends AbstractCrdtType5 {
+  constructor(children) {
+    super();
+    this.initialValue = children.map((item) => item.value);
+    this.value = new YXmlFragment();
+    this.push(...children);
+  }
+  get length() {
+    return this.value.length;
+  }
+  delete(index, length = 1) {
+    this.value.delete(index, length);
+    return this;
+  }
+  insert(index, ...children) {
+    const converted = children.map((child) => toYjsValue(child));
+    this.value.insert(index, converted);
+    return this;
+  }
+  push(...children) {
+    return this.insert(this.length, ...children);
+  }
+  unshift(...children) {
+    return this.insert(0, ...children);
+  }
+  toJson() {
+    return this.value.toJSON();
+  }
+};
+
+// src/xmlFragment/xmlFragment.ts
+var xmlFragment = (children) => {
+  return new CrdtYjsXmlFragment(children);
+};
+
+// src/xmlText/CrdtYjsXmlText.ts
+import { AbstractCrdtType as AbstractCrdtType6 } from "@pluv/crdt";
+import { XmlText as YXmlText } from "yjs";
+var CrdtYjsXmlText = class extends AbstractCrdtType6 {
+  constructor(value = "") {
+    super();
+    this.initialValue = value;
+    this.value = new YXmlText(value);
+  }
+  get length() {
+    return this.value.length;
+  }
+  delete(index, length = 1) {
+    this.value.delete(index, length);
+    return this;
+  }
+  insert(index, text2, attributes) {
+    this.value.insert(index, text2, attributes);
+    return this;
+  }
+  toJson() {
+    return this.value.toJSON();
+  }
+};
+
+// src/xmlText/xmlText.ts
+var xmlText = (value = "") => {
+  return new CrdtYjsXmlText(value);
+};
+
+// src/shared/isWrapper.ts
+var isWrapper = (item) => {
+  return item instanceof CrdtYjsArray || item instanceof CrdtYjsMap || item instanceof CrdtYjsObject || item instanceof CrdtYjsText || item instanceof CrdtYjsXmlElement || item instanceof CrdtYjsXmlFragment || item instanceof CrdtYjsXmlText;
+};
+
+// src/shared/toYjsValue.ts
+var toYjsValue = (item) => {
+  return isWrapper(item) ? item.value : item;
+};
+
+// src/array/CrdtYjsArray.ts
+var CrdtYjsArray = class extends AbstractCrdtType7 {
+  constructor(value = []) {
+    super();
+    const initialValue = value.map((item) => toYjsValue(item));
+    this.initialValue = initialValue;
+    this.value = new YArray();
+    this.push(...value);
+  }
+  get length() {
+    return this.value.length;
+  }
+  delete(index, length = 1) {
+    this.value.delete(index, length);
+    return this;
+  }
+  insert(index, ...items) {
+    const converted = items.map((item) => toYjsValue(item));
+    this.value.insert(index, converted);
+    return this;
+  }
+  push(...items) {
+    return this.insert(this.length, ...items);
+  }
+  unshift(...items) {
+    return this.insert(0, ...items);
+  }
+  toJson() {
+    return this.value.toJSON();
+  }
+};
+
+// src/array/array.ts
 var array = (value = []) => {
-  const yarray = new YArray();
-  yarray.push(value.slice());
-  return yarray;
+  return new CrdtYjsArray(value);
 };
 
-// src/doc.ts
+// src/doc/CrdtYjsDoc.ts
+import { AbstractCrdtDoc } from "@pluv/crdt";
 import { fromUint8Array, toUint8Array } from "js-base64";
 import {
   UndoManager,
+  Array as YArray2,
   Doc as YDoc,
+  Map as YMap3,
+  Text as YText2,
+  XmlElement as YXmlElement2,
+  XmlFragment as YXmlFragment2,
+  XmlText as YXmlText2,
   applyUpdate,
   encodeStateAsUpdate
 } from "yjs";
-var YjsDoc = class _YjsDoc {
-  constructor(value) {
+var CrdtYjsDoc = class extends AbstractCrdtDoc {
+  constructor(value = {}) {
+    super();
     this.value = new YDoc();
     this._undoManager = null;
-    if (!value)
-      return;
-    const storage = this.value.getMap("storage");
-    Object.entries(value).forEach(([key, node]) => {
-      storage.set(key, node);
-    });
-  }
-  get storage() {
-    const storage = this._storage;
-    const keys = Array.from(storage.keys());
-    return keys.reduce(
-      (acc, key) => __spreadProps(__spreadValues({}, acc), { [key]: storage.get(key) }),
-      {}
-    );
+    this._storage = Object.entries(value).reduce((acc, [key, node]) => {
+      if (node instanceof CrdtYjsArray) {
+        const yArray = this.value.get(key, YArray2);
+        yArray.insert(0, node.initialValue.slice(0));
+        node.value = yArray;
+        return __spreadProps(__spreadValues({}, acc), { [key]: node });
+      }
+      if (node instanceof CrdtYjsMap || node instanceof CrdtYjsObject) {
+        const yMap = this.value.get(key, YMap3);
+        node.initialValue.forEach(([k, v]) => {
+          yMap.set(k.toString(), v);
+        });
+        node.value = yMap;
+        return __spreadProps(__spreadValues({}, acc), { [key]: node });
+      }
+      if (node instanceof CrdtYjsObject) {
+        const yMap = this.value.get(key, YMap3);
+        node.initialValue.forEach(([k, v]) => {
+          yMap.set(k.toString(), v);
+        });
+        node.value = yMap;
+        return __spreadProps(__spreadValues({}, acc), { [key]: node });
+      }
+      if (node instanceof CrdtYjsText) {
+        const yText = this.value.get(key, YText2);
+        yText.insert(0, node.initialValue);
+        node.value = yText;
+        return __spreadProps(__spreadValues({}, acc), { [key]: node });
+      }
+      if (node instanceof CrdtYjsXmlElement) {
+        const yXmlElement = this.value.get(
+          key,
+          YXmlElement2
+        );
+        yXmlElement.insert(0, node.initialValue.slice(0));
+        node.value = yXmlElement;
+        return __spreadProps(__spreadValues({}, acc), { [key]: node });
+      }
+      if (node instanceof CrdtYjsXmlFragment) {
+        const yXmlFragment = this.value.get(
+          key,
+          YXmlFragment2
+        );
+        yXmlFragment.insert(0, node.initialValue.slice(0));
+        node.value = yXmlFragment;
+        return __spreadProps(__spreadValues({}, acc), { [key]: node });
+      }
+      if (node instanceof CrdtYjsXmlText) {
+        const yXmlText = this.value.get(key, YXmlText2);
+        yXmlText.insert(0, node.initialValue);
+        node.value = yXmlText;
+        return __spreadProps(__spreadValues({}, acc), { [key]: node });
+      }
+      return acc;
+    }, {});
   }
-  get _storage() {
-    return this.value.getMap("storage");
-  }
-  applyUpdate(update, origin) {
+  applyEncodedState(params) {
+    const { origin, update } = params;
     if (update === null || typeof update === "undefined")
       return this;
     const uint8Update = typeof update === "string" ? toUint8Array(update) : update;
     applyUpdate(this.value, uint8Update, origin);
     return this;
   }
+  batchApplyEncodedState(updates) {
+    const params = updates.reduce(
+      (acc, update) => {
+        if (!update)
+          return acc;
+        if (typeof update === "string") {
+          acc.push({ update });
+          return acc;
+        }
+        if (!!update && typeof update === "object") {
+          acc.push(update);
+          return acc;
+        }
+        return acc;
+      },
+      []
+    );
+    return params.reduce(
+      (doc2, update) => doc2.applyEncodedState(update),
+      this
+    );
+  }
   canRedo() {
     var _a;
     return !!((_a = this._undoManager) == null ? void 0 : _a.canRedo());
@@ -76,111 +390,141 @@ var YjsDoc = class _YjsDoc {
     (_a = this._undoManager) == null ? void 0 : _a.destroy();
     this.value.destroy();
   }
-  encodeStateAsUpdate() {
-    return fromUint8Array(encodeStateAsUpdate(this.value));
-  }
   get(key) {
-    return this._storage.get(key.toString());
+    if (typeof key === "undefined")
+      return this._storage;
+    return this._storage[key];
   }
-  getSharedTypes() {
-    return Array.from(this._storage.keys()).reduce(
-      (acc, key) => __spreadProps(__spreadValues({}, acc), { [key]: this._storage.get(key) }),
-      {}
-    );
+  getEncodedState() {
+    return fromUint8Array(encodeStateAsUpdate(this.value));
+  }
+  isEmpty() {
+    return !this.value.share.size;
   }
   redo() {
     var _a;
     (_a = this._undoManager) == null ? void 0 : _a.redo();
+    return this;
   }
-  subscribe(fn) {
-    const _fn = (update, origin, doc2, transaction) => fn(_YjsDoc.fromUint8Array(update), origin, doc2, transaction);
-    this.value.on("update", _fn);
+  subscribe(listener) {
+    const fn = (update, origin, doc2) => {
+      listener({
+        doc: this,
+        local: origin === null || typeof origin === "undefined",
+        origin: origin ? String(origin) : null,
+        update: fromUint8Array(update)
+      });
+    };
+    this.value.on("update", fn);
     return () => {
-      this.value.off("update", _fn);
+      this.value.off("update", fn);
     };
   }
-  toJSON() {
-    return this._storage.toJSON();
-  }
-  trackOrigins(options) {
-    const { captureTimeout, trackedOrigins } = options;
-    if (this._undoManager) {
+  track() {
+    var _a;
+    if (this._undoManager)
       this._undoManager.destroy();
+    const sharedTypes = Object.values(this._storage).reduce((acc, type) => {
+      if (type instanceof CrdtYjsArray || type instanceof CrdtYjsMap || type instanceof CrdtYjsObject || type instanceof CrdtYjsText || type instanceof CrdtYjsXmlElement || type instanceof CrdtYjsXmlFragment || type instanceof CrdtYjsXmlText) {
+        acc.push(type.value);
+      }
+      return acc;
+    }, []);
+    if (!sharedTypes.length) {
+      (_a = this._undoManager) == null ? void 0 : _a.destroy();
+      this._undoManager = null;
+      return this;
     }
-    this._undoManager = new UndoManager(this._storage, {
-      captureTimeout,
-      trackedOrigins: trackedOrigins ? new Set(trackedOrigins) : void 0
-    });
-  }
-  transact(fn, origin) {
-    this.value.transact((tx) => {
-      fn(tx);
-    }, origin);
+    this._undoManager = new UndoManager(sharedTypes, { captureTimeout: 0 });
+    return this;
   }
-  static fromUint8Array(u8a) {
-    return fromUint8Array(u8a);
+  transact(fn) {
+    this.value.transact(fn);
+    return this;
   }
-  static toUint8Array(str) {
-    return toUint8Array(str);
+  toJson() {
+    return Object.entries(this._storage).reduce(
+      (acc, [key, value]) => __spreadProps(__spreadValues({}, acc), { [key]: value.toJson() }),
+      {}
+    );
   }
   undo() {
     var _a;
     (_a = this._undoManager) == null ? void 0 : _a.undo();
+    return this;
   }
 };
-var doc = (value) => {
-  return new YjsDoc(value);
-};
 
-// src/map.ts
-import { Map as YMap2 } from "yjs";
+// src/doc/CrdtYjsDocFactory.ts
+import { AbstractCrdtDocFactory } from "@pluv/crdt";
+
+// src/map/map.ts
 var map = (value = []) => {
-  return new YMap2(value);
+  return new CrdtYjsMap(value);
 };
 
-// src/object.ts
-import { Map as YMap3 } from "yjs";
+// src/object/object.ts
 var object = (value) => {
-  return new YMap3(Object.entries(value));
-};
-
-// src/text.ts
-import { Text as YText } from "yjs";
-var text = (value = "") => {
-  return new YText(value);
-};
-
-// src/xmlElement.ts
-import { XmlElement as YXmlElement } from "yjs";
-var xmlElement = (name, params = {}) => {
-  const { children = [] } = params;
-  const element = new YXmlElement(name);
-  element.push(children.slice());
-  return element;
+  return new CrdtYjsObject(value);
 };
 
-// src/xmlFragment.ts
-import { XmlFragment as YXmlFragment } from "yjs";
-var xmlFragment = (params = {}) => {
-  const { children = [] } = params;
-  const fragment = new YXmlFragment();
-  fragment.push(children.slice());
-  return fragment;
+// src/doc/CrdtYjsDocFactory.ts
+var CrdtYjsDocFactory = class _CrdtYjsDocFactory extends AbstractCrdtDocFactory {
+  constructor(initialStorage = () => ({})) {
+    super();
+    this._initialStorage = initialStorage;
+  }
+  getEmpty() {
+    return new CrdtYjsDoc();
+  }
+  getFactory(initialStorage) {
+    return new _CrdtYjsDocFactory(
+      initialStorage != null ? initialStorage : this._initialStorage
+    );
+  }
+  getFresh() {
+    const storage = this._initialStorage();
+    return new CrdtYjsDoc(
+      Object.entries(storage).reduce((acc, [key, node]) => {
+        if (node instanceof CrdtYjsArray) {
+          return __spreadProps(__spreadValues({}, acc), { [key]: new CrdtYjsArray([]) });
+        }
+        if (node instanceof CrdtYjsMap) {
+          return __spreadProps(__spreadValues({}, acc), { [key]: new CrdtYjsMap([]) });
+        }
+        if (node instanceof CrdtYjsObject) {
+          return __spreadProps(__spreadValues({}, acc), { [key]: new CrdtYjsObject({}) });
+        }
+        if (node instanceof CrdtYjsText) {
+          return __spreadProps(__spreadValues({}, acc), { [key]: new CrdtYjsText("") });
+        }
+        if (node instanceof CrdtYjsXmlElement) {
+          return __spreadProps(__spreadValues({}, acc), {
+            [key]: new CrdtYjsXmlElement(node.name, [])
+          });
+        }
+        if (node instanceof CrdtYjsXmlFragment) {
+          return __spreadProps(__spreadValues({}, acc), { [key]: new CrdtYjsXmlFragment([]) });
+        }
+        if (node instanceof CrdtYjsXmlText) {
+          return __spreadProps(__spreadValues({}, acc), { [key]: new CrdtYjsXmlText("") });
+        }
+        return acc;
+      }, {})
+    );
+  }
+  getInitialized(initialStorage) {
+    var _a;
+    return new CrdtYjsDoc(
+      (_a = initialStorage == null ? void 0 : initialStorage()) != null ? _a : this._initialStorage()
+    );
+  }
 };
 
-// src/xmlText.ts
-import { XmlText as YXmlText } from "yjs";
-var xmlText = (value = "") => {
-  return new YXmlText(value);
+// src/doc/doc.ts
+var doc = (value = () => ({})) => {
+  return new CrdtYjsDocFactory(value);
 };
 export {
-  YjsDoc,
-  array,
-  doc,
-  map,
-  object,
-  text,
-  xmlElement,
-  xmlFragment,
-  xmlText
+  yjs_exports as yjs
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pluv/crdt-yjs",
-  "version": "0.15.0",
+  "version": "0.16.1",
   "description": "yjs for @pluv/io",
   "author": "leedavidcs",
   "license": "MIT",
@@ -17,19 +17,20 @@
     "access": "public"
   },
   "dependencies": {
-    "js-base64": "^3.7.5",
-    "@pluv/types": "^0.15.0"
+    "js-base64": "^3.7.6",
+    "@pluv/crdt": "^0.16.1",
+    "@pluv/types": "^0.16.1"
   },
   "peerDependencies": {
     "yjs": "^13.0.0"
   },
   "devDependencies": {
     "eslint": "^8.56.0",
-    "tsup": "^8.0.1",
-    "typescript": "^5.2.2",
-    "yjs": "^13.6.10",
-    "@pluv/tsconfig": "^0.15.0",
-    "eslint-config-pluv": "^0.15.0"
+    "tsup": "^8.0.2",
+    "typescript": "^5.3.3",
+    "yjs": "^13.6.12",
+    "@pluv/tsconfig": "^0.16.1",
+    "eslint-config-pluv": "^0.16.1"
   },
   "scripts": {
     "build": "tsup src/index.ts --format esm,cjs --dts",

package/src/array/CrdtYjsArray.ts

@@ -0,0 +1,55 @@
+import type { InferCrdtStorageJson } from "@pluv/crdt";
+import { AbstractCrdtType } from "@pluv/crdt";
+import { Array as YArray } from "yjs";
+import { toYjsValue } from "../shared";
+import type { InferYjsJson, InferYjsType } from "../types";
+
+export class CrdtYjsArray<T extends unknown> extends AbstractCrdtType<
+    YArray<InferYjsType<T>>,
+    InferYjsJson<T>[]
+> {
+    public readonly initialValue:
+        | InferYjsType<T>[]
+        | readonly InferYjsType<T>[];
+    public value: YArray<InferYjsType<T>>;
+
+    constructor(value: T[] | readonly T[] = []) {
+        super();
+
+        const initialValue = value.map((item) => toYjsValue(item));
+
+        this.initialValue = initialValue;
+        this.value = new YArray<InferYjsType<T>>();
+        this.push(...value);
+    }
+
+    public get length(): number {
+        return this.value.length;
+    }
+
+    public delete(index: number, length: number = 1): this {
+        this.value.delete(index, length);
+
+        return this;
+    }
+
+    public insert(index: number, ...items: T[]): this {
+        const converted = items.map((item) => toYjsValue(item));
+
+        this.value.insert(index, converted);
+
+        return this;
+    }
+
+    public push(...items: T[]): this {
+        return this.insert(this.length, ...items);
+    }
+
+    public unshift(...items: T[]): this {
+        return this.insert(0, ...items);
+    }
+
+    public toJson(): InferCrdtStorageJson<InferYjsJson<T>>[] {
+        return this.value.toJSON();
+    }
+}