applesauce-core 0.0.0-next-20250828145754 → 0.0.0-next-20250912090040

package/dist/helpers/app-data.d.ts

@@ -0,0 +1,36 @@
+import { NostrEvent } from "nostr-tools";
+import { EncryptionMethod } from "./encrypted-content.js";
+import { HiddenContentSigner } from "./hidden-content.js";
+export declare const APP_DATA_KIND = 30078;
+export declare const AppDataContentSymbol: unique symbol;
+/** Checks if an event has application data */
+export declare function hasAppData<T extends {
+    kind: number;
+    content: string;
+}>(event: T): boolean;
+/** Checks if the application data is encrypted */
+export declare function getAppDataEncryption<T extends {
+    kind: number;
+    content: string;
+}>(event: T): EncryptionMethod | undefined;
+/** Checks if the application data is locked (encrypted and not decrypted) */
+export declare function isAppDataLocked<T extends object>(event: T): boolean;
+/** Returns the parsed application data for an event if it's unlocked */
+export declare function getAppDataContent<R extends unknown = unknown, T extends {
+    kind: number;
+    content: string;
+} = NostrEvent>(event: T): R | undefined;
+/**
+ * Unlocks the encrypted application data in the event
+ * @param event The event with encrypted content to decrypt
+ * @param signer A signer to use to decrypt the content
+ * @param override The encryption method to use instead of the default
+ * @returns The decrypted application data
+ */
+export declare function unlockAppData<R extends unknown = unknown, T extends {
+    kind: number;
+    pubkey: string;
+    content: string;
+} = NostrEvent>(event: T, signer: HiddenContentSigner, override?: EncryptionMethod): Promise<R>;
+/** Removes the unencrypted application data cache on an event */
+export declare function lockAppData<T extends object>(event: T): void;

package/dist/helpers/app-data.js

@@ -0,0 +1,67 @@
+import { isNIP04Encrypted } from "./encryption.js";
+import { getHiddenContent, isHiddenContentLocked, lockHiddenContent, setHiddenContentEncryptionMethod, unlockHiddenContent, } from "./hidden-content.js";
+import { safeParse } from "./json.js";
+// NIP-78 Application Data event kind
+export const APP_DATA_KIND = 30078;
+export const AppDataContentSymbol = Symbol.for("app-data-content");
+// Set the encryption method for app data events (default to nip44)
+setHiddenContentEncryptionMethod(APP_DATA_KIND, "nip44");
+/** Checks if an event has application data */
+export function hasAppData(event) {
+    return event.kind === APP_DATA_KIND && event.content.length > 0;
+}
+/** Checks if the application data is encrypted */
+export function getAppDataEncryption(event) {
+    // If content is empty, it can't be encrypted
+    if (event.content.length === 0)
+        return undefined;
+    // Try to parse as JSON - if it fails, it's likely encrypted
+    const parsed = safeParse(event.content);
+    if (parsed !== undefined)
+        return undefined;
+    return isNIP04Encrypted(event.content) ? "nip04" : "nip44";
+}
+/** Checks if the application data is locked (encrypted and not decrypted) */
+export function isAppDataLocked(event) {
+    return isHiddenContentLocked(event);
+}
+/** Returns the parsed application data for an event if it's unlocked */
+export function getAppDataContent(event) {
+    const cached = Reflect.get(event, AppDataContentSymbol);
+    if (cached)
+        return cached;
+    // If content is empty, return undefined
+    if (event.content.length === 0)
+        return undefined;
+    let data = getAppDataEncryption(event) ? undefined : safeParse(event.content);
+    if (!data) {
+        const decrypted = getHiddenContent(event);
+        if (decrypted)
+            data = safeParse(decrypted);
+    }
+    if (!data)
+        return undefined;
+    Reflect.set(event, AppDataContentSymbol, data);
+    return data;
+}
+/**
+ * Unlocks the encrypted application data in the event
+ * @param event The event with encrypted content to decrypt
+ * @param signer A signer to use to decrypt the content
+ * @param override The encryption method to use instead of the default
+ * @returns The decrypted application data
+ */
+export async function unlockAppData(event, signer, override) {
+    if (!getAppDataEncryption(event))
+        return getAppDataContent(event);
+    const method = override ?? getAppDataEncryption(event);
+    const plaintext = await unlockHiddenContent(event, signer, method);
+    const parsed = safeParse(plaintext);
+    if (parsed === undefined)
+        throw new Error("Failed to parse decrypted application data as JSON");
+    return parsed;
+}
+/** Removes the unencrypted application data cache on an event */
+export function lockAppData(event) {
+    lockHiddenContent(event);
+}

package/dist/helpers/event-cache.d.ts

@@ -9,7 +9,9 @@ import { IEventStoreStreams } from "../event-store/interface.js";
  * @param opts.maxBatchSize - The maximum number of events to write in a batch
  * @returns A function to stop the process
  */
-export declare function presistEventsToCache(eventStore: IEventStoreStreams, write: (events: NostrEvent[]) => Promise<void>, opts?: {
+export declare function persistEventsToCache(eventStore: IEventStoreStreams, write: (events: NostrEvent[]) => Promise<void>, opts?: {
     maxBatchSize?: number;
     batchTime?: number;
 }): () => void;
+/** @deprecated Use persistEventsToCache instead */
+export declare const presistEventsToCache: typeof persistEventsToCache;

package/dist/helpers/event-cache.js

@@ -11,7 +11,7 @@ const log = logger.extend("event-cache");
  * @param opts.maxBatchSize - The maximum number of events to write in a batch
  * @returns A function to stop the process
  */
-export function presistEventsToCache(eventStore, write, opts) {
+export function persistEventsToCache(eventStore, write, opts) {
     const time = opts?.batchTime ?? 5_000;
     // Save all new events to the cache
     const sub = eventStore.insert$
@@ -30,3 +30,5 @@ export function presistEventsToCache(eventStore, write, opts) {
     });
     return () => sub.unsubscribe();
 }
+/** @deprecated Use persistEventsToCache instead */
+export const presistEventsToCache = persistEventsToCache;

package/dist/helpers/event-tags.d.ts

@@ -10,5 +10,11 @@ export declare function getTagValue<T extends {
     tags: string[][];
     content: string;
 }>(event: T, name: string): string | undefined;
+/** Checks if an event has a public name / value tag*/
+export declare function hasNameValueTag<T extends {
+    kind: number;
+    tags: string[][];
+    content: string;
+}>(event: T, name: string, value: string): boolean;
 /** Returns a Set of tag names and values that are indexable */
 export declare function getIndexableTags(event: NostrEvent): Set<string>;

package/dist/helpers/event-tags.js

@@ -13,6 +13,10 @@ export function getTagValue(event, name) {
         return hiddenValue;
     return event.tags.find((t) => t[0] === name)?.[1];
 }
+/** Checks if an event has a public name / value tag*/
+export function hasNameValueTag(event, name, value) {
+    return event.tags.some((t) => t[0] === name && t[1] === value);
+}
 /** Returns a Set of tag names and values that are indexable */
 export function getIndexableTags(event) {
     let indexable = Reflect.get(event, EventIndexableTagsSymbol);

package/dist/helpers/event.d.ts

@@ -1,5 +1,7 @@
 import { NostrEvent, VerifiedEvent } from "nostr-tools";
 import { IEventStore } from "../event-store/interface.js";
+export { NostrEvent, EventTemplate, UnsignedEvent, verifiedSymbol } from "nostr-tools/pure";
+export * as kinds from "nostr-tools/kinds";
 /** A symbol on an event that marks which event store its part of */
 export declare const EventStoreSymbol: unique symbol;
 export declare const EventUIDSymbol: unique symbol;

package/dist/helpers/event.js

@@ -1,6 +1,9 @@
 import { verifiedSymbol } from "nostr-tools";
 import { isAddressableKind, isReplaceableKind } from "nostr-tools/kinds";
 import { getOrComputeCachedValue } from "./cache.js";
+// Re-export types from nostr-tools
+export { verifiedSymbol } from "nostr-tools/pure";
+export * as kinds from "nostr-tools/kinds";
 /** A symbol on an event that marks which event store its part of */
 export const EventStoreSymbol = Symbol.for("event-store");
 export const EventUIDSymbol = Symbol.for("event-uid");

package/dist/helpers/filter.d.ts

@@ -1,4 +1,5 @@
 import { Filter, NostrEvent } from "nostr-tools";
+export { Filter } from "nostr-tools/filter";
 /**
  * Copied from nostr-tools and modified to use getIndexableTags
  * @see https://github.com/nbd-wtf/nostr-tools/blob/a61cde77eacc9518001f11d7f67f1a50ae05fd80/filter.ts

package/dist/helpers/relays.d.ts

@@ -12,4 +12,6 @@ export declare function getSeenRelays(event: NostrEvent): Set<string> | undefine
 /** A fast check to make sure relay hints are safe to connect to */
 export declare function isSafeRelayURL(relay: string): boolean;
 /** Merge multiple sets of relays and remove duplicates (ignores invalid URLs) */
-export declare function mergeRelaySets(...sources: (Iterable<string> | undefined)[]): string[];
+export declare function mergeRelaySets(...sources: (Iterable<string> | string | undefined)[]): string[];
+/** Alias for {@link mergeRelaySets} */
+export declare const relaySet: typeof mergeRelaySets;

package/dist/helpers/relays.js

@@ -23,9 +23,10 @@ export function mergeRelaySets(...sources) {
     for (const src of sources) {
         if (!src)
             continue;
-        for (const url of src) {
+        if (typeof src === "string") {
+            // Source is a string
             try {
-                const safe = normalizeURL(url).toString();
+                const safe = normalizeURL(src).toString();
                 if (safe)
                     set.add(safe);
             }
@@ -33,6 +34,21 @@ export function mergeRelaySets(...sources) {
                 // failed to parse URL, ignore
             }
         }
+        else {
+            // Source is iterable
+            for (const url of src) {
+                try {
+                    const safe = normalizeURL(url).toString();
+                    if (safe)
+                        set.add(safe);
+                }
+                catch (error) {
+                    // failed to parse URL, ignore
+                }
+            }
+        }
     }
     return Array.from(set);
 }
+/** Alias for {@link mergeRelaySets} */
+export const relaySet = mergeRelaySets;

package/dist/observable/index.d.ts

@@ -1,7 +1,7 @@
 import { firstValueFrom, lastValueFrom } from "rxjs";
 export * from "./defined.js";
 export * from "./get-observable-value.js";
-export * from "./map-events-timeline.js";
+export * from "./map-events-to-timeline.js";
 export * from "./map-events-to-store.js";
 export * from "./simple-timeout.js";
 export * from "./watch-event-updates.js";

package/dist/observable/index.js

@@ -1,7 +1,7 @@
 import { firstValueFrom, lastValueFrom } from "rxjs";
 export * from "./defined.js";
 export * from "./get-observable-value.js";
-export * from "./map-events-timeline.js";
+export * from "./map-events-to-timeline.js";
 export * from "./map-events-to-store.js";
 export * from "./simple-timeout.js";
 export * from "./watch-event-updates.js";

package/dist/observable/map-events-to-store.d.ts

@@ -1,5 +1,7 @@
-import { MonoTypeOperatorFunction } from "rxjs";
 import { NostrEvent } from "nostr-tools";
-import { IEventStore } from "../event-store/interface.js";
+import { MonoTypeOperatorFunction } from "rxjs";
+import { IEventStoreActions } from "../event-store/interface.js";
 /** Saves all events to an event store and filters out invalid events */
-export declare function mapEventsToStore(store: IEventStore, removeDuplicates?: boolean): MonoTypeOperatorFunction<NostrEvent>;
+export declare function mapEventsToStore(store: IEventStoreActions, removeDuplicates?: boolean): MonoTypeOperatorFunction<NostrEvent>;
+/** Alias for {@link mapEventsToStore} */
+export declare const filterDuplicateEvents: (store: IEventStoreActions) => MonoTypeOperatorFunction<import("nostr-tools").Event>;

package/dist/observable/map-events-to-store.js

@@ -3,10 +3,12 @@ import { distinct, filter, identity, map } from "rxjs";
 export function mapEventsToStore(store, removeDuplicates = true) {
     return (source) => source.pipe(
     // Map all events to the store
-    // NOTE: map is used here because we want to return the single cononical version of the event so that distinct() can be used later
+    // NOTE: map is used here because we want to return the single instance of the event so that distinct() can be used later
     map((event) => store.add(event)), 
     // Ignore invalid events
     filter((e) => e !== null), 
     // Remove duplicates if requested
     removeDuplicates ? distinct() : identity);
 }
+/** Alias for {@link mapEventsToStore} */
+export const filterDuplicateEvents = (store) => mapEventsToStore(store, true);

package/dist/observable/map-events-to-timeline.d.ts

@@ -0,0 +1,7 @@
+import { NostrEvent } from "nostr-tools";
+import { OperatorFunction } from "rxjs";
+/**
+ * Accumulate events into an ordered timeline
+ * @note This does not remove duplicate events
+ */
+export declare function mapEventsToTimeline(): OperatorFunction<NostrEvent, NostrEvent[]>;

package/dist/observable/map-events-to-timeline.js

@@ -0,0 +1,12 @@
+import { insertEventIntoDescendingList } from "nostr-tools/utils";
+import { pipe, scan } from "rxjs";
+import { withImmediateValueOrDefault } from "./with-immediate-value.js";
+/**
+ * Accumulate events into an ordered timeline
+ * @note This does not remove duplicate events
+ */
+export function mapEventsToTimeline() {
+    return pipe(scan((timeline, event) => insertEventIntoDescendingList(timeline, event), []), 
+    // Emit an empty array first. This is to prevent empty observables completing without a value (EMPTY)
+    withImmediateValueOrDefault([]));
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "applesauce-core",
-  "version": "0.0.0-next-20250828145754",
+  "version": "0.0.0-next-20250912090040",
   "description": "",
   "type": "module",
   "main": "dist/index.js",
@@ -72,7 +72,7 @@
     "@types/debug": "^4.1.12",
     "@types/hash-sum": "^1.0.2",
     "typescript": "^5.8.3",
-    "vitest": "^3.2.3"
+    "vitest": "^3.2.4"
   },
   "funding": {
     "type": "lightning",