applesauce-core 0.0.0-next-20251220152312 → 0.0.0-next-20251231055351

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/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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "applesauce-core",
-  "version": "0.0.0-next-20251220152312",
+  "version": "0.0.0-next-20251231055351",
   "description": "",
   "type": "module",
   "main": "dist/index.js",

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]);
-}