@dynamic-labs/react-native-extension 4.92.3 → 4.93.0

package/ios/EmbeddedWebViewController.swift

@@ -24,7 +24,6 @@ public final class EmbeddedWebViewController: NSObject {
   private var window: UIWindow?
   private var webView: WKWebView?
   private var debuggingEnabled = false
-  private var hasLoaded = false
   private var pendingNavigationDecisions: [String: (WKNavigationActionPolicy) -> Void] = [:]
   private var navigationTimers: [String: Timer] = [:]
   private var emitterToken: UUID?
@@ -69,10 +68,9 @@ public final class EmbeddedWebViewController: NSObject {
       return
     }
     ensureWebView()
-    hasLoaded = true
     // Pre-approve the origin so the first `decidePolicyFor` call can skip
     // the JS round-trip. On cold boot the JS thread may be too congested to
-    // respond within the 2 s navigation-decision timeout, silently
+    // respond within the navigation-decision timeout, silently
     // cancelling the load.
     preApprovedOrigin = originString(for: parsed)
     webView?.load(URLRequest(url: parsed))
@@ -133,7 +131,6 @@ public final class EmbeddedWebViewController: NSObject {
     pendingNavigationDecisions.removeAll()
     navigationTimers.values.forEach { $0.invalidate() }
     navigationTimers.removeAll()
-    hasLoaded = false
     preApprovedOrigin = nil
   }
 
@@ -349,7 +346,7 @@ extension EmbeddedWebViewController: WKNavigationDelegate {
     // Fast-path: if the URL's origin matches the pre-approved origin (set
     // by `setUrl`), allow immediately. This eliminates the cold-boot race
     // where the JS thread is too congested to respond to
-    // `onShouldStartLoad` within the 2 s navigation-decision timeout.
+    // `onShouldStartLoad` within the navigation-decision timeout.
     if let approved = preApprovedOrigin,
        approved == originString(for: navigationAction.request.url) {
       preApprovedOrigin = nil
@@ -469,10 +466,14 @@ extension EmbeddedWebViewController: WKNavigationDelegate {
       "description": "WebContent process terminated",
       "isProvisional": false,
     ])
+    // The content process is dead — this WKWebView can never load anything
+    // again. Tear it down so the next `setUrl` recreates a fresh webview via
+    // the lazy `ensureWebView` path (mirrors Android's onRenderProcessGone).
+    destroy()
   }
 
   // Errors from cancelling our own navigation (e.g. when the JS allowlist
-  // returns false or the 2 s decision timeout fires) are not real load
+  // returns false or the navigation-decision timeout fires) are not real load
   // failures and should not be instrumented as such.
   private func isCancellationError(_ error: NSError) -> Bool {
     if error.domain == NSURLErrorDomain && error.code == NSURLErrorCancelled {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dynamic-labs/react-native-extension",
-  "version": "4.92.3",
+  "version": "4.93.0",
   "main": "./index.cjs",
   "module": "./index.js",
   "types": "./src/index.d.ts",
@@ -18,11 +18,11 @@
     "@turnkey/react-native-passkey-stamper": "1.2.7",
     "@react-native-documents/picker": "^11.0.0",
     "react-native-fs": ">=2.20.0",
-    "@dynamic-labs/assert-package-version": "4.92.3",
-    "@dynamic-labs/client": "4.92.3",
-    "@dynamic-labs/logger": "4.92.3",
-    "@dynamic-labs/message-transport": "4.92.3",
-    "@dynamic-labs/webview-messages": "4.92.3"
+    "@dynamic-labs/assert-package-version": "4.93.0",
+    "@dynamic-labs/client": "4.93.0",
+    "@dynamic-labs/logger": "4.93.0",
+    "@dynamic-labs/message-transport": "4.93.0",
+    "@dynamic-labs/webview-messages": "4.93.0"
   },
   "peerDependencies": {
     "react": ">=18.0.0 <20.0.0",

package/src/ReactNativeExtension/ReactNativeExtension.d.ts

@@ -1,5 +1,5 @@
 import { FC } from 'react';
-import { Extension } from '@dynamic-labs/client';
+import { Extension, WebViewLoadOptions } from '@dynamic-labs/client';
 import { WebViewProps } from '../components/WebView';
 export type ReactNativeExtensionProps = {
     /**
@@ -46,10 +46,19 @@ export type ReactNativeExtensionProps = {
      * Defaults to false.
      */
     embeddedWebView?: boolean;
+    /**
+     * Customer-tunable budgets of the webview load engine (how long each
+     * load attempt may take and how long the SDK inside the webview may take
+     * to become ready). Applies to both webview paths. When a budget is
+     * exhausted on the final attempt, the SDK raises
+     * `WebViewFailedToLoadError`. See `WebViewLoadOptions` for the per-field
+     * documentation and defaults. Only tune this for pathological networks.
+     */
+    webviewLoad?: WebViewLoadOptions;
 };
 export type IReactNativeExtension = {
     reactNative: {
         WebView: FC<WebViewProps> | (() => null);
     };
 };
-export declare const ReactNativeExtension: ({ webviewUrl, webviewDebuggingEnabled, appOrigin, embeddedWebView, }?: ReactNativeExtensionProps) => Extension<IReactNativeExtension>;
+export declare const ReactNativeExtension: ({ webviewUrl, webviewDebuggingEnabled, appOrigin, embeddedWebView, webviewLoad, }?: ReactNativeExtensionProps) => Extension<IReactNativeExtension>;

package/src/components/WebView/EmbeddedWebView/EmbeddedWebView.d.ts

@@ -1,26 +1,13 @@
-import { Core } from '@dynamic-labs/client';
+import { Core, WebViewLoadOptions } from '@dynamic-labs/client';
 export type SetupEmbeddedWebViewArgs = {
     webviewUrl: string;
     core: Core;
     webviewDebuggingEnabled?: boolean;
     /**
-     * Max time (ms) between the native webview reporting it has started a
-     * navigation (`onLoadStart`) and reporting that the response committed
-     * (`onLoad`). If this elapses, the SDK raises
-     * {@link WebViewFailedToLoadError} with `phase: 'html_load'` so the page
-     * can no longer hang silently waiting for bytes that never arrive.
-     *
-     * Defaults to 20s, matching the RN `<WebView>` path.
+     * Customer-tunable budgets of the webview load engine. Forwarded
+     * verbatim to `createWebViewLoadController`, which owns the defaults.
+     * See `WebViewLoadOptions` for the per-field documentation.
      */
-    loadingTimeoutMs?: number;
-    /**
-     * Max time (ms) between the native webview reporting it has finished
-     * loading (`onLoadEnd`) and the SDK signalling it has finished booting
-     * (`sdkHasLoadedEventName`). If this elapses, the SDK raises
-     * {@link WebViewFailedToLoadError} with `phase: 'sdk_bootstrap'`.
-     *
-     * Defaults to 20s, matching the RN `<WebView>` path.
-     */
-    recoveryTimeoutMs?: number;
+    webviewLoad?: WebViewLoadOptions;
 };
-export declare const setupEmbeddedWebView: ({ webviewUrl, core, webviewDebuggingEnabled, loadingTimeoutMs, recoveryTimeoutMs, }: SetupEmbeddedWebViewArgs) => (() => void);
+export declare const setupEmbeddedWebView: ({ webviewUrl, core, webviewDebuggingEnabled, webviewLoad, }: SetupEmbeddedWebViewArgs) => (() => void);

package/src/components/WebView/WebView.d.ts

@@ -1,18 +1,22 @@
 import { FC } from 'react';
-import { Core } from '@dynamic-labs/client';
+import { Core, WebViewLoadOptions } from '@dynamic-labs/client';
 export type WebViewProps = {
     /**
-     * Disable the webview recovery
+     * @deprecated No-op, accepted only for backwards compatibility. Webview
+     * load recovery is owned by the shared webview load controller (bounded
+     * retries with backoff) and is always on — it can no longer be disabled.
      */
     disableRecovery?: boolean;
     /**
-     * The timeout between the page loaded event and the SDK
-     * has loaded event
+     * @deprecated Configure `webviewLoad.sdkReadyTimeoutMs` on
+     * `ReactNativeExtension` instead. Still honored; an explicit value here
+     * overrides the extension setting.
      */
     recoveryTimeout?: number;
     /**
-     * The timeout between the webview page load start event and the
-     * page html and assets finishes loading
+     * @deprecated Configure `webviewLoad.pageLoadTimeoutMs` on
+     * `ReactNativeExtension` instead. Still honored; an explicit value here
+     * overrides the extension setting.
      */
     loadingTimeout?: number;
 };
@@ -20,6 +24,13 @@ type WebViewInternalProps = WebViewProps & {
     webviewUrl: string;
     core: Core;
     webviewDebuggingEnabled?: boolean;
+    /**
+     * Customer-tunable budgets of the webview load engine, as configured on
+     * `ReactNativeExtension`. Forwarded to `createWebViewLoadController`;
+     * the deprecated `loadingTimeout` / `recoveryTimeout` JSX props override
+     * the two timeout fields when set explicitly.
+     */
+    webviewLoad?: WebViewLoadOptions;
 };
 export declare const WebView: FC<WebViewInternalProps>;
 export declare const createWebView: (internalProps: WebViewInternalProps) => FC<WebViewProps>;

package/src/errors/WebViewFailedToLoadError.d.ts

@@ -1,86 +1 @@
-/**
- * Categorical phase the WebView was in when the failure was raised.
- *
- * Use this for high-level grouping; the duration fields on
- * {@link WebViewFailedToLoadErrorMeta} give the granular timing data.
- */
-export type WebViewFailedToLoadErrorPhase = 'html_load' | 'sdk_bootstrap' | 'after_clear_state' | 'native_error' | 'embedded_native_error' | 'unknown';
-/**
- * Structured context attached to {@link WebViewFailedToLoadError} so the
- * resulting error log carries enough information to tell *which* step the
- * WebView was stuck in when the failure was raised, and how long each step
- * took.
- *
- * The setter on `InitializationModule.error` forwards this object directly
- * to `logger.error`, so every field below ends up as a structured field on
- * the same Datadog log as the error message.
- */
-export type WebViewFailedToLoadErrorMeta = {
-    phase: WebViewFailedToLoadErrorPhase;
-    /**
-     * Milliseconds between RN's `onLoadStart` and `onLoad` callbacks (the
-     * HTML + asset fetch). `null` if `onLoad` never fired.
-     */
-    htmlLoadMs: number | null;
-    /**
-     * Milliseconds between RN's `onLoad` and `onLoadEnd` callbacks. Usually
-     * small; mostly there to flag pathological cases. `null` if `onLoadEnd`
-     * never fired.
-     */
-    onLoadToOnLoadEndMs: number | null;
-    /**
-     * Milliseconds between `onLoadEnd` and the first `manifest` request
-     * received from the webview-side SDK. Proxy for "the JS bundle is alive
-     * and the message bridge works". `null` if the manifest request never
-     * arrived.
-     */
-    manifestReceivedMs: number | null;
-    /**
-     * Milliseconds between `onLoadEnd` and the webview-side SDK signalling
-     * it has finished initialising (via the `sdkHasLoadedEventName` store
-     * change). `null` if the SDK never signalled it was ready.
-     */
-    sdkReadyMs: number | null;
-    /**
-     * Number of `retry` increments in the WebView URL at the time of failure
-     * (covers OS-kill reloads, load_error reloads, and recovery reloads).
-     */
-    retryCount: number;
-    /**
-     * Whether the `clear-state` query parameter was present in the URL when
-     * the failure was raised. `true` indicates we already retried with a
-     * clean state and still couldn't finish loading.
-     */
-    hadClearState: boolean;
-    /**
-     * Number of times RN's `onError` fired across the lifetime of the
-     * WebView component instance.
-     */
-    nativeErrorCount: number;
-    /**
-     * Number of times the OS killed the WebView process (via
-     * `onContentProcessDidTerminate` on iOS or `onRenderProcessGone` on
-     * Android) across the lifetime of the WebView component instance.
-     */
-    osKillCount: number;
-    /** The configured value for `loadingTimeout` (ms). */
-    loadingTimeoutMs: number;
-    /** The configured value for `recoveryTimeout` (ms). */
-    recoveryTimeoutMs: number;
-    /** The URL the WebView was attempting to load when the failure occurred. */
-    webviewUrl?: string;
-    /**
-     * Native error info, only populated when the failure originated from the
-     * embedded native WebView path (iOS WKWebView / Android WebView), where
-     * we get a single `onLoadError` event with these fields.
-     */
-    nativeErrorCode?: number;
-    nativeErrorDescription?: string;
-    nativeErrorDomain?: string;
-    nativeErrorIsProvisional?: boolean;
-    nativeErrorFailedUrl?: string;
-};
-export declare class WebViewFailedToLoadError extends Error {
-    readonly meta?: WebViewFailedToLoadErrorMeta;
-    constructor(meta?: WebViewFailedToLoadErrorMeta);
-}
+export { WebViewFailedToLoadError, type WebViewFailedToLoadErrorMeta, type WebViewFailedToLoadErrorPhase, type WebViewLoadAttemptFailure, } from '@dynamic-labs/client';

package/src/components/WebView/EmbeddedWebView/embeddedWebViewPhaseTimers/embeddedWebViewPhaseTimers.d.ts

@@ -1,66 +0,0 @@
-import { Core } from '@dynamic-labs/client';
-import { WebViewFailedToLoadErrorMeta, WebViewFailedToLoadErrorPhase } from '../../../../errors/WebViewFailedToLoadError';
-import { WebViewLoadSuccessMeta, WebViewPhaseEvent } from '../../webViewPhaseTimerCore';
-/**
- * Path-agnostic success-log meta. Re-exported here for callsite
- * ergonomics so `setupEmbeddedWebView` doesn't need to reach into
- * `webViewPhaseTimerCore` directly.
- */
-export type EmbeddedWebViewLoadSuccessMeta = WebViewLoadSuccessMeta;
-/**
- * Re-exported for callsite ergonomics: lets `setupEmbeddedWebView` import
- * a single `EmbeddedWebViewPhaseEvent` type rather than reach into
- * `webViewPhaseTimerCore` directly.
- */
-export type EmbeddedWebViewPhaseEvent = WebViewPhaseEvent;
-type EmbeddedWebViewPhaseTimersProps = {
-    core: Core;
-    loadingTimeoutMs: number;
-    recoveryTimeoutMs: number;
-    webViewUrl: URL;
-};
-export type EmbeddedWebViewPhaseTimers = {
-    /**
-     * Detach from the message transport. Call this on teardown so the
-     * embedded webview controller can be re-created without leaking
-     * subscriptions.
-     */
-    dispose: () => void;
-    /**
-     * Build the structured meta to attach to
-     * {@link WebViewFailedToLoadError}. The `phase` argument reflects the
-     * source of the failure; the duration fields come from the recorded
-     * lifecycle events and observed message-transport activity.
-     */
-    getMeta: (args: {
-        phase: WebViewFailedToLoadErrorPhase;
-    }) => WebViewFailedToLoadErrorMeta;
-    /**
-     * Build the structured meta to attach to the `webview.load_succeeded`
-     * instrumentation log. Same timing fields as {@link getMeta} but without
-     * the failure-specific `phase` discriminator.
-     */
-    getSuccessMeta: () => EmbeddedWebViewLoadSuccessMeta;
-    /**
-     * Record a per-attempt lifecycle event. See {@link WebViewPhaseEvent}
-     * for the semantics of each event.
-     */
-    recordEvent: (event: EmbeddedWebViewPhaseEvent) => void;
-};
-/**
- * Non-React equivalent of `useWebViewPhaseTimers` for the embedded native
- * webview path. The embedded path is a singleton wired by
- * `setupEmbeddedWebView` (not a React component), so we expose the same
- * phase-timing surface as a plain factory.
- *
- * Both this factory and the hook delegate the actual state machine to
- * {@link createWebViewPhaseTimerCore}; the only path-specific bits are:
- *
- * - `hadClearState` is always `false` (embedded path has no clear-state
- *   recovery model — that's exclusive to the React `<WebView>` path's
- *   loading-timeout recovery flow)
- * - `retryCount` is always `0` (embedded path has no retry counter URL
- *   query param either)
- */
-export declare const createEmbeddedWebViewPhaseTimers: ({ core, loadingTimeoutMs, recoveryTimeoutMs, webViewUrl, }: EmbeddedWebViewPhaseTimersProps) => EmbeddedWebViewPhaseTimers;
-export {};

package/src/components/WebView/EmbeddedWebView/embeddedWebViewPhaseTimers/index.d.ts

@@ -1 +0,0 @@
-export { createEmbeddedWebViewPhaseTimers, type EmbeddedWebViewPhaseEvent, type EmbeddedWebViewPhaseTimers, } from './embeddedWebViewPhaseTimers';

package/src/components/WebView/constants.d.ts

@@ -1,3 +0,0 @@
-export declare const CLEAR_STATE_PARAM = "clear-state";
-export declare const ENVIRONMENT_ID_PARAM = "environmentId";
-export declare const WEBVIEW_START_TIME_PARAM = "webviewStartTime";

package/src/components/WebView/successLog/emitSuccessLog.d.ts

@@ -1,35 +0,0 @@
-import { Core } from '@dynamic-labs/client';
-import { SuccessLogCooldown } from './successLogCooldown';
-export declare const SUCCESS_LOG_KEY = "webview.load_succeeded";
-type SuccessLogMeta = Record<string, unknown>;
-type EmitSuccessLogArgs<Meta extends SuccessLogMeta> = {
-    /**
-     * Device-local cooldown gate. If `shouldEmit` returns false the log
-     * is suppressed; on emit, the cooldown is recorded immediately so a
-     * crash between emit and `recordEmitted` doesn't replay the log.
-     */
-    cooldown: SuccessLogCooldown;
-    core: Core;
-    /**
-     * Late-bound meta builder. We call this only after the cooldown
-     * passes so paths that maintain expensive snapshots don't pay the
-     * cost when they're going to be suppressed.
-     */
-    getMeta: () => Meta;
-    /**
-     * Short identifier describing the path. Appears in the log message
-     * (`<name> loaded successfully`) so the two streams are
-     * distinguishable in Datadog without a per-path `key` field.
-     */
-    name: string;
-};
-/**
- * Shared emission pattern for the `webview.load_succeeded`
- * instrumentation log. Both the RN `<WebView>` and the embedded
- * WebView fire the same event with the same payload shape after
- * checking the same cooldown gate — this helper centralises that
- * sequence so the two call sites stay aligned and any future field we
- * add to the success log lands in both places automatically.
- */
-export declare const emitSuccessLog: <Meta extends SuccessLogMeta>({ cooldown, core, getMeta, name, }: EmitSuccessLogArgs<Meta>) => Promise<void>;
-export {};

package/src/components/WebView/successLog/index.d.ts

@@ -1,3 +0,0 @@
-export { emitSuccessLog, SUCCESS_LOG_KEY } from './emitSuccessLog';
-export { createSuccessLogCooldown, SUCCESS_LOG_COOLDOWN_MS, } from './successLogCooldown';
-export type { SuccessLogCooldown } from './successLogCooldown';

package/src/components/WebView/useWebViewLoadingTimeout/index.d.ts

@@ -1 +0,0 @@
-export { useWebViewLoadingTimeout } from './useWebViewLoadingTimeout';

package/src/components/WebView/useWebViewLoadingTimeout/useWebViewLoadingTimeout.d.ts

@@ -1,4 +0,0 @@
-export declare const useWebViewLoadingTimeout: (timeout: number, onTimeout: () => void) => {
-    onLoad: () => void;
-    onLoadStart: () => void;
-};

package/src/components/WebView/useWebViewPhaseTimers/index.d.ts

@@ -1 +0,0 @@
-export { useWebViewPhaseTimers, type WebViewPhaseTimers, } from './useWebViewPhaseTimers';

package/src/components/WebView/useWebViewPhaseTimers/useWebViewPhaseTimers.d.ts

@@ -1,46 +0,0 @@
-import { Core } from '@dynamic-labs/client';
-import { WebViewFailedToLoadErrorMeta, WebViewFailedToLoadErrorPhase } from '../../../errors/WebViewFailedToLoadError';
-import { WebViewLoadSuccessMeta, WebViewPhaseEvent } from '../webViewPhaseTimerCore';
-export type { WebViewLoadSuccessMeta };
-type UseWebViewPhaseTimersProps = {
-    core: Core;
-    loadingTimeout: number;
-    recoveryTimeout: number;
-    webViewUrl: URL;
-};
-export type WebViewPhaseTimers = {
-    /**
-     * Build the structured meta to attach to {@link WebViewFailedToLoadError}.
-     * Pass `phase` explicitly from the callsite (the phase reflects the
-     * source of the failure, not just the current timing state).
-     */
-    getMeta: (args: {
-        phase: WebViewFailedToLoadErrorPhase;
-    }) => WebViewFailedToLoadErrorMeta;
-    /**
-     * Build the structured meta to attach to the `webview.load_succeeded`
-     * instrumentation log. Same timing fields as {@link getMeta} but without
-     * the failure-specific `phase` discriminator.
-     */
-    getSuccessMeta: () => WebViewLoadSuccessMeta;
-    /**
-     * Record a per-attempt lifecycle event. See {@link WebViewPhaseEvent}
-     * for the semantics of each event.
-     */
-    recordEvent: (event: WebViewPhaseEvent) => void;
-};
-/**
- * Tracks how long each step of the WebView load took, so when we raise
- * `WebViewFailedToLoadError` we can attach the timings to the error log.
- *
- * The timings cover the host-side phases of the load — the webview-side
- * timings (`webview.time_to_load_manifest`, `webview.time_to_sdk_ready`)
- * still come from the webview itself once it boots, but those don't help
- * when the webview never boots in the first place.
- *
- * The actual state machine lives in {@link createWebViewPhaseTimerCore},
- * which is also reused by the embedded native WebView path. This hook
- * only layers the React-specific bits (ref-based core lifetime tied to
- * `useEffect`, URL-derived `hadClearState` / `retryCount`).
- */
-export declare const useWebViewPhaseTimers: ({ core, loadingTimeout, recoveryTimeout, webViewUrl, }: UseWebViewPhaseTimersProps) => WebViewPhaseTimers;

package/src/components/WebView/useWebViewRecoveryTimeout/index.d.ts

@@ -1 +0,0 @@
-export { useWebViewRecoveryTimeout } from './useWebViewRecoveryTimeout';

package/src/components/WebView/useWebViewRecoveryTimeout/useWebViewRecoveryTimeout.d.ts

@@ -1,12 +0,0 @@
-import { Dispatch, SetStateAction } from 'react';
-import { Core } from '@dynamic-labs/client';
-type UseWebViewRecoveryTimeoutProps = {
-    core: Core;
-    webViewUrl: URL;
-    disableRecovery: boolean;
-    recoveryTimeout: number;
-    setWebViewUrl: Dispatch<SetStateAction<URL>>;
-    onFailedToLoadAfterClearState?: () => void;
-};
-export declare const useWebViewRecoveryTimeout: ({ core, webViewUrl, disableRecovery, recoveryTimeout, setWebViewUrl, onFailedToLoadAfterClearState, }: UseWebViewRecoveryTimeoutProps) => () => void;
-export {};

package/src/components/WebView/useWebViewSuccessLog/index.d.ts

@@ -1 +0,0 @@
-export { useWebViewSuccessLog } from './useWebViewSuccessLog';

package/src/components/WebView/useWebViewSuccessLog/useWebViewSuccessLog.d.ts

@@ -1,28 +0,0 @@
-import { Core } from '@dynamic-labs/client';
-import { WebViewLoadSuccessMeta } from '../useWebViewPhaseTimers/useWebViewPhaseTimers';
-type UseWebViewSuccessLogProps = {
-    core: Core;
-    getSuccessMeta: () => WebViewLoadSuccessMeta;
-};
-/**
- * Emit a `webview.load_succeeded` instrumentation log the first time
- * the SDK signals it's ready, gated by a device-local 1h cooldown so a
- * customer with many WebView mounts (or many app launches) doesn't spam
- * the logs pipeline.
- *
- * The error path is unaffected: failures keep going through
- * `logger.error(WebViewFailedToLoadError, meta)` with no cooldown.
- *
- * The hook intentionally fires only once per mount (`hasEmittedRef`):
- * after a successful boot we don't expect another `sdkHasLoaded` for
- * the same WebView lifetime, and emitting twice for the same load would
- * be misleading.
- *
- * Cooldown gating + log emission are delegated to the shared
- * `successLog` helpers so this hook and the embedded native WebView
- * path stay in lockstep on payload shape and storage semantics; the
- * dedicated storage key here keeps the RN-path cooldown independent
- * from the embedded path's.
- */
-export declare const useWebViewSuccessLog: ({ core, getSuccessMeta, }: UseWebViewSuccessLogProps) => void;
-export {};

package/src/components/WebView/utils/assignEnvironmentIdToUrl/assignEnvironmentIdToUrl.d.ts

@@ -1 +0,0 @@
-export declare const assignEnvironmentIdToUrl: (url: string, environmentId: string) => URL;

package/src/components/WebView/utils/assignEnvironmentIdToUrl/index.d.ts

@@ -1 +0,0 @@
-export { assignEnvironmentIdToUrl } from './assignEnvironmentIdToUrl';

package/src/components/WebView/utils/assignStartTimeToUrl/assignStartTimeToUrl.d.ts

@@ -1 +0,0 @@
-export declare const assignStartTimeToUrl: (url: URL) => URL;

package/src/components/WebView/utils/assignStartTimeToUrl/index.d.ts

@@ -1 +0,0 @@
-export { assignStartTimeToUrl } from './assignStartTimeToUrl';

package/src/components/WebView/utils/hasClearStateInUrl/hasClearStateInUrl.d.ts

@@ -1 +0,0 @@
-export declare const hasClearStateInUrl: (webViewUrl: URL) => boolean;

package/src/components/WebView/utils/hasClearStateInUrl/index.d.ts

@@ -1 +0,0 @@
-export { hasClearStateInUrl } from './hasClearStateInUrl';

package/src/components/WebView/utils/increaseRetryToUrl/increaseRetryToUrl.d.ts

@@ -1 +0,0 @@
-export declare const increaseRetryToUrl: (webViewUrl: URL) => URL;

package/src/components/WebView/utils/increaseRetryToUrl/index.d.ts

@@ -1 +0,0 @@
-export { increaseRetryToUrl } from './increaseRetryToUrl';

package/src/components/WebView/utils/setClearStateToUrl/index.d.ts

@@ -1 +0,0 @@
-export { setClearStateToUrl } from './setClearStateToUrl';

package/src/components/WebView/utils/setClearStateToUrl/setClearStateToUrl.d.ts

@@ -1 +0,0 @@
-export declare const setClearStateToUrl: (webViewUrl: URL) => URL;

package/src/components/WebView/webViewPhaseTimerCore/index.d.ts

@@ -1,2 +0,0 @@
-export { buildSuccessMeta, computePhaseDurations, createWebViewPhaseTimerCore, } from './webViewPhaseTimerCore';
-export type { CumulativeCounters, PerAttemptTimings, PhaseDurations, WebViewLoadSuccessMeta, WebViewPhaseEvent, WebViewPhaseTimerCore, } from './webViewPhaseTimerCore';