applesauce-core 0.0.0-next-20251220152312 → 0.0.0-next-20251231062646

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

@@ -43,11 +43,11 @@ export declare class AsyncEventStore extends EventModels implements IAsyncEventS
     /** Sets the method used to verify events */
     set verifyEvent(method: undefined | ((event: NostrEvent) => boolean));
     /** A stream of new events added to the store */
-    insert$: Subject<import("nostr-tools/core").Event>;
+    insert$: Subject<NostrEvent>;
     /** A stream of events that have been updated (Warning: this is a very noisy stream, use with caution) */
-    update$: Subject<import("nostr-tools/core").Event>;
+    update$: Subject<NostrEvent>;
     /** A stream of events that have been removed */
-    remove$: Subject<import("nostr-tools/core").Event>;
+    remove$: Subject<NostrEvent>;
     /**
      * A method that will be called when an event isn't found in the store
      */

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

@@ -6,16 +6,16 @@ import { IEventMemory } from "./interface.js";
 export declare class EventMemory implements IEventMemory {
     protected log: import("debug").Debugger;
     /** Indexes */
-    protected kinds: Map<number, Set<import("nostr-tools").Event>>;
-    protected authors: Map<string, Set<import("nostr-tools").Event>>;
-    protected tags: LRU<Set<import("nostr-tools").Event>>;
+    protected kinds: Map<number, Set<NostrEvent>>;
+    protected authors: Map<string, Set<NostrEvent>>;
+    protected tags: LRU<Set<NostrEvent>>;
     protected created_at: NostrEvent[];
     /** Composite index for kind+author queries (common pattern) */
-    protected kindAuthor: Map<string, Set<import("nostr-tools").Event>>;
+    protected kindAuthor: Map<string, Set<NostrEvent>>;
     /** LRU cache of last events touched */
-    events: LRU<import("nostr-tools").Event>;
+    events: LRU<NostrEvent>;
     /** A sorted array of replaceable events by address */
-    protected replaceable: Map<string, import("nostr-tools").Event[]>;
+    protected replaceable: Map<string, NostrEvent[]>;
     /** The number of events in the database */
     get size(): number;
     /** Checks if the database contains an event without touching it */
@@ -41,7 +41,7 @@ export declare class EventMemory implements IEventMemory {
     /** Notify the database that an event has updated */
     update(_event: NostrEvent): void;
     /** A weak map of events to claim reference counts */
-    protected claims: WeakMap<import("nostr-tools").Event, number>;
+    protected claims: WeakMap<NostrEvent, number>;
     /** Moves an event to the top of the LRU cache */
     touch(event: NostrEvent): void;
     /** Increments the claim count on the event and touches it */
@@ -57,10 +57,10 @@ export declare class EventMemory implements IEventMemory {
     /** Removes events that are not claimed (free up memory) */
     prune(limit?: number): number;
     /** Index helper methods */
-    protected getKindIndex(kind: number): Set<import("nostr-tools").Event>;
-    protected getAuthorsIndex(author: string): Set<import("nostr-tools").Event>;
-    protected getKindAuthorIndex(kind: number, pubkey: string): Set<import("nostr-tools").Event>;
-    protected getTagIndex(tagAndValue: string): Set<import("nostr-tools").Event>;
+    protected getKindIndex(kind: number): Set<NostrEvent>;
+    protected getAuthorsIndex(author: string): Set<NostrEvent>;
+    protected getKindAuthorIndex(kind: number, pubkey: string): Set<NostrEvent>;
+    protected getTagIndex(tagAndValue: string): Set<NostrEvent>;
     /**
      * Helper method to remove an event from a sorted array using binary search.
      * Falls back to indexOf if binary search doesn't find exact match.

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

@@ -312,6 +312,9 @@ export class EventMemory {
     }
     /** Iterates over all events by time */
     *iterateTime(since, until) {
+        // Early return if array is empty
+        if (this.created_at.length === 0)
+            return;
         let startIndex = 0;
         let endIndex = this.created_at.length - 1;
         // If until is set, use binary search to find better start index
@@ -320,16 +323,21 @@ export class EventMemory {
                 return mid.created_at - until;
             })
             : undefined;
-        if (start)
-            startIndex = start[0];
+        if (start) {
+            startIndex = Math.max(0, Math.min(start[0], this.created_at.length - 1));
+        }
         // If since is set, use binary search to find better end index
         const end = since
             ? binarySearch(this.created_at, (mid) => {
                 return mid.created_at - since;
             })
             : undefined;
-        if (end)
-            endIndex = end[0];
+        if (end) {
+            endIndex = Math.max(0, Math.min(end[0], this.created_at.length - 1));
+        }
+        // Ensure startIndex <= endIndex
+        if (startIndex > endIndex)
+            return;
         // Yield events in the range, filtering by exact bounds
         for (let i = startIndex; i <= endIndex; i++) {
             const event = this.created_at[i];

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

@@ -43,11 +43,11 @@ export declare class EventStore extends EventModels implements IEventStore {
     /** Sets the method used to verify events */
     set verifyEvent(method: undefined | ((event: NostrEvent) => boolean));
     /** A stream of new events added to the store */
-    insert$: Subject<import("nostr-tools/core").Event>;
+    insert$: Subject<NostrEvent>;
     /** A stream of events that have been updated (Warning: this is a very noisy stream, use with caution) */
-    update$: Subject<import("nostr-tools/core").Event>;
+    update$: Subject<NostrEvent>;
     /** A stream of events that have been removed */
-    remove$: Subject<import("nostr-tools/core").Event>;
+    remove$: Subject<NostrEvent>;
     /** A method that will be called when an event isn't found in the store */
     eventLoader?: (pointer: EventPointer | AddressPointer | AddressPointerWithoutD) => Observable<NostrEvent> | Promise<NostrEvent | undefined>;
     constructor(options?: EventStoreOptions);

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

@@ -9,7 +9,7 @@ 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 persistEventsToCache(eventStore: IEventStoreStreams, write: (events: NostrEvent[]) => Promise<void>, opts?: {
+export declare function persistEventsToCache(eventStore: IEventStoreStreams, write: (events: NostrEvent[]) => Promise<any>, opts?: {
     maxBatchSize?: number;
     batchTime?: number;
 }): () => void;

package/dist/helpers/pointers.d.ts

@@ -20,6 +20,8 @@ export declare function getPubkeyFromDecodeResult(result?: DecodeResult): string
 export declare function getRelaysFromDecodeResult(result?: DecodeResult): string[] | undefined;
 /** Encodes the result of nip19.decode */
 export declare function encodeDecodeResult(result: DecodeResult): "" | `nevent1${string}` | `nprofile1${string}` | `naddr1${string}` | `nsec1${string}` | `npub1${string}` | `note1${string}`;
+/** Encodes a pointer to a NIP-19 string */
+export declare function encodePointer(pointer: AddressPointer | EventPointer | ProfilePointer): string;
 /** Gets an EventPointer form a common "e" tag */
 export declare function getEventPointerFromETag(tag: string[]): EventPointer | null;
 /** Gets an EventPointer form a common "q" tag */
@@ -30,6 +32,8 @@ export declare function getAddressPointerFromATag(tag: string[]): AddressPointer
 export declare function getProfilePointerFromPTag(tag: string[]): ProfilePointer | null;
 /** Checks if a pointer is an AddressPointer */
 export declare function isAddressPointer(pointer: any): pointer is AddressPointer;
+/** Checks if a pointer is a ProfilePointer */
+export declare function isProfilePointer(pointer: any): pointer is ProfilePointer;
 /** Checks if a pointer is an EventPointer */
 export declare function isEventPointer(pointer: any): pointer is EventPointer;
 /** Returns the stringified address pointer */

package/dist/helpers/pointers.js

@@ -106,6 +106,17 @@ export function encodeDecodeResult(result) {
     }
     return "";
 }
+/** Encodes a pointer to a NIP-19 string */
+export function encodePointer(pointer) {
+    if (isAddressPointer(pointer))
+        return naddrEncode(pointer);
+    else if (isEventPointer(pointer))
+        return neventEncode(pointer);
+    else if (isProfilePointer(pointer))
+        return nprofileEncode(pointer);
+    else
+        return "";
+}
 /** Gets an EventPointer form a common "e" tag */
 export function getEventPointerFromETag(tag) {
     const id = tag[1];
@@ -160,6 +171,16 @@ export function isAddressPointer(pointer) {
         typeof pointer.pubkey === "string" &&
         typeof pointer.kind === "number");
 }
+/** Checks if a pointer is a ProfilePointer */
+export function isProfilePointer(pointer) {
+    return (typeof pointer === "object" &&
+        pointer !== null &&
+        "pubkey" in pointer &&
+        typeof pointer.pubkey === "string" &&
+        // Ensure its not an event or address pointer since they both have a pubkey fields
+        !isEventPointer(pointer) &&
+        !isAddressPointer(pointer));
+}
 /** Checks if a pointer is an EventPointer */
 export function isEventPointer(pointer) {
     return typeof pointer === "object" && pointer !== null && "id" in pointer && typeof pointer.id === "string";

package/dist/helpers/profile.d.ts

@@ -1,21 +1,43 @@
 import { KnownEvent, NostrEvent, kinds } from "./event.js";
 export declare const ProfileContentSymbol: unique symbol;
 export type ProfileContent = {
+    /** Nickname or full name of the user */
     name?: string;
     /** @deprecated use name instead */
     username?: string;
+    /** An alternative, bigger name with richer characters than `name`. `name` should always be set regardless of the presence of `display_name`. */
     display_name?: string;
     /** @deprecated use display_name instead */
     displayName?: string;
+    /** Short bio or description of the user */
     about?: string;
     /** @deprecated use picture instead */
     image?: string;
+    /** URL of the profile picture image */
     picture?: string;
+    /** URL to a wide (~1024x768) picture to be optionally displayed in the background of a profile screen */
     banner?: string;
+    /** A web URL related in any way to the event author */
     website?: string;
+    /** Lightning address in the format `user@domain.com` (LUD-16 format) */
     lud16?: string;
+    /** Lightning address in the format `user@domain.com` (LUD-06 format) */
     lud06?: string;
+    /** DNS-based verification identifier in the format `_@domain.com` or `user@domain.com` */
     nip05?: string;
+    /** Boolean to clarify that the content is entirely or partially the result of automation, such as with chatbots or newsfeeds */
+    bot?: boolean;
+    /** Object representing the author's birth date. Each field may be omitted. */
+    birthday?: {
+        /** Birth year */
+        year?: number;
+        /** Birth month (1-12) */
+        month?: number;
+        /** Birth day (1-31) */
+        day?: number;
+    };
+    /** An array of strings representing the author's preferred languages (in order of preference), each in IETF BCP 47 format (e.g., ["en", "ja"], ["es-AR", "en-US"]). The first element is the primary language. */
+    languages?: string[];
 };
 /** Type for validated profile events */
 export type ProfileEvent = KnownEvent<kinds.Metadata>;

package/dist/helpers/relays.d.ts

@@ -1,10 +1,5 @@
 import { NostrEvent } from "./event.js";
 export declare const SeenRelaysSymbol: unique symbol;
-declare module "nostr-tools" {
-    interface Event {
-        [SeenRelaysSymbol]?: Set<string>;
-    }
-}
 /** Marks an event as being seen on a relay */
 export declare function addSeenRelay(event: NostrEvent, relay: string): Set<string>;
 /** Returns the set of relays this event was seen on */

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

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "applesauce-core",
-  "version": "0.0.0-next-20251220152312",
+  "version": "0.0.0-next-20251231062646",
   "description": "",
   "type": "module",
   "main": "dist/index.js",
@@ -81,7 +81,7 @@
     "fast-deep-equal": "^3.1.3",
     "hash-sum": "^2.0.0",
     "nanoid": "^5.0.9",
-    "nostr-tools": "~2.18",
+    "nostr-tools": "~2.19",
     "rxjs": "^7.8.1"
   },
   "devDependencies": {

package/dist/helpers/external-id.d.ts

@@ -1,29 +0,0 @@
-export type ExternalIdentifiers = {
-    "#": `#${string}`;
-    geo: `geo:${string}`;
-    isbn: `isbn:${string}`;
-    "podcast:guid": `podcast:guid:${string}`;
-    "podcast:item:guid": `podcast:item:guid:${string}`;
-    "podcast:publisher:guid": `podcast:publisher:guid:${string}`;
-    isan: `isan:${string}`;
-    doi: `doi:${string}`;
-};
-export type ExternalPointer<Prefix extends keyof ExternalIdentifiers> = {
-    kind: Prefix;
-    identifier: ExternalIdentifiers[Prefix];
-};
-export type ParseResult = {
-    [P in keyof ExternalIdentifiers]: ExternalPointer<P>;
-}[keyof ExternalIdentifiers];
-/**
- * Parses a NIP-73 external identifier
- * @throws
- */
-export declare function parseExternalPointer<Prefix extends keyof ExternalIdentifiers>(identifier: `${Prefix}1${string}`): ExternalPointer<Prefix>;
-export declare function parseExternalPointer(identifier: string): ParseResult;
-/**
- * Gets an ExternalPointer for a "i" tag
- * @throws
- */
-export declare function getExternalPointerFromTag<Prefix extends keyof ExternalIdentifiers>(tag: string[]): ExternalPointer<Prefix>;
-export declare function getExternalPointerFromTag(tag: string[]): ParseResult;

package/dist/helpers/external-id.js

@@ -1,20 +0,0 @@
-export function parseExternalPointer(identifier) {
-    if (identifier.startsWith("#"))
-        return { kind: "#", identifier: identifier };
-    if (identifier.startsWith("geo:"))
-        return { kind: "geo", identifier: identifier };
-    if (identifier.startsWith("podcast:guid:"))
-        return { kind: "podcast:guid", identifier: identifier };
-    if (identifier.startsWith("podcast:item:guid:"))
-        return { kind: "podcast:item:guid", identifier: identifier };
-    if (identifier.startsWith("podcast:publisher:guid:"))
-        return { kind: "podcast:publisher:guid", identifier: identifier };
-    if (identifier.startsWith("isan:"))
-        return { kind: "isan", identifier: identifier };
-    if (identifier.startsWith("doi:"))
-        return { kind: "doi", identifier: identifier };
-    throw new Error("Failed to parse external identifier");
-}
-export function getExternalPointerFromTag(tag) {
-    return parseExternalPointer(tag[1]);
-}