@buoy-gg/network 7.0.78 → 7.0.79

package/lib/typescript/network/conditions/store.d.ts

@@ -1,26 +1,52 @@
-export declare const NETWORK_CONDITIONS: {
-    readonly normal: {
-        readonly label: "Normal";
-        readonly delayMs: 0;
-    };
-    readonly offline: {
-        readonly label: "Offline (requests)";
-        readonly delayMs: 0;
-    };
-    readonly slow: {
-        readonly label: "Slow (+500 ms)";
-        readonly delayMs: 500;
+import { type NetworkConditionProfile, type NetworkConnection, type NetworkConditionStamp } from "./profiles";
+export { NETWORK_CONDITIONS, CONDITIONS_SCOPE } from "./profiles";
+export type { NetworkConditionProfile, NetworkConnection, NetworkConditionStamp } from "./profiles";
+export interface ConnectionSupport {
+    supported: boolean;
+    reason?: string;
+}
+declare const connectionSupport: {
+    netInfo: ConnectionSupport;
+    expoNetwork: ConnectionSupport;
+};
+export declare const getNetworkConnection: () => NetworkConnection;
+export declare const getConditionsRevision: () => number;
+export declare const getEffectiveNetworkConnection: () => "real" | "offline" | "wifi" | "cellular" | "noInternet";
+export declare const networkConditionsActive: () => boolean;
+export declare function setConnectionSupport(key: keyof typeof connectionSupport, value: ConnectionSupport): void;
+export declare function getNetworkConditions(): {
+    version: 2;
+    runtimeId: string;
+    revision: number;
+    profile: "offline" | "normal" | "slow" | "verySlow" | "slow3g" | "slow4g" | "fast4g";
+    connection: NetworkConnection;
+    available: boolean;
+    active: boolean;
+    delayMs: number;
+    downloadBytesPerSecond: number | null;
+    uploadBytesPerSecond: number | null;
+    capabilities: {
+        fetch: string;
+        xhr: string;
+        upload: string;
+        webSocket: boolean;
+        nativeImages: boolean;
+        nativeModules: boolean;
+        netInfo: ConnectionSupport;
+        expoNetwork: ConnectionSupport;
     };
-    readonly verySlow: {
-        readonly label: "Very slow (+2000 ms)";
-        readonly delayMs: 2000;
+    scope: {
+        download: string;
+        upload: string;
+        transports: string;
     };
 };
-export type NetworkConditionProfile = keyof typeof NETWORK_CONDITIONS;
-export interface NetworkConditionStamp {
-    readonly profile: NetworkConditionProfile;
-    readonly delayMs: number;
+export type NetworkConditionsState = ReturnType<typeof getNetworkConditions>;
+export interface NetworkConditionsChange {
+    profile?: NetworkConditionProfile;
+    connection?: NetworkConnection;
 }
+export declare function setNetworkConditions(value?: unknown): NetworkConditionsState;
 export declare const networkConditionsRuntimeId: string;
 export declare const conditionsCanApply: () => boolean;
 export declare const getNetworkCondition: () => NetworkConditionProfile;

package/lib/typescript/network/conditions/xhr.d.ts

@@ -1,5 +1,5 @@
 import type { OverrideOutcome } from "../overrides/types";
 import type { NetworkConditionStamp } from "./store";
 /** Active simulation uses a send-to-completion deadline, including the wait. */
-export declare function runConditionXhr(target: XMLHttpRequest, url: string, condition: NetworkConditionStamp, outcome: OverrideOutcome | null, dispatch: () => void): void;
+export declare function runConditionXhr(target: XMLHttpRequest, url: string, condition: NetworkConditionStamp, outcome: OverrideOutcome | null, dispatch: () => void, body?: unknown): void;
 //# sourceMappingURL=xhr.d.ts.map

package/lib/typescript/network/overrides/engine.d.ts

@@ -3,6 +3,10 @@ export interface OverrideHooks {
     getRules: () => readonly OverrideRule[];
     /** The rule APPLIED to a request. */
     recordHit: (ruleId: string) => void;
+    /** Resolves once saved rules are loaded (a request at app start waits for it). */
+    ready?: () => Promise<void>;
+    /** True once saved rules are loaded, for callers that can't wait on a promise first. */
+    isReady?: () => boolean;
     /**
      * The rule MATCHED a request, whether or not it applied.
      *
@@ -12,6 +16,16 @@ export interface OverrideHooks {
     recordMatch: (ruleId: string) => void;
 }
 export declare function setOverrideHooks(next: OverrideHooks | null): void;
+/**
+ * Wait for saved rules before an async request decides. At app start the
+ * rules are still loading; a loaded bug case's sandbox would otherwise miss
+ * the app's first calls and let them reach real servers.
+ */
+export declare function overrideRulesReady(): Promise<void>;
+/** Whether saved rules are loaded yet. */
+export declare function overrideRulesLoaded(): boolean;
+/** Whether any rule reads the request body (a body match or a GraphQL operation). */
+export declare function overrideRulesNeedBody(): boolean;
 /**
  * Whether a rule stored right now could ever be applied to a request.
  *

package/lib/typescript/network/overrides/matchRule.d.ts

@@ -17,6 +17,9 @@ import type { OverrideRule } from "./types";
  */
 export declare function escapeRegex(pattern: string): string;
 export declare function compilePattern(pattern: string): RegExp;
+/** A GraphQL JSON body (one operation or a batch) that names `operation`. */
+/** JSON with object keys sorted at every level, so equal values give equal text. */
+export declare function canonicalJson(value: unknown): string;
 /** Does this rule apply to this request? Ignores `enabled` — callers check it. */
 export declare function ruleMatches(rule: OverrideRule, url: string, method: string, headers?: Record<string, string>, body?: string): boolean;
 //# sourceMappingURL=matchRule.d.ts.map

package/lib/typescript/network/overrides/overrideRulesStore.d.ts

@@ -111,6 +111,8 @@ declare class OverrideRulesStore {
      * needs no second check.
      */
     getRules(): readonly OverrideRule[];
+    private sandboxCache;
+    private sandboxOnly;
     /**
      * The rule's real body, fetching it from the device when this surface only
      * has the stripped copy (see `OverrideRule.bodyOmitted`).
@@ -172,6 +174,7 @@ declare class OverrideRulesStore {
      * because a rule has to fire from app boot — with the Network tool closed and
      * nothing capturing. On the web `loadNow` has usually done it already.
      */
+    isLoaded(): boolean;
     ensureLoaded(): Promise<void>;
     /**
      * Web only: read the saved rules from localStorage right now.

package/lib/typescript/network/overrides/types.d.ts

@@ -89,6 +89,25 @@ export interface OverrideRule {
      * asked first. A body that isn't text (FormData, a Blob) never matches.
      */
     bodyIncludes?: string;
+    /**
+     * Only GraphQL requests whose JSON body names this `operationName` (or a
+     * batch that holds it). Parsed, not matched as text, so spacing and key
+     * order in the body don't matter.
+     */
+    graphqlOperation?: string;
+    /**
+     * With graphqlOperation: only when that operation's `variables` equal this,
+     * written as JSON with its keys sorted (see canonicalJson). Parsed, so
+     * spacing and key order don't matter. Missing variables count as {}.
+     */
+    graphqlVariables?: string;
+    /**
+     * Part of a loaded bug case's sandbox (bug links). Such a rule keeps
+     * applying while Buoy's account access is off, because the case's data is
+     * in the app either way and must not reach a real server, and it is never
+     * auto-paused at launch. Release builds still never apply any rule.
+     */
+    sandbox?: boolean;
     kind: OverrideRuleKind;
     /** `respond` only. Clamped to [STATUS_MIN, STATUS_MAX]. Defaults to 200. */
     status?: number;

package/lib/typescript/network/sync/networkSyncAdapter.d.ts

@@ -1,3 +1,4 @@
+import { getNetworkConditions, setNetworkConditions } from "../conditions/store";
 import type { OverrideRulesState } from "../overrides/overrideRulesStore";
 import { type OverrideRuleKind } from "../overrides/types";
 import type { NetworkEvent } from "../types";
@@ -54,10 +55,31 @@ export declare const networkSyncAdapter: {
     version: number;
     getSnapshot: () => {
         conditions: {
-            version: number;
+            version: 2;
             runtimeId: string;
-            profile: "normal" | "offline" | "slow" | "verySlow";
+            revision: number;
+            profile: "offline" | "normal" | "slow" | "verySlow" | "slow3g" | "slow4g" | "fast4g";
+            connection: import("../..").NetworkConnection;
             available: boolean;
+            active: boolean;
+            delayMs: number;
+            downloadBytesPerSecond: number | null;
+            uploadBytesPerSecond: number | null;
+            capabilities: {
+                fetch: string;
+                xhr: string;
+                upload: string;
+                webSocket: boolean;
+                nativeImages: boolean;
+                nativeModules: boolean;
+                netInfo: import("../conditions/store").ConnectionSupport;
+                expoNetwork: import("../conditions/store").ConnectionSupport;
+            };
+            scope: {
+                download: string;
+                upload: string;
+                transports: string;
+            };
         };
         events: NetworkEvent[];
         /**
@@ -79,16 +101,8 @@ export declare const networkSyncAdapter: {
     };
     subscribe: (onChange: () => void) => () => void;
     actions: {
-        getNetworkConditions: () => {
-            runtimeId: string;
-            profile: "normal" | "offline" | "slow" | "verySlow";
-            available: boolean;
-        };
-        setNetworkConditions: (params?: unknown) => {
-            runtimeId: string;
-            profile: "normal" | "offline" | "slow" | "verySlow";
-            available: boolean;
-        };
+        getNetworkConditions: typeof getNetworkConditions;
+        setNetworkConditions: typeof setNetworkConditions;
         clearEvents: () => void;
         /**
          * Return the full (un-stripped) request/response bodies for one event,
@@ -101,6 +115,7 @@ export declare const networkSyncAdapter: {
             method: string;
             status: number | null;
             override: import("../types").NetworkOverrideMark | null;
+            condition: import("../..").NetworkConditionStamp | null;
             requestData: {} | null;
             responseData: {} | null;
             requestHeaders: Record<string, string>;

package/lib/typescript/network/utils/networkListener.d.ts

@@ -170,6 +170,10 @@ declare class NetworkListener {
      * in flight are emitted when they finish. The recorder stops recording on
      * the first call, so each request is reported once. See
      * core/src/earlyNetwork.ts for the record shapes.
+     *
+     * The recorder sits on a hidden `Symbol.for("buoy.earlyNetwork")` key. An
+     * older core only sets `__BUOY_EARLY_NETWORK__`, so that name is read as a
+     * fallback. Drop the fallback once no supported core writes only that name.
      */
     adoptEarlyRequests(): void;
     private adoptEarlyFetch;