applesauce-core 0.9.0 → 0.11.0

package/dist/helpers/threading.js

@@ -1,10 +1,31 @@
-import { getAddressPointerFromTag, getEventPointerFromTag } from "./pointers.js";
+import { getAddressPointerFromATag } from "./pointers.js";
 import { getOrComputeCachedValue } from "./cache.js";
+import { isSafeRelayURL } from "./relays.js";
 export const Nip10ThreadRefsSymbol = Symbol.for("nip10-thread-refs");
+/**
+ * Gets an EventPointer form a NIP-10 threading "e" tag
+ * @throws
+ */
+export function getEventPointerFromThreadTag(tag) {
+    if (!tag[1])
+        throw new Error("Missing event id in tag");
+    let pointer = { id: tag[1] };
+    if (tag[2] && isSafeRelayURL(tag[2]))
+        pointer.relays = [tag[2]];
+    // get author from NIP-18 quote tags, nip-22 comments tags, or nip-10 thread tags
+    if (tag[0] === "e" &&
+        (tag[3] === "root" || tag[3] === "reply" || tag[3] === "mention") &&
+        tag[4] &&
+        tag[4].length === 64) {
+        // NIP-10 "e" tag
+        pointer.author = tag[4];
+    }
+    return pointer;
+}
 /** Parses NIP-10 tags and handles legacy behavior */
-export function interpretThreadTags(event) {
-    const eTags = event.tags.filter((t) => t[0] === "e" && t[1]);
-    const aTags = event.tags.filter((t) => t[0] === "a" && t[1]);
+export function interpretThreadTags(tags) {
+    const eTags = tags.filter((t) => t[0] === "e" && t[1]);
+    const aTags = tags.filter((t) => t[0] === "a" && t[1]);
     // find the root and reply tags.
     let rootETag = eTags.find((t) => t[3] === "root");
     let replyETag = eTags.find((t) => t[3] === "reply");
@@ -44,13 +65,13 @@ export function interpretThreadTags(event) {
 /** Returns the parsed NIP-10 tags for an event */
 export function getNip10References(event) {
     return getOrComputeCachedValue(event, Nip10ThreadRefsSymbol, () => {
-        const tags = interpretThreadTags(event);
+        const tags = interpretThreadTags(event.tags);
         let root;
         if (tags.root) {
             try {
                 root = {
-                    e: tags.root.e && getEventPointerFromTag(tags.root.e),
-                    a: tags.root.a && getAddressPointerFromTag(tags.root.a),
+                    e: tags.root.e && getEventPointerFromThreadTag(tags.root.e),
+                    a: tags.root.a && getAddressPointerFromATag(tags.root.a),
                 };
             }
             catch (error) { }
@@ -59,8 +80,8 @@ export function getNip10References(event) {
         if (tags.reply) {
             try {
                 reply = {
-                    e: tags.reply.e && getEventPointerFromTag(tags.reply.e),
-                    a: tags.reply.a && getAddressPointerFromTag(tags.reply.a),
+                    e: tags.reply.e && getEventPointerFromThreadTag(tags.reply.e),
+                    a: tags.reply.a && getAddressPointerFromATag(tags.reply.a),
                 };
             }
             catch (error) { }

package/dist/helpers/url.d.ts

@@ -4,8 +4,18 @@ export declare const IMAGE_EXT: string[];
 export declare const VIDEO_EXT: string[];
 export declare const STREAM_EXT: string[];
 export declare const AUDIO_EXT: string[];
-export declare function isVisualMediaURL(url: string | URL): boolean;
+/** Checks if a url is a image URL */
 export declare function isImageURL(url: string | URL): boolean;
+/** Checks if a url is a video URL */
 export declare function isVideoURL(url: string | URL): boolean;
+/** Checks if a url is a stream URL */
 export declare function isStreamURL(url: string | URL): boolean;
+/** Checks if a url is a audio URL */
 export declare function isAudioURL(url: string | URL): boolean;
+/** Tests if two URLs are the same */
+export declare function isSameURL(a: string | URL, b: string | URL): boolean;
+/**
+ * Normalizes a string into a relay URL
+ * Does not remove the trailing slash
+ */
+export declare function normalizeURL<T extends string | URL>(url: T): T;

package/dist/helpers/url.js

@@ -4,26 +4,54 @@ export const IMAGE_EXT = [".svg", ".gif", ".png", ".jpg", ".jpeg", ".webp", ".av
 export const VIDEO_EXT = [".mp4", ".mkv", ".webm", ".mov"];
 export const STREAM_EXT = [".m3u8"];
 export const AUDIO_EXT = [".mp3", ".wav", ".ogg", ".aac"];
-export function isVisualMediaURL(url) {
-    return isImageURL(url) || isVideoURL(url) || isStreamURL(url);
-}
+/** Checks if a url is a image URL */
 export function isImageURL(url) {
     url = convertToUrl(url);
     const filename = getURLFilename(url);
     return !!filename && IMAGE_EXT.some((ext) => filename.endsWith(ext));
 }
+/** Checks if a url is a video URL */
 export function isVideoURL(url) {
     url = convertToUrl(url);
     const filename = getURLFilename(url);
     return !!filename && VIDEO_EXT.some((ext) => filename.endsWith(ext));
 }
+/** Checks if a url is a stream URL */
 export function isStreamURL(url) {
     url = convertToUrl(url);
     const filename = getURLFilename(url);
     return !!filename && STREAM_EXT.some((ext) => filename.endsWith(ext));
 }
+/** Checks if a url is a audio URL */
 export function isAudioURL(url) {
     url = convertToUrl(url);
     const filename = getURLFilename(url);
     return !!filename && AUDIO_EXT.some((ext) => filename.endsWith(ext));
 }
+/** Tests if two URLs are the same */
+export function isSameURL(a, b) {
+    try {
+        a = normalizeURL(a);
+        b = normalizeURL(b);
+        return a === b;
+    }
+    catch (error) {
+        return false;
+    }
+}
+/**
+ * Normalizes a string into a relay URL
+ * Does not remove the trailing slash
+ */
+export function normalizeURL(url) {
+    let p = new URL(url);
+    // remove any double slashes
+    p.pathname = p.pathname.replace(/\/+/g, "/");
+    // drop the port if its not needed
+    if ((p.port === "80" && (p.protocol === "ws:" || p.protocol === "http:")) ||
+        (p.port === "443" && (p.protocol === "wss:" || p.protocol === "https:")))
+        p.port = "";
+    // return a string if a string was passed in
+    // @ts-expect-error
+    return typeof url === "string" ? p.toString() : p;
+}

package/dist/helpers/user-status.d.ts

@@ -0,0 +1,18 @@
+import { NostrEvent } from "nostr-tools";
+import { AddressPointer, EventPointer, ProfilePointer } from "nostr-tools/nip19";
+export declare const UserStatusPointerSymbol: unique symbol;
+export type UserStatusPointer = {
+    type: "nevent";
+    data: EventPointer;
+} | {
+    type: "nprofile";
+    data: ProfilePointer;
+} | {
+    type: "naddr";
+    data: AddressPointer;
+} | {
+    type: "url";
+    data: string;
+};
+/** Gets the {@link UserStatusPointer} for a status event */
+export declare function getUserStatusPointer(status: NostrEvent): UserStatusPointer | null;

package/dist/helpers/user-status.js

@@ -0,0 +1,21 @@
+import { getAddressPointerFromATag, getEventPointerFromETag, getOrComputeCachedValue, getProfilePointerFromPTag, } from "applesauce-core/helpers";
+export const UserStatusPointerSymbol = Symbol.for("user-status-pointer");
+function getStatusPointer(status) {
+    const pTag = status.tags.find((t) => t[0] === "p" && t[1]);
+    if (pTag)
+        return { type: "nprofile", data: getProfilePointerFromPTag(pTag) };
+    const eTag = status.tags.find((t) => t[0] === "e" && t[1]);
+    if (eTag)
+        return { type: "nevent", data: getEventPointerFromETag(eTag) };
+    const aTag = status.tags.find((t) => t[0] === "a" && t[1]);
+    if (aTag)
+        return { type: "naddr", data: getAddressPointerFromATag(aTag) };
+    const rTag = status.tags.find((t) => t[0] === "r" && t[1]);
+    if (rTag)
+        return { type: "url", data: rTag[1] };
+    return null;
+}
+/** Gets the {@link UserStatusPointer} for a status event */
+export function getUserStatusPointer(status) {
+    return getOrComputeCachedValue(status, UserStatusPointerSymbol, () => getStatusPointer(status));
+}

package/dist/helpers/zap.d.ts

@@ -4,11 +4,36 @@ export declare const ZapFromSymbol: unique symbol;
 export declare const ZapInvoiceSymbol: unique symbol;
 export declare const ZapEventPointerSymbol: unique symbol;
 export declare const ZapAddressPointerSymbol: unique symbol;
+/** Returns the senders pubkey */
 export declare function getZapSender(zap: NostrEvent): string;
+/**
+ * Gets the receivers pubkey
+ * @throws
+ */
 export declare function getZapRecipient(zap: NostrEvent): string;
+/** Returns the parsed bolt11 invoice */
 export declare function getZapPayment(zap: NostrEvent): import("./bolt11.js").ParsedInvoice | undefined;
+/** Gets the AddressPointer that was zapped */
 export declare function getZapAddressPointer(zap: NostrEvent): import("nostr-tools/nip19").AddressPointer | null;
+/** Gets the EventPointer that was zapped */
 export declare function getZapEventPointer(zap: NostrEvent): import("nostr-tools/nip19").EventPointer | null;
+/** Gets the preimage for the bolt11 invoice */
 export declare function getZapPreimage(zap: NostrEvent): string | undefined;
+/**
+ * Returns the zap request event inside the zap receipt
+ * @throws
+ */
 export declare function getZapRequest(zap: NostrEvent): import("nostr-tools").Event;
+/**
+ * Checks if the zap is valid
+ * DOES NOT validate LNURL address
+ */
 export declare function isValidZap(zap?: NostrEvent): boolean;
+export type ZapSplit = {
+    pubkey: string;
+    percent: number;
+    weight: number;
+    relay?: string;
+};
+/** Returns the zap splits for an event */
+export declare function getZapSplits(event: NostrEvent): ZapSplit[] | undefined;

package/dist/helpers/zap.js

@@ -2,43 +2,56 @@ import { kinds, nip57 } from "nostr-tools";
 import { getOrComputeCachedValue } from "./cache.js";
 import { getTagValue } from "./event.js";
 import { isATag, isETag } from "./tags.js";
-import { getAddressPointerFromTag, getEventPointerFromTag } from "./pointers.js";
+import { getAddressPointerFromATag, getEventPointerFromETag } from "./pointers.js";
 import { parseBolt11 } from "./bolt11.js";
 export const ZapRequestSymbol = Symbol.for("zap-request");
 export const ZapFromSymbol = Symbol.for("zap-from");
 export const ZapInvoiceSymbol = Symbol.for("zap-bolt11");
 export const ZapEventPointerSymbol = Symbol.for("zap-event-pointer");
 export const ZapAddressPointerSymbol = Symbol.for("zap-address-pointer");
+/** Returns the senders pubkey */
 export function getZapSender(zap) {
     return getTagValue(zap, "P") || getZapRequest(zap).pubkey;
 }
+/**
+ * Gets the receivers pubkey
+ * @throws
+ */
 export function getZapRecipient(zap) {
     const recipient = getTagValue(zap, "p");
     if (!recipient)
         throw new Error("Missing recipient");
     return recipient;
 }
+/** Returns the parsed bolt11 invoice */
 export function getZapPayment(zap) {
     return getOrComputeCachedValue(zap, ZapInvoiceSymbol, () => {
         const bolt11 = getTagValue(zap, "bolt11");
         return bolt11 ? parseBolt11(bolt11) : undefined;
     });
 }
+/** Gets the AddressPointer that was zapped */
 export function getZapAddressPointer(zap) {
     return getOrComputeCachedValue(zap, ZapAddressPointerSymbol, () => {
         const a = zap.tags.find(isATag);
-        return a ? getAddressPointerFromTag(a) : null;
+        return a ? getAddressPointerFromATag(a) : null;
     });
 }
+/** Gets the EventPointer that was zapped */
 export function getZapEventPointer(zap) {
     return getOrComputeCachedValue(zap, ZapEventPointerSymbol, () => {
         const e = zap.tags.find(isETag);
-        return e ? getEventPointerFromTag(e) : null;
+        return e ? getEventPointerFromETag(e) : null;
     });
 }
+/** Gets the preimage for the bolt11 invoice */
 export function getZapPreimage(zap) {
     return getTagValue(zap, "preimage");
 }
+/**
+ * Returns the zap request event inside the zap receipt
+ * @throws
+ */
 export function getZapRequest(zap) {
     return getOrComputeCachedValue(zap, ZapRequestSymbol, () => {
         const description = getTagValue(zap, "description");
@@ -50,6 +63,10 @@ export function getZapRequest(zap) {
         return JSON.parse(description);
     });
 }
+/**
+ * Checks if the zap is valid
+ * DOES NOT validate LNURL address
+ */
 export function isValidZap(zap) {
     if (!zap)
         return false;
@@ -64,3 +81,15 @@ export function isValidZap(zap) {
         return false;
     }
 }
+/** Returns the zap splits for an event */
+export function getZapSplits(event) {
+    const tags = event.tags.filter((t) => t[0] === "zap" && t[1] && t[3]);
+    if (tags.length > 0) {
+        const targets = tags
+            .map((t) => ({ pubkey: t[1], relay: t[2], weight: parseFloat(t[3]) }))
+            .filter((p) => Number.isFinite(p.weight));
+        const total = targets.reduce((v, p) => v + p.weight, 0);
+        return targets.map((p) => ({ ...p, percent: p.weight / total }));
+    }
+    return undefined;
+}

package/dist/observable/__tests__/claim-events.test.d.ts

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

package/dist/observable/__tests__/claim-events.test.js

@@ -0,0 +1,23 @@
+import { describe, expect, it } from "vitest";
+import { Database } from "../../event-store/database.js";
+import { claimEvents } from "../claim-events.js";
+const event = {
+    content: '{"name":"hzrd149","picture":"https://cdn.hzrd149.com/5ed3fe5df09a74e8c126831eac999364f9eb7624e2b86d521521b8021de20bdc.png","about":"JavaScript developer working on some nostr stuff\\n- noStrudel https://nostrudel.ninja/ \\n- Blossom https://github.com/hzrd149/blossom \\n- Applesauce https://hzrd149.github.io/applesauce/","website":"https://hzrd149.com","nip05":"_@hzrd149.com","lud16":"hzrd1499@minibits.cash","pubkey":"266815e0c9210dfa324c6cba3573b14bee49da4209a9456f9484e5106cd408a5","display_name":"hzrd149","displayName":"hzrd149","banner":""}',
+    created_at: 1738362529,
+    id: "e9df8d5898c4ccfbd21fcd59f3f48abb3ff0ab7259b19570e2f1756de1e9306b",
+    kind: 0,
+    pubkey: "266815e0c9210dfa324c6cba3573b14bee49da4209a9456f9484e5106cd408a5",
+    relays: [""],
+    sig: "465a47b93626a587bf81dadc2b306b8f713a62db31d6ce1533198e9ae1e665a6eaf376a03250bf9ffbb02eb9059c8eafbd37ae1092d05d215757575bd8357586",
+    tags: [],
+};
+describe("claimEvents", () => {
+    it("it should claim events", () => {
+        const database = new Database();
+        const sub = database.inserted.pipe(claimEvents(database)).subscribe();
+        database.addEvent(event);
+        expect(database.isClaimed(event)).toBe(true);
+        sub.unsubscribe();
+        expect(database.isClaimed(event)).toBe(false);
+    });
+});

package/dist/observable/__tests__/claim-latest.test.d.ts

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

package/dist/observable/__tests__/claim-latest.test.js

@@ -0,0 +1,37 @@
+import { describe, expect, it } from "vitest";
+import { Database } from "../../event-store/database.js";
+import { claimLatest } from "../claim-latest.js";
+const event1 = {
+    content: '{"name":"hzrd149","picture":"https://cdn.hzrd149.com/5ed3fe5df09a74e8c126831eac999364f9eb7624e2b86d521521b8021de20bdc.png","about":"JavaScript developer working on some nostr stuff\\n- noStrudel https://nostrudel.ninja/ \\n- Blossom https://github.com/hzrd149/blossom \\n- Applesauce https://hzrd149.github.io/applesauce/","website":"https://hzrd149.com","nip05":"_@hzrd149.com","lud16":"hzrd1499@minibits.cash","pubkey":"266815e0c9210dfa324c6cba3573b14bee49da4209a9456f9484e5106cd408a5","display_name":"hzrd149","displayName":"hzrd149","banner":""}',
+    created_at: 1738362529,
+    id: "e9df8d5898c4ccfbd21fcd59f3f48abb3ff0ab7259b19570e2f1756de1e9306b",
+    kind: 0,
+    pubkey: "266815e0c9210dfa324c6cba3573b14bee49da4209a9456f9484e5106cd408a5",
+    relays: [""],
+    sig: "465a47b93626a587bf81dadc2b306b8f713a62db31d6ce1533198e9ae1e665a6eaf376a03250bf9ffbb02eb9059c8eafbd37ae1092d05d215757575bd8357586",
+    tags: [],
+};
+const event2 = {
+    content: '{"name":"Cesar Dias","website":"dev.nosotros.app","picture":"https://nostr.build/i/5b0e4387b0fdfff9897ee7f8dcc554761fe377583a5fb71bbf3b915e7c4971c2.jpg","display_name":"Cesar Dias","nip05":"_@nosotros.app","lud16":"cesardias@getalby.com","about":"Developer 🇧🇷, building a client https://dev.nosotros.app and nostr-editor https://github.com/cesardeazevedo/nostr-editor","banner":"https://image.nostr.build/87dbc55a6391d15bddda206561d53867a5679dd95e84fe8ed62bfe2e3adcadf3.jpg\\",\\"ox 87dbc55a6391d15bddda206561d53867a5679dd95e84fe8ed62bfe2e3adcadf3"}',
+    created_at: 1727998492,
+    id: "c771fe19ac255ea28690c5547258a5e146d2f47805f7f48093b773478bdd137c",
+    kind: 0,
+    pubkey: "c6603b0f1ccfec625d9c08b753e4f774eaf7d1cf2769223125b5fd4da728019e",
+    relays: [""],
+    sig: "5220d6a8cdb4837b2569c26a84a2ac6a44427a224cb1602c05c578c6a63fe122a37e16455b09cb38bf297fc8161a8e715d7b444d017624c044d87a77e092c881",
+    tags: [["alt", "User profile for Cesar Dias"]],
+};
+describe("claimLatest", () => {
+    it("it should claim events", () => {
+        const database = new Database();
+        const sub = database.inserted.pipe(claimLatest(database)).subscribe();
+        database.addEvent(event1);
+        expect(database.isClaimed(event1)).toBe(true);
+        database.addEvent(event2);
+        expect(database.isClaimed(event1)).toBe(false);
+        expect(database.isClaimed(event2)).toBe(true);
+        sub.unsubscribe();
+        expect(database.isClaimed(event1)).toBe(false);
+        expect(database.isClaimed(event2)).toBe(false);
+    });
+});

package/dist/observable/__tests__/simple-timeout.test.d.ts

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

package/dist/observable/__tests__/simple-timeout.test.js

@@ -0,0 +1,34 @@
+import { describe, it, expect } from "vitest";
+import { Observable, Subject, firstValueFrom } from "rxjs";
+import { simpleTimeout, TimeoutError } from "../simple-timeout.js";
+describe("simpleTimeout operator", () => {
+    it("should throw TimeoutError after specified timeout period", async () => {
+        const subject = new Subject();
+        const obs = subject.pipe(simpleTimeout(10));
+        const promise = firstValueFrom(obs);
+        await expect(promise).rejects.toThrow(TimeoutError);
+        await expect(promise).rejects.toThrow("Timeout");
+    });
+    it("should throw TimeoutError with custom message", async () => {
+        const subject = new Subject();
+        const customMessage = "Custom timeout message";
+        const obs = subject.pipe(simpleTimeout(10, customMessage));
+        const promise = firstValueFrom(obs);
+        await expect(promise).rejects.toThrow(TimeoutError);
+        await expect(promise).rejects.toThrow(customMessage);
+    });
+    it("should not throw when value emitted before timeout", async () => {
+        const subject = new Subject();
+        const obs = subject.pipe(simpleTimeout(1000));
+        const promise = firstValueFrom(obs);
+        subject.next("test value");
+        await expect(promise).resolves.toBe("test value");
+    });
+    it("should complete without error when source emits non-null value before timeout", async () => {
+        const source = new Observable((subscriber) => {
+            subscriber.next("test value");
+        });
+        const result = await firstValueFrom(source.pipe(simpleTimeout(10)));
+        expect(result).toBe("test value");
+    });
+});

package/dist/observable/claim-events.d.ts

@@ -0,0 +1,5 @@
+import { MonoTypeOperatorFunction } from "rxjs";
+import { NostrEvent } from "nostr-tools";
+import { Database } from "../event-store/database.js";
+/** keep a claim on any event that goes through this observable, claims are removed when the observable completes */
+export declare function claimEvents<T extends NostrEvent[] | NostrEvent | undefined>(database: Database): MonoTypeOperatorFunction<T>;

package/dist/observable/claim-events.js

@@ -0,0 +1,28 @@
+import { finalize, tap } from "rxjs";
+/** keep a claim on any event that goes through this observable, claims are removed when the observable completes */
+export function claimEvents(database) {
+    return (source) => {
+        const seen = new Set();
+        return source.pipe(
+        // claim all events
+        tap((message) => {
+            if (message === undefined)
+                return;
+            if (Array.isArray(message)) {
+                for (const event of message) {
+                    seen.add(event);
+                    database.claimEvent(event, source);
+                }
+            }
+            else {
+                seen.add(message);
+                database.claimEvent(message, source);
+            }
+        }), 
+        // remove claims on cleanup
+        finalize(() => {
+            for (const e of seen)
+                database.removeClaim(e, source);
+        }));
+    };
+}

package/dist/observable/claim-latest.d.ts

@@ -0,0 +1,4 @@
+import { MonoTypeOperatorFunction } from "rxjs";
+import { NostrEvent } from "nostr-tools";
+import { Database } from "../event-store/database.js";
+export declare function claimLatest(database: Database): MonoTypeOperatorFunction<NostrEvent | undefined>;

package/dist/observable/claim-latest.js

@@ -0,0 +1,20 @@
+import { finalize, tap } from "rxjs";
+export function claimLatest(database) {
+    return (source) => {
+        let latest = undefined;
+        return source.pipe(tap((event) => {
+            // remove old claim
+            if (latest)
+                database.removeClaim(latest, source);
+            // claim new event
+            if (event)
+                database.claimEvent(event, source);
+            // update state
+            latest = event;
+        }), finalize(() => {
+            // late claim
+            if (latest)
+                database.removeClaim(latest, source);
+        }));
+    };
+}

package/dist/observable/get-observable-value.d.ts

@@ -0,0 +1,3 @@
+import { Observable } from "rxjs";
+/** Subscribes and returns the observables current or next value */
+export declare function getObservableValue<T>(observable: Observable<T>): T | Promise<T>;

package/dist/observable/get-observable-value.js

@@ -0,0 +1,9 @@
+import { BehaviorSubject, firstValueFrom } from "rxjs";
+/** Subscribes and returns the observables current or next value */
+export function getObservableValue(observable) {
+    if (observable instanceof BehaviorSubject)
+        return observable.value;
+    if (Reflect.has(observable, "value"))
+        return Reflect.get(observable, "value");
+    return firstValueFrom(observable);
+}

package/dist/observable/index.d.ts

@@ -1,2 +1,3 @@
-export * from "./getValue.js";
+export * from "./get-observable-value.js";
 export * from "./share-latest-value.js";
+export * from "./simple-timeout.js";

package/dist/observable/index.js

@@ -1,2 +1,3 @@
-export * from "./getValue.js";
+export * from "./get-observable-value.js";
 export * from "./share-latest-value.js";
+export * from "./simple-timeout.js";

package/dist/observable/share-latest-value.d.ts

@@ -1,8 +1,6 @@
-import { Observable, ShareConfig } from "rxjs";
+import { OperatorFunction } from "rxjs";
 /**
  * Creates an operator that adds a 'value' property and multiplexes the source
  * @param config Optional ShareConfig for customizing sharing behavior
  */
-export declare function shareLatestValue<T>(config?: ShareConfig<T>): (source: Observable<T>) => Observable<T> & {
-    value: T | undefined;
-};
+export declare function shareLatestValue<T>(): OperatorFunction<T, T | undefined>;

package/dist/observable/share-latest-value.js

@@ -1,21 +1,24 @@
-import { share } from "rxjs";
-import { tap } from "rxjs/operators";
+import { BehaviorSubject, share } from "rxjs";
 /**
  * Creates an operator that adds a 'value' property and multiplexes the source
  * @param config Optional ShareConfig for customizing sharing behavior
  */
-export function shareLatestValue(config = {}) {
-    return (source) => {
-        // Create storage for latest value
-        let latestValue = undefined;
-        // Create shared source with value tracking
-        const shared$ = source.pipe(tap((value) => {
-            latestValue = value;
-        }), share(config));
-        // Add value property
-        Object.defineProperty(shared$, "value", {
-            get: () => latestValue,
-        });
-        return shared$;
-    };
+export function shareLatestValue() {
+    return (source$) => source$.pipe(share({ connector: () => new BehaviorSubject(undefined) }));
+    // return (source: Observable<T>): Observable<T> & { value: T | undefined } => {
+    //   // Create storage for latest value
+    //   let latestValue: T | undefined = undefined;
+    //   // Create shared source with value tracking
+    //   const shared$ = source.pipe(
+    //     tap((value) => {
+    //       latestValue = value;
+    //     }),
+    //     share(config),
+    //   );
+    //   // Add value property
+    //   Object.defineProperty(shared$, "value", {
+    //     get: () => latestValue,
+    //   });
+    //   return shared$ as Observable<T> & { value: T | undefined };
+    // };
 }

package/dist/observable/simple-timeout.d.ts

@@ -0,0 +1,4 @@
+import { MonoTypeOperatorFunction } from "rxjs";
+export declare class TimeoutError extends Error {
+}
+export declare function simpleTimeout<T extends unknown>(first: number, message?: string): MonoTypeOperatorFunction<T>;

package/dist/observable/simple-timeout.js

@@ -0,0 +1,6 @@
+import { throwError, timeout } from "rxjs";
+export class TimeoutError extends Error {
+}
+export function simpleTimeout(first, message) {
+    return timeout({ first, with: () => throwError(() => new TimeoutError(message ?? "Timeout")) });
+}

package/dist/promise/deferred.d.ts

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

package/dist/promise/deferred.js

@@ -1,3 +1,4 @@
+/** Creates a controlled promise */
 export function createDefer() {
     let _resolve;
     let _reject;

package/dist/queries/blossom.d.ts

@@ -0,0 +1,2 @@
+import { Query } from "../query-store/index.js";
+export declare function UserBlossomServersQuery(pubkey: string): Query<URL[] | undefined>;

package/dist/queries/blossom.js

@@ -0,0 +1,10 @@
+import { map } from "rxjs/operators";
+import { BLOSSOM_SERVER_LIST_KIND, getBlossomServersFromList } from "../helpers/blossom.js";
+export function UserBlossomServersQuery(pubkey) {
+    return {
+        key: pubkey,
+        run: (store) => store
+            .replaceable(BLOSSOM_SERVER_LIST_KIND, pubkey)
+            .pipe(map((event) => event && getBlossomServersFromList(event))),
+    };
+}

package/dist/queries/bookmarks.d.ts

@@ -0,0 +1,8 @@
+import { Bookmarks } from "../helpers/bookmarks.js";
+import { Query } from "../query-store/index.js";
+export declare function UserBookmarkQuery(pubkey: string): Query<Bookmarks | undefined>;
+export declare function UserHiddenBookmarkQuery(pubkey: string): Query<(Bookmarks & {
+    locked: false;
+}) | {
+    locked: true;
+} | undefined>;

package/dist/queries/bookmarks.js

@@ -0,0 +1,23 @@
+import { kinds } from "nostr-tools";
+import { map } from "rxjs/operators";
+import { isHiddenTagsLocked } from "../helpers/index.js";
+import { getBookmarks, getHiddenBookmarks } from "../helpers/bookmarks.js";
+export function UserBookmarkQuery(pubkey) {
+    return {
+        key: pubkey,
+        run: (store) => store.replaceable(kinds.Mutelist, pubkey).pipe(map((event) => event && getBookmarks(event))),
+    };
+}
+export function UserHiddenBookmarkQuery(pubkey) {
+    return {
+        key: pubkey,
+        run: (store) => store.replaceable(kinds.Mutelist, pubkey).pipe(map((event) => {
+            if (!event)
+                return undefined;
+            const bookmarks = getHiddenBookmarks(event);
+            if (isHiddenTagsLocked(event) || !bookmarks)
+                return { locked: true };
+            return { locked: false, ...bookmarks };
+        })),
+    };
+}