applesauce-core 0.0.0-next-20241103143210

package/dist/event-store/index.js

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

package/dist/helpers/bolt11.d.ts

@@ -0,0 +1,8 @@
+export type ParsedInvoice = {
+    paymentRequest: string;
+    description: string;
+    amount?: number;
+    timestamp: number;
+    expiry: number;
+};
+export declare function parseBolt11(paymentRequest: string): ParsedInvoice;

package/dist/helpers/bolt11.js

@@ -0,0 +1,14 @@
+import { decode } from "light-bolt11-decoder";
+export function parseBolt11(paymentRequest) {
+    const decoded = decode(paymentRequest);
+    const timestamp = decoded.sections.find((s) => s.name === "timestamp")?.value ?? 0;
+    const description = decoded.sections.find((s) => s.name === "description")?.value ?? "";
+    const amount = parseInt(decoded.sections.find((s) => s.name === "amount")?.value ?? "0");
+    return {
+        paymentRequest: decoded.paymentRequest,
+        description: description,
+        amount: amount,
+        timestamp: timestamp,
+        expiry: timestamp + decoded.expiry,
+    };
+}

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) {
+    return Reflect.get(event, symbol);
+}
+export function setCachedValue(event, symbol, value) {
+    Reflect.set(event, symbol, value);
+}
+/** Internal method used to cache computed values on events */
+export function getOrComputeCachedValue(event, symbol, compute) {
+    if (Reflect.has(event, symbol)) {
+        return Reflect.get(event, symbol);
+    }
+    else {
+        const value = compute(event);
+        Reflect.set(event, symbol, value);
+        return value;
+    }
+}

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

@@ -0,0 +1,34 @@
+import { NostrEvent, VerifiedEvent } from "nostr-tools";
+export declare const EventUIDSymbol: unique symbol;
+export declare const EventIndexableTagsSymbol: unique symbol;
+export declare const FromCacheSymbol: unique symbol;
+declare module "nostr-tools" {
+    interface Event {
+        [EventUIDSymbol]?: string;
+        [EventIndexableTagsSymbol]?: Set<string>;
+        [FromCacheSymbol]?: boolean;
+    }
+}
+/**
+ * Returns if a kind is replaceable ( 10000 <= n < 20000 || n == 0 || n == 3 )
+ * or parameterized replaceable ( 30000 <= n < 40000 )
+ */
+export declare function isReplaceable(kind: number): boolean;
+/**
+ * Returns the events Unique ID
+ * For normal or ephemeral events this is ( event.id )
+ * For replaceable events this is ( event.kind + ":" + event.pubkey )
+ * For parametrized replaceable events this is ( event.kind + ":" + event.pubkey + ":" + event.tags.d.1 )
+ */
+export declare function getEventUID(event: NostrEvent): string;
+export declare function getReplaceableUID(kind: number, pubkey: string, d?: string): string;
+/** Returns a Set of tag names and values that are indexable */
+export declare function getIndexableTags(event: NostrEvent): Set<string>;
+/** Returns the second index ( tag[1] ) of the first tag that matches the name */
+export declare function getTagValue(event: NostrEvent, name: string): string | undefined;
+/** Sets events verified flag without checking anything */
+export declare function fakeVerifyEvent(event: NostrEvent): event is VerifiedEvent;
+/** Marks an event as being from a cache */
+export declare function markFromCache(event: NostrEvent): void;
+/** Returns if an event was from a cache */
+export declare function isFromCache(event: NostrEvent): boolean;

package/dist/helpers/event.js

@@ -0,0 +1,64 @@
+import { kinds, verifiedSymbol } from "nostr-tools";
+import { INDEXABLE_TAGS } from "../event-store/common.js";
+export const EventUIDSymbol = Symbol.for("event-uid");
+export const EventIndexableTagsSymbol = Symbol.for("indexable-tags");
+export const FromCacheSymbol = Symbol.for("from-cache");
+/**
+ * Returns if a kind is replaceable ( 10000 <= n < 20000 || n == 0 || n == 3 )
+ * or parameterized replaceable ( 30000 <= n < 40000 )
+ */
+export function isReplaceable(kind) {
+    return kinds.isReplaceableKind(kind) || kinds.isParameterizedReplaceableKind(kind);
+}
+/**
+ * Returns the events Unique ID
+ * For normal or ephemeral events this is ( event.id )
+ * For replaceable events this is ( event.kind + ":" + event.pubkey )
+ * For parametrized replaceable events this is ( event.kind + ":" + event.pubkey + ":" + event.tags.d.1 )
+ */
+export function getEventUID(event) {
+    let id = event[EventUIDSymbol];
+    if (!id) {
+        if (isReplaceable(event.kind)) {
+            const d = event.tags.find((t) => t[0] === "d")?.[1];
+            id = getReplaceableUID(event.kind, event.pubkey, d);
+        }
+        else {
+            id = event.id;
+        }
+    }
+    return id;
+}
+export function getReplaceableUID(kind, pubkey, d) {
+    return d ? `${kind}:${pubkey}:${d}` : `${kind}:${pubkey}`;
+}
+/** Returns a Set of tag names and values that are indexable */
+export function getIndexableTags(event) {
+    let indexable = event[EventIndexableTagsSymbol];
+    if (!indexable) {
+        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]);
+            }
+        }
+        indexable = event[EventIndexableTagsSymbol] = tags;
+    }
+    return indexable;
+}
+/** Returns the second index ( tag[1] ) of the first tag that matches the name */
+export function getTagValue(event, name) {
+    return event.tags.find((t) => t[0] === name)?.[1];
+}
+/** Sets events verified flag without checking anything */
+export function fakeVerifyEvent(event) {
+    return (event[verifiedSymbol] = true);
+}
+/** Marks an event as being from a cache */
+export function markFromCache(event) {
+    event[FromCacheSymbol] = true;
+}
+/** Returns if an event was from a cache */
+export function isFromCache(event) {
+    return !!event[FromCacheSymbol];
+}

package/dist/helpers/filter.d.ts

@@ -0,0 +1,12 @@
+import { Filter, NostrEvent } from "nostr-tools";
+/**
+ * Copied from nostr-tools and modified to use getIndexableTags
+ * @see https://github.com/nbd-wtf/nostr-tools/blob/a61cde77eacc9518001f11d7f67f1a50ae05fd80/filter.ts
+ */
+export declare function matchFilter(filter: Filter, event: NostrEvent): boolean;
+/** Copied from nostr-tools */
+export declare function matchFilters(filters: Filter[], event: NostrEvent): boolean;
+/** Stringify filters in a predictable way */
+export declare function stringifyFilter(filter: Filter | Filter[]): string;
+/** Check if two filters are equal */
+export declare function isFilterEqual(a: Filter | Filter[], b: Filter | Filter[]): boolean;

package/dist/helpers/filter.js

@@ -0,0 +1,50 @@
+import { getIndexableTags } from "./event.js";
+import stringify from "json-stringify-deterministic";
+/**
+ * Copied from nostr-tools and modified to use getIndexableTags
+ * @see https://github.com/nbd-wtf/nostr-tools/blob/a61cde77eacc9518001f11d7f67f1a50ae05fd80/filter.ts
+ */
+export function matchFilter(filter, event) {
+    if (filter.ids && filter.ids.indexOf(event.id) === -1) {
+        return false;
+    }
+    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;
+}
+/** Copied from nostr-tools */
+export function matchFilters(filters, event) {
+    for (let i = 0; i < filters.length; i++) {
+        if (matchFilter(filters[i], event)) {
+            return true;
+        }
+    }
+    return false;
+}
+/** Stringify filters in a predictable way */
+export function stringifyFilter(filter) {
+    return stringify(filter);
+}
+/** Check if two filters are equal */
+export function isFilterEqual(a, b) {
+    return stringifyFilter(a) === stringifyFilter(b);
+}

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

@@ -0,0 +1,16 @@
+export * from "./profile.js";
+export * from "./relays.js";
+export * from "./event.js";
+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";
+export * from "./emoji.js";
+export * from "./lru.js";
+export * from "./hashtag.js";
+export * from "./url.js";
+export * from "./zap.js";
+export * from "./bolt11.js";

package/dist/helpers/index.js

@@ -0,0 +1,16 @@
+export * from "./profile.js";
+export * from "./relays.js";
+export * from "./event.js";
+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";
+export * from "./emoji.js";
+export * from "./lru.js";
+export * from "./hashtag.js";
+export * from "./url.js";
+export * from "./zap.js";
+export * from "./bolt11.js";

package/dist/helpers/json.d.ts

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

package/dist/helpers/json.js

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

package/dist/helpers/lru.d.ts

@@ -0,0 +1,32 @@
+type Item<T> = {
+    key: string;
+    prev: Item<T> | null;
+    value: T;
+    next: Item<T> | null;
+    expiry: number;
+};
+/**
+ * Copied from tiny-lru and modified to support typescript
+ * @see https://github.com/avoidwork/tiny-lru/blob/master/src/lru.js
+ */
+export declare class LRU<T extends unknown> {
+    first: Item<T> | null;
+    items: Record<string, Item<T>>;
+    last: Item<T> | null;
+    max: number;
+    resetTtl: boolean;
+    size: number;
+    ttl: number;
+    constructor(max?: number, ttl?: number, resetTtl?: boolean);
+    clear(): this;
+    delete(key: string): this;
+    entries(keys?: string[]): (string | T | undefined)[][];
+    evict(bypass?: boolean): this;
+    expiresAt(key: string): number | undefined;
+    get(key: string): T | undefined;
+    has(key: string): boolean;
+    keys(): string[];
+    set(key: string, value: T, bypass?: boolean, resetTtl?: boolean): this;
+    values(keys?: string[]): NonNullable<T>[];
+}
+export {};

package/dist/helpers/lru.js

@@ -0,0 +1,148 @@
+/**
+ * Copied from tiny-lru and modified to support typescript
+ * @see https://github.com/avoidwork/tiny-lru/blob/master/src/lru.js
+ */
+export class LRU {
+    first = null;
+    items = Object.create(null);
+    last = null;
+    max;
+    resetTtl;
+    size;
+    ttl;
+    constructor(max = 0, ttl = 0, resetTtl = false) {
+        this.first = null;
+        this.items = Object.create(null);
+        this.last = null;
+        this.max = max;
+        this.resetTtl = resetTtl;
+        this.size = 0;
+        this.ttl = ttl;
+    }
+    clear() {
+        this.first = null;
+        this.items = Object.create(null);
+        this.last = null;
+        this.size = 0;
+        return this;
+    }
+    delete(key) {
+        if (this.has(key)) {
+            const item = this.items[key];
+            delete this.items[key];
+            this.size--;
+            if (item.prev !== null) {
+                item.prev.next = item.next;
+            }
+            if (item.next !== null) {
+                item.next.prev = item.prev;
+            }
+            if (this.first === item) {
+                this.first = item.next;
+            }
+            if (this.last === item) {
+                this.last = item.prev;
+            }
+        }
+        return this;
+    }
+    entries(keys = this.keys()) {
+        return keys.map((key) => [key, this.get(key)]);
+    }
+    evict(bypass = false) {
+        if (bypass || this.size > 0) {
+            const item = this.first;
+            delete this.items[item.key];
+            if (--this.size === 0) {
+                this.first = null;
+                this.last = null;
+            }
+            else {
+                this.first = item.next;
+                this.first.prev = null;
+            }
+        }
+        return this;
+    }
+    expiresAt(key) {
+        let result;
+        if (this.has(key)) {
+            result = this.items[key].expiry;
+        }
+        return result;
+    }
+    get(key) {
+        let result;
+        if (this.has(key)) {
+            const item = this.items[key];
+            if (this.ttl > 0 && item.expiry <= Date.now()) {
+                this.delete(key);
+            }
+            else {
+                result = item.value;
+                this.set(key, result, true);
+            }
+        }
+        return result;
+    }
+    has(key) {
+        return key in this.items;
+    }
+    keys() {
+        const result = [];
+        let x = this.first;
+        while (x !== null) {
+            result.push(x.key);
+            x = x.next;
+        }
+        return result;
+    }
+    set(key, value, bypass = false, resetTtl = this.resetTtl) {
+        let item;
+        if (bypass || this.has(key)) {
+            item = this.items[key];
+            item.value = value;
+            if (bypass === false && resetTtl) {
+                item.expiry = this.ttl > 0 ? Date.now() + this.ttl : this.ttl;
+            }
+            if (this.last !== item) {
+                const last = this.last, next = item.next, prev = item.prev;
+                if (this.first === item) {
+                    this.first = item.next;
+                }
+                item.next = null;
+                item.prev = this.last;
+                last.next = item;
+                if (prev !== null) {
+                    prev.next = next;
+                }
+                if (next !== null) {
+                    next.prev = prev;
+                }
+            }
+        }
+        else {
+            if (this.max > 0 && this.size === this.max) {
+                this.evict(true);
+            }
+            item = this.items[key] = {
+                expiry: this.ttl > 0 ? Date.now() + this.ttl : this.ttl,
+                key: key,
+                prev: this.last,
+                next: null,
+                value,
+            };
+            if (++this.size === 1) {
+                this.first = item;
+            }
+            else {
+                this.last.next = item;
+            }
+        }
+        this.last = item;
+        return this;
+    }
+    values(keys = this.keys()) {
+        return keys.map((key) => this.get(key));
+    }
+}

package/dist/helpers/mailboxes.d.ts

@@ -0,0 +1,17 @@
+import { NostrEvent } from "nostr-tools";
+export declare const MailboxesInboxesSymbol: unique symbol;
+export declare const MailboxesOutboxesSymbol: unique symbol;
+declare module "nostr-tools" {
+    interface Event {
+        [MailboxesInboxesSymbol]?: string[];
+        [MailboxesOutboxesSymbol]?: string[];
+    }
+}
+/**
+ * Parses a 10002 event and stores the inboxes in the event using the {@link MailboxesInboxesSymbol} symbol
+ */
+export declare function getInboxes(event: NostrEvent): string[];
+/**
+ * Parses a 10002 event and stores the outboxes in the event using the {@link MailboxesOutboxesSymbol} symbol
+ */
+export declare function getOutboxes(event: NostrEvent): string[];

package/dist/helpers/mailboxes.js

@@ -0,0 +1,37 @@
+import { safeRelayUrl } from "./relays.js";
+export const MailboxesInboxesSymbol = Symbol.for("mailboxes-inboxes");
+export const MailboxesOutboxesSymbol = Symbol.for("mailboxes-outboxes");
+/**
+ * Parses a 10002 event and stores the inboxes in the event using the {@link MailboxesInboxesSymbol} symbol
+ */
+export function getInboxes(event) {
+    if (!event[MailboxesInboxesSymbol]) {
+        const inboxes = [];
+        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.includes(url))
+                    inboxes.push(url);
+            }
+        }
+        event[MailboxesInboxesSymbol] = inboxes;
+    }
+    return event[MailboxesInboxesSymbol];
+}
+/**
+ * Parses a 10002 event and stores the outboxes in the event using the {@link MailboxesOutboxesSymbol} symbol
+ */
+export function getOutboxes(event) {
+    if (!event[MailboxesOutboxesSymbol]) {
+        const outboxes = [];
+        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.includes(url))
+                    outboxes.push(url);
+            }
+        }
+        event[MailboxesOutboxesSymbol] = outboxes;
+    }
+    return event[MailboxesOutboxesSymbol];
+}

package/dist/helpers/mailboxes.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/helpers/mailboxes.test.js

@@ -0,0 +1,80 @@
+import { getInboxes, getOutboxes } from "./mailboxes.js";
+const emptyEvent = {
+    kind: 10002,
+    content: "",
+    tags: [],
+    created_at: 0,
+    sig: "",
+    id: "",
+    pubkey: "",
+};
+describe("Mailboxes", () => {
+    describe("getInboxes", () => {
+        test("should transform urls", () => {
+            expect(Array.from(getInboxes({
+                ...emptyEvent,
+                tags: [["r", "wss://inbox.com"]],
+            }))).toIncludeAllMembers(["wss://inbox.com/"]);
+        });
+        test("should remove bad urls", () => {
+            expect(Array.from(getInboxes({
+                ...emptyEvent,
+                tags: [["r", "bad://inbox.com"]],
+            }))).toBeArrayOfSize(0);
+            expect(Array.from(getInboxes({
+                ...emptyEvent,
+                tags: [["r", "something that is not a url"]],
+            }))).toBeArrayOfSize(0);
+            expect(Array.from(getInboxes({
+                ...emptyEvent,
+                tags: [["r", "wss://inbox.com,wss://inbox.org"]],
+            }))).toBeArrayOfSize(0);
+        });
+        test("without marker", () => {
+            expect(Array.from(getInboxes({
+                ...emptyEvent,
+                tags: [["r", "wss://inbox.com/"]],
+            }))).toIncludeAllMembers(["wss://inbox.com/"]);
+        });
+        test("with marker", () => {
+            expect(Array.from(getInboxes({
+                ...emptyEvent,
+                tags: [["r", "wss://inbox.com/", "read"]],
+            }))).toIncludeAllMembers(["wss://inbox.com/"]);
+        });
+    });
+    describe("getOutboxes", () => {
+        test("should transform urls", () => {
+            expect(Array.from(getOutboxes({
+                ...emptyEvent,
+                tags: [["r", "wss://outbox.com"]],
+            }))).toIncludeAllMembers(["wss://outbox.com/"]);
+        });
+        test("should remove bad urls", () => {
+            expect(Array.from(getOutboxes({
+                ...emptyEvent,
+                tags: [["r", "bad://inbox.com"]],
+            }))).toBeArrayOfSize(0);
+            expect(Array.from(getOutboxes({
+                ...emptyEvent,
+                tags: [["r", "something that is not a url"]],
+            }))).toBeArrayOfSize(0);
+            expect(Array.from(getOutboxes({
+                ...emptyEvent,
+                tags: [["r", "wss://outbox.com,wss://inbox.org"]],
+            }))).toBeArrayOfSize(0);
+        });
+        test("without marker", () => {
+            expect(Array.from(getOutboxes({
+                ...emptyEvent,
+                tags: [["r", "wss://outbox.com/"]],
+            }))).toIncludeAllMembers(["wss://outbox.com/"]);
+        });
+        test("with marker", () => {
+            expect(Array.from(getOutboxes({
+                ...emptyEvent,
+                tags: [["r", "wss://outbox.com/", "write"]],
+            }))).toIncludeAllMembers(["wss://outbox.com/"]);
+        });
+    });
+});

package/dist/helpers/pointers.d.ts

@@ -0,0 +1,22 @@
+import { AddressPointer, DecodeResult, EventPointer, ProfilePointer } from "nostr-tools/nip19";
+export type AddressPointerWithoutD = Omit<AddressPointer, "identifier"> & {
+    identifier?: string;
+};
+export declare function parseCoordinate(a: string): AddressPointerWithoutD | null;
+export declare function parseCoordinate(a: string, requireD: false): AddressPointerWithoutD | null;
+export declare function parseCoordinate(a: string, requireD: true): AddressPointer | null;
+export declare function parseCoordinate(a: string, requireD: false, silent: false): AddressPointerWithoutD;
+export declare function parseCoordinate(a: string, requireD: true, silent: false): AddressPointer;
+export declare function parseCoordinate(a: string, requireD: true, silent: true): AddressPointer | null;
+export declare function parseCoordinate(a: string, requireD: false, silent: true): AddressPointerWithoutD | null;
+export declare function getPubkeyFromDecodeResult(result?: DecodeResult): string | undefined;
+export declare function encodeDecodeResult(result: DecodeResult): "" | `nsec1${string}` | `npub1${string}` | `note1${string}` | `nprofile1${string}` | `nevent1${string}` | `naddr1${string}` | `nrelay1${string}`;
+export declare function getEventPointerFromTag(tag: string[]): EventPointer;
+export declare function getAddressPointerFromTag(tag: string[]): AddressPointer;
+export declare function getProfilePointerFromTag(tag: string[]): ProfilePointer;
+export declare function getPointerFromTag(tag: string[]): DecodeResult | null;
+export declare function isAddressPointer(pointer: DecodeResult["data"]): pointer is AddressPointer;
+export declare function isEventPointer(pointer: DecodeResult["data"]): pointer is EventPointer;
+export declare function getCoordinateFromAddressPointer(pointer: AddressPointer): string;
+export declare function getATagFromAddressPointer(pointer: AddressPointer): ["a", ...string[]];
+export declare function getETagFromEventPointer(pointer: EventPointer): ["e", ...string[]];