@automerge/automerge-repo 2.0.0-alpha.6 → 2.0.0-collectionsync-alpha.1

package/dist/src/Repo.js

@@ -0,0 +1,208 @@
+import debug from "debug"
+import { NetworkSubsystem } from "./network/NetworkSubsystem.js"
+import { StorageSubsystem } from "./storage/StorageSubsystem.js"
+import { CollectionSynchronizer } from "./synchronizer/CollectionSynchronizer.js"
+import {
+  parseAutomergeUrl,
+  generateAutomergeUrl,
+  isValidAutomergeUrl,
+  parseLegacyUUID,
+} from "./DocUrl.js"
+import { DocHandle } from "./DocHandle.js"
+import { EventEmitter } from "eventemitter3"
+/** A Repo is a collection of documents with networking, syncing, and storage capabilities. */
+/** The `Repo` is the main entry point of this library
+ *
+ * @remarks
+ * To construct a `Repo` you will need an {@link StorageAdapter} and one or
+ * more {@link NetworkAdapter}s. Once you have a `Repo` you can use it to
+ * obtain {@link DocHandle}s.
+ */
+export class Repo extends EventEmitter {
+  #log
+  networkSubsystem
+  storageSubsystem
+  #handleCache = {}
+  /** By default, we share generously with all peers. */
+  sharePolicy = async () => true
+  constructor({ storage, network, peerId, sharePolicy }) {
+    super()
+    this.#log = debug(`automerge-repo:repo`)
+    this.sharePolicy = sharePolicy ?? this.sharePolicy
+    // DOC COLLECTION
+    // The `document` event is fired by the DocCollection any time we create a new document or look
+    // up a document by ID. We listen for it in order to wire up storage and network synchronization.
+    this.on("document", async ({ handle, isNew }) => {
+      if (storageSubsystem) {
+        // Save when the document changes
+        handle.on("heads-changed", async ({ handle, doc }) => {
+          await storageSubsystem.saveDoc(handle.documentId, doc)
+        })
+        if (isNew) {
+          // this is a new document, immediately save it
+          await storageSubsystem.saveDoc(handle.documentId, handle.docSync())
+        } else {
+          // Try to load from disk
+          const loadedDoc = await storageSubsystem.loadDoc(handle.documentId)
+          if (loadedDoc) {
+            handle.update(() => loadedDoc)
+          }
+        }
+      }
+      handle.on("unavailable", () => {
+        this.#log("document unavailable", { documentId: handle.documentId })
+        this.emit("unavailable-document", {
+          documentId: handle.documentId,
+        })
+      })
+      if (this.networkSubsystem.isReady()) {
+        handle.request()
+      } else {
+        handle.awaitNetwork()
+        this.networkSubsystem
+          .whenReady()
+          .then(() => {
+            handle.networkReady()
+          })
+          .catch(err => {
+            this.#log("error waiting for network", { err })
+          })
+      }
+      // Register the document with the synchronizer. This advertises our interest in the document.
+      synchronizer.addDocument(handle.documentId)
+    })
+    this.on("delete-document", ({ documentId }) => {
+      // TODO Pass the delete on to the network
+      // synchronizer.removeDocument(documentId)
+      if (storageSubsystem) {
+        storageSubsystem.remove(documentId).catch(err => {
+          this.#log("error deleting document", { documentId, err })
+        })
+      }
+    })
+    // SYNCHRONIZER
+    // The synchronizer uses the network subsystem to keep documents in sync with peers.
+    const synchronizer = new CollectionSynchronizer(this)
+    // When the synchronizer emits sync messages, send them to peers
+    synchronizer.on("message", message => {
+      this.#log(`sending sync message to ${message.targetId}`)
+      networkSubsystem.send(message)
+    })
+    // STORAGE
+    // The storage subsystem has access to some form of persistence, and deals with save and loading documents.
+    const storageSubsystem = storage ? new StorageSubsystem(storage) : undefined
+    this.storageSubsystem = storageSubsystem
+    // NETWORK
+    // The network subsystem deals with sending and receiving messages to and from peers.
+    const networkSubsystem = new NetworkSubsystem(network, peerId)
+    this.networkSubsystem = networkSubsystem
+    // When we get a new peer, register it with the synchronizer
+    networkSubsystem.on("peer", async ({ peerId }) => {
+      this.#log("peer connected", { peerId })
+      synchronizer.addPeer(peerId)
+    })
+    // When a peer disconnects, remove it from the synchronizer
+    networkSubsystem.on("peer-disconnected", ({ peerId }) => {
+      synchronizer.removePeer(peerId)
+    })
+    // Handle incoming messages
+    networkSubsystem.on("message", async msg => {
+      await synchronizer.receiveMessage(msg)
+    })
+  }
+  /** Returns an existing handle if we have it; creates one otherwise. */
+  #getHandle(
+    /** The documentId of the handle to look up or create */
+    documentId,
+    /** If we know we're creating a new document, specify this so we can have access to it immediately */
+    isNew
+  ) {
+    // If we have the handle cached, return it
+    if (this.#handleCache[documentId]) return this.#handleCache[documentId]
+    // If not, create a new handle, cache it, and return it
+    if (!documentId) throw new Error(`Invalid documentId ${documentId}`)
+    const handle = new DocHandle(documentId, { isNew })
+    this.#handleCache[documentId] = handle
+    return handle
+  }
+  /** Returns all the handles we have cached. */
+  get handles() {
+    return this.#handleCache
+  }
+  /**
+   * Creates a new document and returns a handle to it. The initial value of the document is
+   * an empty object `{}`. Its documentId is generated by the system. we emit a `document` event
+   * to advertise interest in the document.
+   */
+  create() {
+    // TODO:
+    // either
+    // - pass an initial value and do something like this to ensure that you get a valid initial value
+    // const myInitialValue = {
+    //   tasks: [],
+    //   filter: "all",
+    //
+    // const guaranteeInitialValue = (doc: any) => {
+    // if (!doc.tasks) doc.tasks = []
+    // if (!doc.filter) doc.filter = "all"
+    //   return { ...myInitialValue, ...doc }
+    // }
+    // or
+    // - pass a "reify" function that takes a `<any>` and returns `<T>`
+    // Generate a new UUID and store it in the buffer
+    const { documentId } = parseAutomergeUrl(generateAutomergeUrl())
+    const handle = this.#getHandle(documentId, true)
+    this.emit("document", { handle, isNew: true })
+    return handle
+  }
+  /**
+   * Retrieves a document by id. It gets data from the local system, but also emits a `document`
+   * event to advertise interest in the document.
+   */
+  find(
+    /** The documentId of the handle to retrieve */
+    automergeUrl
+  ) {
+    if (!isValidAutomergeUrl(automergeUrl)) {
+      let maybeAutomergeUrl = parseLegacyUUID(automergeUrl)
+      if (maybeAutomergeUrl) {
+        console.warn(
+          "Legacy UUID document ID detected, converting to AutomergeUrl. This will be removed in a future version."
+        )
+        automergeUrl = maybeAutomergeUrl
+      } else {
+        throw new Error(`Invalid AutomergeUrl: '${automergeUrl}'`)
+      }
+    }
+    const { documentId } = parseAutomergeUrl(automergeUrl)
+    // If we have the handle cached, return it
+    if (this.#handleCache[documentId]) {
+      if (this.#handleCache[documentId].isUnavailable()) {
+        // this ensures that the event fires after the handle has been returned
+        setTimeout(() => {
+          this.#handleCache[documentId].emit("unavailable", {
+            handle: this.#handleCache[documentId],
+          })
+        })
+      }
+      return this.#handleCache[documentId]
+    }
+    const handle = this.#getHandle(documentId, false)
+    this.emit("document", { handle, isNew: false })
+    return handle
+  }
+  delete(
+    /** The documentId of the handle to delete */
+    id
+  ) {
+    if (isValidAutomergeUrl(id)) {
+      ;({ documentId: id } = parseAutomergeUrl(id))
+    }
+    const handle = this.#getHandle(id, false)
+    handle.delete()
+    delete this.#handleCache[id]
+    this.emit("delete-document", {
+      documentId: id,
+    })
+  }
+}

package/dist/src/helpers/arraysAreEqual.d.ts

@@ -0,0 +1,2 @@
+export declare const arraysAreEqual: <T>(a: T[], b: T[]) => boolean
+//# sourceMappingURL=arraysAreEqual.d.ts.map

package/dist/src/helpers/arraysAreEqual.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"arraysAreEqual.d.ts","sourceRoot":"","sources":["../../../src/helpers/arraysAreEqual.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,cAAc,gCACiD,CAAA"}

package/dist/src/helpers/arraysAreEqual.js

@@ -0,0 +1,2 @@
+export const arraysAreEqual = (a, b) =>
+  a.length === b.length && a.every((element, index) => element === b[index])

package/dist/src/helpers/cbor.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="node" resolution-mode="require"/>
+export declare function encode(obj: any): Buffer
+export declare function decode(buf: Buffer | Uint8Array): any
+//# sourceMappingURL=cbor.d.ts.map

package/dist/src/helpers/cbor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cbor.d.ts","sourceRoot":"","sources":["../../../src/helpers/cbor.ts"],"names":[],"mappings":";AAEA,wBAAgB,MAAM,CAAC,GAAG,EAAE,GAAG,GAAG,MAAM,CAGvC;AAED,wBAAgB,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,UAAU,GAAG,GAAG,CAEpD"}

package/dist/src/helpers/cbor.js

@@ -0,0 +1,8 @@
+import { Encoder, decode as cborXdecode } from "cbor-x"
+export function encode(obj) {
+  let encoder = new Encoder({ tagUint8Array: false })
+  return encoder.encode(obj)
+}
+export function decode(buf) {
+  return cborXdecode(buf)
+}

package/dist/src/helpers/eventPromise.d.ts

@@ -0,0 +1,11 @@
+import { EventEmitter } from "eventemitter3"
+/** Returns a promise that resolves when the given event is emitted on the given emitter. */
+export declare const eventPromise: (
+  emitter: EventEmitter,
+  event: string
+) => Promise<any>
+export declare const eventPromises: (
+  emitters: EventEmitter[],
+  event: string
+) => Promise<any[]>
+//# sourceMappingURL=eventPromise.d.ts.map

package/dist/src/helpers/eventPromise.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"eventPromise.d.ts","sourceRoot":"","sources":["../../../src/helpers/eventPromise.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,eAAe,CAAA;AAE5C,4FAA4F;AAC5F,eAAO,MAAM,YAAY,YAAa,YAAY,SAAS,MAAM,iBACE,CAAA;AAEnE,eAAO,MAAM,aAAa,aAAc,YAAY,EAAE,SAAS,MAAM,mBAGpE,CAAA"}

package/dist/src/helpers/eventPromise.js

@@ -0,0 +1,7 @@
+/** Returns a promise that resolves when the given event is emitted on the given emitter. */
+export const eventPromise = (emitter, event) =>
+  new Promise(resolve => emitter.once(event, d => resolve(d)))
+export const eventPromises = (emitters, event) => {
+  const promises = emitters.map(emitter => eventPromise(emitter, event))
+  return Promise.all(promises)
+}

package/dist/src/helpers/headsAreSame.d.ts

@@ -0,0 +1,2 @@
+export declare const headsAreSame: (a: Heads, b: Heads) => boolean
+//# sourceMappingURL=headsAreSame.d.ts.map

package/dist/src/helpers/headsAreSame.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"headsAreSame.d.ts","sourceRoot":"","sources":["../../../src/helpers/headsAreSame.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,YAAY,iCAExB,CAAA"}

package/dist/src/helpers/headsAreSame.js

@@ -0,0 +1,4 @@
+import { arraysAreEqual } from "./arraysAreEqual.js"
+export const headsAreSame = (a, b) => {
+  return arraysAreEqual(a, b)
+}

package/dist/src/helpers/mergeArrays.d.ts

@@ -0,0 +1,2 @@
+export declare function mergeArrays(myArrays: Uint8Array[]): Uint8Array
+//# sourceMappingURL=mergeArrays.d.ts.map

package/dist/src/helpers/mergeArrays.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mergeArrays.d.ts","sourceRoot":"","sources":["../../../src/helpers/mergeArrays.ts"],"names":[],"mappings":"AAAA,wBAAgB,WAAW,CAAC,QAAQ,EAAE,UAAU,EAAE,cAgBjD"}

package/dist/src/helpers/mergeArrays.js

@@ -0,0 +1,15 @@
+export function mergeArrays(myArrays) {
+  // Get the total length of all arrays.
+  let length = 0
+  myArrays.forEach(item => {
+    length += item.length
+  })
+  // Create a new array with total length and merge all source arrays.
+  const mergedArray = new Uint8Array(length)
+  let offset = 0
+  myArrays.forEach(item => {
+    mergedArray.set(item, offset)
+    offset += item.length
+  })
+  return mergedArray
+}

package/dist/src/helpers/pause.d.ts

@@ -0,0 +1,6 @@
+export declare const pause: (t?: number) => Promise<void>
+export declare function rejectOnTimeout<T>(
+  promise: Promise<T>,
+  millis: number
+): Promise<T>
+//# sourceMappingURL=pause.d.ts.map

package/dist/src/helpers/pause.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pause.d.ts","sourceRoot":"","sources":["../../../src/helpers/pause.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,KAAK,+BAC4C,CAAA;AAE9D,wBAAgB,eAAe,CAAC,CAAC,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,CAAC,CAAC,CAKlF"}

package/dist/src/helpers/pause.js

@@ -0,0 +1,10 @@
+export const pause = (t = 0) =>
+  new Promise(resolve => setTimeout(() => resolve(), t))
+export function rejectOnTimeout(promise, millis) {
+  return Promise.race([
+    promise,
+    pause(millis).then(() => {
+      throw new Error("timeout exceeded")
+    }),
+  ])
+}

package/dist/src/helpers/tests/network-adapter-tests.d.ts

@@ -0,0 +1,21 @@
+import { type NetworkAdapter } from "../../index.js"
+/**
+ * Runs a series of tests against a set of three peers, each represented by one or more instantiated
+ * network adapters.
+ *
+ * The adapter `setup` function should return an object with the following properties:
+ *
+ * - `adapters`: A tuple representing three peers' network configuration. Each element can be either
+ *   a single adapter or an array of adapters. Each will be used to instantiate a Repo for that
+ *   peer.
+ * - `teardown`: An optional function that will be called after the tests have run. This can be used
+ *   to clean up any resources that were created during the test.
+ */
+export declare function runAdapterTests(_setup: SetupFn, title?: string): void
+type Network = NetworkAdapter | NetworkAdapter[]
+export type SetupFn = () => Promise<{
+  adapters: [Network, Network, Network]
+  teardown?: () => void
+}>
+export {}
+//# sourceMappingURL=network-adapter-tests.d.ts.map

package/dist/src/helpers/tests/network-adapter-tests.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"network-adapter-tests.d.ts","sourceRoot":"","sources":["../../../../src/helpers/tests/network-adapter-tests.ts"],"names":[],"mappings":"AAAA,OAAO,EAAgB,KAAK,cAAc,EAAc,MAAM,gBAAgB,CAAA;AAM9E;;;;;;;;;;;GAWG;AACH,wBAAgB,eAAe,CAAC,MAAM,EAAE,OAAO,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,IAAI,CA8HrE;AAID,KAAK,OAAO,GAAG,cAAc,GAAG,cAAc,EAAE,CAAA;AAEhD,MAAM,MAAM,OAAO,GAAG,MAAM,OAAO,CAAC;IAClC,QAAQ,EAAE,CAAC,OAAO,EAAE,OAAO,EAAE,OAAO,CAAC,CAAA;IACrC,QAAQ,CAAC,EAAE,MAAM,IAAI,CAAA;CACtB,CAAC,CAAA"}

package/dist/src/helpers/tests/network-adapter-tests.js

@@ -0,0 +1,122 @@
+import { Repo } from "../../index.js"
+import { eventPromise, eventPromises } from "../eventPromise.js"
+import { assert } from "chai"
+import { describe, it } from "mocha"
+import { pause } from "../pause.js"
+/**
+ * Runs a series of tests against a set of three peers, each represented by one or more instantiated
+ * network adapters.
+ *
+ * The adapter `setup` function should return an object with the following properties:
+ *
+ * - `adapters`: A tuple representing three peers' network configuration. Each element can be either
+ *   a single adapter or an array of adapters. Each will be used to instantiate a Repo for that
+ *   peer.
+ * - `teardown`: An optional function that will be called after the tests have run. This can be used
+ *   to clean up any resources that were created during the test.
+ */
+export function runAdapterTests(_setup, title) {
+  // Wrap the provided setup function
+  const setup = async () => {
+    const { adapters, teardown = NO_OP } = await _setup()
+    // these might be individual adapters or arrays of adapters; normalize them to arrays
+    const [a, b, c] = adapters.map(toArray)
+    return { adapters: [a, b, c], teardown }
+  }
+  describe(`Adapter acceptance tests ${title ? `(${title})` : ""}`, () => {
+    it("can sync 2 repos", async () => {
+      const doTest = async (a, b) => {
+        const aliceRepo = new Repo({ network: a, peerId: alice })
+        const bobRepo = new Repo({ network: b, peerId: bob })
+        // Alice creates a document
+        const aliceHandle = aliceRepo.create()
+        // Bob receives the document
+        await eventPromise(bobRepo, "document")
+        const bobHandle = bobRepo.find(aliceHandle.url)
+        // Alice changes the document
+        aliceHandle.change(d => {
+          d.foo = "bar"
+        })
+        // Bob receives the change
+        await eventPromise(bobHandle, "change")
+        assert.equal((await bobHandle.doc())?.foo, "bar")
+        // Bob changes the document
+        bobHandle.change(d => {
+          d.foo = "baz"
+        })
+        // Alice receives the change
+        await eventPromise(aliceHandle, "change")
+        assert.equal((await aliceHandle.doc())?.foo, "baz")
+      }
+      // Run the test in both directions, in case they're different types of adapters
+      {
+        const { adapters, teardown } = await setup()
+        const [x, y] = adapters
+        await doTest(x, y) // x is Alice
+        teardown()
+      }
+      {
+        const { adapters, teardown } = await setup()
+        const [x, y] = adapters
+        await doTest(y, x) // y is Alice
+        teardown()
+      }
+    })
+    it("can sync 3 repos", async () => {
+      const { adapters, teardown } = await setup()
+      const [a, b, c] = adapters
+      const aliceRepo = new Repo({ network: a, peerId: alice })
+      const bobRepo = new Repo({ network: b, peerId: bob })
+      const charlieRepo = new Repo({ network: c, peerId: charlie })
+      // Alice creates a document
+      const aliceHandle = aliceRepo.create()
+      const docUrl = aliceHandle.url
+      // Bob and Charlie receive the document
+      await eventPromises([bobRepo, charlieRepo], "document")
+      const bobHandle = bobRepo.find(docUrl)
+      const charlieHandle = charlieRepo.find(docUrl)
+      // Alice changes the document
+      aliceHandle.change(d => {
+        d.foo = "bar"
+      })
+      // Bob and Charlie receive the change
+      await eventPromises([bobHandle, charlieHandle], "change")
+      assert.equal((await bobHandle.doc())?.foo, "bar")
+      assert.equal((await charlieHandle.doc())?.foo, "bar")
+      // Charlie changes the document
+      charlieHandle.change(d => {
+        d.foo = "baz"
+      })
+      // Alice and Bob receive the change
+      await eventPromises([aliceHandle, bobHandle], "change")
+      assert.equal((await bobHandle.doc())?.foo, "baz")
+      assert.equal((await charlieHandle.doc())?.foo, "baz")
+      teardown()
+    })
+    it("can broadcast a message", async () => {
+      const { adapters, teardown } = await setup()
+      const [a, b, c] = adapters
+      const aliceRepo = new Repo({ network: a, peerId: alice })
+      const bobRepo = new Repo({ network: b, peerId: bob })
+      const charlieRepo = new Repo({ network: c, peerId: charlie })
+      await eventPromises(
+        [aliceRepo, bobRepo, charlieRepo].map(r => r.networkSubsystem),
+        "peer"
+      )
+      const aliceHandle = aliceRepo.create()
+      const charlieHandle = charlieRepo.find(aliceHandle.url)
+      // pause to give charlie a chance to let alice know it wants the doc
+      await pause(100)
+      const alicePresenceData = { presence: "alice" }
+      aliceHandle.broadcast(alicePresenceData)
+      const { message } = await eventPromise(charlieHandle, "ephemeral-message")
+      assert.deepStrictEqual(message, alicePresenceData)
+      teardown()
+    })
+  })
+}
+const NO_OP = () => {}
+const toArray = x => (Array.isArray(x) ? x : [x])
+const alice = "alice"
+const bob = "bob"
+const charlie = "charlie"

package/dist/src/helpers/withTimeout.d.ts

@@ -0,0 +1,12 @@
+/**
+ * If `promise` is resolved before `t` ms elapse, the timeout is cleared and the result of the
+ * promise is returned. If the timeout ends first, a `TimeoutError` is thrown.
+ */
+export declare const withTimeout: <T>(
+  promise: Promise<T>,
+  t: number
+) => Promise<T>
+export declare class TimeoutError extends Error {
+  constructor(message: string)
+}
+//# sourceMappingURL=withTimeout.d.ts.map

package/dist/src/helpers/withTimeout.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"withTimeout.d.ts","sourceRoot":"","sources":["../../../src/helpers/withTimeout.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,eAAO,MAAM,WAAW,8BAEnB,MAAM,eAcV,CAAA;AAED,qBAAa,YAAa,SAAQ,KAAK;gBACzB,OAAO,EAAE,MAAM;CAI5B"}

package/dist/src/helpers/withTimeout.js

@@ -0,0 +1,24 @@
+/**
+ * If `promise` is resolved before `t` ms elapse, the timeout is cleared and the result of the
+ * promise is returned. If the timeout ends first, a `TimeoutError` is thrown.
+ */
+export const withTimeout = async (promise, t) => {
+  let timeoutId
+  const timeoutPromise = new Promise((_, reject) => {
+    timeoutId = setTimeout(
+      () => reject(new TimeoutError(`withTimeout: timed out after ${t}ms`)),
+      t
+    )
+  })
+  try {
+    return await Promise.race([promise, timeoutPromise])
+  } finally {
+    clearTimeout(timeoutId)
+  }
+}
+export class TimeoutError extends Error {
+  constructor(message) {
+    super(message)
+    this.name = "TimeoutError"
+  }
+}

package/dist/src/index.d.ts

@@ -0,0 +1,53 @@
+/**
+ * @packageDocumentation
+ *
+ * The [`automerge`](https://www.npmjs.com/package/@automerge/automerge) CRDT
+ * provides a core CRDT data structure and an implementation of a storage
+ * format and sync protocol but doesn't provide the plumbing to use these tools
+ * in a JS application. `automerge-repo` provides the plumbing.
+ *
+ * The main entry point is the {@link Repo} class, which you instantiate with
+ * a {@link StorageAdapter} and zero or more {@link NetworkAdapter}s. Once you
+ * have a repo you can use it to create {@link DocHandle}s. {@link DocHandle}s
+ * are a reference to a document, identified by a {@link AutomergeUrl}, a place to
+ * listen for changes to the document, and to make new changes.
+ *
+ * A typical example of how to use this library then might look like this:
+ *
+ * ```typescript
+ * import { Repo } from "@automerge/automerge-repo";
+ *
+ * const repo = new Repo({
+ *   storage: <storage adapter>,
+ *   network: [<network adapter>, <network adapter>]
+ * })
+ *
+ * const handle = repo.create
+ * ```
+ */
+export { DocHandle, HandleState, type DocHandleOptions } from "./DocHandle.js"
+export type { DocHandleChangePayload } from "./DocHandle.js"
+export { NetworkAdapter } from "./network/NetworkAdapter.js"
+export type {
+  OpenPayload,
+  PeerCandidatePayload,
+  PeerDisconnectedPayload,
+} from "./network/NetworkAdapter.js"
+export type {
+  Message,
+  NetworkAdapterMessage,
+  EphemeralMessage,
+  SyncMessage,
+} from "./network/messages.js"
+export { isValidMessage } from "./network/messages.js"
+export { Repo, type SharePolicy, type RepoConfig } from "./Repo.js"
+export { StorageAdapter, type StorageKey } from "./storage/StorageAdapter.js"
+export {
+  parseAutomergeUrl,
+  isValidAutomergeUrl,
+  stringifyAutomergeUrl as generateAutomergeUrl,
+} from "./DocUrl.js"
+export * from "./types.js"
+/** @hidden **/
+export * as cbor from "./helpers/cbor.js"
+//# sourceMappingURL=index.d.ts.map

package/dist/src/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAEH,OAAO,EAAE,SAAS,EAAE,WAAW,EAAE,KAAK,gBAAgB,EAAE,MAAM,gBAAgB,CAAA;AAC9E,YAAY,EAAE,sBAAsB,EAAE,MAAM,gBAAgB,CAAA;AAC5D,OAAO,EAAE,cAAc,EAAE,MAAM,6BAA6B,CAAA;AAC5D,YAAY,EACV,WAAW,EACX,oBAAoB,EACpB,uBAAuB,GACxB,MAAM,6BAA6B,CAAA;AAMpC,YAAY,EACV,OAAO,EACP,qBAAqB,EACrB,gBAAgB,EAChB,WAAW,GACZ,MAAM,uBAAuB,CAAA;AAC9B,OAAO,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAA;AAEtD,OAAO,EAAE,IAAI,EAAE,KAAK,WAAW,EAAE,KAAK,UAAU,EAAE,MAAM,WAAW,CAAA;AACnE,OAAO,EAAE,cAAc,EAAE,KAAK,UAAU,EAAE,MAAM,6BAA6B,CAAA;AAC7E,OAAO,EACL,iBAAiB,EACjB,mBAAmB,EACnB,qBAAqB,IAAI,oBAAoB,GAC9C,MAAM,aAAa,CAAA;AACpB,cAAc,YAAY,CAAA;AAE1B,eAAe;AACf,OAAO,KAAK,IAAI,MAAM,mBAAmB,CAAA"}

package/dist/src/index.js

@@ -0,0 +1,40 @@
+/**
+ * @packageDocumentation
+ *
+ * The [`automerge`](https://www.npmjs.com/package/@automerge/automerge) CRDT
+ * provides a core CRDT data structure and an implementation of a storage
+ * format and sync protocol but doesn't provide the plumbing to use these tools
+ * in a JS application. `automerge-repo` provides the plumbing.
+ *
+ * The main entry point is the {@link Repo} class, which you instantiate with
+ * a {@link StorageAdapter} and zero or more {@link NetworkAdapter}s. Once you
+ * have a repo you can use it to create {@link DocHandle}s. {@link DocHandle}s
+ * are a reference to a document, identified by a {@link AutomergeUrl}, a place to
+ * listen for changes to the document, and to make new changes.
+ *
+ * A typical example of how to use this library then might look like this:
+ *
+ * ```typescript
+ * import { Repo } from "@automerge/automerge-repo";
+ *
+ * const repo = new Repo({
+ *   storage: <storage adapter>,
+ *   network: [<network adapter>, <network adapter>]
+ * })
+ *
+ * const handle = repo.create
+ * ```
+ */
+export { DocHandle, HandleState } from "./DocHandle.js"
+export { NetworkAdapter } from "./network/NetworkAdapter.js"
+export { isValidMessage } from "./network/messages.js"
+export { Repo } from "./Repo.js"
+export { StorageAdapter } from "./storage/StorageAdapter.js"
+export {
+  parseAutomergeUrl,
+  isValidAutomergeUrl,
+  stringifyAutomergeUrl as generateAutomergeUrl,
+} from "./DocUrl.js"
+export * from "./types.js"
+/** @hidden **/
+export * as cbor from "./helpers/cbor.js"

package/dist/src/network/NetworkAdapter.d.ts

@@ -0,0 +1,26 @@
+import { EventEmitter } from "eventemitter3"
+import { PeerId } from "../types.js"
+import { Message } from "./messages.js"
+export declare abstract class NetworkAdapter extends EventEmitter<NetworkAdapterEvents> {
+  peerId?: PeerId
+  abstract connect(peerId: PeerId): void
+  abstract send(message: Message): void
+  abstract disconnect(): void
+}
+export interface NetworkAdapterEvents {
+  ready: (payload: OpenPayload) => void
+  close: () => void
+  "peer-candidate": (payload: PeerCandidatePayload) => void
+  "peer-disconnected": (payload: PeerDisconnectedPayload) => void
+  message: (payload: Message) => void
+}
+export interface OpenPayload {
+  network: NetworkAdapter
+}
+export interface PeerCandidatePayload {
+  peerId: PeerId
+}
+export interface PeerDisconnectedPayload {
+  peerId: PeerId
+}
+//# sourceMappingURL=NetworkAdapter.d.ts.map

package/dist/src/network/NetworkAdapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"NetworkAdapter.d.ts","sourceRoot":"","sources":["../../../src/network/NetworkAdapter.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,eAAe,CAAA;AAC5C,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAA;AACpC,OAAO,EAAE,OAAO,EAAE,MAAM,eAAe,CAAA;AAEvC,8BAAsB,cAAe,SAAQ,YAAY,CAAC,oBAAoB,CAAC;IAC7E,MAAM,CAAC,EAAE,MAAM,CAAA;IAEf,QAAQ,CAAC,OAAO,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI;IAEtC,QAAQ,CAAC,IAAI,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI;IAErC,QAAQ,CAAC,UAAU,IAAI,IAAI;CAC5B;AAID,MAAM,WAAW,oBAAoB;IACnC,KAAK,EAAE,CAAC,OAAO,EAAE,WAAW,KAAK,IAAI,CAAA;IACrC,KAAK,EAAE,MAAM,IAAI,CAAA;IACjB,gBAAgB,EAAE,CAAC,OAAO,EAAE,oBAAoB,KAAK,IAAI,CAAA;IACzD,mBAAmB,EAAE,CAAC,OAAO,EAAE,uBAAuB,KAAK,IAAI,CAAA;IAC/D,OAAO,EAAE,CAAC,OAAO,EAAE,OAAO,KAAK,IAAI,CAAA;CACpC;AAED,MAAM,WAAW,WAAW;IAC1B,OAAO,EAAE,cAAc,CAAA;CACxB;AAED,MAAM,WAAW,oBAAoB;IACnC,MAAM,EAAE,MAAM,CAAA;CACf;AAED,MAAM,WAAW,uBAAuB;IACtC,MAAM,EAAE,MAAM,CAAA;CACf"}

package/dist/src/network/NetworkAdapter.js

@@ -0,0 +1,4 @@
+import { EventEmitter } from "eventemitter3"
+export class NetworkAdapter extends EventEmitter {
+  peerId // hmmm, maybe not
+}