applesauce-core 0.10.0 → 0.12.0

package/dist/helpers/mailboxes.js

@@ -1,5 +1,6 @@
-import { safeRelayUrl } from "./relays.js";
 import { getOrComputeCachedValue } from "./cache.js";
+import { isSafeRelayURL } from "./relays.js";
+import { normalizeURL } from "./url.js";
 export const MailboxesInboxesSymbol = Symbol.for("mailboxes-inboxes");
 export const MailboxesOutboxesSymbol = Symbol.for("mailboxes-outboxes");
 /**
@@ -9,10 +10,13 @@ export function getInboxes(event) {
     return getOrComputeCachedValue(event, MailboxesInboxesSymbol, () => {
         const inboxes = [];
         for (const tag of event.tags) {
-            if (tag[0] === "r" && tag[1] && (tag[2] === "read" || tag[2] === undefined)) {
-                const url = safeRelayUrl(tag[1]);
-                if (url && !inboxes.includes(url))
-                    inboxes.push(url);
+            const [name, url, mode] = tag;
+            if (name === "r" &&
+                url &&
+                isSafeRelayURL(url) &&
+                !inboxes.includes(url) &&
+                (mode === "read" || mode === undefined)) {
+                inboxes.push(normalizeURL(url));
             }
         }
         return inboxes;
@@ -25,10 +29,13 @@ export function getOutboxes(event) {
     return getOrComputeCachedValue(event, MailboxesOutboxesSymbol, () => {
         const outboxes = [];
         for (const tag of event.tags) {
-            if (tag[0] === "r" && tag[1] && (tag[2] === "write" || tag[2] === undefined)) {
-                const url = safeRelayUrl(tag[1]);
-                if (url && !outboxes.includes(url))
-                    outboxes.push(url);
+            const [name, url, mode] = tag;
+            if (name === "r" &&
+                url &&
+                isSafeRelayURL(url) &&
+                !outboxes.includes(url) &&
+                (mode === "write" || mode === undefined)) {
+                outboxes.push(normalizeURL(url));
             }
         }
         return outboxes;

package/dist/helpers/mutes.d.ts

@@ -0,0 +1,15 @@
+import { NostrEvent } from "nostr-tools";
+export declare const MutePublicSymbol: unique symbol;
+export declare const MuteHiddenSymbol: unique symbol;
+export type Mutes = {
+    pubkeys: Set<string>;
+    threads: Set<string>;
+    hashtags: Set<string>;
+    words: Set<string>;
+};
+/** Parses mute tags */
+export declare function parseMutedTags(tags: string[][]): Mutes;
+/** Returns muted things */
+export declare function getMutedThings(mute: NostrEvent): Mutes;
+/** Returns the hidden muted content if the event is unlocked */
+export declare function getHiddenMutedThings(mute: NostrEvent): Mutes | undefined;

package/dist/helpers/mutes.js

@@ -0,0 +1,24 @@
+import { isETag, isPTag, isTTag } from "./tags.js";
+import { getOrComputeCachedValue } from "./cache.js";
+import { getHiddenTags } from "./hidden-tags.js";
+export const MutePublicSymbol = Symbol.for("mute-public");
+export const MuteHiddenSymbol = Symbol.for("mute-hidden");
+/** Parses mute tags */
+export function parseMutedTags(tags) {
+    const pubkeys = new Set(tags.filter(isPTag).map((t) => t[1]));
+    const threads = new Set(tags.filter(isETag).map((t) => t[1]));
+    const hashtags = new Set(tags.filter(isTTag).map((t) => t[1].toLocaleLowerCase()));
+    const words = new Set(tags.filter((t) => t[0] === "word" && t[1]).map((t) => t[1].toLocaleLowerCase()));
+    return { pubkeys, threads, hashtags, words };
+}
+/** Returns muted things */
+export function getMutedThings(mute) {
+    return getOrComputeCachedValue(mute, MutePublicSymbol, () => parseMutedTags(mute.tags));
+}
+/** Returns the hidden muted content if the event is unlocked */
+export function getHiddenMutedThings(mute) {
+    return getOrComputeCachedValue(mute, MuteHiddenSymbol, () => {
+        const tags = getHiddenTags(mute);
+        return tags && parseMutedTags(tags);
+    });
+}

package/dist/helpers/nip-19.d.ts

@@ -0,0 +1,4 @@
+/** Gets the hex pubkey from any nip-19 encoded string */
+export declare function normalizeToPubkey(str: string): string;
+/** Converts hex to nsec strings into Uint8 secret keys */
+export declare function normalizeToSecretKey(str: string): Uint8Array;

package/dist/helpers/nip-19.js

@@ -0,0 +1,27 @@
+import { nip19 } from "nostr-tools";
+import { hexToBytes } from "@noble/hashes/utils";
+import { isHexKey } from "./string.js";
+import { getPubkeyFromDecodeResult } from "./pointers.js";
+/** Gets the hex pubkey from any nip-19 encoded string */
+export function normalizeToPubkey(str) {
+    if (isHexKey(str))
+        return str;
+    else {
+        const decode = nip19.decode(str);
+        const pubkey = getPubkeyFromDecodeResult(decode);
+        if (!pubkey)
+            throw new Error(`Cant find pubkey in ${decode.type}`);
+        return pubkey;
+    }
+}
+/** Converts hex to nsec strings into Uint8 secret keys */
+export function normalizeToSecretKey(str) {
+    if (isHexKey(str))
+        return hexToBytes(str);
+    else {
+        const decode = nip19.decode(str);
+        if (decode.type !== "nsec")
+            throw new Error(`Cant get secret key from ${decode.type}`);
+        return decode.data;
+    }
+}

package/dist/helpers/picture-post.d.ts

@@ -0,0 +1,4 @@
+import { NostrEvent } from "nostr-tools";
+export declare const PICTURE_POST_KIND = 20;
+/** Return the media attachments from a kind 20 media post */
+export declare function getPicturePostAttachments(post: NostrEvent): import("./file-metadata.js").FileMetadata[];

package/dist/helpers/picture-post.js

@@ -0,0 +1,6 @@
+import { getMediaAttachments } from "./file-metadata.js";
+export const PICTURE_POST_KIND = 20;
+/** Return the media attachments from a kind 20 media post */
+export function getPicturePostAttachments(post) {
+    return getMediaAttachments(post);
+}

package/dist/helpers/pointers.js

@@ -1,8 +1,8 @@
 import { naddrEncode, neventEncode, noteEncode, nprofileEncode, npubEncode, nsecEncode, } from "nostr-tools/nip19";
 import { getPublicKey, kinds } from "nostr-tools";
-import { safeRelayUrls } from "./relays.js";
-import { getTagValue } from "./index.js";
+import { getReplaceableIdentifier } from "./event.js";
 import { isParameterizedReplaceableKind } from "nostr-tools/kinds";
+import { isSafeRelayURL } from "./relays.js";
 export function parseCoordinate(a, requireD = false, silent = true) {
     const parts = a.split(":");
     const kind = parts[0] && parseInt(parts[0]);
@@ -74,8 +74,8 @@ export function getEventPointerFromETag(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]]);
+    if (tag[2] && isSafeRelayURL(tag[2]))
+        pointer.relays = [tag[2]];
     return pointer;
 }
 /**
@@ -86,8 +86,8 @@ export function getEventPointerFromQTag(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]]);
+    if (tag[2] && isSafeRelayURL(tag[2]))
+        pointer.relays = [tag[2]];
     if (tag[3] && tag[3].length === 64)
         pointer.author = tag[3];
     return pointer;
@@ -100,8 +100,8 @@ export function getAddressPointerFromATag(tag) {
     if (!tag[1])
         throw new Error("Missing coordinate in tag");
     const pointer = parseCoordinate(tag[1], true, false);
-    if (tag[2])
-        pointer.relays = safeRelayUrls([tag[2]]);
+    if (tag[2] && isSafeRelayURL(tag[2]))
+        pointer.relays = [tag[2]];
     return pointer;
 }
 /**
@@ -112,8 +112,8 @@ export function getProfilePointerFromPTag(tag) {
     if (!tag[1])
         throw new Error("Missing pubkey in tag");
     const pointer = { pubkey: tag[1] };
-    if (tag[2])
-        pointer.relays = safeRelayUrls([tag[2]]);
+    if (tag[2] && isSafeRelayURL(tag[2]))
+        pointer.relays = [tag[2]];
     return pointer;
 }
 /** Parses "e", "a", "p", and "q" tags into a pointer */
@@ -148,7 +148,7 @@ export function isEventPointer(pointer) {
 }
 /** Returns the coordinate string for an AddressPointer */
 export function getCoordinateFromAddressPointer(pointer) {
-    return `${pointer.kind}:${pointer.pubkey}:${pointer.identifier}`;
+    return pointer.kind + ":" + pointer.pubkey + ":" + pointer.identifier;
 }
 /**
  * Returns an AddressPointer for a replaceable event
@@ -157,9 +157,7 @@ export function getCoordinateFromAddressPointer(pointer) {
 export function getAddressPointerForEvent(event, relays) {
     if (!isParameterizedReplaceableKind(event.kind))
         throw new Error("Cant get AddressPointer for non-replaceable event");
-    const d = getTagValue(event, "d");
-    if (!d)
-        throw new Error("Event missing identifier");
+    const d = getReplaceableIdentifier(event);
     return {
         identifier: d,
         kind: event.kind,
@@ -182,9 +180,7 @@ export function getEventPointerForEvent(event, relays) {
 /** Returns a pointer for a given event */
 export function getPointerForEvent(event, relays) {
     if (kinds.isParameterizedReplaceableKind(event.kind)) {
-        const d = getTagValue(event, "d");
-        if (!d)
-            throw new Error("Event missing identifier");
+        const d = getReplaceableIdentifier(event);
         return {
             type: "naddr",
             data: {

package/dist/helpers/profile.d.ts

@@ -2,10 +2,13 @@ import { NostrEvent } from "nostr-tools";
 export declare const ProfileContentSymbol: unique symbol;
 export type ProfileContent = {
     name?: string;
+    /** @deprecated use name instead */
+    username?: string;
     display_name?: string;
+    /** @deprecated use display_name instead */
     displayName?: string;
     about?: string;
-    /** @deprecated */
+    /** @deprecated use picture instead */
     image?: string;
     picture?: string;
     banner?: string;
@@ -18,3 +21,5 @@ export type ProfileContent = {
 export declare function getProfileContent(event: NostrEvent): ProfileContent;
 /** Checks if the content of the kind 0 event is valid JSON */
 export declare function isValidProfile(profile?: NostrEvent): boolean;
+/** Gets the display name from a profile with fallbacks */
+export declare function getDisplayName(metadata?: ProfileContent): string | undefined;

package/dist/helpers/profile.js

@@ -29,3 +29,7 @@ export function isValidProfile(profile) {
         return false;
     }
 }
+/** Gets the display name from a profile with fallbacks */
+export function getDisplayName(metadata) {
+    return metadata?.display_name || metadata?.displayName || metadata?.name;
+}

package/dist/helpers/relays.d.ts

@@ -5,8 +5,11 @@ declare module "nostr-tools" {
         [SeenRelaysSymbol]?: Set<string>;
     }
 }
+/** Marks an event as being seen on a relay */
 export declare function addSeenRelay(event: NostrEvent, relay: string): Set<string>;
+/** Returns the set of relays this event was seen on */
 export declare function getSeenRelays(event: NostrEvent): Set<string> | undefined;
-export declare function validateRelayURL(relay: string | URL): URL;
-export declare function safeRelayUrl(relayUrl: string | URL): string | null;
-export declare function safeRelayUrls(urls: Iterable<string>): string[];
+/** A fast check to make sure relay hints are safe to connect to */
+export declare function isSafeRelayURL(relay: string): boolean;
+/** Merge multiple sets of relays and remove duplicates (ignores invalid URLs) */
+export declare function mergeRelaySets(...sources: (Iterable<string> | undefined)[]): string[];

package/dist/helpers/relays.js

@@ -1,31 +1,38 @@
+import { normalizeURL } from "./url.js";
 export const SeenRelaysSymbol = Symbol.for("seen-relays");
-// Seen relays
+/** Marks an event as being seen on a relay */
 export function addSeenRelay(event, relay) {
     if (!event[SeenRelaysSymbol])
         event[SeenRelaysSymbol] = new Set();
     event[SeenRelaysSymbol].add(relay);
     return event[SeenRelaysSymbol];
 }
+/** Returns the set of relays this event was seen on */
 export function getSeenRelays(event) {
     return event[SeenRelaysSymbol];
 }
-// Relay URLs
-export function validateRelayURL(relay) {
-    if (typeof relay === "string" && relay.includes(",ws"))
-        throw new Error("Can not have multiple relays in one string");
-    const url = typeof relay === "string" ? new URL(relay) : relay;
-    if (url.protocol !== "wss:" && url.protocol !== "ws:")
-        throw new Error("Incorrect protocol");
-    return url;
+const WEBSOCKET_URL_CHECK = /^wss?:\/\/([-a-zA-Z0-9@:%._\+~#=]{1,256}\.[a-zA-Z0-9()]{1,6}|localhost)\b([-a-zA-Z0-9()@:%_\+.~#?&\/\/=]*)$/;
+/** A fast check to make sure relay hints are safe to connect to */
+export function isSafeRelayURL(relay) {
+    // anything smaller than 8 is not a URL
+    return relay.length >= 8 && WEBSOCKET_URL_CHECK.test(relay);
 }
-export function safeRelayUrl(relayUrl) {
-    try {
-        return validateRelayURL(relayUrl).toString();
+/** Merge multiple sets of relays and remove duplicates (ignores invalid URLs) */
+export function mergeRelaySets(...sources) {
+    const set = new Set();
+    for (const src of sources) {
+        if (!src)
+            continue;
+        for (const url of src) {
+            try {
+                const safe = normalizeURL(url).toString();
+                if (safe)
+                    set.add(safe);
+            }
+            catch (error) {
+                // failed to parse URL, ignore
+            }
+        }
     }
-    catch (e) {
-        return null;
-    }
-}
-export function safeRelayUrls(urls) {
-    return Array.from(urls).map(safeRelayUrl).filter(Boolean);
+    return Array.from(set);
 }

package/dist/helpers/share.d.ts

@@ -0,0 +1,4 @@
+import { NostrEvent } from "nostr-tools";
+export declare const SharedEventSymbol: unique symbol;
+/** Returns the stringified event in the content of a kind 6 or 16 share event */
+export declare function parseSharedEvent(event: NostrEvent): NostrEvent | undefined;

package/dist/helpers/share.js

@@ -0,0 +1,12 @@
+import { safeParse } from "./json.js";
+import { getOrComputeCachedValue } from "./cache.js";
+export const SharedEventSymbol = Symbol.for("shared-event");
+/** Returns the stringified event in the content of a kind 6 or 16 share event */
+export function parseSharedEvent(event) {
+    return getOrComputeCachedValue(event, SharedEventSymbol, () => {
+        const json = safeParse(event.content);
+        if (!json)
+            return;
+        return json;
+    });
+}

package/dist/helpers/tags.d.ts

@@ -1,3 +1,7 @@
+/** A tag with at least two indexes, the first being the name, the second the value */
+export type NameValueTag<Name extends string = string> = [Name, string, ...string[]];
+/** Tests if a tag has at least two indexes, and optionally the value of the first */
+export declare function isNameValueTag<Name extends string>(tag: string[], name?: Name): tag is NameValueTag<Name>;
 /** Checks if tag is an "e" tag and has at least one value */
 export declare function isETag(tag: string[]): tag is ["e", string, ...string[]];
 /** Checks if tag is an "p" tag and has at least one value */
@@ -10,3 +14,16 @@ export declare function isDTag(tag: string[]): tag is ["d", string, ...string[]]
 export declare function isATag(tag: string[]): tag is ["a", string, ...string[]];
 /** Checks if tag is an "a" tag and has at least one value */
 export declare function isTTag(tag: string[]): tag is ["t", string, ...string[]];
+/** A pipeline that filters and maps each tag */
+type TagPipe = {
+    <A>(tags: string[][], ta: (tag: string[]) => A | undefined): A[];
+    <A, B>(tags: string[][], ta: (tag: string[]) => A | undefined, ab: (a: A) => B | undefined): B[];
+    <A, B, C>(tags: string[][], ta: (tag: string[]) => A | undefined, ab: (a: A) => B | undefined, bc: (b: B) => C | undefined): C[];
+    <A, B, C, D>(tags: string[][], ta: (tag: string[]) => A | undefined, ab: (a: A) => B | undefined, bc: (b: B) => C | undefined, cd: (c: C) => D | undefined): D[];
+    <A, B, C, D, E>(tags: string[][], ta: (tag: string[]) => A | undefined, ab: (a: A) => B | undefined, bc: (b: B) => C | undefined, cd: (c: C) => D | undefined, de: (d: D) => E | undefined): E[];
+    <A, B, C, D, E, F>(tags: string[][], ta: (tag: string[]) => A | undefined, ab: (a: A) => B | undefined, bc: (b: B) => C | undefined, cd: (c: C) => D | undefined, de: (d: D) => E | undefined, ef: (e: E) => F | undefined): F[];
+    <A, B, C, D, E, F, G>(tags: string[][], ta: (tag: string[]) => A | undefined, ab: (a: A) => B | undefined, bc: (b: B) => C | undefined, cd: (c: C) => D | undefined, de: (d: D) => E | undefined, ef: (e: E) => F | undefined, fg: (f: F) => G | undefined): G[];
+};
+/** Filter and transform tags */
+export declare const processTags: TagPipe;
+export {};

package/dist/helpers/tags.js

@@ -1,24 +1,46 @@
+/** Tests if a tag has at least two indexes, and optionally the value of the first */
+export function isNameValueTag(tag, name) {
+    return tag[0] !== undefined && tag[1] !== undefined && (name ? tag[0] === name : true);
+}
 /** Checks if tag is an "e" tag and has at least one value */
 export function isETag(tag) {
-    return tag[0] === "e" && tag[1] !== undefined;
+    return isNameValueTag(tag, "e");
 }
 /** Checks if tag is an "p" tag and has at least one value */
 export function isPTag(tag) {
-    return tag[0] === "p" && tag[1] !== undefined;
+    return isNameValueTag(tag, "p");
 }
 /** Checks if tag is an "r" tag and has at least one value */
 export function isRTag(tag) {
-    return tag[0] === "r" && tag[1] !== undefined;
+    return isNameValueTag(tag, "r");
 }
 /** Checks if tag is an "d" tag and has at least one value */
 export function isDTag(tag) {
-    return tag[0] === "d" && tag[1] !== undefined;
+    return isNameValueTag(tag, "d");
 }
 /** Checks if tag is an "a" tag and has at least one value */
 export function isATag(tag) {
-    return tag[0] === "a" && tag[1] !== undefined;
+    return isNameValueTag(tag, "a");
 }
 /** Checks if tag is an "a" tag and has at least one value */
 export function isTTag(tag) {
-    return tag[0] === "a" && tag[1] !== undefined;
+    return isNameValueTag(tag, "t");
 }
+/** Filter and transform tags */
+export const processTags = (tags, ...fns) => {
+    return fns.reduce((step, fn) => {
+        const next = [];
+        for (const value of step) {
+            try {
+                const result = fn(value);
+                if (result === undefined)
+                    continue; // value is undefined, ignore
+                next.push(result);
+            }
+            catch (error) {
+                // failed to process value, ignore
+            }
+        }
+        return next;
+    }, tags);
+};

package/dist/helpers/threading.js

@@ -1,6 +1,6 @@
 import { getAddressPointerFromATag } from "./pointers.js";
 import { getOrComputeCachedValue } from "./cache.js";
-import { safeRelayUrls } from "./relays.js";
+import { isSafeRelayURL } from "./relays.js";
 export const Nip10ThreadRefsSymbol = Symbol.for("nip10-thread-refs");
 /**
  * Gets an EventPointer form a NIP-10 threading "e" tag
@@ -10,8 +10,8 @@ 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]]);
+    if (tag[2] && isSafeRelayURL(tag[2]))
+        pointer.relays = [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") &&

package/dist/helpers/url.d.ts

@@ -12,3 +12,10 @@ export declare function isVideoURL(url: string | URL): boolean;
 export declare function isStreamURL(url: string | URL): boolean;
 /** Checks if a url is a audio URL */
 export declare function isAudioURL(url: string | URL): boolean;
+/** Tests if two URLs are the same */
+export declare function isSameURL(a: string | URL, b: string | URL): boolean;
+/**
+ * Normalizes a string into a relay URL
+ * Does not remove the trailing slash
+ */
+export declare function normalizeURL<T extends string | URL>(url: T): T;

package/dist/helpers/url.js

@@ -28,3 +28,30 @@ export function isAudioURL(url) {
     const filename = getURLFilename(url);
     return !!filename && AUDIO_EXT.some((ext) => filename.endsWith(ext));
 }
+/** Tests if two URLs are the same */
+export function isSameURL(a, b) {
+    try {
+        a = normalizeURL(a);
+        b = normalizeURL(b);
+        return a === b;
+    }
+    catch (error) {
+        return false;
+    }
+}
+/**
+ * Normalizes a string into a relay URL
+ * Does not remove the trailing slash
+ */
+export function normalizeURL(url) {
+    let p = new URL(url);
+    // remove any double slashes
+    p.pathname = p.pathname.replace(/\/+/g, "/");
+    // drop the port if its not needed
+    if ((p.port === "80" && (p.protocol === "ws:" || p.protocol === "http:")) ||
+        (p.port === "443" && (p.protocol === "wss:" || p.protocol === "https:")))
+        p.port = "";
+    // return a string if a string was passed in
+    // @ts-expect-error
+    return typeof url === "string" ? p.toString() : p;
+}

package/dist/helpers/user-status.d.ts

@@ -0,0 +1,18 @@
+import { NostrEvent } from "nostr-tools";
+import { AddressPointer, EventPointer, ProfilePointer } from "nostr-tools/nip19";
+export declare const UserStatusPointerSymbol: unique symbol;
+export type UserStatusPointer = {
+    type: "nevent";
+    data: EventPointer;
+} | {
+    type: "nprofile";
+    data: ProfilePointer;
+} | {
+    type: "naddr";
+    data: AddressPointer;
+} | {
+    type: "url";
+    data: string;
+};
+/** Gets the {@link UserStatusPointer} for a status event */
+export declare function getUserStatusPointer(status: NostrEvent): UserStatusPointer | null;

package/dist/helpers/user-status.js

@@ -0,0 +1,21 @@
+import { getAddressPointerFromATag, getEventPointerFromETag, getOrComputeCachedValue, getProfilePointerFromPTag, } from "applesauce-core/helpers";
+export const UserStatusPointerSymbol = Symbol.for("user-status-pointer");
+function getStatusPointer(status) {
+    const pTag = status.tags.find((t) => t[0] === "p" && t[1]);
+    if (pTag)
+        return { type: "nprofile", data: getProfilePointerFromPTag(pTag) };
+    const eTag = status.tags.find((t) => t[0] === "e" && t[1]);
+    if (eTag)
+        return { type: "nevent", data: getEventPointerFromETag(eTag) };
+    const aTag = status.tags.find((t) => t[0] === "a" && t[1]);
+    if (aTag)
+        return { type: "naddr", data: getAddressPointerFromATag(aTag) };
+    const rTag = status.tags.find((t) => t[0] === "r" && t[1]);
+    if (rTag)
+        return { type: "url", data: rTag[1] };
+    return null;
+}
+/** Gets the {@link UserStatusPointer} for a status event */
+export function getUserStatusPointer(status) {
+    return getOrComputeCachedValue(status, UserStatusPointerSymbol, () => getStatusPointer(status));
+}

package/dist/observable/__tests__/claim-events.test.d.ts

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

package/dist/observable/__tests__/claim-events.test.js

@@ -0,0 +1,23 @@
+import { describe, expect, it } from "vitest";
+import { Database } from "../../event-store/database.js";
+import { claimEvents } from "../claim-events.js";
+const event = {
+    content: '{"name":"hzrd149","picture":"https://cdn.hzrd149.com/5ed3fe5df09a74e8c126831eac999364f9eb7624e2b86d521521b8021de20bdc.png","about":"JavaScript developer working on some nostr stuff\\n- noStrudel https://nostrudel.ninja/ \\n- Blossom https://github.com/hzrd149/blossom \\n- Applesauce https://hzrd149.github.io/applesauce/","website":"https://hzrd149.com","nip05":"_@hzrd149.com","lud16":"hzrd1499@minibits.cash","pubkey":"266815e0c9210dfa324c6cba3573b14bee49da4209a9456f9484e5106cd408a5","display_name":"hzrd149","displayName":"hzrd149","banner":""}',
+    created_at: 1738362529,
+    id: "e9df8d5898c4ccfbd21fcd59f3f48abb3ff0ab7259b19570e2f1756de1e9306b",
+    kind: 0,
+    pubkey: "266815e0c9210dfa324c6cba3573b14bee49da4209a9456f9484e5106cd408a5",
+    relays: [""],
+    sig: "465a47b93626a587bf81dadc2b306b8f713a62db31d6ce1533198e9ae1e665a6eaf376a03250bf9ffbb02eb9059c8eafbd37ae1092d05d215757575bd8357586",
+    tags: [],
+};
+describe("claimEvents", () => {
+    it("it should claim events", () => {
+        const database = new Database();
+        const sub = database.inserted.pipe(claimEvents(database)).subscribe();
+        database.addEvent(event);
+        expect(database.isClaimed(event)).toBe(true);
+        sub.unsubscribe();
+        expect(database.isClaimed(event)).toBe(false);
+    });
+});

package/dist/observable/__tests__/claim-latest.test.d.ts

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

package/dist/observable/__tests__/claim-latest.test.js

@@ -0,0 +1,37 @@
+import { describe, expect, it } from "vitest";
+import { Database } from "../../event-store/database.js";
+import { claimLatest } from "../claim-latest.js";
+const event1 = {
+    content: '{"name":"hzrd149","picture":"https://cdn.hzrd149.com/5ed3fe5df09a74e8c126831eac999364f9eb7624e2b86d521521b8021de20bdc.png","about":"JavaScript developer working on some nostr stuff\\n- noStrudel https://nostrudel.ninja/ \\n- Blossom https://github.com/hzrd149/blossom \\n- Applesauce https://hzrd149.github.io/applesauce/","website":"https://hzrd149.com","nip05":"_@hzrd149.com","lud16":"hzrd1499@minibits.cash","pubkey":"266815e0c9210dfa324c6cba3573b14bee49da4209a9456f9484e5106cd408a5","display_name":"hzrd149","displayName":"hzrd149","banner":""}',
+    created_at: 1738362529,
+    id: "e9df8d5898c4ccfbd21fcd59f3f48abb3ff0ab7259b19570e2f1756de1e9306b",
+    kind: 0,
+    pubkey: "266815e0c9210dfa324c6cba3573b14bee49da4209a9456f9484e5106cd408a5",
+    relays: [""],
+    sig: "465a47b93626a587bf81dadc2b306b8f713a62db31d6ce1533198e9ae1e665a6eaf376a03250bf9ffbb02eb9059c8eafbd37ae1092d05d215757575bd8357586",
+    tags: [],
+};
+const event2 = {
+    content: '{"name":"Cesar Dias","website":"dev.nosotros.app","picture":"https://nostr.build/i/5b0e4387b0fdfff9897ee7f8dcc554761fe377583a5fb71bbf3b915e7c4971c2.jpg","display_name":"Cesar Dias","nip05":"_@nosotros.app","lud16":"cesardias@getalby.com","about":"Developer 🇧🇷, building a client https://dev.nosotros.app and nostr-editor https://github.com/cesardeazevedo/nostr-editor","banner":"https://image.nostr.build/87dbc55a6391d15bddda206561d53867a5679dd95e84fe8ed62bfe2e3adcadf3.jpg\\",\\"ox 87dbc55a6391d15bddda206561d53867a5679dd95e84fe8ed62bfe2e3adcadf3"}',
+    created_at: 1727998492,
+    id: "c771fe19ac255ea28690c5547258a5e146d2f47805f7f48093b773478bdd137c",
+    kind: 0,
+    pubkey: "c6603b0f1ccfec625d9c08b753e4f774eaf7d1cf2769223125b5fd4da728019e",
+    relays: [""],
+    sig: "5220d6a8cdb4837b2569c26a84a2ac6a44427a224cb1602c05c578c6a63fe122a37e16455b09cb38bf297fc8161a8e715d7b444d017624c044d87a77e092c881",
+    tags: [["alt", "User profile for Cesar Dias"]],
+};
+describe("claimLatest", () => {
+    it("it should claim events", () => {
+        const database = new Database();
+        const sub = database.inserted.pipe(claimLatest(database)).subscribe();
+        database.addEvent(event1);
+        expect(database.isClaimed(event1)).toBe(true);
+        database.addEvent(event2);
+        expect(database.isClaimed(event1)).toBe(false);
+        expect(database.isClaimed(event2)).toBe(true);
+        sub.unsubscribe();
+        expect(database.isClaimed(event1)).toBe(false);
+        expect(database.isClaimed(event2)).toBe(false);
+    });
+});

package/dist/observable/__tests__/simple-timeout.test.d.ts

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

package/dist/observable/__tests__/simple-timeout.test.js

@@ -0,0 +1,34 @@
+import { describe, it, expect } from "vitest";
+import { Observable, Subject, firstValueFrom } from "rxjs";
+import { simpleTimeout, TimeoutError } from "../simple-timeout.js";
+describe("simpleTimeout operator", () => {
+    it("should throw TimeoutError after specified timeout period", async () => {
+        const subject = new Subject();
+        const obs = subject.pipe(simpleTimeout(10));
+        const promise = firstValueFrom(obs);
+        await expect(promise).rejects.toThrow(TimeoutError);
+        await expect(promise).rejects.toThrow("Timeout");
+    });
+    it("should throw TimeoutError with custom message", async () => {
+        const subject = new Subject();
+        const customMessage = "Custom timeout message";
+        const obs = subject.pipe(simpleTimeout(10, customMessage));
+        const promise = firstValueFrom(obs);
+        await expect(promise).rejects.toThrow(TimeoutError);
+        await expect(promise).rejects.toThrow(customMessage);
+    });
+    it("should not throw when value emitted before timeout", async () => {
+        const subject = new Subject();
+        const obs = subject.pipe(simpleTimeout(1000));
+        const promise = firstValueFrom(obs);
+        subject.next("test value");
+        await expect(promise).resolves.toBe("test value");
+    });
+    it("should complete without error when source emits non-null value before timeout", async () => {
+        const source = new Observable((subscriber) => {
+            subscriber.next("test value");
+        });
+        const result = await firstValueFrom(source.pipe(simpleTimeout(10)));
+        expect(result).toBe("test value");
+    });
+});

package/dist/observable/claim-events.d.ts

@@ -0,0 +1,5 @@
+import { MonoTypeOperatorFunction } from "rxjs";
+import { NostrEvent } from "nostr-tools";
+import { Database } from "../event-store/database.js";
+/** keep a claim on any event that goes through this observable, claims are removed when the observable completes */
+export declare function claimEvents<T extends NostrEvent[] | NostrEvent | undefined>(database: Database): MonoTypeOperatorFunction<T>;