applesauce-common 0.0.0-next-20251203172109

package/dist/models/zaps.js

@@ -0,0 +1,26 @@
+import { kinds } from "applesauce-core/helpers/event";
+import { getCoordinateFromAddressPointer, isAddressPointer, } from "applesauce-core/helpers/pointers";
+import { map } from "rxjs";
+import { isValidZap } from "../helpers/zap.js";
+/** A model that gets all zap events for an event */
+export function EventZapsModel(id) {
+    return (events) => {
+        if (isAddressPointer(id)) {
+            return events
+                .timeline([{ kinds: [kinds.Zap], "#a": [getCoordinateFromAddressPointer(id)] }])
+                .pipe(map((events) => events.filter(isValidZap)));
+        }
+        else {
+            id = typeof id === "string" ? id : id.id;
+            return events.timeline([{ kinds: [kinds.Zap], "#e": [id] }]).pipe(map((events) => events.filter(isValidZap)));
+        }
+    };
+}
+/** A model that returns all zaps sent by a user */
+export function SentZapsModel(pubkey) {
+    return (events) => events.timeline([{ kinds: [kinds.Zap], authors: [pubkey] }]).pipe(map((events) => events.filter(isValidZap)));
+}
+/** A model that returns all zaps received by a user */
+export function ReceivedZapsModel(pubkey) {
+    return (events) => events.timeline([{ kinds: [kinds.Zap], "#p": [pubkey] }]).pipe(map((events) => events.filter(isValidZap)));
+}

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

@@ -0,0 +1,6 @@
+import { EventOperation } from "applesauce-core/event-factory";
+import { EncryptionMethod } from "applesauce-core/helpers/encrypted-content";
+/** Sets the app data identifier */
+export declare function setIdentifier(identifier: string): EventOperation;
+/** Sets the content of an application data event */
+export declare function setContent<T>(data: T, encryption?: boolean | EncryptionMethod): EventOperation;

package/dist/operations/app-data.js

@@ -0,0 +1,21 @@
+import { setContent as setPlaintextContent } from "applesauce-core/operations/content";
+import { setHiddenContent } from "applesauce-core/operations/hidden-content";
+import { includeSingletonTag } from "applesauce-core/operations/tags";
+/** Sets the app data identifier */
+export function setIdentifier(identifier) {
+    return includeSingletonTag(["d", identifier]);
+}
+/** Sets the content of an application data event */
+export function setContent(data, encryption) {
+    const json = JSON.stringify(data);
+    switch (typeof encryption) {
+        case "boolean":
+            return encryption ? setHiddenContent(json) : setPlaintextContent(json);
+        case "string":
+            return setHiddenContent(json, encryption);
+        case "undefined":
+            return setPlaintextContent(json);
+        default:
+            throw new Error("Invalid encrypted type");
+    }
+}

package/dist/operations/blossom.d.ts

@@ -0,0 +1,5 @@
+import { EventOperation } from "applesauce-core/event-factory";
+/** Adds a server to a 10063 event */
+export declare function addBlossomServer(url: string | URL, replace?: boolean): EventOperation;
+/** Removes server matching the url from a 10063 event */
+export declare function removeBlossomServer(url: string | URL): EventOperation;

package/dist/operations/blossom.js

@@ -0,0 +1,13 @@
+import { normalizeURL } from "applesauce-core/helpers";
+import { addNameValueTag } from "applesauce-core/operations/tag/common";
+import { modifyPublicTags } from "applesauce-core/operations/tags";
+import { areBlossomServersEqual } from "../helpers/blossom.js";
+/** Adds a server to a 10063 event */
+export function addBlossomServer(url, replace = true) {
+    url = normalizeURL(url).toString();
+    return modifyPublicTags(addNameValueTag(["server", url], replace, (a, b) => areBlossomServersEqual(a, b)));
+}
+/** Removes server matching the url from a 10063 event */
+export function removeBlossomServer(url) {
+    return modifyPublicTags((tags) => tags.filter((t) => !(t[0] === "server" && t[1] && areBlossomServersEqual(t[1], url))));
+}

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

@@ -0,0 +1,34 @@
+import { EventOperation } from "applesauce-core/event-factory";
+import { CalendarEventParticipant } from "../helpers/calendar-event.js";
+/** Sets the title of a calendar event */
+export declare function setTitle(title: string): EventOperation;
+/** Sets the summary of a calendar event */
+export declare function setSummary(summary: string): EventOperation;
+/** Sets the image for a calendar event */
+export declare function setImage(image: string): EventOperation;
+/** Adds a participant to a calendar event */
+export declare function addParticipant(participant: CalendarEventParticipant): EventOperation;
+/** Removes a participant from a calendar event */
+export declare function removeParticipant(pubkey: string | CalendarEventParticipant): EventOperation;
+/** Adds a location to a calendar event */
+export declare function addLocation(location: string): EventOperation;
+/** Removes a location from a calendar event */
+export declare function removeLocation(location: string): EventOperation;
+/** Adds a location to a calendar event */
+export declare function addReferenceLink(link: string | URL): EventOperation;
+/** Removes a location from a calendar event */
+export declare function removeReferenceLink(link: string | URL): EventOperation;
+/** Removes all locations from a calendar event */
+export declare function clearLocations(): EventOperation;
+/** Sets the geohash for a calendar event */
+export declare function setGeohash(geohash: string): EventOperation;
+/** Removes the geohash from a calendar event */
+export declare function removeGeohash(): EventOperation;
+/** Sets the start date for a date based calendar event */
+export declare function setStartDate(start: string | Date): EventOperation;
+/** Sets the start time for a time based calendar event */
+export declare function setStartTime(start: number | Date, timezone?: string): EventOperation;
+/** Sets the end date for a date based calendar event */
+export declare function setEndDate(end: string | Date): EventOperation;
+/** Sets the end time for a time based calendar event */
+export declare function setEndTime(end: number | Date, timezone?: string): EventOperation;

package/dist/operations/calendar-event.js

@@ -0,0 +1,72 @@
+import { addNameValueTag, removeNameValueTag, setSingletonTag } from "applesauce-core/operations/tag/common";
+import { includeNameValueTag, includeSingletonTag, modifyPublicTags } from "applesauce-core/operations/tags";
+import { createCalendarEventParticipantTag } from "../helpers/calendar-event.js";
+import * as Geohash from "./geohash.js";
+/** Sets the title of a calendar event */
+export function setTitle(title) {
+    return includeSingletonTag(["title", title], true);
+}
+/** Sets the summary of a calendar event */
+export function setSummary(summary) {
+    return includeSingletonTag(["summary", summary], true);
+}
+/** Sets the image for a calendar event */
+export function setImage(image) {
+    return includeSingletonTag(["image", image], true);
+}
+/** Adds a participant to a calendar event */
+export function addParticipant(participant) {
+    return includeNameValueTag(createCalendarEventParticipantTag(participant), true);
+}
+/** Removes a participant from a calendar event */
+export function removeParticipant(pubkey) {
+    return modifyPublicTags(removeNameValueTag(["p", typeof pubkey === "string" ? pubkey : pubkey.pubkey]));
+}
+/** Adds a location to a calendar event */
+export function addLocation(location) {
+    return modifyPublicTags(addNameValueTag(["location", location], true));
+}
+/** Removes a location from a calendar event */
+export function removeLocation(location) {
+    return modifyPublicTags(removeNameValueTag(["location", location]));
+}
+/** Adds a location to a calendar event */
+export function addReferenceLink(link) {
+    return modifyPublicTags(addNameValueTag(["r", new URL(link).toString()], true));
+}
+/** Removes a location from a calendar event */
+export function removeReferenceLink(link) {
+    return modifyPublicTags(removeNameValueTag(["r", new URL(link).toString()]));
+}
+/** Removes all locations from a calendar event */
+export function clearLocations() {
+    return modifyPublicTags((tags) => tags.filter((tag) => tag[0] !== "location"));
+}
+/** Sets the geohash for a calendar event */
+export function setGeohash(geohash) {
+    return Geohash.setGeohash(geohash);
+}
+/** Removes the geohash from a calendar event */
+export function removeGeohash() {
+    return Geohash.removeGeohash();
+}
+/** Sets the start date for a date based calendar event */
+export function setStartDate(start) {
+    const date = new Date(start).toISOString().split("T")[0];
+    return includeSingletonTag(["start", date], true);
+}
+/** Sets the start time for a time based calendar event */
+export function setStartTime(start, timezone) {
+    const timestamp = typeof start === "number" ? start : Math.round(new Date(start).valueOf() / 1000);
+    return modifyPublicTags(setSingletonTag(["start", String(timestamp)], true), timezone ? setSingletonTag(["start_tzid", timezone], true) : undefined);
+}
+/** Sets the end date for a date based calendar event */
+export function setEndDate(end) {
+    const date = new Date(end).toISOString().split("T")[0];
+    return includeSingletonTag(["end", date], true);
+}
+/** Sets the end time for a time based calendar event */
+export function setEndTime(end, timezone) {
+    const timestamp = typeof end === "number" ? end : Math.round(new Date(end).valueOf() / 1000);
+    return modifyPublicTags(setSingletonTag(["end", String(timestamp)], true), timezone ? setSingletonTag(["end_tzid", timezone], true) : undefined);
+}

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

@@ -0,0 +1,10 @@
+import { EventOperation } from "applesauce-core/event-factory";
+import { NostrEvent } from "applesauce-core/helpers/event";
+import { AddressPointer } from "applesauce-core/helpers/pointers";
+import { RSVPFreeBusy, RSVPStatus } from "../helpers/calendar-rsvp.js";
+/** Sets the RSVP status for a calendar event */
+export declare function setStatus(status: RSVPStatus): EventOperation;
+/** Sets the free busy status for a calendar event */
+export declare function setFreeBusy(freeBusy: RSVPFreeBusy): EventOperation;
+/** Sets the pointers to the calendar event for an RSVP event */
+export declare function setCalendarEvent(pointer: NostrEvent | AddressPointer, relay?: string): EventOperation;

package/dist/operations/calendar-rsvp.js

@@ -0,0 +1,35 @@
+import { createATagFromAddressPointer, createETagFromEventPointer, createPTagFromProfilePointer, } from "applesauce-core/helpers";
+import { addRelayHintsToPointer, getAddressPointerForEvent, isAddressPointer, } from "applesauce-core/helpers/pointers";
+import { setSingletonTag } from "applesauce-core/operations/tag/common";
+import { includeSingletonTag, modifyPublicTags } from "applesauce-core/operations/tags";
+import { DATE_BASED_CALENDAR_EVENT_KIND, TIME_BASED_CALENDAR_EVENT_KIND } from "../helpers/calendar-event.js";
+/** Sets the RSVP status for a calendar event */
+export function setStatus(status) {
+    return includeSingletonTag(["status", status], true);
+}
+/** Sets the free busy status for a calendar event */
+export function setFreeBusy(freeBusy) {
+    return includeSingletonTag(["fb", freeBusy], true);
+}
+/** Sets the pointers to the calendar event for an RSVP event */
+export function setCalendarEvent(pointer, relay) {
+    if (pointer.kind !== DATE_BASED_CALENDAR_EVENT_KIND && pointer.kind !== TIME_BASED_CALENDAR_EVENT_KIND)
+        throw new Error("RSVP pointer must be to a calendar event");
+    let addressPointer = isAddressPointer(pointer) ? pointer : getAddressPointerForEvent(pointer);
+    let eventPointer = isAddressPointer(pointer)
+        ? undefined
+        : { id: pointer.id, kind: pointer.kind, author: pointer.pubkey };
+    let profilePointer = { pubkey: pointer.pubkey };
+    // Add relay hint if provided
+    if (relay) {
+        addressPointer = addRelayHintsToPointer(addressPointer, [relay]);
+        if (eventPointer)
+            eventPointer = addRelayHintsToPointer(eventPointer, [relay]);
+        profilePointer = addRelayHintsToPointer(profilePointer, [relay]);
+    }
+    return modifyPublicTags(
+    // Include "a" and "e" tags for calendar event
+    setSingletonTag(createATagFromAddressPointer(addressPointer)), eventPointer ? setSingletonTag(createETagFromEventPointer(eventPointer)) : undefined, 
+    // Add a "p" tag for the event author
+    setSingletonTag(createPTagFromProfilePointer(profilePointer), true));
+}

package/dist/operations/calendar.d.ts

@@ -0,0 +1,9 @@
+import { EventOperation } from "applesauce-core/event-factory";
+import { NostrEvent } from "applesauce-core/helpers/event";
+import { AddressPointer } from "applesauce-core/helpers/pointers";
+/** Sets the title of a calendar */
+export declare function setTitle(title: string): EventOperation;
+/** Adds a calendar event tags to a calendar event */
+export declare function addEvent(event: AddressPointer | NostrEvent): EventOperation;
+/** Removes a calendar event tags from a calendar event */
+export declare function removeEvent(event: AddressPointer | NostrEvent): EventOperation;

package/dist/operations/calendar.js

@@ -0,0 +1,15 @@
+import { getAddressPointerForEvent, isAddressPointer } from "applesauce-core/helpers/pointers";
+import { addAddressPointerTag, removeAddressPointerTag } from "applesauce-core/operations/tag/common";
+import { includeSingletonTag, modifyPublicTags } from "applesauce-core/operations/tags";
+/** Sets the title of a calendar */
+export function setTitle(title) {
+    return includeSingletonTag(["title", title], true);
+}
+/** Adds a calendar event tags to a calendar event */
+export function addEvent(event) {
+    return modifyPublicTags(addAddressPointerTag(isAddressPointer(event) ? event : getAddressPointerForEvent(event)));
+}
+/** Removes a calendar event tags from a calendar event */
+export function removeEvent(event) {
+    return modifyPublicTags(removeAddressPointerTag(isAddressPointer(event) ? event : getAddressPointerForEvent(event)));
+}

package/dist/operations/channel.d.ts

@@ -0,0 +1,4 @@
+import { EventOperation } from "applesauce-core/event-factory";
+import { NostrEvent } from "applesauce-core/helpers/event";
+/** Includes the "e" tag referencing the channel creating event */
+export declare function includeChannelPointerTag(channel: NostrEvent): EventOperation;

package/dist/operations/channel.js

@@ -0,0 +1,10 @@
+import { ensureMarkedEventPointerTag } from "applesauce-core/helpers/factory";
+import { getEventPointerForEvent } from "applesauce-core/helpers/pointers";
+/** Includes the "e" tag referencing the channel creating event */
+export function includeChannelPointerTag(channel) {
+    return (draft) => {
+        let tags = Array.from(draft.tags);
+        tags = ensureMarkedEventPointerTag(tags, getEventPointerForEvent(channel), "root");
+        return { ...draft, tags };
+    };
+}

package/dist/operations/client.d.ts

@@ -0,0 +1,4 @@
+import { EventOperation } from "applesauce-core/event-factory";
+import { AddressPointer } from "applesauce-core/helpers/pointers";
+/** Includes a NIP-89 client tag in an event*/
+export declare function setClient(name: string, pointer?: Omit<AddressPointer, "kind" | "relays">, replace?: boolean): EventOperation;

package/dist/operations/client.js

@@ -0,0 +1,23 @@
+import { kinds } from "applesauce-core/helpers/event";
+import { getCoordinateFromAddressPointer } from "applesauce-core/helpers/pointers";
+import { fillAndTrimTag } from "applesauce-core/helpers/tags";
+import { includeSingletonTag } from "applesauce-core/operations/tags";
+// A list of event kinds to never attach the "client" tag to
+const NEVER_ATTACH_CLIENT_TAG = [kinds.EncryptedDirectMessage, kinds.GiftWrap, kinds.Seal];
+/** Includes a NIP-89 client tag in an event*/
+export function setClient(name, pointer, replace = true) {
+    return (draft, ctx) => {
+        if (NEVER_ATTACH_CLIENT_TAG.includes(draft.kind))
+            return draft;
+        else {
+            const coordinate = pointer
+                ? getCoordinateFromAddressPointer({
+                    pubkey: pointer.pubkey,
+                    identifier: pointer.identifier,
+                    kind: kinds.Handlerinformation,
+                })
+                : undefined;
+            return includeSingletonTag(fillAndTrimTag(["client", name, coordinate]), replace)(draft, ctx);
+        }
+    };
+}

package/dist/operations/comment.d.ts

@@ -0,0 +1,4 @@
+import { EventOperation } from "applesauce-core/event-factory";
+import { NostrEvent } from "applesauce-core/helpers/event";
+/** Sets the necessary tags for a NIP-22 comment event to point to a parent event */
+export declare function setParent(parent: NostrEvent): EventOperation;

package/dist/operations/comment.js

@@ -0,0 +1,11 @@
+import { createCommentTagsForEvent } from "../helpers/comment.js";
+/** Sets the necessary tags for a NIP-22 comment event to point to a parent event */
+export function setParent(parent) {
+    return async (draft, ctx) => {
+        const relayHint = await ctx.getEventRelayHint?.(parent.id);
+        let tags = Array.from(draft.tags);
+        // add NIP-22 comment tags
+        tags.push(...createCommentTagsForEvent(parent, relayHint));
+        return { ...draft, tags };
+    };
+}

package/dist/operations/file-metadata.d.ts

@@ -0,0 +1,4 @@
+import { EventOperation } from "applesauce-core/event-factory";
+import { FileMetadata } from "../helpers/file-metadata.js";
+/** Sets all NIP-94 tags for {@link FileMetadata} */
+export declare function setFileMetadata(metadata: FileMetadata): EventOperation;

package/dist/operations/file-metadata.js

@@ -0,0 +1,21 @@
+import { ensureSingletonTag } from "applesauce-core/helpers";
+import { createFileMetadataTags } from "../helpers/file-metadata.js";
+/** Sets all NIP-94 tags for {@link FileMetadata} */
+export function setFileMetadata(metadata) {
+    return (draft) => {
+        let tags = Array.from(draft.tags);
+        const fileTags = createFileMetadataTags(metadata);
+        for (const tag of fileTags) {
+            switch (tag[0]) {
+                case "fallback":
+                    // support multiple fallback tags
+                    tags.push(tag);
+                    break;
+                default:
+                    tags = ensureSingletonTag(tags, tag);
+                    break;
+            }
+        }
+        return { ...draft, tags };
+    };
+}

package/dist/operations/geohash.d.ts

@@ -0,0 +1,5 @@
+import { EventOperation } from "applesauce-core/event-factory";
+/** Adds all "g" geohash tags for a given geohash or removes them if null */
+export declare function setGeohash(geohash: string | null): EventOperation;
+/** Removes all "g" geohash tags from an event */
+export declare function removeGeohash(): EventOperation;

package/dist/operations/geohash.js

@@ -0,0 +1,17 @@
+import { modifyPublicTags } from "applesauce-core/operations";
+/** Adds all "g" geohash tags for a given geohash or removes them if null */
+export function setGeohash(geohash) {
+    if (!geohash)
+        return removeGeohash();
+    return modifyPublicTags((tags) => {
+        tags = tags.filter((t) => t[0] !== "g" && t[1]);
+        for (let i = 0; i < geohash.length; i++) {
+            tags.push(["g", geohash.slice(0, i + 1)]);
+        }
+        return tags;
+    });
+}
+/** Removes all "g" geohash tags from an event */
+export function removeGeohash() {
+    return modifyPublicTags((tags) => tags.filter((t) => t[0] !== "g" && t[1]));
+}

package/dist/operations/gift-wrap.d.ts

@@ -0,0 +1,13 @@
+import { EventOperation } from "applesauce-core/event-factory";
+import { EventTemplate, NostrEvent, UnsignedEvent } from "applesauce-core/helpers/event";
+import { MetaTagOptions } from "applesauce-core/operations/event";
+import { Rumor } from "../helpers/gift-wrap.js";
+/** Converts an event to a rumor. The first operation in the gift wrap pipeline */
+export declare function toRumor(): EventOperation<EventTemplate | UnsignedEvent | NostrEvent, Rumor>;
+/** Seals a rumor in a NIP-59 seal. The second operation in the gift wrap pipeline */
+export declare function sealRumor(pubkey: string): EventOperation<Rumor, NostrEvent>;
+export type GiftWrapOptions = MetaTagOptions;
+/** Gift wraps a seal to a pubkey. The third operation in the gift wrap pipeline */
+export declare function wrapSeal(pubkey: string, opts?: GiftWrapOptions): EventOperation<NostrEvent, NostrEvent>;
+/** An operation that gift wraps an event to a pubkey */
+export declare function giftWrap(pubkey: string, opts?: GiftWrapOptions): EventOperation<EventTemplate | UnsignedEvent | NostrEvent, NostrEvent>;

package/dist/operations/gift-wrap.js

@@ -0,0 +1,93 @@
+// Read https://github.com/nostr-protocol/nips/blob/master/59.md#overview for details on rumors and seals
+// Gift wrap (signed random key) -> seal (signed sender key) -> rumor (unsigned)
+import { buildEvent } from "applesauce-core/event-factory";
+import { EncryptedContentSymbol } from "applesauce-core/helpers/encrypted-content";
+import { nip44 } from "applesauce-core/helpers/encryption";
+import { finalizeEvent, getEventHash, kinds, } from "applesauce-core/helpers/event";
+import { generateSecretKey } from "applesauce-core/helpers/keys";
+import { eventPipe, PRESERVE_EVENT_SYMBOLS } from "applesauce-core/helpers/pipeline";
+import { unixNow } from "applesauce-core/helpers/time";
+import { setEncryptedContent } from "applesauce-core/operations/encrypted-content";
+import { setMetaTags, stamp } from "applesauce-core/operations/event";
+import { GiftWrapSymbol, RumorSymbol, SealSymbol } from "../helpers/gift-wrap.js";
+// Preserve gift-wrap and seal symbols when building gift-wrap events
+PRESERVE_EVENT_SYMBOLS.add(GiftWrapSymbol);
+PRESERVE_EVENT_SYMBOLS.add(SealSymbol);
+PRESERVE_EVENT_SYMBOLS.add(RumorSymbol);
+/** Create a timestamp with a random offset of an hour */
+function randomNow() {
+    return unixNow() - Math.floor(Math.random() * 60 * 60);
+}
+/** Converts an event to a rumor. The first operation in the gift wrap pipeline */
+export function toRumor() {
+    return async (draft, ctx) => {
+        // @ts-expect-error
+        const rumor = { ...draft };
+        // Ensure rumor has pubkey
+        if (!Reflect.has(rumor, "pubkey")) {
+            if (!ctx.signer)
+                throw new Error("A signer is required to create a rumor");
+            rumor.pubkey = await ctx.signer.getPublicKey();
+        }
+        // Ensure rumor has id
+        if (!Reflect.has(rumor, "id"))
+            rumor.id = getEventHash(rumor);
+        // Ensure rumor does not have signature
+        Reflect.deleteProperty(rumor, "sig");
+        return rumor;
+    };
+}
+/** Seals a rumor in a NIP-59 seal. The second operation in the gift wrap pipeline */
+export function sealRumor(pubkey) {
+    return async (rumor, ctx) => {
+        if (!ctx.signer)
+            throw new Error("A signer is required to create a seal");
+        const plaintext = JSON.stringify(rumor);
+        const unsigned = await buildEvent({ kind: kinds.Seal, created_at: randomNow() }, ctx, 
+        // Set the encrypted content
+        setEncryptedContent(pubkey, plaintext), 
+        // Stamp the seal with the signers's pubkey
+        stamp());
+        const seal = await ctx.signer.signEvent(unsigned);
+        // Set the downstream reference on the seal
+        Reflect.set(seal, RumorSymbol, rumor);
+        // Add the upstream reference to the rumor
+        const seals = Reflect.get(rumor, SealSymbol);
+        if (seals)
+            seals.add(seal);
+        else
+            Reflect.set(rumor, SealSymbol, new Set([seal]));
+        return seal;
+    };
+}
+/** Gift wraps a seal to a pubkey. The third operation in the gift wrap pipeline */
+export function wrapSeal(pubkey, opts) {
+    return async (seal) => {
+        const key = generateSecretKey();
+        const plaintext = JSON.stringify(seal);
+        const draft = await buildEvent({
+            kind: kinds.GiftWrap,
+            created_at: randomNow(),
+            content: nip44.encrypt(plaintext, nip44.getConversationKey(key, pubkey)),
+            tags: [["p", pubkey]],
+        }, 
+        // Pass an empty context here so here there is no chance to use the users pubkey
+        {}, 
+        // Set meta tags on the gift wrap
+        setMetaTags(opts));
+        const gift = finalizeEvent(draft, key);
+        // Set the upstream references on the seal
+        Reflect.set(seal, GiftWrapSymbol, gift);
+        // Set the downstream reference on the gift wrap
+        Reflect.set(gift, SealSymbol, seal);
+        // Set the encrypted content on the gift wrap
+        Reflect.set(gift, EncryptedContentSymbol, plaintext);
+        return gift;
+    };
+}
+/** An operation that gift wraps an event to a pubkey */
+export function giftWrap(pubkey, opts) {
+    return eventPipe(toRumor(), 
+    // @ts-expect-error
+    sealRumor(pubkey), wrapSeal(pubkey, opts));
+}

package/dist/operations/group.d.ts

@@ -0,0 +1,11 @@
+import { EventOperation } from "applesauce-core/event-factory";
+import { NostrEvent } from "applesauce-core/helpers/event";
+import { GroupPointer } from "../helpers/groups.js";
+/** Adds a "group" tag to a list */
+export declare function addGroupTag(group: GroupPointer): EventOperation;
+/** Removes a "group" tag from a list */
+export declare function removeGroupTag(group: GroupPointer): EventOperation;
+/** Sets the "h" tag for NIP-29 group messages or other events */
+export declare function setGroupPointer(group: GroupPointer): EventOperation;
+/** Adds "previous" tags for group messages */
+export declare function addPreviousRefs(previous: NostrEvent[], count?: number): EventOperation;

package/dist/operations/group.js

@@ -0,0 +1,34 @@
+import { ensureNamedValueTag } from "applesauce-core/helpers";
+import { includeSingletonTag, modifyPublicTags } from "applesauce-core/operations/tags";
+import { createGroupHTagFromGroupPointer, createGroupTagFromGroupPointer } from "../helpers/groups-helper.js";
+/** Adds a "group" tag to a list */
+export function addGroupTag(group) {
+    return modifyPublicTags((tags) => {
+        // remove existing tag
+        tags = tags.filter((t) => !(t[0] === "group" && t[1] === group.id && t[2] === group.relay));
+        return [...tags, createGroupTagFromGroupPointer(group)];
+    });
+}
+/** Removes a "group" tag from a list */
+export function removeGroupTag(group) {
+    return modifyPublicTags((tags) => tags.filter((tag) => tag[0] === "group" && tag[1] === group.id && tag[2] === group.relay));
+}
+/** Sets the "h" tag for NIP-29 group messages or other events */
+export function setGroupPointer(group) {
+    return includeSingletonTag(createGroupHTagFromGroupPointer(group), true);
+}
+/** Adds "previous" tags for group messages */
+export function addPreviousRefs(previous, count = 6) {
+    return (draft) => {
+        let tags = Array.from(draft.tags);
+        // sort previous events by date and limit to 50
+        const sorted = previous.sort((a, b) => b.created_at - a.created_at).slice(0, 50);
+        for (let i = 0; i < count; i++) {
+            const index = Math.round(Math.random() * (sorted.length - 1));
+            const event = sorted.splice(index, 1)[0];
+            if (event)
+                tags = ensureNamedValueTag(tags, ["previous", event.id.slice(0, 8)]);
+        }
+        return { ...draft, tags };
+    };
+}

package/dist/operations/hashtags.d.ts

@@ -0,0 +1,7 @@
+import { EventOperation } from "applesauce-core/event-factory";
+/** Adds a hashtag to the live event */
+export declare function addHashtag(hashtag: string): EventOperation;
+/** Removes a hashtag from the live event */
+export declare function removeHashtag(hashtag: string): EventOperation;
+/** Adds "t" tags for an array of hashtags */
+export declare function includeHashtags(hashtags: string[]): EventOperation;

package/dist/operations/hashtags.js

@@ -0,0 +1,17 @@
+import { modifyPublicTags } from "applesauce-core/operations";
+import { addNameValueTag } from "applesauce-core/operations/tag/common";
+/** Adds a hashtag to the live event */
+export function addHashtag(hashtag) {
+    // Remove # if present at the beginning
+    const cleanTag = (hashtag.startsWith("#") ? hashtag.slice(1) : hashtag).toLocaleLowerCase();
+    return modifyPublicTags(addNameValueTag(["t", cleanTag], true));
+}
+/** Removes a hashtag from the live event */
+export function removeHashtag(hashtag) {
+    const cleanTag = (hashtag.startsWith("#") ? hashtag.slice(1) : hashtag).toLocaleLowerCase();
+    return modifyPublicTags((tags) => tags.filter((t) => t[0] !== "t" || t[1].toLocaleLowerCase() !== cleanTag));
+}
+/** Adds "t" tags for an array of hashtags */
+export function includeHashtags(hashtags) {
+    return modifyPublicTags(...hashtags.map((hashtag) => addNameValueTag(["t", hashtag.toLocaleLowerCase()])));
+}

package/dist/operations/highlight.d.ts

@@ -0,0 +1,18 @@
+import { EventOperation } from "applesauce-core/event-factory";
+import { NostrEvent } from "applesauce-core/helpers/event";
+import { AddressPointer, EventPointer } from "applesauce-core/helpers/pointers";
+import { HighlightAttribution } from "../helpers/highlight.js";
+/** Sets the content (highlighted text) for a highlight event */
+export declare function setHighlightContent(content: string): EventOperation;
+/** Sets the source event that was highlighted using an 'e' tag */
+export declare function setSource(source: NostrEvent | EventPointer | AddressPointer | string): EventOperation;
+/** Attribution role types for highlight events */
+export type AttributionRole = "author" | "editor" | "mention";
+/** Sets attribution for a pubkey with optional role using 'p' tags */
+export declare function addAttribution(attribution: HighlightAttribution): EventOperation;
+/** Sets the context text for the highlight using a 'context' tag */
+export declare function setContext(context: string): EventOperation;
+/** Sets a comment for the highlight using a 'comment' tag to create a quote highlight */
+export declare function setComment(comment: string): EventOperation;
+/** Sets multiple attributions at once */
+export declare function setAttributions(attributions: HighlightAttribution[]): EventOperation;

package/dist/operations/highlight.js

@@ -0,0 +1,47 @@
+import { ensureMarkedProfilePointerTag } from "applesauce-core/helpers";
+import { isEvent, isReplaceable } from "applesauce-core/helpers/event";
+import { getAddressPointerForEvent, isAddressPointer, isEventPointer, } from "applesauce-core/helpers/pointers";
+import { addAddressPointerTag, addEventPointerTag } from "applesauce-core/operations/tag/common";
+import { includeSingletonTag, modifyPublicTags } from "applesauce-core/operations/tags";
+/** Sets the content (highlighted text) for a highlight event */
+export function setHighlightContent(content) {
+    return (draft) => ({ ...draft, content });
+}
+/** Sets the source event that was highlighted using an 'e' tag */
+export function setSource(source) {
+    if (isEvent(source)) {
+        if (isReplaceable(source.kind))
+            return modifyPublicTags(addEventPointerTag(source, true), addAddressPointerTag(getAddressPointerForEvent(source), true));
+        else
+            return modifyPublicTags(addEventPointerTag(source, true));
+    }
+    else if (isAddressPointer(source)) {
+        return modifyPublicTags(addAddressPointerTag(source, true));
+    }
+    else if (isEventPointer(source))
+        return modifyPublicTags(addEventPointerTag(source, true));
+    else if (typeof source === "string")
+        return includeSingletonTag(["r", source]);
+    else
+        throw new Error("Invalid source");
+}
+/** Sets attribution for a pubkey with optional role using 'p' tags */
+export function addAttribution(attribution) {
+    return modifyPublicTags((tags) => ensureMarkedProfilePointerTag(tags, attribution, attribution.role || "mention"));
+}
+/** Sets the context text for the highlight using a 'context' tag */
+export function setContext(context) {
+    return includeSingletonTag(["context", context]);
+}
+/** Sets a comment for the highlight using a 'comment' tag to create a quote highlight */
+export function setComment(comment) {
+    return includeSingletonTag(["comment", comment]);
+}
+/** Sets multiple attributions at once */
+export function setAttributions(attributions) {
+    return modifyPublicTags(async (tags) => {
+        for (const attribution of attributions)
+            tags = ensureMarkedProfilePointerTag(tags, attribution, attribution.role || "mention");
+        return tags;
+    });
+}