applesauce-core 0.4.0 → 0.6.0

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

@@ -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;
@@ -55,7 +69,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

@@ -17,9 +17,12 @@ 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;
     claims = new WeakMap();
@@ -69,6 +72,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 +90,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/index.d.ts

@@ -5,3 +5,6 @@ export * from "./filter.js";
 export * from "./mailboxes.js";
 export * from "./threading.js";
 export * from "./pointers.js";
+export * from "./string.js";
+export * from "./time.js";
+export * from "./tags.js";

package/dist/helpers/index.js

@@ -5,3 +5,6 @@ export * from "./filter.js";
 export * from "./mailboxes.js";
 export * from "./threading.js";
 export * from "./pointers.js";
+export * from "./string.js";
+export * from "./time.js";
+export * from "./tags.js";

package/dist/helpers/string.d.ts

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

package/dist/helpers/string.js

@@ -0,0 +1,10 @@
+export function isHex(str) {
+    if (str?.match(/^[0-9a-f]+$/i))
+        return true;
+    return false;
+}
+export function isHexKey(key) {
+    if (key?.toLowerCase()?.match(/^[0-9a-f]{64}$/))
+        return true;
+    return false;
+}

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/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/promise/deferred.d.ts

@@ -2,4 +2,4 @@ export type Deferred<T> = Promise<T> & {
     resolve: (value?: T | PromiseLike<T>) => void;
     reject: (reason?: any) => void;
 };
-export default function createDefer<T>(): Deferred<T>;
+export declare function createDefer<T>(): Deferred<T>;

package/dist/promise/deferred.js

@@ -1,4 +1,4 @@
-export default function createDefer() {
+export function createDefer() {
     let _resolve;
     let _reject;
     const promise = new Promise((resolve, reject) => {

package/dist/queries/index.d.ts

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

package/dist/queries/index.js

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

package/dist/queries/simple.d.ts

@@ -1,5 +1,16 @@
 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(pointers: {
+    kind: number;
+    pubkey: string;
+    identifier?: string;
+}[]): Query<Map<string, NostrEvent>>;

package/dist/queries/simple.js

@@ -1,20 +1,38 @@
 import stringify from "json-stringify-deterministic";
 import { getReplaceableUID } from "../helpers/event.js";
+/** Creates a Query that returns a single event or undefined */
 export function SingleEventQuery(uid) {
     return {
         key: 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 {
         key: getReplaceableUID(kind, pubkey, d),
         run: (events) => events.replaceable(kind, pubkey, d),
     };
 }
+/** Creates a Query that returns an array of sorted events matching the filters */
 export function TimelineQuery(filters) {
     return {
         key: stringify(filters),
         run: (events) => events.timeline(Array.isArray(filters) ? filters : [filters]),
     };
 }
+/** Creates a Query that returns a directory of events by their UID */
+export function ReplaceableSetQuery(pointers) {
+    const cords = pointers.map((pointer) => getReplaceableUID(pointer.kind, pointer.pubkey, pointer.identifier));
+    return {
+        key: stringify(pointers),
+        run: (events) => events.events(cords),
+    };
+}

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

@@ -21,8 +21,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(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 */
@@ -34,13 +42,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

@@ -25,10 +25,18 @@ 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(pointers) {
+        return this.runQuery(Queries.ReplaceableSetQuery)(pointers);
+    }
     /** Returns an array of events that match the filter */
     timeline(filters) {
         return this.runQuery(Queries.TimelineQuery)(filters);
@@ -45,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.4.0",
+  "version": "0.6.0",
   "description": "",
   "type": "module",
   "main": "dist/index.js",
@@ -22,10 +22,26 @@
       "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"
     },
+    "./promise": {
+      "import": "./dist/promise/index.js",
+      "types": "./dist/promise/index.d.ts"
+    },
     "./query-store": {
       "import": "./dist/query-store/index.js",
       "types": "./dist/query-store/index.d.ts"
@@ -33,28 +49,24 @@
     "./event-store": {
       "import": "./dist/event-store/index.js",
       "types": "./dist/event-store/index.d.ts"
-    },
-    "./queries": {
-      "import": "./dist/queries/index.js",
-      "types": "./dist/queries/index.d.ts"
     }
   },
   "dependencies": {
-    "@types/zen-push": "^0.1.4",
     "debug": "^4.3.7",
     "json-stringify-deterministic": "^1.0.12",
     "nanoid": "^5.0.7",
     "nostr-tools": "^2.7.2",
-    "zen-push": "^0.3.1"
+    "zen-push": "^0.3.1",
+    "zen-observable": "^0.10.0"
   },
   "devDependencies": {
+    "@types/zen-push": "^0.1.4",
     "@jest/globals": "^29.7.0",
     "@types/debug": "^4.1.12",
     "@types/jest": "^29.5.13",
     "@types/zen-observable": "^0.8.7",
     "jest": "^29.7.0",
-    "jest-extended": "^4.0.2",
-    "zen-observable": "^0.10.0"
+    "jest-extended": "^4.0.2"
   },
   "jest": {
     "roots": [

package/dist/helpers/channel.d.ts

@@ -1,15 +0,0 @@
-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

@@ -1,27 +0,0 @@
-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/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/channel.d.ts

@@ -1,11 +0,0 @@
-import { NostrEvent } from "nostr-tools";
-import { Query } from "../query-store/index.js";
-import { ChannelMetadataContent } from "../helpers/channel.js";
-/** Creates a query that returns the latest parsed metadata */
-export declare function ChannelMetadataQuery(channel: NostrEvent): Query<ChannelMetadataContent | undefined>;
-/** Creates a query that returns a map of hidden messages Map<id, reason> */
-export declare function ChannelHiddenQuery(channel: NostrEvent, authors?: string[]): Query<Map<string, string>>;
-/** Creates a query that returns a map of muted users Map<pubkey, reason> */
-export declare function ChannelMutedQuery(channel: NostrEvent, authors?: string[]): Query<Map<string, string>>;
-/** Creates a query that returns all messages in a channel */
-export declare function ChannelMessagesQuery(channel: NostrEvent): Query<NostrEvent[]>;

package/dist/queries/channel.js

@@ -1,72 +0,0 @@
-import { kinds } from "nostr-tools";
-import { getChannelMetadataContent } from "../helpers/channel.js";
-import { safeParse } from "../helpers/json.js";
-/** Creates a query that returns the latest parsed metadata */
-export function ChannelMetadataQuery(channel) {
-    return {
-        key: channel.id,
-        run: (events) => {
-            const filters = [
-                { ids: [channel.id] },
-                { kinds: [kinds.ChannelMetadata], "#e": [channel.id], authors: [channel.pubkey] },
-            ];
-            let latest = channel;
-            return events.stream(filters).map((event) => {
-                try {
-                    if (event.pubkey === latest.pubkey && event.created_at > latest.created_at) {
-                        latest = event;
-                    }
-                    return getChannelMetadataContent(latest);
-                }
-                catch (error) {
-                    return undefined;
-                }
-            });
-        },
-    };
-}
-/** Creates a query that returns a map of hidden messages Map<id, reason> */
-export function ChannelHiddenQuery(channel, authors = []) {
-    return {
-        key: channel.id,
-        run: (events) => {
-            const hidden = new Map();
-            return events
-                .stream([{ kinds: [kinds.ChannelHideMessage], "#e": [channel.id], authors: [channel.pubkey, ...authors] }])
-                .map((event) => {
-                const reason = safeParse(event.content)?.reason;
-                for (const tag of event.tags) {
-                    if (tag[0] === "e" && tag[1])
-                        hidden.set(tag[1], reason ?? "");
-                }
-                return hidden;
-            });
-        },
-    };
-}
-/** Creates a query that returns a map of muted users Map<pubkey, reason> */
-export function ChannelMutedQuery(channel, authors = []) {
-    return {
-        key: channel.id + authors.join(","),
-        run: (events) => {
-            const muted = new Map();
-            return events
-                .stream([{ kinds: [kinds.ChannelMuteUser], "#e": [channel.id], authors: [channel.pubkey, ...authors] }])
-                .map((event) => {
-                const reason = safeParse(event.content)?.reason;
-                for (const tag of event.tags) {
-                    if (tag[0] === "p" && tag[1])
-                        muted.set(tag[1], reason ?? "");
-                }
-                return muted;
-            });
-        },
-    };
-}
-/** Creates a query that returns all messages in a channel */
-export function ChannelMessagesQuery(channel) {
-    return {
-        key: channel.id,
-        run: (events) => events.timeline([{ kinds: [kinds.ChannelMessage], "#e": [channel.id] }]),
-    };
-}

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 };
-        }),
-    };
-}