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

package/dist/ferigan.js

@@ -1,98 +0,0 @@
-import { EventEmitter } from "eventemitter3";
-const URL_RE = /automerge:([\w\d+/=]+)(?:\?([\w\d+/=&]*))*/;
-export function makeFerigan(repo) {
-    function fakeProgress() {
-        return (async function* () {
-            yield { type: "synchronizing_index" };
-        })();
-    }
-    class FakeFerigan extends EventEmitter {
-        #repo;
-        constructor(repo) {
-            super();
-            this.#repo = repo;
-        }
-        async receiveMessage(message) { }
-        load(doc) {
-            return fakeProgress();
-        }
-        async *loadCollection(doc) {
-            yield { type: "synchronizing_index" };
-            const index = { rootUrl: doc, entries: [] };
-            function findLinks(obj) {
-                const links = [];
-                const traverse = (value) => {
-                    if (typeof value === "string") {
-                        const url = parseUrl(value);
-                        if (url != null) {
-                            links.push(url);
-                        }
-                    }
-                    else if (Array.isArray(value)) {
-                        value.forEach(traverse);
-                    }
-                    else if (typeof value === "object" && value !== null) {
-                        Object.values(value).forEach(traverse);
-                    }
-                };
-                traverse(obj);
-                return links;
-            }
-            const indexDoc = this.#repo.find(doc);
-            const handlesToProcess = [indexDoc];
-            while (handlesToProcess.length > 0) {
-                const handle = handlesToProcess.pop();
-                if (!handle) {
-                    continue;
-                }
-                const doc = await handle.doc();
-                if (!doc) {
-                    continue;
-                }
-                handle.on("change", change => {
-                    for (const patch of change.patches) {
-                        if (patch.action === "splice") {
-                            const possibleUrl = parseUrl(patch.value);
-                            if (possibleUrl != null) {
-                                this.emit("indexChanged", {
-                                    indexUrl: indexDoc.url,
-                                    change: {
-                                        type: "add",
-                                        url: possibleUrl.url,
-                                    }
-                                });
-                            }
-                        }
-                    }
-                });
-                const links = findLinks(doc);
-                for (const { url: urlStr } of links) {
-                    const url = urlStr;
-                    if (index.entries.some(entry => entry === url)) {
-                        continue;
-                    }
-                    index.entries.push(url);
-                    const childHandle = this.#repo.find(url);
-                    handlesToProcess.push(childHandle);
-                }
-            }
-            yield { type: "done", value: index };
-        }
-        append(doc, parents, changes) {
-            return Promise.resolve();
-        }
-        replace(doc, start, end, changes) {
-            return Promise.resolve();
-        }
-    }
-    return new FakeFerigan(repo);
-}
-function parseUrl(urlStr) {
-    const match = urlStr.match(URL_RE);
-    if (!match) {
-        return undefined;
-    }
-    const url = new URL(match[0]);
-    const normalisedUrl = `automerge:${url.pathname}`;
-    return { url: normalisedUrl };
-}

package/dist/src/DocHandle.d.ts

@@ -1,182 +0,0 @@
-import * as A from "@automerge/automerge/next"
-import { EventEmitter } from "eventemitter3"
-import { StateValue } from "xstate"
-import type { DocumentId, PeerId, AutomergeUrl } from "./types.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 declare class DocHandle<T> //
-  extends EventEmitter<DocHandleEvents<T>>
-{
-  #private
-  documentId: DocumentId
-  /** The URL of this document
-   *
-   * @remarks
-   * This can be used to request the document from an instance of {@link Repo}
-   */
-  get url(): AutomergeUrl
-  /** @hidden */
-  constructor(
-    documentId: DocumentId,
-    { isNew, timeoutDelay }?: DocHandleOptions
-  )
-  /**
-   * 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: () => boolean
-  /**
-   * 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: () => boolean
-  isUnavailable: () => boolean
-  inState: (states: HandleState[]) => boolean
-  /** @hidden */
-  get state(): StateValue
-  /**
-   * Use this to block until the document handle has finished loading.
-   * The async equivalent to checking `inState()`.
-   * @param awaitStates = [READY]
-   * @returns
-   */
-  whenReady(awaitStates?: HandleState[]): Promise<void>
-  /**
-   * 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.
-   */
-  doc(awaitStates?: HandleState[]): Promise<A.Doc<T> | 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(): A.Doc<T> | undefined
-  /** `update` is called by the repo when we receive changes from the network
-   * @hidden
-   * */
-  update(callback: (doc: A.Doc<T>) => A.Doc<T>): void
-  /** `change` is called by the repo when the document is changed locally  */
-  change(callback: A.ChangeFn<T>, options?: A.ChangeOptions<T>): void
-  /** Make a change as if the document were at `heads`
-   *
-   * @returns A set of heads representing the concurrent change that was made.
-   */
-  changeAt(
-    heads: A.Heads,
-    callback: A.ChangeFn<T>,
-    options?: A.ChangeOptions<T>
-  ): string[] | undefined
-  unavailable(): void
-  /** `request` is called by the repo when the document is not found in storage
-   * @hidden
-   * */
-  request(): void
-  /** @hidden */
-  awaitNetwork(): void
-  /** @hidden */
-  networkReady(): void
-  /** `delete` is called by the repo when the document is deleted */
-  delete(): void
-  /** `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: any): void
-}
-export interface DocHandleOptions {
-  isNew?: boolean
-  timeoutDelay?: number
-}
-export interface DocHandleMessagePayload {
-  destinationId: PeerId
-  documentId: DocumentId
-  data: Uint8Array
-}
-export interface DocHandleEncodedChangePayload<T> {
-  handle: DocHandle<T>
-  doc: A.Doc<T>
-}
-export interface DocHandleDeletePayload<T> {
-  handle: DocHandle<T>
-}
-export interface DocHandleChangePayload<T> {
-  handle: DocHandle<T>
-  doc: A.Doc<T>
-  patches: A.Patch[]
-  patchInfo: A.PatchInfo<T>
-}
-export interface DocHandleEphemeralMessagePayload {
-  handle: DocHandle<any>
-  senderId: PeerId
-  message: unknown
-}
-export interface DocHandleOutboundEphemeralMessagePayload {
-  handle: DocHandle<any>
-  data: Uint8Array
-}
-export interface DocHandleEvents<T> {
-  "heads-changed": (payload: DocHandleEncodedChangePayload<T>) => void
-  change: (payload: DocHandleChangePayload<T>) => void
-  delete: (payload: DocHandleDeletePayload<T>) => void
-  unavailable: (payload: DocHandleDeletePayload<T>) => void
-  "ephemeral-message": (payload: DocHandleEphemeralMessagePayload) => void
-  "ephemeral-message-outbound": (
-    payload: DocHandleOutboundEphemeralMessagePayload
-  ) => void
-}
-export declare const HandleState: {
-  readonly IDLE: "idle"
-  readonly LOADING: "loading"
-  readonly AWAITING_NETWORK: "awaitingNetwork"
-  readonly REQUESTING: "requesting"
-  readonly READY: "ready"
-  readonly FAILED: "failed"
-  readonly DELETED: "deleted"
-  readonly UNAVAILABLE: "unavailable"
-}
-export type HandleState = (typeof HandleState)[keyof typeof HandleState]
-export declare const Event: {
-  readonly CREATE: "CREATE"
-  readonly FIND: "FIND"
-  readonly REQUEST: "REQUEST"
-  readonly REQUEST_COMPLETE: "REQUEST_COMPLETE"
-  readonly AWAIT_NETWORK: "AWAIT_NETWORK"
-  readonly NETWORK_READY: "NETWORK_READY"
-  readonly UPDATE: "UPDATE"
-  readonly TIMEOUT: "TIMEOUT"
-  readonly DELETE: "DELETE"
-  readonly MARK_UNAVAILABLE: "MARK_UNAVAILABLE"
-}
-export declare const IDLE: "idle",
-  LOADING: "loading",
-  AWAITING_NETWORK: "awaitingNetwork",
-  REQUESTING: "requesting",
-  READY: "ready",
-  FAILED: "failed",
-  DELETED: "deleted",
-  UNAVAILABLE: "unavailable"
-//# sourceMappingURL=DocHandle.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"DocHandle.d.ts","sourceRoot":"","sources":["../../src/DocHandle.ts"],"names":[],"mappings":"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"}

package/dist/src/DocHandle.js

@@ -1,405 +0,0 @@
-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