applesauce-loaders 0.10.0 → 0.12.0

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

@@ -0,0 +1,76 @@
+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/tag-value-loader.d.ts

@@ -0,0 +1,33 @@
+import { EventPacket, RxNostr } from "rx-nostr";
+import { logger } from "applesauce-core";
+import { CacheRequest, Loader } from "./loader.js";
+export type TabValuePointer = {
+    /** The value of the tag to load */
+    value: string;
+    /** The relays to load from */
+    relays?: string[];
+    /** bypass the cache */
+    force?: boolean;
+};
+export type TagValueLoaderOptions = {
+    /** the name of this loader (for debugging) */
+    name?: string;
+    /**
+     * Time interval to buffer requests in ms
+     * @default 1000
+     */
+    bufferTime?: number;
+    /** Restrict queries to specific kinds */
+    kinds?: number[];
+    /** Restrict queries to specific authors */
+    authors?: string[];
+    /** Restrict queries since */
+    since?: number;
+    /** Method used to load from the cache */
+    cacheRequest?: CacheRequest;
+};
+export declare class TagValueLoader extends Loader<TabValuePointer, EventPacket> {
+    name: string;
+    protected log: typeof logger;
+    constructor(rxNostr: RxNostr, tagName: string, opts?: TagValueLoaderOptions);
+}

package/dist/loaders/tag-value-loader.js

@@ -0,0 +1,75 @@
+import { createRxOneshotReq } from "rx-nostr";
+import { bufferTime, filter, map, merge, mergeMap, tap } from "rxjs";
+import { markFromCache } from "applesauce-core/helpers";
+import { logger } from "applesauce-core";
+import { Loader } from "./loader.js";
+import { distinctRelaysBatch } from "../operators/distinct-relays.js";
+import { getDefaultReadRelays } from "../helpers/rx-nostr.js";
+import { unique } from "../helpers/array.js";
+export class TagValueLoader extends Loader {
+    name;
+    log = logger.extend("TagValueLoader");
+    constructor(rxNostr, tagName, opts) {
+        const filterTag = `#${tagName}`;
+        super((source) => source.pipe(
+        // batch the pointers
+        bufferTime(opts?.bufferTime ?? 1000), 
+        // filter out empty batches
+        filter((pointers) => pointers.length > 0), 
+        // only request from each relay once
+        distinctRelaysBatch((m) => m.value), 
+        // batch pointers into requests
+        mergeMap((pointers) => {
+            const baseFilter = {};
+            if (opts?.kinds)
+                baseFilter.kinds = opts.kinds;
+            if (opts?.since)
+                baseFilter.since = opts.since;
+            if (opts?.authors)
+                baseFilter.authors = opts.authors;
+            // build request map for relays
+            const requestMap = pointers.reduce((map, pointer) => {
+                const relays = pointer.relays ?? getDefaultReadRelays(rxNostr);
+                for (const relay of relays) {
+                    if (!map[relay]) {
+                        // create new filter for relay
+                        const filter = { ...baseFilter, [filterTag]: [pointer.value] };
+                        map[relay] = [filter];
+                    }
+                    else {
+                        // map for relay already exists, add the tag value
+                        const filter = map[relay][0];
+                        filter[filterTag].push(pointer.value);
+                    }
+                }
+                return map;
+            }, {});
+            let fromCache = 0;
+            const cacheRequest = opts
+                ?.cacheRequest?.([{ ...baseFilter, [filterTag]: unique(pointers.map((p) => p.value)) }])
+                .pipe(
+            // mark the event as from the cache
+            tap({
+                next: (event) => {
+                    markFromCache(event);
+                    fromCache++;
+                },
+                complete: () => {
+                    if (fromCache > 0)
+                        this.log(`Loaded ${fromCache} from cache`);
+                },
+            }), 
+            // convert to event packets
+            map((e) => ({ event: e, from: "", subId: "replaceable-loader", type: "EVENT" })));
+            const requests = Object.entries(requestMap).map(([relay, filters]) => {
+                const req = createRxOneshotReq({ filters });
+                return rxNostr.use(req, { on: { relays: [relay] } });
+            });
+            this.log(`Requesting ${pointers.length} tag values from ${requests.length} relays`);
+            return cacheRequest ? merge(cacheRequest, ...requests) : merge(...requests);
+        })));
+        // create a unique logger for this instance
+        this.name = opts?.name ?? "";
+        this.log = this.log.extend(opts?.kinds ? `${this.name} ${filterTag} (${opts?.kinds?.join(",")})` : `${this.name} ${filterTag}`);
+    }
+}

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

@@ -0,0 +1,22 @@
+import { EventPacket, RxNostr } from "rx-nostr";
+import { BehaviorSubject } from "rxjs";
+import { logger } from "applesauce-core";
+import { RelayTimelineLoader, TimelessFilter } from "./relay-timeline-loader.js";
+import { CacheRequest, Loader, RelayFilterMap } from "./loader.js";
+import { CacheTimelineLoader } from "./cache-timeline-loader.js";
+export type TimelineLoaderOptions = {
+    limit?: number;
+    cacheRequest?: CacheRequest;
+};
+/** A multi-relay timeline loader that can be used to load a timeline from multiple relays */
+export declare class TimelineLoader extends Loader<number | undefined, EventPacket> {
+    id: string;
+    loading$: BehaviorSubject<boolean>;
+    get loading(): boolean;
+    requests: RelayFilterMap<TimelessFilter>;
+    protected log: typeof logger;
+    protected cache?: CacheTimelineLoader;
+    protected loaders: Map<string, RelayTimelineLoader>;
+    constructor(rxNostr: RxNostr, requests: RelayFilterMap<TimelessFilter>, opts?: TimelineLoaderOptions);
+    static simpleFilterMap(relays: string[], filters: TimelessFilter[]): RelayFilterMap<TimelessFilter>;
+}

package/dist/loaders/timeline-loader.js

@@ -0,0 +1,56 @@
+import { BehaviorSubject, combineLatest, connect, merge, tap } from "rxjs";
+import { logger } from "applesauce-core";
+import { mergeFilters } from "applesauce-core/helpers";
+import { nanoid } from "nanoid";
+import { RelayTimelineLoader } from "./relay-timeline-loader.js";
+import { Loader } from "./loader.js";
+import { CacheTimelineLoader } from "./cache-timeline-loader.js";
+/** A multi-relay timeline loader that can be used to load a timeline from multiple relays */
+export class TimelineLoader extends Loader {
+    id = nanoid(8);
+    loading$ = new BehaviorSubject(false);
+    get loading() {
+        return this.loading$.value;
+    }
+    requests;
+    log = logger.extend("TimelineLoader");
+    cache;
+    loaders;
+    constructor(rxNostr, requests, opts) {
+        const loaders = new Map();
+        // create cache loader
+        const cache = opts?.cacheRequest
+            ? new CacheTimelineLoader(opts.cacheRequest, [mergeFilters(...Object.values(requests).flat())], opts)
+            : undefined;
+        // create loaders
+        for (const [relay, filters] of Object.entries(requests)) {
+            loaders.set(relay, new RelayTimelineLoader(rxNostr, relay, filters, opts));
+        }
+        const allLoaders = cache ? [cache, ...loaders.values()] : Array.from(loaders.values());
+        super((source) => {
+            // observable that triggers the loaders based on cursor
+            const trigger$ = source.pipe(tap((cursor) => {
+                for (const loader of allLoaders) {
+                    // load the next page if cursor is past loader cursor
+                    if (!cursor || !Number.isFinite(cursor) || cursor <= loader.cursor)
+                        loader.next();
+                }
+            }));
+            // observable that handles updating the loading state
+            const loading$ = combineLatest(allLoaders.map((l) => l.loading$)).pipe(
+            // set loading to true as long as one loader is still loading
+            tap((loading) => this.loading$.next(loading.some((v) => v === true))));
+            // observable that merges all the outputs of the loaders
+            const events$ = merge(...allLoaders.map((l) => l.observable));
+            // subscribe to all observables but only return the results of events$
+            return merge(trigger$, loading$, events$).pipe(connect((_shared$) => events$));
+        });
+        this.requests = requests;
+        this.cache = cache;
+        this.loaders = loaders;
+        this.log = this.log.extend(this.id);
+    }
+    static simpleFilterMap(relays, filters) {
+        return relays.reduce((map, relay) => ({ ...map, [relay]: filters }), {});
+    }
+}

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

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

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

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

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

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

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

package/dist/operators/__tests__/generator-sequence.test.js

@@ -0,0 +1,38 @@
+import { expect, it } from "vitest";
+import { lastValueFrom, of, toArray } from "rxjs";
+import { TestScheduler } from "rxjs/testing";
+import { generatorSequence } from "../generator-sequence.js";
+let testScheduler = new TestScheduler((actual, expected) => {
+    expect(actual).toEqual(expected);
+});
+it("should work with normal generator functions", () => {
+    testScheduler.run(({ expectObservable }) => {
+        function* normalGenerator(value) {
+            yield of(value + 1);
+            yield of(value + 2);
+            yield of(value + 3);
+            yield value + 4;
+        }
+        const source$ = of(1).pipe(generatorSequence(normalGenerator));
+        // Define expected marble diagram
+        const expectedMarble = "(abcd|)";
+        const expectedValues = {
+            a: 2,
+            b: 3,
+            c: 4,
+            d: 5,
+        };
+        expectObservable(source$).toBe(expectedMarble, expectedValues);
+    });
+});
+it("should work with async generator functions", async () => {
+    async function* asyncGenerator(value) {
+        yield of(`${value}-1`);
+        yield of(`${value}-2`);
+        yield of(`${value}-3`);
+        yield `${value}-4`;
+    }
+    const source$ = of("test").pipe(generatorSequence(asyncGenerator));
+    const expectedValues = ["test-1", "test-2", "test-3", "test-4"];
+    expect(await lastValueFrom(source$.pipe(toArray()))).toEqual(expectedValues);
+});

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

@@ -0,0 +1,4 @@
+import { OperatorFunction } from "rxjs";
+import { MessageWithRelay } from "../helpers/pointer.js";
+export declare function distinctRelays<T extends MessageWithRelay>(keyFn: (message: T) => string, timeout?: number): OperatorFunction<T, T>;
+export declare function distinctRelaysBatch<T extends MessageWithRelay>(keyFn: (message: T) => string, timeout?: number): OperatorFunction<T[], T[]>;

package/dist/operators/distinct-relays.js

@@ -0,0 +1,14 @@
+import { filter, map } from "rxjs";
+import { removePreviouslyUsedRelays } from "../helpers/pointer.js";
+export function distinctRelays(keyFn, timeout = 60_000) {
+    return (source$) => {
+        const cache = new Map();
+        return source$.pipe(map((message) => removePreviouslyUsedRelays(message, keyFn, cache, timeout)), filter((message) => message !== null));
+    };
+}
+export function distinctRelaysBatch(keyFn, timeout = 60_000) {
+    return (source$) => {
+        const cache = new Map();
+        return source$.pipe(map((batch) => batch.map((m) => removePreviouslyUsedRelays(m, keyFn, cache, timeout)).filter((m) => m !== null)));
+    };
+}

package/dist/operators/distinct-timeout.d.ts

@@ -0,0 +1,3 @@
+import { OperatorFunction } from "rxjs";
+/** Filters out duplicate values based on a key getter and a TTL */
+export declare function distinctTimeout<T>(keyFn: (value: T) => string, ttl?: number): OperatorFunction<T, T>;

package/dist/operators/distinct-timeout.js

@@ -0,0 +1,15 @@
+import { LRU } from "applesauce-core/helpers";
+import { filter } from "rxjs";
+/** Filters out duplicate values based on a key getter and a TTL */
+export function distinctTimeout(keyFn, ttl = 1000) {
+    const seen = new LRU(undefined, ttl);
+    return (source) => source.pipe(filter((value) => {
+        const key = keyFn(value);
+        if (seen.has(key))
+            return false;
+        else {
+            seen.set(key, Date.now());
+            return true;
+        }
+    }));
+}

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

@@ -1,3 +1,3 @@
 import { Observable, OperatorFunction } from "rxjs";
 /** Keeps retrying a value until the generator returns */
-export declare function generatorSequence<T, R>(createGenerator: (value: T) => Generator<Observable<R>, undefined, R[] | undefined>): OperatorFunction<T, R>;
+export declare function generatorSequence<Input, Result>(createGenerator: (value: Input) => Generator<Observable<Result> | Result, void, Result[] | undefined> | AsyncGenerator<Observable<Result> | Result, void, Result[] | undefined>, shouldComplete?: boolean): OperatorFunction<Input, Result>;

package/dist/operators/generator-sequence.js

@@ -1,45 +1,53 @@
-import { Observable } from "rxjs";
+import { isObservable, Observable } from "rxjs";
 /** Keeps retrying a value until the generator returns */
-export function generatorSequence(createGenerator) {
+export function generatorSequence(createGenerator, shouldComplete = true) {
     return (source) => {
         return new Observable((observer) => {
-            let complete = false;
-            const sub = source.subscribe({
-                next: (value) => {
-                    const generator = createGenerator(value);
-                    const next = (prevResults) => {
-                        const result = generator.next(prevResults);
+            return source.subscribe((value) => {
+                const generator = createGenerator(value);
+                const nextSequence = (prevResults) => {
+                    const p = generator.next(prevResults);
+                    const handleResult = (result) => {
                         // generator complete, exit
-                        if (result.done)
+                        if (result.done) {
+                            if (shouldComplete)
+                                observer.complete();
                             return;
+                        }
                         const results = [];
-                        result.value.subscribe({
-                            next: (v) => {
-                                // track results and pass along values
-                                results.push(v);
-                                observer.next(v);
-                            },
-                            error: (err) => {
-                                observer.error(err);
-                            },
-                            complete: () => {
-                                // if the upstream observable was complete. exit
-                                if (complete)
-                                    return observer.complete();
-                                // run next step
-                                next(results);
-                            },
-                        });
+                        if (isObservable(result.value)) {
+                            result.value.subscribe({
+                                next: (v) => {
+                                    // track results and pass along values
+                                    results.push(v);
+                                    observer.next(v);
+                                },
+                                error: (err) => {
+                                    observer.error(err);
+                                },
+                                complete: () => {
+                                    // run next step
+                                    nextSequence(results);
+                                },
+                            });
+                        }
+                        else {
+                            results.push(result.value);
+                            observer.next(result.value);
+                            nextSequence(results);
+                        }
                     };
-                    // start running steps
-                    next();
-                },
-                complete: () => {
-                    // source is complete
-                    complete = true;
-                },
+                    // if its an async generator, wait for the promise
+                    if (p instanceof Promise)
+                        p.then(handleResult, (err) => {
+                            observer.error(err);
+                        });
+                    else
+                        handleResult(p);
+                };
+                // start running steps
+                nextSequence();
             });
-            return () => sub.unsubscribe();
         });
     };
 }

package/dist/operators/index.d.ts

@@ -1,4 +1,3 @@
+export * from "./distinct-relays.js";
+export * from "./distinct-timeout.js";
 export * from "./generator-sequence.js";
-export * from "./relay-request.js";
-export * from "./max-filters.js";
-export * from "./address-pointers-request.js";

package/dist/operators/index.js

@@ -1,4 +1,3 @@
+export * from "./distinct-relays.js";
+export * from "./distinct-timeout.js";
 export * from "./generator-sequence.js";
-export * from "./relay-request.js";
-export * from "./max-filters.js";
-export * from "./address-pointers-request.js";