applesauce-relay 5.2.0 → 6.0.2

package/dist/relay.js

@@ -1,19 +1,24 @@
 import { logger } from "applesauce-core";
+import { addSeenRelay } from "applesauce-core/helpers";
 import { ensureHttpURL } from "applesauce-core/helpers/url";
 import { mapEventsToStore, simpleTimeout } from "applesauce-core/observable";
 import { nanoid } from "nanoid";
 import { makeAuthEvent } from "nostr-tools/nip42";
-import { BehaviorSubject, catchError, combineLatest, defer, endWith, filter, finalize, firstValueFrom, from, identity, ignoreElements, isObservable, lastValueFrom, map, merge, mergeMap, mergeWith, NEVER, Observable, of, repeat, retry, scan, share, shareReplay, Subject, switchMap, take, takeUntil, tap, throwError, timeout, timer, } from "rxjs";
+import { BehaviorSubject, catchError, combineLatest, defer, EMPTY, endWith, filter, finalize, firstValueFrom, from, identity, ignoreElements, isObservable, lastValueFrom, map, merge, mergeMap, mergeWith, NEVER, Observable, of, repeat, retry, scan, share, shareReplay, startWith, Subject, switchMap, take, takeUntil, takeWhile, tap, throwError, timeout, timer, } from "rxjs";
 import { webSocket } from "rxjs/webSocket";
-import { completeOnEose } from "./operators/complete-on-eose.js";
-import { markFromRelay } from "./operators/mark-from-relay.js";
+import { completeWhen } from "./operators/complete-when.js";
 const AUTH_REQUIRED_PREFIX = "auth-required:";
-/** Default retry config for all methods */
+/** Default reconnect/retry config for request, subscription, and publish. linear backoff */
 const DEFAULT_RETRY_CONFIG = {
     count: 3,
-    delay: 1000,
+    delay: (_err, count) => timer(count * 1000),
     resetOnSuccess: true,
 };
+function normalizeRetryConfig(config) {
+    if (typeof config === "number")
+        return { ...DEFAULT_RETRY_CONFIG, count: config };
+    return { ...DEFAULT_RETRY_CONFIG, ...(config ?? {}) };
+}
 /** Flags for the negentropy sync type */
 export var SyncDirection;
 (function (SyncDirection) {
@@ -21,8 +26,45 @@ export var SyncDirection;
     SyncDirection[SyncDirection["SEND"] = 2] = "SEND";
     SyncDirection[SyncDirection["BOTH"] = 3] = "BOTH";
 })(SyncDirection || (SyncDirection = {}));
-/** An error that is thrown when a REQ is closed from the relay side */
-export class ReqCloseError extends Error {
+/** Base error thrown when a relay closes a REQ or COUNT with a CLOSED message */
+export class RelayClosedError extends Error {
+    reason;
+    constructor(reason) {
+        super(reason);
+        this.reason = reason;
+        this.name = "RelayClosedError";
+    }
+}
+/** Thrown when the relay closes a subscription with an auth-required: prefix */
+export class AuthRequiredError extends RelayClosedError {
+    constructor(reason) {
+        super(reason);
+        this.name = "AuthRequiredError";
+    }
+}
+/** NIP-01 machine-readable prefixes that indicate an error condition on CLOSED/OK messages */
+const CLOSED_ERROR_PREFIXES = {
+    "auth-required": AuthRequiredError,
+    unsupported: RelayClosedError,
+    error: RelayClosedError,
+    blocked: RelayClosedError,
+    restricted: RelayClosedError,
+    "rate-limited": RelayClosedError,
+    pow: RelayClosedError,
+    invalid: RelayClosedError,
+    duplicate: RelayClosedError,
+    mute: RelayClosedError,
+};
+/**
+ * Parse a NIP-01 machine-readable CLOSED reason string into a typed error.
+ * Returns null if the reason has no recognized prefix — the relay closed gracefully
+ * and the observable should complete rather than error.
+ */
+function parseClosedError(reason) {
+    const ErrorClass = CLOSED_ERROR_PREFIXES[reason.split(":")[0]];
+    if (ErrorClass)
+        return new ErrorClass(reason);
+    return null;
 }
 /** A dummy filter that will return empty results */
 const PING_FILTER = {
@@ -87,7 +129,7 @@ export class Relay {
     open$ = new Subject();
     /** An observable that emits when underlying websocket is closed */
     close$ = new Subject();
-    /** An observable that emits when underlying websocket is closing due to unsubscription */
+    /** An observable that emits when underlying websocket is closing due to unsubscribe or complete */
     closing$ = new Subject();
     /** Tracks active req() operations by subscription ID */
     reqs$ = new BehaviorSubject({});
@@ -125,8 +167,6 @@ export class Relay {
     get reqs() {
         return this.reqs$.value;
     }
-    /** If an EOSE message is not seen in this time, emit one locally (default 10s)  */
-    eoseTimeout = 10_000;
     /** How long to wait for an OK message from the relay (default 10s) */
     eventTimeout = 10_000;
     /** How long to wait for a publish to complete (default 30s) */
@@ -139,9 +179,9 @@ export class Relay {
     pingFrequency = 29_000;
     /** How long to wait for EOSE response in milliseconds (default 20000) */
     pingTimeout = 20_000;
-    /** Default retry config for subscription() method */
+    /** Default retry config for subscription() connection errors */
     subscriptionReconnect;
-    /** Default retry config for request() method */
+    /** Default retry config for request() connection errors */
     requestReconnect;
     /** Default retry config for publish() method */
     publishRetry;
@@ -174,8 +214,6 @@ export class Relay {
         this.url = url;
         this.log = this.log.extend(url);
         // Set common options
-        if (opts?.eoseTimeout !== undefined)
-            this.eoseTimeout = opts.eoseTimeout;
         if (opts?.eventTimeout !== undefined)
             this.eventTimeout = opts.eventTimeout;
         if (opts?.publishTimeout !== undefined)
@@ -191,8 +229,8 @@ export class Relay {
         if (opts?.onUnresponsive !== undefined)
             this.onUnresponsive = opts.onUnresponsive;
         // Set retry configs
-        this.subscriptionReconnect = { ...DEFAULT_RETRY_CONFIG, ...(opts?.subscriptionRetry ?? {}) };
-        this.requestReconnect = { ...DEFAULT_RETRY_CONFIG, ...(opts?.requestRetry ?? {}) };
+        this.subscriptionReconnect = normalizeRetryConfig(opts?.subscriptionReconnect);
+        this.requestReconnect = normalizeRetryConfig(opts?.requestReconnect);
         this.publishRetry = { ...DEFAULT_RETRY_CONFIG, ...(opts?.publishRetry ?? {}) };
         // Create an observable that tracks boolean authentication state
         this.authenticated$ = this.authenticationResponse$.pipe(map((response) => response?.ok === true));
@@ -214,7 +252,7 @@ export class Relay {
                 this.log("Disconnected");
             else
                 this.log("Failed to connect");
-            // Chnaged the connected state to false
+            // Changed the connected state to false
             if (this.connected$.value)
                 this.connected$.next(false);
             // Increment the attempts counter
@@ -367,7 +405,7 @@ export class Relay {
             if (!ready)
                 return NEVER;
             // Only start the watch tower if the relay is ready
-            return merge(listenForAllMessages, listenForNotice, ListenForChallenge, this.information$, pingHealthCheck).pipe(
+            return merge(listenForAllMessages, listenForNotice, ListenForChallenge, pingHealthCheck).pipe(
             // Never emit any values
             ignoreElements(), 
             // Start the reconnect timer if the connection has an error
@@ -428,8 +466,15 @@ export class Relay {
     send(message) {
         this.socket.next(message);
     }
-    /** Create a REQ observable that emits events or "EOSE" or errors */
-    req(filters, id = nanoid()) {
+    /**
+     * Create a REQ observable that emits OPEN, EVENT, EOSE, and CLOSED messages.
+     *
+     * `resubscribe` only repeats after the relay sends a clean CLOSED message for this REQ.
+     * `reconnect` only retries connection errors and does not retry relay CLOSED errors.
+     */
+    req(filters, opts) {
+        const id = opts?.id ?? nanoid();
+        const waitForAuth = opts?.waitForAuth ?? true;
         // Convert filters input into an observable, if its a normal value merge it with NEVER so it never completes
         let input;
         // Create input from filters input
@@ -441,84 +486,149 @@ export class Relay {
             input = (isObservable(filters) ? filters : merge(of(filters), NEVER)).pipe(map((f) => (Array.isArray(f) ? f : [f])));
         }
         // Create an observable that completes when the upstream observable completes
-        const filtersComplete = input.pipe(ignoreElements(), endWith(null));
+        const filtersComplete = input.pipe(ignoreElements(), endWith(true));
+        // Track whether the relay already sent CLOSED so we skip the redundant client CLOSE
+        let relayClosedSub = false;
+        let shouldResubscribe = false;
         // Create an observable that filters responses from the relay to just the ones for this REQ
         const messages = this.socket.pipe(filter((m) => Array.isArray(m) && (m[0] === "EVENT" || m[0] === "CLOSED" || m[0] === "EOSE") && m[1] === id), 
-        // Singleton (prevents the .pipe() operator later from sending two REQ messages )
+        // Map NIP-01 messages to RelayReqMessage
+        map((m) => {
+            if (m[0] === "EVENT" && typeof m[2] === "object")
+                return { type: "EVENT", from: this.url, id: m[1], event: m[2] };
+            if (m[0] === "CLOSED")
+                return { type: "CLOSED", from: this.url, id: m[1], reason: m[2] ?? "" };
+            // EOSE
+            return { type: "EOSE", from: this.url, id: m[1] };
+        }), 
+        // Throw typed errors for prefixed CLOSED; mark relay-closed before takeWhile sees it
+        tap((m) => {
+            if (m.type === "CLOSED") {
+                relayClosedSub = true;
+                const error = parseClosedError(m.reason);
+                if (error)
+                    throw error;
+                shouldResubscribe = true;
+            }
+        }), 
+        // Complete the stream on unprefixed CLOSED, emitting the CLOSED message last (inclusive)
+        takeWhile((m) => m.type !== "CLOSED", true), 
+        // Singleton (prevents the .pipe() operator later from sending two REQ messages)
         share());
         // Create an observable that controls sending the filters and closing the REQ
         const control = input.pipe(
         // Send the filters when they change
-        tap((filters) => {
+        map((filters) => {
+            // Reset closed flag on each new REQ (resubscribe cycles)
+            relayClosedSub = false;
+            shouldResubscribe = false;
             this.socket.next(["REQ", id, ...filters]);
             // Add to tracking when REQ is sent
             this.reqs$.next({ ...this.reqs$.value, [id]: filters });
+            return { type: "OPEN", id, filters, from: this.url };
         }), 
-        // Send the CLOSE message when unsubscribed or input completes
+        // Send CLOSE when unsubscribed or input completes, but not if relay already sent CLOSED
         finalize(() => {
-            this.socket.next(["CLOSE", id]);
+            if (!relayClosedSub)
+                this.socket.next(["CLOSE", id]);
             // Remove from tracking when REQ closes
             const { [id]: _, ...rest } = this.reqs$.value;
             this.reqs$.next(rest);
         }), 
         // Once filters have been sent, switch to listening for messages
-        switchMap(() => messages));
+        switchMap((openMessage) => messages.pipe(
+        // Pass along the OPEN message for listeners
+        startWith(openMessage))));
         // Start the watch tower with the observables
         const observable = merge(this.watchTower, control).pipe(
-        // Complete the subscription when the control observable completes
-        // This is to work around the fact that merge() waits for both observables to complete
+        // Complete when messages completes (e.g. unprefixed CLOSED = graceful relay close)
         takeUntil(messages.pipe(ignoreElements(), endWith(true))), 
         // Complete the subscription when the input is completed
         takeUntil(filtersComplete), 
-        // Map the messages to events, EOSE, or throw an error
-        map((message) => {
-            if (message[0] === "EOSE")
-                return "EOSE";
-            else if (message[0] === "CLOSED")
-                throw new ReqCloseError(message[2]);
-            else
-                return message[2];
-        }), this.handleAuthRequiredForReq("REQ"), 
         // mark events as from relays
-        markFromRelay(this.url), 
-        // if no events are seen in 10s, emit EOSE
-        // TODO: this timeout should only emit EOSE after the last event is seen and no EOSE has been sent in (timeout ms)
-        timeout({
-            first: this.eoseTimeout,
-            with: () => merge(of("EOSE"), NEVER),
+        tap((message) => {
+            if (message.type === "EVENT")
+                addSeenRelay(message.event, this.url);
+        }), 
+        // Only create one upstream subscription
+        share());
+        // Wait for auth only when enabled and make sure to start the watch tower
+        const reqWithAuthStrategy = waitForAuth ? this.waitForAuth(this.authRequiredForRead$, observable) : observable;
+        return defer(() => this.waitForReady(reqWithAuthStrategy)).pipe(
+        // Retry only auth-required errors, optionally waiting for authentication first
+        retry({
+            delay: (error) => {
+                // Re-throw non-auth-required errors
+                if (!(error instanceof AuthRequiredError))
+                    return throwError(() => error);
+                // Flip the flag to indicate that auth is required
+                this.log(`Auth required for REQ`);
+                this.receivedAuthRequiredForReq.next(true);
+                // If not waiting for auth  , re-throw the error
+                if (!waitForAuth)
+                    return throwError(() => error);
+                // Wait for authentication before retrying
+                return this.authenticated$.pipe(filter((authenticated) => authenticated), take(1));
+            },
         }), 
+        // Retry connection errors independently from relay CLOSED errors
+        this.customConnectionRetryOperator(opts?.reconnect), 
+        // Resubscribe only after the relay cleanly CLOSED this REQ
+        this.customRepeatOperator(opts?.resubscribe, () => shouldResubscribe), 
         // Only create one upstream subscription
         share());
-        // Wait for auth if required and make sure to start the watch tower
-        return this.waitForReady(this.waitForAuth(this.authRequiredForRead$, observable));
     }
     /** Create a COUNT observable that emits a single count response */
     count(filters, id = nanoid()) {
+        // Track whether the relay already sent CLOSED so we skip the redundant client CLOSE
+        let relayClosedSub = false;
         // Create an observable that filters responses from the relay to just the ones for this COUNT
-        const messages = this.socket.pipe(filter((m) => Array.isArray(m) && (m[0] === "COUNT" || m[0] === "CLOSED") && m[1] === id));
+        const messages = this.socket.pipe(filter((m) => Array.isArray(m) && (m[0] === "COUNT" || m[0] === "CLOSED") && m[1] === id), 
+        // Map to typed response, throwing on error-prefixed CLOSED
+        map((m) => {
+            if (m[0] === "COUNT")
+                return m[2];
+            else if (m[0] === "CLOSED") {
+                relayClosedSub = true;
+                const error = parseClosedError(m[2] ?? "");
+                if (error)
+                    throw error;
+            }
+            return null;
+        }), 
+        // Complete the stream on any CLOSED (including graceful close), emitting COUNT last
+        takeWhile((m) => m !== null, true), filter((m) => m !== null), 
+        // Singleton
+        share());
         // Send the COUNT message and listen for response
-        const observable = defer(() => {
+        const control = defer(() => {
+            // Reset closed flag on each new COUNT
+            relayClosedSub = false;
             // Send the COUNT message when subscription starts
             this.socket.next(Array.isArray(filters) ? ["COUNT", id, ...filters] : ["COUNT", id, filters]);
-            // Merge with watch tower to keep connection alive
-            return merge(this.watchTower, messages);
+            return messages;
         }).pipe(
-        // Map the messages to count responses or throw an error
-        map((message) => {
-            if (message[0] === "COUNT")
-                return message[2];
-            else
-                throw new ReqCloseError(message[2]);
-        }), this.handleAuthRequiredForReq("COUNT"), 
+        // Send CLOSE when unsubscribed, but not if relay already sent CLOSED
+        finalize(() => {
+            if (!relayClosedSub)
+                this.socket.next(["CLOSE", id]);
+        }));
+        const observable = merge(this.watchTower, control).pipe(
+        // Complete when messages completes (unprefixed CLOSED = graceful relay close)
+        takeUntil(messages.pipe(ignoreElements(), endWith(true))), 
         // Complete on first value (COUNT responses are single-shot)
         take(1), 
-        // Add timeout
-        timeout({
-            first: this.eoseTimeout,
-            with: () => throwError(() => new Error("COUNT timeout")),
-        }));
+        // Set auth required flag when relay closes with auth-required
+        catchError((error) => {
+            if (error instanceof AuthRequiredError && !this.receivedAuthRequiredForReq.value) {
+                this.log(`Auth required for COUNT`);
+                this.receivedAuthRequiredForReq.next(true);
+            }
+            return throwError(() => error);
+        }), 
+        // Throw an error if no COUNT response received within 10 seconds
+        timeout({ first: 10_000, with: () => throwError(() => new Error("COUNT timeout")) }));
         // Start the watch tower and wait for auth if required
-        // Use share() to prevent multiple subscriptions from creating duplicate COUNT messages
         return this.waitForReady(this.waitForAuth(this.authRequiredForRead$, observable)).pipe(share());
     }
     /** Send an EVENT or AUTH message and return an observable of PublishResponse that completes or errors */
@@ -546,7 +656,7 @@ export class Relay {
                 this.receivedAuthRequiredForEvent.next(true);
             }
         }), 
-        // if no message is seen in 10s, emit EOSE
+        // if no message is seen in 10s, emit failed publish response
         timeout({
             first: this.eventTimeout,
             with: () => of({ ok: false, from: this.url, message: "Timeout" }),
@@ -584,9 +694,9 @@ export class Relay {
         const start = p instanceof Promise ? from(p) : of(p);
         return lastValueFrom(start.pipe(switchMap((event) => this.auth(event))));
     }
-    /** Internal operator for creating the retry() operator */
+    /** Internal operator for creating a retry() operator */
     customRetryOperator(times, base) {
-        if (times === false)
+        if (times === false || times === undefined)
             return identity;
         else if (typeof times === "number")
             return retry({ ...base, count: times });
@@ -595,16 +705,45 @@ export class Relay {
         else
             return retry({ ...base, ...times });
     }
-    /** Internal operator for creating the repeat() operator */
-    customRepeatOperator(times) {
+    /** Internal operator for retrying connection failures without retrying relay CLOSED errors */
+    customConnectionRetryOperator(times, base) {
         if (times === false || times === undefined)
             return identity;
-        else if (times === true)
-            return repeat();
+        const config = typeof times === "number" ? { ...base, count: times } : times === true ? (base ?? {}) : { ...base, ...times };
+        return retry({
+            ...config,
+            delay: (error, count) => {
+                if (error instanceof RelayClosedError)
+                    return throwError(() => error);
+                if (typeof config.delay === "number")
+                    return timer(config.delay);
+                if (typeof config.delay === "function")
+                    return config.delay(error, count);
+                return of(null);
+            },
+        });
+    }
+    /** Internal operator for creating the repeat() operator, optionally gated by a condition */
+    customRepeatOperator(times, condition) {
+        if (times === false || times === undefined)
+            return identity;
+        const delay = (repeatCount) => {
+            if (condition && !condition())
+                return EMPTY;
+            if (typeof times === "object") {
+                if (typeof times.delay === "number")
+                    return timer(times.delay);
+                if (typeof times.delay === "function")
+                    return times.delay(repeatCount);
+            }
+            return of(null);
+        };
+        if (times === true)
+            return repeat({ delay });
         else if (typeof times === "number")
-            return repeat(times);
+            return repeat({ count: times, delay });
         else
-            return repeat(times);
+            return repeat({ ...times, delay });
     }
     /** Internal operator for creating the timeout() operator */
     customTimeoutOperator(timeout, defaultTimeout) {
@@ -618,39 +757,36 @@ export class Relay {
         else
             return simpleTimeout(timeout ?? defaultTimeout);
     }
-    /** Internal operator for handling auth-required errors from REQ/COUNT operations */
-    handleAuthRequiredForReq(operation) {
-        return catchError((error) => {
-            // Set auth required if the operation is closed with auth-required
-            if (error instanceof ReqCloseError &&
-                error.message.startsWith(AUTH_REQUIRED_PREFIX) &&
-                !this.receivedAuthRequiredForReq.value) {
-                this.log(`Auth required for ${operation}`);
-                this.receivedAuthRequiredForReq.next(true);
-            }
-            // Pass the error through
-            return throwError(() => error);
-        });
-    }
-    /** Creates a REQ that retries when relay errors ( default 3 retries ) */
+    /** Creates a persistent REQ that retries connection errors (default 3 retries) */
     subscription(filters, opts) {
-        return this.req(filters, opts?.id).pipe(
-        // Retry on connection errors
-        this.customRetryOperator(opts?.reconnect ?? true, this.subscriptionReconnect), 
-        // Create resubscribe logic (repeat operator)
-        this.customRepeatOperator(opts?.resubscribe), 
+        return this.req(filters, {
+            ...opts,
+            reconnect: opts?.reconnect ?? this.subscriptionReconnect,
+        }).pipe(
+        // Filter for EOSE messages
+        filter((message) => message.type === "EOSE" || message.type === "EVENT"), 
+        // Extract EOSE messages
+        map((message) => (message.type === "EOSE" ? "EOSE" : message.event)), 
         // Single subscription
         share());
     }
-    /** Makes a single request that retires on errors and completes on EOSE */
+    /** Makes a single request that retries connection errors and completes on EOSE */
     request(filters, opts) {
-        return this.req(filters, opts?.id).pipe(
-        // Retry on connection errors
-        this.customRetryOperator(opts?.reconnect ?? true, this.requestReconnect), 
-        // Create resubscribe logic (repeat operator)
-        this.customRepeatOperator(opts?.resubscribe), 
+        const req = this.req(filters, {
+            ...opts,
+            reconnect: opts?.reconnect ?? this.requestReconnect,
+        });
+        return req.pipe(
+        // Add completion condition
+        opts?.complete ? completeWhen(opts?.complete) : identity, 
+        // Apply request timeout
+        timeout({ first: opts?.timeout ?? 30_000 }), 
         // Complete when EOSE is received
-        completeOnEose(), 
+        takeWhile((message) => message.type !== "EOSE"), 
+        // Filter only for event messages
+        filter((message) => message.type === "EVENT"), 
+        // Extract event messages
+        map((message) => message.event), 
         // Single subscription
         share());
     }
@@ -659,7 +795,7 @@ export class Relay {
         return lastValueFrom(this.event(event).pipe(mergeMap((result) => {
             // If the relay responds with auth-required, throw an error for the retry operator to handle
             if (result.ok === false && result.message?.startsWith(AUTH_REQUIRED_PREFIX))
-                return throwError(() => new Error(result.message));
+                return throwError(() => new AuthRequiredError(result.message ?? ""));
             return of(result);
         }), 
         // Retry the publish until it succeeds or the number of retries is reached
@@ -668,7 +804,7 @@ export class Relay {
         this.customTimeoutOperator(opts?.timeout, this.publishTimeout)));
     }
     /** Negentropy sync events with the relay and an event store */
-    sync(store, filter, direction = SyncDirection.RECEIVE) {
+    sync(store, filters, direction = SyncDirection.RECEIVE) {
         const getEvents = async (ids) => {
             if (Array.isArray(store))
                 return store.filter((event) => ids.includes(event.id));
@@ -685,7 +821,7 @@ export class Relay {
                     controller.abort();
                 }
             };
-            this.negentropy(store, filter, async (have, need) => {
+            this.negentropy(store, filters, async (have, need) => {
                 // NOTE: it may be more efficient to sync all the events later in a single batch
                 // Send missing events to the relay
                 if (direction & SyncDirection.SEND && have.length > 0) {
@@ -697,7 +833,11 @@ export class Relay {
                 if (direction & SyncDirection.RECEIVE && need.length > 0) {
                     await lastValueFrom(this.req({ ids: need }).pipe(
                     // Complete when EOSE is received
-                    completeOnEose(), 
+                    takeWhile((message) => message.type !== "EOSE"), 
+                    // Filter only for event messages
+                    filter((message) => message.type === "EVENT"), 
+                    // Extract event messages
+                    map((message) => message.event), 
                     // Add events to the store if its writable
                     Reflect.has(store, "add")
                         ? mapEventsToStore(store)
@@ -756,4 +896,28 @@ export class Relay {
             return timer(delay);
         };
     }
+    /** A complete condition that waits for the subscription to open */
+    static afterOpen(condition) {
+        return (source) => source.pipe(
+        // Wait for subscription open
+        filter((m) => m.type === "OPEN"), 
+        // Switch to timer for complete
+        switchMap(() => source.pipe(condition)));
+    }
+    /** An OR complete condition, that completes when either condition is truthy */
+    static completeOr(...conditions) {
+        return (source) => combineLatest(conditions.map((condition) => source.pipe(condition, startWith(false)))).pipe(
+        // Return true if any condition is truthy
+        map((all) => all.some((v) => !!v)));
+    }
+    /** An AND complete condition, that completes when all conditions are truthy */
+    static completeAnd(...conditions) {
+        return (source) => combineLatest(conditions.map((condition) => source.pipe(condition, startWith(false)))).pipe(
+        // Return true if all conditions are truthy
+        map((all) => all.every((v) => !!v)));
+    }
+    /** A default complete condition that waits for the subscription to open and then completes after a timeout */
+    static defaultComplete(timeout, afterOpen = 10_000) {
+        return this.completeOr(() => timer(timeout), this.afterOpen(() => timer(afterOpen)));
+    }
 }