applesauce-core 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2024 hzrd149
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

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

@@ -0,0 +1 @@
+export declare const INDEXABLE_TAGS: Set<string>;

package/dist/event-store/common.js

@@ -0,0 +1,2 @@
+const LETTERS = "abcdefghijklmnopqrstuvwxyz";
+export const INDEXABLE_TAGS = new Set((LETTERS + LETTERS.toUpperCase()).split(""));

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

@@ -0,0 +1,34 @@
+import { Filter, NostrEvent } from "nostr-tools";
+import { LRU } from "tiny-lru";
+export declare class Database {
+    log: import("debug").Debugger;
+    /** Max number of events to hold */
+    max?: number;
+    /** Indexes */
+    kinds: Map<number, Set<import("nostr-tools").Event>>;
+    authors: Map<string, Set<import("nostr-tools").Event>>;
+    tags: LRU<Set<import("nostr-tools").Event>>;
+    created_at: NostrEvent[];
+    /** LRU cache of last events touched */
+    events: LRU<import("nostr-tools").Event>;
+    constructor(max?: number);
+    /** Index helper methods */
+    private getKindIndex;
+    private getAuthorsIndex;
+    private getTagIndex;
+    touch(event: NostrEvent): void;
+    hasEvent(uid: string): import("nostr-tools").Event | undefined;
+    getEvent(uid: string): import("nostr-tools").Event | undefined;
+    hasReplaceable(kind: number, pubkey: string, d?: string): boolean;
+    getReplaceable(kind: number, pubkey: string, d?: string): import("nostr-tools").Event | undefined;
+    addEvent(event: NostrEvent): import("nostr-tools").Event;
+    deleteEvent(eventOrId: string | NostrEvent): boolean;
+    iterateAuthors(authors: Iterable<string>): Generator<import("nostr-tools").Event, void, unknown>;
+    iterateTag(tag: string, values: Iterable<string>): Generator<import("nostr-tools").Event, void, unknown>;
+    iterateKinds(kinds: Iterable<number>): Generator<import("nostr-tools").Event, void, unknown>;
+    iterateTime(since: number | undefined, until: number | undefined): Generator<never, Set<import("nostr-tools").Event>, unknown>;
+    iterateIds(ids: Iterable<string>): Generator<import("nostr-tools").Event, void, unknown>;
+    getEventsForFilter(filter: Filter): Set<NostrEvent>;
+    getForFilters(filters: Filter[]): Set<import("nostr-tools").Event>;
+    prune(): number | undefined;
+}

package/dist/event-store/database.js

@@ -0,0 +1,240 @@
+import { LRU } from "tiny-lru";
+import { getEventUID, getIndexableTags, getReplaceableUID } from "../helpers/event.js";
+import { INDEXABLE_TAGS } from "./common.js";
+import { logger } from "../logger.js";
+import { binarySearch, insertEventIntoDescendingList } from "nostr-tools/utils";
+export class Database {
+    log = logger.extend("Database");
+    /** Max number of events to hold */
+    max;
+    /** Indexes */
+    kinds = new Map();
+    authors = new Map();
+    tags = new LRU();
+    created_at = [];
+    /** LRU cache of last events touched */
+    events = new LRU();
+    constructor(max) {
+        this.max = max;
+    }
+    /** Index helper methods */
+    getKindIndex(kind) {
+        if (!this.kinds.has(kind))
+            this.kinds.set(kind, new Set());
+        return this.kinds.get(kind);
+    }
+    getAuthorsIndex(author) {
+        if (!this.authors.has(author))
+            this.authors.set(author, new Set());
+        return this.authors.get(author);
+    }
+    getTagIndex(tagAndValue) {
+        if (!this.tags.has(tagAndValue)) {
+            // build new tag index from existing events
+            const events = new Set();
+            const ts = Date.now();
+            for (const event of this.events.values()) {
+                if (getIndexableTags(event).has(tagAndValue)) {
+                    events.add(event);
+                }
+            }
+            const took = Date.now() - ts;
+            if (took > 100)
+                this.log(`Built index ${tagAndValue} took ${took}ms`);
+            this.tags.set(tagAndValue, events);
+        }
+        return this.tags.get(tagAndValue);
+    }
+    touch(event) {
+        this.events.set(getEventUID(event), event);
+    }
+    hasEvent(uid) {
+        return this.events.get(uid);
+    }
+    getEvent(uid) {
+        return this.events.get(uid);
+    }
+    hasReplaceable(kind, pubkey, d) {
+        return this.events.has(getReplaceableUID(kind, pubkey, d));
+    }
+    getReplaceable(kind, pubkey, d) {
+        return this.events.get(getReplaceableUID(kind, pubkey, d));
+    }
+    addEvent(event) {
+        const uid = getEventUID(event);
+        const current = this.events.get(uid);
+        if (current && event.created_at <= current.created_at)
+            return current;
+        this.events.set(uid, event);
+        this.getKindIndex(event.kind).add(event);
+        this.getAuthorsIndex(event.pubkey).add(event);
+        for (const tag of getIndexableTags(event)) {
+            if (this.tags.has(tag)) {
+                this.getTagIndex(tag).add(event);
+            }
+        }
+        insertEventIntoDescendingList(this.created_at, event);
+        return event;
+    }
+    deleteEvent(eventOrId) {
+        let event = typeof eventOrId === "string" ? this.events.get(eventOrId) : eventOrId;
+        if (!event)
+            throw new Error("Missing event");
+        const uid = getEventUID(event);
+        // only remove events that are known
+        if (!this.events.has(uid))
+            return false;
+        this.getAuthorsIndex(event.pubkey).delete(event);
+        this.getKindIndex(event.kind).delete(event);
+        for (const tag of getIndexableTags(event)) {
+            if (this.tags.has(tag)) {
+                this.getTagIndex(tag).delete(event);
+            }
+        }
+        // remove from created_at index
+        const i = this.created_at.indexOf(event);
+        this.created_at.splice(i, 1);
+        this.events.delete(uid);
+        return true;
+    }
+    *iterateAuthors(authors) {
+        for (const author of authors) {
+            const events = this.authors.get(author);
+            if (events) {
+                for (const event of events)
+                    yield event;
+            }
+        }
+    }
+    *iterateTag(tag, values) {
+        for (const value of values) {
+            const events = this.getTagIndex(tag + ":" + value);
+            if (events) {
+                for (const event of events)
+                    yield event;
+            }
+        }
+    }
+    *iterateKinds(kinds) {
+        for (const kind of kinds) {
+            const events = this.kinds.get(kind);
+            if (events) {
+                for (const event of events)
+                    yield event;
+            }
+        }
+    }
+    *iterateTime(since, until) {
+        let untilIndex = 0;
+        let sinceIndex = this.created_at.length - 1;
+        let start = until
+            ? binarySearch(this.created_at, (mid) => {
+                if (mid.created_at === until)
+                    return -1;
+                return mid.created_at - until;
+            })
+            : undefined;
+        if (start && start[1])
+            untilIndex = start[0];
+        const end = since
+            ? binarySearch(this.created_at, (mid) => {
+                if (mid.created_at === since)
+                    return 1;
+                return since - mid.created_at;
+            })
+            : undefined;
+        if (end && end[1])
+            sinceIndex = end[0];
+        const events = new Set();
+        for (let i = untilIndex; i <= sinceIndex; i++) {
+            events.add(this.created_at[i]);
+        }
+        return events;
+    }
+    *iterateIds(ids) {
+        for (const id of ids) {
+            if (this.events.has(id))
+                yield this.events.get(id);
+        }
+    }
+    getEventsForFilter(filter) {
+        // search is not supported, return an empty set
+        if (filter.search)
+            return new Set();
+        let first = true;
+        let events = new Set();
+        const and = (iterable) => {
+            const set = iterable instanceof Set ? iterable : new Set(iterable);
+            if (first) {
+                events = set;
+                first = false;
+            }
+            else {
+                for (const event of events) {
+                    if (!set.has(event))
+                        events.delete(event);
+                }
+            }
+            return events;
+        };
+        if (filter.ids)
+            and(this.iterateIds(filter.ids));
+        let time = null;
+        // query for time first if since is set
+        if (filter.since !== undefined) {
+            time = Array.from(this.iterateTime(filter.since, filter.until));
+            and(time);
+        }
+        for (const t of INDEXABLE_TAGS) {
+            const key = `#${t}`;
+            const values = filter[key];
+            if (values?.length)
+                and(this.iterateTag(t, values));
+        }
+        if (filter.authors)
+            and(this.iterateAuthors(filter.authors));
+        if (filter.kinds)
+            and(this.iterateKinds(filter.kinds));
+        // query for time last if only until is set
+        if (filter.since === undefined && filter.until !== undefined) {
+            time = Array.from(this.iterateTime(filter.since, filter.until));
+            and(time);
+        }
+        // if the filter queried on time and has a limit. truncate the events now
+        if (filter.limit && time) {
+            const limited = new Set();
+            for (const event of time) {
+                if (limited.size >= filter.limit)
+                    break;
+                if (events.has(event))
+                    limited.add(event);
+            }
+            return limited;
+        }
+        return events;
+    }
+    getForFilters(filters) {
+        if (filters.length === 0)
+            throw new Error("No Filters");
+        let events = new Set();
+        for (const filter of filters) {
+            const filtered = this.getEventsForFilter(filter);
+            for (const event of filtered)
+                events.add(event);
+        }
+        return events;
+    }
+    prune() {
+        if (!this.max)
+            return;
+        let removed = 0;
+        while (this.events.size > this.max) {
+            const event = this.events.first;
+            if (event) {
+                this.deleteEvent(event);
+                removed++;
+            }
+        }
+        return removed;
+    }
+}

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

@@ -0,0 +1,21 @@
+import { Filter, NostrEvent } from "nostr-tools";
+import Observable from "zen-observable";
+import { Database } from "./database.js";
+export declare class EventStore {
+    events: Database;
+    private singles;
+    private streams;
+    constructor();
+    add(event: NostrEvent, fromRelay?: string): 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;
+    hasReplaceable(kind: number, pubkey: string, d?: string): boolean;
+    getReplaceable(kind: number, pubkey: string, d?: string): import("nostr-tools").Event | undefined;
+    /** Creates an observable that updates a single event */
+    single(uid: string): Observable<import("nostr-tools").Event>;
+    /** Creates an observable that streams all events that match the filter */
+    stream(filters: Filter[]): Observable<import("nostr-tools").Event>;
+    /** Creates an observable that updates with an array of sorted events */
+    timeline(filters: Filter[]): Observable<import("nostr-tools").Event[]>;
+}

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

@@ -0,0 +1,80 @@
+import { insertEventIntoDescendingList } from "nostr-tools/utils";
+import Observable from "zen-observable";
+import { Database } from "./database.js";
+import { getEventUID } from "../helpers/event.js";
+import { matchFilters } from "../helpers/filter.js";
+import { addSeenRelay } from "../helpers/relays.js";
+export class EventStore {
+    events;
+    singles = new Map();
+    streams = new Map();
+    constructor() {
+        this.events = new Database();
+    }
+    add(event, fromRelay) {
+        const inserted = this.events.addEvent(event);
+        if (inserted === event) {
+            // forward to single event requests
+            const eventUID = getEventUID(event);
+            for (const [control, uid] of this.singles) {
+                if (eventUID === uid)
+                    control.next(event);
+            }
+            // forward to streams
+            for (const [control, filters] of this.streams) {
+                if (matchFilters(filters, event))
+                    control.next(event);
+            }
+        }
+        if (fromRelay)
+            addSeenRelay(inserted, fromRelay);
+        return inserted;
+    }
+    getAll(filters) {
+        return this.events.getForFilters(filters);
+    }
+    hasEvent(uid) {
+        return this.events.hasEvent(uid);
+    }
+    getEvent(uid) {
+        return this.events.getEvent(uid);
+    }
+    hasReplaceable(kind, pubkey, d) {
+        return this.events.hasReplaceable(kind, pubkey, d);
+    }
+    getReplaceable(kind, pubkey, d) {
+        return this.events.getReplaceable(kind, pubkey, d);
+    }
+    /** Creates an observable that updates a single event */
+    single(uid) {
+        return new Observable((control) => {
+            const event = this.events.getEvent(uid);
+            if (event)
+                control.next(event);
+            this.singles.set(control, uid);
+            return () => {
+                this.singles.delete(control);
+            };
+        });
+    }
+    /** Creates an observable that streams all events that match the filter */
+    stream(filters) {
+        return new Observable((control) => {
+            const events = this.events.getForFilters(filters);
+            for (const event of events)
+                control.next(event);
+            this.streams.set(control, filters);
+            return () => {
+                this.streams.delete(control);
+            };
+        });
+    }
+    /** Creates an observable that updates with an array of sorted events */
+    timeline(filters) {
+        let events = [];
+        return this.stream(filters).map((event) => {
+            insertEventIntoDescendingList(events, event);
+            return events;
+        });
+    }
+}

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

@@ -0,0 +1 @@
+export * from './event-store.js';

package/dist/event-store/index.js

@@ -0,0 +1 @@
+export * from './event-store.js';

package/dist/helpers/event.d.ts

@@ -0,0 +1,6 @@
+import { NostrEvent } from "nostr-tools";
+export declare function isReplaceable(kind: number): boolean;
+/** returns the events Unique ID */
+export declare function getEventUID(event: NostrEvent): string;
+export declare function getReplaceableUID(kind: number, pubkey: string, d?: string): string;
+export declare function getIndexableTags(event: NostrEvent): Set<string>;

package/dist/helpers/event.js

@@ -0,0 +1,34 @@
+import { kinds } from "nostr-tools";
+import { INDEXABLE_TAGS } from "../event-store/common.js";
+import { EventIndexableTags, EventUID } from "./symbols.js";
+export function isReplaceable(kind) {
+    return kinds.isReplaceableKind(kind) || kinds.isParameterizedReplaceableKind(kind);
+}
+/** returns the events Unique ID */
+export function getEventUID(event) {
+    if (!event[EventUID]) {
+        if (isReplaceable(event.kind)) {
+            const d = event.tags.find((t) => t[0] === "d")?.[1];
+            event[EventUID] = getReplaceableUID(event.kind, event.pubkey, d);
+        }
+        else {
+            event[EventUID] = event.id;
+        }
+    }
+    return event[EventUID];
+}
+export function getReplaceableUID(kind, pubkey, d) {
+    return d ? `${kind}:${pubkey}:${d}` : `${kind}:${pubkey}`;
+}
+export function getIndexableTags(event) {
+    if (!event[EventIndexableTags]) {
+        const tags = new Set();
+        for (const tag of event.tags) {
+            if (tag[0] && INDEXABLE_TAGS.has(tag[0]) && tag[1]) {
+                tags.add(tag[0] + ":" + tag[1]);
+            }
+        }
+        event[EventIndexableTags] = tags;
+    }
+    return event[EventIndexableTags];
+}

package/dist/helpers/filter.d.ts

@@ -0,0 +1,3 @@
+import { Filter, NostrEvent } from "nostr-tools";
+export declare function matchFilter(filter: Filter, event: NostrEvent): boolean;
+export declare function matchFilters(filters: Filter[], event: NostrEvent): boolean;

package/dist/helpers/filter.js

@@ -0,0 +1,38 @@
+import { getIndexableTags } from "./event.js";
+// Copied from https://github.com/nbd-wtf/nostr-tools/blob/a61cde77eacc9518001f11d7f67f1a50ae05fd80/filter.ts
+// And modified to use getIndexableTags
+export function matchFilter(filter, event) {
+    if (filter.ids && filter.ids.indexOf(event.id) === -1) {
+        return false;
+    }
+    if (filter.kinds && filter.kinds.indexOf(event.kind) === -1) {
+        return false;
+    }
+    if (filter.authors && filter.authors.indexOf(event.pubkey) === -1) {
+        return false;
+    }
+    for (let f in filter) {
+        if (f[0] === "#") {
+            let tagName = f.slice(1);
+            let values = filter[`#${tagName}`];
+            if (values) {
+                const tags = getIndexableTags(event);
+                if (values.some((v) => !tags.has(tagName + ":" + v)))
+                    return false;
+            }
+        }
+    }
+    if (filter.since && event.created_at < filter.since)
+        return false;
+    if (filter.until && event.created_at > filter.until)
+        return false;
+    return true;
+}
+export function matchFilters(filters, event) {
+    for (let i = 0; i < filters.length; i++) {
+        if (matchFilter(filters[i], event)) {
+            return true;
+        }
+    }
+    return false;
+}

package/dist/helpers/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./profile.js";
+export * from "./relays.js";
+export * from "./event.js";
+export * from "./filter.js";
+export * as symbols from "./symbols.js";

package/dist/helpers/index.js

@@ -0,0 +1,5 @@
+export * from "./profile.js";
+export * from "./relays.js";
+export * from "./event.js";
+export * from "./filter.js";
+export * as symbols from "./symbols.js";

package/dist/helpers/mailboxes.d.ts

@@ -0,0 +1,3 @@
+import { NostrEvent } from "nostr-tools";
+export declare function getInboxes(event: NostrEvent): Set<string>;
+export declare function getOutboxes(event: NostrEvent): Set<string>;

package/dist/helpers/mailboxes.js

@@ -0,0 +1,30 @@
+import { safeRelayUrl } from "./relays.js";
+import { MailboxesInboxes, MailboxesOutboxes } from "./symbols.js";
+export function getInboxes(event) {
+    if (!event[MailboxesInboxes]) {
+        const inboxes = new Set();
+        for (const tag of event.tags) {
+            if (tag[0] === "r" && tag[1] && (tag[2] === "read" || tag[2] === undefined)) {
+                const url = safeRelayUrl(tag[1]);
+                if (url)
+                    inboxes.add(url);
+            }
+        }
+        event[MailboxesInboxes] = inboxes;
+    }
+    return event[MailboxesInboxes];
+}
+export function getOutboxes(event) {
+    if (!event[MailboxesOutboxes]) {
+        const outboxes = new Set();
+        for (const tag of event.tags) {
+            if (tag[0] === "r" && tag[1] && (tag[2] === "write" || tag[2] === undefined)) {
+                const url = safeRelayUrl(tag[1]);
+                if (url)
+                    outboxes.add(url);
+            }
+        }
+        event[MailboxesOutboxes] = outboxes;
+    }
+    return event[MailboxesOutboxes];
+}

package/dist/helpers/profile.d.ts

@@ -0,0 +1,18 @@
+import { NostrEvent } from "nostr-tools";
+export type ProfileContent = {
+    name?: string;
+    display_name?: string;
+    displayName?: string;
+    about?: string;
+    /** @deprecated */
+    image?: string;
+    picture?: string;
+    banner?: string;
+    website?: string;
+    lud16?: string;
+    lud06?: string;
+    nip05?: string;
+};
+export declare function getProfileContent(event: NostrEvent): ProfileContent;
+export declare function getProfileContent(event: NostrEvent, quite: false): ProfileContent;
+export declare function getProfileContent(event: NostrEvent, quite: true): ProfileContent | Error;

package/dist/helpers/profile.js

@@ -0,0 +1,28 @@
+import { ProfileContent } from "./symbols.js";
+export function getProfileContent(event, quite = false) {
+    let cached = event[ProfileContent];
+    if (!cached) {
+        try {
+            const profile = JSON.parse(event.content);
+            // ensure nip05 is a string
+            if (profile.nip05 && typeof profile.nip05 !== "string")
+                profile.nip05 = String(profile.nip05);
+            cached = event[ProfileContent] = profile;
+        }
+        catch (e) {
+            if (e instanceof Error)
+                cached = event[ProfileContent] = e;
+        }
+    }
+    if (cached === undefined) {
+        throw new Error("Failed to parse profile");
+    }
+    else if (cached instanceof Error) {
+        if (!quite)
+            throw cached;
+        else
+            return cached;
+    }
+    else
+        return cached;
+}

package/dist/helpers/relays.d.ts

@@ -0,0 +1,6 @@
+import { NostrEvent } from "nostr-tools";
+export declare function addSeenRelay(event: NostrEvent, relay: string): Set<string>;
+export declare function getSeenRelays(event: NostrEvent): Set<string> | undefined;
+export declare function validateRelayURL(relay: string | URL): URL;
+export declare function safeRelayUrl(relayUrl: string | URL): string | null;
+export declare function safeRelayUrls(urls: Iterable<string>): string[];

package/dist/helpers/relays.js

@@ -0,0 +1,30 @@
+import { FromRelays } from "./symbols.js";
+export function addSeenRelay(event, relay) {
+    if (!event[FromRelays])
+        event[FromRelays] = new Set();
+    event[FromRelays].add(relay);
+    return event[FromRelays];
+}
+export function getSeenRelays(event) {
+    return event[FromRelays];
+}
+// Relay URLs
+export function validateRelayURL(relay) {
+    if (typeof relay === "string" && relay.includes(",ws"))
+        throw new Error("Can not have multiple relays in one string");
+    const url = typeof relay === "string" ? new URL(relay) : relay;
+    if (url.protocol !== "wss:" && url.protocol !== "ws:")
+        throw new Error("Incorrect protocol");
+    return url;
+}
+export function safeRelayUrl(relayUrl) {
+    try {
+        return validateRelayURL(relayUrl).toString();
+    }
+    catch (e) {
+        return null;
+    }
+}
+export function safeRelayUrls(urls) {
+    return Array.from(urls).map(safeRelayUrl).filter(Boolean);
+}

package/dist/helpers/symbols.d.ts

@@ -0,0 +1,17 @@
+import { ProfileContent as TProfileContent } from "./profile.js";
+export declare const EventUID: unique symbol;
+export declare const EventIndexableTags: unique symbol;
+export declare const MailboxesInboxes: unique symbol;
+export declare const MailboxesOutboxes: unique symbol;
+export declare const ProfileContent: unique symbol;
+export declare const FromRelays: unique symbol;
+declare module "nostr-tools" {
+    interface Event {
+        [EventUID]?: string;
+        [MailboxesInboxes]?: Set<string>;
+        [MailboxesOutboxes]?: Set<string>;
+        [ProfileContent]?: TProfileContent | Error;
+        [EventIndexableTags]?: Set<string>;
+        [FromRelays]?: Set<string>;
+    }
+}

package/dist/helpers/symbols.js

@@ -0,0 +1,10 @@
+// event
+export const EventUID = Symbol.for("event-uid");
+export const EventIndexableTags = Symbol.for("indexable-tags");
+// mailboxes
+export const MailboxesInboxes = Symbol.for("mailboxes-inboxes");
+export const MailboxesOutboxes = Symbol.for("mailboxes-outboxes");
+// profile
+export const ProfileContent = Symbol.for("profile-content");
+// event relays
+export const FromRelays = Symbol.for("from-relays");

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./event-store/index.js";
+export * from "./query-store/index.js";
+export * as helpers from "./helpers/index.js";

package/dist/index.js

@@ -0,0 +1,3 @@
+export * from "./event-store/index.js";
+export * from "./query-store/index.js";
+export * as helpers from "./helpers/index.js";

package/dist/logger.d.ts

@@ -0,0 +1,2 @@
+import debug from "debug";
+export declare const logger: debug.Debugger;

package/dist/logger.js

@@ -0,0 +1,2 @@
+import debug from "debug";
+export const logger = debug("applesauce");

package/dist/observable/index.d.ts

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

package/dist/observable/index.js

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

package/dist/observable/stateful.d.ts

@@ -0,0 +1,10 @@
+import Observable from "zen-observable";
+export type StatefulObservable<T> = Observable<T> & {
+    _stateful?: true;
+    value?: T;
+    error?: Error;
+    complete?: boolean;
+};
+/** Wraps an observable and makes it stateful */
+export declare function stateful<T extends unknown>(observable: Observable<T>, cleanup?: boolean): StatefulObservable<T>;
+export declare function isStateful<T extends unknown>(observable: Observable<T> | StatefulObservable<T>): observable is StatefulObservable<T>;

package/dist/observable/stateful.js

@@ -0,0 +1,60 @@
+import Observable from "zen-observable";
+/** Wraps an observable and makes it stateful */
+export function stateful(observable, cleanup = false) {
+    let subscription = undefined;
+    let observers = [];
+    const self = new Observable((observer) => {
+        // add observer to list
+        observers.push(observer);
+        // pass any cached values
+        if (self.value)
+            observer.next(self.value);
+        if (self.error)
+            observer.error(self.error);
+        if (self.complete)
+            observer.complete();
+        // subscribe if not already
+        if (!subscription) {
+            subscription = observable.subscribe({
+                next: (v) => {
+                    self.value = v;
+                    for (const observer of observers)
+                        observer.next(v);
+                },
+                error: (err) => {
+                    self.error = err;
+                    for (const observer of observers)
+                        observer.error(err);
+                },
+                complete: () => {
+                    self.complete = true;
+                    for (const observer of observers)
+                        observer.complete();
+                },
+            });
+        }
+        return () => {
+            let i = observers.indexOf(observer);
+            if (i !== -1) {
+                // remove observer from list
+                observers.splice(i, 1);
+                if (subscription && observers.length === 0) {
+                    subscription.unsubscribe();
+                    subscription = undefined;
+                    // reset cached values
+                    if (cleanup) {
+                        delete self.value;
+                        delete self.error;
+                        delete self.complete;
+                    }
+                }
+            }
+        };
+    });
+    self._stateful = true;
+    return self;
+}
+export function isStateful(observable) {
+    // @ts-expect-error
+    return observable._stateful;
+}

package/dist/observable/throttle.d.ts

@@ -0,0 +1,2 @@
+import Observable from "zen-observable";
+export declare function throttle<T>(source: Observable<T>, interval: number): Observable<T>;

package/dist/observable/throttle.js

@@ -0,0 +1,22 @@
+import Observable from "zen-observable";
+export function throttle(source, interval) {
+    return new Observable((observer) => {
+        let lastEmissionTime = 0;
+        let subscription = source.subscribe({
+            next(value) {
+                const currentTime = Date.now();
+                if (currentTime - lastEmissionTime >= interval) {
+                    lastEmissionTime = currentTime;
+                    observer.next(value);
+                }
+            },
+            error(err) {
+                observer.error(err);
+            },
+            complete() {
+                observer.complete();
+            },
+        });
+        return () => subscription.unsubscribe();
+    });
+}

package/dist/promise/deferred.d.ts

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

package/dist/promise/deferred.js

@@ -0,0 +1,14 @@
+export default function createDefer() {
+    let _resolve;
+    let _reject;
+    const promise = new Promise((resolve, reject) => {
+        // @ts-ignore
+        _resolve = resolve;
+        _reject = reject;
+    });
+    // @ts-ignore
+    promise.resolve = _resolve;
+    // @ts-ignore
+    promise.reject = _reject;
+    return promise;
+}

package/dist/promise/index.d.ts

@@ -0,0 +1 @@
+export * from './deferred.js';

package/dist/promise/index.js

@@ -0,0 +1 @@
+export * from './deferred.js';

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

@@ -0,0 +1,26 @@
+import Observable from "zen-observable";
+import { LRU } from "tiny-lru";
+import { Filter, NostrEvent } from "nostr-tools";
+import { EventStore } from "../event-store/event-store.js";
+import { ProfileContent } from "../helpers/profile.js";
+export declare class QueryStore {
+    store: EventStore;
+    constructor(store: EventStore);
+    singleEvents: LRU<Observable<import("nostr-tools").Event>>;
+    getEvent(id: string): Observable<import("nostr-tools").Event>;
+    getReplaceable(kind: number, pubkey: string, d?: string): Observable<import("nostr-tools").Event>;
+    timelines: LRU<Observable<import("nostr-tools").Event[]>>;
+    getTimeline(filters: Filter[]): Observable<import("nostr-tools").Event[]>;
+    profiles: LRU<Observable<ProfileContent>>;
+    getProfile(pubkey: string): Observable<ProfileContent>;
+    reactions: LRU<Observable<import("nostr-tools").Event[]>>;
+    getReactions(event: NostrEvent): Observable<import("nostr-tools").Event[]>;
+    mailboxes: LRU<Observable<{
+        inboxes: Set<string>;
+        outboxes: Set<string>;
+    }>>;
+    getMailboxes(pubkey: string): Observable<{
+        inboxes: Set<string>;
+        outboxes: Set<string>;
+    }>;
+}

package/dist/query-store/index.js

@@ -0,0 +1,71 @@
+import { LRU } from "tiny-lru";
+import { kinds } from "nostr-tools";
+import stringify from "json-stringify-deterministic";
+import { stateful } from "../observable/stateful.js";
+import { getProfileContent } from "../helpers/profile.js";
+import { getEventUID, getReplaceableUID, isReplaceable } from "../helpers/event.js";
+import { getInboxes, getOutboxes } from "../helpers/mailboxes.js";
+export class QueryStore {
+    store;
+    constructor(store) {
+        this.store = store;
+    }
+    singleEvents = new LRU();
+    getEvent(id) {
+        if (!this.singleEvents.has(id)) {
+            const observable = stateful(this.store.single(id));
+            this.singleEvents.set(id, observable);
+        }
+        return this.singleEvents.get(id);
+    }
+    getReplaceable(kind, pubkey, d) {
+        return this.getEvent(getReplaceableUID(kind, pubkey, d));
+    }
+    timelines = new LRU();
+    getTimeline(filters) {
+        const key = stringify(filters);
+        if (!this.singleEvents.has(key)) {
+            const observable = stateful(this.store.timeline(filters));
+            this.timelines.set(key, observable);
+        }
+        return this.timelines.get(key);
+    }
+    profiles = new LRU();
+    getProfile(pubkey) {
+        if (!this.profiles.has(pubkey)) {
+            const observable = stateful(this.getReplaceable(kinds.Metadata, pubkey).map((event) => getProfileContent(event)));
+            this.profiles.set(pubkey, observable);
+        }
+        return this.profiles.get(pubkey);
+    }
+    reactions = new LRU();
+    getReactions(event) {
+        const uid = getEventUID(event);
+        if (!this.reactions.has(uid)) {
+            const observable = this.getTimeline(isReplaceable(event.kind)
+                ? [
+                    { kinds: [kinds.Reaction], "#e": [event.id] },
+                    { kinds: [kinds.Reaction], "#a": [uid] },
+                ]
+                : [
+                    {
+                        kinds: [kinds.Reaction],
+                        "#e": [event.id],
+                    },
+                ]);
+            this.reactions.set(uid, observable);
+        }
+        return this.reactions.get(uid);
+    }
+    mailboxes = new LRU();
+    getMailboxes(pubkey) {
+        if (!this.mailboxes.has(pubkey)) {
+            const observable = stateful(this.getReplaceable(kinds.RelayList, pubkey).map((event) => ({
+                inboxes: getInboxes(event),
+                outboxes: getOutboxes(event),
+            })));
+            this.mailboxes.set(pubkey, observable);
+        }
+        return this.mailboxes.get(pubkey);
+    }
+}

package/package.json

@@ -0,0 +1,53 @@
+{
+  "name": "applesauce-core",
+  "version": "0.1.0",
+  "description": "",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "keywords": [
+    "nostr"
+  ],
+  "author": "hzrd149",
+  "license": "MIT",
+  "files": [
+    "dist"
+  ],
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    },
+    "./helpers": {
+      "import": "./dist/helpers/index.js",
+      "types": "./dist/helpers/index.d.ts"
+    },
+    "./observable": {
+      "import": "./dist/observable/index.js",
+      "types": "./dist/observable/index.d.ts"
+    },
+    "./query-store": {
+      "import": "./dist/query-store/index.js",
+      "types": "./dist/query-store/index.d.ts"
+    },
+    "./event-store": {
+      "import": "./dist/event-store/index.js",
+      "types": "./dist/event-store/index.d.ts"
+    }
+  },
+  "dependencies": {
+    "debug": "^4.3.7",
+    "json-stringify-deterministic": "^1.0.12",
+    "nanoid": "^5.0.7",
+    "nostr-tools": "^2.7.2",
+    "tiny-lru": "^11.2.11"
+  },
+  "devDependencies": {
+    "@types/debug": "^4.1.12",
+    "@types/zen-observable": "^0.8.7",
+    "zen-observable": "^0.10.0"
+  },
+  "scripts": {
+    "build": "tsc"
+  }
+}