@comapeo/core 1.0.0

package/dist/invite-api.d.ts

@@ -0,0 +1,70 @@
+/**
+ * @typedef {Object} InviteApiEvents
+ * @property {(invite: Invite) => void} invite-received
+ * @property {(invite: Invite, removalReason: InviteRemovalReason) => void} invite-removed
+ */
+/**
+ * @extends {TypedEmitter<InviteApiEvents>}
+ */
+export class InviteApi extends TypedEmitter<InviteApiEvents> {
+    /**
+     * @param {Object} options
+     * @param {import('./local-peers.js').LocalPeers} options.rpc
+     * @param {object} options.queries
+     * @param {(projectInviteId: Readonly<Buffer>) => undefined | { projectPublicId: string }} options.queries.getProjectByInviteId
+     * @param {(projectDetails: Pick<ProjectJoinDetails, 'projectKey' | 'encryptionKeys'> & { projectName: string }) => Promise<string>} options.queries.addProject
+     * @param {Logger} [options.logger]
+     */
+    constructor({ rpc, queries, logger }: {
+        rpc: import("./local-peers.js").LocalPeers;
+        queries: {
+            getProjectByInviteId: (projectInviteId: Readonly<Buffer>) => undefined | {
+                projectPublicId: string;
+            };
+            addProject: (projectDetails: Pick<ProjectJoinDetails, "projectKey" | "encryptionKeys"> & {
+                projectName: string;
+            }) => Promise<string>;
+        };
+        logger?: Logger | undefined;
+    });
+    rpc: import("./local-peers.js").LocalPeers;
+    /**
+     * @returns {Array<Invite>}
+     */
+    getPending(): Array<Invite>;
+    /**
+     * Attempt to accept the invite.
+     *
+     * This can fail if the invitor has canceled the invite or if you cannot
+     * connect to the invitor's device.
+     *
+     * If the invite is accepted and you had other invites to the same project,
+     * those invites are removed, and the invitors are told that you're already
+     * part of this project.
+     *
+     * @param {Pick<Invite, 'inviteId'>} invite
+     * @returns {Promise<string>}
+     */
+    accept({ inviteId: inviteIdString }: Pick<Invite, "inviteId">): Promise<string>;
+    /**
+     * @param {Pick<Invite, 'inviteId'>} invite
+     * @returns {void}
+     */
+    reject({ inviteId: inviteIdString }: Pick<Invite, "inviteId">): void;
+    #private;
+}
+export type InviteInternal = InviteRpcMessage & {
+    receivedAt: number;
+};
+export type Invite = MapBuffers<InviteInternal>;
+export type InviteRemovalReason = ("accepted" | "rejected" | "canceled" | "accepted other" | "connection error" | "internal error");
+export type InviteApiEvents = {
+    "invite-received": (invite: Invite) => void;
+    "invite-removed": (invite: Invite, removalReason: InviteRemovalReason) => void;
+};
+import { TypedEmitter } from 'tiny-typed-emitter';
+import type { ProjectJoinDetails } from './generated/rpc.js';
+import { Logger } from './logger.js';
+import type { Invite as InviteRpcMessage } from './generated/rpc.js';
+import type { MapBuffers } from './types.js';
+//# sourceMappingURL=invite-api.d.ts.map

package/dist/invite-api.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"invite-api.d.ts","sourceRoot":"","sources":["../src/invite-api.js"],"names":[],"mappings":"AAiJA;;;;GAIG;AAEH;;GAEG;AACH;IAME;;;;;;;OAOG;IACH,sCANG;QAAuD,GAAG,EAAlD,OAAO,kBAAkB,EAAE,UAAU;QACrB,OAAO,EAC/B;YAAwG,oBAAoB,EAApH,CAAC,eAAe,EAAE,QAAQ,CAAC,MAAM,CAAC,KAAK,SAAS,GAAG;gBAAE,eAAe,EAAE,MAAM,CAAA;aAAE;YAC4D,UAAU,EAApJ,CAAC,cAAc,EAAE,IAAI,CAAC,kBAAkB,EAAE,YAAY,GAAG,gBAAgB,CAAC,GAAG;gBAAE,WAAW,EAAE,MAAM,CAAA;aAAE,KAAK,OAAO,CAAC,MAAM,CAAC;SAChI;QAAyB,MAAM;KAAC,EA0BlC;IAnBC,2CAAc;IAsFhB;;OAEG;IACH,cAFa,KAAK,CAAC,MAAM,CAAC,CAMzB;IAED;;;;;;;;;;;;OAYG;IACH,qCAHW,IAAI,CAAC,MAAM,EAAE,UAAU,CAAC,GACtB,OAAO,CAAC,MAAM,CAAC,CAkI3B;IAED;;;OAGG;IACH,qCAHW,IAAI,CAAC,MAAM,EAAE,UAAU,CAAC,GACtB,IAAI,CAuBhB;;CACF;6BA7ZY,gBAAgB,GAAG;IAAE,UAAU,EAAE,MAAM,CAAA;CAAE;qBAGxC,WAAW,cAAc,CAAC;kCAG3B,CACZ,UAAa,GACb,UAAa,GACb,UAAa,GACb,gBAAmB,GACnB,kBAAqB,GACrB,gBAAmB,CAChB;;uBA8GU,CAAC,MAAM,EAAE,MAAM,KAAK,IAAI;sBACxB,CAAC,MAAM,EAAE,MAAM,EAAE,aAAa,EAAE,mBAAmB,KAAK,IAAI;;6BApJ7C,oBAAoB;wCAavC,oBAAoB;uBAPP,aAAa;gDAO1B,oBAAoB;gCANE,YAAY"}

package/dist/lib/hashmap.d.ts

@@ -0,0 +1,62 @@
+/** @typedef {string | number | bigint | boolean | undefined | symbol | null} Primitive */
+/**
+ * `Map` uses same-value-zero equality for keys, which makes it more difficult
+ * to use reference types like buffers.
+ *
+ * `HashMap` is very similar to `Map`, but accepts a hash function for keys.
+ * This function should return a primitive, such as a number or string, which
+ * will be used as the key.
+ *
+ * It doesn't contain all the functionality of `Map` because we don't need it,
+ * but it should be fairly easy to update as needed.
+ *
+ * @template K
+ * @template {unknown} V
+ * @example
+ * const join = (arr) => arr.join(' ')
+ *
+ * const map = new HashMap(join)
+ *
+ * map.set([1, 2], 3)
+ * map.get([1, 2])
+ * // => 3
+ */
+export default class HashMap<K, V extends unknown> {
+    /**
+     * @param {(key: K) => Primitive} hash
+     * @param {Iterable<[K, V]>} [iterable=[]]
+     */
+    constructor(hash: (key: K) => Primitive, iterable?: Iterable<[K, V]> | undefined);
+    /**
+     * @returns {number}
+     */
+    get size(): number;
+    /**
+     * @param {K} key The key to remove.
+     * @returns {boolean} `true` if the key was present and removed, `false` otherwise.
+     */
+    delete(key: K): boolean;
+    /**
+     * @param {K} key The key to look up.
+     * @returns {undefined | V} The element associated with `key`, or `undefined` if it's not present.
+     */
+    get(key: K): undefined | V;
+    /**
+     * @param {K} key The key to look up.
+     * @returns {boolean} `true` if `key` is present in the map, `false` otherwise.
+     */
+    has(key: K): boolean;
+    /**
+     * @param {K} key The key to update.
+     * @param {V} value The value to add at `key`.
+     * @returns {this} The map.
+     */
+    set(key: K, value: V): this;
+    /**
+     * @returns {IterableIterator<V>}
+     */
+    values(): IterableIterator<V>;
+    #private;
+}
+export type Primitive = string | number | bigint | boolean | undefined | symbol | null;
+//# sourceMappingURL=hashmap.d.ts.map

package/dist/lib/hashmap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hashmap.d.ts","sourceRoot":"","sources":["../../src/lib/hashmap.js"],"names":[],"mappings":"AAAA,0FAA0F;AAE1F;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,6BAXa,CAAC,EACS,CAAC,SAAX,OAAS;IAgBpB;;;OAGG;IACH,kBAHW,CAAC,GAAG,EAAE,CAAC,KAAK,SAAS,2CAM/B;IAED;;OAEG;IACH,mBAEC;IAED;;;OAGG;IACH,YAHW,CAAC,GACC,OAAO,CAKnB;IAED;;;OAGG;IACH,SAHW,CAAC,GACC,SAAS,GAAG,CAAC,CAKzB;IAED;;;OAGG;IACH,SAHW,CAAC,GACC,OAAO,CAKnB;IAED;;;;OAIG;IACH,SAJW,CAAC,SACD,CAAC,GACC,IAAI,CAMhB;IAED;;OAEG;IACH,UAFa,gBAAgB,CAAC,CAAC,CAAC,CAI/B;;CACF;wBA1Fa,MAAM,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,SAAS,GAAG,MAAM,GAAG,IAAI"}

package/dist/lib/hypercore-helpers.d.ts

@@ -0,0 +1,6 @@
+/**
+ * @param {import('hypercore')<'binary', any>} core Core to unreplicate. Must be ready.
+ * @param {import('protomux')} protomux
+ */
+export function unreplicate(core: import("hypercore")<"binary", any>, protomux: import("protomux")): void;
+//# sourceMappingURL=hypercore-helpers.d.ts.map

package/dist/lib/hypercore-helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hypercore-helpers.d.ts","sourceRoot":"","sources":["../../src/lib/hypercore-helpers.js"],"names":[],"mappings":"AAEA;;;GAGG;AACH,kCAHW,OAAO,WAAW,EAAE,QAAQ,EAAE,GAAG,CAAC,YAClC,OAAO,UAAU,CAAC,QAa5B"}

package/dist/lib/noise-secret-stream-helpers.d.ts

@@ -0,0 +1,45 @@
+/** @import { Duplex as NodeDuplex } from 'node:stream' */
+/** @import { Duplex as StreamxDuplex } from 'streamx' */
+/** @import NoiseSecretStream from '@hyperswarm/secret-stream' */
+/**
+ * @internal
+ * @typedef {NodeDuplex | StreamxDuplex} RawStream
+ */
+/**
+ * @template {RawStream} [T=RawStream]
+ * @typedef {NoiseSecretStream<T> & { destroyed: true }} DestroyedNoiseStream
+ */
+/**
+ * @template {RawStream} [T=RawStream]
+ * @typedef {NoiseSecretStream<T> & {
+ *   publicKey: Buffer,
+ *   remotePublicKey: Buffer,
+ *   handshake: Buffer,
+ *   destroyed: false
+ * }} OpenedNoiseStream
+ */
+/**
+ * Utility to await a NoiseSecretStream to open, that returns a stream with the
+ * correct types for publicKey and remotePublicKey (which can be null before
+ * stream is opened)
+ *
+ * @template {RawStream} T
+ * @param {NoiseSecretStream<T>} stream
+ * @returns {Promise<OpenedNoiseStream<T> | DestroyedNoiseStream<T>>}
+ */
+export function openedNoiseSecretStream<T extends RawStream>(stream: NoiseSecretStream<T>): Promise<OpenedNoiseStream<T> | DestroyedNoiseStream<T>>;
+export type RawStream = NodeDuplex | StreamxDuplex;
+export type DestroyedNoiseStream<T extends RawStream = RawStream> = NoiseSecretStream<T> & {
+    destroyed: true;
+};
+export type OpenedNoiseStream<T extends RawStream = RawStream> = NoiseSecretStream<T> & {
+    publicKey: Buffer;
+    remotePublicKey: Buffer;
+    handshake: Buffer;
+    destroyed: false;
+};
+import type NoiseSecretStream from '@hyperswarm/secret-stream';
+import type { Duplex as NodeDuplex } from 'node:stream';
+import type { Duplex as StreamxDuplex } from 'streamx';
+import type NoiseSecretStream_1 from '@hyperswarm/secret-stream';
+//# sourceMappingURL=noise-secret-stream-helpers.d.ts.map

package/dist/lib/noise-secret-stream-helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"noise-secret-stream-helpers.d.ts","sourceRoot":"","sources":["../../src/lib/noise-secret-stream-helpers.js"],"names":[],"mappings":"AAAA,0DAA0D;AAC1D,yDAAyD;AACzD,iEAAiE;AAEjE;;;GAGG;AAEH;;;GAGG;AAEH;;;;;;;;GAQG;AAEH;;;;;;;;GAQG;AACH,wCAJyB,CAAC,SAAZ,SAAU,UACb,kBAAkB,CAAC,CAAC,GAClB,OAAO,CAAC,iBAAiB,CAAC,CAAC,CAAC,GAAG,oBAAoB,CAAC,CAAC,CAAC,CAAC,CAKnE;wBA9BY,UAAU,GAAG,aAAa;iCAIb,CAAC,SAAb,SAAU,gBACX,kBAAkB,CAAC,CAAC,GAAG;IAAE,SAAS,EAAE,IAAI,CAAA;CAAE;8BAI7B,CAAC,SAAb,SAAU,gBACX,kBAAkB,CAAC,CAAC,GAAG;IACnC,SAAa,EAAE,MAAM,CAAC;IACtB,eAAmB,EAAE,MAAM,CAAC;IAC5B,SAAa,EAAE,MAAM,CAAC;IACtB,SAAa,EAAE,KAAK,CAAA;CACjB;mCAnB+B,2BAA2B;0CAFpB,aAAa;6CACV,SAAS;qCACnB,2BAA2B"}

package/dist/lib/ponyfills.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Ponyfill of `AbortSignal.any()`.
+ *
+ * [0]: https://developer.mozilla.org/en-US/docs/Web/API/AbortSignal/any_static
+ *
+ * @param {Iterable<AbortSignal>} iterable
+ * @returns {AbortSignal}
+ */
+export function abortSignalAny(iterable: Iterable<AbortSignal>): AbortSignal;
+//# sourceMappingURL=ponyfills.d.ts.map

package/dist/lib/ponyfills.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ponyfills.d.ts","sourceRoot":"","sources":["../../src/lib/ponyfills.js"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,yCAHW,QAAQ,CAAC,WAAW,CAAC,GACnB,WAAW,CAkBvB"}

package/dist/lib/string.d.ts

@@ -0,0 +1,2 @@
+export function isBlank(str: string): boolean;
+//# sourceMappingURL=string.d.ts.map

package/dist/lib/string.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"string.d.ts","sourceRoot":"","sources":["../../src/lib/string.js"],"names":[],"mappings":"AAMO,6BAHI,MAAM,GACJ,OAAO,CAEuB"}

package/dist/lib/timing-safe-equal.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Compare two values in constant time.
+ *
+ * Useful when you want to avoid leaking data.
+ *
+ * Like `crypto.timingSafeEqual`, but works with strings and doesn't throw if
+ * lengths differ.
+ *
+ * @template {string | NodeJS.ArrayBufferView} T
+ * @param {T} a
+ * @param {T} b
+ * @returns {boolean}
+ */
+export default function timingSafeEqual<T extends string | NodeJS.ArrayBufferView>(a: T, b: T): boolean;
+//# sourceMappingURL=timing-safe-equal.d.ts.map

package/dist/lib/timing-safe-equal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"timing-safe-equal.d.ts","sourceRoot":"","sources":["../../src/lib/timing-safe-equal.js"],"names":[],"mappings":"AAaA;;;;;;;;;;;;GAYG;AACH,wCAL+C,CAAC,SAAlC,MAAM,GAAG,MAAM,CAAC,eAAgB,KACnC,CAAC,KACD,CAAC,GACC,OAAO,CASnB"}

package/dist/local-peers.d.ts

@@ -0,0 +1,151 @@
+export const kTestOnlySendRawInvite: unique symbol;
+/**
+ * @typedef {object} LocalPeersEvents
+ * @property {(peers: PeerInfo[]) => void} peers Emitted whenever the connection status of peers changes. An array of peerInfo objects with a peer id and the peer connection status
+ * @property {(peer: PeerInfoConnected) => void} peer-add Emitted when a new peer is connected
+ * @property {(peerId: string, invite: Invite) => void} invite Emitted when an invite is received
+ * @property {(peerId: string, invite: InviteCancel) => void} invite-cancel Emitted when we receive a cancelation for an invite
+ * @property {(peerId: string, inviteResponse: InviteResponse) => void} invite-response Emitted when an invite response is received
+ * @property {(peerId: string, details: ProjectJoinDetails) => void} got-project-details Emitted when project details are received
+ * @property {(discoveryKey: Buffer, protomux: Protomux<import('@hyperswarm/secret-stream')>) => void} discovery-key Emitted when a new hypercore is replicated (by a peer) to a peer protomux instance (passed as the second parameter)
+ * @property {(messageType: string, errorMessage?: string) => void} failed-to-handle-message Emitted when we received a message we couldn't handle for some reason. Primarily useful for testing
+ */
+/** @extends {TypedEmitter<LocalPeersEvents>} */
+export class LocalPeers extends TypedEmitter<LocalPeersEvents> {
+    /**
+     *
+     * @param {object} [opts]
+     * @param {Logger} [opts.logger]
+     */
+    constructor({ logger }?: {
+        logger?: Logger | undefined;
+    } | undefined);
+    get peers(): ((PeerInfoBase & {
+        status: "connected";
+        connectedAt: number;
+        protomux: Protomux<import("@hyperswarm/secret-stream")>;
+    }) | (PeerInfoBase & {
+        status: "disconnected";
+        disconnectedAt: number;
+    }))[];
+    /**
+     * @param {string} deviceId
+     * @param {Invite} invite
+     * @returns {Promise<void>}
+     */
+    sendInvite(deviceId: string, invite: Invite): Promise<void>;
+    /**
+     * @param {string} deviceId
+     * @param {InviteCancel} inviteCancel
+     * @returns {Promise<void>}
+     */
+    sendInviteCancel(deviceId: string, inviteCancel: InviteCancel): Promise<void>;
+    /**
+     * Respond to an invite from a peer
+     *
+     * @param {string} deviceId id of the peer you want to respond to (publicKey of peer as hex string)
+     * @param {InviteResponse} inviteResponse
+     */
+    sendInviteResponse(deviceId: string, inviteResponse: InviteResponse): Promise<void>;
+    /**
+     * @param {string} deviceId
+     * @param {ProjectJoinDetails} details
+     */
+    sendProjectJoinDetails(deviceId: string, details: ProjectJoinDetails): Promise<void>;
+    /**
+     *
+     * @param {string} deviceId id of the peer you want to send to (publicKey of peer as hex string)
+     * @param {DeviceInfo} deviceInfo device info to send
+     */
+    sendDeviceInfo(deviceId: string, deviceInfo: DeviceInfo): Promise<void>;
+    /**
+     * Connect to a peer over an existing NoiseSecretStream
+     *
+     * @param {import('./types.js').NoiseStream<any>} stream a NoiseSecretStream from @hyperswarm/secret-stream
+     * @returns {import('./types.js').ReplicationStream}
+     */
+    connect(stream: import("./types.js").NoiseStream<any>): import("./types.js").ReplicationStream;
+    /**
+     * @param {string} deviceId
+     * @param {Buffer} buf
+     */
+    [kTestOnlySendRawInvite](deviceId: string, buf: Buffer): Promise<void>;
+    #private;
+}
+export { TimeoutError };
+export class UnknownPeerError extends Error {
+    /** @param {string} [message] */
+    constructor(message?: string | undefined);
+}
+export class PeerDisconnectedError extends Error {
+    /** @param {string} [message] */
+    constructor(message?: string | undefined);
+}
+export class PeerFailedConnectionError extends Error {
+    /** @param {string} [message] */
+    constructor(message?: string | undefined);
+}
+export type PeerInfoBase = {
+    deviceId: string;
+    name: string | undefined;
+    deviceType: import("./generated/rpc.js").DeviceInfo["deviceType"];
+};
+export type PeerInfoConnecting = PeerInfoBase & {
+    status: "connecting";
+};
+export type PeerInfoConnected = PeerInfoBase & {
+    status: "connected";
+    connectedAt: number;
+    protomux: Protomux<import("@hyperswarm/secret-stream")>;
+};
+export type PeerInfoDisconnected = PeerInfoBase & {
+    status: "disconnected";
+    disconnectedAt: number;
+};
+export type PeerInfoInternal = PeerInfoConnecting | PeerInfoConnected | PeerInfoDisconnected;
+export type PeerInfo = PeerInfoConnected | PeerInfoDisconnected;
+export type PeerState = PeerInfoInternal["status"];
+export type LocalPeersEvents = {
+    /**
+     * Emitted whenever the connection status of peers changes. An array of peerInfo objects with a peer id and the peer connection status
+     */
+    peers: (peers: PeerInfo[]) => void;
+    /**
+     * Emitted when a new peer is connected
+     */
+    "peer-add": (peer: PeerInfoConnected) => void;
+    /**
+     * Emitted when an invite is received
+     */
+    invite: (peerId: string, invite: Invite) => void;
+    /**
+     * Emitted when we receive a cancelation for an invite
+     */
+    "invite-cancel": (peerId: string, invite: InviteCancel) => void;
+    /**
+     * Emitted when an invite response is received
+     */
+    "invite-response": (peerId: string, inviteResponse: InviteResponse) => void;
+    /**
+     * Emitted when project details are received
+     */
+    "got-project-details": (peerId: string, details: ProjectJoinDetails) => void;
+    /**
+     * Emitted when a new hypercore is replicated (by a peer) to a peer protomux instance (passed as the second parameter)
+     */
+    "discovery-key": (discoveryKey: Buffer, protomux: Protomux<import("@hyperswarm/secret-stream")>) => void;
+    /**
+     * Emitted when we received a message we couldn't handle for some reason. Primarily useful for testing
+     */
+    "failed-to-handle-message": (messageType: string, errorMessage?: string) => void;
+};
+import { TypedEmitter } from 'tiny-typed-emitter';
+import Protomux from 'protomux';
+import { Invite } from './generated/rpc.js';
+import { InviteCancel } from './generated/rpc.js';
+import { InviteResponse } from './generated/rpc.js';
+import { ProjectJoinDetails } from './generated/rpc.js';
+import { DeviceInfo } from './generated/rpc.js';
+import { Logger } from './logger.js';
+import { TimeoutError } from 'p-timeout';
+//# sourceMappingURL=local-peers.d.ts.map

package/dist/local-peers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"local-peers.d.ts","sourceRoot":"","sources":["../src/local-peers.js"],"names":[],"mappings":"AAqCA,mDAAqE;AAuLrE;;;;;;;;;;GAUG;AAEH,gDAAgD;AAChD;IAYE;;;;OAIG;IACH;;mBAGC;IAED;gBAjNqC,WAAW;qBAAe,MAAM;kBAAY,QAAQ,CAAC,OAAO,2BAA2B,CAAC,CAAC;;gBACzF,cAAc;wBAAkB,MAAM;UAsN1E;IAED;;;;OAIG;IACH,qBAJW,MAAM,UACN,MAAM,GACJ,OAAO,CAAC,IAAI,CAAC,CAMzB;IAED;;;;OAIG;IACH,2BAJW,MAAM,gBACN,YAAY,GACV,OAAO,CAAC,IAAI,CAAC,CAMzB;IAED;;;;;OAKG;IACH,6BAHW,MAAM,kBACN,cAAc,iBAMxB;IAED;;;OAGG;IACH,iCAHW,MAAM,WACN,kBAAkB,iBAM5B;IAED;;;;OAIG;IACH,yBAHW,MAAM,cACN,UAAU,iBAMpB;IAYD;;;;;OAKG;IACH,gBAHW,OAAO,YAAY,EAAE,WAAW,CAAC,GAAG,CAAC,GACnC,OAAO,YAAY,EAAE,iBAAiB,CAuDlD;IArED;;;OAGG;IACH,mCAHW,MAAM,OACN,MAAM,iBAMhB;;CA2RF;;AAID;IACE,gCAAgC;IAChC,0CAGC;CACF;AAED;IACE,gCAAgC;IAChC,0CAGC;CACF;AAED;IACE,gCAAgC;IAChC,0CAGC;CACF;;cAllBa,MAAM;UACN,MAAM,GAAG,SAAS;gBAClB,OAAO,oBAAoB,EAAE,UAAU,CAAC,YAAY,CAAC;;iCAErD,YAAY,GAAG;IAAE,MAAM,EAAE,YAAY,CAAA;CAAE;gCACvC,YAAY,GAAG;IAAE,MAAM,EAAE,WAAW,CAAC;IAAC,WAAW,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,QAAQ,CAAC,OAAO,2BAA2B,CAAC,CAAC,CAAA;CAAE;mCACpH,YAAY,GAAG;IAAE,MAAM,EAAE,cAAc,CAAC;IAAC,cAAc,EAAE,MAAM,CAAA;CAAE;+BAEjE,kBAAkB,GAAG,iBAAiB,GAAG,oBAAoB;uBAC7D,iBAAiB,GAAG,oBAAoB;wBACxC,gBAAgB,CAAC,QAAQ,CAAC;;;;;WA2K1B,CAAC,KAAK,EAAE,QAAQ,EAAE,KAAK,IAAI;;;;gBAC3B,CAAC,IAAI,EAAE,iBAAiB,KAAK,IAAI;;;;YACjC,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,KAAK,IAAI;;;;qBACxC,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,YAAY,KAAK,IAAI;;;;uBAC9C,CAAC,MAAM,EAAE,MAAM,EAAE,cAAc,EAAE,cAAc,KAAK,IAAI;;;;2BACxD,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,kBAAkB,KAAK,IAAI;;;;qBACrD,CAAC,YAAY,EAAE,MAAM,EAAE,QAAQ,EAAE,QAAQ,CAAC,OAAO,2BAA2B,CAAC,CAAC,KAAK,IAAI;;;;gCACvF,CAAC,WAAW,EAAE,MAAM,EAAE,YAAY,CAAC,EAAE,MAAM,KAAK,IAAI;;6BArOrC,oBAAoB;qBAC5B,UAAU;uBAUxB,oBAAoB;6BAApB,oBAAoB;+BAApB,oBAAoB;mCAApB,oBAAoB;2BAApB,oBAAoB;uBAEJ,aAAa;6BACG,WAAW"}

package/dist/logger.d.ts

@@ -0,0 +1,32 @@
+export class Logger {
+    /**
+     * @param {string} ns
+     * @param {Logger} [logger]
+     */
+    static create(ns: string, logger?: Logger | undefined): Logger;
+    /**
+     * @param {object} opts
+     * @param {string} opts.deviceId
+     * @param {createDebug.Debugger} [opts.baseLogger]
+     * @param {string} [opts.ns]
+     */
+    constructor({ deviceId, baseLogger, ns }: {
+        deviceId: string;
+        baseLogger?: createDebug.Debugger | undefined;
+        ns?: string | undefined;
+    });
+    deviceId: string;
+    get enabled(): boolean;
+    /**
+     * @param  {Parameters<createDebug.Debugger>} args
+     */
+    log: (formatter: any, ...args: any[]) => void;
+    /**
+     *
+     * @param {string} ns
+     */
+    extend(ns: string): Logger;
+    #private;
+}
+import createDebug from 'debug';
+//# sourceMappingURL=logger.d.ts.map

package/dist/logger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logger.d.ts","sourceRoot":"","sources":["../src/logger.js"],"names":[],"mappings":"AAmDA;IAIE;;;OAGG;IACH,kBAHW,MAAM,uCAShB;IAED;;;;;OAKG;IACH,0CAJG;QAAqB,QAAQ,EAArB,MAAM;QACsB,UAAU;QACxB,EAAE;KAAC,EAM3B;IAHC,iBAAwB;IAI1B,uBAEC;IAED;;OAEG;IACH,8CAEC;IACD;;;OAGG;IACH,WAFW,MAAM,UAOhB;;CACF;wBAlGuB,OAAO"}

package/dist/mapeo-manager.d.ts

@@ -0,0 +1,178 @@
+export const kRPC: unique symbol;
+export const kManagerReplicate: unique symbol;
+/**
+ * @typedef {Omit<import('./local-peers.js').PeerInfo, 'protomux'>} PublicPeerInfo
+ */
+/**
+ * @typedef {object} MapeoManagerEvents
+ * @property {(peers: PublicPeerInfo[]) => void} local-peers Emitted when the list of connected peers changes (new ones added, or connection status changes)
+ */
+/**
+ * @extends {TypedEmitter<MapeoManagerEvents>}
+ */
+export class MapeoManager extends TypedEmitter<MapeoManagerEvents> {
+    /**
+     * @param {Object} opts
+     * @param {Buffer} opts.rootKey 16-bytes of random data that uniquely identify the device, used to derive a 32-byte master key, which is used to derive all the keypairs used for Mapeo
+     * @param {string} opts.dbFolder Folder for sqlite Dbs. Folder must exist. Use ':memory:' to store everything in-memory
+     * @param {string} opts.projectMigrationsFolder path for drizzle migrations folder for project database
+     * @param {string} opts.clientMigrationsFolder path for drizzle migrations folder for client database
+     * @param {string | CoreStorage} opts.coreStorage Folder for hypercore storage or a function that returns a RandomAccessStorage instance
+     * @param {import('fastify').FastifyInstance} opts.fastify Fastify server instance
+     * @param {String} [opts.defaultConfigPath]
+     */
+    constructor({ rootKey, dbFolder, projectMigrationsFolder, clientMigrationsFolder, coreStorage, fastify, defaultConfigPath, }: {
+        rootKey: Buffer;
+        dbFolder: string;
+        projectMigrationsFolder: string;
+        clientMigrationsFolder: string;
+        coreStorage: string | CoreStorage;
+        fastify: import("fastify").FastifyInstance;
+        defaultConfigPath?: string | undefined;
+    });
+    get deviceId(): string;
+    /**
+     * Create a new project.
+     * @param {(
+     *   import('type-fest').Simplify<(
+     *     Partial<Pick<ProjectValue, 'name'>> &
+     *     { configPath?: string }
+     *   )>
+     * )} [options]
+     * @returns {Promise<string>} Project public id
+     */
+    createProject({ name, configPath }?: {
+        name?: string | undefined;
+        configPath?: string | undefined;
+    } | undefined): Promise<string>;
+    /**
+     * @param {string} projectPublicId
+     * @returns {Promise<MapeoProject>}
+     */
+    getProject(projectPublicId: string): Promise<MapeoProject>;
+    /**
+     * @returns {Promise<Array<Pick<ProjectValue, 'name'> & { projectId: string, createdAt?: string, updatedAt?: string}>>}
+     */
+    listProjects(): Promise<Array<Pick<ProjectValue, "name"> & {
+        projectId: string;
+        createdAt?: string;
+        updatedAt?: string;
+    }>>;
+    /**
+     * Add a project to this device. After adding a project the client should
+     * await `project.$waitForInitialSync()` to ensure that the device has
+     * downloaded their proof of project membership and the project config.
+     *
+     * @param {Pick<import('./generated/rpc.js').ProjectJoinDetails, 'projectKey' | 'encryptionKeys'> & { projectName: string }} projectJoinDetails
+     * @param {{ waitForSync?: boolean }} [opts] For internal use in tests, set opts.waitForSync = false to not wait for sync during addProject()
+     * @returns {Promise<string>}
+     */
+    addProject: ({ projectKey, encryptionKeys, projectName }: Pick<import("./generated/rpc.js").ProjectJoinDetails, "projectKey" | "encryptionKeys"> & {
+        projectName: string;
+    }, { waitForSync }?: {
+        waitForSync?: boolean;
+    } | undefined) => Promise<string>;
+    /**
+     * @typedef {Exclude<
+     * import('./schema/client.js').DeviceInfoParam['deviceType'],
+     * 'selfHostedServer'>} RPCDeviceType
+     */
+    /**
+     * @template {import('type-fest').Exact<
+     * import('./schema/client.js').DeviceInfoParam & {deviceType?: RPCDeviceType}, T>} T
+     * @param {T} deviceInfo
+     */
+    setDeviceInfo<T extends import("type-fest").Exact<import("./schema/client.js").DeviceInfoParam & {
+        deviceType?: "UNRECOGNIZED" | "device_type_unspecified" | "mobile" | "tablet" | "desktop";
+    }, T>>(deviceInfo: T): Promise<void>;
+    /**
+     * @returns {(
+     *   {
+     *     deviceId: string;
+     *     deviceType: DeviceInfoParam['deviceType']
+     *   } & Partial<DeviceInfoParam>
+     * )}
+     */
+    getDeviceInfo(): ({
+        deviceId: string;
+        deviceType: DeviceInfoParam["deviceType"];
+    } & Partial<DeviceInfoParam>);
+    /**
+     * @returns {InviteApi}
+     */
+    get invite(): InviteApi;
+    /** @returns {Promise<{ name: string, port: number }>} */
+    startLocalPeerDiscoveryServer(): Promise<{
+        name: string;
+        port: number;
+    }>;
+    stopLocalPeerDiscoveryServer(opts?: {
+        force?: boolean | undefined;
+        timeout?: number | undefined;
+    } | undefined): Promise<void>;
+    connectLocalPeer({ address, port, name }: {
+        address: string;
+        port: number;
+        name: string;
+    }): void;
+    /**
+     * @returns {Promise<PublicPeerInfo[]>}
+     */
+    listLocalPeers(): Promise<PublicPeerInfo[]>;
+    /**
+     * Call this when the app goes into the background.
+     *
+     * Will gracefully shut down sync.
+     *
+     * @see {@link onForegrounded}
+     * @returns {void}
+     */
+    onBackgrounded(): void;
+    /**
+     * Call this when the app goes into the foreground.
+     *
+     * Will undo the effects of `onBackgrounded`.
+     *
+     * @see {@link onBackgrounded}
+     * @returns {void}
+     */
+    onForegrounded(): void;
+    /**
+     * @param {string} projectPublicId
+     */
+    leaveProject(projectPublicId: string): Promise<void>;
+    getMapStyleJsonUrl(): Promise<string>;
+    /**
+     * MapeoRPC instance, used for tests
+     */
+    get [kRPC](): LocalPeers;
+    /**
+     * Create a Mapeo replication stream. This replication connects the Mapeo RPC
+     * channel and allows invites. All active projects will sync automatically to
+     * this replication stream. Only use for local (trusted) connections, because
+     * the RPC channel key is public. To sync a specific project without
+     * connecting RPC, use project[kProjectReplication].
+     *
+     * @param {boolean} isInitiator
+     */
+    [kManagerReplicate](isInitiator: boolean): import("./types.js").ReplicationStream;
+    #private;
+}
+export type ValidatedProjectKeys = SetNonNullable<ProjectKeys, "encryptionKeys">;
+export type PublicPeerInfo = Omit<import("./local-peers.js").PeerInfo, "protomux">;
+export type MapeoManagerEvents = {
+    /**
+     * Emitted when the list of connected peers changes (new ones added, or connection status changes)
+     */
+    "local-peers": (peers: PublicPeerInfo[]) => void;
+};
+import { TypedEmitter } from 'tiny-typed-emitter';
+import { MapeoProject } from './mapeo-project.js';
+import type { ProjectSettingsValue as ProjectValue } from '@comapeo/schema';
+import type { DeviceInfoParam } from './schema/client.js';
+import { InviteApi } from './invite-api.js';
+import { LocalPeers } from './local-peers.js';
+import type { CoreStorage } from './types.js';
+import { ProjectKeys } from './generated/keys.js';
+import type { SetNonNullable } from 'type-fest';
+//# sourceMappingURL=mapeo-manager.d.ts.map

package/dist/mapeo-manager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mapeo-manager.d.ts","sourceRoot":"","sources":["../src/mapeo-manager.js"],"names":[],"mappings":"AAsEA,iCAAiC;AACjC,8CAA4D;AAE5D;;GAEG;AAEH;;;GAGG;AAEH;;GAEG;AACH;IAqBE;;;;;;;;;OASG;IACH,8HARG;QAAqB,OAAO,EAApB,MAAM;QACO,QAAQ,EAArB,MAAM;QACO,uBAAuB,EAApC,MAAM;QACO,sBAAsB,EAAnC,MAAM;QACqB,WAAW,EAAtC,MAAM,GAAG,WAAW;QACoB,OAAO,EAA/C,OAAO,SAAS,EAAE,eAAe;QACnB,iBAAiB;KAAC,EAoF1C;IASD,uBAEC;IA6ID;;;;;;;;;OASG;IACH;;qBALsB,MAAM;oBAGf,OAAO,CAAC,MAAM,CAAC,CA0E3B;IAED;;;OAGG;IACH,4BAHW,MAAM,GACJ,OAAO,CAAC,YAAY,CAAC,CAuCjC;IAqBD;;OAEG;IACH,gBAFa,OAAO,CAAC,KAAK,CAAC,IAAI,CAAC,YAAY,EAAE,MAAM,CAAC,GAAG;QAAE,SAAS,EAAE,MAAM,CAAC;QAAC,SAAS,CAAC,EAAE,MAAM,CAAC;QAAC,SAAS,CAAC,EAAE,MAAM,CAAA;KAAC,CAAC,CAAC,CAgDrH;IAED;;;;;;;;OAQG;IACH,0DAJW,IAAI,CAAC,OAAO,oBAAoB,EAAE,kBAAkB,EAAE,YAAY,GAAG,gBAAgB,CAAC,GAAG;QAAE,WAAW,EAAE,MAAM,CAAA;KAAE;sBAChG,OAAO;sBACrB,OAAO,CAAC,MAAM,CAAC,CAgF3B;IAgED;;;;OAIG;IAEH;;;;OAIG;IACH,cAHoF,CAAC,SADxE,OAAQ,WAAW,EAAE,KAAK,CACtC,OAAS,oBAAoB,EAAE,eAAe,GAAG;QAAC,UAAU,CAAC,+EAAe;KAAC,EAAE,CAAC,CAAE,cACxE,CAAC,iBA8BX;IAED;;;;;;;OAOG;IACH,iBAPa,CACZ;QACA,QAAc,EAAE,MAAM,CAAC;QACvB,UAAgB,EAAE,eAAe,CAAC,YAAY,CAAC,CAAA;KAC1C,GAAG,OAAO,CAAC,eAAe,CAAC,CAC7B,CAaH;IAED;;OAEG;IACH,wBAEC;IAED,yDAAyD;IACzD,iCADc,OAAO,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC,CAGpD;;;;;;;;;;IAYD;;OAEG;IACH,kBAFa,OAAO,CAAC,cAAc,EAAE,CAAC,CAIrC;IAED;;;;;;;OAOG;IACH,kBAFa,IAAI,CAKhB;IAED;;;;;;;OAOG;IACH,kBAFa,IAAI,CAKhB;IAED;;OAEG;IACH,8BAFW,MAAM,iBAgDhB;IAED,sCAGC;IA7pBD;;OAEG;IACH,yBAEC;IAMD;;;;;;;;OAQG;IACH,iCAFW,OAAO,0CAOjB;;CAqoBF;mCA9yBa,eAAe,WAAW,EAAE,gBAAgB,CAAC;6BAkB9C,IAAI,CAAC,OAAO,kBAAkB,EAAE,QAAQ,EAAE,UAAU,CAAC;;;;;mBAKpD,CAAC,KAAK,EAAE,cAAc,EAAE,KAAK,IAAI;;6BAvElB,oBAAoB;6BAU1C,oBAAoB;0DAgC+B,iBAAiB;qCAGtC,oBAAoB;0BAb/B,iBAAiB;2BADhB,kBAAkB;iCAaD,YAAY;4BA5B5B,qBAAqB;oCA2Bb,WAAW"}