applesauce-loaders 0.12.0 → 2.0.0

package/dist/loaders/loader.d.ts

@@ -1,20 +0,0 @@
-import { Filter, NostrEvent } from "nostr-tools";
-import { InteropObservable, Observable, OperatorFunction, Subject, Subscribable } from "rxjs";
-export type RelayFilterMap<T = Filter> = {
-    [relay: string]: T[];
-};
-export type CacheRequest = (filters: Filter[]) => Observable<NostrEvent>;
-export interface ILoader<T, R> extends Subscribable<R> {
-    next: (value: T) => void;
-    pipe: Observable<R>["pipe"];
-}
-/** Base loader class */
-export declare class Loader<Input, Output> implements ILoader<Input, Output>, InteropObservable<Output> {
-    protected subject: Subject<Input>;
-    observable: Observable<Output>;
-    pipe: Observable<Output>["pipe"];
-    subscribe: Observable<Output>["subscribe"];
-    constructor(transform: OperatorFunction<Input, Output>);
-    next(value: Input): void;
-    [Symbol.observable](): Observable<Output>;
-}

package/dist/loaders/loader.js

@@ -1,22 +0,0 @@
-import { share, Subject } from "rxjs";
-/** Base loader class */
-export class Loader {
-    subject = new Subject();
-    observable;
-    pipe;
-    subscribe;
-    constructor(transform) {
-        this.observable = this.subject.pipe(transform, 
-        // only create a single instance of the transformer
-        share());
-        // copy pipe function
-        this.pipe = this.observable.pipe.bind(this.observable);
-        this.subscribe = this.observable.subscribe.bind(this.observable);
-    }
-    next(value) {
-        this.subject.next(value);
-    }
-    [Symbol.observable]() {
-        return this.observable;
-    }
-}

package/dist/loaders/relay-timeline-loader.d.ts

@@ -1,24 +0,0 @@
-import { EventPacket, RxNostr } from "rx-nostr";
-import { BehaviorSubject } from "rxjs";
-import { logger } from "applesauce-core";
-import { Filter } from "nostr-tools";
-import { Loader } from "./loader.js";
-export type TimelessFilter = Omit<Filter, "since" | "until">;
-export type RelayTimelineLoaderOptions = {
-    /** default number of events to request in each batch */
-    limit?: number;
-};
-/** A loader that can be used to load a timeline in chunks */
-export declare class RelayTimelineLoader extends Loader<number | void, EventPacket> {
-    relay: string;
-    filters: TimelessFilter[];
-    id: string;
-    loading$: BehaviorSubject<boolean>;
-    get loading(): boolean;
-    /** current "until" timestamp */
-    cursor: number;
-    /** if the timeline is complete */
-    complete: boolean;
-    protected log: typeof logger;
-    constructor(rxNostr: RxNostr, relay: string, filters: TimelessFilter[], opts?: RelayTimelineLoaderOptions);
-}

package/dist/loaders/relay-timeline-loader.js

@@ -1,70 +0,0 @@
-import { createRxOneshotReq } from "rx-nostr";
-import { BehaviorSubject, filter, map, Observable } from "rxjs";
-import { logger } from "applesauce-core";
-import { nanoid } from "nanoid";
-import { unixNow } from "applesauce-core/helpers";
-import { Loader } from "./loader.js";
-/** A loader that can be used to load a timeline in chunks */
-export class RelayTimelineLoader extends Loader {
-    relay;
-    filters;
-    id = nanoid(8);
-    loading$ = new BehaviorSubject(false);
-    get loading() {
-        return this.loading$.value;
-    }
-    /** current "until" timestamp */
-    cursor = Infinity;
-    /** if the timeline is complete */
-    complete = false;
-    log = logger.extend("RelayTimelineLoader");
-    constructor(rxNostr, relay, filters, opts) {
-        super((source) => new Observable((observer) => {
-            return source
-                .pipe(filter(() => !this.loading && !this.complete), map((limit) => {
-                // build next batch filters
-                return filters.map((filter) => ({
-                    limit: limit || opts?.limit,
-                    ...filter,
-                    // limit curser to now
-                    until: Math.min(unixNow(), this.cursor),
-                }));
-            }), 
-            // ignore empty filters
-            filter((filters) => filters.length > 0))
-                .subscribe((filters) => {
-                // make batch request
-                let count = 0;
-                const req = createRxOneshotReq({ filters, rxReqId: this.id });
-                this.loading$.next(true);
-                this.log(`Next batch starting at ${filters[0].until} limit ${filters[0].limit}`);
-                rxNostr.use(req, { on: { relays: [relay] } }).subscribe({
-                    next: (packet) => {
-                        // update cursor when event is received
-                        this.cursor = Math.min(packet.event.created_at - 1, this.cursor);
-                        count++;
-                        // forward packet
-                        observer.next(packet);
-                    },
-                    error: (err) => observer.error(err),
-                    complete: () => {
-                        // set loading to false when batch completes
-                        this.loading$.next(false);
-                        // set complete the observable if 0 events where returned
-                        if (count === 0) {
-                            observer.complete();
-                            this.log(`Got ${count} event, Complete`);
-                        }
-                        else {
-                            this.log(`Finished batch, got ${count} events`);
-                        }
-                    },
-                });
-            });
-        }));
-        this.relay = relay;
-        this.filters = filters;
-        // create a unique logger for this instance
-        this.log = this.log.extend(relay);
-    }
-}

package/dist/loaders/replaceable-loader.d.ts

@@ -1,23 +0,0 @@
-import { EventPacket, RxNostr } from "rx-nostr";
-import { logger } from "applesauce-core";
-import { CacheRequest, Loader } from "./loader.js";
-import { LoadableAddressPointer } from "../helpers/address-pointer.js";
-export type ReplaceableLoaderOptions = {
-    /**
-     * Time interval to buffer requests in ms
-     * @default 1000
-     */
-    bufferTime?: number;
-    /** A method used to load events from a local cache */
-    cacheRequest?: CacheRequest;
-    /** Fallback lookup relays to check when event cant be found */
-    lookupRelays?: string[];
-};
-export declare class ReplaceableLoader extends Loader<LoadableAddressPointer, EventPacket> {
-    log: typeof logger;
-    /** A method used to load events from a local cache */
-    cacheRequest?: CacheRequest;
-    /** Fallback lookup relays to check when event cant be found */
-    lookupRelays?: string[];
-    constructor(rxNostr: RxNostr, opts?: ReplaceableLoaderOptions);
-}

package/dist/loaders/replaceable-loader.js

@@ -1,106 +0,0 @@
-import { tap, filter, bufferTime, map } from "rxjs";
-import { createRxOneshotReq } from "rx-nostr";
-import { getEventUID, markFromCache, mergeRelaySets } from "applesauce-core/helpers";
-import { logger } from "applesauce-core";
-import { nanoid } from "nanoid";
-import { Loader } from "./loader.js";
-import { generatorSequence } from "../operators/generator-sequence.js";
-import { consolidateAddressPointers, createFiltersFromAddressPointers, getAddressPointerId, getRelaysFromPointers, isLoadableAddressPointer, } from "../helpers/address-pointer.js";
-import { getDefaultReadRelays } from "../helpers/rx-nostr.js";
-import { distinctRelaysBatch } from "../operators/distinct-relays.js";
-/** A generator that tries to load the address pointers from the cache first, then tries the relays */
-function* cacheFirstSequence(rxNostr, pointers, log, opts) {
-    const id = nanoid(4);
-    let remaining = Array.from(pointers);
-    const pointerRelays = Array.from(getRelaysFromPointers(pointers));
-    // handle previous step results and decide if to exit
-    const handleResults = (results) => {
-        if (results.length) {
-            const coordinates = new Set(results.map((p) => getEventUID(p.event)));
-            // if there where results, filter out any pointers that where found
-            remaining = remaining.filter((pointer) => {
-                const found = coordinates.has(getAddressPointerId(pointer));
-                if (found && pointer.force !== true)
-                    return false;
-                else
-                    return true;
-            });
-            // If there are none left, complete
-            if (remaining.length === 0) {
-                log(`[${id}] Complete`);
-                return true;
-            }
-        }
-        return false;
-    };
-    // first attempt, load from cache relays
-    if (opts?.cacheRequest) {
-        log(`[${id}] Checking cache`, remaining);
-        const filters = createFiltersFromAddressPointers(remaining);
-        const results = yield opts.cacheRequest(filters).pipe(
-        // mark the event as from the cache
-        tap((event) => markFromCache(event)), 
-        // convert to event packets
-        map((e) => ({ event: e, from: "", subId: "replaceable-loader", type: "EVENT" })));
-        if (handleResults(results))
-            return;
-    }
-    // load from pointer relays and default relays
-    const defaultRelays = getDefaultReadRelays(rxNostr);
-    const remoteRelays = mergeRelaySets(pointerRelays, defaultRelays);
-    if (remoteRelays.length > 0) {
-        log(`[${id}] Requesting`, remoteRelays, remaining);
-        const filters = createFiltersFromAddressPointers(remaining);
-        const req = createRxOneshotReq({ filters, rxReqId: id });
-        const results = yield rxNostr.use(req, { on: { relays: remoteRelays } });
-        if (handleResults(results))
-            return;
-    }
-    // finally load from lookup relays
-    if (opts?.lookupRelays) {
-        // make sure we aren't asking a relay twice
-        const relays = opts.lookupRelays.filter((r) => !pointerRelays.includes(r));
-        if (relays.length > 0) {
-            log(`[${id}] Request from lookup`, relays, remaining);
-            const filters = createFiltersFromAddressPointers(remaining);
-            const req = createRxOneshotReq({ filters, rxReqId: id });
-            const results = yield rxNostr.use(req, { on: { relays } });
-            if (handleResults(results))
-                return;
-        }
-    }
-}
-export class ReplaceableLoader extends Loader {
-    log = logger.extend("ReplaceableLoader");
-    /** A method used to load events from a local cache */
-    cacheRequest;
-    /** Fallback lookup relays to check when event cant be found */
-    lookupRelays;
-    constructor(rxNostr, opts) {
-        super((source) => {
-            return source.pipe(
-            // filter out invalid pointers
-            filter(isLoadableAddressPointer), 
-            // buffer on time
-            bufferTime(opts?.bufferTime ?? 1000), 
-            // ignore empty buffers
-            filter((buffer) => buffer.length > 0), 
-            // only fetch from each relay once
-            distinctRelaysBatch(getAddressPointerId), 
-            // consolidate buffered pointers
-            map(consolidateAddressPointers), 
-            // ignore empty buffer
-            filter((buffer) => buffer.length > 0), 
-            // check cache, relays, lookup relays in that order
-            generatorSequence((pointers) => cacheFirstSequence(rxNostr, pointers, this.log, {
-                cacheRequest: this.cacheRequest,
-                lookupRelays: this.lookupRelays,
-            }), 
-            // there will always be more events, never complete
-            false));
-        });
-        // set options
-        this.cacheRequest = opts?.cacheRequest;
-        this.lookupRelays = opts?.lookupRelays;
-    }
-}

package/dist/loaders/request-loader.d.ts

@@ -1,30 +0,0 @@
-import { IEventStore, QueryStore } from "applesauce-core";
-import { ProfilePointer } from "nostr-tools/nip19";
-import { Observable } from "rxjs";
-import { ReplaceableLoader } from "./replaceable-loader.js";
-import { LoadableAddressPointer } from "../helpers/address-pointer.js";
-/** A special Promised based loader built on the {@link QueryStore} */
-export declare class RequestLoader {
-    store: QueryStore;
-    requestTimeout: number;
-    replaceableLoader?: ReplaceableLoader;
-    constructor(store: QueryStore);
-    protected runWithTimeout<T extends unknown, Args extends Array<any>>(queryConstructor: (...args: Args) => {
-        key: string;
-        run: (events: IEventStore, store: QueryStore) => Observable<T>;
-    }, ...args: Args): Promise<NonNullable<T>>;
-    protected checkReplaceable(): ReplaceableLoader;
-    /** Requests a single replaceable event */
-    replaceable(pointer: LoadableAddressPointer, force?: boolean): Promise<import("nostr-tools").Event>;
-    /** Loads a pubkeys profile */
-    profile(pointer: ProfilePointer, force?: boolean): Promise<import("applesauce-core/helpers").ProfileContent>;
-    /** Loads a pubkeys profile */
-    mailboxes(pointer: ProfilePointer, force?: boolean): Promise<{
-        inboxes: string[];
-        outboxes: string[];
-    }>;
-    /** Loads a pubkeys profile */
-    contacts(pointer: ProfilePointer, force?: boolean): Promise<ProfilePointer[]>;
-    /** Loads a pubkeys blossom servers */
-    blossomServers(pointer: ProfilePointer, force?: boolean): Promise<URL[]>;
-}

package/dist/loaders/request-loader.js

@@ -1,57 +0,0 @@
-import { kinds } from "nostr-tools";
-import { MailboxesQuery, ProfileQuery, ReplaceableQuery, UserBlossomServersQuery, UserContactsQuery, } from "applesauce-core/queries";
-import { getObservableValue, simpleTimeout } from "applesauce-core/observable";
-import { filter } from "rxjs";
-import { BLOSSOM_SERVER_LIST_KIND } from "applesauce-core/helpers";
-/** A special Promised based loader built on the {@link QueryStore} */
-export class RequestLoader {
-    store;
-    requestTimeout = 10_000;
-    replaceableLoader;
-    constructor(store) {
-        this.store = store;
-    }
-    // hacky method to run queries with timeouts
-    async runWithTimeout(queryConstructor, ...args) {
-        return getObservableValue(this.store.createQuery(queryConstructor, ...args).pipe(
-        // ignore undefined and null values
-        filter((v) => v !== undefined && v !== null), 
-        // timeout with an error is not values
-        simpleTimeout(this.requestTimeout)));
-    }
-    checkReplaceable() {
-        if (!this.replaceableLoader)
-            throw new Error("Missing ReplaceableLoader");
-        return this.replaceableLoader;
-    }
-    /** Requests a single replaceable event */
-    replaceable(pointer, force) {
-        this.checkReplaceable().next({ ...pointer, force });
-        return this.runWithTimeout(ReplaceableQuery, pointer.kind, pointer.pubkey, pointer.identifier);
-    }
-    /** Loads a pubkeys profile */
-    profile(pointer, force) {
-        this.checkReplaceable().next({ kind: kinds.Metadata, pubkey: pointer.pubkey, relays: pointer.relays, force });
-        return this.runWithTimeout(ProfileQuery, pointer.pubkey);
-    }
-    /** Loads a pubkeys profile */
-    mailboxes(pointer, force) {
-        this.checkReplaceable().next({ kind: kinds.RelayList, pubkey: pointer.pubkey, relays: pointer.relays, force });
-        return this.runWithTimeout(MailboxesQuery, pointer.pubkey);
-    }
-    /** Loads a pubkeys profile */
-    contacts(pointer, force) {
-        this.checkReplaceable().next({ kind: kinds.Contacts, pubkey: pointer.pubkey, relays: pointer.relays, force });
-        return this.runWithTimeout(UserContactsQuery, pointer.pubkey);
-    }
-    /** Loads a pubkeys blossom servers */
-    blossomServers(pointer, force) {
-        this.checkReplaceable().next({
-            kind: BLOSSOM_SERVER_LIST_KIND,
-            pubkey: pointer.pubkey,
-            relays: pointer.relays,
-            force,
-        });
-        return this.runWithTimeout(UserBlossomServersQuery, pointer.pubkey);
-    }
-}

package/dist/loaders/single-event-loader.d.ts

@@ -1,26 +0,0 @@
-import { EventPacket, RxNostr } from "rx-nostr";
-import { logger } from "applesauce-core";
-import { CacheRequest, Loader } from "./loader.js";
-export type LoadableEventPointer = {
-    id: string;
-    /** Relays to load from */
-    relays?: string[];
-};
-export type SingleEventLoaderOptions = {
-    /**
-     * Time interval to buffer requests in ms
-     * @default 1000
-     */
-    bufferTime?: number;
-    /** A method used to load events from a local cache */
-    cacheRequest?: CacheRequest;
-    /**
-     * How long the loader should wait before it allows an event pointer to be refreshed from a relay
-     * @default 60000
-     */
-    refreshTimeout?: number;
-};
-export declare class SingleEventLoader extends Loader<LoadableEventPointer, EventPacket> {
-    log: typeof logger;
-    constructor(rxNostr: RxNostr, opts?: SingleEventLoaderOptions);
-}

package/dist/loaders/single-event-loader.js

@@ -1,76 +0,0 @@
-import { bufferTime, filter, from, map, mergeAll, tap } from "rxjs";
-import { createRxOneshotReq } from "rx-nostr";
-import { markFromCache } from "applesauce-core/helpers";
-import { logger } from "applesauce-core";
-import { nanoid } from "nanoid";
-import { Loader } from "./loader.js";
-import { generatorSequence } from "../operators/generator-sequence.js";
-import { distinctRelaysBatch } from "../operators/distinct-relays.js";
-import { groupByRelay } from "../helpers/pointer.js";
-import { consolidateEventPointers } from "../helpers/event-pointer.js";
-function* cacheFirstSequence(rxNostr, pointers, opts, log) {
-    let remaining = [...pointers];
-    const id = nanoid(8);
-    log = log.extend(id);
-    const loaded = (packets) => {
-        const ids = new Set(packets.map((p) => p.event.id));
-        remaining = remaining.filter((p) => !ids.has(p.id));
-    };
-    if (opts?.cacheRequest) {
-        let filter = { ids: remaining.map((e) => e.id) };
-        const results = yield opts.cacheRequest([filter]).pipe(
-        // mark the event as from the cache
-        tap((event) => markFromCache(event)), 
-        // convert to event packets
-        map((e) => ({ event: e, from: "", subId: "single-event-loader", type: "EVENT" })));
-        if (results.length > 0) {
-            log(`Loaded ${results.length} events from cache`);
-            loaded(results);
-        }
-    }
-    // exit early if all pointers are loaded
-    if (remaining.length === 0)
-        return;
-    let byRelay = groupByRelay(remaining, "default");
-    // load remaining pointers from the relays
-    let results = yield from(Array.from(byRelay.entries()).map(([relay, pointers]) => {
-        let filter = { ids: pointers.map((e) => e.id) };
-        let count = 0;
-        const req = createRxOneshotReq({ filters: [filter], rxReqId: id });
-        log(`Requesting from ${relay}`, filter.ids);
-        let sub$;
-        // don't specify relay if this is the "default" relay
-        if (relay === "default")
-            sub$ = rxNostr.use(req);
-        else
-            sub$ = rxNostr.use(req, { on: { relays: [relay] } });
-        return sub$.pipe(tap({
-            next: () => count++,
-            complete: () => log(`Completed ${relay}, loaded ${count} events`),
-        }));
-    })).pipe(mergeAll());
-    loaded(results);
-    if (remaining.length > 0) {
-        // failed to find remaining
-        log("Failed to load", remaining.map((p) => p.id));
-    }
-}
-export class SingleEventLoader extends Loader {
-    log = logger.extend("SingleEventLoader");
-    constructor(rxNostr, opts) {
-        let options = opts || {};
-        super((source) => source.pipe(
-        // load first from cache
-        bufferTime(opts?.bufferTime ?? 1000), 
-        // ignore empty buffers
-        filter((buffer) => buffer.length > 0), 
-        // only request events from relays once
-        distinctRelaysBatch((p) => p.id, options.refreshTimeout ?? 60_000), 
-        // ensure there is only one of each event pointer
-        map(consolidateEventPointers), 
-        // run the loader sequence
-        generatorSequence((pointers) => cacheFirstSequence(rxNostr, pointers, options, this.log), 
-        // there will always be more events, never complete
-        false)));
-    }
-}

package/dist/loaders/user-sets-loader.d.ts

@@ -1,31 +0,0 @@
-import { EventPacket, RxNostr } from "rx-nostr";
-import { logger } from "applesauce-core";
-import { CacheRequest, Loader } from "./loader.js";
-export type LoadableSetPointer = {
-    /** A replaceable kind >= 30000 & < 40000 */
-    kind: number;
-    pubkey: string;
-    /** Relays to load from */
-    relays?: string[];
-    /** Load the sets even if it has already been loaded */
-    force?: boolean;
-};
-export type UserSetsLoaderOptions = {
-    /**
-     * Time interval to buffer requests in ms
-     * @default 1000
-     */
-    bufferTime?: number;
-    /** A method used to load events from a local cache */
-    cacheRequest?: CacheRequest;
-    /**
-     * How long the loader should wait before it allows an event pointer to be refreshed from a relay
-     * @default 120000
-     */
-    refreshTimeout?: number;
-};
-/** A loader that can be used to load users NIP-51 sets events ( kind >= 30000 < 40000) */
-export declare class UserSetsLoader extends Loader<LoadableSetPointer, EventPacket> {
-    log: typeof logger;
-    constructor(rxNostr: RxNostr, opts?: UserSetsLoaderOptions);
-}

package/dist/loaders/user-sets-loader.js

@@ -1,66 +0,0 @@
-import { tap, from, filter, map, mergeAll, bufferTime } from "rxjs";
-import { createRxOneshotReq } from "rx-nostr";
-import { markFromCache } from "applesauce-core/helpers";
-import { logger } from "applesauce-core";
-import { nanoid } from "nanoid";
-import { Loader } from "./loader.js";
-import { generatorSequence } from "../operators/generator-sequence.js";
-import { consolidateAddressPointers, createFiltersFromAddressPointers } from "../helpers/address-pointer.js";
-import { groupByRelay } from "../helpers/pointer.js";
-import { distinctRelaysBatch } from "../operators/distinct-relays.js";
-/** A generator that tries to load the address pointers from the cache first, then tries the relays */
-function* cacheFirstSequence(rxNostr, pointers, log, opts) {
-    const id = nanoid(8);
-    log = log.extend(id);
-    // first attempt, load from cache relays
-    if (opts?.cacheRequest) {
-        log(`Checking cache`);
-        const filters = createFiltersFromAddressPointers(pointers);
-        const results = yield opts.cacheRequest(filters).pipe(
-        // mark the event as from the cache
-        tap((event) => markFromCache(event)), 
-        // convert to event packets
-        map((e) => ({ event: e, from: "", subId: "user-sets-loader", type: "EVENT" })));
-        if (results.length > 0) {
-            log(`Loaded ${results.length} events from cache`);
-        }
-    }
-    let byRelay = groupByRelay(pointers, "default");
-    // load sets from relays
-    yield from(Array.from(byRelay.entries()).map(([relay, pointers]) => {
-        let filters = createFiltersFromAddressPointers(pointers);
-        let count = 0;
-        const req = createRxOneshotReq({ filters, rxReqId: id });
-        log(`Requesting from ${relay}`, pointers);
-        let sub$;
-        // don't specify relay if this is the "default" relay
-        if (relay === "default")
-            sub$ = rxNostr.use(req);
-        else
-            sub$ = rxNostr.use(req, { on: { relays: [relay] } });
-        return sub$.pipe(tap({
-            next: () => count++,
-            complete: () => log(`Completed ${relay}, loaded ${count} events`),
-        }));
-    })).pipe(mergeAll());
-}
-/** A loader that can be used to load users NIP-51 sets events ( kind >= 30000 < 40000) */
-export class UserSetsLoader extends Loader {
-    log = logger.extend("UserSetsLoader");
-    constructor(rxNostr, opts) {
-        let options = opts || {};
-        super((source) => source.pipe(
-        // load first from cache
-        bufferTime(options?.bufferTime ?? 1000), 
-        // ignore empty buffers
-        filter((buffer) => buffer.length > 0), 
-        // only load from each relay once
-        distinctRelaysBatch((p) => p.kind + ":" + p.pubkey, options.refreshTimeout ?? 120_000), 
-        // deduplicate address pointers
-        map(consolidateAddressPointers), 
-        // check cache, relays, lookup relays in that order
-        generatorSequence((pointers) => cacheFirstSequence(rxNostr, pointers, this.log, options), 
-        // there will always be more events, never complete
-        false)));
-    }
-}

package/dist/operators/__tests__/distinct-relays.test.d.ts

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

package/dist/operators/__tests__/distinct-relays.test.js

@@ -1,75 +0,0 @@
-import { describe, it, expect, vi } from "vitest";
-import { Subject } from "rxjs";
-import { distinctRelays } from "../distinct-relays.js";
-describe("distinctRelays", () => {
-    it("should filter out messages with same relay within timeout window", () => {
-        const fn = vi.fn();
-        const source$ = new Subject();
-        source$.pipe(distinctRelays((msg) => msg.id, 1000)).subscribe(fn);
-        const message = {
-            id: "123",
-            relays: ["relay1", "relay2"],
-        };
-        // Send message with two relays
-        source$.next(message);
-        expect(fn).toHaveBeenCalledTimes(1);
-        expect(fn).toHaveBeenCalledWith(message);
-        // send message again
-        source$.next({ ...message });
-        // should not call again
-        expect(fn).toHaveBeenCalledTimes(1);
-    });
-    it("should only remove duplicate relays in timeout window", () => {
-        const fn = vi.fn();
-        const source$ = new Subject();
-        source$.pipe(distinctRelays((msg) => msg.id, 1000)).subscribe(fn);
-        const message = {
-            id: "123",
-            relays: ["relay1", "relay2"],
-        };
-        // Send message with two relays
-        source$.next(message);
-        expect(fn).toHaveBeenCalledTimes(1);
-        expect(fn).toHaveBeenCalledWith(message);
-        // send message again
-        source$.next({ id: "123", relays: ["relay1", "relay3"] });
-        // should not call again
-        expect(fn).toHaveBeenCalledTimes(2);
-        expect(fn).toHaveBeenCalledWith({ id: "123", relays: ["relay3"] });
-    });
-    it("should filter out duplicate messages without relays in timeout", () => {
-        const fn = vi.fn();
-        const source$ = new Subject();
-        source$.pipe(distinctRelays((msg) => msg.id, 1000)).subscribe(fn);
-        const message = { id: "123" };
-        // Send message with two relays
-        source$.next(message);
-        expect(fn).toHaveBeenCalledTimes(1);
-        expect(fn).toHaveBeenCalledWith(message);
-        // send message again
-        source$.next({ ...message });
-        // should not call again
-        expect(fn).toHaveBeenCalledTimes(1);
-    });
-    it("should treat messages with relays severalty then messages without", () => {
-        const fn = vi.fn();
-        const source$ = new Subject();
-        source$.pipe(distinctRelays((msg) => msg.id, 1000)).subscribe(fn);
-        const withRelays = {
-            id: "123",
-            relays: ["relay1", "relay2"],
-        };
-        const withoutRelays = {
-            id: "123",
-        };
-        // Send message with two relays
-        source$.next(withoutRelays);
-        expect(fn).toHaveBeenCalledTimes(1);
-        expect(fn).toHaveBeenCalledWith(withoutRelays);
-        // send message with relays
-        source$.next(withRelays);
-        // should not call again
-        expect(fn).toHaveBeenCalledTimes(2);
-        expect(fn).toHaveBeenCalledWith(withRelays);
-    });
-});

package/dist/operators/__tests__/generator-sequence.test.d.ts

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