@homeostate/crdt-loro 0.1.1 → 0.1.2

package/CHANGELOG.md

@@ -1,5 +1,13 @@
 # @homeostate/crdt-loro
 
+## 0.1.2
+
+### Patch Changes
+
+- 30abf27: Remove draft release warnings, update docs links
+- Updated dependencies [30abf27]
+  - @homeostate/core@0.1.2
+
 ## 0.1.1
 
 ### Patch Changes

package/README.md

@@ -1,8 +1,5 @@
 # @homeostate/crdt-loro
 
-> **Draft / placeholder release.** `0.0.0` reserves the name while the API is still
-> being designed. Nothing here is stable — do not depend on it yet.
-
 [Loro](https://github.com/loro-dev/loro) backend for
 [`@homeostate/core`](https://github.com/mixedrays/homeostate/tree/main/packages/core).
 It maps the synced state onto a `LoroMap` (nested objects become `LoroMap`, arrays

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@homeostate/crdt-loro",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "description": "Loro CRDT backend for @homeostate/core",
   "license": "MIT",
   "type": "module",
@@ -9,7 +9,7 @@
     "url": "git+https://github.com/mixedrays/homeostate.git",
     "directory": "packages/crdt-loro"
   },
-  "homepage": "https://github.com/mixedrays/homeostate#readme",
+  "homepage": "https://homeostate.pages.dev",
   "bugs": {
     "url": "https://github.com/mixedrays/homeostate/issues"
   },
@@ -30,6 +30,8 @@
   },
   "files": [
     "dist",
+    "src",
+    "!src/**/__tests__",
     "README.md",
     "LICENSE",
     "THIRD_PARTY_NOTICES.md",
@@ -39,7 +41,7 @@
     "access": "public"
   },
   "dependencies": {
-    "@homeostate/core": "^0.1.1"
+    "@homeostate/core": "^0.1.2"
   },
   "peerDependencies": {
     "loro-crdt": "^1.0.0"

package/src/index.ts

@@ -0,0 +1 @@
+export { createLoroBackend } from "./loro-backend.js";

package/src/loro-backend.ts

@@ -0,0 +1,24 @@
+import type { LoroDoc } from "loro-crdt";
+import type { CrdtBackend, Unsubscribe } from "@homeostate/core";
+import { patchContainer } from "./patching.js";
+
+let instances = 0;
+
+export const createLoroBackend = (doc: LoroDoc, name: string): CrdtBackend => {
+  const map = doc.getMap(name);
+  const origin = `homeostate:${name}#${instances++}`;
+
+  return {
+    read: () => map.toJSON(),
+
+    write: (next) => {
+      patchContainer(map, next);
+      doc.commit({ origin });
+    },
+
+    subscribe: (onRemoteChange): Unsubscribe =>
+      map.subscribe((event) => {
+        if (event.origin !== origin) onRemoteChange();
+      }),
+  };
+};

package/src/mapping.ts

@@ -0,0 +1,46 @@
+import { LoroList, LoroMap, LoroText } from "loro-crdt";
+
+export type SharedContainer = LoroMap | LoroList | LoroText;
+
+const isRecord = (value: unknown): value is Record<string, unknown> =>
+  value !== null && typeof value === "object" && !Array.isArray(value);
+
+export const setMapEntry = (
+  map: LoroMap,
+  key: string,
+  value: unknown,
+): void => {
+  if (Array.isArray(value))
+    fillList(map.setContainer(key, new LoroList()), value);
+  else if (typeof value === "string")
+    map.setContainer(key, new LoroText()).insert(0, value);
+  else if (isRecord(value))
+    fillMap(map.setContainer(key, new LoroMap()), value);
+  else map.set(key, value);
+};
+
+export const insertListItem = (
+  list: LoroList,
+  index: number,
+  value: unknown,
+): void => {
+  if (Array.isArray(value))
+    fillList(list.insertContainer(index, new LoroList()), value);
+  else if (typeof value === "string")
+    list.insertContainer(index, new LoroText()).insert(0, value);
+  else if (isRecord(value))
+    fillMap(list.insertContainer(index, new LoroMap()), value);
+  else list.insert(index, value);
+};
+
+export const fillMap = (
+  map: LoroMap,
+  object: Record<string, unknown>,
+): void => {
+  for (const [key, value] of Object.entries(object))
+    setMapEntry(map, key, value);
+};
+
+export const fillList = (list: LoroList, array: unknown[]): void => {
+  array.forEach((value, index) => insertListItem(list, index, value));
+};

package/src/patching.ts

@@ -0,0 +1,90 @@
+import { LoroList, LoroMap, LoroText } from "loro-crdt";
+import {
+  ChangeType,
+  getChanges,
+  type Change,
+  type Diffable,
+} from "@homeostate/core";
+import {
+  insertListItem,
+  setMapEntry,
+  type SharedContainer,
+} from "./mapping.js";
+
+export const patchContainer = (
+  container: SharedContainer,
+  newState: unknown,
+): void => {
+  applyChanges(
+    container,
+    getChanges(container.toJSON() as Diffable, newState as Diffable),
+  );
+};
+
+const applyChanges = (container: SharedContainer, changes: Change[]): void => {
+  for (const [type, key, value] of changes) {
+    if (container instanceof LoroMap)
+      applyToMap(container, type, key as string, value);
+    else if (container instanceof LoroList)
+      applyToList(container, type, key as number, value);
+    else applyToText(container, type, key as number, value);
+  }
+};
+
+const applyToMap = (
+  map: LoroMap,
+  type: ChangeType,
+  key: string,
+  value: unknown,
+): void => {
+  switch (type) {
+    case ChangeType.INSERT:
+    case ChangeType.UPDATE:
+      setMapEntry(map, key, value);
+      break;
+
+    case ChangeType.DELETE:
+      map.delete(key);
+      break;
+
+    case ChangeType.PENDING:
+      applyChanges(map.get(key) as SharedContainer, value as Change[]);
+      break;
+  }
+};
+
+const applyToList = (
+  list: LoroList,
+  type: ChangeType,
+  index: number,
+  value: unknown,
+): void => {
+  switch (type) {
+    case ChangeType.INSERT:
+      insertListItem(list, index, value);
+      break;
+
+    case ChangeType.UPDATE:
+      list.delete(index, 1);
+      insertListItem(list, index, value);
+      break;
+
+    case ChangeType.DELETE:
+      list.delete(index, 1);
+      break;
+
+    case ChangeType.PENDING:
+      applyChanges(list.get(index) as SharedContainer, value as Change[]);
+      break;
+  }
+};
+
+const applyToText = (
+  text: LoroText,
+  type: ChangeType,
+  index: number,
+  value: unknown,
+): void => {
+  if (type === ChangeType.INSERT) text.insert(index, value as string);
+  else if (type === ChangeType.DELETE) text.delete(index, 1);
+};