applesauce-core 0.8.0 → 0.10.0

package/dist/helpers/threading.js

@@ -1,9 +1,31 @@
-import { getAddressPointerFromTag, getEventPointerFromTag } from "./pointers.js";
+import { getAddressPointerFromATag } from "./pointers.js";
+import { getOrComputeCachedValue } from "./cache.js";
+import { safeRelayUrls } from "./relays.js";
 export const Nip10ThreadRefsSymbol = Symbol.for("nip10-thread-refs");
+/**
+ * Gets an EventPointer form a NIP-10 threading "e" tag
+ * @throws
+ */
+export function getEventPointerFromThreadTag(tag) {
+    if (!tag[1])
+        throw new Error("Missing event id in tag");
+    let pointer = { id: tag[1] };
+    if (tag[2])
+        pointer.relays = safeRelayUrls([tag[2]]);
+    // get author from NIP-18 quote tags, nip-22 comments tags, or nip-10 thread tags
+    if (tag[0] === "e" &&
+        (tag[3] === "root" || tag[3] === "reply" || tag[3] === "mention") &&
+        tag[4] &&
+        tag[4].length === 64) {
+        // NIP-10 "e" tag
+        pointer.author = tag[4];
+    }
+    return pointer;
+}
 /** Parses NIP-10 tags and handles legacy behavior */
-export function interpretThreadTags(event) {
-    const eTags = event.tags.filter((t) => t[0] === "e" && t[1]);
-    const aTags = event.tags.filter((t) => t[0] === "a" && t[1]);
+export function interpretThreadTags(tags) {
+    const eTags = tags.filter((t) => t[0] === "e" && t[1]);
+    const aTags = tags.filter((t) => t[0] === "a" && t[1]);
     // find the root and reply tags.
     let rootETag = eTags.find((t) => t[3] === "root");
     let replyETag = eTags.find((t) => t[3] === "reply");
@@ -42,20 +64,31 @@ export function interpretThreadTags(event) {
 }
 /** Returns the parsed NIP-10 tags for an event */
 export function getNip10References(event) {
-    let refs = event[Nip10ThreadRefsSymbol];
-    if (!refs) {
-        const e = event;
-        const tags = interpretThreadTags(e);
-        refs = event[Nip10ThreadRefsSymbol] = {
-            root: tags.root && {
-                e: tags.root.e && getEventPointerFromTag(tags.root.e),
-                a: tags.root.a && getAddressPointerFromTag(tags.root.a),
-            },
-            reply: tags.reply && {
-                e: tags.reply.e && getEventPointerFromTag(tags.reply.e),
-                a: tags.reply.a && getAddressPointerFromTag(tags.reply.a),
-            },
+    return getOrComputeCachedValue(event, Nip10ThreadRefsSymbol, () => {
+        const tags = interpretThreadTags(event.tags);
+        let root;
+        if (tags.root) {
+            try {
+                root = {
+                    e: tags.root.e && getEventPointerFromThreadTag(tags.root.e),
+                    a: tags.root.a && getAddressPointerFromATag(tags.root.a),
+                };
+            }
+            catch (error) { }
+        }
+        let reply;
+        if (tags.reply) {
+            try {
+                reply = {
+                    e: tags.reply.e && getEventPointerFromThreadTag(tags.reply.e),
+                    a: tags.reply.a && getAddressPointerFromATag(tags.reply.a),
+                };
+            }
+            catch (error) { }
+        }
+        return {
+            root,
+            reply,
         };
-    }
-    return refs;
+    });
 }

package/dist/helpers/threading.test.d.ts

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

package/dist/helpers/threading.test.js

@@ -0,0 +1,41 @@
+import { describe, expect, it } from "vitest";
+import { interpretThreadTags } from "./threading.js";
+describe("threading helpers", () => {
+    describe("interpretThreadTags", () => {
+        it("should handle legacy tags", () => {
+            expect(interpretThreadTags([
+                ["e", "root-id"],
+                ["e", "reply-id"],
+            ])).toEqual({ root: { a: undefined, e: ["e", "root-id"] }, reply: { a: undefined, e: ["e", "reply-id"] } });
+        });
+        it("should handle nip-10 tags", () => {
+            expect(interpretThreadTags([
+                ["e", "root-id", "relay", "root"],
+                ["e", "reply-id", "relay", "reply"],
+            ])).toEqual({
+                root: { a: undefined, e: ["e", "root-id", "relay", "root"] },
+                reply: { a: undefined, e: ["e", "reply-id", "relay", "reply"] },
+            });
+        });
+        it("should ignore mention nip-10 tags", () => {
+            expect(interpretThreadTags([
+                ["e", "root-id", "relay", "root"],
+                ["e", "mention-id", "relay", "mention"],
+                ["e", "reply-id", "relay", "reply"],
+            ])).toEqual({
+                root: { a: undefined, e: ["e", "root-id", "relay", "root"] },
+                reply: { a: undefined, e: ["e", "reply-id", "relay", "reply"] },
+            });
+        });
+        it("should handle single nip-10 tags", () => {
+            expect(interpretThreadTags([["e", "root-id", "relay", "root"]])).toEqual({
+                root: { a: undefined, e: ["e", "root-id", "relay", "root"] },
+                reply: { a: undefined, e: ["e", "root-id", "relay", "root"] },
+            });
+            expect(interpretThreadTags([["e", "reply-id", "relay", "reply"]])).toEqual({
+                root: { a: undefined, e: ["e", "reply-id", "relay", "reply"] },
+                reply: { a: undefined, e: ["e", "reply-id", "relay", "reply"] },
+            });
+        });
+    });
+});

package/dist/helpers/url.d.ts

@@ -4,8 +4,11 @@ export declare const IMAGE_EXT: string[];
 export declare const VIDEO_EXT: string[];
 export declare const STREAM_EXT: string[];
 export declare const AUDIO_EXT: string[];
-export declare function isVisualMediaURL(url: string | URL): boolean;
+/** Checks if a url is a image URL */
 export declare function isImageURL(url: string | URL): boolean;
+/** Checks if a url is a video URL */
 export declare function isVideoURL(url: string | URL): boolean;
+/** Checks if a url is a stream URL */
 export declare function isStreamURL(url: string | URL): boolean;
+/** Checks if a url is a audio URL */
 export declare function isAudioURL(url: string | URL): boolean;

package/dist/helpers/url.js

@@ -4,24 +4,25 @@ export const IMAGE_EXT = [".svg", ".gif", ".png", ".jpg", ".jpeg", ".webp", ".av
 export const VIDEO_EXT = [".mp4", ".mkv", ".webm", ".mov"];
 export const STREAM_EXT = [".m3u8"];
 export const AUDIO_EXT = [".mp3", ".wav", ".ogg", ".aac"];
-export function isVisualMediaURL(url) {
-    return isImageURL(url) || isVideoURL(url) || isStreamURL(url);
-}
+/** Checks if a url is a image URL */
 export function isImageURL(url) {
     url = convertToUrl(url);
     const filename = getURLFilename(url);
     return !!filename && IMAGE_EXT.some((ext) => filename.endsWith(ext));
 }
+/** Checks if a url is a video URL */
 export function isVideoURL(url) {
     url = convertToUrl(url);
     const filename = getURLFilename(url);
     return !!filename && VIDEO_EXT.some((ext) => filename.endsWith(ext));
 }
+/** Checks if a url is a stream URL */
 export function isStreamURL(url) {
     url = convertToUrl(url);
     const filename = getURLFilename(url);
     return !!filename && STREAM_EXT.some((ext) => filename.endsWith(ext));
 }
+/** Checks if a url is a audio URL */
 export function isAudioURL(url) {
     url = convertToUrl(url);
     const filename = getURLFilename(url);

package/dist/helpers/zap.d.ts

@@ -0,0 +1,39 @@
+import { NostrEvent } from "nostr-tools";
+export declare const ZapRequestSymbol: unique symbol;
+export declare const ZapFromSymbol: unique symbol;
+export declare const ZapInvoiceSymbol: unique symbol;
+export declare const ZapEventPointerSymbol: unique symbol;
+export declare const ZapAddressPointerSymbol: unique symbol;
+/** Returns the senders pubkey */
+export declare function getZapSender(zap: NostrEvent): string;
+/**
+ * Gets the receivers pubkey
+ * @throws
+ */
+export declare function getZapRecipient(zap: NostrEvent): string;
+/** Returns the parsed bolt11 invoice */
+export declare function getZapPayment(zap: NostrEvent): import("./bolt11.js").ParsedInvoice | undefined;
+/** Gets the AddressPointer that was zapped */
+export declare function getZapAddressPointer(zap: NostrEvent): import("nostr-tools/nip19").AddressPointer | null;
+/** Gets the EventPointer that was zapped */
+export declare function getZapEventPointer(zap: NostrEvent): import("nostr-tools/nip19").EventPointer | null;
+/** Gets the preimage for the bolt11 invoice */
+export declare function getZapPreimage(zap: NostrEvent): string | undefined;
+/**
+ * Returns the zap request event inside the zap receipt
+ * @throws
+ */
+export declare function getZapRequest(zap: NostrEvent): import("nostr-tools").Event;
+/**
+ * Checks if the zap is valid
+ * DOES NOT validate LNURL address
+ */
+export declare function isValidZap(zap?: NostrEvent): boolean;
+export type ZapSplit = {
+    pubkey: string;
+    percent: number;
+    weight: number;
+    relay?: string;
+};
+/** Returns the zap splits for an event */
+export declare function getZapSplits(event: NostrEvent): ZapSplit[] | undefined;

package/dist/helpers/zap.js

@@ -0,0 +1,95 @@
+import { kinds, nip57 } from "nostr-tools";
+import { getOrComputeCachedValue } from "./cache.js";
+import { getTagValue } from "./event.js";
+import { isATag, isETag } from "./tags.js";
+import { getAddressPointerFromATag, getEventPointerFromETag } from "./pointers.js";
+import { parseBolt11 } from "./bolt11.js";
+export const ZapRequestSymbol = Symbol.for("zap-request");
+export const ZapFromSymbol = Symbol.for("zap-from");
+export const ZapInvoiceSymbol = Symbol.for("zap-bolt11");
+export const ZapEventPointerSymbol = Symbol.for("zap-event-pointer");
+export const ZapAddressPointerSymbol = Symbol.for("zap-address-pointer");
+/** Returns the senders pubkey */
+export function getZapSender(zap) {
+    return getTagValue(zap, "P") || getZapRequest(zap).pubkey;
+}
+/**
+ * Gets the receivers pubkey
+ * @throws
+ */
+export function getZapRecipient(zap) {
+    const recipient = getTagValue(zap, "p");
+    if (!recipient)
+        throw new Error("Missing recipient");
+    return recipient;
+}
+/** Returns the parsed bolt11 invoice */
+export function getZapPayment(zap) {
+    return getOrComputeCachedValue(zap, ZapInvoiceSymbol, () => {
+        const bolt11 = getTagValue(zap, "bolt11");
+        return bolt11 ? parseBolt11(bolt11) : undefined;
+    });
+}
+/** Gets the AddressPointer that was zapped */
+export function getZapAddressPointer(zap) {
+    return getOrComputeCachedValue(zap, ZapAddressPointerSymbol, () => {
+        const a = zap.tags.find(isATag);
+        return a ? getAddressPointerFromATag(a) : null;
+    });
+}
+/** Gets the EventPointer that was zapped */
+export function getZapEventPointer(zap) {
+    return getOrComputeCachedValue(zap, ZapEventPointerSymbol, () => {
+        const e = zap.tags.find(isETag);
+        return e ? getEventPointerFromETag(e) : null;
+    });
+}
+/** Gets the preimage for the bolt11 invoice */
+export function getZapPreimage(zap) {
+    return getTagValue(zap, "preimage");
+}
+/**
+ * Returns the zap request event inside the zap receipt
+ * @throws
+ */
+export function getZapRequest(zap) {
+    return getOrComputeCachedValue(zap, ZapRequestSymbol, () => {
+        const description = getTagValue(zap, "description");
+        if (!description)
+            throw new Error("Missing description tag");
+        const error = nip57.validateZapRequest(description);
+        if (error)
+            throw new Error(error);
+        return JSON.parse(description);
+    });
+}
+/**
+ * Checks if the zap is valid
+ * DOES NOT validate LNURL address
+ */
+export function isValidZap(zap) {
+    if (!zap)
+        return false;
+    if (zap.kind !== kinds.Zap)
+        return false;
+    try {
+        getZapRequest(zap);
+        getZapRecipient(zap);
+        return true;
+    }
+    catch (error) {
+        return false;
+    }
+}
+/** Returns the zap splits for an event */
+export function getZapSplits(event) {
+    const tags = event.tags.filter((t) => t[0] === "zap" && t[1] && t[3]);
+    if (tags.length > 0) {
+        const targets = tags
+            .map((t) => ({ pubkey: t[1], relay: t[2], weight: parseFloat(t[3]) }))
+            .filter((p) => Number.isFinite(p.weight));
+        const total = targets.reduce((v, p) => v + p.weight, 0);
+        return targets.map((p) => ({ ...p, percent: p.weight / total }));
+    }
+    return undefined;
+}

package/dist/observable/{getValue.d.ts → get-value.d.ts}

@@ -1,2 +1,3 @@
 import { Observable } from "rxjs";
+/** Subscribes and returns the observables current or next value */
 export declare function getValue<T>(observable: Observable<T>): T | Promise<T>;

package/dist/observable/{getValue.js → get-value.js}

@@ -1,7 +1,10 @@
 import { BehaviorSubject } from "rxjs";
+/** Subscribes and returns the observables current or next value */
 export function getValue(observable) {
     if (observable instanceof BehaviorSubject)
         return observable.value;
+    if (Reflect.has(observable, "value"))
+        return Reflect.get(observable, "value");
     return new Promise((res) => {
         const sub = observable.subscribe((v) => {
             res(v);

package/dist/observable/index.d.ts

@@ -1,2 +1,2 @@
-export * from "./getValue.js";
+export * from "./get-value.js";
 export * from "./share-latest-value.js";

package/dist/observable/index.js

@@ -1,2 +1,2 @@
-export * from "./getValue.js";
+export * from "./get-value.js";
 export * from "./share-latest-value.js";

package/dist/promise/deferred.d.ts

@@ -2,4 +2,5 @@ export type Deferred<T> = Promise<T> & {
     resolve: (value?: T | PromiseLike<T>) => void;
     reject: (reason?: any) => void;
 };
+/** Creates a controlled promise */
 export declare function createDefer<T>(): Deferred<T>;

package/dist/promise/deferred.js

@@ -1,3 +1,4 @@
+/** Creates a controlled promise */
 export function createDefer() {
     let _resolve;
     let _reject;

package/dist/queries/comments.d.ts

@@ -0,0 +1,4 @@
+import { NostrEvent } from "nostr-tools";
+import { Query } from "../query-store/index.js";
+/** Returns all NIP-22 comment replies for the event */
+export declare function CommentsQuery(parent: NostrEvent): Query<NostrEvent[]>;

package/dist/queries/comments.js

@@ -0,0 +1,14 @@
+import { COMMENT_KIND, getEventUID } from "../helpers/index.js";
+import { isParameterizedReplaceableKind } from "nostr-tools/kinds";
+/** Returns all NIP-22 comment replies for the event */
+export function CommentsQuery(parent) {
+    return {
+        key: `${getEventUID(parent)}-comments`,
+        run: (events) => {
+            const filter = { kinds: [COMMENT_KIND], "#e": [parent.id] };
+            if (isParameterizedReplaceableKind(parent.kind))
+                filter["#a"] = [getEventUID(parent)];
+            return events.timeline(filter);
+        },
+    };
+}

package/dist/queries/index.d.ts

@@ -1,5 +1,7 @@
-export * from "./simple.js";
-export * from "./profile.js";
+export * from "./comments.js";
 export * from "./mailboxes.js";
+export * from "./profile.js";
 export * from "./reactions.js";
+export * from "./simple.js";
 export * from "./thread.js";
+export * from "./zaps.js";

package/dist/queries/index.js

@@ -1,5 +1,7 @@
-export * from "./simple.js";
-export * from "./profile.js";
+export * from "./comments.js";
 export * from "./mailboxes.js";
+export * from "./profile.js";
 export * from "./reactions.js";
+export * from "./simple.js";
 export * from "./thread.js";
+export * from "./zaps.js";

package/dist/queries/mailboxes.d.ts

@@ -1,4 +1,5 @@
 import { Query } from "../query-store/index.js";
+/** A query that gets and parses the inbox and outbox relays for a pubkey */
 export declare function MailboxesQuery(pubkey: string): Query<{
     inboxes: string[];
     outboxes: string[];

package/dist/queries/mailboxes.js

@@ -1,6 +1,7 @@
 import { kinds } from "nostr-tools";
 import { map } from "rxjs/operators";
 import { getInboxes, getOutboxes } from "../helpers/mailboxes.js";
+/** A query that gets and parses the inbox and outbox relays for a pubkey */
 export function MailboxesQuery(pubkey) {
     return {
         key: pubkey,

package/dist/queries/profile.d.ts

@@ -1,3 +1,4 @@
 import { ProfileContent } from "../helpers/profile.js";
 import { Query } from "../query-store/index.js";
+/** A query that gets and parses the kind 0 metadata for a pubkey */
 export declare function ProfileQuery(pubkey: string): Query<ProfileContent | undefined>;

package/dist/queries/profile.js

@@ -1,11 +1,12 @@
 import { kinds } from "nostr-tools";
-import { map } from "rxjs/operators";
-import { getProfileContent } from "../helpers/profile.js";
+import { filter, map } from "rxjs/operators";
+import { getProfileContent, isValidProfile } from "../helpers/profile.js";
+/** A query that gets and parses the kind 0 metadata for a pubkey */
 export function ProfileQuery(pubkey) {
     return {
         key: pubkey,
         run: (events) => {
-            return events.replaceable(kinds.Metadata, pubkey).pipe(map((event) => event && getProfileContent(event)));
+            return events.replaceable(kinds.Metadata, pubkey).pipe(filter(isValidProfile), map((event) => event && getProfileContent(event)));
         },
     };
 }

package/dist/queries/reactions.d.ts

@@ -1,4 +1,4 @@
 import { NostrEvent } from "nostr-tools";
 import { Query } from "../query-store/index.js";
-/** Creates a query that returns all reactions to an event (supports replaceable events) */
+/** A query that returns all reactions to an event (supports replaceable events) */
 export declare function ReactionsQuery(event: NostrEvent): Query<NostrEvent[]>;

package/dist/queries/reactions.js

@@ -1,6 +1,6 @@
 import { kinds } from "nostr-tools";
 import { getEventUID, isReplaceable } from "../helpers/event.js";
-/** Creates a query that returns all reactions to an event (supports replaceable events) */
+/** A query that returns all reactions to an event (supports replaceable events) */
 export function ReactionsQuery(event) {
     return {
         key: getEventUID(event),

package/dist/queries/simple.d.ts

@@ -1,13 +1,13 @@
 import { Filter, NostrEvent } from "nostr-tools";
 import { Query } from "../query-store/index.js";
 /** Creates a Query that returns a single event or undefined */
-export declare function SingleEventQuery(uid: string): Query<NostrEvent | undefined>;
+export declare function SingleEventQuery(id: string): Query<NostrEvent | undefined>;
 /** Creates a Query that returns a multiple events in a map */
-export declare function MultipleEventsQuery(uids: string[]): Query<Map<string, NostrEvent>>;
+export declare function MultipleEventsQuery(ids: string[]): Query<Map<string, NostrEvent>>;
 /** Creates a Query returning the latest version of a replaceable event */
 export declare function ReplaceableQuery(kind: number, pubkey: string, d?: string): Query<NostrEvent | undefined>;
 /** Creates a Query that returns an array of sorted events matching the filters */
-export declare function TimelineQuery(filters: Filter | Filter[]): Query<NostrEvent[]>;
+export declare function TimelineQuery(filters: Filter | Filter[], keepOldVersions?: boolean): Query<NostrEvent[]>;
 /** Creates a Query that returns a directory of events by their UID */
 export declare function ReplaceableSetQuery(pointers: {
     kind: number;

package/dist/queries/simple.js

@@ -1,17 +1,17 @@
-import stringify from "json-stringify-deterministic";
+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(uid) {
+export function SingleEventQuery(id) {
     return {
-        key: uid,
-        run: (events) => events.event(uid),
+        key: id,
+        run: (events) => events.event(id),
     };
 }
 /** Creates a Query that returns a multiple events in a map */
-export function MultipleEventsQuery(uids) {
+export function MultipleEventsQuery(ids) {
     return {
-        key: uids.join(","),
-        run: (events) => events.events(uids),
+        key: ids.join(","),
+        run: (events) => events.events(ids),
     };
 }
 /** Creates a Query returning the latest version of a replaceable event */
@@ -22,17 +22,17 @@ export function ReplaceableQuery(kind, pubkey, d) {
     };
 }
 /** Creates a Query that returns an array of sorted events matching the filters */
-export function TimelineQuery(filters) {
+export function TimelineQuery(filters, keepOldVersions) {
+    filters = Array.isArray(filters) ? filters : [filters];
     return {
-        key: stringify(filters),
-        run: (events) => events.timeline(Array.isArray(filters) ? filters : [filters]),
+        key: hash_sum(filters) + (keepOldVersions ? "-history" : ""),
+        run: (events) => events.timeline(filters, keepOldVersions),
     };
 }
 /** Creates a Query that returns a directory of events by their UID */
 export function ReplaceableSetQuery(pointers) {
-    const cords = pointers.map((pointer) => getReplaceableUID(pointer.kind, pointer.pubkey, pointer.identifier));
     return {
-        key: stringify(pointers),
-        run: (events) => events.events(cords),
+        key: hash_sum(pointers),
+        run: (events) => events.replaceableSet(pointers),
     };
 }

package/dist/queries/thread.d.ts

@@ -21,3 +21,5 @@ export type ThreadQueryOptions = {
     kinds?: number[];
 };
 export declare function ThreadQuery(root: string | AddressPointer | EventPointer, opts?: ThreadQueryOptions): Query<Thread>;
+/** A query that gets all legacy and NIP-10, and NIP-22 replies for an event */
+export declare function RepliesQuery(event: NostrEvent, overrideKinds?: number[]): Query<NostrEvent[]>;

package/dist/queries/thread.js

@@ -1,8 +1,10 @@
 import { kinds } from "nostr-tools";
+import { isParameterizedReplaceableKind } from "nostr-tools/kinds";
 import { map } from "rxjs/operators";
-import { getNip10References } from "../helpers/threading.js";
-import { getCoordinateFromAddressPointer, isAddressPointer } from "../helpers/pointers.js";
-import { getEventUID } from "../helpers/event.js";
+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 { COMMENT_KIND } from "../helpers/comment.js";
 const defaultOptions = {
     kinds: [kinds.ShortTextNote],
 };
@@ -64,3 +66,27 @@ export function ThreadQuery(root, opts) {
         })),
     };
 }
+/** 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;
+                });
+            }));
+        },
+    };
+}

package/dist/queries/zaps.d.ts

@@ -0,0 +1,5 @@
+import { AddressPointer, EventPointer } from "nostr-tools/nip19";
+import { NostrEvent } from "nostr-tools";
+import { Query } from "../query-store/index.js";
+/** A query that gets all zap events for an event */
+export declare function EventZapsQuery(id: string | EventPointer | AddressPointer): Query<NostrEvent[]>;

package/dist/queries/zaps.js

@@ -0,0 +1,21 @@
+import { map } from "rxjs";
+import { kinds } from "nostr-tools";
+import { getCoordinateFromAddressPointer, isAddressPointer } from "../helpers/pointers.js";
+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)));
+            }
+        },
+    };
+}