@comapeo/core 1.0.0

package/LICENSE.md

@@ -0,0 +1,9 @@
+# [MIT License](https://spdx.org/licenses/MIT)
+
+Copyright 2022, Digital Democracy
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/README.md

@@ -0,0 +1,31 @@
+# CoMapeo Core
+
+> A local-first library for collaborating on mapping projects.
+
+## About
+
+CoMapeo Core is a library used by the [mobile](https://github.com/digidem/comapeo-mobile) and [desktop](https://github.com/digidem/comapeo-desktop) CoMapeo apps that provides the core features needed for offline-first peer to peer collaboration on mapping projects.
+
+## Docs
+
+To learn more about CoMapeo Core see the [docs](docs/) section of this repo.
+
+## Change log
+
+The changes in each version are described in the [change log](CHANGELOG.md).
+
+## Install
+
+> **⚠️ Warning:** this package is not ready for use!
+
+```shell
+npm install @comapeo/core
+```
+
+## Contributing
+
+Read the [code of conduct](CODE_OF_CONDUCT.md) and the [contributing guide](CONTRIBUTING.md)
+
+## License
+
+[MIT](LICENSE.md)

package/dist/blob-api.d.ts

@@ -0,0 +1,92 @@
+/** @import { BlobId, BlobType } from './types.js' */
+/**
+ * Location coordinate data. Based on [Expo's `LocationObjectCoords`][0].
+ * [0]: https://docs.expo.dev/versions/latest/sdk/location/#locationobjectcoords
+ *
+ * @typedef {object} LocationObjectCoords
+ * @prop {number | null} accuracy
+ * @prop {number | null} altitude
+ * @prop {number | null} altitudeAccuracy
+ * @prop {number | null} heading
+ * @prop {number} latitude
+ * @prop {number} longitude
+ * @prop {number | null} speed
+ */
+/**
+ * Location metadata for a blob. Based on [Expo's `LocationObject`][0].
+ * [0]: https://docs.expo.dev/versions/latest/sdk/location/#locationobject
+ *
+ * @typedef {object} LocationObject
+ * @prop {LocationObjectCoords} coords
+ * @prop {boolean} [mocked]
+ * @prop {number} timestamp
+ */
+/**
+ * @typedef {object} Metadata
+ * @prop {string} mimeType
+ * @prop {number} timestamp
+ * @prop {LocationObject} [location]
+ */
+export class BlobApi {
+    /**
+     * @param {object} options
+     * @param {import('./blob-store/index.js').BlobStore} options.blobStore
+     * @param {() => Promise<string>} options.getMediaBaseUrl
+     */
+    constructor({ blobStore, getMediaBaseUrl }: {
+        blobStore: import("./blob-store/index.js").BlobStore;
+        getMediaBaseUrl: () => Promise<string>;
+    });
+    /**
+     * Get a url for a blob based on its BlobId
+     * @param {BlobId} blobId
+     * @returns {Promise<string>}
+     */
+    getUrl(blobId: BlobId): Promise<string>;
+    /**
+     * Write blobs for provided variants of a file
+     * @param {{ original: string, preview?: string, thumbnail?: string }} filepaths
+     * @param {Metadata} metadata
+     * @returns {Promise<{ driveId: string, name: string, type: 'photo' | 'video' | 'audio', hash: string }>}
+     */
+    create(filepaths: {
+        original: string;
+        preview?: string;
+        thumbnail?: string;
+    }, metadata: Metadata): Promise<{
+        driveId: string;
+        name: string;
+        type: "photo" | "video" | "audio";
+        hash: string;
+    }>;
+    #private;
+}
+/**
+ * Location coordinate data. Based on [Expo's `LocationObjectCoords`][0].
+ * [0]: https://docs.expo.dev/versions/latest/sdk/location/#locationobjectcoords
+ */
+export type LocationObjectCoords = {
+    accuracy: number | null;
+    altitude: number | null;
+    altitudeAccuracy: number | null;
+    heading: number | null;
+    latitude: number;
+    longitude: number;
+    speed: number | null;
+};
+/**
+ * Location metadata for a blob. Based on [Expo's `LocationObject`][0].
+ * [0]: https://docs.expo.dev/versions/latest/sdk/location/#locationobject
+ */
+export type LocationObject = {
+    coords: LocationObjectCoords;
+    mocked?: boolean | undefined;
+    timestamp: number;
+};
+export type Metadata = {
+    mimeType: string;
+    timestamp: number;
+    location?: LocationObject | undefined;
+};
+import type { BlobId } from './types.js';
+//# sourceMappingURL=blob-api.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"blob-api.d.ts","sourceRoot":"","sources":["../src/blob-api.js"],"names":[],"mappings":"AAIA,qDAAqD;AAErD;;;;;;;;;;;;GAYG;AAEH;;;;;;;;GAQG;AAEH;;;;;GAKG;AAEH;IAIE;;;;OAIG;IACH,4CAHG;QAA2D,SAAS,EAA5D,OAAO,uBAAuB,EAAE,SAAS;QACV,eAAe,EAA9C,MAAM,OAAO,CAAC,MAAM,CAAC;KAC/B,EAIA;IAED;;;;OAIG;IACH,eAHW,MAAM,GACJ,OAAO,CAAC,MAAM,CAAC,CAY3B;IAED;;;;;OAKG;IACH,kBAJW;QAAE,QAAQ,EAAE,MAAM,CAAC;QAAC,OAAO,CAAC,EAAE,MAAM,CAAC;QAAC,SAAS,CAAC,EAAE,MAAM,CAAA;KAAE,YAC1D,QAAQ,GACN,OAAO,CAAC;QAAE,OAAO,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,OAAO,GAAG,OAAO,GAAG,OAAO,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC,CAyCvG;;CACF;;;;;;cAvGS,MAAM,GAAG,IAAI;cACb,MAAM,GAAG,IAAI;sBACb,MAAM,GAAG,IAAI;aACb,MAAM,GAAG,IAAI;cACb,MAAM;eACN,MAAM;WACN,MAAM,GAAG,IAAI;;;;;;;YAQb,oBAAoB;;eAEpB,MAAM;;;cAKN,MAAM;eACN,MAAM;;;4BA7BsB,YAAY"}

package/dist/blob-store/index.d.ts

@@ -0,0 +1,163 @@
+export class BlobStore {
+    /**
+     * @param {object} options
+     * @param {import('../core-manager/index.js').CoreManager} options.coreManager
+     */
+    constructor({ coreManager }: {
+        coreManager: import("../core-manager/index.js").CoreManager;
+    });
+    get writerDriveId(): string;
+    /**
+     * @param {BlobId} blobId
+     * @param {object} opts
+     * @param {false} [opts.wait=false] Set to `true` to wait for a blob to download, otherwise will throw if blob is not available locally
+     * @param {never} [opts.timeout] Optional timeout to wait for a blob to download
+     */
+    get({ type, variant, name, driveId }: BlobId, { wait, timeout }?: {
+        wait?: false | undefined;
+        timeout?: undefined;
+    }): Promise<Buffer>;
+    /**
+     * Download blobs from all drives, optionally filtering particular blob types
+     * or blob variants. Download will be 'live' and will continue downloading new
+     * data as it becomes available from any replicating drive.
+     *
+     * If no filter is specified, all blobs will be downloaded. If a filter is
+     * specified, then _only_ blobs that match the filter will be downloaded.
+     *
+     * @param {import('../types.js').BlobFilter} [filter] Filter blob types and/or variants to download. Filter is { [BlobType]: BlobVariants[] }. At least one blob variant must be specified for each blob type.
+     * @param {object} options
+     * @param {AbortSignal} [options.signal] Optional AbortSignal to cancel in-progress download
+     * @returns EventEmitter with `.state` propery, emits `state` with new state when it updates
+     */
+    download(filter?: import("../types.js").BlobFilter | undefined, { signal }?: {
+        signal?: AbortSignal | undefined;
+    }): LiveDownload;
+    /**
+     * @param {BlobId} blobId
+     * @param {object} [options]
+     * @param {boolean} [options.wait=false] Set to `true` to wait for a blob to download, otherwise will throw if blob is not available locally
+     * @param {number} [options.timeout] Optional timeout to wait for a blob to download
+     */
+    createReadStream({ type, variant, name, driveId }: BlobId, options?: {
+        wait?: boolean | undefined;
+        timeout?: number | undefined;
+    } | undefined): import("streamx").Readable<any, any, any, true, false, import("streamx").ReadableEvents<any>>;
+    /**
+     * Optimization for creating the blobs read stream when you have
+     * previously read the entry from Hyperdrive using `drive.entry`
+     * @param {BlobId['driveId']} driveId Hyperdrive drive discovery id
+     * @param {import('hyperdrive').HyperdriveEntry} entry Hyperdrive entry
+     * @param {object} [options]
+     * @param {boolean} [options.wait=false] Set to `true` to wait for a blob to download, otherwise will throw if blob is not available locally
+     */
+    createEntryReadStream(driveId: BlobId["driveId"], entry: import("hyperdrive").HyperdriveEntry, options?: {
+        wait?: boolean | undefined;
+    } | undefined): Promise<{
+        _read(cb: import("streamx").ResultCallback<any>): void;
+        pipe<TTarget extends import("streamx").AnyWritable<any, any, any> = import("streamx").AnyWritable<any, any, any>>(dest: TTarget, cb?: import("streamx").Callback): TTarget;
+        read(): any;
+        push(data: any): boolean;
+        unshift(data: any): void;
+        resume(): any;
+        pause(): any;
+        [Symbol.asyncIterator]: () => AsyncIterator<any, any, undefined>;
+        _open(cb: import("streamx").Callback): void;
+        _destroy(cb: import("streamx").Callback): void;
+        _predestroy(cb: import("streamx").Callback): void;
+        readonly readable: true;
+        readonly writable: false;
+        readonly destroyed: boolean;
+        readonly destroying: boolean;
+        destroy(error?: Error | null): void;
+        addListener<TEvent extends "end" | "data" | "readable" | keyof import("streamx").StreamEvents | "piping">(event: TEvent, listener: TEvent extends "end" | "data" | "readable" | keyof import("streamx").StreamEvents | "piping" ? import("streamx").ReadableEvents<any>[TEvent] : (...args: any[]) => void): any;
+        on<TEvent extends "end" | "data" | "readable" | keyof import("streamx").StreamEvents | "piping">(event: TEvent, listener: TEvent extends "end" | "data" | "readable" | keyof import("streamx").StreamEvents | "piping" ? import("streamx").ReadableEvents<any>[TEvent] : (...args: any[]) => void): any;
+        once<TEvent extends "end" | "data" | "readable" | keyof import("streamx").StreamEvents | "piping">(event: TEvent, listener: TEvent extends "end" | "data" | "readable" | keyof import("streamx").StreamEvents | "piping" ? import("streamx").ReadableEvents<any>[TEvent] : (...args: any[]) => void): any;
+        removeListener<TEvent extends "end" | "data" | "readable" | keyof import("streamx").StreamEvents | "piping">(event: TEvent, listener: TEvent extends "end" | "data" | "readable" | keyof import("streamx").StreamEvents | "piping" ? import("streamx").ReadableEvents<any>[TEvent] : (...args: any[]) => void): any;
+        off<TEvent extends "end" | "data" | "readable" | keyof import("streamx").StreamEvents | "piping">(event: TEvent, listener: TEvent extends "end" | "data" | "readable" | keyof import("streamx").StreamEvents | "piping" ? import("streamx").ReadableEvents<any>[TEvent] : (...args: any[]) => void): any;
+        removeAllListeners(event?: "end" | "data" | "readable" | keyof import("streamx").StreamEvents | "piping" | undefined): any;
+        setMaxListeners(n: number): any;
+        getMaxListeners(): number;
+        listeners<TEvent extends "end" | "data" | "readable" | keyof import("streamx").StreamEvents | "piping">(event: TEvent): (TEvent extends "end" | "data" | "readable" | keyof import("streamx").StreamEvents | "piping" ? import("streamx").ReadableEvents<any>[TEvent] : (...args: any[]) => void)[];
+        rawListeners<TEvent extends "end" | "data" | "readable" | keyof import("streamx").StreamEvents | "piping">(event: TEvent): (TEvent extends "end" | "data" | "readable" | keyof import("streamx").StreamEvents | "piping" ? import("streamx").ReadableEvents<any>[TEvent] : (...args: any[]) => void)[];
+        emit<TEvent extends "end" | "data" | "readable" | keyof import("streamx").StreamEvents | "piping">(event: TEvent, ...rest: Parameters<TEvent extends "end" | "data" | "readable" | keyof import("streamx").StreamEvents | "piping" ? import("streamx").ReadableEvents<any>[TEvent] : (...args: any[]) => void>): boolean;
+        listenerCount(event: "end" | "data" | "readable" | keyof import("streamx").StreamEvents | "piping"): number;
+        prependListener<TEvent extends "end" | "data" | "readable" | keyof import("streamx").StreamEvents | "piping">(event: TEvent, listener: TEvent extends "end" | "data" | "readable" | keyof import("streamx").StreamEvents | "piping" ? import("streamx").ReadableEvents<any>[TEvent] : (...args: any[]) => void): any;
+        prependOnceListener<TEvent extends "end" | "data" | "readable" | keyof import("streamx").StreamEvents | "piping">(event: TEvent, listener: TEvent extends "end" | "data" | "readable" | keyof import("streamx").StreamEvents | "piping" ? import("streamx").ReadableEvents<any>[TEvent] : (...args: any[]) => void): any;
+        eventNames(): Array<string | symbol>;
+        [EventEmitter.captureRejectionSymbol]?<K>(error: Error, event: string | symbol, ...args: any[]): void;
+    }>;
+    /**
+     * @param {BlobId['driveId']} driveId Hyperdrive drive id
+     * @param {import('hyperdrive').HyperdriveEntry} entry Hyperdrive entry
+     * @param {object} [opts]
+     * @param {number} [opts.length]
+     *
+     * @returns {Promise<Buffer | null>}
+     */
+    getEntryBlob(driveId: BlobId["driveId"], entry: import("hyperdrive").HyperdriveEntry, { length }?: {
+        length?: number | undefined;
+    } | undefined): Promise<Buffer | null>;
+    /**
+     *
+     * @param {Omit<BlobId, 'driveId'>} blobId
+     * @param {Buffer} blob
+     * @param {object} [options]
+     * @param {{mimeType: string}} [options.metadata] Metadata to store with the blob
+     * @returns {Promise<string>} discovery key as hex string of hyperdrive where blob is stored
+     */
+    put({ type, variant, name }: Omit<BlobId, "driveId">, blob: Buffer, options?: {
+        metadata?: {
+            mimeType: string;
+        } | undefined;
+    } | undefined): Promise<string>;
+    /**
+     * @param {Omit<BlobId, 'driveId'>} blobId
+     * @param {object} [options]
+     * @param {{mimeType: string}} [options.metadata] Metadata to store with the blob
+     */
+    createWriteStream({ type, variant, name }: Omit<BlobId, "driveId">, options?: {
+        metadata?: {
+            mimeType: string;
+        } | undefined;
+    } | undefined): import("streamx").Writable<any, any, any, false, true, import("streamx").WritableEvents<any>> & {
+        driveId: string;
+    };
+    /**
+     * @param {BlobId} blobId
+     * @param {object} [options]
+     * @param {boolean} [options.follow=false] Set to `true` to follow symlinks (16 max or throws an error)
+     * @param {false} [options.wait=false] Set to `true` to wait for a blob to download, otherwise will throw if blob is not available locally
+     * @param {never} [options.timeout] Optional timeout to wait for a blob to download
+     * @returns {Promise<import('hyperdrive').HyperdriveEntry | null>}
+     */
+    entry({ type, variant, name, driveId }: BlobId, options?: {
+        follow?: boolean | undefined;
+        wait?: false | undefined;
+        timeout?: undefined;
+    } | undefined): Promise<import("hyperdrive").HyperdriveEntry | null>;
+    /**
+     * @param {BlobId} blobId
+     * @param {object} [options]
+     * @param {boolean} [options.diff=false] Enable to return an object with a `block` property with number of bytes removed
+     * @return {Promise<{ blocks: number } | null>}
+     */
+    clear({ type, variant, name, driveId }: BlobId, options?: {
+        diff?: boolean | undefined;
+    } | undefined): Promise<{
+        blocks: number;
+    } | null>;
+    #private;
+}
+export type InternalDriveEmitter = TypedEmitter<{
+    "add-drive": (drive: import("hyperdrive")) => void;
+}>;
+export namespace SUPPORTED_BLOB_VARIANTS {
+    let photo: readonly ["original", "preview", "thumbnail"];
+    let audio: readonly ["original"];
+    let video: readonly ["original"];
+}
+import type { BlobId } from '../types.js';
+import { LiveDownload } from './live-download.js';
+import { TypedEmitter } from 'tiny-typed-emitter';
+//# sourceMappingURL=index.d.ts.map

package/dist/blob-store/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/blob-store/index.js"],"names":[],"mappings":"AA8BA;IAUE;;;OAGG;IACH,6BAFG;QAAgE,WAAW,EAAnE,OAAO,0BAA0B,EAAE,WAAW;KACxD,EA+BA;IAED,4BAEC;IAWD;;;;;OAKG;IACH,sCALW,MAAM,sBAEd;QAAqB,IAAI;QACJ,OAAO;KAC9B,mBAOA;IAED;;;;;;;;;;;;OAYG;IACH,6EAHG;QAA8B,MAAM;KACpC,gBAOF;IAED;;;;;OAKG;IACH,mDALW,MAAM;;;kHAehB;IAED;;;;;;;OAOG;IACH,+BALW,MAAM,CAAC,SAAS,CAAC,SACjB,OAAO,YAAY,EAAE,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAe9C;IAED;;;;;;;OAOG;IACH,sBAPW,MAAM,CAAC,SAAS,CAAC,SACjB,OAAO,YAAY,EAAE,eAAe;;oBAIlC,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAalC;IAED;;;;;;;OAOG;IACH,6BANW,IAAI,CAAC,MAAM,EAAE,SAAS,CAAC,QACvB,MAAM;;sBAEK,MAAM;;oBACf,OAAO,CAAC,MAAM,CAAC,CAM3B;IAED;;;;OAIG;IACH,2CAJW,IAAI,CAAC,MAAM,EAAE,SAAS,CAAC;;sBAEZ,MAAM;;;;MAQ3B;IAED;;;;;;;OAOG;IACH,wCAPW,MAAM;;;;oBAKJ,OAAO,CAAC,OAAO,YAAY,EAAE,eAAe,GAAG,IAAI,CAAC,CAWhE;IAED;;;;;OAKG;IACH,wCALW,MAAM;;oBAGL,OAAO,CAAC;QAAE,MAAM,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI,CAAC,CAO7C;;CACF;mCAzOa,YAAY,CAAC;IAAE,WAAW,EAAE,CAAC,KAAK,EAAE,OAAO,YAAY,CAAC,KAAK,IAAI,CAAA;CAAE,CAAC;;;;;;4BAFtD,aAAa;6BADZ,oBAAoB;6BADpB,oBAAoB"}

package/dist/blob-store/live-download.d.ts

@@ -0,0 +1,107 @@
+/**
+ * Reduce multiple states into one. Factored out for unit testing because I
+ * don't trust my coding. Probably a smarter way to do this, but this works.
+ *
+ * @param {Iterable<{ state: BlobDownloadState | BlobDownloadStateError }>} liveDownloads
+ * @param {{ signal?: AbortSignal }} options
+ * @returns {BlobDownloadState | BlobDownloadStateError}
+ */
+export function combineStates(liveDownloads: Iterable<{
+    state: BlobDownloadState | BlobDownloadStateError;
+}>, { signal }?: {
+    signal?: AbortSignal;
+}): BlobDownloadState | BlobDownloadStateError;
+/**
+ * @typedef {object} BlobDownloadState
+ * @property {number} haveCount The number of files already downloaded
+ * @property {number} haveBytes The bytes already downloaded
+ * @property {number} wantCount The number of files pending download
+ * @property {number} wantBytes The bytes pending download
+ * @property {null} error If status = 'error' then this will be an Error object
+ * @property {'checking' | 'downloading' | 'downloaded' | 'aborted'} status
+ */
+/** @typedef {Omit<BlobDownloadState, 'error' | 'status'> & { status: 'error', error: Error }} BlobDownloadStateError */
+/**
+ * @typedef {object} BlobDownloadEvents
+ * @property {(state: BlobDownloadState | BlobDownloadStateError ) => void} state Emitted with the current download state whenever it changes (not emitted during initial 'checking' status)
+ */
+/**
+ * LiveDownload class
+ * @extends {TypedEmitter<BlobDownloadEvents>}
+ */
+export class LiveDownload extends TypedEmitter<BlobDownloadEvents> {
+    /**
+     * Like drive.download() but 'live', and for multiple drives
+     * @param {Iterable<import('hyperdrive')>} drives
+     * @param {import('./index.js').InternalDriveEmitter} emitter
+     * @param {object} options
+     * @param {import('../types.js').BlobFilter} [options.filter] Filter blobs of specific types and/or sizes to download
+     * @param {AbortSignal} [options.signal]
+     */
+    constructor(drives: Iterable<import("hyperdrive")>, emitter: import("./index.js").InternalDriveEmitter, { filter, signal }: {
+        filter?: import("../types.js").BlobFilter | undefined;
+        signal?: AbortSignal | undefined;
+    });
+    /**
+     * @returns {BlobDownloadState | BlobDownloadStateError}
+     */
+    get state(): BlobDownloadState | BlobDownloadStateError;
+    #private;
+}
+/**
+ * LiveDownload class
+ * @extends {TypedEmitter<BlobDownloadEvents>}
+ */
+export class DriveLiveDownload extends TypedEmitter<BlobDownloadEvents> {
+    /**
+     * Like drive.download() but 'live',
+     * @param {import('hyperdrive')} drive
+     * @param {object} options
+     * @param {import('../types.js').BlobFilter} [options.filter] Filter blobs of specific types and/or sizes to download
+     * @param {AbortSignal} [options.signal]
+     */
+    constructor(drive: import("hyperdrive"), { filter, signal }?: {
+        filter?: import("../types.js").BlobFilter | undefined;
+        signal?: AbortSignal | undefined;
+    });
+    /**
+     * @returns {BlobDownloadState | BlobDownloadStateError}
+     */
+    get state(): BlobDownloadState | BlobDownloadStateError;
+    #private;
+}
+export type BlobDownloadState = {
+    /**
+     * The number of files already downloaded
+     */
+    haveCount: number;
+    /**
+     * The bytes already downloaded
+     */
+    haveBytes: number;
+    /**
+     * The number of files pending download
+     */
+    wantCount: number;
+    /**
+     * The bytes pending download
+     */
+    wantBytes: number;
+    /**
+     * If status = 'error' then this will be an Error object
+     */
+    error: null;
+    status: "checking" | "downloading" | "downloaded" | "aborted";
+};
+export type BlobDownloadStateError = Omit<BlobDownloadState, "error" | "status"> & {
+    status: "error";
+    error: Error;
+};
+export type BlobDownloadEvents = {
+    /**
+     * Emitted with the current download state whenever it changes (not emitted during initial 'checking' status)
+     */
+    state: (state: BlobDownloadState | BlobDownloadStateError) => void;
+};
+import { TypedEmitter } from 'tiny-typed-emitter';
+//# sourceMappingURL=live-download.d.ts.map

package/dist/blob-store/live-download.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"live-download.d.ts","sourceRoot":"","sources":["../../src/blob-store/live-download.js"],"names":[],"mappings":"AA+RA;;;;;;;GAOG;AACH,6CAJW,QAAQ,CAAC;IAAE,KAAK,EAAE,iBAAiB,GAAG,sBAAsB,CAAA;CAAE,CAAC,eAC/D;IAAE,MAAM,CAAC,EAAE,WAAW,CAAA;CAAE,GACtB,iBAAiB,GAAG,sBAAsB,CAqCtD;AApUD;;;;;;;;GAQG;AAEH,wHAAwH;AAExH;;;GAGG;AAEH;;;GAGG;AACH;IAKE;;;;;;;OAOG;IACH,oBANW,QAAQ,CAAC,OAAO,YAAY,CAAC,CAAC,WAC9B,OAAO,YAAY,EAAE,oBAAoB,sBAEjD;QAAmD,MAAM;QAC3B,MAAM;KAAC,EAiCvC;IAED;;OAEG;IACH,wDAEC;;CACF;AAED;;;GAGG;AACH;IAaE;;;;;;OAMG;IACH,mBALW,OAAO,YAAY,CAAC,uBAE5B;QAAmD,MAAM;QAC3B,MAAM;KAAC,EAmBvC;IAED;;OAEG;IACH,wDAyBC;;CAqIF;;;;;eArRa,MAAM;;;;eACN,MAAM;;;;eACN,MAAM;;;;eACN,MAAM;;;;WACN,IAAI;YACJ,UAAU,GAAG,aAAa,GAAG,YAAY,GAAG,SAAS;;qCAGrD,IAAI,CAAC,iBAAiB,EAAE,OAAO,GAAG,QAAQ,CAAC,GAAG;IAAE,MAAM,EAAE,OAAO,CAAC;IAAC,KAAK,EAAE,KAAK,CAAA;CAAE;;;;;WAI/E,CAAC,KAAK,EAAE,iBAAiB,GAAG,sBAAsB,KAAM,IAAI;;6BApB7C,oBAAoB"}

package/dist/config-import.d.ts

@@ -0,0 +1,74 @@
+/**
+ * @typedef {yauzl.Entry} Entry
+ */
+/**
+ * @typedef {{
+ *   presets: { [id: string]: unknown }
+ *   fields:  { [id: string]: unknown }
+ * }} PresetsFile
+ */
+/** @typedef {('presets' | 'fields')} ValidDocTypes */
+/**
+ * @typedef {{
+ *  [lang: string]: unknown
+ * }} TranslationsFile
+ */
+/** @typedef {NonNullable<import('@comapeo/schema').ProjectSettingsValue['configMetadata']>} MetadataFile */
+/**
+ * @typedef {Parameters<import('./icon-api.js').IconApi['create']>[0]} IconData
+ */
+/**
+ * @param {string} configPath
+ */
+export function readConfig(configPath: string): Promise<{
+    readonly warnings: Error[];
+    readonly metadata: {
+        importDate: string;
+        name: string;
+        buildDate: string;
+        fileVersion: string;
+    };
+    close(): Promise<void>;
+    /**
+     * @returns {AsyncIterable<IconData>}
+     */
+    icons(): AsyncIterable<IconData>;
+    /**
+     * @returns {Iterable<{ name: string, value: import('@comapeo/schema').FieldValue }>}
+     */
+    fields(): Iterable<{
+        name: string;
+        value: import("@comapeo/schema").FieldValue;
+    }>;
+    /**
+     * @returns {Iterable<{ fieldNames: string[], iconName: string | undefined, value: import('@comapeo/schema').PresetValue, name: string}>}
+     */
+    presets(): Iterable<{
+        fieldNames: string[];
+        iconName: string | undefined;
+        value: import("@comapeo/schema").PresetValue;
+        name: string;
+    }>;
+    /** @returns {Iterable<{ name: string, value:Omit<import('@comapeo/schema').TranslationValue, 'docRef'>}>} */
+    translations(): Iterable<{
+        name: string;
+        value: Omit<import("@comapeo/schema").TranslationValue, "docRef">;
+    }>;
+}>;
+export type Entry = yauzl.Entry;
+export type PresetsFile = {
+    presets: {
+        [id: string]: unknown;
+    };
+    fields: {
+        [id: string]: unknown;
+    };
+};
+export type ValidDocTypes = ("presets" | "fields");
+export type TranslationsFile = {
+    [lang: string]: unknown;
+};
+export type MetadataFile = NonNullable<import("@comapeo/schema").ProjectSettingsValue["configMetadata"]>;
+export type IconData = Parameters<import("./icon-api.js").IconApi["create"]>[0];
+import yauzl from 'yauzl-promise';
+//# sourceMappingURL=config-import.d.ts.map

package/dist/config-import.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config-import.d.ts","sourceRoot":"","sources":["../src/config-import.js"],"names":[],"mappings":"AAaA;;GAEG;AACH;;;;;GAKG;AAEH,sDAAsD;AACtD;;;;GAIG;AAEH,4GAA4G;AAE5G;;GAEG;AAEH;;GAEG;AACH,uCAFW,MAAM;;;;;;;;;IAmCb;;OAEG;aADU,aAAa,CAAC,QAAQ,CAAC;IAiDpC;;OAEG;cADU,QAAQ,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,OAAO,iBAAiB,EAAE,UAAU,CAAA;KAAE,CAAC;IA6BpF;;OAEG;eADU,QAAQ,CAAC;QAAE,UAAU,EAAE,MAAM,EAAE,CAAC;QAAC,QAAQ,EAAE,MAAM,GAAG,SAAS,CAAC;QAAC,KAAK,EAAE,OAAO,iBAAiB,EAAE,WAAW,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAC,CAAC;IAiFxI,6GAA6G;oBAA/F,QAAQ,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,KAAK,EAAC,IAAI,CAAC,OAAO,iBAAiB,EAAE,gBAAgB,EAAE,QAAQ,CAAC,CAAA;KAAC,CAAC;GAkB5G;oBA9OY,KAAK,CAAC,KAAK;0BAGX;IACZ,OAAW,EAAE;QAAE,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAA;KAAE,CAAA;IACtC,MAAU,EAAG;QAAE,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAA;KAAE,CAAA;CACnC;4BAGU,CAAC,SAAS,GAAG,QAAQ,CAAC;+BAEvB;IACZ,CAAI,IAAI,EAAE,MAAM,GAAG,OAAO,CAAA;CACvB;2BAGU,WAAW,CAAC,OAAO,iBAAiB,EAAE,oBAAoB,CAAC,gBAAgB,CAAC,CAAC;uBAG9E,UAAU,CAAC,OAAO,eAAe,EAAE,OAAO,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC;kBAjCnD,eAAe"}

package/dist/constants.d.ts

@@ -0,0 +1,14 @@
+/** @import { Namespace } from './types.js' */
+export const NAMESPACES: readonly ["auth", "config", "data", "blobIndex", "blob"];
+/** @type {ReadonlyArray<Namespace>} */
+export const PRESYNC_NAMESPACES: ReadonlyArray<Namespace>;
+/** @type {ReadonlyArray<Namespace>} */
+export const DATA_NAMESPACES: ReadonlyArray<Namespace>;
+export namespace NAMESPACE_SCHEMAS {
+    let data: readonly ["observation", "track"];
+    let config: readonly ["translation", "preset", "field", "projectSettings", "deviceInfo", "icon"];
+    let auth: readonly ["coreOwnership", "role"];
+}
+export const SUPPORTED_CONFIG_VERSION: 1;
+import type { Namespace } from './types.js';
+//# sourceMappingURL=constants.d.ts.map

package/dist/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../src/constants.js"],"names":[],"mappings":"AAAA,8CAA8C;AAI9C,kFAME;AAEF,uCAAuC;AACvC,iCADW,aAAa,CAAC,SAAS,CAAC,CAC8B;AAEjE,uCAAuC;AACvC,8BADW,aAAa,CAAC,SAAS,CAAC,CAGlC;;;;;;AAeD,yCAAyC;+BAjCV,YAAY"}

package/dist/core-manager/bitfield-rle.d.ts

@@ -0,0 +1,25 @@
+/**
+ * @param {Uint32Array} bitfield
+ * @param {Buffer} [buffer]
+ * @param {number} [offset]
+ */
+export function encode(bitfield: Uint32Array, buffer?: Buffer | undefined, offset?: number | undefined): Buffer;
+export namespace encode {
+    let bytes: number;
+}
+/**
+ * @param {Buffer} buffer
+ * @param {number} [offset]
+ * @returns {Uint32Array}
+ */
+export function decode(buffer: Buffer, offset?: number | undefined): Uint32Array;
+export namespace decode {
+    let bytes_1: number;
+    export { bytes_1 as bytes };
+}
+/**
+ * @param {Buffer} buffer
+ * @param {number} offset
+ */
+export function decodingLength(buffer: Buffer, offset: number): number;
+//# sourceMappingURL=bitfield-rle.d.ts.map

package/dist/core-manager/bitfield-rle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bitfield-rle.d.ts","sourceRoot":"","sources":["../../src/core-manager/bitfield-rle.js"],"names":[],"mappings":"AA+BA;;;;GAIG;AACH,iCAJW,WAAW,oEAqBrB;;;;AAYD;;;;GAIG;AACH,+BAJW,MAAM,gCAEJ,WAAW,CAmCvB;;;;;AAED;;;GAGG;AACH,uCAHW,MAAM,UACN,MAAM,UAuBhB"}

package/dist/core-manager/core-index.d.ts

@@ -0,0 +1,56 @@
+/** @import { Namespace } from '../types.js' */
+/** @import { CoreRecord } from './index.js' */
+/**
+ * An in-memory index of open cores.
+ */
+export class CoreIndex {
+    /**
+     * NB. Need to pass key here because `core.key` is not populated until the
+     * core is ready, but we know it beforehand.
+     *
+     * @param {Object} options
+     * @param {import('hypercore')<"binary", Buffer>} options.core Hypercore instance
+     * @param {Buffer} options.key Buffer containing public key of this core
+     * @param {Namespace} options.namespace
+     * @param {boolean} [options.writer] Is this a writer core?
+     */
+    add({ core, key, namespace, writer }: {
+        core: import("hypercore")<"binary", Buffer>;
+        key: Buffer;
+        namespace: Namespace;
+        writer?: boolean | undefined;
+    }): void;
+    /**
+     * Get all known cores in a namespace
+     *
+     * @param {Namespace} namespace
+     * @returns {CoreRecord[]}
+     */
+    getByNamespace(namespace: Namespace): CoreRecord[];
+    /**
+     * Get the write core for the given namespace
+     *
+     * @param {Namespace} namespace
+     * @returns {CoreRecord}
+     */
+    getWriter(namespace: Namespace): CoreRecord;
+    /**
+     * Get a core by its discoveryId (discover key as hex string)
+     *
+     * @param {string} discoveryId
+     * @returns {CoreRecord | undefined}
+     */
+    getByDiscoveryId(discoveryId: string): CoreRecord | undefined;
+    /**
+     * Get a core by its public key
+     *
+     * @param {Buffer} coreKey
+     * @returns {CoreRecord | undefined}
+     */
+    getByCoreKey(coreKey: Buffer): CoreRecord | undefined;
+    [Symbol.iterator](): IterableIterator<CoreRecord>;
+    #private;
+}
+import type { Namespace } from '../types.js';
+import type { CoreRecord } from './index.js';
+//# sourceMappingURL=core-index.d.ts.map

package/dist/core-manager/core-index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"core-index.d.ts","sourceRoot":"","sources":["../../src/core-manager/core-index.js"],"names":[],"mappings":"AACA,+CAA+C;AAC/C,+CAA+C;AAE/C;;GAEG;AACH;IAUE;;;;;;;;;OASG;IACH,sCALG;QAAuD,IAAI,EAAnD,OAAO,WAAW,EAAE,QAAQ,EAAE,MAAM,CAAC;QACrB,GAAG,EAAnB,MAAM;QACa,SAAS,EAA5B,SAAS;QACS,MAAM;KAClC,QASA;IAED;;;;;OAKG;IACH,0BAHW,SAAS,GACP,UAAU,EAAE,CAQxB;IAED;;;;;OAKG;IACH,qBAHW,SAAS,GACP,UAAU,CAStB;IAED;;;;;OAKG;IACH,8BAHW,MAAM,GACJ,UAAU,GAAG,SAAS,CAIlC;IAED;;;;;OAKG;IACH,sBAHW,MAAM,GACJ,UAAU,GAAG,SAAS,CAKlC;IAxED,kDAEC;;CAuEF;+BArF8B,aAAa;gCACZ,YAAY"}