applesauce-core 0.0.0-next-20250423181842 → 0.0.0-next-20250424153457

package/dist/event-store/database.js

@@ -1,6 +1,6 @@
 import { binarySearch, insertEventIntoDescendingList } from "nostr-tools/utils";
 import { Subject } from "rxjs";
-import { getEventUID, getIndexableTags, getReplaceableUID, isReplaceable } from "../helpers/event.js";
+import { getEventUID, getIndexableTags, createReplaceableAddress, isReplaceable } from "../helpers/event.js";
 import { INDEXABLE_TAGS } from "./common.js";
 import { logger } from "../logger.js";
 import { LRU } from "../helpers/lru.js";
@@ -73,12 +73,12 @@ export class Database {
     }
     /** Checks if the database contains a replaceable event without touching it */
     hasReplaceable(kind, pubkey, d) {
-        const events = this.replaceable.get(getReplaceableUID(kind, pubkey, d));
+        const events = this.replaceable.get(createReplaceableAddress(kind, pubkey, d));
         return !!events && events.length > 0;
     }
     /** Gets an array of replaceable events */
     getReplaceable(kind, pubkey, d) {
-        return this.replaceable.get(getReplaceableUID(kind, pubkey, d));
+        return this.replaceable.get(createReplaceableAddress(kind, pubkey, d));
     }
     /** Inserts an event into the database and notifies all subscriptions */
     addEvent(event) {

package/dist/event-store/event-store.js

@@ -1,9 +1,9 @@
 import { kinds } from "nostr-tools";
 import { insertEventIntoDescendingList } from "nostr-tools/utils";
-import { isParameterizedReplaceableKind } from "nostr-tools/kinds";
+import { isAddressableKind } from "nostr-tools/kinds";
 import { defer, distinctUntilChanged, EMPTY, endWith, filter, finalize, from, map, merge, mergeMap, mergeWith, of, repeat, scan, take, takeUntil, tap, } from "rxjs";
 import { Database } from "./database.js";
-import { FromCacheSymbol, getEventUID, getReplaceableIdentifier, getReplaceableUID, getTagValue, isReplaceable, } from "../helpers/event.js";
+import { FromCacheSymbol, getEventUID, getReplaceableIdentifier, createReplaceableAddress, getTagValue, isReplaceable, } from "../helpers/event.js";
 import { matchFilters } from "../helpers/filter.js";
 import { addSeenRelay, getSeenRelays } from "../helpers/relays.js";
 import { getDeleteCoordinates, getDeleteIds } from "../helpers/delete.js";
@@ -54,7 +54,7 @@ export class EventStore {
         else {
             if (this.deletedIds.has(event.id))
                 return true;
-            if (isParameterizedReplaceableKind(event.kind)) {
+            if (isAddressableKind(event.kind)) {
                 const deleted = this.deletedCoords.get(getEventUID(event));
                 if (deleted)
                     return deleted > event.created_at;
@@ -295,7 +295,7 @@ export class EventStore {
     }
     /** Creates an observable that subscribes to the latest version of an array of replaceable events*/
     replaceableSet(pointers) {
-        const uids = new Set(pointers.map((p) => getReplaceableUID(p.kind, p.pubkey, p.identifier)));
+        const uids = new Set(pointers.map((p) => createReplaceableAddress(p.kind, p.pubkey, p.identifier)));
         return merge(
         // start with existing events
         defer(() => from(pointers.map((p) => this.getReplaceable(p.kind, p.pubkey, p.identifier)))), 

package/dist/helpers/__tests__/events.test.d.ts

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

package/dist/helpers/__tests__/events.test.js

@@ -0,0 +1,32 @@
+import { kinds } from "nostr-tools";
+import { describe, expect, it } from "vitest";
+import { FakeUser } from "../../__tests__/fixtures.js";
+import { getReplaceableAddress } from "../event.js";
+const user = new FakeUser();
+describe("getReplaceableAddress", () => {
+    it("should throw an error for non-replaceable events", () => {
+        const normalEvent = user.note("Hello world");
+        expect(() => {
+            getReplaceableAddress(normalEvent);
+        }).toThrow("Event is not replaceable or addressable");
+    });
+    it("should return the correct address for replaceable events", () => {
+        const replaceableEvent = user.event({
+            kind: kinds.Metadata,
+            content: JSON.stringify({ name: "Test User" }),
+            tags: [],
+        });
+        const expectedAddress = `${kinds.Metadata}:${user.pubkey}:`;
+        expect(getReplaceableAddress(replaceableEvent)).toBe(expectedAddress);
+    });
+    it("should include the identifier for addressable events", () => {
+        const identifier = "test-profile";
+        const addressableEvent = user.event({
+            kind: 30000, // Parameterized replaceable event
+            content: "Test content",
+            tags: [["d", identifier]],
+        });
+        const expectedAddress = `30000:${user.pubkey}:${identifier}`;
+        expect(getReplaceableAddress(addressableEvent)).toBe(expectedAddress);
+    });
+});

package/dist/helpers/__tests__/mutes.test.d.ts

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

package/dist/helpers/__tests__/mutes.test.js

@@ -0,0 +1,55 @@
+import { describe, expect, it } from "vitest";
+import { matchMutes } from "../mutes.js";
+import { FakeUser } from "../../__tests__/fixtures.js";
+const mutedUser = new FakeUser();
+const nonMutedUser = new FakeUser();
+const thread = nonMutedUser.note("Hello world");
+// Create a mutes object with a pubkey to mute
+const mutes = {
+    pubkeys: new Set([mutedUser.pubkey]),
+    threads: new Set([thread.id]),
+    hashtags: new Set(["nostr"]),
+    words: new Set(["GM"]),
+};
+describe("matchMutes", () => {
+    it("should match events with muted pubkeys", () => {
+        const mutedEvent = mutedUser.note("Hello world");
+        const nonMutedEvent = nonMutedUser.note("Hello world");
+        // The event with the muted pubkey should match
+        expect(matchMutes(mutes, mutedEvent)).toBe(true);
+        // The event with a different pubkey should not match
+        expect(matchMutes(mutes, nonMutedEvent)).toBe(false);
+    });
+    it("should match events with muted hashtags", () => {
+        // Create events with and without the muted hashtag
+        const eventWithMutedHashtag = nonMutedUser.note("Hello world");
+        eventWithMutedHashtag.tags.push(["t", "nostr"]);
+        const eventWithDifferentHashtag = nonMutedUser.note("Hello world");
+        eventWithDifferentHashtag.tags.push(["t", "bitcoin"]);
+        const eventWithNoHashtag = nonMutedUser.note("Hello world");
+        // The event with the muted hashtag should match
+        expect(matchMutes(mutes, eventWithMutedHashtag)).toBe(true);
+        // The events without the muted hashtag should not match
+        expect(matchMutes(mutes, eventWithDifferentHashtag)).toBe(false);
+        expect(matchMutes(mutes, eventWithNoHashtag)).toBe(false);
+    });
+    it("should match events within threads", () => {
+        // Create a reply to the thread
+        const reply = nonMutedUser.note("Hello world");
+        reply.tags.push(["e", thread.id, "", "root"]);
+        // The reply should match the mute
+        expect(matchMutes(mutes, reply)).toBe(true);
+        // The thread should not match the mute
+        expect(matchMutes(mutes, thread)).toBe(false);
+    });
+    it("should match events with muted words", () => {
+        // The event with the muted word should match
+        expect(matchMutes(mutes, nonMutedUser.note("GM"))).toBe(true);
+        // Should not match other words that contain the muted word
+        expect(matchMutes(mutes, nonMutedUser.note("GMing"))).toBe(false);
+        // Should be case-insensitive
+        expect(matchMutes(mutes, nonMutedUser.note("gm"))).toBe(true);
+        // Should match if the muted word
+        expect(matchMutes(mutes, nonMutedUser.note("Hello GM world"))).toBe(true);
+    });
+});

package/dist/helpers/event.d.ts

@@ -24,11 +24,16 @@ export declare function isReplaceable(kind: number): boolean;
 /**
  * Returns the events Unique ID
  * For normal or ephemeral events this is ( event.id )
- * For replaceable events this is ( event.kind + ":" + event.pubkey )
- * For parametrized replaceable events this is ( event.kind + ":" + event.pubkey + ":" + event.tags.d.1 )
+ * For replaceable events this is ( event.kind + ":" + event.pubkey + ":" )
+ * For parametrized replaceable events this is ( event.kind + ":" + event.pubkey + ":" + event.tags.d )
  */
 export declare function getEventUID(event: NostrEvent): string;
-export declare function getReplaceableUID(kind: number, pubkey: string, d?: string): string;
+/** Returns the replaceable event address for an addressable event */
+export declare function getReplaceableAddress(event: NostrEvent): string;
+/** Creates a replaceable event address from a kind, pubkey, and identifier */
+export declare function createReplaceableAddress(kind: number, pubkey: string, identifier?: string): string;
+/** @deprecated use createReplaceableAddress instead */
+export declare const getReplaceableUID: typeof createReplaceableAddress;
 /** Returns a Set of tag names and values that are indexable */
 export declare function getIndexableTags(event: NostrEvent): Set<string>;
 /**

package/dist/helpers/event.js

@@ -1,8 +1,8 @@
-import { kinds, verifiedSymbol } from "nostr-tools";
+import { verifiedSymbol } from "nostr-tools";
 import { INDEXABLE_TAGS } from "../event-store/common.js";
 import { getHiddenTags } from "./hidden-tags.js";
 import { getOrComputeCachedValue } from "./cache.js";
-import { isParameterizedReplaceableKind } from "nostr-tools/kinds";
+import { isAddressableKind, isReplaceableKind } from "nostr-tools/kinds";
 import { EventStoreSymbol } from "../event-store/event-store.js";
 export const EventUIDSymbol = Symbol.for("event-uid");
 export const EventIndexableTagsSymbol = Symbol.for("indexable-tags");
@@ -29,30 +29,38 @@ export function isEvent(event) {
  * or parameterized replaceable ( 30000 <= n < 40000 )
  */
 export function isReplaceable(kind) {
-    return kinds.isReplaceableKind(kind) || kinds.isParameterizedReplaceableKind(kind);
+    return isReplaceableKind(kind) || isAddressableKind(kind);
 }
 /**
  * Returns the events Unique ID
  * For normal or ephemeral events this is ( event.id )
- * For replaceable events this is ( event.kind + ":" + event.pubkey )
- * For parametrized replaceable events this is ( event.kind + ":" + event.pubkey + ":" + event.tags.d.1 )
+ * For replaceable events this is ( event.kind + ":" + event.pubkey + ":" )
+ * For parametrized replaceable events this is ( event.kind + ":" + event.pubkey + ":" + event.tags.d )
  */
 export function getEventUID(event) {
     let uid = event[EventUIDSymbol];
     if (!uid) {
-        if (isReplaceable(event.kind)) {
-            let d = event.tags.find((t) => t[0] === "d")?.[1];
-            uid = getReplaceableUID(event.kind, event.pubkey, d);
-        }
+        if (isReplaceable(event.kind))
+            uid = getReplaceableAddress(event);
         else
             uid = event.id;
         event[EventUIDSymbol] = uid;
     }
     return uid;
 }
-export function getReplaceableUID(kind, pubkey, d) {
-    return d ? kind + ":" + pubkey + ":" + d : kind + ":" + pubkey;
+/** Returns the replaceable event address for an addressable event */
+export function getReplaceableAddress(event) {
+    if (!isReplaceable(event.kind))
+        throw new Error("Event is not replaceable or addressable");
+    const identifier = isAddressableKind(event.kind) ? getReplaceableIdentifier(event) : undefined;
+    return createReplaceableAddress(event.kind, event.pubkey, identifier);
+}
+/** Creates a replaceable event address from a kind, pubkey, and identifier */
+export function createReplaceableAddress(kind, pubkey, identifier) {
+    return kind + ":" + pubkey + ":" + (identifier ?? "");
 }
+/** @deprecated use createReplaceableAddress instead */
+export const getReplaceableUID = createReplaceableAddress;
 /** Returns a Set of tag names and values that are indexable */
 export function getIndexableTags(event) {
     let indexable = event[EventIndexableTagsSymbol];
@@ -100,8 +108,8 @@ export function getParentEventStore(event) {
  * @throws
  */
 export function getReplaceableIdentifier(event) {
-    if (!isParameterizedReplaceableKind(event.kind))
-        throw new Error("Event is not replaceable");
+    if (!isAddressableKind(event.kind))
+        throw new Error("Event is not addressable");
     return getOrComputeCachedValue(event, ReplaceableIdentifierSymbol, () => {
         const d = getTagValue(event, "d");
         if (d === undefined)

package/dist/helpers/lists.js

@@ -1,4 +1,4 @@
-import { isParameterizedReplaceableKind, isReplaceableKind } from "nostr-tools/kinds";
+import { isAddressableKind, isReplaceableKind } from "nostr-tools/kinds";
 import { getHiddenTags } from "./hidden-tags.js";
 import { getAddressPointerFromATag, getCoordinateFromAddressPointer, getEventPointerFromETag, getProfilePointerFromPTag, } from "./pointers.js";
 import { isATag, isETag, isPTag, processTags } from "./tags.js";
@@ -49,7 +49,7 @@ export function getProfilePointersFromList(list) {
 /** Returns if an event is a valid list or set */
 export function isValidList(event) {
     try {
-        if (isParameterizedReplaceableKind(event.kind)) {
+        if (isAddressableKind(event.kind)) {
             // event is a set
             // ensure the set has an identifier
             getReplaceableIdentifier(event);

package/dist/helpers/mutes.d.ts

@@ -17,3 +17,7 @@ export declare function getMutedThings(mute: NostrEvent): Mutes;
 export declare function getPublicMutedThings(mute: NostrEvent): Mutes;
 /** Returns the hidden muted content if the event is unlocked */
 export declare function getHiddenMutedThings(mute: NostrEvent): Mutes | undefined;
+/** Creates a RegExp for matching muted words */
+export declare function createMutedWordsRegExp(mutedWords: string[]): RegExp;
+/** Returns true if the event matches the mutes */
+export declare function matchMutes(mutes: Mutes, event: NostrEvent): boolean;

package/dist/helpers/mutes.js

@@ -1,6 +1,8 @@
+import { kinds } from "nostr-tools";
 import { isETag, isPTag, isTTag } from "./tags.js";
 import { getOrComputeCachedValue } from "./cache.js";
 import { getHiddenTags, isHiddenTagsLocked } from "./hidden-tags.js";
+import { getIndexableTags, getNip10References } from "./index.js";
 export const MutePublicSymbol = Symbol.for("mute-public");
 export const MuteHiddenSymbol = Symbol.for("mute-hidden");
 /** Merges any number of mute sets */
@@ -44,3 +46,40 @@ export function getHiddenMutedThings(mute) {
         return undefined;
     return getOrComputeCachedValue(mute, MuteHiddenSymbol, () => parseMutedTags(getHiddenTags(mute)));
 }
+/** Creates a RegExp for matching muted words */
+export function createMutedWordsRegExp(mutedWords) {
+    // Escape special characters and join with |
+    const escapedWords = mutedWords.map((word) => word.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"));
+    // Create the RegExp with word boundaries and case insensitive flag
+    return new RegExp(`\\b(${escapedWords.join("|")})\\b`, "gi");
+}
+/** Returns true if the event matches the mutes */
+export function matchMutes(mutes, event) {
+    // Filter on muted pubkeys
+    if (mutes.pubkeys.size > 0) {
+        if (mutes.pubkeys.has(event.pubkey))
+            return true;
+    }
+    // Filter on muted hashtags`
+    if (mutes.hashtags.size > 0) {
+        const tags = getIndexableTags(event);
+        for (let tag of mutes.hashtags) {
+            if (tags.has("t:" + tag))
+                return true;
+        }
+    }
+    // Filter on muted threads
+    if (mutes.threads.size > 0 && event.kind === kinds.ShortTextNote) {
+        const refs = getNip10References(event);
+        if (refs.root?.e && mutes.threads.has(refs.root.e.id))
+            return true;
+    }
+    // Filter on muted words
+    if (mutes.words.size > 0) {
+        const regExp = createMutedWordsRegExp(Array.from(mutes.words));
+        if (regExp.test(event.content))
+            return true;
+    }
+    // Event does not match any mutes
+    return false;
+}

package/dist/helpers/pointers.js

@@ -1,7 +1,7 @@
 import { naddrEncode, neventEncode, noteEncode, nprofileEncode, npubEncode, nsecEncode, } from "nostr-tools/nip19";
 import { getPublicKey, kinds } from "nostr-tools";
 import { getReplaceableIdentifier } from "./event.js";
-import { isParameterizedReplaceableKind } from "nostr-tools/kinds";
+import { isAddressableKind } from "nostr-tools/kinds";
 import { isSafeRelayURL } from "./relays.js";
 export function parseCoordinate(a, requireD = false, silent = true) {
     const parts = a.split(":");
@@ -155,7 +155,7 @@ export function getCoordinateFromAddressPointer(pointer) {
  * @throws
  */
 export function getAddressPointerForEvent(event, relays) {
-    if (!isParameterizedReplaceableKind(event.kind))
+    if (!isAddressableKind(event.kind))
         throw new Error("Cant get AddressPointer for non-replaceable event");
     const d = getReplaceableIdentifier(event);
     return {
@@ -179,7 +179,7 @@ export function getEventPointerForEvent(event, relays) {
 }
 /** Returns a pointer for a given event */
 export function getPointerForEvent(event, relays) {
-    if (kinds.isParameterizedReplaceableKind(event.kind)) {
+    if (kinds.isAddressableKind(event.kind)) {
         const d = getReplaceableIdentifier(event);
         return {
             type: "naddr",

package/dist/observable/__tests__/listen-latest-updates.test.d.ts

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

package/dist/observable/__tests__/listen-latest-updates.test.js

@@ -0,0 +1,55 @@
+import { beforeEach, describe, expect, it } from "vitest";
+import { subscribeSpyTo } from "@hirez_io/observer-spy";
+import { of } from "rxjs";
+import { EventStore } from "../../event-store/event-store.js";
+import { listenLatestUpdates } from "../listen-latest-updates.js";
+import { FakeUser } from "../../__tests__/fixtures.js";
+let eventStore;
+let user;
+let event;
+beforeEach(() => {
+    eventStore = new EventStore();
+    user = new FakeUser();
+    event = user.note("original content");
+});
+describe("listenLatestUpdates", () => {
+    it("should emit the initial event", () => {
+        const source = of(event);
+        const spy = subscribeSpyTo(source.pipe(listenLatestUpdates(eventStore)));
+        expect(spy.getValues()).toEqual([event]);
+    });
+    it("should emit the event again when it's updated in the event store", () => {
+        // Add the event to the store first
+        eventStore.add(event);
+        // Create a source that emits the event
+        const source = of(event);
+        const spy = subscribeSpyTo(source.pipe(listenLatestUpdates(eventStore)));
+        // Create an updated version of the event
+        Reflect.set(event, Symbol.for("new-prop"), "testing");
+        // Update the event in the store
+        eventStore.update(event);
+        // Should have received both the original and updated event
+        expect(spy.getValues()).toEqual([event, event]);
+    });
+    it("should not emit updates for other events", () => {
+        // Add the event to the store
+        eventStore.add(event);
+        // Create a source that emits the event
+        const source = of(event);
+        const spy = subscribeSpyTo(source.pipe(listenLatestUpdates(eventStore)));
+        // Create a different event
+        const otherEvent = user.note("other content");
+        // Add the other event to the store
+        eventStore.add(otherEvent);
+        // Should only have received the original event
+        expect(spy.getValues()).toEqual([event]);
+    });
+    it("should handle undefined initial event", () => {
+        const source = of(undefined);
+        const spy = subscribeSpyTo(source.pipe(listenLatestUpdates(eventStore)));
+        expect(spy.getValues()).toEqual([undefined]);
+        // Adding events to the store should not trigger emissions
+        eventStore.add(event);
+        expect(spy.getValues()).toEqual([undefined]);
+    });
+});

package/dist/queries/thread.js

@@ -3,7 +3,7 @@ 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],
@@ -71,7 +71,7 @@ export function RepliesQuery(event, overrideKinds) {
         if (isEvent(parent) || isEventPointer(event))
             filter["#e"] = [event.id];
         const address = isAddressableKind(event.kind)
-            ? getReplaceableUID(event.kind, event.pubkey, getTagValue(event, "d"))
+            ? createReplaceableAddress(event.kind, event.pubkey, getTagValue(event, "d"))
             : undefined;
         if (address) {
             filter["#a"] = [address];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "applesauce-core",
-  "version": "0.0.0-next-20250423181842",
+  "version": "0.0.0-next-20250424153457",
   "description": "",
   "type": "module",
   "main": "dist/index.js",