applesauce-loaders 4.0.0 → 4.2.0

package/dist/helpers/cache.d.ts

@@ -1,5 +1,5 @@
-import { Observable } from "rxjs";
 import { Filter, NostrEvent } from "nostr-tools";
+import { Observable } from "rxjs";
 import { CacheRequest } from "../types.js";
 /** Calls the cache request and converts the reponse into an observable */
 export declare function unwrapCacheRequest(request: CacheRequest, filters: Filter[]): Observable<NostrEvent>;

package/dist/helpers/cache.js

@@ -1,18 +1,24 @@
-import { from, isObservable, of, switchMap, tap } from "rxjs";
 import { markFromCache } from "applesauce-core/helpers";
+import { from, isObservable, of, switchMap, tap } from "rxjs";
 /** Calls the cache request and converts the reponse into an observable */
 export function unwrapCacheRequest(request, filters) {
     const result = request(filters);
     if (isObservable(result))
         return result;
-    else if (result instanceof Promise)
-        return from(result).pipe(switchMap((v) => (Array.isArray(v) ? from(v) : of(v))));
-    else if (Array.isArray(result))
+    else if (result instanceof Promise) {
+        return from(result).pipe(switchMap((v) => (Array.isArray(v) ? from(v) : of(v))), tap((e) => markFromCache(e)));
+    }
+    else if (Array.isArray(result)) {
+        for (const event of result)
+            markFromCache(event);
         return from(result);
-    else
+    }
+    else {
+        markFromCache(result);
         return of(result);
+    }
 }
 /** Calls a cache request method with filters and marks all returned events as being from the cache */
 export function makeCacheRequest(request, filters) {
-    return unwrapCacheRequest(request, filters).pipe(tap((e) => markFromCache(e)));
+    return unwrapCacheRequest(request, filters);
 }

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

@@ -1,4 +1,4 @@
-import { mapEventsToStore } from "applesauce-core";
+import { filterDuplicateEvents } from "applesauce-core";
 import { NostrEvent } from "nostr-tools";
 import { Observable } from "rxjs";
 import { CacheRequest, NostrRequest, UpstreamPool } from "../types.js";
@@ -33,8 +33,8 @@ export type AddressLoaderOptions = Partial<{
     bufferTime: number;
     /** Max buffer size ( default 200 ) */
     bufferSize: number;
-    /** An event store used to deduplicate events */
-    eventStore?: Parameters<typeof mapEventsToStore>[0];
+    /** An event store used to deduplicate events. Set to null to disable deduplication */
+    eventStore?: Parameters<typeof filterDuplicateEvents>[0] | null;
     /** A method used to load events from a local cache */
     cacheRequest: CacheRequest;
     /** Whether to follow relay hints ( default true ) */

package/dist/loaders/address-loader.js

@@ -1,6 +1,6 @@
-import { mapEventsToStore } from "applesauce-core";
+import { EventMemory, filterDuplicateEvents } from "applesauce-core";
 import { createReplaceableAddress, getReplaceableAddress, getReplaceableIdentifier, isReplaceable, mergeRelaySets, } from "applesauce-core/helpers";
-import { bufferTime, catchError, EMPTY } from "rxjs";
+import { bufferTime, catchError, EMPTY, identity } from "rxjs";
 import { createFiltersFromAddressPointers, isLoadableAddressPointer } from "../helpers/address-pointer.js";
 import { makeCacheRequest } from "../helpers/cache.js";
 import { batchLoader, unwrap } from "../helpers/loaders.js";
@@ -116,6 +116,6 @@ export function createAddressLoader(pool, opts) {
     (pointer, event) => event.kind === pointer.kind &&
         event.pubkey === pointer.pubkey &&
         (pointer.identifier ? getReplaceableIdentifier(event) === pointer.identifier : true), 
-    // Pass all events through the store if defined
-    opts?.eventStore && mapEventsToStore(opts.eventStore));
+    // Pass all events through the store if provided, or use EventMemory for deduplication by default
+    opts?.eventStore === null ? identity : filterDuplicateEvents(opts?.eventStore || new EventMemory()));
 }

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

@@ -1,4 +1,4 @@
-import { mapEventsToStore } from "applesauce-core";
+import { filterDuplicateEvents } from "applesauce-core";
 import { NostrEvent } from "nostr-tools";
 import { EventPointer } from "nostr-tools/nip19";
 import { Observable } from "rxjs";
@@ -23,8 +23,8 @@ export type EventPointerLoaderOptions = Partial<{
     bufferTime: number;
     /** Max buffer size ( default 200 ) */
     bufferSize: number;
-    /** An event store used to deduplicate events */
-    eventStore?: Parameters<typeof mapEventsToStore>[0];
+    /** An event store used to deduplicate events. Set to null to disable deduplication */
+    eventStore?: Parameters<typeof filterDuplicateEvents>[0] | null;
     /** A method used to load events from a local cache */
     cacheRequest: CacheRequest;
     /** Whether to follow relay hints ( default true ) */

package/dist/loaders/event-loader.js

@@ -1,5 +1,5 @@
-import { mapEventsToStore } from "applesauce-core";
-import { bufferTime, catchError, EMPTY, merge, tap } from "rxjs";
+import { EventMemory, filterDuplicateEvents } from "applesauce-core";
+import { bufferTime, catchError, EMPTY, identity, merge, tap } from "rxjs";
 import { makeCacheRequest } from "../helpers/cache.js";
 import { consolidateEventPointers } from "../helpers/event-pointer.js";
 import { batchLoader, unwrap } from "../helpers/loaders.js";
@@ -85,6 +85,6 @@ export function createEventLoader(pool, opts) {
     opts?.extraRelays ? relaysEventsLoader(request, opts.extraRelays) : undefined), 
     // Filter resutls based on requests
     (pointer, event) => event.id === pointer.id, 
-    // Pass all events through the store if defined
-    opts?.eventStore && mapEventsToStore(opts.eventStore));
+    // Pass all events through the store if provided, or use EventMemory for deduplication by default
+    opts?.eventStore === null ? identity : filterDuplicateEvents(opts?.eventStore || new EventMemory()));
 }

package/dist/loaders/tag-value-loader.d.ts

@@ -1,4 +1,4 @@
-import { mapEventsToStore } from "applesauce-core";
+import { filterDuplicateEvents } from "applesauce-core";
 import { NostrEvent } from "nostr-tools";
 import { Observable } from "rxjs";
 import { CacheRequest, NostrRequest, UpstreamPool } from "../types.js";
@@ -25,8 +25,8 @@ export type TagValueLoaderOptions = {
     cacheRequest?: CacheRequest;
     /** An array of relays to always fetch from */
     extraRelays?: string[] | Observable<string[]>;
-    /** An event store used to deduplicate events */
-    eventStore?: Parameters<typeof mapEventsToStore>[0];
+    /** An event store used to deduplicate events. Set to null to disable deduplication */
+    eventStore?: Parameters<typeof filterDuplicateEvents>[0] | null;
 };
 export type TagValueLoader = (pointer: TagValuePointer) => Observable<NostrEvent>;
 /** Creates a loader that gets tag values from the cache */

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

@@ -1,6 +1,6 @@
-import { mapEventsToStore } from "applesauce-core";
+import { EventMemory, filterDuplicateEvents } from "applesauce-core";
 import { mergeRelaySets } from "applesauce-core/helpers";
-import { bufferTime, EMPTY, merge } from "rxjs";
+import { bufferTime, EMPTY, identity, merge } from "rxjs";
 import { unique } from "../helpers/array.js";
 import { makeCacheRequest } from "../helpers/cache.js";
 import { batchLoader, unwrap } from "../helpers/loaders.js";
@@ -70,6 +70,6 @@ export function createTagValueLoader(pool, tagName, opts) {
     }, 
     // Filter results based on requests
     (pointer, event) => event.tags.some((tag) => tag[0] === tagName && tag[1] === pointer.value), 
-    // Pass all events through the store if defined
-    opts?.eventStore && mapEventsToStore(opts?.eventStore));
+    // Pass all events through the store if provided, or use EventMemory for deduplication by default
+    opts?.eventStore === null ? identity : filterDuplicateEvents(opts?.eventStore || new EventMemory()));
 }

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

@@ -1,24 +1,73 @@
 import { mapEventsToStore } from "applesauce-core";
-import { NostrEvent } from "nostr-tools";
-import { Observable } from "rxjs";
-import { CacheRequest, FilterRequest, NostrRequest, TimelessFilter, UpstreamPool } from "../types.js";
+import { FilterMap, OutboxMap, ProfilePointer } from "applesauce-core/helpers";
+import { Filter, NostrEvent } from "nostr-tools";
+import { Observable, OperatorFunction } from "rxjs";
+import { CacheRequest, TimelessFilter, UpstreamPool } from "../types.js";
 /** A loader that optionally takes a timestamp to load till and returns a stream of events */
-export type TimelineLoader = (since?: number) => Observable<NostrEvent>;
+export type TimelineLoader = (since?: number | TimelineWindow) => Observable<NostrEvent>;
+/**
+ * The current `since` value of the timeline loader
+ * `undefined` is used to initialize the loader to "now"
+ * -Infinity (for since) and Infinity (for until) should be used to force loading the next block of events
+ */
+export type TimelineWindow = {
+    since?: number;
+    until?: number;
+};
 /** Common options for timeline loaders */
 export type CommonTimelineLoaderOptions = Partial<{
     limit: number;
+    /** Logger to extend */
+    logger?: debug.Debugger;
 }>;
+/**
+ * Watches for changes in the window and loads blocks of events going backward
+ * NOTE: this operator is stateful
+ */
+export declare function loadBackwardBlocks(request: (until?: number) => Observable<NostrEvent>, opts?: CommonTimelineLoaderOptions): OperatorFunction<TimelineWindow, NostrEvent>;
+/**
+ * Watches for changes in the window and loads blocks of events going forward
+ * NOTE: this operator is stateful
+ */
+export declare function loadForwardBlocks(request: (since?: number) => Observable<NostrEvent>, opts?: CommonTimelineLoaderOptions): OperatorFunction<TimelineWindow, NostrEvent>;
 /** A loader that loads blocks of events until none are returned or the since timestamp is reached */
-export declare function filterBlockLoader(request: FilterRequest, filters: TimelessFilter[], opts?: CommonTimelineLoaderOptions): TimelineLoader;
-/** Creates a loader that loads a timeline from a cache */
-export declare function cacheTimelineLoader(request: CacheRequest, filters: TimelessFilter[], opts?: CommonTimelineLoaderOptions): TimelineLoader;
-/** Creates a timeline loader that loads the same filters from multiple relays */
-export declare function relaysTimelineLoader(request: NostrRequest, relays: string[], filters: TimelessFilter[], opts?: CommonTimelineLoaderOptions): TimelineLoader;
+export declare function loadBlocksForTimelineWindow(request: (base: Filter) => Observable<NostrEvent>, opts?: CommonTimelineLoaderOptions): OperatorFunction<TimelineWindow, NostrEvent>;
+/** Loads timeline blocs from cache using a cache request */
+export declare function loadBlocksFromCache(request: CacheRequest, filters: TimelessFilter[] | TimelessFilter, opts?: CommonTimelineLoaderOptions): OperatorFunction<TimelineWindow, NostrEvent>;
+/** Loads timeline blocs from relays using a pool or request method */
+export declare function loadBlocksFromRelays(pool: UpstreamPool, relays: string[], filters: TimelessFilter[] | TimelessFilter, opts?: CommonTimelineLoaderOptions): OperatorFunction<TimelineWindow, NostrEvent>;
+/** Loads timeline blocs from relay set using a pool or request method */
+export declare function loadBlocksFromRelay(pool: UpstreamPool, relay: string, filters: TimelessFilter[] | TimelessFilter, opts?: CommonTimelineLoaderOptions): OperatorFunction<TimelineWindow, NostrEvent>;
+/** Loads timeline blocks from a map of relays and filters */
+export declare function loadBlocksFromFilterMap(pool: UpstreamPool, relayMap: FilterMap | Observable<FilterMap>, opts?: CommonTimelineLoaderOptions): OperatorFunction<TimelineWindow, NostrEvent>;
+/** Loads timeline blocks from an {@link OutboxMap} and {@link Filter} or a function that projects users to a filter */
+export declare function loadBlocksFromOutboxMap(pool: UpstreamPool, outboxes: OutboxMap | Observable<OutboxMap>, filter: TimelessFilter | ((users: ProfilePointer[]) => TimelessFilter | TimelessFilter[]), opts?: CommonTimelineLoaderOptions): OperatorFunction<TimelineWindow, NostrEvent>;
+/** Loads timeline blocks from a {@link CacheRequest} using a {@link OutboxMap} and filters */
+export declare function loadBlocksFromOutboxMapCache(cache: CacheRequest, outboxes: OutboxMap | Observable<OutboxMap>, filter: TimelessFilter | ((users: ProfilePointer[]) => TimelessFilter | TimelessFilter[]), opts?: CommonTimelineLoaderOptions): OperatorFunction<TimelineWindow, NostrEvent>;
+/** Options for the create timeline loader methods */
 export type TimelineLoaderOptions = Partial<{
     /** A method used to load the timeline from the cache */
     cache: CacheRequest;
     /** An event store to pass all the events to */
     eventStore?: Parameters<typeof mapEventsToStore>[0];
 }> & CommonTimelineLoaderOptions;
-/** A common timeline loader that takes an array of relays and a cache method */
+/** @deprecated Use the {@link loadBlocksFromCache} operator instead */
+export declare function cacheTimelineLoader(request: CacheRequest, filters: TimelessFilter[] | TimelessFilter, opts?: CommonTimelineLoaderOptions): TimelineLoader;
+/** @deprecated Use the {@link createTimelineLoader} operator instead */
+export declare function relaysTimelineLoader(pool: UpstreamPool, relays: string[], filters: TimelessFilter[] | TimelessFilter, opts?: CommonTimelineLoaderOptions): TimelineLoader;
+/**
+ * Creates a {@link TimelineLoader} that loads events from multiple relays and a cache
+ * @param pool - The upstream pool to use
+ * @param relays - The relays to load from
+ * @param filters - The filters to use
+ * @param opts - The options for the timeline loader
+ */
 export declare function createTimelineLoader(pool: UpstreamPool, relays: string[], filters: TimelessFilter[] | TimelessFilter, opts?: TimelineLoaderOptions): TimelineLoader;
+/**
+ * Creates a {@link TimelineLoader} that loads events for a {@link OutboxMap} or an observable of {@link OutboxMap}
+ * @param pool - The upstream pool to use
+ * @param outboxMap - An {@link OutboxMap} or an observable of {@link OutboxMap}
+ * @param filter - A function to create filters for a set of users
+ * @param opts - The options for the timeline loader
+ */
+export declare function createOutboxTimelineLoader(pool: UpstreamPool, outboxes: OutboxMap | Observable<OutboxMap>, filter: TimelessFilter | ((users: ProfilePointer[]) => TimelessFilter | TimelessFilter[]), opts?: TimelineLoaderOptions): TimelineLoader;

package/dist/loaders/timeline-loader.js

@@ -1,50 +1,279 @@
-import { mapEventsToStore } from "applesauce-core";
-import { EMPTY, finalize, identity, merge, tap } from "rxjs";
+import { logger as baseLogger, EventMemory, filterDuplicateEvents } from "applesauce-core";
+import { createFilterMap, isFilterEqual, mergeFilters, } from "applesauce-core/helpers";
+import { nanoid } from "nanoid";
+import { BehaviorSubject, distinctUntilChanged, EMPTY, filter, finalize, identity, isObservable, map, merge, mergeMap, Observable, of, share, switchMap, tap, } from "rxjs";
 import { makeCacheRequest } from "../helpers/cache.js";
 import { wrapUpstreamPool } from "../helpers/upstream.js";
-/** A loader that loads blocks of events until none are returned or the since timestamp is reached */
-export function filterBlockLoader(request, filters, opts) {
-    let cursor = Infinity;
-    let complete = false;
-    return (since) => {
-        if (complete)
-            return EMPTY;
-        if (since !== undefined && cursor <= since)
-            return EMPTY;
-        // Keep loading blocks until none are returned or an event is found that is ealier then the new cursor
-        const withTime = filters.map((filter) => ({
-            ...filter,
-            limit: filter.limit || opts?.limit,
-            until: cursor !== Infinity ? cursor : undefined,
+/**
+ * Watches for changes in the window and loads blocks of events going backward
+ * NOTE: this operator is stateful
+ */
+export function loadBackwardBlocks(request, opts) {
+    return (source) => {
+        const log = opts?.logger?.extend("backward").extend(nanoid(8));
+        let cursor = undefined;
+        let loading = false;
+        let complete = false;
+        return source.pipe(filter(({ since, until }) => {
+            // Once complete, prevent further requests
+            if (complete)
+                return false;
+            // If max is unset, initialize to until
+            if (cursor === undefined && until !== undefined && Number.isFinite(until))
+                cursor = until;
+            // Skip loads if since is still in range
+            if (
+            // Ignore undefined since values
+            since === undefined ||
+                // If number is finite and in the loaded range, skip
+                (Number.isFinite(since) && cursor !== undefined && since <= cursor))
+                return false;
+            // Don't load blocks in parallel
+            if (loading)
+                return false;
+            return true;
+        }), 
+        // NOTE: use mergeMap here to ensure old requests continue to load
+        mergeMap(() => {
+            // Set loading lock
+            loading = true;
+            // Count returned events so complete set
+            let count = 0;
+            log?.(`Loading block since:${cursor}`);
+            // Request the next block of events
+            return request(cursor).pipe(tap((event) => {
+                count++;
+                // Track the minimum created_at seen from the events
+                cursor = Math.min(event.created_at, cursor ?? Infinity);
+            }), finalize(() => {
+                loading = false;
+                complete = count === 0;
+                log?.(`Found ${count} events`);
+                if (complete)
+                    log?.("Complete");
+            }));
         }));
-        let count = 0;
-        // Load the next block of events
-        return request(withTime).pipe(tap((event) => {
-            // Update the cursor to the oldest event
-            cursor = Math.min(event.created_at - 1, cursor);
-            count++;
-        }), finalize(() => {
-            // Set the loader to complete if no events are returned
-            if (count === 0)
-                complete = true;
+    };
+}
+/**
+ * Watches for changes in the window and loads blocks of events going forward
+ * NOTE: this operator is stateful
+ */
+export function loadForwardBlocks(request, opts) {
+    return (source) => {
+        const log = opts?.logger?.extend("forward").extend(nanoid(8));
+        let cursor = undefined;
+        let loading = false;
+        let complete = false;
+        return source.pipe(filter(({ since, until }) => {
+            // Once complete, prevent further requests
+            if (complete)
+                return false;
+            // If min is unset, initialize to since
+            if (cursor === undefined && since !== undefined && Number.isFinite(since))
+                cursor = since;
+            // Skip loads if until is still in range
+            if (
+            // Ignore undefined until values
+            until === undefined ||
+                // If number is finite and in the loaded range, skip
+                (Number.isFinite(until) && cursor !== undefined && until <= cursor))
+                return false;
+            // Don't load blocks in parallel
+            if (loading)
+                return false;
+            return true;
+        }), 
+        // NOTE: use mergeMap here to ensure old requests continue to load
+        mergeMap(() => {
+            // Set loading lock
+            loading = true;
+            // Count returned events so complete set
+            let count = 0;
+            log?.(`Loading block until:${cursor}`);
+            // Request the next block of events
+            return request(cursor).pipe(tap((event) => {
+                count++;
+                // Track the maximum created_at seen from the events
+                cursor = Math.max(event.created_at, cursor ?? -Infinity);
+            }), finalize(() => {
+                loading = false;
+                complete = count === 0;
+                log?.(`Found ${count} events`);
+                if (complete)
+                    log?.("Complete");
+            }));
         }));
     };
 }
-/** Creates a loader that loads a timeline from a cache */
-export function cacheTimelineLoader(request, filters, opts) {
-    return filterBlockLoader((filters) => makeCacheRequest(request, filters), filters, opts);
+/** A loader that loads blocks of events until none are returned or the since timestamp is reached */
+export function loadBlocksForTimelineWindow(request, opts) {
+    return (source) => merge(source.pipe(loadBackwardBlocks((until) => request({ until }), opts)), source.pipe(loadForwardBlocks((since) => request({ since }), opts)));
 }
-/** Creates a timeline loader that loads the same filters from multiple relays */
-export function relaysTimelineLoader(request, relays, filters, opts) {
-    const loaders = relays.map((relay) => filterBlockLoader((f) => request([relay], f), filters, opts));
-    return (since) => merge(...loaders.map((l) => l(since)));
+/** Loads timeline blocs from cache using a cache request */
+export function loadBlocksFromCache(request, filters, opts) {
+    if (!Array.isArray(filters))
+        filters = [filters];
+    const logger = opts?.logger?.extend("cache");
+    const loader = (base) => makeCacheRequest(request, 
+    // Create filters from filters, base, and optional limit
+    filters.map((f) => (opts?.limit ? mergeFilters(f, base, { limit: opts.limit }) : mergeFilters(f, base))));
+    return (source) => source.pipe(loadBlocksForTimelineWindow(loader, { ...opts, logger }));
 }
-/** A common timeline loader that takes an array of relays and a cache method */
-export function createTimelineLoader(pool, relays, filters, opts) {
+/** Loads timeline blocs from relays using a pool or request method */
+export function loadBlocksFromRelays(pool, relays, filters, opts) {
+    if (!Array.isArray(filters))
+        filters = [filters];
+    const logger = opts?.logger?.extend("relays");
+    const request = wrapUpstreamPool(pool);
+    const loader = (base) => request(relays, 
+    // Create filters from filters, base, and optional limit
+    filters.map((f) => (opts?.limit ? mergeFilters(f, base, { limit: opts.limit }) : mergeFilters(f, base))));
+    return (source) => source.pipe(loadBlocksForTimelineWindow(loader, { ...opts, logger }));
+}
+/** Loads timeline blocs from relay set using a pool or request method */
+export function loadBlocksFromRelay(pool, relay, filters, opts) {
     if (!Array.isArray(filters))
         filters = [filters];
+    const logger = opts?.logger?.extend(relay);
     const request = wrapUpstreamPool(pool);
-    const cacheLoader = opts?.cache && cacheTimelineLoader(opts.cache, filters, opts);
-    const relayLoader = relaysTimelineLoader(request, relays, filters, opts);
-    return (since) => merge(cacheLoader?.(since) ?? EMPTY, relayLoader?.(since)).pipe(opts?.eventStore ? mapEventsToStore(opts.eventStore) : identity);
+    const loader = (base) => request([relay], 
+    // Create filters from filters, base, and optional limit
+    filters.map((f) => (opts?.limit ? mergeFilters(f, base, { limit: opts.limit }) : mergeFilters(f, base))));
+    return (source) => source.pipe(loadBlocksForTimelineWindow(loader, { ...opts, logger }));
+}
+/** Loads timeline blocks from a map of relays and filters */
+export function loadBlocksFromFilterMap(pool, relayMap, opts) {
+    return (source) => {
+        const map$ = isObservable(relayMap) ? relayMap : of(relayMap);
+        const cache = new Map();
+        const loaders$ = map$.pipe(map((relayMap) => Object.entries(relayMap).map(([relay, filters]) => {
+            const existing = cache.get(relay);
+            if (existing && isFilterEqual(existing.filters, filters))
+                return existing.loader;
+            // Create a new loader for this relay + filter set
+            const loader = source.pipe(loadBlocksFromRelay(pool, relay, filters, opts));
+            cache.set(relay, { filters, loader });
+            return loader;
+        })));
+        return loaders$.pipe(switchMap((loaders) => merge(...loaders)));
+    };
+}
+/** Loads timeline blocks from an {@link OutboxMap} and {@link Filter} or a function that projects users to a filter */
+export function loadBlocksFromOutboxMap(pool, outboxes, filter, opts) {
+    const outboxes$ = isObservable(outboxes) ? outboxes : of(outboxes);
+    // Project outbox map to filter map
+    const filterMap$ = outboxes$.pipe(map((outboxes) => {
+        // Filter is a dynamic method that returns a filter
+        if (typeof filter === "function")
+            return Object.fromEntries(Object.entries(outboxes).map(([relay, users]) => [relay, filter(users)]));
+        // Filter is just a filter
+        return createFilterMap(outboxes, filter);
+    }));
+    // Load blocks from the filter map
+    return loadBlocksFromFilterMap(pool, filterMap$, opts);
+}
+/** Loads timeline blocks from a {@link CacheRequest} using a {@link OutboxMap} and filters */
+export function loadBlocksFromOutboxMapCache(cache, outboxes, filter, opts) {
+    const outboxes$ = isObservable(outboxes) ? outboxes : of(outboxes);
+    // Project outboxes to filters
+    const filters$ = outboxes$.pipe(map((outboxes) => {
+        // Get all pubkeys from all relays
+        const pubkeys = new Set();
+        for (const users of Object.values(outboxes)) {
+            for (const user of users) {
+                pubkeys.add(user.pubkey);
+            }
+        }
+        // Create filters for all the pubkeys
+        if (typeof filter === "function") {
+            const users = Array.from(pubkeys).map((pubkey) => ({ pubkey }));
+            return filter(users);
+        }
+        else {
+            return mergeFilters(filter, { authors: Array.from(pubkeys) });
+        }
+    }), 
+    // Only create a new loader if the filters change
+    distinctUntilChanged((a, b) => isFilterEqual(a, b)));
+    // Load blocks from the filter map
+    return (source) => filters$.pipe(
+    // Every time the filters change, create a new cache loader instance
+    switchMap((filters) => source.pipe(loadBlocksFromCache(cache, filters, opts))));
+}
+/** Internal logic for function based timeline loaders */
+function wrapTimelineLoader(window$, loader$, eventStore) {
+    const singleton$ = loader$.pipe(
+    // Pass all events through the store if provided
+    eventStore === null ? identity : filterDuplicateEvents(eventStore || new EventMemory()), 
+    // Ensure a single subscription to the requests
+    share());
+    return (since) => {
+        // Return the loader so it can be subscribed to
+        return new Observable((observer) => {
+            const sub = singleton$.subscribe(observer);
+            // Once subscribed, update the window
+            if (typeof since === "object" && since !== undefined) {
+                // Pass new window to the loader
+                window$.next(since);
+            }
+            else {
+                // Only update window when this request is subscribed to (prevents window getting lost before subscription)
+                window$.next({
+                    // Default to -Infinity to force loading the next block of events (legacy behavior)
+                    since: since ?? -Infinity,
+                });
+            }
+            return () => sub.unsubscribe();
+        });
+    };
+}
+/** @deprecated Use the {@link loadBlocksFromCache} operator instead */
+export function cacheTimelineLoader(request, filters, opts) {
+    const window$ = new BehaviorSubject({});
+    return wrapTimelineLoader(window$, window$.pipe(loadBlocksFromCache(request, filters, opts)));
+}
+/** @deprecated Use the {@link createTimelineLoader} operator instead */
+export function relaysTimelineLoader(pool, relays, filters, opts) {
+    const window$ = new BehaviorSubject({});
+    return wrapTimelineLoader(window$, window$.pipe(loadBlocksFromRelays(pool, relays, filters, opts)));
+}
+/**
+ * Creates a {@link TimelineLoader} that loads events from multiple relays and a cache
+ * @param pool - The upstream pool to use
+ * @param relays - The relays to load from
+ * @param filters - The filters to use
+ * @param opts - The options for the timeline loader
+ */
+export function createTimelineLoader(pool, relays, filters, opts) {
+    const logger = (opts?.logger ?? baseLogger).extend("timeline").extend(nanoid(4));
+    const window$ = new BehaviorSubject({});
+    // Create cache and relays loaders
+    const cache$ = opts?.cache ? window$.pipe(loadBlocksFromCache(opts.cache, filters, { ...opts, logger })) : EMPTY;
+    // Load blocks from relays
+    const relays$ = window$.pipe(loadBlocksFromRelays(pool, relays, filters, { ...opts, logger }));
+    // Merge the cache and relays loaders
+    const loader$ = merge(cache$, relays$);
+    return wrapTimelineLoader(window$, loader$, opts?.eventStore);
+}
+/**
+ * Creates a {@link TimelineLoader} that loads events for a {@link OutboxMap} or an observable of {@link OutboxMap}
+ * @param pool - The upstream pool to use
+ * @param outboxMap - An {@link OutboxMap} or an observable of {@link OutboxMap}
+ * @param filter - A function to create filters for a set of users
+ * @param opts - The options for the timeline loader
+ */
+export function createOutboxTimelineLoader(pool, outboxes, filter, opts) {
+    const logger = (opts?.logger ?? baseLogger).extend("outbox-timeline").extend(nanoid(4));
+    const window$ = new BehaviorSubject({});
+    // An observable of a cache loader instance for all users
+    const cache$ = opts?.cache
+        ? window$.pipe(loadBlocksFromOutboxMapCache(opts?.cache, outboxes, filter, { ...opts, logger }))
+        : EMPTY;
+    // Load blocks from relays using outboxes
+    const relays$ = window$.pipe(loadBlocksFromOutboxMap(pool, outboxes, filter, { ...opts, logger }));
+    // Merge the cache and relays loaders
+    const loader$ = merge(cache$, relays$);
+    // Wrap the loader in a timeline loader function
+    return wrapTimelineLoader(window$, loader$, opts?.eventStore);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "applesauce-loaders",
-  "version": "4.0.0",
+  "version": "4.2.0",
   "description": "A collection of observable based loaders built on rx-nostr",
   "type": "module",
   "main": "dist/index.js",
@@ -52,14 +52,14 @@
     }
   },
   "dependencies": {
-    "applesauce-core": "^4.0.0",
+    "applesauce-core": "^4.2.0",
     "nanoid": "^5.0.9",
     "nostr-tools": "~2.17",
     "rxjs": "^7.8.1"
   },
   "devDependencies": {
     "@hirez_io/observer-spy": "^2.2.0",
-    "applesauce-signers": "^4.0.0",
+    "applesauce-signers": "^4.2.0",
     "rimraf": "^6.0.1",
     "typescript": "^5.8.3",
     "vitest": "^3.2.4",