applesauce-core 2.3.0 → 3.0.0

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

@@ -1,7 +1,7 @@
 import { binarySearch, insertEventIntoDescendingList } from "nostr-tools/utils";
 import { Subject } from "rxjs";
 import { getIndexableTags, INDEXABLE_TAGS } from "../helpers/event-tags.js";
-import { createReplaceableAddress, getReplaceableAddress, isReplaceable } from "../helpers/event.js";
+import { createReplaceableAddress, isReplaceable } from "../helpers/event.js";
 import { LRU } from "../helpers/lru.js";
 import { logger } from "../logger.js";
 /**
@@ -92,7 +92,8 @@ export class EventSet {
         insertEventIntoDescendingList(this.created_at, event);
         // Insert into replaceable index
         if (isReplaceable(event.kind)) {
-            const address = getReplaceableAddress(event);
+            const identifier = event.tags.find((t) => t[0] === "d")?.[1];
+            const address = createReplaceableAddress(event.kind, event.pubkey, identifier);
             let array = this.replaceable.get(address);
             if (!this.replaceable.has(address)) {
                 // add an empty array if there is no array
@@ -135,7 +136,8 @@ export class EventSet {
         this.events.delete(id);
         // remove from replaceable index
         if (isReplaceable(event.kind)) {
-            const address = getReplaceableAddress(event);
+            const identifier = event.tags.find((t) => t[0] === "d")?.[1];
+            const address = createReplaceableAddress(event.kind, event.pubkey, identifier);
             const array = this.replaceable.get(address);
             if (array && array.includes(event)) {
                 const idx = array.indexOf(event);

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

@@ -1,12 +1,16 @@
 import { Filter, NostrEvent } from "nostr-tools";
 import { Observable } from "rxjs";
+import { AddressPointer, EventPointer, ProfilePointer } from "nostr-tools/nip19";
+import { AddressPointerWithoutD } from "../helpers/pointers.js";
 import { EventSet } from "./event-set.js";
 import { IEventStore, ModelConstructor } from "./interface.js";
-import { AddressPointer, EventPointer } from "nostr-tools/nip19";
+/** An extended {@link EventSet} that handles replaceable events, delets, and models */
 export declare class EventStore implements IEventStore {
     database: EventSet;
     /** Enable this to keep old versions of replaceable events */
     keepOldVersions: boolean;
+    /** Enable this to keep expired events */
+    keepExpired: boolean;
     /**
      * A method used to verify new events before added them
      * @returns true if the event is valid, false if it should be ignored
@@ -18,10 +22,33 @@ export declare class EventStore implements IEventStore {
     update$: Observable<NostrEvent>;
     /** A stream of events that have been removed */
     remove$: Observable<NostrEvent>;
+    /**
+     * A method that will be called when an event isn't found in the store
+     * @experimental
+     */
+    eventLoader?: (pointer: EventPointer) => Observable<NostrEvent> | Promise<NostrEvent | undefined>;
+    /**
+     * A method that will be called when a replaceable event isn't found in the store
+     * @experimental
+     */
+    replaceableLoader?: (pointer: AddressPointerWithoutD) => Observable<NostrEvent> | Promise<NostrEvent | undefined>;
+    /**
+     * A method that will be called when an addressable event isn't found in the store
+     * @experimental
+     */
+    addressableLoader?: (pointer: AddressPointer) => Observable<NostrEvent> | Promise<NostrEvent | undefined>;
     constructor();
     protected deletedIds: Set<string>;
     protected deletedCoords: Map<string, number>;
     protected checkDeleted(event: string | NostrEvent): boolean;
+    protected expirations: Map<string, number>;
+    /** Adds an event to the expiration map */
+    protected addExpiration(event: NostrEvent): void;
+    protected expirationTimeout: number | null;
+    protected nextExpirationCheck: number | null;
+    protected handleExpiringEvent(event: NostrEvent): void;
+    /** Remove expired events from the store */
+    protected pruneExpired(): void;
     protected handleDeleteEvent(deleteEvent: NostrEvent): void;
     /** Copies important metadata from and identical event to another */
     static mergeDuplicateEvent(source: NostrEvent, dest: NostrEvent): void;
@@ -75,36 +102,39 @@ export declare class EventStore implements IEventStore {
     /** Creates an observable that emits when event is updated */
     updated(event: string | NostrEvent): Observable<NostrEvent>;
     /** Creates a {@link EventModel} */
-    event(id: string): Observable<NostrEvent | undefined>;
+    event(pointer: string | EventPointer): Observable<NostrEvent | undefined>;
     /** Creates a {@link ReplaceableModel} */
+    replaceable(pointer: AddressPointer | AddressPointerWithoutD): Observable<NostrEvent | undefined>;
     replaceable(kind: number, pubkey: string, identifier?: string): Observable<NostrEvent | undefined>;
+    /** Subscribe to an addressable event by pointer */
+    addressable(pointer: AddressPointer): Observable<NostrEvent | undefined>;
     /** Creates a {@link TimelineModel} */
     timeline(filters: Filter | Filter[], includeOldVersion?: boolean): Observable<NostrEvent[]>;
-    /** Creates a {@link EventsModel} */
-    events(ids: string[]): Observable<Record<string, NostrEvent>>;
-    /** Creates a {@link ReplaceableSetModel} */
-    replaceableSet(pointers: {
-        kind: number;
-        pubkey: string;
-        identifier?: string;
-    }[]): Observable<Record<string, NostrEvent>>;
-    /** Creates a {@link ProfileModel} */
-    profile(pubkey: string): Observable<import("../helpers/profile.js").ProfileContent | undefined>;
-    /** Creates a {@link ContactsModel} */
-    contacts(pubkey: string): Observable<import("nostr-tools/nip19").ProfilePointer[]>;
-    /** Creates a {@link MuteModel} */
-    mutes(pubkey: string): Observable<import("../helpers/mutes.js").Mutes | undefined>;
-    /** Creates a {@link ReactionsModel} */
-    reactions(event: NostrEvent): Observable<import("nostr-tools").Event[]>;
-    /** Creates a {@link MailboxesModel} */
-    mailboxes(pubkey: string): Observable<{
+    /** Subscribe to a users profile */
+    profile(user: string | ProfilePointer): Observable<import("../helpers/profile.js").ProfileContent | undefined>;
+    /** Subscribe to a users contacts */
+    contacts(user: string | ProfilePointer): Observable<ProfilePointer[]>;
+    /** Subscribe to a users mutes */
+    mutes(user: string | ProfilePointer): Observable<import("../helpers/mutes.js").Mutes | undefined>;
+    /** Subscribe to a users NIP-65 mailboxes */
+    mailboxes(user: string | ProfilePointer): Observable<{
         inboxes: string[];
         outboxes: string[];
     } | undefined>;
-    /** Creates a {@link UserBlossomServersModel} */
-    blossomServers(pubkey: string): Observable<URL[]>;
-    /** Creates a {@link ThreadModel} */
+    /** Subscribe to a users blossom servers */
+    blossomServers(user: string | ProfilePointer): Observable<URL[]>;
+    /** Subscribe to an event's reactions */
+    reactions(event: NostrEvent): Observable<import("nostr-tools").Event[]>;
+    /** Subscribe to a thread */
     thread(root: string | EventPointer | AddressPointer): Observable<import("../models/thread.js").Thread>;
-    /** Creates a {@link CommentsModel} */
+    /** Subscribe to a event's comments */
     comments(event: NostrEvent): Observable<import("nostr-tools").Event[]>;
+    /** @deprecated use multiple {@link EventModel} instead */
+    events(ids: string[]): Observable<Record<string, NostrEvent | undefined>>;
+    /** @deprecated use multiple {@link ReplaceableModel} instead */
+    replaceableSet(pointers: {
+        kind: number;
+        pubkey: string;
+        identifier?: string;
+    }[]): Observable<Record<string, NostrEvent | undefined>>;
 }

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

@@ -3,23 +3,28 @@ import { isAddressableKind } from "nostr-tools/kinds";
 import { EMPTY, filter, finalize, from, merge, mergeMap, ReplaySubject, share, take, timer } from "rxjs";
 import hash_sum from "hash-sum";
 import { getDeleteCoordinates, getDeleteIds } from "../helpers/delete.js";
-import { EventStoreSymbol, FromCacheSymbol, getReplaceableAddress, isReplaceable } from "../helpers/event.js";
+import { createReplaceableAddress, EventStoreSymbol, FromCacheSymbol, isReplaceable } from "../helpers/event.js";
+import { getExpirationTimestamp } from "../helpers/expiration.js";
 import { matchFilters } from "../helpers/filter.js";
 import { parseCoordinate } from "../helpers/pointers.js";
 import { addSeenRelay, getSeenRelays } from "../helpers/relays.js";
+import { unixNow } from "../helpers/time.js";
+import { UserBlossomServersModel } from "../models/blossom.js";
 import { EventModel, EventsModel, ReplaceableModel, ReplaceableSetModel, TimelineModel } from "../models/common.js";
-import { EventSet } from "./event-set.js";
-import { ProfileModel } from "../models/profile.js";
 import { ContactsModel } from "../models/contacts.js";
+import { CommentsModel, ThreadModel } from "../models/index.js";
+import { MailboxesModel } from "../models/mailboxes.js";
 import { MuteModel } from "../models/mutes.js";
+import { ProfileModel } from "../models/profile.js";
 import { ReactionsModel } from "../models/reactions.js";
-import { MailboxesModel } from "../models/mailboxes.js";
-import { UserBlossomServersModel } from "../models/blossom.js";
-import { CommentsModel, ThreadModel } from "../models/index.js";
+import { EventSet } from "./event-set.js";
+/** An extended {@link EventSet} that handles replaceable events, delets, and models */
 export class EventStore {
     database;
     /** Enable this to keep old versions of replaceable events */
     keepOldVersions = false;
+    /** Enable this to keep expired events */
+    keepExpired = false;
     /**
      * A method used to verify new events before added them
      * @returns true if the event is valid, false if it should be ignored
@@ -31,6 +36,21 @@ export class EventStore {
     update$;
     /** A stream of events that have been removed */
     remove$;
+    /**
+     * A method that will be called when an event isn't found in the store
+     * @experimental
+     */
+    eventLoader;
+    /**
+     * A method that will be called when a replaceable event isn't found in the store
+     * @experimental
+     */
+    replaceableLoader;
+    /**
+     * A method that will be called when an addressable event isn't found in the store
+     * @experimental
+     */
+    addressableLoader;
     constructor() {
         this.database = new EventSet();
         // verify events before they are added to the database
@@ -63,12 +83,53 @@ export class EventStore {
             if (this.deletedIds.has(event.id))
                 return true;
             if (isAddressableKind(event.kind)) {
-                const deleted = this.deletedCoords.get(getReplaceableAddress(event));
+                const identifier = event.tags.find((t) => t[0] === "d")?.[1];
+                const deleted = this.deletedCoords.get(createReplaceableAddress(event.kind, event.pubkey, identifier));
                 if (deleted)
                     return deleted > event.created_at;
             }
-            return false;
         }
+        return false;
+    }
+    expirations = new Map();
+    /** Adds an event to the expiration map */
+    addExpiration(event) {
+        const expiration = getExpirationTimestamp(event);
+        if (expiration && Number.isFinite(expiration))
+            this.expirations.set(event.id, expiration);
+    }
+    expirationTimeout = null;
+    nextExpirationCheck = null;
+    handleExpiringEvent(event) {
+        const expiration = getExpirationTimestamp(event);
+        if (!expiration)
+            return;
+        // Add event to expiration map
+        this.expirations.set(event.id, expiration);
+        // Exit if the next check is already less than the next expiration
+        if (this.expirationTimeout && this.nextExpirationCheck && this.nextExpirationCheck < expiration)
+            return;
+        // Set timeout to prune expired events
+        if (this.expirationTimeout)
+            clearTimeout(this.expirationTimeout);
+        const timeout = expiration - unixNow();
+        this.expirationTimeout = setTimeout(this.pruneExpired.bind(this), timeout * 1000 + 10);
+        this.nextExpirationCheck = expiration;
+    }
+    /** Remove expired events from the store */
+    pruneExpired() {
+        const now = unixNow();
+        for (const [id, expiration] of this.expirations) {
+            if (expiration <= now) {
+                this.expirations.delete(id);
+                this.remove(id);
+            }
+        }
+        // Cleanup timers
+        if (this.expirationTimeout)
+            clearTimeout(this.expirationTimeout);
+        this.nextExpirationCheck = null;
+        this.expirationTimeout = null;
     }
     // handling delete events
     handleDeleteEvent(deleteEvent) {
@@ -117,11 +178,15 @@ export class EventStore {
         // Ignore if the event was deleted
         if (this.checkDeleted(event))
             return event;
+        // Reject expired events if keepExpired is false
+        const expiration = getExpirationTimestamp(event);
+        if (this.keepExpired === false && expiration && expiration <= unixNow())
+            return null;
         // Get the replaceable identifier
-        const d = isReplaceable(event.kind) ? event.tags.find((t) => t[0] === "d")?.[1] : undefined;
+        const identifier = isReplaceable(event.kind) ? event.tags.find((t) => t[0] === "d")?.[1] : undefined;
         // Don't insert the event if there is already a newer version
         if (!this.keepOldVersions && isReplaceable(event.kind)) {
-            const existing = this.database.getReplaceableHistory(event.kind, event.pubkey, d);
+            const existing = this.database.getReplaceableHistory(event.kind, event.pubkey, identifier);
             // If there is already a newer version, copy cached symbols and return existing event
             if (existing && existing.length > 0 && existing[0].created_at >= event.created_at) {
                 EventStore.mergeDuplicateEvent(event, existing[0]);
@@ -149,7 +214,7 @@ export class EventStore {
             addSeenRelay(inserted, fromRelay);
         // remove all old version of the replaceable event
         if (!this.keepOldVersions && isReplaceable(event.kind)) {
-            const existing = this.database.getReplaceableHistory(event.kind, event.pubkey, d);
+            const existing = this.database.getReplaceableHistory(event.kind, event.pubkey, identifier);
             if (existing) {
                 const older = Array.from(existing).filter((e) => e.created_at < event.created_at);
                 for (const old of older)
@@ -160,6 +225,9 @@ export class EventStore {
                     return existing[0];
             }
         }
+        // Add event to expiration map
+        if (this.keepExpired === false && expiration)
+            this.handleExpiringEvent(inserted);
         return inserted;
     }
     /** Removes an event from the database and updates subscriptions */
@@ -284,55 +352,79 @@ export class EventStore {
     }
     // Helper methods for creating models
     /** Creates a {@link EventModel} */
-    event(id) {
-        return this.model(EventModel, id);
+    event(pointer) {
+        if (typeof pointer === "string")
+            pointer = { id: pointer };
+        return this.model(EventModel, pointer);
+    }
+    replaceable(...args) {
+        let pointer;
+        // Parse arguments
+        if (args.length === 1) {
+            pointer = args[0];
+        }
+        else if (args.length === 3 || args.length === 2) {
+            let [kind, pubkey, identifier] = args;
+            pointer = { kind, pubkey, identifier };
+        }
+        if (!pointer)
+            throw new Error("Invalid arguments, expected address pointer or kind, pubkey, identifier");
+        return this.model(ReplaceableModel, pointer);
     }
-    /** Creates a {@link ReplaceableModel} */
-    replaceable(kind, pubkey, identifier) {
-        return this.model(ReplaceableModel, kind, pubkey, identifier);
+    /** Subscribe to an addressable event by pointer */
+    addressable(pointer) {
+        return this.model(ReplaceableModel, pointer);
     }
     /** Creates a {@link TimelineModel} */
     timeline(filters, includeOldVersion = false) {
         return this.model(TimelineModel, filters, includeOldVersion);
     }
-    /** Creates a {@link EventsModel} */
-    events(ids) {
-        return this.model(EventsModel, ids);
-    }
-    /** Creates a {@link ReplaceableSetModel} */
-    replaceableSet(pointers) {
-        return this.model(ReplaceableSetModel, pointers);
-    }
-    /** Creates a {@link ProfileModel} */
-    profile(pubkey) {
-        return this.model(ProfileModel, pubkey);
-    }
-    /** Creates a {@link ContactsModel} */
-    contacts(pubkey) {
-        return this.model(ContactsModel, pubkey);
-    }
-    /** Creates a {@link MuteModel} */
-    mutes(pubkey) {
-        return this.model(MuteModel, pubkey);
-    }
-    /** Creates a {@link ReactionsModel} */
+    /** Subscribe to a users profile */
+    profile(user) {
+        return this.model(ProfileModel, user);
+    }
+    /** Subscribe to a users contacts */
+    contacts(user) {
+        if (typeof user === "string")
+            user = { pubkey: user };
+        return this.model(ContactsModel, user);
+    }
+    /** Subscribe to a users mutes */
+    mutes(user) {
+        if (typeof user === "string")
+            user = { pubkey: user };
+        return this.model(MuteModel, user);
+    }
+    /** Subscribe to a users NIP-65 mailboxes */
+    mailboxes(user) {
+        if (typeof user === "string")
+            user = { pubkey: user };
+        return this.model(MailboxesModel, user);
+    }
+    /** Subscribe to a users blossom servers */
+    blossomServers(user) {
+        if (typeof user === "string")
+            user = { pubkey: user };
+        return this.model(UserBlossomServersModel, user);
+    }
+    /** Subscribe to an event's reactions */
     reactions(event) {
         return this.model(ReactionsModel, event);
     }
-    /** Creates a {@link MailboxesModel} */
-    mailboxes(pubkey) {
-        return this.model(MailboxesModel, pubkey);
-    }
-    /** Creates a {@link UserBlossomServersModel} */
-    blossomServers(pubkey) {
-        return this.model(UserBlossomServersModel, pubkey);
-    }
-    /** Creates a {@link ThreadModel} */
+    /** Subscribe to a thread */
     thread(root) {
         return this.model(ThreadModel, root);
     }
-    /** Creates a {@link CommentsModel} */
+    /** Subscribe to a event's comments */
     comments(event) {
         return this.model(CommentsModel, event);
     }
+    /** @deprecated use multiple {@link EventModel} instead */
+    events(ids) {
+        return this.model(EventsModel, ids);
+    }
+    /** @deprecated use multiple {@link ReplaceableModel} instead */
+    replaceableSet(pointers) {
+        return this.model(ReplaceableSetModel, pointers);
+    }
 }

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

@@ -5,6 +5,7 @@ import { LRU } from "../helpers/lru.js";
 import { Mutes } from "../helpers/mutes.js";
 import { ProfileContent } from "../helpers/profile.js";
 import { Thread } from "../models/thread.js";
+import { AddressPointerWithoutD } from "../helpers/pointers.js";
 /** The read interface for an event store */
 export interface IEventStoreRead {
     /** Check if the event store has an event with id */
@@ -51,27 +52,26 @@ export interface IEventClaims {
     /** Removes all claims on an event */
     clearClaim(event: NostrEvent): void;
 }
+/** An event store that can be subscribed to */
+export interface IEventStoreSubscriptions {
+    /** Susbscribe to an event by id */
+    event(id: string | EventPointer): Observable<NostrEvent | undefined>;
+    /** Subscribe to a replaceable event by pointer */
+    replaceable(pointer: AddressPointerWithoutD): Observable<NostrEvent | undefined>;
+    /** Subscribe to an addressable event by pointer */
+    addressable(pointer: AddressPointer): Observable<NostrEvent | undefined>;
+    /** Subscribe to a batch of events that match the filters */
+    filter(filters: Filter | Filter[]): Observable<NostrEvent[]>;
+}
 /** Methods for creating common models */
 export interface IEventStoreModels {
+    model<T extends unknown, Args extends Array<any>>(constructor: ModelConstructor<T, Args>, ...args: Args): Observable<T>;
     event(id: string): Observable<NostrEvent | undefined>;
-    events(ids: string[]): Observable<Record<string, NostrEvent>>;
-    replaceable(kind: number, pubkey: string, identifier?: string): Observable<NostrEvent | undefined>;
-    replaceableSet(pointers: {
-        kind: number;
-        pubkey: string;
-        identifier?: string;
-    }[]): Observable<Record<string, NostrEvent>>;
+    replaceable(pointer: AddressPointerWithoutD): Observable<NostrEvent | undefined>;
+    addressable(pointer: AddressPointer): Observable<NostrEvent | undefined>;
     timeline(filters: Filter | Filter[], includeOldVersion?: boolean): Observable<NostrEvent[]>;
-    profile(pubkey: string): Observable<ProfileContent | undefined>;
-    contacts(pubkey: string): Observable<ProfilePointer[]>;
-    mutes(pubkey: string): Observable<Mutes | undefined>;
-    reactions(event: NostrEvent): Observable<NostrEvent[]>;
-    mailboxes(pubkey: string): Observable<{
-        inboxes: string[];
-        outboxes: string[];
-    } | undefined>;
-    blossomServers(pubkey: string): Observable<URL[]>;
-    thread(root: string | EventPointer | AddressPointer): Observable<Thread>;
+    events(ids: string[]): Observable<Record<string, NostrEvent | undefined>>;
+    replaceableSet(pointers: (AddressPointer | AddressPointerWithoutD)[]): Observable<Record<string, NostrEvent | undefined>>;
 }
 /** A computed view of an event set or event store */
 export type Model<T extends unknown> = (events: IEventStore) => Observable<T>;
@@ -84,8 +84,26 @@ export interface IEventSet extends IEventStoreRead, IEventStoreStreams, IEventSt
     events: LRU<NostrEvent>;
 }
 export interface IEventStore extends IEventStoreRead, IEventStoreStreams, IEventStoreActions, IEventStoreModels, IEventClaims {
+    /** Enable this to keep old versions of replaceable events */
+    keepOldVersions: boolean;
+    /** Enable this to keep expired events */
+    keepExpired: boolean;
     filters(filters: Filter | Filter[]): Observable<NostrEvent>;
     updated(id: string | NostrEvent): Observable<NostrEvent>;
     removed(id: string): Observable<never>;
-    model<T extends unknown, Args extends Array<any>>(constructor: ModelConstructor<T, Args>, ...args: Args): Observable<T>;
+    replaceable(kind: number, pubkey: string, identifier?: string): Observable<NostrEvent | undefined>;
+    replaceable(pointer: AddressPointerWithoutD): Observable<NostrEvent | undefined>;
+    eventLoader?: (pointer: EventPointer) => Observable<NostrEvent> | Promise<NostrEvent | undefined>;
+    replaceableLoader?: (pointer: AddressPointerWithoutD) => Observable<NostrEvent> | Promise<NostrEvent | undefined>;
+    addressableLoader?: (pointer: AddressPointer) => Observable<NostrEvent> | Promise<NostrEvent | undefined>;
+    profile(user: string | ProfilePointer): Observable<ProfileContent | undefined>;
+    contacts(user: string | ProfilePointer): Observable<ProfilePointer[]>;
+    mutes(user: string | ProfilePointer): Observable<Mutes | undefined>;
+    mailboxes(user: string | ProfilePointer): Observable<{
+        inboxes: string[];
+        outboxes: string[];
+    } | undefined>;
+    blossomServers(user: string | ProfilePointer): Observable<URL[]>;
+    reactions(event: NostrEvent): Observable<NostrEvent[]>;
+    thread(root: string | EventPointer | AddressPointer): Observable<Thread>;
 }

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

@@ -0,0 +1,36 @@
+import { NostrEvent } from "nostr-tools";
+import { ProfilePointer } from "nostr-tools/nip19";
+export declare const DATE_BASED_CALENDAR_EVENT_KIND = 31922;
+export declare const TIME_BASED_CALENDAR_EVENT_KIND = 31923;
+export type CalendarEventParticipant = ProfilePointer & {
+    role?: string;
+};
+export declare const CalendarEventLocationsSymbol: unique symbol;
+export declare const CalendarEventParticipantsSymbol: unique symbol;
+export declare const CalendarEventHashtagsSymbol: unique symbol;
+export declare const CalendarEventReferencesSymbol: unique symbol;
+export declare const CalendarEventGeohashSymbol: unique symbol;
+/** Gets the title of a calendar event or calendar */
+export declare function getCalendarEventTitle(event: NostrEvent): string | undefined;
+/** Gets the summary of a calendar event */
+export declare function getCalendarEventSummary(event: NostrEvent): string | undefined;
+/** Gets the image URL of a calendar event */
+export declare function getCalendarEventImage(event: NostrEvent): string | undefined;
+/** Gets the start Unix timestamp of a calendar event */
+export declare function getCalendarEventStart(event: NostrEvent): number | undefined;
+/** Gets the timezone of the start timestamp of a calendar event */
+export declare function getCalendarEventStartTimezone(event: NostrEvent): string | undefined;
+/** Gets the timezone of the end timestamp of a calendar event */
+export declare function getCalendarEventEndTimezone(event: NostrEvent): string | undefined;
+/** Gets the end Unix timestamp of a calendar event */
+export declare function getCalendarEventEnd(event: NostrEvent): number | undefined;
+/** Gets all locations from a calendar event */
+export declare function getCalendarEventLocations(event: NostrEvent): string[];
+/** Gets the geohash of a calendar event */
+export declare function getCalendarEventGeohash(event: NostrEvent): string | undefined;
+/** Gets all participants from a calendar event */
+export declare function getCalendarEventParticipants(event: NostrEvent): CalendarEventParticipant[];
+/** Gets all hashtags from a calendar event */
+export declare function getCalendarEventHashtags(event: NostrEvent): string[];
+/** Gets all references from a calendar event */
+export declare function getCalendarEventReferences(event: NostrEvent): string[];

package/dist/helpers/calendar-event.js

@@ -0,0 +1,110 @@
+import { getOrComputeCachedValue } from "./cache.js";
+import { getTagValue } from "./event-tags.js";
+import { getProfilePointerFromPTag } from "./pointers.js";
+import { isPTag, isRTag, isTTag } from "./tags.js";
+// NIP-52 Calendar Event Kinds
+export const DATE_BASED_CALENDAR_EVENT_KIND = 31922;
+export const TIME_BASED_CALENDAR_EVENT_KIND = 31923;
+// Cache symbols for complex operations only
+export const CalendarEventLocationsSymbol = Symbol.for("calendar-event-locations");
+export const CalendarEventParticipantsSymbol = Symbol.for("calendar-event-participants");
+export const CalendarEventHashtagsSymbol = Symbol.for("calendar-event-hashtags");
+export const CalendarEventReferencesSymbol = Symbol.for("calendar-event-references");
+export const CalendarEventGeohashSymbol = Symbol.for("calendar-event-geohash");
+/** Gets the title of a calendar event or calendar */
+export function getCalendarEventTitle(event) {
+    return getTagValue(event, "title") || getTagValue(event, "name"); // fallback to deprecated "name" tag
+}
+/** Gets the summary of a calendar event */
+export function getCalendarEventSummary(event) {
+    return getTagValue(event, "summary");
+}
+/** Gets the image URL of a calendar event */
+export function getCalendarEventImage(event) {
+    return getTagValue(event, "image");
+}
+/** Gets the start Unix timestamp of a calendar event */
+export function getCalendarEventStart(event) {
+    const value = getTagValue(event, "start");
+    if (!value)
+        return undefined;
+    if (event.kind === DATE_BASED_CALENDAR_EVENT_KIND)
+        return new Date(value).valueOf() / 1000;
+    else if (event.kind === TIME_BASED_CALENDAR_EVENT_KIND)
+        return parseInt(value);
+    else
+        return undefined;
+}
+/** Gets the timezone of the start timestamp of a calendar event */
+export function getCalendarEventStartTimezone(event) {
+    if (event.kind === DATE_BASED_CALENDAR_EVENT_KIND)
+        return undefined;
+    return getTagValue(event, "start_tzid");
+}
+/** Gets the timezone of the end timestamp of a calendar event */
+export function getCalendarEventEndTimezone(event) {
+    if (event.kind === DATE_BASED_CALENDAR_EVENT_KIND)
+        return undefined;
+    return getTagValue(event, "end_tzid");
+}
+/** Gets the end Unix timestamp of a calendar event */
+export function getCalendarEventEnd(event) {
+    const value = getTagValue(event, "end");
+    if (!value)
+        return undefined;
+    if (event.kind === DATE_BASED_CALENDAR_EVENT_KIND)
+        return new Date(value).valueOf() / 1000;
+    else if (event.kind === TIME_BASED_CALENDAR_EVENT_KIND)
+        return parseInt(value);
+    else
+        return undefined;
+}
+/** Gets all locations from a calendar event */
+export function getCalendarEventLocations(event) {
+    if (event.kind !== DATE_BASED_CALENDAR_EVENT_KIND && event.kind !== TIME_BASED_CALENDAR_EVENT_KIND)
+        throw new Error("Event is not a date-based or time-based calendar event");
+    return getOrComputeCachedValue(event, CalendarEventLocationsSymbol, () => {
+        return event.tags.filter((t) => t[0] === "location" && t[1]).map((t) => t[1]);
+    });
+}
+/** Gets the geohash of a calendar event */
+export function getCalendarEventGeohash(event) {
+    if (event.kind !== DATE_BASED_CALENDAR_EVENT_KIND && event.kind !== TIME_BASED_CALENDAR_EVENT_KIND)
+        throw new Error("Event is not a date-based or time-based calendar event");
+    return getOrComputeCachedValue(event, CalendarEventGeohashSymbol, () => {
+        let hash = undefined;
+        for (const tag of event.tags) {
+            if (tag[0] === "g" && tag[1] && (!hash || tag[1].length > hash.length))
+                hash = tag[1];
+        }
+        return hash;
+    });
+}
+/** Gets all participants from a calendar event */
+export function getCalendarEventParticipants(event) {
+    if (event.kind !== DATE_BASED_CALENDAR_EVENT_KIND && event.kind !== TIME_BASED_CALENDAR_EVENT_KIND)
+        throw new Error("Event is not a date-based or time-based calendar event");
+    return getOrComputeCachedValue(event, CalendarEventParticipantsSymbol, () => {
+        return event.tags.filter(isPTag).map((tag) => ({
+            ...getProfilePointerFromPTag(tag),
+            // Third index of tag is optional "role"
+            role: tag[3] || undefined,
+        }));
+    });
+}
+/** Gets all hashtags from a calendar event */
+export function getCalendarEventHashtags(event) {
+    if (event.kind !== DATE_BASED_CALENDAR_EVENT_KIND && event.kind !== TIME_BASED_CALENDAR_EVENT_KIND)
+        throw new Error("Event is not a date-based or time-based calendar event");
+    return getOrComputeCachedValue(event, CalendarEventHashtagsSymbol, () => {
+        return event.tags.filter(isTTag).map((t) => t[1]);
+    });
+}
+/** Gets all references from a calendar event */
+export function getCalendarEventReferences(event) {
+    if (event.kind !== DATE_BASED_CALENDAR_EVENT_KIND && event.kind !== TIME_BASED_CALENDAR_EVENT_KIND)
+        throw new Error("Event is not a date-based or time-based calendar event");
+    return getOrComputeCachedValue(event, CalendarEventReferencesSymbol, () => {
+        return event.tags.filter(isRTag).map((t) => t[1]);
+    });
+}

package/dist/helpers/calendar-rsvp.d.ts

@@ -0,0 +1,15 @@
+import { NostrEvent } from "nostr-tools";
+import { AddressPointer, EventPointer, ProfilePointer } from "nostr-tools/nip19";
+export declare const CALENDAR_EVENT_RSVP_KIND = 31925;
+export type RSVPStatus = "accepted" | "declined" | "tentative";
+export type RSVPFreeBusy = "free" | "busy";
+/** Gets the RSVP status from a calendar event RSVP */
+export declare function getRSVPStatus(event: NostrEvent): RSVPStatus | undefined;
+/** Gets the free/busy status from a calendar event RSVP (will be undefined if the RSVP is declined) */
+export declare function getRSVPFreeBusy(event: NostrEvent): RSVPFreeBusy | undefined;
+/** Gets the referenced calendar event coordinate that the RSVP is responding to */
+export declare function getRSVPAddressPointer(event: NostrEvent): AddressPointer | undefined;
+/** Gets the referenced calendar event pointer that the RSVP is responding to */
+export declare function getRSVPEventPointer(event: NostrEvent): EventPointer | undefined;
+/** Gets the profile pointer that the RSVP is responding to */
+export declare function getRSVPProfilePointer(event: NostrEvent): ProfilePointer | undefined;