@homeostate/crdt-automerge 0.1.1 → 0.1.2

package/CHANGELOG.md

@@ -1,5 +1,13 @@
 # @homeostate/crdt-automerge
 
+## 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-automerge
 
-> **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.
-
 [Automerge](https://automerge.org) backend for
 [`@homeostate/core`](https://github.com/mixedrays/homeostate/tree/main/packages/core).
 It maps the synced state onto one key of an Automerge document (nested objects become

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@homeostate/crdt-automerge",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "description": "Automerge CRDT backend for @homeostate/core",
   "license": "MIT",
   "type": "module",
@@ -9,7 +9,7 @@
     "url": "git+https://github.com/mixedrays/homeostate.git",
     "directory": "packages/crdt-automerge"
   },
-  "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": {
     "@automerge/automerge": "^3.0.0"

package/src/automerge-backend.ts

@@ -0,0 +1,37 @@
+import type { CrdtBackend, Unsubscribe } from "@homeostate/core";
+import type { AutomergeHandle } from "./handle.js";
+import { applyChanges, diff, toJson, type Container } from "./patching.js";
+import { createSnapshot } from "./snapshot.js";
+
+export const createAutomergeBackend = <T extends Container>(
+  handle: AutomergeHandle<T>,
+  name: string,
+): CrdtBackend => {
+  const snapshot = createSnapshot();
+  let writing = false;
+
+  const current = (): unknown => (handle.doc() as Container)[name];
+
+  return {
+    read: () => snapshot(current()) ?? {},
+
+    write: (next) => {
+      const changes = diff(current(), next);
+      if (changes?.length === 0) return;
+      writing = true;
+      try {
+        handle.change((doc) => {
+          if (changes === null) (doc as Container)[name] = toJson(next);
+          else applyChanges(doc as Container, [name], changes);
+        });
+      } finally {
+        writing = false;
+      }
+    },
+
+    subscribe: (onRemoteChange): Unsubscribe =>
+      handle.subscribe(() => {
+        if (!writing) onRemoteChange();
+      }),
+  };
+};

package/src/handle.ts

@@ -0,0 +1,51 @@
+import * as A from "@automerge/automerge";
+import type { Unsubscribe } from "@homeostate/core";
+
+export interface AutomergeHandleEvent<T> {
+  doc: A.Doc<T>;
+  local: boolean;
+}
+
+export interface AutomergeHandle<T = Record<string, unknown>> {
+  doc: () => A.Doc<T>;
+  change: (fn: A.ChangeFn<T>) => void;
+  update: (fn: (doc: A.Doc<T>) => A.Doc<T>) => void;
+  subscribe: (
+    listener: (event: AutomergeHandleEvent<T>) => void,
+  ) => Unsubscribe;
+}
+
+const sameHeads = (a: A.Heads, b: A.Heads): boolean =>
+  a.length === b.length && a.every((hash, i) => hash === b[i]);
+
+export const createAutomergeHandle = <T = Record<string, unknown>>(
+  initial: A.Doc<T> = A.init<T>(),
+): AutomergeHandle<T> => {
+  let current = initial;
+  const listeners = new Set<(event: AutomergeHandleEvent<T>) => void>();
+
+  const replace = (
+    operation: (doc: A.Doc<T>) => A.Doc<T>,
+    local: boolean,
+  ): void => {
+    const before = A.getHeads(current);
+    const next = operation(current);
+    if (next === current) return;
+    current = next;
+    if (sameHeads(before, A.getHeads(next))) return;
+    const event = { doc: next, local };
+    listeners.forEach((listener) => listener(event));
+  };
+
+  return {
+    doc: () => current,
+    change: (fn) => replace((doc) => A.change(doc, fn), true),
+    update: (fn) => replace(fn, false),
+    subscribe: (listener): Unsubscribe => {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
+    },
+  };
+};

package/src/index.ts

@@ -0,0 +1,3 @@
+export { createAutomergeBackend } from "./automerge-backend.js";
+export { createAutomergeHandle } from "./handle.js";
+export type { AutomergeHandle, AutomergeHandleEvent } from "./handle.js";

package/src/patching.ts

@@ -0,0 +1,105 @@
+import * as A from "@automerge/automerge";
+import { ChangeType, getChanges, type Change } from "@homeostate/core";
+
+export type Container = Record<string, unknown>;
+
+const isRecord = (value: unknown): value is Container =>
+  value !== null && typeof value === "object" && !Array.isArray(value);
+
+export const toJson = (value: unknown): unknown => {
+  if (Array.isArray(value))
+    return value.map((item) => (item === undefined ? null : toJson(item)));
+  if (!isRecord(value)) return value;
+  const result: Container = {};
+  for (const [key, item] of Object.entries(value))
+    if (item !== undefined) result[key] = toJson(item);
+  return result;
+};
+
+export const diff = (current: unknown, next: unknown): Change[] | null => {
+  if (!isRecord(next)) return [];
+  return isRecord(current) ? getChanges(current, next) : null;
+};
+
+export const applyChanges = (
+  doc: Container,
+  path: A.Prop[],
+  changes: Change[],
+): void => {
+  const container = path.reduce<unknown>(
+    (value, prop) => (value as Container)[prop],
+    doc,
+  );
+  for (const [type, key, value] of changes) {
+    if (typeof container === "string")
+      applyToText(doc, path, type, key as number, value);
+    else if (Array.isArray(container))
+      applyToList(doc, path, container, type, key as number, value);
+    else
+      applyToMap(doc, path, container as Container, type, key as string, value);
+  }
+};
+
+const applyToMap = (
+  doc: Container,
+  path: A.Prop[],
+  map: Container,
+  type: ChangeType,
+  key: string,
+  value: unknown,
+): void => {
+  switch (type) {
+    case ChangeType.INSERT:
+    case ChangeType.UPDATE:
+      if (value !== undefined) map[key] = toJson(value);
+      else if (key in map) delete map[key];
+      break;
+
+    case ChangeType.DELETE:
+      delete map[key];
+      break;
+
+    case ChangeType.PENDING:
+      applyChanges(doc, [...path, key], value as Change[]);
+      break;
+  }
+};
+
+const applyToList = (
+  doc: Container,
+  path: A.Prop[],
+  list: unknown[],
+  type: ChangeType,
+  index: number,
+  value: unknown,
+): void => {
+  switch (type) {
+    case ChangeType.INSERT:
+      A.insertAt(list, index, toJson(value));
+      break;
+
+    case ChangeType.UPDATE:
+      list[index] = toJson(value);
+      break;
+
+    case ChangeType.DELETE:
+      A.deleteAt(list, index, 1);
+      break;
+
+    case ChangeType.PENDING:
+      applyChanges(doc, [...path, index], value as Change[]);
+      break;
+  }
+};
+
+const applyToText = (
+  doc: Container,
+  path: A.Prop[],
+  type: ChangeType,
+  index: number,
+  value: unknown,
+): void => {
+  if (type === ChangeType.INSERT)
+    A.splice(doc, path, index, 0, value as string);
+  else if (type === ChangeType.DELETE) A.splice(doc, path, index, 1);
+};

package/src/snapshot.ts

@@ -0,0 +1,18 @@
+export const createSnapshot = (): ((value: unknown) => unknown) => {
+  const copies = new WeakMap<object, unknown>();
+
+  const copy = (value: unknown): unknown => {
+    if (value === null || typeof value !== "object") return value;
+    const cached = copies.get(value);
+    if (cached !== undefined) return cached;
+    const result = Array.isArray(value)
+      ? value.map(copy)
+      : Object.fromEntries(
+          Object.entries(value).map(([key, item]) => [key, copy(item)]),
+        );
+    copies.set(value, result);
+    return result;
+  };
+
+  return copy;
+};