@comapeo/map-server 1.0.0-pre.0

package/dist/lib/errors.js

@@ -0,0 +1,158 @@
+import { json } from 'itty-router';
+export class StatusError extends Error {
+    status;
+    constructor(status = 500, body) {
+        super(typeof body === 'object' ? body.message : body);
+        if (typeof body === 'object')
+            Object.assign(this, body);
+        this.status = status;
+    }
+}
+const errorsList = [
+    // Download errors (receiver-side)
+    {
+        code: 'DOWNLOAD_NOT_FOUND',
+        message: 'Download not found',
+        status: 404,
+    },
+    {
+        code: 'DOWNLOAD_ERROR',
+        message: 'Download failed',
+        status: 500,
+    },
+    {
+        code: 'DOWNLOAD_SHARE_CANCELED',
+        message: 'Download canceled by sender',
+        status: 409,
+    },
+    {
+        code: 'DOWNLOAD_SHARE_DECLINED',
+        message: 'Cannot download: share was declined',
+        status: 409,
+    },
+    {
+        code: 'DOWNLOAD_SHARE_NOT_PENDING',
+        message: 'Cannot download: share is not pending',
+        status: 409,
+    },
+    {
+        code: 'ABORT_NOT_DOWNLOADING',
+        message: 'Cannot abort: download is not in progress',
+        status: 409,
+    },
+    {
+        code: 'INVALID_SENDER_DEVICE_ID',
+        message: 'Invalid sender device ID',
+        status: 400,
+    },
+    // Map share errors (sender-side)
+    {
+        code: 'MAP_SHARE_NOT_FOUND',
+        message: 'Map share not found',
+        status: 404,
+    },
+    {
+        code: 'CANCEL_SHARE_NOT_CANCELABLE',
+        message: 'Cannot cancel: share is not pending or downloading',
+        status: 409,
+    },
+    {
+        code: 'DECLINE_SHARE_NOT_PENDING',
+        message: 'Cannot decline: share is not pending',
+        status: 409,
+    },
+    {
+        code: 'DECLINE_CANNOT_CONNECT',
+        message: 'Cannot decline: unable to connect to sender',
+        status: 502,
+    },
+    // Map errors
+    {
+        code: 'MAP_NOT_FOUND',
+        message: 'Map not found',
+        status: 404,
+    },
+    {
+        code: 'RESOURCE_NOT_FOUND',
+        message: 'Resource not found',
+        status: 404,
+    },
+    {
+        code: 'INVALID_MAP_FILE',
+        message: 'Invalid map file',
+        status: 400,
+    },
+    // Generic errors
+    {
+        code: 'FORBIDDEN',
+        message: 'Forbidden',
+        status: 403,
+    },
+    {
+        code: 'INVALID_REQUEST',
+        message: 'Invalid request',
+        status: 400,
+    },
+];
+export const errors = {};
+for (const { code, message, status } of errorsList) {
+    errors[code] = class extends StatusError {
+        constructor(body) {
+            body = typeof body === 'string' ? { message: body } : body;
+            super(status, { code, message, ...body });
+        }
+    };
+}
+export class ExhaustivenessError extends Error {
+    constructor(value) {
+        super(`Exhaustiveness check failed. ${value} should be impossible`);
+        this.name = 'ExhaustivenessError';
+    }
+}
+export function jsonError(err) {
+    if (err === null) {
+        return { message: 'Unknown error', code: 'UNKNOWN_ERROR' };
+    }
+    else if (typeof err !== 'object') {
+        return { message: String(err), code: 'UNKNOWN_ERROR' };
+    }
+    else {
+        return {
+            message: 'message' in err
+                ? String(err.message)
+                : String(err.error),
+            code: err.code || 'UNKNOWN_ERROR',
+        };
+    }
+}
+const getMessage = (code) => ({
+    400: 'Bad Request',
+    401: 'Unauthorized',
+    403: 'Forbidden',
+    404: 'Not Found',
+    500: 'Internal Server Error',
+})[code] || 'Unknown Error';
+const getCode = (status) => ({
+    400: 'BAD_REQUEST',
+    401: 'UNAUTHORIZED',
+    403: 'FORBIDDEN',
+    404: 'NOT_FOUND',
+    500: 'INTERNAL_SERVER_ERROR',
+})[status] || 'UNKNOWN_ERROR';
+export const error = (a = 500, b) => {
+    // handle passing an Error | StatusError directly in
+    if (a instanceof Error) {
+        const { message, code, ...err } = a;
+        a = a.status || 500;
+        b = {
+            message: message || getMessage(a),
+            code: code || getCode(a),
+            ...err,
+        };
+    }
+    b = {
+        status: a,
+        ...(typeof b === 'object' ? b : { message: b || getMessage(a) }),
+    };
+    return json(b, { status: a });
+};

package/dist/lib/event-stream-response.d.ts

@@ -0,0 +1,17 @@
+import type { TypedEventTarget } from 'typed-event-target';
+type EventTargetStateUpdater = TypedEventTarget<Readonly<Event & {
+    type: 'update';
+}>> & {
+    state: any;
+};
+/**
+ * Create a Server-Sent Events stream for an EventTarget with a `state` property
+ * that emits 'update' events with state updates.
+ *
+ * You must pass an AbortSignal that will cancel the stream if the client disconnects.
+ */
+export declare function createEventStreamResponse(eventTarget: EventTargetStateUpdater, { signal }: {
+    signal: AbortSignal;
+}): Response;
+export {};
+//# sourceMappingURL=event-stream-response.d.ts.map

package/dist/lib/event-stream-response.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"event-stream-response.d.ts","sourceRoot":"","sources":["../../src/lib/event-stream-response.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAA;AAM1D,KAAK,uBAAuB,GAAG,gBAAgB,CAC9C,QAAQ,CAAC,KAAK,GAAG;IAAE,IAAI,EAAE,QAAQ,CAAA;CAAE,CAAC,CACpC,GAAG;IACH,KAAK,EAAE,GAAG,CAAA;CACV,CAAA;AAED;;;;;GAKG;AACH,wBAAgB,yBAAyB,CACxC,WAAW,EAAE,uBAAuB,EACpC,EAAE,MAAM,EAAE,EAAE;IAAE,MAAM,EAAE,WAAW,CAAA;CAAE,GACjC,QAAQ,CAmCV"}

package/dist/lib/event-stream-response.js

@@ -0,0 +1,39 @@
+import { noop } from './utils.js';
+const encoder = new TextEncoder();
+/**
+ * Create a Server-Sent Events stream for an EventTarget with a `state` property
+ * that emits 'update' events with state updates.
+ *
+ * You must pass an AbortSignal that will cancel the stream if the client disconnects.
+ */
+export function createEventStreamResponse(eventTarget, { signal }) {
+    let listener;
+    const stream = new ReadableStream({
+        start(controller) {
+            controller.enqueue(encoder.encode(`data: ${JSON.stringify(eventTarget.state)}\n\n`));
+            listener = (event) => {
+                // eslint-disable-next-line @typescript-eslint/no-unused-vars
+                const { type, ...update } = event;
+                controller.enqueue(encoder.encode(`data: ${JSON.stringify(update)}\n\n`));
+            };
+            eventTarget.addEventListener('update', listener);
+        },
+        cancel() {
+            signal.removeEventListener('abort', onAbort);
+            if (listener) {
+                eventTarget.removeEventListener('update', listener);
+            }
+        },
+    });
+    const onAbort = () => {
+        stream.cancel().catch(noop);
+    };
+    signal.addEventListener('abort', onAbort, { once: true });
+    return new Response(stream, {
+        headers: {
+            'Content-Type': 'text/event-stream',
+            'Cache-Control': 'no-cache',
+            Connection: 'keep-alive',
+        },
+    });
+}

package/dist/lib/event-target.d.ts

@@ -0,0 +1,9 @@
+import { type TypedEventTarget as TypedEventTargetOrig } from 'typed-event-target';
+/**
+ * A strongly typed EventTarget - no runtime overhead
+ */
+export declare const TypedEventTarget: {
+    new <PossibleEvents extends Readonly<Event>>(): TypedEventTargetOrig<PossibleEvents>;
+    prototype: EventTarget;
+};
+//# sourceMappingURL=event-target.d.ts.map

package/dist/lib/event-target.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"event-target.d.ts","sourceRoot":"","sources":["../../src/lib/event-target.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,gBAAgB,IAAI,oBAAoB,EAAE,MAAM,oBAAoB,CAAA;AAElF;;GAEG;AACH,eAAO,MAAM,gBAAgB,EAAkB;IAC9C,KACC,cAAc,SAAS,QAAQ,CAAC,KAAK,CAAC,KAClC,oBAAoB,CAAC,cAAc,CAAC,CAAA;IACzC,SAAS,EAAE,WAAW,CAAA;CACtB,CAAA"}

package/dist/lib/event-target.js

@@ -0,0 +1,4 @@
+/**
+ * A strongly typed EventTarget - no runtime overhead
+ */
+export const TypedEventTarget = EventTarget;

package/dist/lib/fetch-api.d.ts

@@ -0,0 +1,3 @@
+import type { ServerAdapterOptions } from '@whatwg-node/server';
+export declare const fetchAPI: ServerAdapterOptions<any>['fetchAPI'];
+//# sourceMappingURL=fetch-api.d.ts.map

package/dist/lib/fetch-api.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fetch-api.d.ts","sourceRoot":"","sources":["../../src/lib/fetch-api.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,qBAAqB,CAAA;AAM/D,eAAO,MAAM,QAAQ,EAAE,oBAAoB,CAAC,GAAG,CAAC,CAAC,UAAU,CAW1D,CAAA"}

package/dist/lib/fetch-api.js

@@ -0,0 +1,16 @@
+// @whatwg-node/server ponyfills the fetch API by default, which has bugs in the
+// ReadableStream implementation that was causing issues with stream error
+// propagation. To avoid these issues, we explicitly provide the native fetch
+// API implementation from Node.js.
+export const fetchAPI = {
+    ReadableStream: globalThis.ReadableStream,
+    WritableStream: globalThis.WritableStream,
+    TransformStream: globalThis.TransformStream,
+    Response: globalThis.Response,
+    Request: globalThis.Request,
+    Headers: globalThis.Headers,
+    FormData: globalThis.FormData,
+    File: globalThis.File,
+    Blob: globalThis.Blob,
+    fetch: globalThis.fetch,
+};

package/dist/lib/map-share.d.ts

@@ -0,0 +1,52 @@
+import { TypedEventTarget } from '../lib/event-target.js';
+import { MapShareState, type MapShareStateUpdate, type DownloadStateUpdate, type MapInfo } from '../types.js';
+import { StateUpdateEvent } from './state-update-event.js';
+export type MapShareOptions = MapInfo & {
+    /**
+     * Base URLs to construct the download URLs for the map share. Multiple URLs
+     * are supported because the server might have multiple network interfaces
+     * with different IP addresses
+     */
+    baseUrls: string[];
+    /** The device ID of the receiver */
+    receiverDeviceId: string;
+};
+/**
+ * Maintains the state of a map share and handles downloading from the sharer side
+ */
+export declare class MapShare extends TypedEventTarget<InstanceType<typeof StateUpdateEvent>> {
+    #private;
+    constructor({ baseUrls, receiverDeviceId, ...mapInfo }: MapShareOptions);
+    get shareId(): string;
+    get state(): MapShareState;
+    /**
+     * Create a download response for the map share
+     */
+    downloadResponse(readable: ReadableStream): Response;
+    /**
+     * Decline the map share with a given reason
+     */
+    decline(reason: Extract<MapShareStateUpdate, {
+        status: 'declined';
+    }>['reason']): void;
+    /**
+     * Cancel the map share
+     */
+    cancel(): void;
+}
+/**
+ * Handles the download response of a map share and tracks its state.
+ *
+ * Currently we only support a single download per map share, but I'm keeping
+ * this as a separate class in case we want to support multiple downloads per
+ * share in the future (multiple downloads per share will make the "state" of a
+ * MapShare harder to reason about and define).
+ */
+export declare class DownloadResponse extends TypedEventTarget<InstanceType<typeof StateUpdateEvent<DownloadStateUpdate>>> {
+    #private;
+    constructor(readable: ReadableStream<Uint8Array>);
+    get response(): Response;
+    get state(): DownloadStateUpdate;
+    cancel(): void;
+}
+//# sourceMappingURL=map-share.d.ts.map

package/dist/lib/map-share.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"map-share.d.ts","sourceRoot":"","sources":["../../src/lib/map-share.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAA;AACzD,OAAO,EACN,aAAa,EACb,KAAK,mBAAmB,EACxB,KAAK,mBAAmB,EACxB,KAAK,OAAO,EACZ,MAAM,aAAa,CAAA;AAEpB,OAAO,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAA;AAG1D,MAAM,MAAM,eAAe,GAAG,OAAO,GAAG;IACvC;;;;OAIG;IACH,QAAQ,EAAE,MAAM,EAAE,CAAA;IAClB,oCAAoC;IACpC,gBAAgB,EAAE,MAAM,CAAA;CACxB,CAAA;AAED;;GAEG;AACH,qBAAa,QAAS,SAAQ,gBAAgB,CAC7C,YAAY,CAAC,OAAO,gBAAgB,CAAC,CACrC;;gBAGY,EAAE,QAAQ,EAAE,gBAAgB,EAAE,GAAG,OAAO,EAAE,EAAE,eAAe;IAevE,IAAI,OAAO,WAEV;IAED,IAAI,KAAK,kBAER;IAED;;OAEG;IACH,gBAAgB,CAAC,QAAQ,EAAE,cAAc,GAAG,QAAQ;IAkBpD;;OAEG;IACH,OAAO,CACN,MAAM,EAAE,OAAO,CAAC,mBAAmB,EAAE;QAAE,MAAM,EAAE,UAAU,CAAA;KAAE,CAAC,CAAC,QAAQ,CAAC;IAUvE;;OAEG;IACH,MAAM;CAiBN;AAED;;;;;;;GAOG;AACH,qBAAa,gBAAiB,SAAQ,gBAAgB,CACrD,YAAY,CAAC,OAAO,gBAAgB,CAAC,mBAAmB,CAAC,CAAC,CAC1D;;gBAOY,QAAQ,EAAE,cAAc,CAAC,UAAU,CAAC;IAyChD,IAAI,QAAQ,aAEX;IAED,IAAI,KAAK,wBAER;IAED,MAAM;CAQN"}

package/dist/lib/map-share.js

@@ -0,0 +1,142 @@
+import { TypedEventTarget } from '../lib/event-target.js';
+import { errors } from './errors.js';
+import { StateUpdateEvent } from './state-update-event.js';
+import { addTrailingSlash, generateId, getErrorCode } from './utils.js';
+/**
+ * Maintains the state of a map share and handles downloading from the sharer side
+ */
+export class MapShare extends TypedEventTarget {
+    #state;
+    #download;
+    constructor({ baseUrls, receiverDeviceId, ...mapInfo }) {
+        super();
+        const shareId = generateId();
+        this.#state = {
+            ...mapInfo,
+            shareId,
+            mapShareUrls: baseUrls.map((baseUrl) => new URL(`${shareId}`, addTrailingSlash(baseUrl)).href),
+            receiverDeviceId,
+            mapShareCreated: Date.now(),
+            status: 'pending',
+        };
+    }
+    get shareId() {
+        return this.#state.shareId;
+    }
+    get state() {
+        return this.#state;
+    }
+    /**
+     * Create a download response for the map share
+     */
+    downloadResponse(readable) {
+        if (this.#state.status === 'canceled') {
+            throw new errors.DOWNLOAD_SHARE_CANCELED();
+        }
+        else if (this.#state.status === 'declined') {
+            throw new errors.DOWNLOAD_SHARE_DECLINED();
+        }
+        else if (this.#state.status !== 'pending') {
+            throw new errors.DOWNLOAD_SHARE_NOT_PENDING(`Cannot download: share status is '${this.#state.status}'`);
+        }
+        this.#download?.removeAllEventListeners();
+        this.#download = new DownloadResponse(readable);
+        this.#download.addEventListener('update', (event) => {
+            this.#updateState(event);
+        });
+        return this.#download.response;
+    }
+    /**
+     * Decline the map share with a given reason
+     */
+    decline(reason) {
+        if (this.#state.status !== 'pending') {
+            throw new errors.DECLINE_SHARE_NOT_PENDING(`Cannot decline: share status is '${this.#state.status}'`);
+        }
+        this.#updateState({ status: 'declined', reason });
+    }
+    /**
+     * Cancel the map share
+     */
+    cancel() {
+        if (this.#state.status !== 'pending' &&
+            this.#state.status !== 'downloading') {
+            throw new errors.CANCEL_SHARE_NOT_CANCELABLE(`Cannot cancel: share status is '${this.#state.status}'`);
+        }
+        this.#download?.cancel();
+        this.#updateState({ status: 'canceled' });
+    }
+    #updateState(update) {
+        this.#state = { ...this.#state, ...update };
+        queueMicrotask(() => this.dispatchEvent(new StateUpdateEvent(update)));
+    }
+}
+/**
+ * Handles the download response of a map share and tracks its state.
+ *
+ * Currently we only support a single download per map share, but I'm keeping
+ * this as a separate class in case we want to support multiple downloads per
+ * share in the future (multiple downloads per share will make the "state" of a
+ * MapShare harder to reason about and define).
+ */
+export class DownloadResponse extends TypedEventTarget {
+    #stream;
+    #bytesDownloaded = 0;
+    #abortController = new AbortController();
+    #state = { status: 'downloading', bytesDownloaded: 0 };
+    #response;
+    constructor(readable) {
+        super();
+        this.#stream = new TransformStream({
+            start: () => {
+                this.#updateState({ status: 'downloading', bytesDownloaded: 0 });
+            },
+            transform: (chunk, controller) => {
+                this.#bytesDownloaded += chunk.length;
+                this.#updateState({
+                    status: 'downloading',
+                    bytesDownloaded: this.#bytesDownloaded,
+                });
+                controller.enqueue(chunk);
+            },
+            flush: () => {
+                this.#updateState({ status: 'completed' });
+            },
+        });
+        readable
+            .pipeTo(this.#stream.writable, {
+            signal: this.#abortController.signal,
+            // preventAbort: true,
+            // preventCancel: true,
+        })
+            .catch((error) => {
+            if (error.name === 'AbortError') {
+                this.#updateState({ status: 'canceled' });
+            }
+            else if (getErrorCode(error) === 'ECONNRESET') {
+                this.#updateState({ status: 'aborted' });
+            }
+            else {
+                this.#updateState({ status: 'error', error });
+            }
+        });
+        this.#response = new Response(this.#stream.readable, {
+            headers: {
+                'Content-Type': 'application/vnd.smp+zip',
+            },
+        });
+    }
+    get response() {
+        return this.#response;
+    }
+    get state() {
+        return this.#state;
+    }
+    cancel() {
+        this.#abortController.abort();
+    }
+    #updateState(update) {
+        this.#state = update;
+        this.dispatchEvent(new StateUpdateEvent(update));
+    }
+}

package/dist/lib/secret-stream-fetch.d.ts

@@ -0,0 +1,7 @@
+import { fetch as secretStreamFetchOrig } from 'secret-stream-http';
+/**
+ * A wrapper around secret-stream-http's fetch that tries multiple URLs until one works.
+ * This is useful when the server has multiple IPs for different network interfaces.
+ */
+export declare function secretStreamFetch(urls: string | URL | Array<string | URL>, options: Parameters<typeof secretStreamFetchOrig>[1]): Promise<Response>;
+//# sourceMappingURL=secret-stream-fetch.d.ts.map

package/dist/lib/secret-stream-fetch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"secret-stream-fetch.d.ts","sourceRoot":"","sources":["../../src/lib/secret-stream-fetch.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,IAAI,qBAAqB,EAAE,MAAM,oBAAoB,CAAA;AAInE;;;GAGG;AACH,wBAAsB,iBAAiB,CACtC,IAAI,EAAE,MAAM,GAAG,GAAG,GAAG,KAAK,CAAC,MAAM,GAAG,GAAG,CAAC,EACxC,OAAO,EAAE,UAAU,CAAC,OAAO,qBAAqB,CAAC,CAAC,CAAC,CAAC,qBA+BpD"}

package/dist/lib/secret-stream-fetch.js

@@ -0,0 +1,34 @@
+import { fetch as secretStreamFetchOrig } from 'secret-stream-http';
+import { errors } from './errors.js';
+/**
+ * A wrapper around secret-stream-http's fetch that tries multiple URLs until one works.
+ * This is useful when the server has multiple IPs for different network interfaces.
+ */
+export async function secretStreamFetch(urls, options) {
+    if (!Array.isArray(urls)) {
+        urls = [urls];
+    }
+    let response;
+    let error;
+    // The server could have multiple IPs for different network interfaces, and
+    // not all of them may be on the same network as us, so try each URL until
+    // one works
+    for (const url of urls) {
+        try {
+            response = (await secretStreamFetchOrig(url, options)); // Subtle difference bewteen Undici fetch Response and whatwg Response
+            break; // Exit loop on successful fetch
+        }
+        catch (err) {
+            error = err;
+            // Ignore errors and try the next URL
+        }
+    }
+    if (!response) {
+        throw new errors.DOWNLOAD_ERROR({
+            message: 'Could not connect to map share sender',
+            urls,
+            cause: error,
+        });
+    }
+    return response;
+}

package/dist/lib/self-evicting-map.d.ts

@@ -0,0 +1,16 @@
+/**
+ * "Not a LRU": A Map that automatically evicts entries after a specified
+ * timeout. Used for MapShares which we don't want to keep indefinitely. NB: The
+ * use of the Typescript `object` type is intentional: this must be used with
+ * non-primitive values, otherwise behaviour would be unexpected because
+ * removing a value and re-adding it could result in it being evicted with the
+ * original timeout. This has limited applications, but works for our needs.
+ */
+export declare class SelfEvictingTimeoutMap<K, V extends object> extends Map<K, V> {
+    #private;
+    constructor(iterable?: ConstructorParameters<typeof Map<K, V>>[0], { evictionTimeoutMs }?: {
+        evictionTimeoutMs?: number | undefined;
+    });
+    set(key: K, value: V): this;
+}
+//# sourceMappingURL=self-evicting-map.d.ts.map

package/dist/lib/self-evicting-map.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"self-evicting-map.d.ts","sourceRoot":"","sources":["../../src/lib/self-evicting-map.ts"],"names":[],"mappings":"AAEA;;;;;;;GAOG;AACH,qBAAa,sBAAsB,CAAC,CAAC,EAAE,CAAC,SAAS,MAAM,CAAE,SAAQ,GAAG,CAAC,CAAC,EAAE,CAAC,CAAC;;gBAKxE,QAAQ,CAAC,EAAE,qBAAqB,CAAC,OAAO,GAAG,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,EACrD,EAAE,iBAA+C,EAAE;;KAAK;IAMhD,GAAG,CAAC,GAAG,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,IAAI;CAYpC"}

package/dist/lib/self-evicting-map.js

@@ -0,0 +1,29 @@
+const DEFAULT_EVICTION_TIMEOUT_MS = 15 * 60 * 1000; // 15 minutes
+/**
+ * "Not a LRU": A Map that automatically evicts entries after a specified
+ * timeout. Used for MapShares which we don't want to keep indefinitely. NB: The
+ * use of the Typescript `object` type is intentional: this must be used with
+ * non-primitive values, otherwise behaviour would be unexpected because
+ * removing a value and re-adding it could result in it being evicted with the
+ * original timeout. This has limited applications, but works for our needs.
+ */
+export class SelfEvictingTimeoutMap extends Map {
+    #evictionTimeoutMs;
+    #timeouts = new Set();
+    constructor(iterable, { evictionTimeoutMs = DEFAULT_EVICTION_TIMEOUT_MS } = {}) {
+        super(iterable);
+        this.#evictionTimeoutMs = evictionTimeoutMs;
+    }
+    set(key, value) {
+        super.set(key, value);
+        const timeout = setTimeout(() => {
+            this.#timeouts.delete(timeout);
+            if (this.get(key) === value) {
+                this.delete(key);
+            }
+        }, this.#evictionTimeoutMs);
+        timeout.unref();
+        this.#timeouts.add(timeout);
+        return this;
+    }
+}

package/dist/lib/state-update-event.d.ts

@@ -0,0 +1,8 @@
+import type { MapShareStateUpdate } from '../types.js';
+/**
+ * Event representing a state update in a map share
+ */
+export declare const StateUpdateEvent: new <TUpdate extends MapShareStateUpdate>(update: TUpdate) => Event & {
+    type: "update";
+} & TUpdate;
+//# sourceMappingURL=state-update-event.d.ts.map

package/dist/lib/state-update-event.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"state-update-event.d.ts","sourceRoot":"","sources":["../../src/lib/state-update-event.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,aAAa,CAAA;AAEtD;;GAEG;AACH,eAAO,MAAM,gBAAgB,EAMxB,KAAK,OAAO,SAAS,mBAAmB,EAC5C,MAAM,EAAE,OAAO,KACX,KAAK,GAAG;IAAE,IAAI,EAAE,QAAQ,CAAA;CAAE,GAAG,OAAO,CAAA"}

package/dist/lib/state-update-event.js

@@ -0,0 +1,10 @@
+/**
+ * Event representing a state update in a map share
+ */
+export const StateUpdateEvent = class extends Event {
+    static type = 'update';
+    constructor(update) {
+        super('update');
+        Object.assign(this, update);
+    }
+};

package/dist/lib/utils.d.ts

@@ -0,0 +1,32 @@
+import type { SMPStyle } from 'styled-map-package';
+import type { BBox } from '../types.js';
+/**
+ * If the argument is an `Error` instance, return its `code` property if it is a string.
+ * Otherwise, returns `undefined`.
+ *
+ * @param {unknown} maybeError
+ * @returns {undefined | string}
+ * @example
+ * try {
+ *   // do something
+ * } catch (err) {
+ *   console.error(getErrorCode(err))
+ * }
+ */
+export declare function getErrorCode(maybeError: unknown): string | undefined;
+export declare function noop(): void;
+export declare function generateId(): string;
+export declare function getOrInsert<K, V>(map: Map<K, V>, key: K, value: V): V;
+export declare function timingSafeEqual(a: string, b: string): boolean;
+/**
+ * Returns a bbox that is the smallest bounding box that contains all the input bboxes.
+ *
+ * @param bboxes
+ * @returns Bounding Box [w, s, e, n] of all input bboxes
+ */
+export declare function unionBBox(bboxes: [BBox, ...BBox[]]): BBox;
+export declare function getStyleBbox(style: SMPStyle): BBox;
+export declare function getStyleMaxZoom(style: SMPStyle): number;
+export declare function getStyleMinZoom(style: SMPStyle): number;
+export declare function addTrailingSlash(url: string): string;
+//# sourceMappingURL=utils.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/lib/utils.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,oBAAoB,CAAA;AAGlD,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,aAAa,CAAA;AAEvC;;;;;;;;;;;;GAYG;AACH,wBAAgB,YAAY,CAAC,UAAU,EAAE,OAAO,sBAS/C;AAED,wBAAgB,IAAI,SAAK;AAEzB,wBAAgB,UAAU,WAEzB;AAED,wBAAgB,WAAW,CAAC,CAAC,EAAE,CAAC,EAAE,GAAG,EAAE,GAAG,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,CAAC,CAMrE;AAED,wBAAgB,eAAe,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,OAAO,CAO7D;AAED;;;;;GAKG;AACH,wBAAgB,SAAS,CAAC,MAAM,EAAE,CAAC,IAAI,EAAE,GAAG,IAAI,EAAE,CAAC,GAAG,IAAI,CAUzD;AAED,wBAAgB,YAAY,CAAC,KAAK,EAAE,QAAQ,GAAG,IAAI,CAUlD;AAED,wBAAgB,eAAe,CAAC,KAAK,EAAE,QAAQ,GAAG,MAAM,CAOvD;AAED,wBAAgB,eAAe,CAAC,KAAK,EAAE,QAAQ,GAAG,MAAM,CAOvD;AAMD,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAEpD"}