applesauce-loaders 0.12.0 → 2.0.0

package/dist/loaders/timeline-loader.js

@@ -1,56 +1,50 @@
-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 }), {});
-    }
+import { mapEventsToStore } from "applesauce-core";
+import { EMPTY, finalize, identity, merge, 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,
+        }));
+        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;
+        }));
+    };
+}
+/** Creates a loader that loads a timeline from a cache */
+export function cacheTimelineLoader(request, filters, opts) {
+    return filterBlockLoader((filters) => makeCacheRequest(request, filters), filters, 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)));
+}
+/** A common timeline loader that takes an array of relays and a cache method */
+export function createTimelineLoader(pool, relays, filters, opts) {
+    if (!Array.isArray(filters))
+        filters = [filters];
+    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);
 }

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

@@ -0,0 +1,26 @@
+import { IEventStore } from "applesauce-core";
+import { NostrEvent } from "nostr-tools";
+import { ProfilePointer } from "nostr-tools/nip19";
+import { Observable } from "rxjs";
+import { CacheRequest, UpstreamPool } from "../types.js";
+/** A list of NIP-51 list kinds that most clients will use */
+export declare const COMMON_LIST_KINDS: number[];
+/** A list of NIP-51 set kinds that most clients will use */
+export declare const COMMON_SET_KINDS: number[];
+/** A loader that takes a user profile and loads their NIP-51 sets and lists */
+export type UserListsLoader = (user: ProfilePointer) => Observable<NostrEvent>;
+export type UserListsLoaderOptions = Partial<{
+    /** An array of NIP-51 kinds to load */
+    kinds: number[];
+    /** A method used to load events from a local cache */
+    cacheRequest?: CacheRequest;
+    /** An array of extra relay to load from */
+    extraRelays?: string[];
+    /** An event store used to deduplicate events */
+    eventStore: IEventStore;
+}>;
+/**
+ * A special address loader that can request addressable events without specifying the identifier
+ * @todo this does not have a buffer, it may be useful to have one
+ */
+export declare function createUserListsLoader(pool: UpstreamPool, opts?: UserListsLoaderOptions): UserListsLoader;

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

@@ -0,0 +1,33 @@
+import { mapEventsToStore } from "applesauce-core";
+import { mergeRelaySets } from "applesauce-core/helpers";
+import { kinds } from "nostr-tools";
+import { EMPTY, identity, merge } from "rxjs";
+import { makeCacheRequest, wrapCacheRequest } from "../helpers/cache.js";
+import { wrapUpstreamPool } from "../helpers/upstream.js";
+/** A list of NIP-51 list kinds that most clients will use */
+export const COMMON_LIST_KINDS = [kinds.Contacts, kinds.Mutelist, kinds.Pinlist, kinds.BookmarkList];
+/** A list of NIP-51 set kinds that most clients will use */
+export const COMMON_SET_KINDS = [kinds.Bookmarksets, kinds.Followsets];
+/**
+ * A special address loader that can request addressable events without specifying the identifier
+ * @todo this does not have a buffer, it may be useful to have one
+ */
+export function createUserListsLoader(pool, opts) {
+    const request = wrapUpstreamPool(pool);
+    const cacheRequest = opts?.cacheRequest ? wrapCacheRequest(opts.cacheRequest) : undefined;
+    return (user) => {
+        const filter = {
+            kinds: opts?.kinds || [...COMMON_LIST_KINDS, ...COMMON_SET_KINDS],
+            authors: [user.pubkey],
+        };
+        // Merge extra relays with user relays
+        const relays = opts?.extraRelays ? mergeRelaySets(user.relays, opts.extraRelays) : user.relays;
+        return merge(
+        // Load from cache
+        cacheRequest ? makeCacheRequest(cacheRequest, [filter]) : EMPTY, 
+        // Load from relays
+        relays ? request(relays, [filter]) : EMPTY).pipe(
+        // If event store is set, deduplicate events
+        opts?.eventStore ? mapEventsToStore(opts.eventStore) : identity);
+    };
+}

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

@@ -0,0 +1,12 @@
+import { NostrEvent } from "nostr-tools";
+import { Observable } from "rxjs";
+import { UpstreamPool } from "../types.js";
+import { TagValueLoaderOptions } from "./tag-value-loader.js";
+/** A loader that takes an event and returns zaps */
+export type ZapsLoader = (event: NostrEvent, relays?: string[]) => Observable<NostrEvent>;
+export type ZapsLoaderOptions = Omit<TagValueLoaderOptions, "kinds"> & {
+    /** Whether to request zaps from the relays the event was seen on ( default true ) */
+    useSeenRelays?: boolean;
+};
+/** Creates a loader that loads zap events for a given event */
+export declare function createZapsLoader(pool: UpstreamPool, opts?: ZapsLoaderOptions): ZapsLoader;

package/dist/loaders/zaps-loader.js

@@ -0,0 +1,18 @@
+import { getReplaceableAddress, getSeenRelays, isReplaceable, mergeRelaySets } from "applesauce-core/helpers";
+import { kinds } from "nostr-tools";
+import { wrapUpstreamPool } from "../helpers/upstream.js";
+import { createTagValueLoader } from "./tag-value-loader.js";
+/** Creates a loader that loads zap events for a given event */
+export function createZapsLoader(pool, opts) {
+    const request = wrapUpstreamPool(pool);
+    const eventLoader = createTagValueLoader(request, "e", { ...opts, kinds: [kinds.Zap] });
+    const addressableLoader = createTagValueLoader(request, "a", { ...opts, kinds: [kinds.Zap] });
+    // Return diffrent loaders depending on if the event is addressable
+    return (event, relays) => {
+        if (opts?.useSeenRelays ?? true)
+            relays = mergeRelaySets(relays, getSeenRelays(event));
+        return isReplaceable(event.kind)
+            ? addressableLoader({ value: getReplaceableAddress(event), relays })
+            : eventLoader({ value: event.id, relays });
+    };
+}

package/dist/operators/complete-on-eose.d.ts

@@ -0,0 +1,6 @@
+import { OperatorFunction } from "rxjs";
+/**
+ * Completes the observable when an EOSE message is received
+ * @deprecated request methods passed to loaders should complete on their own
+ */
+export declare function completeOnEOSE<T extends unknown>(): OperatorFunction<T | "EOSE", T>;

package/dist/operators/complete-on-eose.js

@@ -0,0 +1,8 @@
+import { takeWhile } from "rxjs";
+/**
+ * Completes the observable when an EOSE message is received
+ * @deprecated request methods passed to loaders should complete on their own
+ */
+export function completeOnEOSE() {
+    return (source) => source.pipe(takeWhile((m) => m !== "EOSE", false));
+}

package/dist/operators/generator.d.ts

@@ -0,0 +1,13 @@
+import { Observable, OperatorFunction } from "rxjs";
+/** Creates an observable that runs a generator and flattes the results */
+export declare function fromGenerator<Result>(generator: Generator<Observable<Result> | Result, void, Result[]> | AsyncGenerator<Observable<Result> | Result, void, Result[]>): Observable<Result>;
+/** Wraps a generator function to return an observable */
+export declare function wrapGeneratorFunction<Args extends unknown[], Result>(constructor: (...args: Args) => Generator<Observable<Result> | Result, void, Result[]> | AsyncGenerator<Observable<Result> | Result, void, Result[]>): (...args: Args) => Observable<Result>;
+/** Runs a generator for each value in sequence waiting for each to complete before running the next */
+export declare function concatGeneratorMap<Input, Result>(createGenerator: (value: Input) => Generator<Observable<Result> | Result, void, Result[]> | AsyncGenerator<Observable<Result> | Result, void, Result[]>): OperatorFunction<Input, Result>;
+/** Runs a generator for each value, canceling the current generator if a new value is received */
+export declare function switchGeneratorMap<Input, Result>(createGenerator: (value: Input) => Generator<Observable<Result> | Result, void, Result[]> | AsyncGenerator<Observable<Result> | Result, void, Result[]>): OperatorFunction<Input, Result>;
+/** Keeps retrying a value until the generator returns */
+export declare function generator<Input, Result>(createGenerator: (value: Input) => Generator<Observable<Result> | Result, void, Result[]> | AsyncGenerator<Observable<Result> | Result, void, Result[]>, 
+/** @deprecated merge with NEVER if no completion is needed */
+shouldComplete?: boolean): OperatorFunction<Input, Result>;

package/dist/operators/generator.js

@@ -0,0 +1,72 @@
+import { concatMap, EMPTY, isObservable, mergeMap, mergeWith, NEVER, Observable, share, switchMap, } from "rxjs";
+/** Creates an observable that runs a generator and flattes the results */
+export function fromGenerator(generator) {
+    return new Observable((observer) => {
+        let sub;
+        const nextSequence = (prevResults) => {
+            const p = prevResults ? generator.next(prevResults) : generator.next();
+            const handleResult = (result) => {
+                // generator complete, exit
+                if (result.done) {
+                    // Ignore result.value here because its the return value and we only want the yield values
+                    return observer.complete();
+                }
+                const results = [];
+                if (isObservable(result.value)) {
+                    sub = 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);
+                }
+            };
+            // 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();
+        // Attempt to cleanup
+        return () => sub?.unsubscribe();
+    }).pipe(
+    // Only create a single instance of the observalbe to avoice race conditions
+    share());
+}
+/** Wraps a generator function to return an observable */
+export function wrapGeneratorFunction(constructor) {
+    return (...args) => fromGenerator(constructor(...args));
+}
+/** Runs a generator for each value in sequence waiting for each to complete before running the next */
+export function concatGeneratorMap(createGenerator) {
+    return (source) => source.pipe(concatMap((value) => fromGenerator(createGenerator(value))));
+}
+/** Runs a generator for each value, canceling the current generator if a new value is received */
+export function switchGeneratorMap(createGenerator) {
+    return (source) => source.pipe(switchMap((value) => fromGenerator(createGenerator(value))));
+}
+/** Keeps retrying a value until the generator returns */
+export function generator(createGenerator, 
+/** @deprecated merge with NEVER if no completion is needed */
+shouldComplete = true) {
+    return (source) => source.pipe(
+    // Run the generator for each value
+    mergeMap((value) => fromGenerator(createGenerator(value))), 
+    // Merge with NEVER if shouldComplete is false
+    mergeWith(shouldComplete ? EMPTY : NEVER));
+}

package/dist/operators/index.d.ts

@@ -1,3 +1,3 @@
 export * from "./distinct-relays.js";
 export * from "./distinct-timeout.js";
-export * from "./generator-sequence.js";
+export * from "./generator.js";

package/dist/operators/index.js

@@ -1,3 +1,3 @@
 export * from "./distinct-relays.js";
 export * from "./distinct-timeout.js";
-export * from "./generator-sequence.js";
+export * from "./generator.js";

package/dist/types.d.ts

@@ -0,0 +1,14 @@
+import { Filter, NostrEvent } from "nostr-tools";
+import { Observable } from "rxjs";
+/** A flexible method for requesting events from a cache */
+export type CacheRequest = (filters: Filter[]) => Observable<NostrEvent> | Promise<NostrEvent | NostrEvent[]> | NostrEvent | NostrEvent[];
+/** A flexible type for the upstream relay pool */
+export type UpstreamPool = NostrRequest | {
+    request: NostrRequest;
+};
+/** A method for requesting events from a relay or cache` */
+export type FilterRequest = (filters: Filter[]) => Observable<NostrEvent>;
+/** A method for requesting events from multiple relays */
+export type NostrRequest = (relays: string[], filters: Filter[]) => Observable<NostrEvent>;
+/** A filter that is does not have a since or until */
+export type TimelessFilter = Omit<Filter, "since" | "until">;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "applesauce-loaders",
-  "version": "0.12.0",
+  "version": "2.0.0",
   "description": "A collection of observable based loaders built on rx-nostr",
   "type": "module",
   "main": "dist/index.js",
@@ -53,18 +53,18 @@
     }
   },
   "dependencies": {
-    "applesauce-core": "^0.12.0",
+    "applesauce-core": "^2.0.0",
     "nanoid": "^5.0.9",
-    "nostr-tools": "^2.10.4",
-    "rx-nostr": "^3.5.0",
+    "nostr-tools": "^2.13",
     "rxjs": "^7.8.1"
   },
   "devDependencies": {
-    "rx-nostr-crypto": "^3.1.3",
-    "typescript": "^5.7.3",
-    "vitest": "^3.0.5",
+    "@hirez_io/observer-spy": "^2.2.0",
+    "applesauce-signers": "^2.0.0",
+    "typescript": "^5.8.3",
+    "vitest": "^3.2.3",
     "vitest-nostr": "^0.4.1",
-    "vitest-websocket-mock": "^0.4.0"
+    "vitest-websocket-mock": "^0.5.0"
   },
   "funding": {
     "type": "lightning",

package/dist/helpers/__tests__/address-pointer.test.js

@@ -1,19 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { createFiltersFromAddressPointers } from "../address-pointer.js";
-import { kinds } from "nostr-tools";
-describe("address pointer helpers", () => {
-    describe("createFiltersFromAddressPointers", () => {
-        it("should separate replaceable and parameterized replaceable pointers", () => {
-            expect(createFiltersFromAddressPointers([
-                { kind: kinds.BookmarkList, pubkey: "pubkey" },
-                { kind: kinds.Metadata, pubkey: "pubkey" },
-                { kind: kinds.Metadata, pubkey: "pubkey2" },
-                { kind: kinds.Bookmarksets, identifier: "funny", pubkey: "pubkey" },
-            ])).toEqual(expect.arrayContaining([
-                { kinds: [kinds.Metadata], authors: ["pubkey", "pubkey2"] },
-                { kinds: [kinds.BookmarkList], authors: ["pubkey"] },
-                { "#d": ["funny"], authors: ["pubkey"], kinds: [kinds.Bookmarksets] },
-            ]));
-        });
-    });
-});

package/dist/helpers/rx-nostr.d.ts

@@ -1,2 +0,0 @@
-import { RxNostr } from "rx-nostr";
-export declare function getDefaultReadRelays(rxNostr: RxNostr): string[];

package/dist/helpers/rx-nostr.js

@@ -1,5 +0,0 @@
-export function getDefaultReadRelays(rxNostr) {
-    return Object.entries(rxNostr.getDefaultRelays())
-        .filter(([_, config]) => config.read)
-        .map(([relay]) => relay);
-}

package/dist/loaders/__tests__/dns-identity-loader.test.d.ts

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

package/dist/loaders/__tests__/dns-identity-loader.test.js

@@ -1,59 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from "vitest";
-import { DnsIdentityLoader } from "../dns-identity-loader.js";
-import { unixNow } from "applesauce-core/helpers";
-import { IdentityStatus } from "../../helpers/dns-identity.js";
-let loader;
-beforeEach(() => {
-    loader = new DnsIdentityLoader();
-});
-describe("fetch", () => {
-    it("should not assign this in fetch method", async () => {
-        const loader = new DnsIdentityLoader();
-        let that = undefined;
-        function custom() {
-            //@ts-expect-error
-            that = this;
-            throw new Error("not implemented");
-        }
-        // @ts-expect-error
-        loader.fetch = custom;
-        await loader.fetchIdentity("_", "hzrd149.com");
-        expect(that).not.toBe(loader);
-    });
-});
-describe("requestIdentity", () => {
-    it("should load from cache first", async () => {
-        const cache = {
-            save: vi.fn().mockResolvedValue(undefined),
-            load: vi.fn().mockResolvedValue({
-                name: "_",
-                domain: "hzrd149.com",
-                pubkey: "pubkey",
-                checked: unixNow(),
-                status: IdentityStatus.Found,
-            }),
-        };
-        loader.cache = cache;
-        loader.fetch = vi.fn().mockRejectedValue(new Error("error"));
-        await loader.requestIdentity("_", "hzrd149.com");
-        expect(cache.load).toHaveBeenCalledWith("_@hzrd149.com");
-        expect(loader.fetch).not.toHaveBeenCalled();
-    });
-    it("should fetch if cache is too old", async () => {
-        const cache = {
-            save: vi.fn().mockResolvedValue(undefined),
-            load: vi.fn().mockResolvedValue({
-                name: "_",
-                domain: "hzrd149.com",
-                pubkey: "pubkey",
-                checked: unixNow() - 60 * 60 * 24 * 7 * 2,
-                status: IdentityStatus.Found,
-            }),
-        };
-        loader.cache = cache;
-        loader.fetch = vi.fn().mockRejectedValue(new Error("error"));
-        await loader.requestIdentity("_", "hzrd149.com");
-        expect(cache.load).toHaveBeenCalledWith("_@hzrd149.com");
-        expect(loader.fetch).toHaveBeenCalled();
-    });
-});

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

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

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

@@ -1,26 +0,0 @@
-import { expect, it } from "vitest";
-// import { createMockRelay, MockRelay } from "vitest-nostr";
-// import { createRxNostr } from "rx-nostr";
-// import { verifier } from "rx-nostr-crypto";
-// import { RelayTimelineLoader } from "./relay-timeline-loader.js";
-// let relay: MockRelay;
-// beforeEach(async () => {
-//   relay = createMockRelay("ws://localhost:1234");
-// });
-it("should complete when 0 events are returned", async () => {
-    // const rxNostr = createRxNostr({ verifier });
-    // const loader = new RelayTimelineLoader(rxNostr, "ws://localhost:1234", [{ kinds: [1] }]);
-    // let received = 0;
-    // loader.subscribe(() => received++);
-    // // load first page
-    // loader.next(100);
-    // expect(loader.loading).toBe(true);
-    // await relay.connected;
-    // await expect(relay).toReceiveREQ();
-    // relay.emitEVENT(loader.id, faker.event({ kind: 1 }));
-    // relay.emitEOSE(loader.id);
-    // await new Promise((res) => setTimeout(res, 0));
-    // expect(received).toBe(1);
-    // expect(loader.loading).toBe(false);
-    expect(true).toBeTruthy();
-});

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

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

package/dist/loaders/__tests__/request-loader.test.js

@@ -1,37 +0,0 @@
-import { Subject } from "rxjs";
-import { beforeEach, describe, expect, it, vi } from "vitest";
-import { TimeoutError } from "applesauce-core/observable";
-import { EventStore, QueryStore } from "applesauce-core";
-import { RequestLoader } from "../request-loader.js";
-let eventStore;
-let queryStore;
-let loader;
-beforeEach(() => {
-    eventStore = new EventStore();
-    queryStore = new QueryStore(eventStore);
-    loader = new RequestLoader(queryStore);
-    // @ts-expect-error
-    loader.replaceableLoader = new Subject();
-    vi.spyOn(loader.replaceableLoader, "next").mockImplementation(() => { });
-});
-describe("profile", () => {
-    it("should return a promise that resolves", async () => {
-        const p = loader.profile({ pubkey: "3bf0c63fcb93463407af97a5e5ee64fa883d107ef9e558472c4eb9aaaefa459d" });
-        expect(loader.replaceableLoader.next).toHaveBeenCalledWith(expect.objectContaining({ pubkey: "3bf0c63fcb93463407af97a5e5ee64fa883d107ef9e558472c4eb9aaaefa459d" }));
-        eventStore.add({
-            content: '{"name":"fiatjaf","about":"~","picture":"https://fiatjaf.com/static/favicon.jpg","nip05":"_@fiatjaf.com","lud16":"fiatjaf@zbd.gg","website":"https://nostr.technology"}',
-            created_at: 1738588530,
-            id: "c43be8b4634298e97dde3020a5e6aeec37d7f5a4b0259705f496e81a550c8f8b",
-            kind: 0,
-            pubkey: "3bf0c63fcb93463407af97a5e5ee64fa883d107ef9e558472c4eb9aaaefa459d",
-            sig: "202a1bf6a58943d660c1891662dbdda142aa8e5bca9d4a3cb03cde816ad3bdda6f4ec3b880671506c2820285b32218a0afdec2d172de9694d83972190ab4f9da",
-            tags: [],
-        });
-        expect(await p).toEqual(expect.objectContaining({ name: "fiatjaf" }));
-    });
-    it("should reject with TimeoutError after 10 seconds", async () => {
-        // reduce timeout for tests
-        loader.requestTimeout = 10;
-        await expect(loader.profile({ pubkey: "3bf0c63fcb93463407af97a5e5ee64fa883d107ef9e558472c4eb9aaaefa459d" })).rejects.toThrow(TimeoutError);
-    });
-});

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

@@ -1,22 +0,0 @@
-import { EventPacket } from "rx-nostr";
-import { BehaviorSubject } from "rxjs";
-import { logger } from "applesauce-core";
-import { CacheRequest, Loader } from "./loader.js";
-import { TimelessFilter } from "./relay-timeline-loader.js";
-export type CacheTimelineLoaderOptions = {
-    /** 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 CacheTimelineLoader extends Loader<number | void, EventPacket> {
-    filters: TimelessFilter[];
-    id: string;
-    loading$: BehaviorSubject<boolean>;
-    get loading(): boolean;
-    /** current "until" timestamp */
-    cursor: number;
-    /** set to true when 0 events are returned from last batch */
-    eose: boolean;
-    protected log: typeof logger;
-    constructor(cacheRequest: CacheRequest, filters: TimelessFilter[], opts?: CacheTimelineLoaderOptions);
-}

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

@@ -1,61 +0,0 @@
-import { BehaviorSubject, filter, map, mergeMap, tap } from "rxjs";
-import { markFromCache, unixNow } from "applesauce-core/helpers";
-import { logger } from "applesauce-core";
-import { nanoid } from "nanoid";
-import { Loader } from "./loader.js";
-/** A loader that can be used to load a timeline in chunks */
-export class CacheTimelineLoader extends Loader {
-    filters;
-    id = nanoid(8);
-    loading$ = new BehaviorSubject(false);
-    get loading() {
-        return this.loading$.value;
-    }
-    /** current "until" timestamp */
-    cursor = Infinity;
-    /** set to true when 0 events are returned from last batch */
-    eose = false;
-    log = logger.extend("CacheTimelineLoader");
-    constructor(cacheRequest, filters, opts) {
-        super((source) => source.pipe(filter(() => !this.loading && !this.eose), 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), mergeMap((filters) => {
-            // make batch request
-            let count = 0;
-            this.loading$.next(true);
-            this.log(`Next batch starting at ${filters[0].until} limit ${filters[0].limit}`);
-            return cacheRequest(filters).pipe(tap({
-                next: (event) => {
-                    // mark event from cache
-                    markFromCache(event);
-                    // update cursor when event is received
-                    this.cursor = Math.min(event.created_at - 1, this.cursor);
-                    count++;
-                },
-                complete: () => {
-                    // set loading to false when batch completes
-                    this.loading$.next(false);
-                    // set eose if no events where returned
-                    if (count === 0) {
-                        this.eose = true;
-                        this.log(`Got ${count} event, Complete`);
-                    }
-                    else {
-                        this.log(`Finished batch, got ${count} events`);
-                    }
-                },
-            }), map((event) => ({ event, from: "", subId: "cache-timeline-loader", type: "EVENT" })));
-        })));
-        this.filters = filters;
-        // create a unique logger for this instance
-        this.log = this.log.extend("cache");
-    }
-}