applesauce-core 0.0.0-next-20241213171848 → 0.0.0-next-20241219164005

package/dist/helpers/event.d.ts

@@ -2,6 +2,7 @@ import { NostrEvent, VerifiedEvent } from "nostr-tools";
 export declare const EventUIDSymbol: unique symbol;
 export declare const EventIndexableTagsSymbol: unique symbol;
 export declare const FromCacheSymbol: unique symbol;
+export declare const ReplaceableIdentifierSymbol: unique symbol;
 declare module "nostr-tools" {
     interface Event {
         [EventUIDSymbol]?: string;
@@ -40,3 +41,8 @@ export declare function fakeVerifyEvent(event: NostrEvent): event is VerifiedEve
 export declare function markFromCache(event: NostrEvent): void;
 /** Returns if an event was from a cache */
 export declare function isFromCache(event: NostrEvent): boolean;
+/**
+ * Returns the replaceable identifier for a replaceable event
+ * @throws
+ */
+export declare function getReplaceableIdentifier(event: NostrEvent): string;

package/dist/helpers/event.js

@@ -1,9 +1,12 @@
 import { kinds, verifiedSymbol } from "nostr-tools";
 import { INDEXABLE_TAGS } from "../event-store/common.js";
 import { getHiddenTags } from "./hidden-tags.js";
+import { getOrComputeCachedValue } from "./cache.js";
+import { isParameterizedReplaceableKind } from "nostr-tools/kinds";
 export const EventUIDSymbol = Symbol.for("event-uid");
 export const EventIndexableTagsSymbol = Symbol.for("indexable-tags");
 export const FromCacheSymbol = Symbol.for("from-cache");
+export const ReplaceableIdentifierSymbol = Symbol.for("replaceable-identifier");
 /**
  * Checks if an object is a nostr event
  * NOTE: does not validation the signature on the event
@@ -86,3 +89,17 @@ export function markFromCache(event) {
 export function isFromCache(event) {
     return !!event[FromCacheSymbol];
 }
+/**
+ * Returns the replaceable identifier for a replaceable event
+ * @throws
+ */
+export function getReplaceableIdentifier(event) {
+    if (!isParameterizedReplaceableKind(event.kind))
+        throw new Error("Event is not replaceable");
+    return getOrComputeCachedValue(event, ReplaceableIdentifierSymbol, () => {
+        const d = getTagValue(event, "d");
+        if (d === undefined)
+            throw new Error("Event missing identifier");
+        return d;
+    });
+}

package/dist/helpers/index.d.ts

@@ -9,6 +9,7 @@ export * from "./external-id.js";
 export * from "./filter.js";
 export * from "./hashtag.js";
 export * from "./hidden-tags.js";
+export * from "./json.js";
 export * from "./lnurl.js";
 export * from "./lru.js";
 export * from "./mailboxes.js";

package/dist/helpers/index.js

@@ -9,6 +9,7 @@ export * from "./external-id.js";
 export * from "./filter.js";
 export * from "./hashtag.js";
 export * from "./hidden-tags.js";
+export * from "./json.js";
 export * from "./lnurl.js";
 export * from "./lru.js";
 export * from "./mailboxes.js";

package/dist/helpers/pipe.d.ts

@@ -0,0 +1,10 @@
+export type Pipe = {
+    <A>(a: A): A;
+    <A, B>(a: A, ab: (a: A) => B): B;
+    <A, B, C>(a: A, ab: (a: A) => B, bc: (b: B) => C): C;
+    <A, B, C, D>(a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D): D;
+    <A, B, C, D, E>(a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E): E;
+    <A, B, C, D, E, F>(a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F): F;
+    <A, B, C, D, E, F, G>(a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F, fg: (f: F) => G): G;
+};
+export declare const pipe: Pipe;

package/dist/helpers/pipe.js

@@ -0,0 +1,3 @@
+export const pipe = (initial, ...fns) => {
+    return fns.reduce((acc, fn) => fn(acc), initial);
+};

package/dist/helpers/pointers.js

@@ -1,7 +1,7 @@
 import { naddrEncode, neventEncode, noteEncode, nprofileEncode, npubEncode, nsecEncode, } from "nostr-tools/nip19";
 import { getPublicKey, kinds } from "nostr-tools";
+import { getReplaceableIdentifier } from "./event.js";
 import { safeRelayUrls } from "./relays.js";
-import { getTagValue } from "./index.js";
 import { isParameterizedReplaceableKind } from "nostr-tools/kinds";
 export function parseCoordinate(a, requireD = false, silent = true) {
     const parts = a.split(":");
@@ -157,9 +157,7 @@ export function getCoordinateFromAddressPointer(pointer) {
 export function getAddressPointerForEvent(event, relays) {
     if (!isParameterizedReplaceableKind(event.kind))
         throw new Error("Cant get AddressPointer for non-replaceable event");
-    const d = getTagValue(event, "d");
-    if (!d)
-        throw new Error("Event missing identifier");
+    const d = getReplaceableIdentifier(event);
     return {
         identifier: d,
         kind: event.kind,
@@ -182,9 +180,7 @@ export function getEventPointerForEvent(event, relays) {
 /** Returns a pointer for a given event */
 export function getPointerForEvent(event, relays) {
     if (kinds.isParameterizedReplaceableKind(event.kind)) {
-        const d = getTagValue(event, "d");
-        if (!d)
-            throw new Error("Event missing identifier");
+        const d = getReplaceableIdentifier(event);
         return {
             type: "naddr",
             data: {

package/dist/helpers/tags.d.ts

@@ -10,3 +10,16 @@ export declare function isDTag(tag: string[]): tag is ["d", string, ...string[]]
 export declare function isATag(tag: string[]): tag is ["a", string, ...string[]];
 /** Checks if tag is an "a" tag and has at least one value */
 export declare function isTTag(tag: string[]): tag is ["t", string, ...string[]];
+/** A pipeline that filters and maps each tag */
+type TagPipe = {
+    <A>(tags: string[][], ta: (tag: string[]) => A | undefined): A[];
+    <A, B>(tags: string[][], ta: (tag: string[]) => A | undefined, ab: (a: A) => B | undefined): B[];
+    <A, B, C>(tags: string[][], ta: (tag: string[]) => A | undefined, ab: (a: A) => B | undefined, bc: (b: B) => C | undefined): C[];
+    <A, B, C, D>(tags: string[][], ta: (tag: string[]) => A | undefined, ab: (a: A) => B | undefined, bc: (b: B) => C | undefined, cd: (c: C) => D | undefined): D[];
+    <A, B, C, D, E>(tags: string[][], ta: (tag: string[]) => A | undefined, ab: (a: A) => B | undefined, bc: (b: B) => C | undefined, cd: (c: C) => D | undefined, de: (d: D) => E | undefined): E[];
+    <A, B, C, D, E, F>(tags: string[][], ta: (tag: string[]) => A | undefined, ab: (a: A) => B | undefined, bc: (b: B) => C | undefined, cd: (c: C) => D | undefined, de: (d: D) => E | undefined, ef: (e: E) => F | undefined): F[];
+    <A, B, C, D, E, F, G>(tags: string[][], ta: (tag: string[]) => A | undefined, ab: (a: A) => B | undefined, bc: (b: B) => C | undefined, cd: (c: C) => D | undefined, de: (d: D) => E | undefined, ef: (e: E) => F | undefined, fg: (f: F) => G | undefined): G[];
+};
+/** Filter and transform tags */
+export declare const processTags: TagPipe;
+export {};

package/dist/helpers/tags.js

@@ -22,3 +22,21 @@ export function isATag(tag) {
 export function isTTag(tag) {
     return tag[0] === "a" && tag[1] !== undefined;
 }
+/** Filter and transform tags */
+export const processTags = (tags, ...fns) => {
+    return fns.reduce((step, fn) => {
+        const next = [];
+        for (const value of step) {
+            try {
+                const result = fn(value);
+                if (result === undefined)
+                    continue; // value is undefined, ignore
+                next.push(result);
+            }
+            catch (error) {
+                // failed to process value, ignore
+            }
+        }
+        return next;
+    }, tags);
+};

package/dist/helpers/tags.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/helpers/tags.test.js

@@ -0,0 +1,16 @@
+import { describe, expect, it } from "vitest";
+import { isATag, processTags } from "./tags.js";
+import { getAddressPointerFromATag } from "./pointers.js";
+describe("tag helpers", () => {
+    describe("processTags", () => {
+        it("should filter out errors", () => {
+            expect(processTags([["a", "bad coordinate"], ["e"], ["a", "30000:pubkey:list"]], getAddressPointerFromATag)).toEqual([{ identifier: "list", kind: 30000, pubkey: "pubkey" }]);
+        });
+        it("should filter out undefined", () => {
+            expect(processTags([["a", "bad coordinate"], ["e"], ["a", "30000:pubkey:list"]], (tag) => isATag(tag) ? tag : undefined)).toEqual([
+                ["a", "bad coordinate"],
+                ["a", "30000:pubkey:list"],
+            ]);
+        });
+    });
+});

package/package.json

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