applesauce-core 5.2.0 → 6.0.2

package/dist/observable/combine-latest-by-index.js

@@ -0,0 +1,121 @@
+import { Observable, Subject } from "rxjs";
+/** Sentinel to distinguish "no value yet" from a real value */
+const NOT_YET = Symbol("NOT_YET");
+/**
+ * Dynamic counterpart to `switchMap(() => combineLatest(...))` for arrays,
+ * with stable branches by index.
+ *
+ * Each array index gets its own long-lived branch (`of(value).pipe(...)`
+ * equivalent), and branches are only created/removed when indices are
+ * added/removed.
+ */
+export function combineLatestByIndex(project) {
+    return (source$) => new Observable((subscriber) => {
+        const slots = [];
+        let sourceCompleted = false;
+        let batchingSourceNext = false;
+        let emittedDuringBatch = false;
+        function checkComplete() {
+            if (!sourceCompleted)
+                return;
+            for (const slot of slots) {
+                if (!slot.completed)
+                    return;
+            }
+            subscriber.complete();
+        }
+        function tryEmit() {
+            for (const slot of slots) {
+                if (slot.value === NOT_YET)
+                    return;
+            }
+            subscriber.next(slots.map((slot) => slot.value));
+        }
+        function createSlot(index) {
+            const input = new Subject();
+            const slot = { input, value: NOT_YET, completed: false };
+            let projected$;
+            try {
+                projected$ = project(input, index);
+            }
+            catch (err) {
+                input.complete();
+                subscriber.error(err);
+                return undefined;
+            }
+            slot.sub = projected$.subscribe({
+                next(value) {
+                    slot.value = value;
+                    if (batchingSourceNext) {
+                        emittedDuringBatch = true;
+                        return;
+                    }
+                    tryEmit();
+                },
+                error(err) {
+                    subscriber.error(err);
+                },
+                complete() {
+                    slot.completed = true;
+                    checkComplete();
+                },
+            });
+            return slot;
+        }
+        const sourceSub = source$.subscribe({
+            next(items) {
+                batchingSourceNext = true;
+                emittedDuringBatch = false;
+                while (slots.length > items.length) {
+                    const slot = slots.pop();
+                    if (!slot)
+                        break;
+                    slot.sub?.unsubscribe();
+                    slot.input.complete();
+                }
+                while (slots.length < items.length) {
+                    const slot = createSlot(slots.length);
+                    if (!slot) {
+                        batchingSourceNext = false;
+                        return;
+                    }
+                    slots.push(slot);
+                }
+                for (let i = 0; i < items.length; i++) {
+                    if (subscriber.closed) {
+                        batchingSourceNext = false;
+                        return;
+                    }
+                    const slot = slots[i];
+                    if (!slot) {
+                        batchingSourceNext = false;
+                        return;
+                    }
+                    slot.input.next(items[i]);
+                }
+                // Emit once for this source update if possible.
+                if (emittedDuringBatch || items.length === 0)
+                    tryEmit();
+                batchingSourceNext = false;
+            },
+            error(err) {
+                subscriber.error(err);
+            },
+            complete() {
+                sourceCompleted = true;
+                for (const slot of slots) {
+                    slot.input.complete();
+                }
+                checkComplete();
+            },
+        });
+        return () => {
+            sourceSub.unsubscribe();
+            for (const slot of slots) {
+                slot.sub?.unsubscribe();
+                slot.input.complete();
+            }
+            slots.length = 0;
+        };
+    });
+}

package/dist/observable/combine-latest-by-key.d.ts

@@ -0,0 +1,10 @@
+import { Observable, type OperatorFunction } from "rxjs";
+/**
+ * Dynamic counterpart to `switchMap(() => combineLatest(...))` for records,
+ * with stable branches by key.
+ *
+ * Each record key gets its own long-lived branch. Branches are only
+ * created/removed when keys are added/removed; value updates are pushed through
+ * the existing key branch.
+ */
+export declare function combineLatestByKey<Input extends Record<string, unknown>, R>(project: (source$: Observable<Input[Extract<keyof Input, string>]>, key: Extract<keyof Input, string>) => Observable<R>): OperatorFunction<Input, Record<Extract<keyof Input, string>, R>>;

package/dist/observable/combine-latest-by-key.js

@@ -0,0 +1,136 @@
+import { Observable, Subject } from "rxjs";
+/** Sentinel to distinguish "no value yet" from a real value */
+const NOT_YET = Symbol("NOT_YET");
+/**
+ * Dynamic counterpart to `switchMap(() => combineLatest(...))` for records,
+ * with stable branches by key.
+ *
+ * Each record key gets its own long-lived branch. Branches are only
+ * created/removed when keys are added/removed; value updates are pushed through
+ * the existing key branch.
+ */
+export function combineLatestByKey(project) {
+    return (source$) => new Observable((subscriber) => {
+        const slots = new Map();
+        let sourceCompleted = false;
+        let currentKeys = [];
+        let batchingSourceNext = false;
+        let emittedDuringBatch = false;
+        function checkComplete() {
+            if (!sourceCompleted)
+                return;
+            for (const slot of slots.values()) {
+                if (!slot.completed)
+                    return;
+            }
+            subscriber.complete();
+        }
+        function tryEmit() {
+            for (const key of currentKeys) {
+                const slot = slots.get(key);
+                if (!slot || slot.value === NOT_YET)
+                    return;
+            }
+            const out = {};
+            for (const key of currentKeys) {
+                const slot = slots.get(key);
+                if (!slot)
+                    return;
+                out[key] = slot.value;
+            }
+            subscriber.next(out);
+            if (batchingSourceNext)
+                emittedDuringBatch = true;
+        }
+        function createSlot(key) {
+            const input = new Subject();
+            const slot = { input, value: NOT_YET, completed: false };
+            let child$;
+            try {
+                child$ = project(input, key);
+            }
+            catch (err) {
+                input.complete();
+                subscriber.error(err);
+                return undefined;
+            }
+            slot.sub = child$.subscribe({
+                next(value) {
+                    slot.value = value;
+                    if (batchingSourceNext) {
+                        emittedDuringBatch = true;
+                        return;
+                    }
+                    tryEmit();
+                },
+                error(err) {
+                    subscriber.error(err);
+                },
+                complete() {
+                    slot.completed = true;
+                    checkComplete();
+                },
+            });
+            return slot;
+        }
+        const sourceSub = source$.subscribe({
+            next(input) {
+                batchingSourceNext = true;
+                emittedDuringBatch = false;
+                const entries = Object.entries(input);
+                currentKeys = entries.map(([key]) => key);
+                const newKeysSet = new Set(currentKeys);
+                for (const [key, slot] of slots) {
+                    if (!newKeysSet.has(key)) {
+                        slot.sub?.unsubscribe();
+                        slot.input.complete();
+                        slots.delete(key);
+                    }
+                }
+                for (const key of currentKeys) {
+                    if (!slots.has(key)) {
+                        const slot = createSlot(key);
+                        if (!slot) {
+                            batchingSourceNext = false;
+                            return;
+                        }
+                        slots.set(key, slot);
+                    }
+                }
+                for (const [key, value] of entries) {
+                    if (subscriber.closed) {
+                        batchingSourceNext = false;
+                        return;
+                    }
+                    const slot = slots.get(key);
+                    if (!slot) {
+                        batchingSourceNext = false;
+                        return;
+                    }
+                    slot.input.next(value);
+                }
+                if (emittedDuringBatch || entries.length === 0)
+                    tryEmit();
+                batchingSourceNext = false;
+            },
+            error(err) {
+                subscriber.error(err);
+            },
+            complete() {
+                sourceCompleted = true;
+                for (const slot of slots.values()) {
+                    slot.input.complete();
+                }
+                checkComplete();
+            },
+        });
+        return () => {
+            sourceSub.unsubscribe();
+            for (const slot of slots.values()) {
+                slot.sub?.unsubscribe();
+                slot.input.complete();
+            }
+            slots.clear();
+        };
+    });
+}

package/dist/observable/combine-latest-by-value.d.ts

@@ -0,0 +1,10 @@
+import { Observable, type OperatorFunction } from "rxjs";
+/**
+ * Dynamic counterpart to `switchMap((values) => combineLatest(values.map(...)))`
+ * for arrays, with stable branches by value.
+ *
+ * A single branch is created per unique array value (Map key semantics) and is
+ * only created/removed when values are added/removed across emissions. Duplicate
+ * values in the same array share the same branch.
+ */
+export declare function combineLatestByValue<T, R>(project: (value: T) => Observable<R>): OperatorFunction<readonly T[], Map<T, R>>;

package/dist/observable/combine-latest-by-value.js

@@ -0,0 +1,117 @@
+import { Observable } from "rxjs";
+/** Sentinel to distinguish "no value yet" from a real value */
+const NOT_YET = Symbol("NOT_YET");
+/**
+ * Dynamic counterpart to `switchMap((values) => combineLatest(values.map(...)))`
+ * for arrays, with stable branches by value.
+ *
+ * A single branch is created per unique array value (Map key semantics) and is
+ * only created/removed when values are added/removed across emissions. Duplicate
+ * values in the same array share the same branch.
+ */
+export function combineLatestByValue(project) {
+    return (source$) => new Observable((subscriber) => {
+        const slots = new Map();
+        let sourceCompleted = false;
+        let currentValues = [];
+        let batchingSourceNext = false;
+        function checkComplete() {
+            if (!sourceCompleted)
+                return;
+            for (const slot of slots.values()) {
+                if (!slot.completed)
+                    return;
+            }
+            subscriber.complete();
+        }
+        function tryEmit() {
+            for (const value of currentValues) {
+                const slot = slots.get(value);
+                if (!slot || slot.value === NOT_YET)
+                    return;
+            }
+            const out = new Map();
+            for (const value of currentValues) {
+                const slot = slots.get(value);
+                if (!slot)
+                    return;
+                out.set(value, slot.value);
+            }
+            subscriber.next(out);
+        }
+        function createSlot(value) {
+            const slot = { value: NOT_YET, completed: false };
+            let child$;
+            try {
+                child$ = project(value);
+            }
+            catch (err) {
+                subscriber.error(err);
+                return undefined;
+            }
+            slot.sub = child$.subscribe({
+                next(nextValue) {
+                    slot.value = nextValue;
+                    if (batchingSourceNext) {
+                        return;
+                    }
+                    tryEmit();
+                },
+                error(err) {
+                    subscriber.error(err);
+                },
+                complete() {
+                    slot.completed = true;
+                    checkComplete();
+                },
+            });
+            return slot;
+        }
+        const sourceSub = source$.subscribe({
+            next(input) {
+                batchingSourceNext = true;
+                const uniqueValues = [];
+                const nextValueSet = new Set();
+                for (const value of input) {
+                    if (nextValueSet.has(value))
+                        continue;
+                    nextValueSet.add(value);
+                    uniqueValues.push(value);
+                }
+                currentValues = uniqueValues;
+                for (const [value, slot] of slots) {
+                    if (!nextValueSet.has(value)) {
+                        slot.sub?.unsubscribe();
+                        slots.delete(value);
+                    }
+                }
+                for (const value of currentValues) {
+                    if (!slots.has(value)) {
+                        const slot = createSlot(value);
+                        if (!slot) {
+                            batchingSourceNext = false;
+                            return;
+                        }
+                        slots.set(value, slot);
+                    }
+                }
+                tryEmit();
+                batchingSourceNext = false;
+            },
+            error(err) {
+                subscriber.error(err);
+            },
+            complete() {
+                sourceCompleted = true;
+                checkComplete();
+            },
+        });
+        return () => {
+            sourceSub.unsubscribe();
+            for (const slot of slots.values()) {
+                slot.sub?.unsubscribe();
+            }
+            slots.clear();
+        };
+    });
+}

package/dist/observable/combine-latest-by.d.ts

@@ -0,0 +1,16 @@
+import { type OperatorFunction } from "rxjs";
+/** Operator object type: one branch operator per output key. */
+type CombineLatestByObjectOperators<Input, Output extends Record<string, unknown>> = {
+    [K in keyof Output]: OperatorFunction<Input, Output[K]>;
+};
+/** Operator tuple type: one branch operator per output index. */
+type CombineLatestByArrayOperators<Input, Output extends readonly unknown[]> = {
+    [K in keyof Output]: OperatorFunction<Input, Output[K]>;
+};
+/**
+ * Branches a source through multiple operators and combines branch outputs with
+ * `combineLatest` semantics.
+ */
+export declare function combineLatestBy<Input, Output extends Record<string, unknown>>(operators: CombineLatestByObjectOperators<Input, Output>): OperatorFunction<Input, Output>;
+export declare function combineLatestBy<Input, Output extends readonly unknown[]>(operators: CombineLatestByArrayOperators<Input, Output>): OperatorFunction<Input, Output>;
+export {};

package/dist/observable/combine-latest-by.js

@@ -0,0 +1,12 @@
+import { combineLatest, connect } from "rxjs";
+export function combineLatestBy(operators) {
+    return connect((shared$) => {
+        if (Array.isArray(operators)) {
+            const branches = operators.map((op) => shared$.pipe(op));
+            return combineLatest(branches);
+        }
+        const objectOperators = operators;
+        const branches = Object.fromEntries(Object.entries(objectOperators).map(([key, op]) => [key, shared$.pipe(op)]));
+        return combineLatest(branches);
+    });
+}

package/dist/observable/index.d.ts

@@ -1,10 +1,16 @@
-export { firstValueFrom, lastValueFrom, combineLatest, merge } from "rxjs";
-export { Observable, Subject, BehaviorSubject, ReplaySubject } from "rxjs";
+export { BehaviorSubject, combineLatest, firstValueFrom, lastValueFrom, merge, Observable, ReplaySubject, Subject, } from "rxjs";
+export * from "./catch-error-inline.js";
+export * from "./chainable.js";
+export * from "./combine-latest-by-index.js";
+export * from "./combine-latest-by-key.js";
+export * from "./combine-latest-by-value.js";
+export * from "./combine-latest-by.js";
 export * from "./defined.js";
 export * from "./get-observable-value.js";
-export * from "./map-events-to-timeline.js";
 export * from "./map-events-to-store.js";
+export * from "./map-events-to-timeline.js";
+export * from "./relay-selection.js";
 export * from "./simple-timeout.js";
+export * from "./timeout-with-ignore.js";
 export * from "./watch-event-updates.js";
 export * from "./with-immediate-value.js";
-export * from "./relay-selection.js";

package/dist/observable/index.js

@@ -1,11 +1,17 @@
 // Re-export some useful rxjs functions
-export { firstValueFrom, lastValueFrom, combineLatest, merge } from "rxjs";
-export { Observable, Subject, BehaviorSubject, ReplaySubject } from "rxjs";
+export { BehaviorSubject, combineLatest, firstValueFrom, lastValueFrom, merge, Observable, ReplaySubject, Subject, } from "rxjs";
+export * from "./catch-error-inline.js";
+export * from "./chainable.js";
+export * from "./combine-latest-by-index.js";
+export * from "./combine-latest-by-key.js";
+export * from "./combine-latest-by-value.js";
+export * from "./combine-latest-by.js";
 export * from "./defined.js";
 export * from "./get-observable-value.js";
-export * from "./map-events-to-timeline.js";
 export * from "./map-events-to-store.js";
+export * from "./map-events-to-timeline.js";
+export * from "./relay-selection.js";
 export * from "./simple-timeout.js";
+export * from "./timeout-with-ignore.js";
 export * from "./watch-event-updates.js";
 export * from "./with-immediate-value.js";
-export * from "./relay-selection.js";

package/dist/observable/timeout-with-ignore.d.ts

@@ -0,0 +1,24 @@
+import { type ObservableInput, type ObservedValueOf, type OperatorFunction, type TimeoutConfig } from "rxjs";
+/**
+ * Like RxJS `timeout`, but only for emissions that are not ignored.
+ *
+ * Values that match `config.ignore` are forwarded immediately and do not affect
+ * timeout state (`first`/`each`). Timeout timing only observes non-ignored values.
+ *
+ * Example usage:
+ *
+ *   source$.pipe(
+ *     timeoutWithIgnore({
+ *       first: 1500,
+ *       each: 1000,
+ *       with: () => of(null),
+ *       ignore: value => value === undefined,
+ *     })
+ *   )
+ *
+ * @param config RxJS timeout config with an additional `ignore` matcher
+ * (`(value) => boolean` or array of values) used to bypass timeout checks.
+ */
+export declare function timeoutWithIgnore<T, O extends ObservableInput<unknown> = ObservableInput<T>, M = unknown>(config: TimeoutConfig<T, O, M> & {
+    ignore: readonly T[] | ((value: T) => boolean);
+}): OperatorFunction<T, T | ObservedValueOf<O>>;

package/dist/observable/timeout-with-ignore.js

@@ -0,0 +1,33 @@
+import { endWith, filter, ignoreElements, merge, share, takeUntil, timeout, } from "rxjs";
+/**
+ * Like RxJS `timeout`, but only for emissions that are not ignored.
+ *
+ * Values that match `config.ignore` are forwarded immediately and do not affect
+ * timeout state (`first`/`each`). Timeout timing only observes non-ignored values.
+ *
+ * Example usage:
+ *
+ *   source$.pipe(
+ *     timeoutWithIgnore({
+ *       first: 1500,
+ *       each: 1000,
+ *       with: () => of(null),
+ *       ignore: value => value === undefined,
+ *     })
+ *   )
+ *
+ * @param config RxJS timeout config with an additional `ignore` matcher
+ * (`(value) => boolean` or array of values) used to bypass timeout checks.
+ */
+export function timeoutWithIgnore(config) {
+    return (source) => {
+        const { ignore, ...timeoutConfig } = config;
+        const isIgnored = (value) => (typeof ignore === "function" ? ignore(value) : ignore.includes(value));
+        const shared$ = source.pipe(share());
+        const watched$ = shared$.pipe(filter((value) => !isIgnored(value)));
+        const ignored$ = shared$.pipe(filter(isIgnored));
+        const timed$ = watched$.pipe(timeout(timeoutConfig), share());
+        // Stop forwarding ignored values as soon as the timed branch completes/errors.
+        return merge(timed$, ignored$).pipe(takeUntil(timed$.pipe(ignoreElements(), endWith(true))));
+    };
+}

package/dist/operations/client.d.ts

@@ -1,4 +1,4 @@
-import { EventOperation } from "../event-factory/types.js";
+import type { EventOperation } from "../factories/types.js";
 import { AddressPointer } from "../helpers/pointers.js";
 /** 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

@@ -6,7 +6,7 @@ import { includeSingletonTag } from "./tags.js";
 const NEVER_ATTACH_CLIENT_TAG = [kinds.EncryptedDirectMessage, kinds.GiftWrap, kinds.Seal, kinds.PrivateDirectMessage];
 /** Includes a NIP-89 client tag in an event*/
 export function setClient(name, pointer, replace = true) {
-    return (draft, ctx) => {
+    return (draft) => {
         if (NEVER_ATTACH_CLIENT_TAG.includes(draft.kind))
             return draft;
         else {
@@ -17,7 +17,7 @@ export function setClient(name, pointer, replace = true) {
                     kind: kinds.Handlerinformation,
                 })
                 : undefined;
-            return includeSingletonTag(fillAndTrimTag(["client", name, coordinate]), replace)(draft, ctx);
+            return includeSingletonTag(fillAndTrimTag(["client", name, coordinate]), replace)(draft);
         }
     };
 }

package/dist/operations/content.d.ts

@@ -1,4 +1,4 @@
-import { Emoji, EventOperation } from "../event-factory/types.js";
+import type { EventOperation, Emoji } from "../factories/types.js";
 /** Override the event content */
 export declare function setContent(content: string): EventOperation;
 /** Replaces any `@npub` or bare npub mentions with nostr: prefix */
@@ -11,7 +11,10 @@ export declare function setContentWarning(warning: boolean | string): EventOpera
 export declare function includeQuoteTags(): EventOperation;
 /** Adds "t" tags for every #hashtag in the content */
 export declare function includeContentHashtags(): EventOperation;
-/** Adds "emoji" tags for NIP-30 emojis used in the content */
+/**
+ * Adds "emoji" tags for NIP-30 emojis used in the content
+ * @param emojis - Array of custom emojis to check for in content
+ */
 export declare function includeEmojis(emojis?: Emoji[]): EventOperation;
 export type TextContentOptions = {
     emojis?: Emoji[];

package/dist/operations/content.js

@@ -16,7 +16,7 @@ export function setContent(content) {
 export function repairNostrLinks() {
     return (draft) => ({
         ...draft,
-        content: draft.content.replaceAll(/(?<=^|\s)(?:@)?((?:npub|note|nprofile|nevent|naddr)1[qpzry9x8gf2tvdw0s3jn54khce6mua7l]{58})/gi, "nostr:$1"),
+        content: draft.content.replaceAll(/(?<=^|\s)(?:@)?((?:npub|note|nprofile|nevent|naddr)1[qpzry9x8gf2tvdw0s3jn54khce6mua7l]{58,})/gi, "nostr:$1"),
     });
 }
 /** "p" tag any pubkey mentioned in the content using nostr: links */
@@ -76,15 +76,17 @@ export function includeContentHashtags() {
         return { ...draft, tags };
     };
 }
-/** Adds "emoji" tags for NIP-30 emojis used in the content */
-export function includeEmojis(emojis) {
-    return (draft, ctx) => {
-        const all = [...(ctx.emojis ?? []), ...(emojis ?? [])];
+/**
+ * Adds "emoji" tags for NIP-30 emojis used in the content
+ * @param emojis - Array of custom emojis to check for in content
+ */
+export function includeEmojis(emojis = []) {
+    return (draft) => {
         const tags = Array.from(draft.tags);
-        // create tags for all occurrences of #hashtag
+        // create tags for all occurrences of :emoji:
         const matches = draft.content.matchAll(Expressions.emoji);
         for (const [_, name] of matches) {
-            const emoji = all.find((e) => e.shortcode === name);
+            const emoji = emojis.find((e) => e.shortcode === name);
             if (emoji?.url) {
                 tags.push(emoji.address
                     ? ["emoji", emoji.shortcode, emoji.url, getReplaceableAddressFromPointer(emoji.address)]

package/dist/operations/delete.d.ts

@@ -1,4 +1,4 @@
-import { EventOperation } from "../event-factory/types.js";
+import type { EventOperation } from "../factories/types.js";
 import { NostrEvent } from "../helpers/event.js";
 /** Sets the necessary tags for a NIP-09 delete event to point to a the events being deleted */
 export declare function setDeleteEvents(events: (string | NostrEvent)[]): EventOperation;

package/dist/operations/encrypted-content.d.ts

@@ -1,4 +1,10 @@
-import { EventOperation } from "../event-factory/types.js";
+import type { EventOperation } from "../factories/types.js";
 import { EncryptionMethod } from "../helpers/encrypted-content.js";
-/** Sets the content to be encrypted to the pubkey with optional override method */
-export declare function setEncryptedContent(pubkey: string, content: string, override?: EncryptionMethod): EventOperation;
+/**
+ * Sets the content to be encrypted to the pubkey with optional override method
+ * @param pubkey - Pubkey to encrypt the content for
+ * @param content - Plaintext content to encrypt
+ * @param signer - EventSigner for encryption
+ * @param override - Optional encryption method override
+ */
+export declare function setEncryptedContent(pubkey: string, content: string, signer?: import("../factories/types.js").EventSigner, override?: EncryptionMethod): EventOperation;

package/dist/operations/encrypted-content.js

@@ -1,7 +1,13 @@
 import { EncryptedContentSymbol, getEncryptedContentEncryptionMethods, } from "../helpers/encrypted-content.js";
-/** Sets the content to be encrypted to the pubkey with optional override method */
-export function setEncryptedContent(pubkey, content, override) {
-    return async (draft, { signer }) => {
+/**
+ * Sets the content to be encrypted to the pubkey with optional override method
+ * @param pubkey - Pubkey to encrypt the content for
+ * @param content - Plaintext content to encrypt
+ * @param signer - EventSigner for encryption
+ * @param override - Optional encryption method override
+ */
+export function setEncryptedContent(pubkey, content, signer, override) {
+    return async (draft) => {
         if (!signer)
             throw new Error("Signer required for encrypted content");
         // Set method based on kind if not provided