applesauce-core 0.12.1 → 1.0.0

package/dist/queries/relays.js

@@ -0,0 +1,44 @@
+import { kinds } from "nostr-tools";
+import { identity, map } from "rxjs";
+import { FAVORITE_RELAYS_KIND, getAddressPointersFromList, getRelaysFromList } from "../helpers/lists.js";
+import { listenLatestUpdates } from "../observable/listen-latest-updates.js";
+/**
+ * A query that returns all favorite relays for a pubkey
+ * @param pubkey - The pubkey to get the favorite relays for
+ * @param type - Which types of tags to read
+ */
+export function FavoriteRelays(pubkey, type) {
+    return (events) => {
+        return events.replaceable(FAVORITE_RELAYS_KIND, pubkey).pipe(type !== "public" ? listenLatestUpdates(events) : map(identity), map((e) => e && getRelaysFromList(e, type)));
+    };
+}
+/**
+ * A query that returns all favorite relay sets for a pubkey
+ * @param pubkey - The pubkey to get the favorite relay sets for
+ * @param type - Which types of tags to read
+ */
+export function FavoriteRelaySets(pubkey, type) {
+    return (events) => {
+        return events.replaceable(FAVORITE_RELAYS_KIND, pubkey).pipe(type !== "public" ? listenLatestUpdates(events) : map(identity), map((e) => e && getAddressPointersFromList(e, type)));
+    };
+}
+/**
+ * A query that returns all search relays for a pubkey
+ * @param pubkey - The pubkey to get the search relays for
+ * @param type - Which types of tags to read
+ */
+export function SearchRelays(pubkey, type) {
+    return (events) => {
+        return events.replaceable(kinds.SearchRelaysList, pubkey).pipe(type !== "public" ? listenLatestUpdates(events) : map(identity), map((e) => e && getRelaysFromList(e, type)));
+    };
+}
+/**
+ * A query that returns all blocked relays for a pubkey
+ * @param pubkey - The pubkey to get the blocked relays for
+ * @param type - Which types of tags to read
+ */
+export function BlockedRelays(pubkey, type) {
+    return (events) => {
+        return events.replaceable(kinds.BlockedRelaysList, pubkey).pipe(type !== "public" ? listenLatestUpdates(events) : map(identity), map((e) => e && getRelaysFromList(e, type)));
+    };
+}

package/dist/queries/simple.js

@@ -1,38 +1,21 @@
-import hash_sum from "hash-sum";
-import { getReplaceableUID } from "../helpers/event.js";
 /** Creates a Query that returns a single event or undefined */
 export function SingleEventQuery(id) {
-    return {
-        key: id,
-        run: (events) => events.event(id),
-    };
+    return (events) => events.event(id);
 }
 /** Creates a Query that returns a multiple events in a map */
 export function MultipleEventsQuery(ids) {
-    return {
-        key: ids.join(","),
-        run: (events) => events.events(ids),
-    };
+    return (events) => events.events(ids);
 }
 /** Creates a Query returning the latest version of a replaceable event */
 export function ReplaceableQuery(kind, pubkey, d) {
-    return {
-        key: getReplaceableUID(kind, pubkey, d),
-        run: (events) => events.replaceable(kind, pubkey, d),
-    };
+    return (events) => events.replaceable(kind, pubkey, d);
 }
 /** Creates a Query that returns an array of sorted events matching the filters */
 export function TimelineQuery(filters, includeOldVersion) {
     filters = Array.isArray(filters) ? filters : [filters];
-    return {
-        key: hash_sum(filters) + (includeOldVersion ? "-history" : ""),
-        run: (events) => events.timeline(filters, includeOldVersion),
-    };
+    return (events) => events.timeline(filters, includeOldVersion);
 }
 /** Creates a Query that returns a directory of events by their UID */
 export function ReplaceableSetQuery(pointers) {
-    return {
-        key: hash_sum(pointers),
-        run: (events) => events.replaceableSet(pointers),
-    };
+    return (events) => events.replaceableSet(pointers);
 }

package/dist/queries/thread.js

@@ -1,9 +1,9 @@
 import { kinds } from "nostr-tools";
-import { isParameterizedReplaceableKind } from "nostr-tools/kinds";
+import { isAddressableKind } from "nostr-tools/kinds";
 import { map } from "rxjs/operators";
 import { getNip10References, interpretThreadTags } from "../helpers/threading.js";
 import { getCoordinateFromAddressPointer, isAddressPointer, isEventPointer } from "../helpers/pointers.js";
-import { getEventUID, getReplaceableUID, getTagValue, isEvent } from "../helpers/event.js";
+import { getEventUID, createReplaceableAddress, getTagValue, isEvent } from "../helpers/event.js";
 import { COMMENT_KIND } from "../helpers/comment.js";
 const defaultOptions = {
     kinds: [kinds.ShortTextNote],
@@ -32,61 +32,55 @@ export function ThreadQuery(root, opts) {
         rootFilter.ids = [root.id];
         replyFilter["#e"] = [root.id];
     }
-    return {
-        key: `${rootUID}-${kinds.join(",")}`,
-        run: (events) => events.filters([rootFilter, replyFilter]).pipe(map((event) => {
-            if (!items.has(getEventUID(event))) {
-                const refs = getNip10References(event);
-                const replies = parentReferences.get(getEventUID(event)) || new Set();
-                const item = { event, refs, replies };
-                for (const child of replies) {
-                    child.parent = item;
+    return (events) => events.filters([rootFilter, replyFilter]).pipe(map((event) => {
+        if (!items.has(getEventUID(event))) {
+            const refs = getNip10References(event);
+            const replies = parentReferences.get(getEventUID(event)) || new Set();
+            const item = { event, refs, replies };
+            for (const child of replies) {
+                child.parent = item;
+            }
+            // add item to parent
+            if (refs.reply?.e || refs.reply?.a) {
+                let uid = refs.reply.e ? refs.reply.e.id : getCoordinateFromAddressPointer(refs.reply.a);
+                item.parent = items.get(uid);
+                if (item.parent) {
+                    item.parent.replies.add(item);
                 }
-                // add item to parent
-                if (refs.reply?.e || refs.reply?.a) {
-                    let uid = refs.reply.e ? refs.reply.e.id : getCoordinateFromAddressPointer(refs.reply.a);
-                    item.parent = items.get(uid);
-                    if (item.parent) {
-                        item.parent.replies.add(item);
-                    }
-                    else {
-                        // parent isn't created yet, store ref for later
-                        let set = parentReferences.get(uid);
-                        if (!set) {
-                            set = new Set();
-                            parentReferences.set(uid, set);
-                        }
-                        set.add(item);
+                else {
+                    // parent isn't created yet, store ref for later
+                    let set = parentReferences.get(uid);
+                    if (!set) {
+                        set = new Set();
+                        parentReferences.set(uid, set);
                     }
+                    set.add(item);
                 }
-                // add item to map
-                items.set(getEventUID(event), item);
             }
-            return { root: items.get(rootUID), all: items };
-        })),
-    };
+            // add item to map
+            items.set(getEventUID(event), item);
+        }
+        return { root: items.get(rootUID), all: items };
+    }));
 }
 /** A query that gets all legacy and NIP-10, and NIP-22 replies for an event */
 export function RepliesQuery(event, overrideKinds) {
-    return {
-        key: getEventUID(event),
-        run: (events) => {
-            const kinds = overrideKinds || event.kind === 1 ? [1, COMMENT_KIND] : [COMMENT_KIND];
-            const filter = { kinds };
-            if (isEvent(parent) || isEventPointer(event))
-                filter["#e"] = [event.id];
-            const address = isParameterizedReplaceableKind(event.kind)
-                ? getReplaceableUID(event.kind, event.pubkey, getTagValue(event, "d"))
-                : undefined;
-            if (address) {
-                filter["#a"] = [address];
-            }
-            return events.timeline(filter).pipe(map((events) => {
-                return events.filter((e) => {
-                    const refs = interpretThreadTags(e.tags);
-                    return refs.reply?.e?.[1] === event.id || refs.reply?.a?.[1] === address;
-                });
-            }));
-        },
+    return (events) => {
+        const kinds = overrideKinds || event.kind === 1 ? [1, COMMENT_KIND] : [COMMENT_KIND];
+        const filter = { kinds };
+        if (isEvent(parent) || isEventPointer(event))
+            filter["#e"] = [event.id];
+        const address = isAddressableKind(event.kind)
+            ? createReplaceableAddress(event.kind, event.pubkey, getTagValue(event, "d"))
+            : undefined;
+        if (address) {
+            filter["#a"] = [address];
+        }
+        return events.timeline(filter).pipe(map((events) => {
+            return events.filter((e) => {
+                const refs = interpretThreadTags(e.tags);
+                return refs.reply?.e?.[1] === event.id || refs.reply?.a?.[1] === address;
+            });
+        }));
     };
 }

package/dist/queries/user-status.js

@@ -4,36 +4,30 @@ import { getUserStatusPointer } from "../helpers/user-status.js";
 import { getReplaceableIdentifier } from "../helpers/event.js";
 /** Creates a Query that returns a parsed {@link UserStatus} for a certain type */
 export function UserStatusQuery(pubkey, type = "general") {
-    return {
-        key: pubkey,
-        run: (events) => events.replaceable(kinds.UserStatuses, pubkey, type).pipe(map((event) => {
-            if (!event)
-                return undefined;
-            const pointer = getUserStatusPointer(event);
-            if (!pointer)
-                return null;
-            return {
-                ...pointer,
-                event,
-                content: event.content,
-            };
-        })),
-    };
+    return (events) => events.replaceable(kinds.UserStatuses, pubkey, type).pipe(map((event) => {
+        if (!event)
+            return undefined;
+        const pointer = getUserStatusPointer(event);
+        if (!pointer)
+            return null;
+        return {
+            ...pointer,
+            event,
+            content: event.content,
+        };
+    }));
 }
 /** Creates a Query that returns a directory of parsed {@link UserStatus} for a pubkey */
 export function UserStatusesQuery(pubkey) {
-    return {
-        key: pubkey,
-        run: (events) => events.timeline([{ kinds: [kinds.UserStatuses], authors: [pubkey] }]).pipe(map((events) => {
-            return events.reduce((dir, event) => {
-                try {
-                    const d = getReplaceableIdentifier(event);
-                    return { ...dir, [d]: { event, ...getUserStatusPointer(event), content: event.content } };
-                }
-                catch (error) {
-                    return dir;
-                }
-            }, {});
-        })),
-    };
+    return (events) => events.timeline([{ kinds: [kinds.UserStatuses], authors: [pubkey] }]).pipe(map((events) => {
+        return events.reduce((dir, event) => {
+            try {
+                const d = getReplaceableIdentifier(event);
+                return { ...dir, [d]: { event, ...getUserStatusPointer(event), content: event.content } };
+            }
+            catch (error) {
+                return dir;
+            }
+        }, {});
+    }));
 }

package/dist/queries/zaps.js

@@ -4,18 +4,15 @@ import { getCoordinateFromAddressPointer, isAddressPointer } from "../helpers/po
 import { isValidZap } from "../helpers/zap.js";
 /** A query that gets all zap events for an event */
 export function EventZapsQuery(id) {
-    return {
-        key: JSON.stringify(id),
-        run: (events) => {
-            if (isAddressPointer(id)) {
-                return events
-                    .timeline([{ kinds: [kinds.Zap], "#a": [getCoordinateFromAddressPointer(id)] }])
-                    .pipe(map((events) => events.filter(isValidZap)));
-            }
-            else {
-                id = typeof id === "string" ? id : id.id;
-                return events.timeline([{ kinds: [kinds.Zap], "#e": [id] }]).pipe(map((events) => events.filter(isValidZap)));
-            }
-        },
+    return (events) => {
+        if (isAddressPointer(id)) {
+            return events
+                .timeline([{ kinds: [kinds.Zap], "#a": [getCoordinateFromAddressPointer(id)] }])
+                .pipe(map((events) => events.filter(isValidZap)));
+        }
+        else {
+            id = typeof id === "string" ? id : id.id;
+            return events.timeline([{ kinds: [kinds.Zap], "#e": [id] }]).pipe(map((events) => events.filter(isValidZap)));
+        }
     };
 }

package/dist/query-store/query-store.d.ts

@@ -3,13 +3,10 @@ import { Filter, NostrEvent } from "nostr-tools";
 import type { AddressPointer, EventPointer } from "nostr-tools/nip19";
 import { IEventStore } from "../event-store/interface.js";
 import * as Queries from "../queries/index.js";
-export type Query<T extends unknown> = {
-    /** A unique key for this query. this is used to detect duplicate queries */
-    key: string;
-    /** The meat of the query, this should return an Observables that subscribes to the eventStore in some way */
-    run: (events: IEventStore, store: QueryStore) => Observable<T>;
+export type Query<T extends unknown> = (events: IEventStore, store: QueryStore) => Observable<T>;
+export type QueryConstructor<T extends unknown, Args extends Array<any>> = ((...args: Args) => Query<T>) & {
+    getKey?: (...args: Args) => string;
 };
-export type QueryConstructor<T extends unknown, Args extends Array<any>> = (...args: Args) => Query<T>;
 export declare class QueryStore {
     static Queries: typeof Queries;
     store: IEventStore;
@@ -38,6 +35,10 @@ export declare class QueryStore {
     timeline(filters: Filter | Filter[], keepOldVersions?: boolean): Observable<import("nostr-tools").Event[] | undefined>;
     /** Creates a ProfileQuery */
     profile(pubkey: string): Observable<import("../helpers/profile.js").ProfileContent | undefined>;
+    /** Creates a ContactsQuery */
+    contacts(pubkey: string): Observable<import("nostr-tools/nip19").ProfilePointer[] | undefined>;
+    /** Creates a MuteQuery */
+    mutes(pubkey: string): Observable<import("../helpers/mutes.js").Mutes | undefined>;
     /** Creates a ReactionsQuery */
     reactions(event: NostrEvent): Observable<import("nostr-tools").Event[] | undefined>;
     /** Creates a MailboxesQuery */

package/dist/query-store/query-store.js

@@ -1,7 +1,6 @@
-import { filter, finalize, ReplaySubject, share, timer } from "rxjs";
+import { filter, finalize, firstValueFrom, ReplaySubject, share, timer } from "rxjs";
 import hash_sum from "hash-sum";
 import * as Queries from "../queries/index.js";
-import { getObservableValue } from "../observable/get-observable-value.js";
 import { withImmediateValueOrDefault } from "../observable/with-immediate-value.js";
 export class QueryStore {
     static Queries = Queries;
@@ -22,19 +21,17 @@ export class QueryStore {
             observables = new Map();
             this.queries.set(queryConstructor, observables);
         }
-        const key = hash_sum(args);
+        const key = queryConstructor.getKey ? queryConstructor.getKey(...args) : hash_sum(args);
         let observable = observables.get(key);
         if (!observable) {
             const cleanup = () => {
                 if (observables.get(key) === observable)
                     observables.delete(key);
             };
-            observable = queryConstructor(...args)
-                .run(this.store, this)
-                .pipe(
+            observable = queryConstructor(...args)(this.store, this).pipe(
             // always emit undefined so the observable is sync
             withImmediateValueOrDefault(undefined), 
-            // remove the observable when its subscribed
+            // remove the observable when its unsubscribed
             finalize(cleanup), 
             // only create a single observable for all components
             share({
@@ -51,7 +48,7 @@ export class QueryStore {
     /** Creates a query and waits for the next value */
     async executeQuery(queryConstructor, ...args) {
         const query = this.createQuery(queryConstructor, ...args).pipe(filter((v) => v !== undefined));
-        return getObservableValue(query);
+        return firstValueFrom(query);
     }
     /** Creates a SingleEventQuery */
     event(id) {
@@ -77,6 +74,14 @@ export class QueryStore {
     profile(pubkey) {
         return this.createQuery(Queries.ProfileQuery, pubkey);
     }
+    /** Creates a ContactsQuery */
+    contacts(pubkey) {
+        return this.createQuery(Queries.ContactsQuery, pubkey);
+    }
+    /** Creates a MuteQuery */
+    mutes(pubkey) {
+        return this.createQuery(Queries.MuteQuery, pubkey);
+    }
     /** Creates a ReactionsQuery */
     reactions(event) {
         return this.createQuery(Queries.ReactionsQuery, event);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "applesauce-core",
-  "version": "0.12.1",
+  "version": "1.0.0",
   "description": "",
   "type": "module",
   "main": "dist/index.js",
@@ -76,8 +76,8 @@
     "@hirez_io/observer-spy": "^2.2.0",
     "@types/debug": "^4.1.12",
     "@types/hash-sum": "^1.0.2",
-    "typescript": "^5.7.3",
-    "vitest": "^3.0.5"
+    "typescript": "^5.8.3",
+    "vitest": "^3.1.1"
   },
   "funding": {
     "type": "lightning",

package/dist/observable/share-latest-value.d.ts

@@ -1,6 +0,0 @@
-import { OperatorFunction } from "rxjs";
-/**
- * Creates an operator that adds a 'value' property and multiplexes the source
- * @param config Optional ShareConfig for customizing sharing behavior
- */
-export declare function shareLatestValue<T>(): OperatorFunction<T, T | undefined>;

package/dist/observable/share-latest-value.js

@@ -1,24 +0,0 @@
-import { BehaviorSubject, share } from "rxjs";
-/**
- * Creates an operator that adds a 'value' property and multiplexes the source
- * @param config Optional ShareConfig for customizing sharing behavior
- */
-export function shareLatestValue() {
-    return (source$) => source$.pipe(share({ connector: () => new BehaviorSubject(undefined) }));
-    // return (source: Observable<T>): Observable<T> & { value: T | undefined } => {
-    //   // Create storage for latest value
-    //   let latestValue: T | undefined = undefined;
-    //   // Create shared source with value tracking
-    //   const shared$ = source.pipe(
-    //     tap((value) => {
-    //       latestValue = value;
-    //     }),
-    //     share(config),
-    //   );
-    //   // Add value property
-    //   Object.defineProperty(shared$, "value", {
-    //     get: () => latestValue,
-    //   });
-    //   return shared$ as Observable<T> & { value: T | undefined };
-    // };
-}