applesauce-core 1.2.0 → 2.1.0

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

@@ -1,49 +1,59 @@
 import { kinds } from "nostr-tools";
-import { insertEventIntoDescendingList } from "nostr-tools/utils";
 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, createReplaceableAddress, getTagValue, isReplaceable, } from "../helpers/event.js";
-import { matchFilters } from "../helpers/filter.js";
-import { addSeenRelay, getSeenRelays } from "../helpers/relays.js";
+import { EMPTY, filter, finalize, from, merge, mergeMap, ReplaySubject, share, take, timer } from "rxjs";
+import hash_sum from "hash-sum";
 import { getDeleteCoordinates, getDeleteIds } from "../helpers/delete.js";
-import { claimEvents } from "../observable/claim-events.js";
-import { claimLatest } from "../observable/claim-latest.js";
+import { FromCacheSymbol, getReplaceableAddress, getTagValue, isReplaceable } from "../helpers/event.js";
+import { matchFilters } from "../helpers/filter.js";
 import { parseCoordinate } from "../helpers/pointers.js";
+import { addSeenRelay, getSeenRelays } from "../helpers/relays.js";
+import { EventModel, EventsModel, ReplaceableModel, ReplaceableSetModel, TimelineModel } from "../models/common.js";
+import { EventSet } from "./event-set.js";
+import { ProfileModel } from "../models/profile.js";
+import { ContactsModel } from "../models/contacts.js";
+import { MuteModel } from "../models/mutes.js";
+import { ReactionsModel } from "../models/reactions.js";
+import { MailboxesModel } from "../models/mailboxes.js";
+import { UserBlossomServersModel } from "../models/blossom.js";
+import { CommentsModel, ThreadModel } from "../models/index.js";
+/** A symbol on an event that marks which event store its part of */
 export const EventStoreSymbol = Symbol.for("event-store");
-function sortDesc(a, b) {
-    return b.created_at - a.created_at;
-}
 export class EventStore {
     database;
     /** Enable this to keep old versions of replaceable events */
     keepOldVersions = false;
-    /** A method used to verify new events before added them */
+    /**
+     * A method used to verify new events before added them
+     * @returns true if the event is valid, false if it should be ignored
+     */
     verifyEvent;
     /** A stream of new events added to the store */
-    inserts;
+    insert$;
     /** A stream of events that have been updated */
-    updates;
+    update$;
     /** A stream of events that have been removed */
-    removes;
+    remove$;
     constructor() {
-        this.database = new Database();
+        this.database = new EventSet();
+        // verify events before they are added to the database
         this.database.onBeforeInsert = (event) => {
-            // reject events that are invalid
+            // Ignore events that are invalid
             if (this.verifyEvent && this.verifyEvent(event) === false)
-                throw new Error("Invalid event");
+                return false;
+            else
+                return true;
         };
         // when events are added to the database, add the symbol
-        this.database.inserted.subscribe((event) => {
+        this.database.insert$.subscribe((event) => {
             Reflect.set(event, EventStoreSymbol, this);
         });
         // when events are removed from the database, remove the symbol
-        this.database.removed.subscribe((event) => {
+        this.database.remove$.subscribe((event) => {
             Reflect.deleteProperty(event, EventStoreSymbol);
         });
-        this.inserts = this.database.inserted;
-        this.updates = this.database.updated;
-        this.removes = this.database.removed;
+        this.insert$ = this.database.insert$;
+        this.update$ = this.database.update$;
+        this.remove$ = this.database.remove$;
     }
     // delete state
     deletedIds = new Set();
@@ -55,7 +65,7 @@ export class EventStore {
             if (this.deletedIds.has(event.id))
                 return true;
             if (isAddressableKind(event.kind)) {
-                const deleted = this.deletedCoords.get(getEventUID(event));
+                const deleted = this.deletedCoords.get(getReplaceableAddress(event));
                 if (deleted)
                     return deleted > event.created_at;
             }
@@ -70,7 +80,7 @@ export class EventStore {
             // remove deleted events in the database
             const event = this.database.getEvent(id);
             if (event)
-                this.database.removeEvent(event);
+                this.database.remove(event);
         }
         const coords = getDeleteCoordinates(deleteEvent);
         for (const coord of coords) {
@@ -80,10 +90,10 @@ export class EventStore {
             if (!parsed)
                 continue;
             // Remove older versions of replaceable events
-            const events = this.database.getReplaceable(parsed.kind, parsed.pubkey, parsed.identifier) ?? [];
+            const events = this.database.getReplaceableHistory(parsed.kind, parsed.pubkey, parsed.identifier) ?? [];
             for (const event of events) {
                 if (event.created_at < deleteEvent.created_at)
-                    this.database.removeEvent(event);
+                    this.database.remove(event);
             }
         }
     }
@@ -100,8 +110,8 @@ export class EventStore {
             Reflect.set(dest, FromCacheSymbol, fromCache);
     }
     /**
-     * Adds an event to the database and update subscriptions
-     * @throws
+     * Adds an event to the store and update subscriptions
+     * @returns The existing event or the event that was added, if it was ignored returns null
      */
     add(event, fromRelay) {
         if (event.kind === kinds.EventDeletion)
@@ -113,7 +123,7 @@ export class EventStore {
         const d = isReplaceable(event.kind) ? getTagValue(event, "d") : undefined;
         // Don't insert the event if there is already a newer version
         if (!this.keepOldVersions && isReplaceable(event.kind)) {
-            const existing = this.database.getReplaceable(event.kind, event.pubkey, d);
+            const existing = this.database.getReplaceableHistory(event.kind, event.pubkey, d);
             // If there is already a newer version, copy cached symbols and return existing event
             if (existing && existing.length > 0 && existing[0].created_at >= event.created_at) {
                 EventStore.mergeDuplicateEvent(event, existing[0]);
@@ -129,7 +139,10 @@ export class EventStore {
             }
         }
         // Insert event into database
-        const inserted = this.database.addEvent(event);
+        const inserted = this.database.add(event);
+        // If the event was ignored, return null
+        if (inserted === null)
+            return null;
         // Copy cached data if its a duplicate event
         if (event !== inserted)
             EventStore.mergeDuplicateEvent(event, inserted);
@@ -138,11 +151,11 @@ export class EventStore {
             addSeenRelay(inserted, fromRelay);
         // remove all old version of the replaceable event
         if (!this.keepOldVersions && isReplaceable(event.kind)) {
-            const existing = this.database.getReplaceable(event.kind, event.pubkey, d);
+            const existing = this.database.getReplaceableHistory(event.kind, event.pubkey, d);
             if (existing) {
                 const older = Array.from(existing).filter((e) => e.created_at < event.created_at);
                 for (const old of older)
-                    this.database.removeEvent(old);
+                    this.database.remove(old);
                 // return the newest version of the replaceable event
                 // most of the time this will be === event, but not always
                 if (existing.length !== older.length)
@@ -153,24 +166,21 @@ export class EventStore {
     }
     /** Removes an event from the database and updates subscriptions */
     remove(event) {
-        return this.database.removeEvent(event);
-    }
-    /** Removes any event that is not being used by a subscription */
-    prune(max) {
-        return this.database.prune(max);
+        return this.database.remove(event);
     }
     /** Add an event to the store and notifies all subscribes it has updated */
     update(event) {
-        return this.database.updateEvent(event);
+        return this.database.update(event);
     }
-    /** Get all events matching a filter */
-    getAll(filters) {
-        return this.database.getEventsForFilters(Array.isArray(filters) ? filters : [filters]);
+    /** Removes any event that is not being used by a subscription */
+    prune(max) {
+        return this.database.prune(max);
     }
-    /** Check if the store has an event */
+    /** Check if the store has an event by id */
     hasEvent(id) {
         return this.database.hasEvent(id);
     }
+    /** Get an event by id from the store */
     getEvent(id) {
         return this.database.getEvent(id);
     }
@@ -179,19 +189,73 @@ export class EventStore {
         return this.database.hasReplaceable(kind, pubkey, d);
     }
     /** Gets the latest version of a replaceable event */
-    getReplaceable(kind, pubkey, d) {
-        return this.database.getReplaceable(kind, pubkey, d)?.[0];
+    getReplaceable(kind, pubkey, identifier) {
+        return this.database.getReplaceable(kind, pubkey, identifier);
     }
     /** Returns all versions of a replaceable event */
-    getReplaceableHistory(kind, pubkey, d) {
-        return this.database.getReplaceable(kind, pubkey, d);
+    getReplaceableHistory(kind, pubkey, identifier) {
+        return this.database.getReplaceableHistory(kind, pubkey, identifier);
+    }
+    /** Get all events matching a filter */
+    getByFilters(filters) {
+        return this.database.getByFilters(filters);
     }
     /** Returns a timeline of events that match filters */
     getTimeline(filters) {
-        return Array.from(this.database.getEventsForFilters(Array.isArray(filters) ? filters : [filters])).sort(sortDesc);
+        return this.database.getTimeline(filters);
+    }
+    /** Sets the claim on the event and touches it */
+    claim(event, claim) {
+        this.database.claim(event, claim);
+    }
+    /** Checks if an event is claimed by anything */
+    isClaimed(event) {
+        return this.database.isClaimed(event);
+    }
+    /** Removes a claim from an event */
+    removeClaim(event, claim) {
+        this.database.removeClaim(event, claim);
+    }
+    /** Removes all claims on an event */
+    clearClaim(event) {
+        this.database.clearClaim(event);
+    }
+    /** A directory of all active models */
+    models = new Map();
+    /** How long a model should be kept "warm" while nothing is subscribed to it */
+    modelKeepWarm = 60_000;
+    /** Get or create a model on the event store */
+    model(constructor, ...args) {
+        let models = this.models.get(constructor);
+        if (!models) {
+            models = new Map();
+            this.models.set(constructor, models);
+        }
+        const key = constructor.getKey ? constructor.getKey(...args) : hash_sum(args);
+        let model = models.get(key);
+        // Create the model if it does not exist
+        if (!model) {
+            const cleanup = () => {
+                // Remove the model from the cache if its the same one
+                if (models.get(key) === model)
+                    models.delete(key);
+            };
+            model = constructor(...args)(this).pipe(
+            // remove the model when its unsubscribed
+            finalize(cleanup), 
+            // only subscribe to models once for all subscriptions
+            share({
+                connector: () => new ReplaySubject(1),
+                resetOnComplete: () => timer(this.modelKeepWarm),
+                resetOnRefCountZero: () => timer(this.modelKeepWarm),
+            }));
+            // Add the model to the cache
+            models.set(key, model);
+        }
+        return model;
     }
     /**
-     * Creates an observable that streams all events that match the filter and remains open
+     * Creates an observable that streams all events that match the filter
      * @param filters
      * @param [onlyNew=false] Only subscribe to new events
      */
@@ -199,16 +263,16 @@ export class EventStore {
         filters = Array.isArray(filters) ? filters : [filters];
         return merge(
         // merge existing events
-        onlyNew ? EMPTY : from(this.getAll(filters)), 
+        onlyNew ? EMPTY : from(this.getByFilters(filters)), 
         // subscribe to future events
-        this.inserts.pipe(filter((e) => matchFilters(filters, e))));
+        this.insert$.pipe(filter((e) => matchFilters(filters, e))));
     }
     /** Returns an observable that completes when an event is removed */
     removed(id) {
         const deleted = this.checkDeleted(id);
         if (deleted)
             return EMPTY;
-        return this.removes.pipe(
+        return this.remove$.pipe(
         // listen for removed events
         filter((e) => e.id === id), 
         // complete as soon as we find a matching removed event
@@ -218,166 +282,59 @@ export class EventStore {
     }
     /** Creates an observable that emits when event is updated */
     updated(event) {
-        return this.database.updated.pipe(filter((e) => e.id === event || e === event));
+        return this.database.update$.pipe(filter((e) => e.id === event || e === event));
     }
-    /** Creates an observable that subscribes to a single event */
+    // Helper methods for creating models
+    /** Creates a {@link EventModel} */
     event(id) {
-        return merge(
-        // get current event and ignore if there is none
-        defer(() => {
-            let event = this.getEvent(id);
-            return event ? of(event) : EMPTY;
-        }), 
-        // subscribe to updates
-        this.inserts.pipe(filter((e) => e.id === id)), 
-        // subscribe to updates
-        this.updated(id), 
-        // emit undefined when deleted
-        this.removed(id).pipe(endWith(undefined))).pipe(
-        // claim all events
-        claimLatest(this.database));
-    }
-    /** Creates an observable that subscribes to multiple events */
+        return this.model(EventModel, id);
+    }
+    /** Creates a {@link ReplaceableModel} */
+    replaceable(kind, pubkey, identifier) {
+        return this.model(ReplaceableModel, kind, pubkey, identifier);
+    }
+    /** Creates a {@link TimelineModel} */
+    timeline(filters, includeOldVersion = false) {
+        return this.model(TimelineModel, filters, includeOldVersion);
+    }
+    /** Creates a {@link EventsModel} */
     events(ids) {
-        return merge(
-        // lazily get existing events
-        defer(() => from(ids.map((id) => this.getEvent(id)))), 
-        // subscribe to new events
-        this.inserts.pipe(filter((e) => ids.includes(e.id))), 
-        // subscribe to updates
-        this.updates.pipe(filter((e) => ids.includes(e.id)))).pipe(
-        // ignore empty messages
-        filter((e) => !!e), 
-        // claim all events until cleanup
-        claimEvents(this.database), 
-        // watch for removed events
-        mergeWith(this.removes.pipe(filter((e) => ids.includes(e.id)), map((e) => e.id))), 
-        // merge all events into a directory
-        scan((dir, event) => {
-            if (typeof event === "string") {
-                // delete event by id
-                const clone = { ...dir };
-                delete clone[event];
-                return clone;
-            }
-            else {
-                // add even to directory
-                return { ...dir, [event.id]: event };
-            }
-        }, {}));
+        return this.model(EventsModel, ids);
     }
-    /** Creates an observable that subscribes to the latest version of a replaceable event */
-    replaceable(kind, pubkey, d) {
-        let current = undefined;
-        return merge(
-        // lazily get current event
-        defer(() => {
-            let event = this.getReplaceable(kind, pubkey, d);
-            return event ? of(event) : EMPTY;
-        }), 
-        // subscribe to new events
-        this.inserts.pipe(filter((e) => e.pubkey == pubkey && e.kind === kind && (d !== undefined ? getReplaceableIdentifier(e) === d : true)))).pipe(
-        // only update if event is newer
-        distinctUntilChanged((prev, event) => {
-            // are the events the same? i.e. is the prev event older
-            return prev.created_at >= event.created_at;
-        }), 
-        // Hacky way to extract the current event so takeUntil can access it
-        tap((event) => (current = event)), 
-        // complete when event is removed
-        takeUntil(this.removes.pipe(filter((e) => e.id === current?.id))), 
-        // emit undefined when removed
-        endWith(undefined), 
-        // keep the observable hot
-        repeat(), 
-        // claim latest event
-        claimLatest(this.database));
-    }
-    /** Creates an observable that subscribes to the latest version of an array of replaceable events*/
+    /** Creates a {@link ReplaceableSetModel} */
     replaceableSet(pointers) {
-        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)))), 
-        // subscribe to new events
-        this.inserts.pipe(filter((e) => isReplaceable(e.kind) && uids.has(getEventUID(e))))).pipe(
-        // filter out undefined
-        filter((e) => !!e), 
-        // claim all events
-        claimEvents(this.database), 
-        // convert events to add commands
-        map((e) => ["add", e]), 
-        // watch for removed events
-        mergeWith(this.removes.pipe(filter((e) => isReplaceable(e.kind) && uids.has(getEventUID(e))), map((e) => ["remove", e]))), 
-        // reduce events into directory
-        scan((dir, [action, event]) => {
-            const uid = getEventUID(event);
-            if (action === "add") {
-                // add event to dir if its newer
-                if (!dir[uid] || dir[uid].created_at < event.created_at)
-                    return { ...dir, [uid]: event };
-            }
-            else if (action === "remove" && dir[uid] === event) {
-                // remove event from dir
-                let newDir = { ...dir };
-                delete newDir[uid];
-                return newDir;
-            }
-            return dir;
-        }, {}), 
-        // ignore changes that do not modify the directory
-        distinctUntilChanged());
+        return this.model(ReplaceableSetModel, pointers);
     }
-    /** Creates an observable that updates with an array of sorted events */
-    timeline(filters, keepOldVersions = false) {
-        filters = Array.isArray(filters) ? filters : [filters];
-        const seen = new Map();
-        // get current events
-        return defer(() => of(Array.from(this.database.getEventsForFilters(filters)).sort(sortDesc))).pipe(
-        // claim existing events
-        claimEvents(this.database), 
-        // subscribe to newer events
-        mergeWith(this.inserts.pipe(filter((e) => matchFilters(filters, e)), 
-        // claim all new events
-        claimEvents(this.database))), 
-        // subscribe to delete events
-        mergeWith(this.removes.pipe(filter((e) => matchFilters(filters, e)), map((e) => e.id))), 
-        // build a timeline
-        scan((timeline, event) => {
-            // filter out removed events from timeline
-            if (typeof event === "string")
-                return timeline.filter((e) => e.id !== event);
-            // initial timeline array
-            if (Array.isArray(event)) {
-                if (!keepOldVersions) {
-                    for (const e of event)
-                        if (isReplaceable(e.kind))
-                            seen.set(getEventUID(e), e);
-                }
-                return event;
-            }
-            // create a new timeline and insert the event into it
-            let newTimeline = [...timeline];
-            // remove old replaceable events if enabled
-            if (!keepOldVersions && isReplaceable(event.kind)) {
-                const uid = getEventUID(event);
-                const existing = seen.get(uid);
-                // if this is an older replaceable event, exit
-                if (existing && event.created_at < existing.created_at)
-                    return timeline;
-                // update latest version
-                seen.set(uid, event);
-                // remove old event from timeline
-                if (existing)
-                    newTimeline.slice(newTimeline.indexOf(existing), 1);
-            }
-            // add event into timeline
-            insertEventIntoDescendingList(newTimeline, event);
-            return newTimeline;
-        }, []), 
-        // ignore changes that do not modify the timeline instance
-        distinctUntilChanged(), 
-        // hacky hack to clear seen on unsubscribe
-        finalize(() => seen.clear()));
+    /** Creates a {@link ProfileModel} */
+    profile(pubkey) {
+        return this.model(ProfileModel, pubkey);
+    }
+    /** Creates a {@link ContactsModel} */
+    contacts(pubkey) {
+        return this.model(ContactsModel, pubkey);
+    }
+    /** Creates a {@link MuteModel} */
+    mutes(pubkey) {
+        return this.model(MuteModel, pubkey);
+    }
+    /** Creates a {@link ReactionsModel} */
+    reactions(event) {
+        return this.model(ReactionsModel, event);
+    }
+    /** Creates a {@link MailboxesModel} */
+    mailboxes(pubkey) {
+        return this.model(MailboxesModel, pubkey);
+    }
+    /** Creates a {@link UserBlossomServersModel} */
+    blossomServers(pubkey) {
+        return this.model(UserBlossomServersModel, pubkey);
+    }
+    /** Creates a {@link ThreadModel} */
+    thread(root) {
+        return this.model(ThreadModel, root);
+    }
+    /** Creates a {@link CommentsModel} */
+    comments(event) {
+        return this.model(CommentsModel, event);
     }
 }

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

@@ -1,3 +1,3 @@
 export * from "./event-store.js";
-export * from "./database.js";
+export * from "./event-set.js";
 export * from "./interface.js";

package/dist/event-store/index.js

@@ -1,3 +1,3 @@
 export * from "./event-store.js";
-export * from "./database.js";
+export * from "./event-set.js";
 export * from "./interface.js";

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

@@ -1,21 +1,58 @@
 import { Filter, NostrEvent } from "nostr-tools";
+import { AddressPointer, EventPointer, ProfilePointer } from "nostr-tools/nip19";
 import { Observable } from "rxjs";
-export interface ISyncEventStore {
+import { LRU } from "../helpers/lru.js";
+import { Mutes } from "../helpers/mutes.js";
+import { ProfileContent } from "../helpers/profile.js";
+import { Thread } from "../models/thread.js";
+/** The read interface for an event store */
+export interface IEventStoreRead {
+    /** Check if the event store has an event with id */
     hasEvent(id: string): boolean;
+    /** Check if the event store has a replaceable event */
     hasReplaceable(kind: number, pubkey: string, identifier?: string): boolean;
+    /** Get an event by id */
     getEvent(id: string): NostrEvent | undefined;
+    /** Get a replaceable event */
     getReplaceable(kind: number, pubkey: string, identifier?: string): NostrEvent | undefined;
+    /** Get the history of a replaceable event */
     getReplaceableHistory(kind: number, pubkey: string, identifier?: string): NostrEvent[] | undefined;
-    getAll(filters: Filter | Filter[]): Set<NostrEvent>;
+    /** Get all events that match the filters */
+    getByFilters(filters: Filter | Filter[]): Set<NostrEvent>;
+    /** Get a timeline of events that match the filters */
     getTimeline(filters: Filter | Filter[]): NostrEvent[];
 }
-export interface IStreamEventStore {
-    inserts: Observable<NostrEvent>;
-    updates: Observable<NostrEvent>;
-    removes: Observable<NostrEvent>;
-    filters(filters: Filter | Filter[]): Observable<NostrEvent>;
-    updated(id: string | NostrEvent): Observable<NostrEvent>;
-    removed(id: string): Observable<never>;
+/** The stream interface for an event store */
+export interface IEventStoreStreams {
+    /** A stream of new events added to the store */
+    insert$: Observable<NostrEvent>;
+    /** A stream of events that have been updated */
+    update$: Observable<NostrEvent>;
+    /** A stream of events that have been removed */
+    remove$: Observable<NostrEvent>;
+}
+/** The actions for an event store */
+export interface IEventStoreActions {
+    /** Add an event to the store */
+    add(event: NostrEvent): NostrEvent | null;
+    /** Remove an event from the store */
+    remove(event: string | NostrEvent): boolean;
+    /** Notify the store that an event has updated */
+    update(event: NostrEvent): void;
+}
+/** The claim interface for an event store */
+export interface IEventClaims {
+    /** Sets the claim on the event and touches it */
+    claim(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;
+}
+/** Methods for creating common models */
+export interface IEventStoreModels {
     event(id: string): Observable<NostrEvent | undefined>;
     events(ids: string[]): Observable<Record<string, NostrEvent>>;
     replaceable(kind: number, pubkey: string, identifier?: string): Observable<NostrEvent | undefined>;
@@ -25,9 +62,30 @@ export interface IStreamEventStore {
         identifier?: string;
     }[]): Observable<Record<string, NostrEvent>>;
     timeline(filters: Filter | Filter[], includeOldVersion?: boolean): Observable<NostrEvent[]>;
+    profile(pubkey: string): Observable<ProfileContent | undefined>;
+    contacts(pubkey: string): Observable<ProfilePointer[]>;
+    mutes(pubkey: string): Observable<Mutes | undefined>;
+    reactions(event: NostrEvent): Observable<NostrEvent[]>;
+    mailboxes(pubkey: string): Observable<{
+        inboxes: string[];
+        outboxes: string[];
+    } | undefined>;
+    blossomServers(pubkey: string): Observable<URL[]>;
+    thread(root: string | EventPointer | AddressPointer): Observable<Thread>;
 }
-export interface IEventStore extends ISyncEventStore, IStreamEventStore {
-    add(event: NostrEvent, fromRelay?: string): NostrEvent;
-    remove(event: string | NostrEvent): boolean;
-    update(event: NostrEvent): NostrEvent;
+/** A computed view of an event set or event store */
+export type Model<T extends unknown> = (events: IEventStore) => Observable<T>;
+/** A constructor for a {@link Model} */
+export type ModelConstructor<T extends unknown, Args extends Array<any>> = ((...args: Args) => Model<T>) & {
+    getKey?: (...args: Args) => string;
+};
+/** The base interface for a set of events */
+export interface IEventSet extends IEventStoreRead, IEventStoreStreams, IEventStoreActions, IEventClaims {
+    events: LRU<NostrEvent>;
+}
+export interface IEventStore extends IEventStoreRead, IEventStoreStreams, IEventStoreActions, IEventStoreModels, IEventClaims {
+    filters(filters: Filter | Filter[]): Observable<NostrEvent>;
+    updated(id: string | NostrEvent): Observable<NostrEvent>;
+    removed(id: string): Observable<never>;
+    model<T extends unknown, Args extends Array<any>>(constructor: ModelConstructor<T, Args>, ...args: Args): Observable<T>;
 }

package/dist/helpers/app-handlers.d.ts

@@ -0,0 +1,23 @@
+import { NostrEvent } from "nostr-tools";
+import { AddressPointer, EventPointer, ProfilePointer } from "nostr-tools/nip19";
+import { DecodeResult } from "./pointers.js";
+export type HandlerLinkPlatform = "web" | "ios" | "android";
+export type HandlerLinkType = DecodeResult["type"];
+/** Returns an array of supported kinds for a given handler */
+export declare function getHandlerSupportedKinds(handler: NostrEvent): number[];
+/** Returns the name of the handler */
+export declare function getHandlerName(handler: NostrEvent): string;
+/** Returns the picture of the handler */
+export declare function getHandlerPicture(handler: NostrEvent, fallback?: string): string | undefined;
+/** Returns the description of the handler */
+export declare function getHandlerDescription(handler: NostrEvent): string | undefined;
+/** Returns the web link template for a handler and type */
+export declare function getHandlerLinkTemplate(handler: NostrEvent, platform?: HandlerLinkPlatform, type?: HandlerLinkType): string | undefined;
+/** Returns a link for a Profile Pointer */
+export declare function createHandlerProfileLink(handler: NostrEvent, pointer: ProfilePointer, platform?: HandlerLinkPlatform): string | undefined;
+/** Returns a link for an Event Pointer */
+export declare function createHandlerEventLink(handler: NostrEvent, pointer: EventPointer, platform?: HandlerLinkPlatform): string | undefined;
+/** Returns a link for an Address Pointer */
+export declare function createHandlerAddressLink(handler: NostrEvent, pointer: AddressPointer, platform?: HandlerLinkPlatform): string | undefined;
+/** Creates a handler link for a pointer and optionally fallsback to a web link */
+export declare function createHandlerLink(handler: NostrEvent, pointer: AddressPointer | EventPointer | ProfilePointer, platform?: HandlerLinkPlatform, webFallback?: boolean): string | undefined;