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

package/dist/src/DocHandle.js

@@ -0,0 +1,405 @@
+import * as A from "@automerge/automerge/next"
+import debug from "debug"
+import { EventEmitter } from "eventemitter3"
+import { assign, createMachine, interpret } from "xstate"
+import { waitFor } from "xstate/lib/waitFor.js"
+import { headsAreSame } from "./helpers/headsAreSame.js"
+import { pause } from "./helpers/pause.js"
+import { TimeoutError, withTimeout } from "./helpers/withTimeout.js"
+import { stringifyAutomergeUrl } from "./DocUrl.js"
+import { encode } from "./helpers/cbor.js"
+/** DocHandle is a wrapper around a single Automerge document that lets us
+ * listen for changes and notify the network and storage of new changes.
+ *
+ * @remarks
+ * A `DocHandle` represents a document which is being managed by a {@link Repo}.
+ * To obtain `DocHandle` use {@link Repo.find} or {@link Repo.create}.
+ *
+ * To modify the underlying document use either {@link DocHandle.change} or
+ * {@link DocHandle.changeAt}. These methods will notify the `Repo` that some
+ * change has occured and the `Repo` will save any new changes to the
+ * attached {@link StorageAdapter} and send sync messages to connected peers.
+ * */
+export class DocHandle //
+  extends EventEmitter
+{
+  documentId
+  #log
+  #machine
+  #timeoutDelay
+  /** The URL of this document
+   *
+   * @remarks
+   * This can be used to request the document from an instance of {@link Repo}
+   */
+  get url() {
+    return stringifyAutomergeUrl({ documentId: this.documentId })
+  }
+  /** @hidden */
+  constructor(documentId, { isNew = false, timeoutDelay = 60_000 } = {}) {
+    super()
+    this.documentId = documentId
+    this.#timeoutDelay = timeoutDelay
+    this.#log = debug(`automerge-repo:dochandle:${this.documentId.slice(0, 5)}`)
+    // initial doc
+    let doc = A.init()
+    // Make an empty change so that we have something to save to disk
+    if (isNew) {
+      doc = A.emptyChange(doc, {})
+    }
+    /**
+     * Internally we use a state machine to orchestrate document loading and/or syncing, in order to
+     * avoid requesting data we already have, or surfacing intermediate values to the consumer.
+     *
+     *                          ┌─────────────────────┬─────────TIMEOUT────►┌────────┐
+     *                      ┌───┴─────┐           ┌───┴────────┐            │ failed │
+     *  ┌───────┐  ┌──FIND──┤ loading ├─REQUEST──►│ requesting ├─UPDATE──┐  └────────┘
+     *  │ idle  ├──┤        └───┬─────┘           └────────────┘         │
+     *  └───────┘  │            │                                        └─►┌────────┐
+     *             │            └───────LOAD───────────────────────────────►│ ready  │
+     *             └──CREATE───────────────────────────────────────────────►└────────┘
+     */
+    this.#machine = interpret(
+      createMachine(
+        {
+          predictableActionArguments: true,
+          id: "docHandle",
+          initial: IDLE,
+          context: { documentId: this.documentId, doc },
+          states: {
+            idle: {
+              on: {
+                // If we're creating a new document, we don't need to load anything
+                CREATE: { target: READY },
+                // If we're accessing an existing document, we need to request it from storage
+                // and/or the network
+                FIND: { target: LOADING },
+                DELETE: { actions: "onDelete", target: DELETED },
+              },
+            },
+            loading: {
+              on: {
+                // UPDATE is called by the Repo if the document is found in storage
+                UPDATE: { actions: "onUpdate", target: READY },
+                // REQUEST is called by the Repo if the document is not found in storage
+                REQUEST: { target: REQUESTING },
+                // AWAIT_NETWORK is called by the repo if the document is not found in storage but the network is not yet ready
+                AWAIT_NETWORK: { target: AWAITING_NETWORK },
+                DELETE: { actions: "onDelete", target: DELETED },
+              },
+              after: [
+                {
+                  delay: this.#timeoutDelay,
+                  target: FAILED,
+                },
+              ],
+            },
+            awaitingNetwork: {
+              on: {
+                NETWORK_READY: { target: REQUESTING },
+              },
+            },
+            requesting: {
+              on: {
+                MARK_UNAVAILABLE: {
+                  target: UNAVAILABLE,
+                  actions: "onUnavailable",
+                },
+                // UPDATE is called by the Repo when we receive changes from the network
+                UPDATE: { actions: "onUpdate" },
+                // REQUEST_COMPLETE is called from `onUpdate` when the doc has been fully loaded from the network
+                REQUEST_COMPLETE: { target: READY },
+                DELETE: { actions: "onDelete", target: DELETED },
+              },
+              after: [
+                {
+                  delay: this.#timeoutDelay,
+                  target: FAILED,
+                },
+              ],
+            },
+            ready: {
+              on: {
+                // UPDATE is called by the Repo when we receive changes from the network
+                UPDATE: { actions: "onUpdate", target: READY },
+                DELETE: { actions: "onDelete", target: DELETED },
+              },
+            },
+            failed: {
+              type: "final",
+            },
+            deleted: {
+              type: "final",
+            },
+            unavailable: {
+              on: {
+                UPDATE: { actions: "onUpdate" },
+                // REQUEST_COMPLETE is called from `onUpdate` when the doc has been fully loaded from the network
+                REQUEST_COMPLETE: { target: READY },
+                DELETE: { actions: "onDelete", target: DELETED },
+              },
+            },
+          },
+        },
+        {
+          actions: {
+            /** Put the updated doc on context */
+            onUpdate: assign((context, { payload }) => {
+              const { doc: oldDoc } = context
+              const { callback } = payload
+              const newDoc = callback(oldDoc)
+              return { doc: newDoc }
+            }),
+            onDelete: assign(() => {
+              this.emit("delete", { handle: this })
+              return { doc: undefined }
+            }),
+            onUnavailable: assign(context => {
+              const { doc } = context
+              this.emit("unavailable", { handle: this })
+              return { doc }
+            }),
+          },
+        }
+      )
+    )
+      .onTransition(({ value: state, history, context }, event) => {
+        const oldDoc = history?.context?.doc
+        const newDoc = context.doc
+        this.#log(`${history?.value}: ${event.type} → ${state}`, newDoc)
+        const docChanged =
+          newDoc &&
+          oldDoc &&
+          !headsAreSame(A.getHeads(newDoc), A.getHeads(oldDoc))
+        if (docChanged) {
+          this.emit("heads-changed", { handle: this, doc: newDoc })
+          const patches = A.diff(newDoc, A.getHeads(oldDoc), A.getHeads(newDoc))
+          if (patches.length > 0) {
+            const source = "change" // TODO: pass along the source (load/change/network)
+            this.emit("change", {
+              handle: this,
+              doc: newDoc,
+              patches,
+              patchInfo: { before: oldDoc, after: newDoc, source },
+            })
+          }
+          if (!this.isReady()) {
+            this.#machine.send(REQUEST_COMPLETE)
+          }
+        }
+      })
+      .start()
+    this.#machine.send(isNew ? CREATE : FIND)
+  }
+  // PRIVATE
+  /** Returns the current document, regardless of state */
+  get #doc() {
+    return this.#machine?.getSnapshot().context.doc
+  }
+  /** Returns the docHandle's state (READY, etc.) */
+  get #state() {
+    return this.#machine?.getSnapshot().value
+  }
+  /** Returns a promise that resolves when the docHandle is in one of the given states */
+  #statePromise(awaitStates) {
+    if (!Array.isArray(awaitStates)) awaitStates = [awaitStates]
+    return Promise.any(
+      awaitStates.map(state =>
+        waitFor(this.#machine, s => s.matches(state), {
+          timeout: this.#timeoutDelay * 2000, // longer than the delay above for testing
+        })
+      )
+    )
+  }
+  // PUBLIC
+  /**
+   * Checks if the document is ready for accessing or changes.
+   * Note that for documents already stored locally this occurs before synchronization
+   * with any peers. We do not currently have an equivalent `whenSynced()`.
+   */
+  isReady = () => this.inState([HandleState.READY])
+  /**
+   * Checks if this document has been marked as deleted.
+   * Deleted documents are removed from local storage and the sync process.
+   * It's not currently possible at runtime to undelete a document.
+   * @returns true if the document has been marked as deleted
+   */
+  isDeleted = () => this.inState([HandleState.DELETED])
+  isUnavailable = () => this.inState([HandleState.UNAVAILABLE])
+  inState = states => states.some(this.#machine?.getSnapshot().matches)
+  /** @hidden */
+  get state() {
+    return this.#machine?.getSnapshot().value
+  }
+  /**
+   * Use this to block until the document handle has finished loading.
+   * The async equivalent to checking `inState()`.
+   * @param awaitStates = [READY]
+   * @returns
+   */
+  async whenReady(awaitStates = [READY]) {
+    await withTimeout(this.#statePromise(awaitStates), this.#timeoutDelay)
+  }
+  /**
+   * Returns the current state of the Automerge document this handle manages.
+   * Note that this waits for the handle to be ready if necessary, and currently, if
+   * loading (or synchronization) fails, will never resolve.
+   *
+   * @param {awaitStates=[READY]} optional states to wait for, such as "LOADING". mostly for internal use.
+   */
+  async doc(awaitStates = [READY, UNAVAILABLE]) {
+    await pause() // yield one tick because reasons
+    try {
+      // wait for the document to enter one of the desired states
+      await this.#statePromise(awaitStates)
+    } catch (error) {
+      if (error instanceof TimeoutError)
+        throw new Error(`DocHandle: timed out loading ${this.documentId}`)
+      else throw error
+    }
+    // Return the document
+    return !this.isUnavailable() ? this.#doc : undefined
+  }
+  /**
+   * Returns the current state of the Automerge document this handle manages, or undefined.
+   * Useful in a synchronous context. Consider using `await handle.doc()` instead, check `isReady()`,
+   * or use `whenReady()` if you want to make sure loading is complete first.
+   *
+   * Do not confuse this with the SyncState of the document, which describes the state of the synchronization process.
+   *
+   * Note that `undefined` is not a valid Automerge document so the return from this function is unambigous.
+   * @returns the current document, or undefined if the document is not ready
+   */
+  docSync() {
+    if (!this.isReady()) {
+      return undefined
+    }
+    return this.#doc
+  }
+  /** `update` is called by the repo when we receive changes from the network
+   * @hidden
+   * */
+  update(callback) {
+    this.#machine.send(UPDATE, {
+      payload: { callback },
+    })
+  }
+  /** `change` is called by the repo when the document is changed locally  */
+  change(callback, options = {}) {
+    if (!this.isReady()) {
+      throw new Error(
+        `DocHandle#${this.documentId} is not ready. Check \`handle.isReady()\` before accessing the document.`
+      )
+    }
+    this.#machine.send(UPDATE, {
+      payload: {
+        callback: doc => {
+          return A.change(doc, options, callback)
+        },
+      },
+    })
+  }
+  /** Make a change as if the document were at `heads`
+   *
+   * @returns A set of heads representing the concurrent change that was made.
+   */
+  changeAt(heads, callback, options = {}) {
+    if (!this.isReady()) {
+      throw new Error(
+        `DocHandle#${this.documentId} is not ready. Check \`handle.isReady()\` before accessing the document.`
+      )
+    }
+    let resultHeads = undefined
+    this.#machine.send(UPDATE, {
+      payload: {
+        callback: doc => {
+          const result = A.changeAt(doc, heads, options, callback)
+          resultHeads = result.newHeads
+          return result.newDoc
+        },
+      },
+    })
+    return resultHeads
+  }
+  unavailable() {
+    this.#machine.send(MARK_UNAVAILABLE)
+  }
+  /** `request` is called by the repo when the document is not found in storage
+   * @hidden
+   * */
+  request() {
+    if (this.#state === LOADING) this.#machine.send(REQUEST)
+  }
+  /** @hidden */
+  awaitNetwork() {
+    if (this.#state === LOADING) this.#machine.send(AWAIT_NETWORK)
+  }
+  /** @hidden */
+  networkReady() {
+    if (this.#state === AWAITING_NETWORK) this.#machine.send(NETWORK_READY)
+  }
+  /** `delete` is called by the repo when the document is deleted */
+  delete() {
+    this.#machine.send(DELETE)
+  }
+  /** `broadcast` sends an arbitrary ephemeral message out to all reachable peers who would receive sync messages from you
+   * it has no guarantee of delivery, and is not persisted to the underlying automerge doc in any way.
+   * messages will have a sending PeerId but this is *not* a useful user identifier.
+   * a user could have multiple tabs open and would appear as multiple PeerIds.
+   * every message source must have a unique PeerId.
+   */
+  broadcast(message) {
+    this.emit("ephemeral-message-outbound", {
+      handle: this,
+      data: encode(message),
+    })
+  }
+}
+// STATE MACHINE TYPES
+// state
+export const HandleState = {
+  IDLE: "idle",
+  LOADING: "loading",
+  AWAITING_NETWORK: "awaitingNetwork",
+  REQUESTING: "requesting",
+  READY: "ready",
+  FAILED: "failed",
+  DELETED: "deleted",
+  UNAVAILABLE: "unavailable",
+}
+// events
+export const Event = {
+  CREATE: "CREATE",
+  FIND: "FIND",
+  REQUEST: "REQUEST",
+  REQUEST_COMPLETE: "REQUEST_COMPLETE",
+  AWAIT_NETWORK: "AWAIT_NETWORK",
+  NETWORK_READY: "NETWORK_READY",
+  UPDATE: "UPDATE",
+  TIMEOUT: "TIMEOUT",
+  DELETE: "DELETE",
+  MARK_UNAVAILABLE: "MARK_UNAVAILABLE",
+}
+// CONSTANTS
+export const {
+  IDLE,
+  LOADING,
+  AWAITING_NETWORK,
+  REQUESTING,
+  READY,
+  FAILED,
+  DELETED,
+  UNAVAILABLE,
+} = HandleState
+const {
+  CREATE,
+  FIND,
+  REQUEST,
+  UPDATE,
+  TIMEOUT,
+  DELETE,
+  REQUEST_COMPLETE,
+  MARK_UNAVAILABLE,
+  AWAIT_NETWORK,
+  NETWORK_READY,
+} = Event

package/dist/src/DocUrl.d.ts

@@ -0,0 +1,49 @@
+import {
+  type AutomergeUrl,
+  type BinaryDocumentId,
+  type DocumentId,
+} from "./types.js"
+export declare const urlPrefix = "automerge:"
+/**
+ * given an Automerge URL, return a decoded DocumentId (and the encoded DocumentId)
+ *
+ * @param url
+ * @returns { binaryDocumentId: BinaryDocumentId, documentId: DocumentId }
+ */
+export declare const parseAutomergeUrl: (url: AutomergeUrl) => {
+  binaryDocumentId: BinaryDocumentId
+  documentId: DocumentId
+}
+interface StringifyAutomergeUrlOptions {
+  documentId: DocumentId | BinaryDocumentId
+}
+/**
+ * Given a documentId in either canonical form, return an Automerge URL
+ * Throws on invalid input.
+ * Note: this is an object because we anticipate adding fields in the future.
+ * @param { documentId: BinaryDocumentId | DocumentId }
+ * @returns AutomergeUrl
+ */
+export declare const stringifyAutomergeUrl: ({
+  documentId,
+}: StringifyAutomergeUrlOptions) => AutomergeUrl
+/**
+ * Given a string, return true if it is a valid Automerge URL
+ * also acts as a type discriminator in Typescript.
+ * @param str: URL candidate
+ * @returns boolean
+ */
+export declare const isValidAutomergeUrl: (str: string) => str is AutomergeUrl
+/**
+ * generateAutomergeUrl produces a new AutomergeUrl.
+ * generally only called by create(), but used in tests as well.
+ * @returns a new Automerge URL with a random UUID documentId
+ */
+export declare const generateAutomergeUrl: () => AutomergeUrl
+export declare const documentIdToBinary: (
+  docId: DocumentId
+) => BinaryDocumentId | undefined
+export declare const binaryToDocumentId: (docId: BinaryDocumentId) => DocumentId
+export declare const parseLegacyUUID: (str: string) => AutomergeUrl | undefined
+export {}
+//# sourceMappingURL=DocUrl.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"DocUrl.d.ts","sourceRoot":"","sources":["../../src/DocUrl.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,YAAY,EACjB,KAAK,gBAAgB,EACrB,KAAK,UAAU,EAChB,MAAM,YAAY,CAAA;AAInB,eAAO,MAAM,SAAS,eAAe,CAAA;AAErC;;;;;GAKG;AACH,eAAO,MAAM,iBAAiB,QAAS,YAAY;;;CAIlD,CAAA;AAED,UAAU,4BAA4B;IACpC,UAAU,EAAE,UAAU,GAAG,gBAAgB,CAAA;CAC1C;AAED;;;;;;GAMG;AACH,eAAO,MAAM,qBAAqB,oBAE/B,4BAA4B,KAAG,YAQjC,CAAA;AAED;;;;;GAKG;AACH,eAAO,MAAM,mBAAmB,QAAS,MAAM,wBAK9C,CAAA;AAED;;;;GAIG;AACH,eAAO,MAAM,oBAAoB,QAAO,YAGpC,CAAA;AAEJ,eAAO,MAAM,kBAAkB,UACtB,UAAU,KAChB,gBAAgB,GAAG,SACyC,CAAA;AAE/D,eAAO,MAAM,kBAAkB,UAAW,gBAAgB,KAAG,UACtB,CAAA;AAEvC,eAAO,MAAM,eAAe,QAAS,MAAM,KAAG,YAAY,GAAG,SAM5D,CAAA"}

package/dist/src/DocUrl.js

@@ -0,0 +1,72 @@
+import * as Uuid from "uuid"
+import bs58check from "bs58check"
+export const urlPrefix = "automerge:"
+/**
+ * given an Automerge URL, return a decoded DocumentId (and the encoded DocumentId)
+ *
+ * @param url
+ * @returns { binaryDocumentId: BinaryDocumentId, documentId: DocumentId }
+ */
+export const parseAutomergeUrl = url => {
+  const { binaryDocumentId, documentId } = parts(url)
+  if (!binaryDocumentId) throw new Error("Invalid document URL: " + url)
+  return { binaryDocumentId, documentId }
+}
+/**
+ * Given a documentId in either canonical form, return an Automerge URL
+ * Throws on invalid input.
+ * Note: this is an object because we anticipate adding fields in the future.
+ * @param { documentId: BinaryDocumentId | DocumentId }
+ * @returns AutomergeUrl
+ */
+export const stringifyAutomergeUrl = ({ documentId }) => {
+  if (documentId instanceof Uint8Array)
+    return urlPrefix + binaryToDocumentId(documentId)
+  else if (typeof documentId === "string") {
+    return urlPrefix + documentId
+  }
+  throw new Error("Invalid documentId: " + documentId)
+}
+/**
+ * Given a string, return true if it is a valid Automerge URL
+ * also acts as a type discriminator in Typescript.
+ * @param str: URL candidate
+ * @returns boolean
+ */
+export const isValidAutomergeUrl = str => {
+  if (!str.startsWith(urlPrefix)) return false
+  const { binaryDocumentId: documentId } = parts(str)
+  return documentId ? true : false
+}
+/**
+ * generateAutomergeUrl produces a new AutomergeUrl.
+ * generally only called by create(), but used in tests as well.
+ * @returns a new Automerge URL with a random UUID documentId
+ */
+export const generateAutomergeUrl = () =>
+  stringifyAutomergeUrl({
+    documentId: Uuid.v4(null, new Uint8Array(16)),
+  })
+export const documentIdToBinary = docId => bs58check.decodeUnsafe(docId)
+export const binaryToDocumentId = docId => bs58check.encode(docId)
+export const parseLegacyUUID = str => {
+  if (Uuid.validate(str)) {
+    const uuid = Uuid.parse(str)
+    return stringifyAutomergeUrl({ documentId: uuid })
+  }
+  return undefined
+}
+/**
+ * parts breaks up the URL into constituent pieces,
+ * eventually this could include things like heads, so we use this structure
+ * we return both a binary & string-encoded version of the document ID
+ * @param str
+ * @returns { binaryDocumentId, documentId }
+ */
+const parts = str => {
+  const regex = new RegExp(`^${urlPrefix}(\\w+)$`)
+  const [_, docMatch] = str.match(regex) || []
+  const documentId = docMatch
+  const binaryDocumentId = documentIdToBinary(documentId)
+  return { binaryDocumentId, documentId }
+}

package/dist/src/EphemeralData.d.ts

@@ -0,0 +1,19 @@
+import { DocumentId, PeerId } from "./index.js"
+import { EphemeralMessageContents } from "./network/messages.js"
+export type SessionId = string & {
+  __SessionId: false
+}
+export interface EphemeralDataPayload {
+  documentId: DocumentId
+  peerId: PeerId
+  data: {
+    peerId: PeerId
+    documentId: DocumentId
+    data: unknown
+  }
+}
+export type EphemeralDataMessageEvents = {
+  message: (event: EphemeralMessageContents) => void
+  data: (event: EphemeralDataPayload) => void
+}
+//# sourceMappingURL=EphemeralData.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"EphemeralData.d.ts","sourceRoot":"","sources":["../../src/EphemeralData.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,EAAE,MAAM,YAAY,CAAA;AAC/C,OAAO,EAAE,wBAAwB,EAAE,MAAM,uBAAuB,CAAA;AAGhE,MAAM,MAAM,SAAS,GAAG,MAAM,GAAG;IAAE,WAAW,EAAE,KAAK,CAAA;CAAE,CAAA;AAEvD,MAAM,WAAW,oBAAoB;IACnC,UAAU,EAAE,UAAU,CAAA;IACtB,MAAM,EAAE,MAAM,CAAA;IACd,IAAI,EAAE;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,UAAU,CAAC;QAAC,IAAI,EAAE,OAAO,CAAA;KAAE,CAAA;CAChE;AAED,MAAM,MAAM,0BAA0B,GAAG;IACvC,OAAO,EAAE,CAAC,KAAK,EAAE,wBAAwB,KAAK,IAAI,CAAA;IAClD,IAAI,EAAE,CAAC,KAAK,EAAE,oBAAoB,KAAK,IAAI,CAAA;CAC5C,CAAA"}

package/dist/src/EphemeralData.js

@@ -0,0 +1 @@
+export {}

package/dist/src/Repo.d.ts

@@ -0,0 +1,74 @@
+import { NetworkAdapter } from "./network/NetworkAdapter.js"
+import { NetworkSubsystem } from "./network/NetworkSubsystem.js"
+import { StorageAdapter } from "./storage/StorageAdapter.js"
+import { StorageSubsystem } from "./storage/StorageSubsystem.js"
+import { type AutomergeUrl, DocumentId, PeerId } from "./types.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 declare class Repo extends EventEmitter<DocCollectionEvents> {
+  #private
+  networkSubsystem: NetworkSubsystem
+  storageSubsystem?: StorageSubsystem
+  /** By default, we share generously with all peers. */
+  sharePolicy: SharePolicy
+  constructor({ storage, network, peerId, sharePolicy }: RepoConfig)
+  /** Returns all the handles we have cached. */
+  get handles(): Record<DocumentId, DocHandle<any>>
+  /**
+   * 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<T>(): DocHandle<T>
+  /**
+   * 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<T>(
+    /** The documentId of the handle to retrieve */
+    automergeUrl: AutomergeUrl
+  ): DocHandle<T>
+  delete(
+    /** The documentId of the handle to delete */
+    id: DocumentId | AutomergeUrl
+  ): void
+}
+export interface RepoConfig {
+  /** Our unique identifier */
+  peerId?: PeerId
+  /** A storage adapter can be provided, or not */
+  storage?: StorageAdapter
+  /** One or more network adapters must be provided */
+  network: NetworkAdapter[]
+  /**
+   * Normal peers typically share generously with everyone (meaning we sync all our documents with
+   * all peers). A server only syncs documents that a peer explicitly requests by ID.
+   */
+  sharePolicy?: SharePolicy
+}
+export type SharePolicy = (
+  peerId: PeerId,
+  documentId?: DocumentId
+) => Promise<boolean>
+interface DocCollectionEvents {
+  document: (arg: DocumentPayload) => void
+  "delete-document": (arg: DeleteDocumentPayload) => void
+  "unavailable-document": (arg: DeleteDocumentPayload) => void
+}
+interface DocumentPayload {
+  handle: DocHandle<any>
+  isNew: boolean
+}
+interface DeleteDocumentPayload {
+  documentId: DocumentId
+}
+export {}
+//# sourceMappingURL=Repo.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Repo.d.ts","sourceRoot":"","sources":["../../src/Repo.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,cAAc,EAAE,MAAM,6BAA6B,CAAA;AAC5D,OAAO,EAAE,gBAAgB,EAAE,MAAM,+BAA+B,CAAA;AAChE,OAAO,EAAE,cAAc,EAAE,MAAM,6BAA6B,CAAA;AAC5D,OAAO,EAAE,gBAAgB,EAAE,MAAM,+BAA+B,CAAA;AAEhE,OAAO,EAAE,KAAK,YAAY,EAAE,UAAU,EAAE,MAAM,EAAE,MAAM,YAAY,CAAA;AASlE,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAA;AAC1C,OAAO,EAAE,YAAY,EAAE,MAAM,eAAe,CAAA;AAG5C,8FAA8F;AAC9F;;;;;;GAMG;AACH,qBAAa,IAAK,SAAQ,YAAY,CAAC,mBAAmB,CAAC;;IAGzD,gBAAgB,EAAE,gBAAgB,CAAA;IAClC,gBAAgB,CAAC,EAAE,gBAAgB,CAAA;IAGnC,sDAAsD;IACtD,WAAW,EAAE,WAAW,CAAmB;gBAE/B,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,WAAW,EAAE,EAAE,UAAU;IAuHjE,8CAA8C;IAC9C,IAAI,OAAO,uCAEV;IAED;;;;OAIG;IACH,MAAM,CAAC,CAAC,KAAK,SAAS,CAAC,CAAC,CAAC;IA0BzB;;;OAGG;IACH,IAAI,CAAC,CAAC;IACJ,+CAA+C;IAC/C,YAAY,EAAE,YAAY,GACzB,SAAS,CAAC,CAAC,CAAC;IAgCf,MAAM;IACJ,6CAA6C;IAC7C,EAAE,EAAE,UAAU,GAAG,YAAY;CAchC;AAED,MAAM,WAAW,UAAU;IACzB,4BAA4B;IAC5B,MAAM,CAAC,EAAE,MAAM,CAAA;IAEf,gDAAgD;IAChD,OAAO,CAAC,EAAE,cAAc,CAAA;IAExB,oDAAoD;IACpD,OAAO,EAAE,cAAc,EAAE,CAAA;IAEzB;;;OAGG;IACH,WAAW,CAAC,EAAE,WAAW,CAAA;CAC1B;AAED,MAAM,MAAM,WAAW,GAAG,CACxB,MAAM,EAAE,MAAM,EACd,UAAU,CAAC,EAAE,UAAU,KACpB,OAAO,CAAC,OAAO,CAAC,CAAA;AAGrB,UAAU,mBAAmB;IAC3B,QAAQ,EAAE,CAAC,GAAG,EAAE,eAAe,KAAK,IAAI,CAAA;IACxC,iBAAiB,EAAE,CAAC,GAAG,EAAE,qBAAqB,KAAK,IAAI,CAAA;IACvD,sBAAsB,EAAE,CAAC,GAAG,EAAE,qBAAqB,KAAK,IAAI,CAAA;CAC7D;AAED,UAAU,eAAe;IACvB,MAAM,EAAE,SAAS,CAAC,GAAG,CAAC,CAAA;IACtB,KAAK,EAAE,OAAO,CAAA;CACf;AAED,UAAU,qBAAqB;IAC7B,UAAU,EAAE,UAAU,CAAA;CACvB"}