applesauce-core 0.1.0 → 0.3.0

package/README.md

@@ -0,0 +1,39 @@
+# applesauce-core
+
+AppleSauce Core is an interpretation layer for nostr clients, Push events into the in-memory [database](https://hzrd149.github.io/applesauce/classes/Database.html) and get nicely formatted data out with [queries](https://hzrd149.github.io/applesauce/modules/Queries)
+
+# Example
+
+```js
+import { EventStore, QueryStore } from "applesauce-core";
+import { Relay } from "nostr-tools/relay";
+
+// The EventStore handles all the events
+const eventStore = new EventStore();
+
+// The QueryStore handles queries and makes sure not to run multiple of the same query
+const queryStore = new QueryStore(eventStore);
+
+// Use nostr-tools or anything else to talk to relays
+const relay = await Relay.connect("wss://relay.example.com");
+
+const sub = relay.subscribe([{ authors: ["266815e0c9210dfa324c6cba3573b14bee49da4209a9456f9484e5106cd408a5"] }], {
+  onevent(event) {
+    eventStore.add(event);
+  },
+});
+
+// This will return an Observable<ProfileContent | undefined> of the parsed metadata
+const profile = queryStore.profile("266815e0c9210dfa324c6cba3573b14bee49da4209a9456f9484e5106cd408a5");
+
+profile.subscribe((parsed) => {
+  if (parsed) console.log(parsed);
+});
+
+// This will return an Observable<NostrEvent[]> of all kind 1 events sorted by created_at
+const timeline = queryStore.timeline({ kinds: [1] });
+
+timeline.subscribe((events) => {
+  console.log(events);
+});
+```

package/dist/event-store/database.d.ts

@@ -1,34 +1,78 @@
+/// <reference types="debug" />
+/// <reference types="zen-observable" />
 import { Filter, NostrEvent } from "nostr-tools";
-import { LRU } from "tiny-lru";
+import { LRU } from "../utils/lru.js";
+/**
+ * An in-memory database for nostr events
+ */
 export declare class Database {
     log: import("debug").Debugger;
-    /** Max number of events to hold */
-    max?: number;
     /** Indexes */
-    kinds: Map<number, Set<import("nostr-tools").Event>>;
-    authors: Map<string, Set<import("nostr-tools").Event>>;
-    tags: LRU<Set<import("nostr-tools").Event>>;
-    created_at: NostrEvent[];
+    protected kinds: Map<number, Set<import("nostr-tools").Event>>;
+    protected authors: Map<string, Set<import("nostr-tools").Event>>;
+    protected tags: LRU<Set<import("nostr-tools").Event>>;
+    protected created_at: NostrEvent[];
     /** LRU cache of last events touched */
     events: LRU<import("nostr-tools").Event>;
-    constructor(max?: number);
+    private insertedSignal;
+    private deletedSignal;
+    /** A stream of events inserted into the database */
+    inserted: {
+        subscribe(observer: ZenObservable.Observer<import("nostr-tools").Event>): ZenObservable.Subscription;
+        subscribe(onNext: (value: import("nostr-tools").Event) => void, onError?: ((error: any) => void) | undefined, onComplete?: (() => void) | undefined): ZenObservable.Subscription;
+        forEach(callback: (value: import("nostr-tools").Event) => void): Promise<void>;
+        map<R>(callback: (value: import("nostr-tools").Event) => R): import("zen-observable")<R>;
+        filter<S extends import("nostr-tools").Event>(callback: (value: import("nostr-tools").Event) => value is S): import("zen-observable")<S>;
+        filter(callback: (value: import("nostr-tools").Event) => boolean): import("zen-observable")<import("nostr-tools").Event>;
+        reduce(callback: (previousValue: import("nostr-tools").Event, currentValue: import("nostr-tools").Event) => import("nostr-tools").Event, initialValue?: import("nostr-tools").Event | undefined): import("zen-observable")<import("nostr-tools").Event>;
+        reduce<R_1>(callback: (previousValue: R_1, currentValue: import("nostr-tools").Event) => R_1, initialValue?: R_1 | undefined): import("zen-observable")<R_1>;
+        flatMap<R_2>(callback: (value: import("nostr-tools").Event) => ZenObservable.ObservableLike<R_2>): import("zen-observable")<R_2>;
+        concat<R_3>(...observable: import("zen-observable")<R_3>[]): import("zen-observable")<R_3>;
+    };
+    /** A stream of events removed of the database */
+    deleted: {
+        subscribe(observer: ZenObservable.Observer<import("nostr-tools").Event>): ZenObservable.Subscription;
+        subscribe(onNext: (value: import("nostr-tools").Event) => void, onError?: ((error: any) => void) | undefined, onComplete?: (() => void) | undefined): ZenObservable.Subscription;
+        forEach(callback: (value: import("nostr-tools").Event) => void): Promise<void>;
+        map<R>(callback: (value: import("nostr-tools").Event) => R): import("zen-observable")<R>;
+        filter<S extends import("nostr-tools").Event>(callback: (value: import("nostr-tools").Event) => value is S): import("zen-observable")<S>;
+        filter(callback: (value: import("nostr-tools").Event) => boolean): import("zen-observable")<import("nostr-tools").Event>;
+        reduce(callback: (previousValue: import("nostr-tools").Event, currentValue: import("nostr-tools").Event) => import("nostr-tools").Event, initialValue?: import("nostr-tools").Event | undefined): import("zen-observable")<import("nostr-tools").Event>;
+        reduce<R_1>(callback: (previousValue: R_1, currentValue: import("nostr-tools").Event) => R_1, initialValue?: R_1 | undefined): import("zen-observable")<R_1>;
+        flatMap<R_2>(callback: (value: import("nostr-tools").Event) => ZenObservable.ObservableLike<R_2>): import("zen-observable")<R_2>;
+        concat<R_3>(...observable: import("zen-observable")<R_3>[]): import("zen-observable")<R_3>;
+    };
+    protected claims: WeakMap<import("nostr-tools").Event, any>;
     /** Index helper methods */
-    private getKindIndex;
-    private getAuthorsIndex;
-    private getTagIndex;
+    protected getKindIndex(kind: number): Set<import("nostr-tools").Event>;
+    protected getAuthorsIndex(author: string): Set<import("nostr-tools").Event>;
+    protected getTagIndex(tagAndValue: string): Set<import("nostr-tools").Event>;
+    /** Moves an event to the top of the LRU cache */
     touch(event: NostrEvent): void;
     hasEvent(uid: string): import("nostr-tools").Event | undefined;
     getEvent(uid: string): import("nostr-tools").Event | undefined;
+    /** Checks if the database contains a replaceable event without touching it */
     hasReplaceable(kind: number, pubkey: string, d?: string): boolean;
+    /** Gets a replaceable event and touches it */
     getReplaceable(kind: number, pubkey: string, d?: string): import("nostr-tools").Event | undefined;
     addEvent(event: NostrEvent): import("nostr-tools").Event;
-    deleteEvent(eventOrId: string | NostrEvent): boolean;
+    deleteEvent(eventOrUID: string | NostrEvent): boolean;
+    /** Sets the claim on the event and touches it */
+    claimEvent(event: NostrEvent, claim: any): void;
+    /** Checks if an event is claimed by anything */
+    isClaimed(event: NostrEvent): boolean;
+    /** Removes a claim from an event */
+    removeClaim(event: NostrEvent, claim: any): void;
+    /** Removes all claims on an event */
+    clearClaim(event: NostrEvent): void;
     iterateAuthors(authors: Iterable<string>): Generator<import("nostr-tools").Event, void, unknown>;
     iterateTag(tag: string, values: Iterable<string>): Generator<import("nostr-tools").Event, void, unknown>;
     iterateKinds(kinds: Iterable<number>): Generator<import("nostr-tools").Event, void, unknown>;
     iterateTime(since: number | undefined, until: number | undefined): Generator<never, Set<import("nostr-tools").Event>, unknown>;
     iterateIds(ids: Iterable<string>): Generator<import("nostr-tools").Event, void, unknown>;
+    /** Returns all events that match the filter */
     getEventsForFilter(filter: Filter): Set<NostrEvent>;
     getForFilters(filters: Filter[]): Set<import("nostr-tools").Event>;
-    prune(): number | undefined;
+    /** Remove the oldest events that are not claimed */
+    prune(limit?: number): number;
 }

package/dist/event-store/database.js

@@ -1,12 +1,14 @@
-import { LRU } from "tiny-lru";
+import { binarySearch, insertEventIntoDescendingList } from "nostr-tools/utils";
+import PushStream from "zen-push";
 import { getEventUID, getIndexableTags, getReplaceableUID } from "../helpers/event.js";
 import { INDEXABLE_TAGS } from "./common.js";
 import { logger } from "../logger.js";
-import { binarySearch, insertEventIntoDescendingList } from "nostr-tools/utils";
+import { LRU } from "../utils/lru.js";
+/**
+ * An in-memory database for nostr events
+ */
 export class Database {
     log = logger.extend("Database");
-    /** Max number of events to hold */
-    max;
     /** Indexes */
     kinds = new Map();
     authors = new Map();
@@ -14,9 +16,13 @@ export class Database {
     created_at = [];
     /** LRU cache of last events touched */
     events = new LRU();
-    constructor(max) {
-        this.max = max;
-    }
+    insertedSignal = new PushStream();
+    deletedSignal = new PushStream();
+    /** A stream of events inserted into the database */
+    inserted = this.insertedSignal.observable;
+    /** A stream of events removed of the database */
+    deleted = this.deletedSignal.observable;
+    claims = new WeakMap();
     /** Index helper methods */
     getKindIndex(kind) {
         if (!this.kinds.has(kind))
@@ -45,6 +51,7 @@ export class Database {
         }
         return this.tags.get(tagAndValue);
     }
+    /** Moves an event to the top of the LRU cache */
     touch(event) {
         this.events.set(getEventUID(event), event);
     }
@@ -54,9 +61,11 @@ export class Database {
     getEvent(uid) {
         return this.events.get(uid);
     }
+    /** Checks if the database contains a replaceable event without touching it */
     hasReplaceable(kind, pubkey, d) {
         return this.events.has(getReplaceableUID(kind, pubkey, d));
     }
+    /** Gets a replaceable event and touches it */
     getReplaceable(kind, pubkey, d) {
         return this.events.get(getReplaceableUID(kind, pubkey, d));
     }
@@ -74,10 +83,11 @@ export class Database {
             }
         }
         insertEventIntoDescendingList(this.created_at, event);
+        this.insertedSignal.next(event);
         return event;
     }
-    deleteEvent(eventOrId) {
-        let event = typeof eventOrId === "string" ? this.events.get(eventOrId) : eventOrId;
+    deleteEvent(eventOrUID) {
+        let event = typeof eventOrUID === "string" ? this.events.get(eventOrUID) : eventOrUID;
         if (!event)
             throw new Error("Missing event");
         const uid = getEventUID(event);
@@ -95,8 +105,31 @@ export class Database {
         const i = this.created_at.indexOf(event);
         this.created_at.splice(i, 1);
         this.events.delete(uid);
+        this.deletedSignal.next(event);
         return true;
     }
+    /** Sets the claim on the event and touches it */
+    claimEvent(event, claim) {
+        if (!this.claims.has(event)) {
+            this.claims.set(event, claim);
+        }
+        // always touch event
+        this.touch(event);
+    }
+    /** Checks if an event is claimed by anything */
+    isClaimed(event) {
+        return this.claims.has(event);
+    }
+    /** Removes a claim from an event */
+    removeClaim(event, claim) {
+        const current = this.claims.get(event);
+        if (current === claim)
+            this.claims.delete(event);
+    }
+    /** Removes all claims on an event */
+    clearClaim(event) {
+        this.claims.delete(event);
+    }
     *iterateAuthors(authors) {
         for (const author of authors) {
             const events = this.authors.get(author);
@@ -157,6 +190,7 @@ export class Database {
                 yield this.events.get(id);
         }
     }
+    /** Returns all events that match the filter */
     getEventsForFilter(filter) {
         // search is not supported, return an empty set
         if (filter.search)
@@ -224,16 +258,19 @@ export class Database {
         }
         return events;
     }
-    prune() {
-        if (!this.max)
-            return;
+    /** Remove the oldest events that are not claimed */
+    prune(limit = 1000) {
         let removed = 0;
-        while (this.events.size > this.max) {
-            const event = this.events.first;
-            if (event) {
+        let cursor = this.events.first;
+        while (cursor) {
+            const event = cursor.value;
+            if (!this.isClaimed(event)) {
                 this.deleteEvent(event);
                 removed++;
+                if (removed >= limit)
+                    break;
             }
+            cursor = cursor.next;
         }
         return removed;
     }

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

@@ -5,6 +5,7 @@ export declare class EventStore {
     events: Database;
     private singles;
     private streams;
+    private timelines;
     constructor();
     add(event: NostrEvent, fromRelay?: string): import("nostr-tools").Event;
     getAll(filters: Filter[]): Set<import("nostr-tools").Event>;
@@ -13,7 +14,9 @@ export declare class EventStore {
     hasReplaceable(kind: number, pubkey: string, d?: string): boolean;
     getReplaceable(kind: number, pubkey: string, d?: string): import("nostr-tools").Event | undefined;
     /** Creates an observable that updates a single event */
-    single(uid: string): Observable<import("nostr-tools").Event>;
+    event(uid: string): Observable<import("nostr-tools").Event | undefined>;
+    /** Creates an observable that updates a single replaceable event */
+    replaceable(kind: number, pubkey: string, d?: string): Observable<import("nostr-tools").Event | undefined>;
     /** Creates an observable that streams all events that match the filter */
     stream(filters: Filter[]): Observable<import("nostr-tools").Event>;
     /** Creates an observable that updates with an array of sorted events */

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

@@ -1,31 +1,19 @@
 import { insertEventIntoDescendingList } from "nostr-tools/utils";
 import Observable from "zen-observable";
 import { Database } from "./database.js";
-import { getEventUID } from "../helpers/event.js";
+import { getEventUID, getReplaceableUID } from "../helpers/event.js";
 import { matchFilters } from "../helpers/filter.js";
 import { addSeenRelay } from "../helpers/relays.js";
 export class EventStore {
     events;
     singles = new Map();
     streams = new Map();
+    timelines = new Map();
     constructor() {
         this.events = new Database();
     }
     add(event, fromRelay) {
         const inserted = this.events.addEvent(event);
-        if (inserted === event) {
-            // forward to single event requests
-            const eventUID = getEventUID(event);
-            for (const [control, uid] of this.singles) {
-                if (eventUID === uid)
-                    control.next(event);
-            }
-            // forward to streams
-            for (const [control, filters] of this.streams) {
-                if (matchFilters(filters, event))
-                    control.next(event);
-            }
-        }
         if (fromRelay)
             addSeenRelay(inserted, fromRelay);
         return inserted;
@@ -46,35 +34,138 @@ export class EventStore {
         return this.events.getReplaceable(kind, pubkey, d);
     }
     /** Creates an observable that updates a single event */
-    single(uid) {
-        return new Observable((control) => {
-            const event = this.events.getEvent(uid);
-            if (event)
-                control.next(event);
-            this.singles.set(control, uid);
+    event(uid) {
+        return new Observable((observer) => {
+            let current = this.events.getEvent(uid);
+            if (current) {
+                observer.next(current);
+                this.events.claimEvent(current, observer);
+            }
+            // subscribe to future events
+            const inserted = this.events.inserted.subscribe((event) => {
+                if (getEventUID(event) === uid && (!current || event.created_at > current.created_at)) {
+                    // remove old claim
+                    if (current)
+                        this.events.removeClaim(current, observer);
+                    current = event;
+                    observer.next(event);
+                    // claim new event
+                    this.events.claimEvent(current, observer);
+                }
+            });
+            // subscribe to deleted events
+            const deleted = this.events.deleted.subscribe((event) => {
+                if (getEventUID(event) === uid && current) {
+                    this.events.removeClaim(current, observer);
+                    current = undefined;
+                    observer.next(undefined);
+                }
+            });
+            this.singles.set(observer, uid);
             return () => {
-                this.singles.delete(control);
+                inserted.unsubscribe();
+                deleted.unsubscribe();
+                this.singles.delete(observer);
+                if (current)
+                    this.events.removeClaim(current, observer);
             };
         });
     }
+    /** Creates an observable that updates a single replaceable event */
+    replaceable(kind, pubkey, d) {
+        return this.event(getReplaceableUID(kind, pubkey, d));
+    }
     /** Creates an observable that streams all events that match the filter */
     stream(filters) {
-        return new Observable((control) => {
-            const events = this.events.getForFilters(filters);
-            for (const event of events)
-                control.next(event);
-            this.streams.set(control, filters);
+        return new Observable((observer) => {
+            let claimed = new Set();
+            let events = this.events.getForFilters(filters);
+            for (const event of events) {
+                observer.next(event);
+                this.events.claimEvent(event, observer);
+                claimed.add(event);
+            }
+            // subscribe to future events
+            const sub = this.events.inserted.subscribe((event) => {
+                if (matchFilters(filters, event)) {
+                    observer.next(event);
+                    this.events.claimEvent(event, observer);
+                    claimed.add(event);
+                }
+            });
+            this.streams.set(observer, filters);
             return () => {
-                this.streams.delete(control);
+                sub.unsubscribe();
+                this.streams.delete(observer);
+                // remove all claims
+                for (const event of claimed)
+                    this.events.removeClaim(event, observer);
+                claimed.clear();
             };
         });
     }
     /** Creates an observable that updates with an array of sorted events */
     timeline(filters) {
-        let events = [];
-        return this.stream(filters).map((event) => {
-            insertEventIntoDescendingList(events, event);
-            return events;
+        return new Observable((observer) => {
+            const seen = new Map();
+            const timeline = [];
+            // build initial timeline
+            const events = this.events.getForFilters(filters);
+            for (const event of events) {
+                insertEventIntoDescendingList(timeline, event);
+                this.events.claimEvent(event, observer);
+                seen.set(getEventUID(event), event);
+            }
+            observer.next([...timeline]);
+            // subscribe to future events
+            const inserted = this.events.inserted.subscribe((event) => {
+                if (matchFilters(filters, event)) {
+                    const uid = getEventUID(event);
+                    let current = seen.get(uid);
+                    if (current) {
+                        if (event.created_at > current.created_at) {
+                            // replace event
+                            timeline.splice(timeline.indexOf(current), 1, event);
+                            observer.next([...timeline]);
+                            // update the claim
+                            seen.set(uid, event);
+                            this.events.removeClaim(current, observer);
+                            this.events.claimEvent(event, observer);
+                        }
+                    }
+                    else {
+                        insertEventIntoDescendingList(timeline, event);
+                        observer.next([...timeline]);
+                        // claim new event
+                        this.events.claimEvent(event, observer);
+                        seen.set(getEventUID(event), event);
+                    }
+                }
+            });
+            // subscribe to removed events
+            const deleted = this.events.deleted.subscribe((event) => {
+                const uid = getEventUID(event);
+                let current = seen.get(uid);
+                if (current) {
+                    // remove the event
+                    timeline.splice(timeline.indexOf(current), 1);
+                    observer.next([...timeline]);
+                    // remove the claim
+                    seen.delete(uid);
+                    this.events.removeClaim(current, observer);
+                }
+            });
+            this.timelines.set(observer, filters);
+            return () => {
+                this.timelines.delete(observer);
+                inserted.unsubscribe();
+                deleted.unsubscribe();
+                // remove all claims
+                for (const [_, event] of seen) {
+                    this.events.removeClaim(event, observer);
+                }
+                seen.clear();
+            };
         });
     }
 }

package/dist/event-store/index.d.ts

@@ -1 +1,2 @@
-export * from './event-store.js';
+export * from "./event-store.js";
+export * from "./database.js";

package/dist/event-store/index.js

@@ -1 +1,2 @@
-export * from './event-store.js';
+export * from "./event-store.js";
+export * from "./database.js";

package/dist/helpers/channel.d.ts

@@ -0,0 +1,15 @@
+import { nip19, NostrEvent } from "nostr-tools";
+import { ChannelMetadata } from "nostr-tools/nip28";
+export declare const ChannelMetadataSymbol: unique symbol;
+declare module "nostr-tools" {
+    interface Event {
+        [ChannelMetadataSymbol]?: ChannelMetadataContent;
+    }
+}
+export type ChannelMetadataContent = ChannelMetadata & {
+    relays?: string[];
+};
+/** Gets the parsed metadata on a channel creation or channel metadata event */
+export declare function getChannelMetadataContent(channel: NostrEvent): ChannelMetadataContent;
+/** gets the EventPointer for a channel message or metadata event */
+export declare function getChannelPointer(event: NostrEvent): nip19.EventPointer | undefined;

package/dist/helpers/channel.js

@@ -0,0 +1,27 @@
+export const ChannelMetadataSymbol = Symbol.for("channel-metadata");
+function parseChannelMetadataContent(channel) {
+    const metadata = JSON.parse(channel.content);
+    if (metadata.name === undefined)
+        throw new Error("Missing name");
+    if (metadata.about === undefined)
+        throw new Error("Missing about");
+    if (metadata.picture === undefined)
+        throw new Error("Missing picture");
+    if (metadata.relays && !Array.isArray(metadata.relays))
+        throw new Error("Invalid relays");
+    return metadata;
+}
+/** Gets the parsed metadata on a channel creation or channel metadata event */
+export function getChannelMetadataContent(channel) {
+    let metadata = channel[ChannelMetadataSymbol];
+    if (!metadata)
+        metadata = channel[ChannelMetadataSymbol] = parseChannelMetadataContent(channel);
+    return metadata;
+}
+/** gets the EventPointer for a channel message or metadata event */
+export function getChannelPointer(event) {
+    const tag = event.tags.find((t) => t[0] === "e" && t[1]);
+    if (!tag)
+        return undefined;
+    return tag[2] ? { id: tag[1], relays: [tag[2]] } : { id: tag[1] };
+}

package/dist/helpers/event.d.ts

@@ -1,4 +1,16 @@
 import { NostrEvent } from "nostr-tools";
+export declare const EventUIDSymbol: unique symbol;
+export declare const EventIndexableTagsSymbol: unique symbol;
+declare module "nostr-tools" {
+    interface Event {
+        [EventUIDSymbol]?: string;
+        [EventIndexableTagsSymbol]?: Set<string>;
+    }
+}
+/**
+ * Returns if a kind is replaceable ( 10000 <= n < 20000 || n == 0 || n == 3 )
+ * or parameterized replaceable ( 30000 <= n < 40000 )
+ */
 export declare function isReplaceable(kind: number): boolean;
 /** returns the events Unique ID */
 export declare function getEventUID(event: NostrEvent): string;

package/dist/helpers/event.js

@@ -1,34 +1,39 @@
 import { kinds } from "nostr-tools";
 import { INDEXABLE_TAGS } from "../event-store/common.js";
-import { EventIndexableTags, EventUID } from "./symbols.js";
+export const EventUIDSymbol = Symbol.for("event-uid");
+export const EventIndexableTagsSymbol = Symbol.for("indexable-tags");
+/**
+ * Returns if a kind is replaceable ( 10000 <= n < 20000 || n == 0 || n == 3 )
+ * or parameterized replaceable ( 30000 <= n < 40000 )
+ */
 export function isReplaceable(kind) {
     return kinds.isReplaceableKind(kind) || kinds.isParameterizedReplaceableKind(kind);
 }
 /** returns the events Unique ID */
 export function getEventUID(event) {
-    if (!event[EventUID]) {
+    if (!event[EventUIDSymbol]) {
         if (isReplaceable(event.kind)) {
             const d = event.tags.find((t) => t[0] === "d")?.[1];
-            event[EventUID] = getReplaceableUID(event.kind, event.pubkey, d);
+            event[EventUIDSymbol] = getReplaceableUID(event.kind, event.pubkey, d);
         }
         else {
-            event[EventUID] = event.id;
+            event[EventUIDSymbol] = event.id;
         }
     }
-    return event[EventUID];
+    return event[EventUIDSymbol];
 }
 export function getReplaceableUID(kind, pubkey, d) {
     return d ? `${kind}:${pubkey}:${d}` : `${kind}:${pubkey}`;
 }
 export function getIndexableTags(event) {
-    if (!event[EventIndexableTags]) {
+    if (!event[EventIndexableTagsSymbol]) {
         const tags = new Set();
         for (const tag of event.tags) {
             if (tag[0] && INDEXABLE_TAGS.has(tag[0]) && tag[1]) {
                 tags.add(tag[0] + ":" + tag[1]);
             }
         }
-        event[EventIndexableTags] = tags;
+        event[EventIndexableTagsSymbol] = tags;
     }
-    return event[EventIndexableTags];
+    return event[EventIndexableTagsSymbol];
 }

package/dist/helpers/filter.d.ts

@@ -1,3 +1,8 @@
 import { Filter, NostrEvent } from "nostr-tools";
+/**
+ * Copied from nostr-tools and modified to use getIndexableTags
+ * @see https://github.com/nbd-wtf/nostr-tools/blob/a61cde77eacc9518001f11d7f67f1a50ae05fd80/filter.ts
+ */
 export declare function matchFilter(filter: Filter, event: NostrEvent): boolean;
+/** Copied from nostr-tools */
 export declare function matchFilters(filters: Filter[], event: NostrEvent): boolean;

package/dist/helpers/filter.js

@@ -1,6 +1,8 @@
 import { getIndexableTags } from "./event.js";
-// Copied from https://github.com/nbd-wtf/nostr-tools/blob/a61cde77eacc9518001f11d7f67f1a50ae05fd80/filter.ts
-// And modified to use getIndexableTags
+/**
+ * Copied from nostr-tools and modified to use getIndexableTags
+ * @see https://github.com/nbd-wtf/nostr-tools/blob/a61cde77eacc9518001f11d7f67f1a50ae05fd80/filter.ts
+ */
 export function matchFilter(filter, event) {
     if (filter.ids && filter.ids.indexOf(event.id) === -1) {
         return false;
@@ -28,6 +30,7 @@ export function matchFilter(filter, event) {
         return false;
     return true;
 }
+/** Copied from nostr-tools */
 export function matchFilters(filters, event) {
     for (let i = 0; i < filters.length; i++) {
         if (matchFilter(filters[i], event)) {

package/dist/helpers/index.d.ts

@@ -2,4 +2,4 @@ export * from "./profile.js";
 export * from "./relays.js";
 export * from "./event.js";
 export * from "./filter.js";
-export * as symbols from "./symbols.js";
+export * from "./mailboxes.js";

package/dist/helpers/index.js

@@ -2,4 +2,4 @@ export * from "./profile.js";
 export * from "./relays.js";
 export * from "./event.js";
 export * from "./filter.js";
-export * as symbols from "./symbols.js";
+export * from "./mailboxes.js";

package/dist/helpers/json.d.ts

@@ -0,0 +1 @@
+export declare function safeParse<T extends unknown = any>(str: string): T | undefined;

package/dist/helpers/json.js

@@ -0,0 +1,8 @@
+export function safeParse(str) {
+    try {
+        return JSON.parse(str);
+    }
+    catch (error) {
+        return undefined;
+    }
+}