@pluv/crdt-loro 0.16.0

package/dist/index.js

@@ -0,0 +1,701 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  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 });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  loro: () => loro_exports
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/loro.ts
+var loro_exports = {};
+__export(loro_exports, {
+  CrdtLoroArray: () => CrdtLoroArray,
+  CrdtLoroDoc: () => CrdtLoroDoc,
+  CrdtLoroMap: () => CrdtLoroMap,
+  CrdtLoroObject: () => CrdtLoroObject,
+  CrdtLoroText: () => CrdtLoroText,
+  array: () => array,
+  doc: () => doc,
+  map: () => map,
+  object: () => object,
+  text: () => text
+});
+
+// src/array/CrdtLoroArray.ts
+var import_crdt5 = require("@pluv/crdt");
+var import_loro_crdt4 = require("loro-crdt");
+
+// src/shared/cloneType.ts
+var import_crdt4 = require("@pluv/crdt");
+
+// src/map/CrdtLoroMap.ts
+var import_crdt = require("@pluv/crdt");
+var import_loro_crdt = require("loro-crdt");
+var CrdtLoroMap = class extends import_crdt.AbstractCrdtType {
+  constructor(value = []) {
+    super();
+    this._doc = null;
+    this._initialized = false;
+    this._value = new import_loro_crdt.LoroMap();
+    this.initialValue = value.map(
+      ([k, v]) => [k, v]
+    );
+  }
+  set doc(doc2) {
+    if (this._doc)
+      throw new Error("Cannot overwrite array doc");
+    this._doc = doc2;
+  }
+  get size() {
+    return this.value.size;
+  }
+  get value() {
+    return this._value;
+  }
+  set value(value) {
+    if (this._initialized)
+      throw new Error("Cannot re-assign map");
+    this._initialized = true;
+    this._value = value;
+    cloneType({ source: this, target: this.value });
+  }
+  delete(prop) {
+    var _a;
+    this._guardInitialized();
+    this.value.delete(prop);
+    (_a = this._doc) == null ? void 0 : _a.value.commit();
+    return this;
+  }
+  set(prop, value) {
+    var _a, _b;
+    this._guardInitialized();
+    if (!(value instanceof import_crdt.AbstractCrdtType)) {
+      this.value.set(prop, value);
+      (_a = this._doc) == null ? void 0 : _a.value.commit();
+      return this;
+    }
+    if (!isWrapper(value)) {
+      throw new Error("This type is not yet supported");
+    }
+    const containerType = getLoroContainerType(value);
+    const container = this.value.setContainer(prop, containerType);
+    cloneType({ source: value, target: container });
+    if (this._doc)
+      value.doc = this._doc;
+    (_b = this._doc) == null ? void 0 : _b.value.commit();
+    return this;
+  }
+  toJson() {
+    return this.value.toJson();
+  }
+  _guardInitialized() {
+    if (!this._initialized)
+      throw new Error("Array is not yet initialized");
+  }
+};
+
+// src/map/map.ts
+var map = (value = []) => {
+  return new CrdtLoroMap(value);
+};
+
+// src/object/CrdtLoroObject.ts
+var import_crdt2 = require("@pluv/crdt");
+var import_loro_crdt2 = require("loro-crdt");
+var CrdtLoroObject = class extends import_crdt2.AbstractCrdtType {
+  constructor(value) {
+    super();
+    this._doc = null;
+    this._initialized = false;
+    this._value = new import_loro_crdt2.LoroMap();
+    this.initialValue = Object.entries(value).map(
+      ([k, v]) => [k, v]
+    );
+  }
+  set doc(doc2) {
+    if (this._doc)
+      throw new Error("Cannot overwrite array doc");
+    this._doc = doc2;
+  }
+  get size() {
+    return this.value.size;
+  }
+  get value() {
+    return this._value;
+  }
+  set value(value) {
+    if (this._initialized)
+      throw new Error("Cannot re-assign map");
+    this._initialized = true;
+    this._value = value;
+    cloneType({ source: this, target: this.value });
+  }
+  set(prop, value) {
+    var _a, _b;
+    this._guardInitialized();
+    if (!(value instanceof import_crdt2.AbstractCrdtType)) {
+      this.value.set(prop, value);
+      (_a = this._doc) == null ? void 0 : _a.value.commit();
+      return this;
+    }
+    if (!isWrapper(value)) {
+      throw new Error("This type is not yet supported");
+    }
+    const containerType = getLoroContainerType(value);
+    const container = this.value.setContainer(prop, containerType);
+    cloneType({ source: value, target: container });
+    if (this._doc)
+      value.doc = this._doc;
+    (_b = this._doc) == null ? void 0 : _b.value.commit();
+    return this;
+  }
+  toJson() {
+    return this.value.toJson();
+  }
+  _guardInitialized() {
+    if (!this._initialized)
+      throw new Error("Array is not yet initialized");
+  }
+};
+
+// src/object/object.ts
+var object = (value) => {
+  return new CrdtLoroObject(value);
+};
+
+// src/text/CrdtLoroText.ts
+var import_crdt3 = require("@pluv/crdt");
+var import_loro_crdt3 = require("loro-crdt");
+var CrdtLoroText = class extends import_crdt3.AbstractCrdtType {
+  constructor(value = "") {
+    super();
+    this._doc = null;
+    this._initialized = false;
+    this._value = new import_loro_crdt3.LoroText();
+    this.initalValue = value;
+    this.value = new import_loro_crdt3.LoroText();
+  }
+  set doc(doc2) {
+    if (this._doc)
+      throw new Error("Cannot overwrite array doc");
+    this._doc = doc2;
+  }
+  get length() {
+    return this.value.length;
+  }
+  get value() {
+    return this._value;
+  }
+  set value(value) {
+    if (this._initialized)
+      throw new Error("Cannot re-assign text");
+    this._initialized = true;
+    this._value = value;
+    cloneType({ source: this, target: this.value });
+  }
+  delete(index, length = 1) {
+    var _a;
+    this._guardInitialized();
+    this.value.delete(index, length);
+    (_a = this._doc) == null ? void 0 : _a.value.commit();
+    return this;
+  }
+  insert(index, text2) {
+    var _a;
+    this._guardInitialized();
+    this.value.insert(index, text2);
+    (_a = this._doc) == null ? void 0 : _a.value.commit();
+    return this;
+  }
+  toJson() {
+    return this.value.toString();
+  }
+  _guardInitialized() {
+    if (!this._initialized)
+      throw new Error("Array is not yet initialized");
+  }
+};
+
+// src/text/text.ts
+var text = (value = "") => {
+  return new CrdtLoroText(value);
+};
+
+// src/shared/cloneType.ts
+function cloneArray(params) {
+  const { source, target } = params;
+  const items = source.initialValue;
+  items.forEach((item, i) => {
+    if (!(item instanceof import_crdt4.AbstractCrdtType)) {
+      target.insert(i, item);
+      return;
+    }
+    if (item instanceof CrdtLoroArray) {
+      const list = target.insertContainer(i, "List");
+      item.value = list;
+      cloneArray({ source: item, target: list });
+      return;
+    }
+    if (item instanceof CrdtLoroMap) {
+      const map2 = target.insertContainer(i, "Map");
+      item.value = map2;
+      cloneMap({ source: item, target: map2 });
+      return;
+    }
+    if (item instanceof CrdtLoroObject) {
+      const map2 = target.insertContainer(i, "Map");
+      item.value = map2;
+      cloneObject({ source: item, target: map2 });
+      return;
+    }
+    if (item instanceof CrdtLoroText) {
+      const text2 = target.insertContainer(i, "Text");
+      item.value = text2;
+      cloneText({ source: item, target: text2 });
+      return;
+    }
+    throw new Error("This type is not yet supported");
+  });
+}
+function cloneMap(params) {
+  const { source, target } = params;
+  const items = source.initialValue;
+  items.forEach(([key, item]) => {
+    if (!(item instanceof import_crdt4.AbstractCrdtType)) {
+      target.set(key, item);
+      return;
+    }
+    if (item instanceof CrdtLoroArray) {
+      const list = target.setContainer(key, "List");
+      item.value = list;
+      cloneArray({ source: item, target: list });
+      return;
+    }
+    if (item instanceof CrdtLoroMap) {
+      const map2 = target.setContainer(key, "Map");
+      item.value = map2;
+      cloneMap({ source: item, target: map2 });
+      return;
+    }
+    if (item instanceof CrdtLoroObject) {
+      const map2 = target.setContainer(key, "Map");
+      item.value = map2;
+      cloneObject({ source: item, target: map2 });
+      return;
+    }
+    if (item instanceof CrdtLoroText) {
+      const text2 = target.setContainer(key, "Text");
+      item.value = text2;
+      cloneText({ source: item, target: text2 });
+      return;
+    }
+    throw new Error("This type is not yet supported");
+  });
+}
+function cloneObject(params) {
+  const { source, target } = params;
+  const items = source.initialValue;
+  items.forEach(([key, item]) => {
+    if (!(item instanceof import_crdt4.AbstractCrdtType)) {
+      target.set(key, item);
+      return;
+    }
+    if (item instanceof CrdtLoroArray) {
+      const list = target.setContainer(key, "List");
+      item.value = list;
+      cloneArray({ source: item, target: list });
+      return;
+    }
+    if (item instanceof CrdtLoroMap) {
+      const map2 = target.setContainer(key, "Map");
+      item.value = map2;
+      cloneMap({ source: item, target: map2 });
+      return;
+    }
+    if (item instanceof CrdtLoroObject) {
+      const map2 = target.setContainer(key, "Map");
+      item.value = map2;
+      cloneObject({ source: item, target: map2 });
+      return;
+    }
+    if (item instanceof CrdtLoroText) {
+      const text2 = target.setContainer(key, "Text");
+      item.value = text2;
+      cloneText({ source: item, target: text2 });
+      return;
+    }
+    throw new Error("This type is not yet supported");
+  });
+}
+function cloneText(params) {
+  const { source, target } = params;
+  source.value = target;
+  source.insert(0, source.initalValue);
+}
+var cloneType = (params) => {
+  const { source, target } = params;
+  if (source instanceof CrdtLoroArray) {
+    cloneArray({ source, target });
+    return;
+  }
+  if (source instanceof CrdtLoroMap) {
+    cloneMap({ source, target });
+    return;
+  }
+  if (source instanceof CrdtLoroObject) {
+    cloneObject({ source, target });
+    return;
+  }
+  if (source instanceof CrdtLoroText) {
+    cloneText({ source, target });
+    return;
+  }
+  throw new Error("This type is not yet supported");
+};
+
+// src/shared/getLoroContainerType.ts
+var getLoroContainerType = (value) => {
+  if (value instanceof CrdtLoroArray)
+    return "List";
+  if (value instanceof CrdtLoroMap)
+    return "Map";
+  if (value instanceof CrdtLoroObject)
+    return "Map";
+  if (value instanceof CrdtLoroText)
+    return "Text";
+  throw new Error("This type is not yet supported");
+};
+
+// src/shared/isWrapper.ts
+var isWrapper = (item) => {
+  return item instanceof CrdtLoroArray || item instanceof CrdtLoroMap || item instanceof CrdtLoroObject || item instanceof CrdtLoroText;
+};
+
+// src/array/CrdtLoroArray.ts
+var CrdtLoroArray = class extends import_crdt5.AbstractCrdtType {
+  constructor(value = []) {
+    super();
+    this._doc = null;
+    this._initialized = false;
+    this._value = new import_loro_crdt4.LoroList();
+    this.initialValue = value.slice();
+  }
+  set doc(doc2) {
+    if (this._doc)
+      throw new Error("Cannot overwrite array doc");
+    this._doc = doc2;
+  }
+  get length() {
+    return this.value.length;
+  }
+  get value() {
+    return this._value;
+  }
+  set value(value) {
+    if (this._initialized)
+      throw new Error("Cannot re-assign array");
+    this._initialized = true;
+    this._value = value;
+    cloneType({ source: this, target: this.value });
+  }
+  delete(index, length = 1) {
+    var _a;
+    this._guardInitialized();
+    this.value.delete(index, length);
+    (_a = this._doc) == null ? void 0 : _a.value.commit();
+    return this;
+  }
+  insert(index, ...items) {
+    var _a;
+    this._guardInitialized();
+    items.forEach((item, i) => {
+      var _a2;
+      if (!(item instanceof import_crdt5.AbstractCrdtType)) {
+        this.value.insert(index + i, item);
+        (_a2 = this._doc) == null ? void 0 : _a2.value.commit();
+        return this;
+      }
+      if (!isWrapper(item)) {
+        throw new Error("This type is not yet supported");
+      }
+      const containerType = getLoroContainerType(item);
+      const container = this.value.insertContainer(
+        index + i,
+        containerType
+      );
+      cloneType({ source: item, target: container });
+      if (this._doc)
+        item.doc = this._doc;
+      return this;
+    });
+    (_a = this._doc) == null ? void 0 : _a.value.commit();
+    return this;
+  }
+  push(...items) {
+    return this.insert(this.length, ...items);
+  }
+  unshift(...items) {
+    return this.insert(0, ...items);
+  }
+  toJson() {
+    return this.value.toJson();
+  }
+  _guardInitialized() {
+    if (!this._initialized)
+      throw new Error("Array is not yet initialized");
+  }
+};
+
+// src/array/array.ts
+var array = (value = []) => {
+  return new CrdtLoroArray(value);
+};
+
+// src/doc/CrdtLoroDoc.ts
+var import_crdt6 = require("@pluv/crdt");
+var import_js_base64 = require("js-base64");
+var import_loro_crdt5 = require("loro-crdt");
+var CrdtLoroDoc = class extends import_crdt6.AbstractCrdtDoc {
+  constructor(value = {}) {
+    super();
+    this.value = new import_loro_crdt5.Loro();
+    this._storage = Object.entries(value).reduce((acc, [key, node]) => {
+      if (node instanceof CrdtLoroArray) {
+        const loroList = this.value.getList(key);
+        node.value = loroList;
+        node.doc = this;
+        return __spreadProps(__spreadValues({}, acc), { [key]: node });
+      }
+      if (node instanceof CrdtLoroMap || node instanceof CrdtLoroObject) {
+        const loroMap = this.value.getMap(key);
+        node.value = loroMap;
+        node.doc = this;
+        return __spreadProps(__spreadValues({}, acc), { [key]: node });
+      }
+      if (node instanceof CrdtLoroText) {
+        const loroText = this.value.getText(key);
+        node.value = loroText;
+        node.doc = this;
+        return __spreadProps(__spreadValues({}, acc), { [key]: loroText });
+      }
+      return acc;
+    }, {});
+  }
+  applyEncodedState(params) {
+    const update = typeof params.update === "string" ? (0, import_js_base64.toUint8Array)(params.update) : params.update;
+    if (!update)
+      return this;
+    this.value.import(update);
+    return this;
+  }
+  batchApplyEncodedState(updates) {
+    var _a;
+    const _updates = updates.reduce((acc, item) => {
+      if (!item)
+        return acc;
+      if (typeof item === "string") {
+        acc.push((0, import_js_base64.toUint8Array)(item));
+        return acc;
+      }
+      if (typeof item === "object") {
+        const update = typeof item.update === "string" ? (0, import_js_base64.toUint8Array)(item.update) : item.update;
+        if (!update)
+          return acc;
+        acc.push(update);
+        return acc;
+      }
+      return acc;
+    }, []);
+    if (!_updates.length)
+      return this;
+    if (_updates.length === 1) {
+      const update = (_a = _updates[0]) != null ? _a : null;
+      update && this.value.import(update);
+      return this;
+    }
+    this.value.importUpdateBatch(_updates);
+    return this;
+  }
+  /**
+   * TODO
+   * @description This method is not yet supported for loro
+   */
+  canRedo() {
+    return false;
+  }
+  /**
+   * TODO
+   * @description This method is not yet supported for loro
+   */
+  canUndo() {
+    return false;
+  }
+  destroy() {
+    return;
+  }
+  get(key) {
+    if (typeof key === "undefined")
+      return this._storage;
+    return this._storage[key];
+  }
+  getEncodedState() {
+    return (0, import_js_base64.fromUint8Array)(this.value.exportSnapshot());
+  }
+  toJson() {
+    return Object.entries(this._storage).reduce(
+      (acc, [key, value]) => __spreadProps(__spreadValues({}, acc), { [key]: value.toJson() }),
+      {}
+    );
+  }
+  isEmpty() {
+    const serialized = this.value.toJson();
+    return !serialized || !Object.keys(serialized).length;
+  }
+  /**
+   * TODO
+   * @description This method is not yet supported for loro
+   */
+  redo() {
+    throw new Error("This is not yet supported");
+  }
+  subscribe(listener) {
+    const fn = (event) => {
+      const update = (0, import_js_base64.fromUint8Array)(this.value.exportFrom());
+      listener({
+        doc: this,
+        local: event.local,
+        origin: event.origin ? String(event.origin) : null,
+        update
+      });
+    };
+    const subscriptionIds = Object.entries(this._storage).reduce(
+      (map2, [key, crdtType]) => {
+        const container = crdtType.value;
+        const subscriptionId = container.subscribe(this.value, fn);
+        return map2.set(key, subscriptionId);
+      },
+      /* @__PURE__ */ new Map()
+    );
+    return () => {
+      Array.from(subscriptionIds.entries()).forEach(
+        ([key, subscriptionId]) => {
+          var _a, _b;
+          const container = (_b = (_a = this._storage[key]) == null ? void 0 : _a.value) != null ? _b : null;
+          if (!container) {
+            throw new Error("Storage could not be found");
+          }
+          container.unsubscribe(this.value, subscriptionId);
+        }
+      );
+    };
+  }
+  /**
+   * TODO
+   * @description This method doesn't do anything yet.
+   */
+  track() {
+    return this;
+  }
+  /**
+   * TODO
+   * @description This method doesn't do anything yet. The callback will still be executed.
+   */
+  transact(fn) {
+    fn();
+    return this;
+  }
+  /**
+   * TODO
+   * @description This method is not yet supported for loro
+   */
+  undo() {
+    throw new Error("This is not yet supported");
+  }
+};
+
+// src/doc/CrdtLoroDocFactory.ts
+var import_crdt7 = require("@pluv/crdt");
+var CrdtLoroDocFactory = class _CrdtLoroDocFactory extends import_crdt7.AbstractCrdtDocFactory {
+  constructor(initialStorage = () => ({})) {
+    super();
+    this._initialStorage = initialStorage;
+  }
+  getEmpty() {
+    return new CrdtLoroDoc();
+  }
+  getFactory(initialStorage) {
+    return new _CrdtLoroDocFactory(
+      initialStorage != null ? initialStorage : this._initialStorage
+    );
+  }
+  getFresh() {
+    const storage = this._initialStorage();
+    return new CrdtLoroDoc(
+      Object.entries(storage).reduce((acc, [key, node]) => {
+        if (node instanceof CrdtLoroArray) {
+          return __spreadProps(__spreadValues({}, acc), { [key]: new CrdtLoroArray([]) });
+        }
+        if (node instanceof CrdtLoroMap) {
+          return __spreadProps(__spreadValues({}, acc), { [key]: new CrdtLoroMap([]) });
+        }
+        if (node instanceof CrdtLoroObject) {
+          return __spreadProps(__spreadValues({}, acc), { [key]: new CrdtLoroObject({}) });
+        }
+        if (node instanceof CrdtLoroText) {
+          return __spreadProps(__spreadValues({}, acc), { [key]: new CrdtLoroText("") });
+        }
+        return acc;
+      }, {})
+    );
+  }
+  getInitialized(initialStorage) {
+    var _a;
+    return new CrdtLoroDoc(
+      (_a = initialStorage == null ? void 0 : initialStorage()) != null ? _a : this._initialStorage()
+    );
+  }
+};
+
+// src/doc/doc.ts
+var doc = (value = () => ({})) => {
+  return new CrdtLoroDocFactory(value);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  loro
+});