applesauce-loaders 0.0.0-next-20250111214201 → 0.0.0-next-20250114214607

package/dist/helpers/address-pointer.d.ts

@@ -1,7 +1,8 @@
 import { AddressPointerWithoutD } from "applesauce-core/helpers";
 import { Filter } from "nostr-tools";
+import { AddressPointer } from "nostr-tools/nip19";
 /** Converts an array of address pointers to a filter */
-export declare function createFilterFromAddressPointers(pointers: AddressPointerWithoutD[]): Filter;
+export declare function createFilterFromAddressPointers(pointers: AddressPointerWithoutD[] | AddressPointer[]): Filter;
 /** Takes a set of address pointers, groups them, then returns filters for the groups */
 export declare function createFiltersFromAddressPointers(pointers: AddressPointerWithoutD[]): Filter[];
 /** Checks if a relay will understand an address pointer */
@@ -11,6 +12,14 @@ export declare function groupAddressPointersByKind(pointers: AddressPointerWitho
 /** Group an array of address pointers by pubkey */
 export declare function groupAddressPointersByPubkey(pointers: AddressPointerWithoutD[]): Map<string, AddressPointerWithoutD[]>;
 /** Groups address pointers by kind or pubkey depending on which is most optimal */
-export declare function groupAddressPointersByPubkeyOrKind(pointers: AddressPointerWithoutD[]): Map<number, AddressPointerWithoutD[]> | Map<string, AddressPointerWithoutD[]>;
+export declare function groupAddressPointersByPubkeyOrKind(pointers: AddressPointerWithoutD[]): Map<string, AddressPointerWithoutD[]> | Map<number, AddressPointerWithoutD[]>;
 export declare function getRelaysFromPointers(pointers: AddressPointerWithoutD[]): Set<string>;
 export declare function getAddressPointerId<T extends AddressPointerWithoutD>(pointer: T): string;
+/** deduplicates an array of address pointers and merges their relays array */
+export declare function consolidateAddressPointers<T extends {
+    kind: number;
+    pubkey: string;
+    identifier?: string;
+    relays?: string[];
+    force?: boolean;
+}>(pointers: T[]): T[];

package/dist/helpers/address-pointer.js

@@ -13,8 +13,19 @@ export function createFilterFromAddressPointers(pointers) {
 }
 /** Takes a set of address pointers, groups them, then returns filters for the groups */
 export function createFiltersFromAddressPointers(pointers) {
-    const groups = groupAddressPointersByPubkeyOrKind(pointers);
-    return Array.from(groups.values()).map((pointers) => createFilterFromAddressPointers(pointers));
+    // split the points in to two groups so they they don't mix in the filters
+    const parameterizedReplaceable = pointers.filter((p) => isParameterizedReplaceableKind(p.kind));
+    const replaceable = pointers.filter((p) => isReplaceableKind(p.kind));
+    const filters = [];
+    if (replaceable.length > 0) {
+        const groups = groupAddressPointersByPubkeyOrKind(replaceable);
+        filters.push(...Array.from(groups.values()).map(createFilterFromAddressPointers));
+    }
+    if (parameterizedReplaceable.length > 0) {
+        const groups = groupAddressPointersByPubkeyOrKind(parameterizedReplaceable);
+        filters.push(...Array.from(groups.values()).map(createFilterFromAddressPointers));
+    }
+    return filters;
 }
 /** Checks if a relay will understand an address pointer */
 export function isLoadableAddressPointer(pointer) {
@@ -49,7 +60,7 @@ export function groupAddressPointersByPubkey(pointers) {
 export function groupAddressPointersByPubkeyOrKind(pointers) {
     const kinds = new Set(pointers.map((p) => p.kind));
     const pubkeys = new Set(pointers.map((p) => p.pubkey));
-    return pubkeys.size > kinds.size ? groupAddressPointersByKind(pointers) : groupAddressPointersByPubkey(pointers);
+    return pubkeys.size < kinds.size ? groupAddressPointersByPubkey(pointers) : groupAddressPointersByKind(pointers);
 }
 export function getRelaysFromPointers(pointers) {
     const relays = new Set();
@@ -65,3 +76,27 @@ export function getRelaysFromPointers(pointers) {
 export function getAddressPointerId(pointer) {
     return getReplaceableUID(pointer.kind, pointer.pubkey, pointer.identifier);
 }
+/** deduplicates an array of address pointers and merges their relays array */
+export function consolidateAddressPointers(pointers) {
+    const byCoordinate = new Map();
+    for (const pointer of pointers) {
+        let cord = getAddressPointerId(pointer);
+        let existing = byCoordinate.get(cord);
+        if (existing) {
+            // override force flag
+            if (pointer.force)
+                existing.force = pointer.force;
+            // merge relays
+            if (pointer.relays) {
+                if (!existing.relays)
+                    existing.relays = [...pointer.relays];
+                else
+                    existing.relays = [...existing.relays, ...pointer.relays.filter((r) => !existing.relays.includes(r))];
+            }
+        }
+        else {
+            byCoordinate.set(cord, pointer);
+        }
+    }
+    return Array.from(byCoordinate.values());
+}

package/dist/helpers/address-pointer.test.d.ts

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

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

@@ -0,0 +1,19 @@
+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/event-pointer.d.ts

@@ -0,0 +1,5 @@
+/** deduplicates an array of event pointers and merges their relays array */
+export declare function consolidateEventPointers<T extends {
+    id: string;
+    relays?: string[];
+}>(pointers: T[]): T[];

package/dist/helpers/event-pointer.js

@@ -0,0 +1,19 @@
+/** deduplicates an array of event pointers and merges their relays array */
+export function consolidateEventPointers(pointers) {
+    let ids = new Map();
+    for (let pointer of pointers) {
+        let existing = ids.get(pointer.id);
+        if (existing) {
+            // merge relays
+            if (pointer.relays) {
+                if (!existing.relays)
+                    existing.relays = [...pointer.relays];
+                else
+                    existing.relays = [...existing.relays, ...pointer.relays.filter((r) => !existing.relays.includes(r))];
+            }
+        }
+        else
+            ids.set(pointer.id, pointer);
+    }
+    return Array.from(ids.values());
+}

package/dist/helpers/pointer.d.ts

@@ -0,0 +1,3 @@
+export declare function groupByRelay<T extends {
+    relays?: string[];
+}>(pointers: T[], defaultKey?: string): Map<string, T[]>;

package/dist/helpers/pointer.js

@@ -0,0 +1,13 @@
+export function groupByRelay(pointers, defaultKey) {
+    let byRelay = new Map();
+    for (const pointer of pointers) {
+        let relays = pointer.relays?.length ? pointer.relays : defaultKey ? [defaultKey] : [];
+        for (const relay of relays) {
+            if (!byRelay.has(relay))
+                byRelay.set(relay, [pointer]);
+            else
+                byRelay.get(relay)?.push(pointer);
+        }
+    }
+    return byRelay;
+}

package/dist/index.d.ts

@@ -1,2 +1,2 @@
-export * as Loaders from "./loaders/index.js";
+export * from "./loaders/index.js";
 export * as Operators from "./operators/index.js";

package/dist/index.js

@@ -1,2 +1,2 @@
-export * as Loaders from "./loaders/index.js";
+export * from "./loaders/index.js";
 export * as Operators from "./operators/index.js";

package/dist/loaders/index.d.ts

@@ -1,3 +1,5 @@
 export * from "./loader.js";
 export * from "./replaceable-loader.js";
+export * from "./single-event-loader.js";
 export * from "./single-relay-replaceable-loader.js";
+export * from "./user-sets-loader.js";

package/dist/loaders/index.js

@@ -1,3 +1,5 @@
 export * from "./loader.js";
 export * from "./replaceable-loader.js";
+export * from "./single-event-loader.js";
 export * from "./single-relay-replaceable-loader.js";
+export * from "./user-sets-loader.js";

package/dist/loaders/loader.d.ts

@@ -1,4 +1,6 @@
+import { Filter, NostrEvent } from "nostr-tools";
 import { Observable, OperatorFunction, Subject, Subscribable } from "rxjs";
+export type CacheRequest = (filters: Filter[]) => Observable<NostrEvent>;
 export interface ILoader<T, R> extends Subscribable<R> {
     next: (value: T) => void;
     pipe: Observable<R>["pipe"];

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

@@ -1,8 +1,6 @@
-import { Observable } from "rxjs";
 import { EventPacket, RxNostr } from "rx-nostr";
-import { Filter, NostrEvent } from "nostr-tools";
 import { logger } from "applesauce-core";
-import { Loader } from "./loader.js";
+import { CacheRequest, Loader } from "./loader.js";
 export type LoadableAddressPointer = {
     kind: number;
     pubkey: string;
@@ -13,14 +11,13 @@ export type LoadableAddressPointer = {
     /** Load this address pointer even if it has already been loaded */
     force?: boolean;
 };
-export type CacheRequest = (filters: Filter[]) => Observable<NostrEvent>;
 export type ReplaceableLoaderOptions = {
     /**
      * Time interval to buffer requests in ms
      * @default 1000
      */
     bufferTime?: number;
-    /** Request events from the cache first */
+    /** A method used to load events from a local cache */
     cacheRequest?: CacheRequest;
     /** Fallback lookup relays to check when event cant be found */
     lookupRelays?: string[];

package/dist/loaders/replaceable-loader.js

@@ -4,7 +4,7 @@ import { logger } from "applesauce-core";
 import { nanoid } from "nanoid";
 import { Loader } from "./loader.js";
 import { generatorSequence } from "../operators/generator-sequence.js";
-import { replaceableRequest } from "../operators/address-pointers-request.js";
+import { addressPointersRequest } from "../operators/address-pointers-request.js";
 import { createFiltersFromAddressPointers, getAddressPointerId, getRelaysFromPointers, isLoadableAddressPointer, } from "../helpers/address-pointer.js";
 import { unique } from "../helpers/array.js";
 /** deep clone a loadable pointer to ensure its safe to modify */
@@ -59,7 +59,7 @@ function* cacheFirstSequence(rxNostr, pointers, log, opts) {
     const remoteRelays = [...pointerRelays, ...defaultRelays];
     if (remoteRelays.length > 0) {
         log(`Requesting`, remoteRelays, remaining);
-        const results = yield from([remaining]).pipe(replaceableRequest(rxNostr, id, remoteRelays));
+        const results = yield from([remaining]).pipe(addressPointersRequest(rxNostr, id, remoteRelays));
         if (handleResults(results))
             return;
     }
@@ -69,7 +69,7 @@ function* cacheFirstSequence(rxNostr, pointers, log, opts) {
         const relays = opts.lookupRelays.filter((r) => !pointerRelays.includes(r));
         if (relays.length > 0) {
             log(`Request from lookup`, relays, remaining);
-            const results = yield from([remaining]).pipe(replaceableRequest(rxNostr, id, relays));
+            const results = yield from([remaining]).pipe(addressPointersRequest(rxNostr, id, relays));
             if (handleResults(results))
                 return;
         }

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

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

@@ -0,0 +1,78 @@
+import { bufferTime, filter, from, map, mergeAll, share, 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 { distinctRelays } from "../operators/distinct-by-relays.js";
+import { groupByRelay } from "../helpers/pointer.js";
+import { consolidateEventPointers } from "../helpers/event-pointer.js";
+/** Consolidate a batch of event pointers */
+function consolidateLoadableEventPointers() {
+    return (source) => source.pipe(map(consolidateEventPointers));
+}
+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: "cache", subId: "cache", 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(distinctRelays((p) => p.id, options.refreshTimeout ?? 60_000), 
+        // load first from cache
+        bufferTime(opts?.bufferTime ?? 1000), 
+        // ignore empty buffers
+        filter((buffer) => buffer.length > 0), 
+        // ensure there is only one of each event pointer
+        consolidateLoadableEventPointers(), 
+        // run the loader sequence
+        generatorSequence((pointers) => cacheFirstSequence(rxNostr, pointers, options, this.log)), 
+        // share the response with all subscribers
+        share()));
+    }
+}

package/dist/loaders/single-relay-replaceable-loader.js

@@ -3,7 +3,7 @@ import { getReplaceableUID } from "applesauce-core/helpers";
 import { nanoid } from "nanoid";
 import { Loader } from "./loader.js";
 import { isLoadableAddressPointer } from "../helpers/address-pointer.js";
-import { replaceableRequest } from "../operators/address-pointers-request.js";
+import { addressPointersRequest } from "../operators/address-pointers-request.js";
 const defaultRelayReplaceableLoaderOptions = {
     bufferTime: 1000,
 };
@@ -44,7 +44,7 @@ export class SingleRelayReplaceableLoader extends Loader {
         // batch and filter
         singleRelayBatcher(opts), 
         // breakout the batches so they can complete
-        mergeMap((pointers) => from([pointers]).pipe(replaceableRequest(rxNostr, nanoid(8), [relay]))), 
+        mergeMap((pointers) => from([pointers]).pipe(addressPointersRequest(rxNostr, nanoid(8), [relay]))), 
         // share the response with all subscribers
         share()));
     }

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,64 @@
+import { share, 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 { distinctRelays } from "../operators/distinct-by-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: "cache", subId: "cache", 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(distinctRelays((p) => p.kind + ":" + p.pubkey, options.refreshTimeout ?? 120_000), 
+        // load first from cache
+        bufferTime(options?.bufferTime ?? 1000), 
+        // ignore empty buffers
+        filter((buffer) => buffer.length > 0), 
+        // deduplicate address pointers
+        map(consolidateAddressPointers), 
+        // check cache, relays, lookup relays in that order
+        generatorSequence((pointers) => cacheFirstSequence(rxNostr, pointers, this.log, options)), 
+        // share the response with all subscribers
+        share()));
+    }
+}

package/dist/operators/address-pointers-request.d.ts

@@ -2,4 +2,4 @@ import { EventPacket, RxNostr } from "rx-nostr";
 import { OperatorFunction } from "rxjs";
 import { AddressPointerWithoutD } from "applesauce-core/helpers";
 /** Makes a request to relays for every set of address pointers */
-export declare function replaceableRequest<T extends AddressPointerWithoutD>(rxNostr: RxNostr, id: string, relays?: string[]): OperatorFunction<T[], EventPacket>;
+export declare function addressPointersRequest<T extends AddressPointerWithoutD>(rxNostr: RxNostr, id: string, relays?: string[]): OperatorFunction<T[], EventPacket>;

package/dist/operators/address-pointers-request.js

@@ -3,15 +3,15 @@ import { logger } from "applesauce-core";
 import { relaysRequest } from "./relay-request.js";
 import { createFiltersFromAddressPointers } from "../helpers/address-pointer.js";
 /** Makes a request to relays for every set of address pointers */
-export function replaceableRequest(rxNostr, id, relays) {
+export function addressPointersRequest(rxNostr, id, relays) {
     return (source) => {
-        const log = logger.extend(`replaceableRequest:${id}`);
+        const log = logger.extend(`addressPointersRequest:${id}`);
         return source.pipe(
         // convert pointers to filters
         map(createFiltersFromAddressPointers), 
         // make requests
         tap((filters) => {
-            log(`Requesting`, relays, filters);
+            log(`Requesting`, filters, "from", relays);
         }), 
         // make requests
         relaysRequest(rxNostr, id, relays), 

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

@@ -0,0 +1,9 @@
+import { OperatorFunction } from "rxjs";
+interface Message {
+    relays?: string[];
+    /** Ignore timeout and force message through */
+    force?: boolean;
+    [key: string]: any;
+}
+export declare function distinctRelays<T extends Message>(keyFn: (message: T) => string, timeout?: number): OperatorFunction<T, T>;
+export {};

package/dist/operators/distinct-by-relays.js

@@ -0,0 +1,39 @@
+import { filter, map, share } from "rxjs";
+export function distinctRelays(keyFn, timeout = 1000) {
+    return (source$) => {
+        const cache = new Map();
+        return source$.pipe(map((message) => {
+            if (message.force)
+                return message;
+            let key = keyFn(message);
+            let now = Date.now();
+            if (message.relays) {
+                // requesting from specific relays
+                let relays = message.relays;
+                relays = relays.filter((relay) => {
+                    let relayKey = key + " " + relay;
+                    let last = cache.get(relayKey);
+                    if (!last || now >= last + timeout) {
+                        cache.set(relayKey, now);
+                        return true;
+                    }
+                    else
+                        return false;
+                });
+                if (relays.length === 0)
+                    return null;
+                return { ...message, relays };
+            }
+            else {
+                // requesting from default relays
+                let last = cache.get(key);
+                if (!last || now >= last + timeout) {
+                    cache.set(key, now);
+                    return message;
+                }
+                else
+                    return null;
+            }
+        }), filter((message) => message !== null && !!message.relays?.length), share());
+    };
+}

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/group-by-relays.d.ts

@@ -0,0 +1,8 @@
+import { GroupedObservable, OperatorFunction } from "rxjs";
+interface Message {
+    relays?: string[];
+    [key: string]: any;
+}
+/** Splits a stream of messages out into relay specific observables */
+export declare function groupByRelays<T extends Message>(defaultRelay: string): OperatorFunction<T, GroupedObservable<string, T>>;
+export {};

package/dist/operators/group-by-relays.js

@@ -0,0 +1,10 @@
+import { from, groupBy, map, mergeMap, share } from "rxjs";
+/** Splits a stream of messages out into relay specific observables */
+export function groupByRelays(defaultRelay) {
+    return (source$) => {
+        return source$.pipe(mergeMap((message) => {
+            const relays = message.relays?.length ? message.relays : [defaultRelay];
+            return from(relays).pipe(map((relay) => ({ relay, message })));
+        }), groupBy((pair) => pair.relay, { element: (pair) => pair.message }), share());
+    };
+}

package/dist/operators/index.d.ts

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

package/dist/operators/index.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "applesauce-loaders",
-  "version": "0.0.0-next-20250111214201",
+  "version": "0.0.0-next-20250114214607",
   "description": "A collection of observable based loaders built on rx-nostr",
   "type": "module",
   "main": "dist/index.js",
@@ -41,7 +41,7 @@
     }
   },
   "dependencies": {
-    "applesauce-core": "0.0.0-next-20250111214201",
+    "applesauce-core": "0.0.0-next-20250114214607",
     "nanoid": "^5.0.9",
     "nostr-tools": "^2.10.3",
     "rx-nostr": "^3.4.1",