applesauce-core 0.5.0 → 0.7.0

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

@@ -1,12 +1,12 @@
 /// <reference types="debug" />
 /// <reference types="zen-observable" />
 import { Filter, NostrEvent } from "nostr-tools";
-import { LRU } from "../utils/lru.js";
+import { LRU } from "../helpers/lru.js";
 /**
  * An in-memory database for nostr events
  */
 export declare class Database {
-    log: import("debug").Debugger;
+    protected log: import("debug").Debugger;
     /** Indexes */
     protected kinds: Map<number, Set<import("nostr-tools").Event>>;
     protected authors: Map<string, Set<import("nostr-tools").Event>>;
@@ -15,6 +15,7 @@ export declare class Database {
     /** LRU cache of last events touched */
     events: LRU<import("nostr-tools").Event>;
     private insertedSignal;
+    private updatedSignal;
     private deletedSignal;
     /** A stream of events inserted into the database */
     inserted: {
@@ -29,6 +30,19 @@ export declare class Database {
         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 that have been updated */
+    updated: {
+        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;
@@ -42,6 +56,7 @@ export declare class Database {
         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>;
     };
+    get size(): number;
     protected claims: WeakMap<import("nostr-tools").Event, any>;
     /** Index helper methods */
     protected getKindIndex(kind: number): Set<import("nostr-tools").Event>;
@@ -55,7 +70,11 @@ export declare class Database {
     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;
+    /** Inserts an event into the database and notifies all subscriptions */
     addEvent(event: NostrEvent): import("nostr-tools").Event;
+    /** Inserts and event into the database and notifies all subscriptions that the event has updated */
+    updateEvent(event: NostrEvent): import("nostr-tools").Event;
+    /** Deletes an event from the database and notifies all subscriptions */
     deleteEvent(eventOrUID: string | NostrEvent): boolean;
     /** Sets the claim on the event and touches it */
     claimEvent(event: NostrEvent, claim: any): void;

package/dist/event-store/database.js

@@ -3,7 +3,7 @@ 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 { LRU } from "../utils/lru.js";
+import { LRU } from "../helpers/lru.js";
 /**
  * An in-memory database for nostr events
  */
@@ -17,11 +17,17 @@ export class Database {
     /** LRU cache of last events touched */
     events = new LRU();
     insertedSignal = new PushStream();
+    updatedSignal = new PushStream();
     deletedSignal = new PushStream();
     /** A stream of events inserted into the database */
     inserted = this.insertedSignal.observable;
+    /** A stream of events that have been updated */
+    updated = this.updatedSignal.observable;
     /** A stream of events removed of the database */
     deleted = this.deletedSignal.observable;
+    get size() {
+        return this.events.size;
+    }
     claims = new WeakMap();
     /** Index helper methods */
     getKindIndex(kind) {
@@ -69,6 +75,7 @@ export class Database {
     getReplaceable(kind, pubkey, d) {
         return this.events.get(getReplaceableUID(kind, pubkey, d));
     }
+    /** Inserts an event into the database and notifies all subscriptions */
     addEvent(event) {
         const uid = getEventUID(event);
         const current = this.events.get(uid);
@@ -86,6 +93,13 @@ export class Database {
         this.insertedSignal.next(event);
         return event;
     }
+    /** Inserts and event into the database and notifies all subscriptions that the event has updated */
+    updateEvent(event) {
+        const inserted = this.addEvent(event);
+        this.updatedSignal.next(inserted);
+        return inserted;
+    }
+    /** Deletes an event from the database and notifies all subscriptions */
     deleteEvent(eventOrUID) {
         let event = typeof eventOrUID === "string" ? this.events.get(eventOrUID) : eventOrUID;
         if (!event)

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

@@ -2,12 +2,15 @@ import { Filter, NostrEvent } from "nostr-tools";
 import Observable from "zen-observable";
 import { Database } from "./database.js";
 export declare class EventStore {
-    events: Database;
+    database: Database;
     private singles;
     private streams;
     private timelines;
     constructor();
+    /** Adds an event to the database */
     add(event: NostrEvent, fromRelay?: string): import("nostr-tools").Event;
+    /** Add an event to the store and notifies all subscribes it has updated */
+    update(event: NostrEvent): import("nostr-tools").Event;
     getAll(filters: Filter[]): Set<import("nostr-tools").Event>;
     hasEvent(uid: string): import("nostr-tools").Event | undefined;
     getEvent(uid: string): import("nostr-tools").Event | undefined;
@@ -15,6 +18,8 @@ export declare class EventStore {
     getReplaceable(kind: number, pubkey: string, d?: string): import("nostr-tools").Event | undefined;
     /** Creates an observable that updates a single event */
     event(uid: string): Observable<import("nostr-tools").Event | undefined>;
+    /** Creates an observable that subscribes to multiple events */
+    events(uids: string[]): Observable<Map<string, import("nostr-tools").Event>>;
     /** 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 */

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

@@ -5,58 +5,68 @@ import { getEventUID, getReplaceableUID } from "../helpers/event.js";
 import { matchFilters } from "../helpers/filter.js";
 import { addSeenRelay } from "../helpers/relays.js";
 export class EventStore {
-    events;
+    database;
     singles = new Map();
     streams = new Map();
     timelines = new Map();
     constructor() {
-        this.events = new Database();
+        this.database = new Database();
     }
+    /** Adds an event to the database */
     add(event, fromRelay) {
-        const inserted = this.events.addEvent(event);
+        const inserted = this.database.addEvent(event);
         if (fromRelay)
             addSeenRelay(inserted, fromRelay);
         return inserted;
     }
+    /** Add an event to the store and notifies all subscribes it has updated */
+    update(event) {
+        return this.database.updateEvent(event);
+    }
     getAll(filters) {
-        return this.events.getForFilters(filters);
+        return this.database.getForFilters(filters);
     }
     hasEvent(uid) {
-        return this.events.hasEvent(uid);
+        return this.database.hasEvent(uid);
     }
     getEvent(uid) {
-        return this.events.getEvent(uid);
+        return this.database.getEvent(uid);
     }
     hasReplaceable(kind, pubkey, d) {
-        return this.events.hasReplaceable(kind, pubkey, d);
+        return this.database.hasReplaceable(kind, pubkey, d);
     }
     getReplaceable(kind, pubkey, d) {
-        return this.events.getReplaceable(kind, pubkey, d);
+        return this.database.getReplaceable(kind, pubkey, d);
     }
     /** Creates an observable that updates a single event */
     event(uid) {
         return new Observable((observer) => {
-            let current = this.events.getEvent(uid);
+            let current = this.database.getEvent(uid);
             if (current) {
                 observer.next(current);
-                this.events.claimEvent(current, observer);
+                this.database.claimEvent(current, observer);
             }
             // subscribe to future events
-            const inserted = this.events.inserted.subscribe((event) => {
+            const inserted = this.database.inserted.subscribe((event) => {
                 if (getEventUID(event) === uid && (!current || event.created_at > current.created_at)) {
                     // remove old claim
                     if (current)
-                        this.events.removeClaim(current, observer);
+                        this.database.removeClaim(current, observer);
                     current = event;
                     observer.next(event);
                     // claim new event
-                    this.events.claimEvent(current, observer);
+                    this.database.claimEvent(current, observer);
                 }
             });
+            // subscribe to updates
+            const updated = this.database.updated.subscribe((event) => {
+                if (event === current)
+                    observer.next(event);
+            });
             // subscribe to deleted events
-            const deleted = this.events.deleted.subscribe((event) => {
+            const deleted = this.database.deleted.subscribe((event) => {
                 if (getEventUID(event) === uid && current) {
-                    this.events.removeClaim(current, observer);
+                    this.database.removeClaim(current, observer);
                     current = undefined;
                     observer.next(undefined);
                 }
@@ -65,9 +75,66 @@ export class EventStore {
             return () => {
                 inserted.unsubscribe();
                 deleted.unsubscribe();
+                updated.unsubscribe();
                 this.singles.delete(observer);
                 if (current)
-                    this.events.removeClaim(current, observer);
+                    this.database.removeClaim(current, observer);
+            };
+        });
+    }
+    /** Creates an observable that subscribes to multiple events */
+    events(uids) {
+        return new Observable((observer) => {
+            const events = new Map();
+            for (const uid of uids) {
+                const e = this.getEvent(uid);
+                if (e) {
+                    events.set(uid, e);
+                    this.database.claimEvent(e, observer);
+                }
+            }
+            observer.next(events);
+            // subscribe to future events
+            const inserted = this.database.inserted.subscribe((event) => {
+                const uid = getEventUID(event);
+                if (uids.includes(uid)) {
+                    const current = events.get(uid);
+                    // remove old claim
+                    if (!current || event.created_at > current.created_at) {
+                        if (current)
+                            this.database.removeClaim(current, observer);
+                        events.set(uid, event);
+                        observer.next(events);
+                        // claim new event
+                        this.database.claimEvent(event, observer);
+                    }
+                }
+            });
+            // subscribe to updates
+            const updated = this.database.updated.subscribe((event) => {
+                const uid = getEventUID(event);
+                if (uids.includes(uid))
+                    observer.next(events);
+            });
+            // subscribe to deleted events
+            const deleted = this.database.deleted.subscribe((event) => {
+                const uid = getEventUID(event);
+                if (uids.includes(uid)) {
+                    const current = events.get(uid);
+                    if (current) {
+                        this.database.removeClaim(current, observer);
+                        events.delete(uid);
+                        observer.next(events);
+                    }
+                }
+            });
+            return () => {
+                inserted.unsubscribe();
+                deleted.unsubscribe();
+                updated.unsubscribe();
+                for (const [_uid, event] of events) {
+                    this.database.removeClaim(event, observer);
+                }
             };
         });
     }
@@ -79,17 +146,17 @@ export class EventStore {
     stream(filters) {
         return new Observable((observer) => {
             let claimed = new Set();
-            let events = this.events.getForFilters(filters);
+            let events = this.database.getForFilters(filters);
             for (const event of events) {
                 observer.next(event);
-                this.events.claimEvent(event, observer);
+                this.database.claimEvent(event, observer);
                 claimed.add(event);
             }
             // subscribe to future events
-            const sub = this.events.inserted.subscribe((event) => {
+            const sub = this.database.inserted.subscribe((event) => {
                 if (matchFilters(filters, event)) {
                     observer.next(event);
-                    this.events.claimEvent(event, observer);
+                    this.database.claimEvent(event, observer);
                     claimed.add(event);
                 }
             });
@@ -99,7 +166,7 @@ export class EventStore {
                 this.streams.delete(observer);
                 // remove all claims
                 for (const event of claimed)
-                    this.events.removeClaim(event, observer);
+                    this.database.removeClaim(event, observer);
                 claimed.clear();
             };
         });
@@ -110,15 +177,15 @@ export class EventStore {
             const seen = new Map();
             const timeline = [];
             // build initial timeline
-            const events = this.events.getForFilters(filters);
+            const events = this.database.getForFilters(filters);
             for (const event of events) {
                 insertEventIntoDescendingList(timeline, event);
-                this.events.claimEvent(event, observer);
+                this.database.claimEvent(event, observer);
                 seen.set(getEventUID(event), event);
             }
             observer.next([...timeline]);
             // subscribe to future events
-            const inserted = this.events.inserted.subscribe((event) => {
+            const inserted = this.database.inserted.subscribe((event) => {
                 if (matchFilters(filters, event)) {
                     const uid = getEventUID(event);
                     let current = seen.get(uid);
@@ -129,21 +196,27 @@ export class EventStore {
                             observer.next([...timeline]);
                             // update the claim
                             seen.set(uid, event);
-                            this.events.removeClaim(current, observer);
-                            this.events.claimEvent(event, observer);
+                            this.database.removeClaim(current, observer);
+                            this.database.claimEvent(event, observer);
                         }
                     }
                     else {
                         insertEventIntoDescendingList(timeline, event);
                         observer.next([...timeline]);
                         // claim new event
-                        this.events.claimEvent(event, observer);
+                        this.database.claimEvent(event, observer);
                         seen.set(getEventUID(event), event);
                     }
                 }
             });
+            // subscribe to updates
+            const updated = this.database.updated.subscribe((event) => {
+                if (seen.has(getEventUID(event))) {
+                    observer.next([...timeline]);
+                }
+            });
             // subscribe to removed events
-            const deleted = this.events.deleted.subscribe((event) => {
+            const deleted = this.database.deleted.subscribe((event) => {
                 const uid = getEventUID(event);
                 let current = seen.get(uid);
                 if (current) {
@@ -152,7 +225,7 @@ export class EventStore {
                     observer.next([...timeline]);
                     // remove the claim
                     seen.delete(uid);
-                    this.events.removeClaim(current, observer);
+                    this.database.removeClaim(current, observer);
                 }
             });
             this.timelines.set(observer, filters);
@@ -160,9 +233,10 @@ export class EventStore {
                 this.timelines.delete(observer);
                 inserted.unsubscribe();
                 deleted.unsubscribe();
+                updated.unsubscribe();
                 // remove all claims
                 for (const [_, event] of seen) {
-                    this.events.removeClaim(event, observer);
+                    this.database.removeClaim(event, observer);
                 }
                 seen.clear();
             };

package/dist/helpers/cache.d.ts

@@ -0,0 +1,5 @@
+import { EventTemplate, NostrEvent } from "nostr-tools";
+export declare function getCachedValue<T extends unknown>(event: NostrEvent | EventTemplate, symbol: symbol): T | undefined;
+export declare function setCachedValue<T extends unknown>(event: NostrEvent | EventTemplate, symbol: symbol, value: T): void;
+/** Internal method used to cache computed values on events */
+export declare function getOrComputeCachedValue<T extends unknown>(event: NostrEvent | EventTemplate, symbol: symbol, compute: (event: NostrEvent | EventTemplate) => T): T;

package/dist/helpers/cache.js

@@ -0,0 +1,17 @@
+export function getCachedValue(event, symbol) {
+    // @ts-expect-error
+    return event[symbol];
+}
+export function setCachedValue(event, symbol, value) {
+    // @ts-expect-error
+    event[symbol] = value;
+}
+/** Internal method used to cache computed values on events */
+export function getOrComputeCachedValue(event, symbol, compute) {
+    let cached = getCachedValue(event, symbol);
+    if (!cached) {
+        // @ts-expect-error
+        cached = event[symbol] = compute(event);
+    }
+    return cached;
+}

package/dist/helpers/emoji.d.ts

@@ -0,0 +1,2 @@
+import { EventTemplate, NostrEvent } from "nostr-tools";
+export declare function getEmojiTag(event: NostrEvent | EventTemplate, code: string): ["emoji", string, string];

package/dist/helpers/emoji.js

@@ -0,0 +1,4 @@
+export function getEmojiTag(event, code) {
+    code = code.replace(/^:|:$/g, "").toLocaleLowerCase();
+    return event.tags.filter((t) => t[0] === "emoji" && t[1] && t[2]).find((t) => t[1].toLowerCase() === code);
+}

package/dist/helpers/hashtag.d.ts

@@ -0,0 +1,2 @@
+import { EventTemplate, NostrEvent } from "nostr-tools";
+export declare function getHashtagTag(event: NostrEvent | EventTemplate, hashtag: string): ["t", string];

package/dist/helpers/hashtag.js

@@ -0,0 +1,7 @@
+import { stripInvisibleChar } from "./string.js";
+export function getHashtagTag(event, hashtag) {
+    hashtag = stripInvisibleChar(hashtag.replace(/^#/, "").toLocaleLowerCase());
+    return event.tags
+        .filter((t) => t[0] === "t" && t[1])
+        .find((t) => stripInvisibleChar(t[1].toLowerCase()) === hashtag);
+}

package/dist/helpers/index.d.ts

@@ -6,3 +6,9 @@ export * from "./mailboxes.js";
 export * from "./threading.js";
 export * from "./pointers.js";
 export * from "./string.js";
+export * from "./time.js";
+export * from "./tags.js";
+export * from "./emoji.js";
+export * from "./lru.js";
+export * from "./hashtag.js";
+export * from "./url.js";

package/dist/helpers/index.js

@@ -6,3 +6,9 @@ export * from "./mailboxes.js";
 export * from "./threading.js";
 export * from "./pointers.js";
 export * from "./string.js";
+export * from "./time.js";
+export * from "./tags.js";
+export * from "./emoji.js";
+export * from "./lru.js";
+export * from "./hashtag.js";
+export * from "./url.js";

package/dist/helpers/string.d.ts

@@ -1,2 +1,4 @@
 export declare function isHex(str?: string): boolean;
 export declare function isHexKey(key?: string): boolean;
+export declare function stripInvisibleChar(str: string): string;
+export declare function stripInvisibleChar(str?: string | undefined): string | undefined;

package/dist/helpers/string.js

@@ -8,3 +8,6 @@ export function isHexKey(key) {
         return true;
     return false;
 }
+export function stripInvisibleChar(str) {
+    return str && str.replaceAll(/[\p{Cf}\p{Zs}]/gu, "");
+}

package/dist/helpers/tags.d.ts

@@ -0,0 +1,6 @@
+export declare function isETag(tag: string[]): tag is ["e", string, ...string[]];
+export declare function isPTag(tag: string[]): tag is ["p", string, ...string[]];
+export declare function isRTag(tag: string[]): tag is ["r", string, ...string[]];
+export declare function isDTag(tag: string[]): tag is ["d", string, ...string[]];
+export declare function isATag(tag: string[]): tag is ["a", string, ...string[]];
+export declare function isTTag(tag: string[]): tag is ["t", string, ...string[]];

package/dist/helpers/tags.js

@@ -0,0 +1,18 @@
+export function isETag(tag) {
+    return tag[0] === "e" && tag[1] !== undefined;
+}
+export function isPTag(tag) {
+    return tag[0] === "p" && tag[1] !== undefined;
+}
+export function isRTag(tag) {
+    return tag[0] === "r" && tag[1] !== undefined;
+}
+export function isDTag(tag) {
+    return tag[0] === "d" && tag[1] !== undefined;
+}
+export function isATag(tag) {
+    return tag[0] === "a" && tag[1] !== undefined;
+}
+export function isTTag(tag) {
+    return tag[0] === "a" && tag[1] !== undefined;
+}

package/dist/helpers/time.d.ts

@@ -0,0 +1,2 @@
+/** Returns the current unix timestamp */
+export declare function unixNow(): number;

package/dist/helpers/time.js

@@ -0,0 +1,4 @@
+/** Returns the current unix timestamp */
+export function unixNow() {
+    return Math.round(Date.now() / 1000);
+}

package/dist/helpers/url.d.ts

@@ -0,0 +1,11 @@
+export declare const convertToUrl: (url: string | URL) => URL;
+export declare const getURLFilename: (url: URL) => string | undefined;
+export declare const IMAGE_EXT: string[];
+export declare const VIDEO_EXT: string[];
+export declare const STREAM_EXT: string[];
+export declare const AUDIO_EXT: string[];
+export declare function isVisualMediaURL(url: string | URL): boolean;
+export declare function isImageURL(url: string | URL): boolean;
+export declare function isVideoURL(url: string | URL): boolean;
+export declare function isStreamURL(url: string | URL): boolean;
+export declare function isAudioURL(url: string | URL): boolean;

package/dist/helpers/url.js

@@ -0,0 +1,29 @@
+export const convertToUrl = (url) => (url instanceof URL ? url : new URL(url));
+export const getURLFilename = (url) => url.pathname.split("/").pop()?.toLocaleLowerCase() || url.searchParams.get("filename")?.toLocaleLowerCase();
+export const IMAGE_EXT = [".svg", ".gif", ".png", ".jpg", ".jpeg", ".webp", ".avif"];
+export const VIDEO_EXT = [".mp4", ".mkv", ".webm", ".mov"];
+export const STREAM_EXT = [".m3u8"];
+export const AUDIO_EXT = [".mp3", ".wav", ".ogg", ".aac"];
+export function isVisualMediaURL(url) {
+    return isImageURL(url) || isVideoURL(url) || isStreamURL(url);
+}
+export function isImageURL(url) {
+    url = convertToUrl(url);
+    const filename = getURLFilename(url);
+    return !!filename && IMAGE_EXT.some((ext) => filename.endsWith(ext));
+}
+export function isVideoURL(url) {
+    url = convertToUrl(url);
+    const filename = getURLFilename(url);
+    return !!filename && VIDEO_EXT.some((ext) => filename.endsWith(ext));
+}
+export function isStreamURL(url) {
+    url = convertToUrl(url);
+    const filename = getURLFilename(url);
+    return !!filename && STREAM_EXT.some((ext) => filename.endsWith(ext));
+}
+export function isAudioURL(url) {
+    url = convertToUrl(url);
+    const filename = getURLFilename(url);
+    return !!filename && AUDIO_EXT.some((ext) => filename.endsWith(ext));
+}

package/dist/index.d.ts

@@ -1,4 +1,4 @@
 export * from "./event-store/index.js";
 export * from "./query-store/index.js";
-export * as helpers from "./helpers/index.js";
+export * as Helpers from "./helpers/index.js";
 export * as Queries from "./queries/index.js";

package/dist/index.js

@@ -1,4 +1,4 @@
 export * from "./event-store/index.js";
 export * from "./query-store/index.js";
-export * as helpers from "./helpers/index.js";
+export * as Helpers from "./helpers/index.js";
 export * as Queries from "./queries/index.js";

package/dist/observable/getValue.d.ts

@@ -0,0 +1,2 @@
+import Observable from "zen-observable";
+export declare function getValue<T>(observable: Observable<T>): T | Promise<T>;

package/dist/observable/getValue.js

@@ -0,0 +1,11 @@
+import { isStateful } from "./stateful.js";
+export function getValue(observable) {
+    if (isStateful(observable) && observable.value !== undefined)
+        return observable.value;
+    return new Promise((res) => {
+        const sub = observable.subscribe((v) => {
+            res(v);
+            sub.unsubscribe();
+        });
+    });
+}

package/dist/observable/index.d.ts

@@ -1,2 +1,3 @@
 export * from "./stateful.js";
 export * from "./throttle.js";
+export * from "./getValue.js";

package/dist/observable/index.js

@@ -1,2 +1,3 @@
 export * from "./stateful.js";
 export * from "./throttle.js";
+export * from "./getValue.js";

package/dist/queries/index.d.ts

@@ -2,5 +2,4 @@ export * from "./simple.js";
 export * from "./profile.js";
 export * from "./mailboxes.js";
 export * from "./reactions.js";
-export * from "./mute.js";
 export * from "./thread.js";

package/dist/queries/index.js

@@ -2,5 +2,4 @@ export * from "./simple.js";
 export * from "./profile.js";
 export * from "./mailboxes.js";
 export * from "./reactions.js";
-export * from "./mute.js";
 export * from "./thread.js";

package/dist/queries/simple.d.ts

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

package/dist/queries/simple.js

@@ -1,5 +1,5 @@
 import stringify from "json-stringify-deterministic";
-import { getEventUID, getReplaceableUID } from "../helpers/event.js";
+import { getReplaceableUID } from "../helpers/event.js";
 /** Creates a Query that returns a single event or undefined */
 export function SingleEventQuery(uid) {
     return {
@@ -7,6 +7,13 @@ export function SingleEventQuery(uid) {
         run: (events) => events.event(uid),
     };
 }
+/** Creates a Query that returns a multiple events in a map */
+export function MultipleEventsQuery(uids) {
+    return {
+        key: uids.join(","),
+        run: (events) => events.events(uids),
+    };
+}
 /** Creates a Query returning the latest version of a replaceable event */
 export function ReplaceableQuery(kind, pubkey, d) {
     return {
@@ -22,11 +29,10 @@ export function TimelineQuery(filters) {
     };
 }
 /** Creates a Query that returns a directory of events by their UID */
-export function ReplaceableSetQuery(filters) {
+export function ReplaceableSetQuery(pointers) {
+    const cords = pointers.map((pointer) => getReplaceableUID(pointer.kind, pointer.pubkey, pointer.identifier));
     return {
-        key: stringify(filters),
-        run: (events) => events
-            .timeline(Array.isArray(filters) ? filters : [filters])
-            .map((events) => events.reduce((dir, event) => ({ ...dir, [getEventUID(event)]: event }), {})),
+        key: stringify(pointers),
+        run: (events) => events.events(cords),
     };
 }

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

@@ -1,7 +1,8 @@
 import Observable from "zen-observable";
 import { Filter, NostrEvent } from "nostr-tools";
 import { EventStore } from "../event-store/event-store.js";
-import { LRU } from "../utils/lru.js";
+import { StatefulObservable } from "../observable/stateful.js";
+import { LRU } from "../helpers/lru.js";
 import * as Queries from "../queries/index.js";
 import { AddressPointer, EventPointer } from "nostr-tools/nip19";
 export type Query<T extends unknown> = {
@@ -13,7 +14,7 @@ export declare class QueryStore {
     static Queries: typeof Queries;
     store: EventStore;
     constructor(store: EventStore);
-    queries: LRU<Observable<any>>;
+    queries: LRU<StatefulObservable<any>>;
     /** Creates a cached query */
     runQuery<T extends unknown, Args extends Array<any>>(queryConstructor: (...args: Args) => {
         key: string;
@@ -21,10 +22,16 @@ export declare class QueryStore {
     }): (...args: Args) => Observable<T>;
     /** Returns a single event */
     event(id: string): Observable<import("nostr-tools").Event | undefined>;
+    /** Returns a single event */
+    events(ids: string[]): Observable<Map<string, import("nostr-tools").Event>>;
     /** Returns the latest version of a replaceable event */
     replaceable(kind: number, pubkey: string, d?: string): Observable<import("nostr-tools").Event | undefined>;
     /** Returns a directory of events by their UID */
-    replaceableSet(filters: Filter | Filter[]): Observable<Record<string, import("nostr-tools").Event>>;
+    replaceableSet(pointers: {
+        kind: number;
+        pubkey: string;
+        identifier?: string;
+    }[]): Observable<Map<string, import("nostr-tools").Event>>;
     /** Returns an array of events that match the filter */
     timeline(filters: Filter | Filter[]): Observable<import("nostr-tools").Event[]>;
     /** Returns the parsed profile (0) for a pubkey */
@@ -36,13 +43,6 @@ export declare class QueryStore {
         inboxes: Set<string>;
         outboxes: Set<string>;
     } | undefined>;
-    /** Returns the parsed mute list for the pubkey */
-    mute(pubkey: string): Observable<{
-        words: Set<string>;
-        pubkeys: Set<string>;
-        threads: Set<string>;
-        hashtags: Set<string>;
-    } | undefined>;
     thread(root: string | EventPointer | AddressPointer): Observable<Queries.Thread>;
 }
 export { Queries };

package/dist/query-store/index.js

@@ -1,5 +1,5 @@
 import { stateful } from "../observable/stateful.js";
-import { LRU } from "../utils/lru.js";
+import { LRU } from "../helpers/lru.js";
 import * as Queries from "../queries/index.js";
 export class QueryStore {
     static Queries = Queries;
@@ -25,13 +25,17 @@ export class QueryStore {
     event(id) {
         return this.runQuery(Queries.SingleEventQuery)(id);
     }
+    /** Returns a single event */
+    events(ids) {
+        return this.runQuery(Queries.MultipleEventsQuery)(ids);
+    }
     /** Returns the latest version of a replaceable event */
     replaceable(kind, pubkey, d) {
         return this.runQuery(Queries.ReplaceableQuery)(kind, pubkey, d);
     }
     /** Returns a directory of events by their UID */
-    replaceableSet(filters) {
-        return this.runQuery(Queries.ReplaceableSetQuery)(filters);
+    replaceableSet(pointers) {
+        return this.runQuery(Queries.ReplaceableSetQuery)(pointers);
     }
     /** Returns an array of events that match the filter */
     timeline(filters) {
@@ -49,10 +53,6 @@ export class QueryStore {
     mailboxes(pubkey) {
         return this.runQuery(Queries.MailboxesQuery)(pubkey);
     }
-    /** Returns the parsed mute list for the pubkey */
-    mute(pubkey) {
-        return this.runQuery(Queries.UserMuteQuery)(pubkey);
-    }
     thread(root) {
         return this.runQuery(Queries.ThreadQuery)(root);
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "applesauce-core",
-  "version": "0.5.0",
+  "version": "0.7.0",
   "description": "",
   "type": "module",
   "main": "dist/index.js",
@@ -22,10 +22,18 @@
       "import": "./dist/helpers/index.js",
       "types": "./dist/helpers/index.d.ts"
     },
+    "./helpers/*": {
+      "import": "./dist/helpers/*.js",
+      "types": "./dist/helpers/*.d.ts"
+    },
     "./queries": {
       "import": "./dist/queries/index.js",
       "types": "./dist/queries/index.d.ts"
     },
+    "./queries/*": {
+      "import": "./dist/queries/*.js",
+      "types": "./dist/queries/*.d.ts"
+    },
     "./observable": {
       "import": "./dist/observable/index.js",
       "types": "./dist/observable/index.d.ts"

package/dist/helpers/mute.d.ts

@@ -1,21 +0,0 @@
-import { NostrEvent } from "nostr-tools";
-export declare const MutePubkeysSymbol: unique symbol;
-export declare const MuteThreadsSymbol: unique symbol;
-export declare const MuteHashtagsSymbol: unique symbol;
-export declare const MuteWordsSymbol: unique symbol;
-declare module "nostr-tools" {
-    interface Event {
-        [MutePubkeysSymbol]?: Set<string>;
-        [MuteThreadsSymbol]?: Set<string>;
-        [MuteHashtagsSymbol]?: Set<string>;
-        [MuteWordsSymbol]?: Set<string>;
-    }
-}
-/** Returns a set of muted pubkeys */
-export declare function getMutedPubkeys(mute: NostrEvent): Set<string>;
-/** Returns a set of muted threads */
-export declare function getMutedThreads(mute: NostrEvent): Set<string>;
-/** Returns a set of muted words ( lowercase ) */
-export declare function getMutedWords(mute: NostrEvent): Set<string>;
-/** Returns a set of muted hashtags ( lowercase ) */
-export declare function getMutedHashtags(mute: NostrEvent): Set<string>;

package/dist/helpers/mute.js

@@ -1,52 +0,0 @@
-export const MutePubkeysSymbol = Symbol.for("mute-pubkeys");
-export const MuteThreadsSymbol = Symbol.for("mute-threads");
-export const MuteHashtagsSymbol = Symbol.for("mute-hashtags");
-export const MuteWordsSymbol = Symbol.for("mute-words");
-/** Returns a set of muted pubkeys */
-export function getMutedPubkeys(mute) {
-    let pubkeys = mute[MutePubkeysSymbol];
-    if (!pubkeys) {
-        pubkeys = mute[MutePubkeysSymbol] = new Set();
-        for (const tag of mute.tags) {
-            if (tag[0] === "p" && tag[1])
-                pubkeys.add(tag[1]);
-        }
-    }
-    return pubkeys;
-}
-/** Returns a set of muted threads */
-export function getMutedThreads(mute) {
-    let threads = mute[MuteThreadsSymbol];
-    if (!threads) {
-        threads = mute[MuteThreadsSymbol] = new Set();
-        for (const tag of mute.tags) {
-            if (tag[0] === "e" && tag[1])
-                threads.add(tag[1]);
-        }
-    }
-    return threads;
-}
-/** Returns a set of muted words ( lowercase ) */
-export function getMutedWords(mute) {
-    let words = mute[MuteWordsSymbol];
-    if (!words) {
-        words = mute[MuteWordsSymbol] = new Set();
-        for (const tag of mute.tags) {
-            if (tag[0] === "word" && tag[1])
-                words.add(tag[1].toLocaleLowerCase());
-        }
-    }
-    return words;
-}
-/** Returns a set of muted hashtags ( lowercase ) */
-export function getMutedHashtags(mute) {
-    let hashtags = mute[MuteHashtagsSymbol];
-    if (!hashtags) {
-        hashtags = mute[MuteHashtagsSymbol] = new Set();
-        for (const tag of mute.tags) {
-            if (tag[0] === "t" && tag[1])
-                hashtags.add(tag[1].toLocaleLowerCase());
-        }
-    }
-    return hashtags;
-}

package/dist/queries/mute.d.ts

@@ -1,7 +0,0 @@
-import { Query } from "../query-store/index.js";
-export declare function UserMuteQuery(pubkey: string): Query<{
-    words: Set<string>;
-    pubkeys: Set<string>;
-    threads: Set<string>;
-    hashtags: Set<string>;
-} | undefined>;

package/dist/queries/mute.js

@@ -1,16 +0,0 @@
-import { kinds } from "nostr-tools";
-import { getMutedHashtags, getMutedPubkeys, getMutedThreads, getMutedWords } from "../helpers/mute.js";
-export function UserMuteQuery(pubkey) {
-    return {
-        key: pubkey,
-        run: (store) => store.replaceable(kinds.Mutelist, pubkey).map((event) => {
-            if (!event)
-                return;
-            const pubkeys = getMutedPubkeys(event);
-            const threads = getMutedThreads(event);
-            const hashtags = getMutedHashtags(event);
-            const words = getMutedWords(event);
-            return { pubkeys, threads, hashtags, words };
-        }),
-    };
-}