@capgo/capacitor-webview-crash 7.1.0

package/android/src/main/java/app/capgo/webviewcrash/WebViewCrashPlugin.java

@@ -0,0 +1,185 @@
+package app.capgo.webviewcrash;
+
+import android.os.Handler;
+import android.os.Looper;
+import android.webkit.RenderProcessGoneDetail;
+import android.webkit.WebView;
+import androidx.appcompat.app.AppCompatActivity;
+import com.getcapacitor.JSObject;
+import com.getcapacitor.Plugin;
+import com.getcapacitor.PluginCall;
+import com.getcapacitor.PluginMethod;
+import com.getcapacitor.WebViewListener;
+import com.getcapacitor.annotation.CapacitorPlugin;
+import java.util.HashSet;
+import java.util.Set;
+
+@CapacitorPlugin(name = "WebViewCrash")
+public class WebViewCrashPlugin extends Plugin {
+
+    private final WebViewCrash implementation = new WebViewCrash();
+    private final Set<String> dispatchedPendingEvents = new HashSet<>();
+    private WebViewCrash.RestartOptions restartOptions = new WebViewCrash.RestartOptions(true, 0, null, 0);
+    private Handler mainHandler;
+
+    private final Runnable periodicRestartRunnable = () -> {
+        WebView webView = bridge != null ? bridge.getWebView() : null;
+        String url = webView != null ? webView.getUrl() : null;
+        JSObject restartInfo = implementation.buildCrashInfo(WebViewCrash.PERIODIC_RESTART_REASON, url, null, null);
+
+        implementation.writePendingCrashInfo(getContext(), restartInfo);
+        dispatchedPendingEvents.clear();
+        restartWebView(0);
+    };
+
+    private final WebViewListener webViewListener = new WebViewListener() {
+        @Override
+        public boolean onRenderProcessGone(WebView webView, RenderProcessGoneDetail detail) {
+            JSObject crashInfo = implementation.buildCrashInfo(
+                "renderProcessGone",
+                webView.getUrl(),
+                detail.didCrash(),
+                detail.rendererPriorityAtExit()
+            );
+
+            implementation.writePendingCrashInfo(getContext(), crashInfo);
+            dispatchedPendingEvents.clear();
+
+            if (!restartOptions.restartOnCrash) {
+                return false;
+            }
+
+            restartWebView(restartOptions.restartAfterCrashDelayMs);
+            return true;
+        }
+    };
+
+    @Override
+    public void load() {
+        restartOptions = implementation.readRestartOptions(getConfig());
+        bridge.addWebViewListener(webViewListener);
+        schedulePeriodicRestart();
+    }
+
+    @Override
+    protected void handleOnDestroy() {
+        bridge.removeWebViewListener(webViewListener);
+        cancelPeriodicRestart();
+    }
+
+    @Override
+    public void addListener(PluginCall call) {
+        super.addListener(call);
+
+        String eventName = call.getString("eventName");
+        if (WebViewCrash.CRASH_EVENT_NAME.equals(eventName) || WebViewCrash.RESTART_EVENT_NAME.equals(eventName)) {
+            dispatchPendingCrashIfNeeded(eventName);
+        }
+    }
+
+    @PluginMethod
+    public void getPendingCrashInfo(PluginCall call) {
+        JSObject result = new JSObject();
+        result.put("value", implementation.readPendingCrashInfo(getContext()));
+        call.resolve(result);
+    }
+
+    @PluginMethod
+    public void clearPendingCrashInfo(PluginCall call) {
+        implementation.clearPendingCrashInfo(getContext());
+        dispatchedPendingEvents.clear();
+        call.resolve();
+    }
+
+    @PluginMethod
+    public void simulateCrashRecovery(PluginCall call) {
+        String url = bridge.getWebView() != null ? bridge.getWebView().getUrl() : null;
+        JSObject crashInfo = implementation.buildCrashInfo("simulated", url, null, null);
+
+        implementation.writePendingCrashInfo(getContext(), crashInfo);
+        dispatchedPendingEvents.clear();
+        dispatchPendingCrashIfNeeded(WebViewCrash.CRASH_EVENT_NAME);
+        dispatchPendingCrashIfNeeded(WebViewCrash.RESTART_EVENT_NAME);
+
+        JSObject result = new JSObject();
+        result.put("value", crashInfo);
+        call.resolve(result);
+    }
+
+    @PluginMethod
+    public void restartWebView(PluginCall call) {
+        WebView webView = bridge != null ? bridge.getWebView() : null;
+        String url = webView != null ? webView.getUrl() : null;
+        JSObject restartInfo = implementation.buildCrashInfo(WebViewCrash.MANUAL_RESTART_REASON, url, null, null);
+
+        implementation.writePendingCrashInfo(getContext(), restartInfo);
+        dispatchedPendingEvents.clear();
+
+        JSObject result = new JSObject();
+        result.put("value", restartInfo);
+        call.resolve(result);
+
+        restartWebView(0);
+    }
+
+    private void dispatchPendingCrashIfNeeded(String eventName) {
+        if (dispatchedPendingEvents.contains(eventName)) {
+            return;
+        }
+
+        JSObject crashInfo = implementation.readPendingCrashInfo(getContext());
+        if (crashInfo == null || !implementation.shouldDispatchEvent(eventName, crashInfo)) {
+            return;
+        }
+
+        dispatchedPendingEvents.add(eventName);
+        notifyListeners(eventName, crashInfo);
+    }
+
+    private void schedulePeriodicRestart() {
+        cancelPeriodicRestart();
+        Long delayMs = restartOptions.nextRestartDelayMs();
+        if (delayMs == null || delayMs <= 0) {
+            return;
+        }
+
+        getMainHandler().postDelayed(periodicRestartRunnable, delayMs);
+    }
+
+    private void cancelPeriodicRestart() {
+        if (mainHandler != null) {
+            mainHandler.removeCallbacks(periodicRestartRunnable);
+        }
+    }
+
+    private void restartWebView(int delayMs) {
+        Runnable restart = () -> {
+            AppCompatActivity currentActivity = getActivity();
+            if (currentActivity == null) {
+                schedulePeriodicRestart();
+                return;
+            }
+
+            currentActivity.runOnUiThread(() -> {
+                if (bridge != null) {
+                    bridge.reset();
+                }
+                currentActivity.recreate();
+            });
+        };
+
+        if (delayMs > 0) {
+            getMainHandler().postDelayed(restart, delayMs);
+        } else {
+            getMainHandler().post(restart);
+        }
+    }
+
+    private Handler getMainHandler() {
+        if (mainHandler == null) {
+            mainHandler = new Handler(Looper.getMainLooper());
+        }
+
+        return mainHandler;
+    }
+}

package/dist/docs.json

@@ -0,0 +1,271 @@
+{
+  "api": {
+    "name": "WebViewCrashPlugin",
+    "slug": "webviewcrashplugin",
+    "docs": "Capacitor API for recovered WebView crash and restart detection.",
+    "tags": [],
+    "methods": [
+      {
+        "name": "getPendingCrashInfo",
+        "signature": "() => Promise<PendingCrashInfoResult>",
+        "parameters": [],
+        "returns": "Promise<PendingCrashInfoResult>",
+        "tags": [],
+        "docs": "Returns the pending native crash or restart marker, if one exists.",
+        "complexTypes": [
+          "PendingCrashInfoResult"
+        ],
+        "slug": "getpendingcrashinfo"
+      },
+      {
+        "name": "clearPendingCrashInfo",
+        "signature": "() => Promise<void>",
+        "parameters": [],
+        "returns": "Promise<void>",
+        "tags": [],
+        "docs": "Clears the stored marker after the app has handled recovery.",
+        "complexTypes": [],
+        "slug": "clearpendingcrashinfo"
+      },
+      {
+        "name": "simulateCrashRecovery",
+        "signature": "() => Promise<PendingCrashInfoResult>",
+        "parameters": [],
+        "returns": "Promise<PendingCrashInfoResult>",
+        "tags": [],
+        "docs": "Creates a fake crash marker so recovery flows can be tested locally.",
+        "complexTypes": [
+          "PendingCrashInfoResult"
+        ],
+        "slug": "simulatecrashrecovery"
+      },
+      {
+        "name": "restartWebView",
+        "signature": "() => Promise<PendingCrashInfoResult>",
+        "parameters": [],
+        "returns": "Promise<PendingCrashInfoResult>",
+        "tags": [],
+        "docs": "Stores a manual restart marker and asks native code to create a fresh WebView.\n\nOn Android this recreates the host Activity. On iOS this rebuilds the Capacitor bridge view so a new `WKWebView`\ninstance is created instead of reloading the current page.",
+        "complexTypes": [
+          "PendingCrashInfoResult"
+        ],
+        "slug": "restartwebview"
+      },
+      {
+        "name": "addListener",
+        "signature": "(eventName: 'webViewRestoredAfterCrash' | 'webViewRestoredAfterRestart', listenerFunc: (info: WebViewCrashInfo) => void) => Promise<PluginListenerHandle>",
+        "parameters": [
+          {
+            "name": "eventName",
+            "docs": "",
+            "type": "'webViewRestoredAfterCrash' | 'webViewRestoredAfterRestart'"
+          },
+          {
+            "name": "listenerFunc",
+            "docs": "",
+            "type": "(info: WebViewCrashInfo) => void"
+          }
+        ],
+        "returns": "Promise<PluginListenerHandle>",
+        "tags": [],
+        "docs": "Fires after a new JavaScript runtime attaches a listener and a matching marker is still pending.",
+        "complexTypes": [
+          "PluginListenerHandle",
+          "WebViewCrashInfo"
+        ],
+        "slug": "addlistenerwebviewrestoredaftercrash--webviewrestoredafterrestart-"
+      },
+      {
+        "name": "removeAllListeners",
+        "signature": "() => Promise<void>",
+        "parameters": [],
+        "returns": "Promise<void>",
+        "tags": [],
+        "docs": "Removes all plugin listeners.",
+        "complexTypes": [],
+        "slug": "removealllisteners"
+      }
+    ],
+    "properties": []
+  },
+  "interfaces": [
+    {
+      "name": "PendingCrashInfoResult",
+      "slug": "pendingcrashinforesult",
+      "docs": "Pending crash or restart marker returned to JavaScript.",
+      "tags": [],
+      "methods": [],
+      "properties": [
+        {
+          "name": "value",
+          "tags": [],
+          "docs": "Stored crash or restart metadata, or `null` when no marker is pending.",
+          "complexTypes": [
+            "WebViewCrashInfo"
+          ],
+          "type": "WebViewCrashInfo | null"
+        }
+      ]
+    },
+    {
+      "name": "WebViewCrashInfo",
+      "slug": "webviewcrashinfo",
+      "docs": "Metadata captured natively after the previous WebView process died or was restarted.",
+      "tags": [],
+      "methods": [],
+      "properties": [
+        {
+          "name": "platform",
+          "tags": [],
+          "docs": "Platform that detected and stored the marker.",
+          "complexTypes": [
+            "WebViewCrashPlatform"
+          ],
+          "type": "WebViewCrashPlatform"
+        },
+        {
+          "name": "timestamp",
+          "tags": [],
+          "docs": "Unix timestamp in milliseconds for when the marker was written.",
+          "complexTypes": [],
+          "type": "number"
+        },
+        {
+          "name": "timestampISO",
+          "tags": [],
+          "docs": "ISO-8601 version of `timestamp`.",
+          "complexTypes": [],
+          "type": "string"
+        },
+        {
+          "name": "reason",
+          "tags": [],
+          "docs": "Platform-specific reason for the crash or restart marker.",
+          "complexTypes": [
+            "WebViewCrashReason"
+          ],
+          "type": "WebViewCrashReason"
+        },
+        {
+          "name": "url",
+          "tags": [],
+          "docs": "Last known WebView URL when the marker was written.",
+          "complexTypes": [],
+          "type": "string | undefined"
+        },
+        {
+          "name": "didCrash",
+          "tags": [],
+          "docs": "Android-only hint from `RenderProcessGoneDetail.didCrash()`.",
+          "complexTypes": [],
+          "type": "boolean | undefined"
+        },
+        {
+          "name": "rendererPriorityAtExit",
+          "tags": [],
+          "docs": "Android-only renderer priority reported at exit.",
+          "complexTypes": [],
+          "type": "number | undefined"
+        },
+        {
+          "name": "appState",
+          "tags": [],
+          "docs": "iOS-only application state captured when the marker was written.",
+          "complexTypes": [
+            "WebViewCrashAppState"
+          ],
+          "type": "WebViewCrashAppState"
+        }
+      ]
+    },
+    {
+      "name": "PluginListenerHandle",
+      "slug": "pluginlistenerhandle",
+      "docs": "",
+      "tags": [],
+      "methods": [],
+      "properties": [
+        {
+          "name": "remove",
+          "tags": [],
+          "docs": "",
+          "complexTypes": [],
+          "type": "() => Promise<void>"
+        }
+      ]
+    }
+  ],
+  "enums": [],
+  "typeAliases": [
+    {
+      "name": "WebViewCrashPlatform",
+      "slug": "webviewcrashplatform",
+      "docs": "Platform that produced the stored marker.",
+      "types": [
+        {
+          "text": "'android'",
+          "complexTypes": []
+        },
+        {
+          "text": "'ios'",
+          "complexTypes": []
+        },
+        {
+          "text": "'web'",
+          "complexTypes": []
+        }
+      ]
+    },
+    {
+      "name": "WebViewCrashReason",
+      "slug": "webviewcrashreason",
+      "docs": "Native reason reported for the previous WebView failure or restart.",
+      "types": [
+        {
+          "text": "'renderProcessGone'",
+          "complexTypes": []
+        },
+        {
+          "text": "'webContentProcessDidTerminate'",
+          "complexTypes": []
+        },
+        {
+          "text": "'periodicRestart'",
+          "complexTypes": []
+        },
+        {
+          "text": "'manualRestart'",
+          "complexTypes": []
+        },
+        {
+          "text": "'simulated'",
+          "complexTypes": []
+        }
+      ]
+    },
+    {
+      "name": "WebViewCrashAppState",
+      "slug": "webviewcrashappstate",
+      "docs": "Best-effort application state captured on iOS when the WebView process died.",
+      "types": [
+        {
+          "text": "'active'",
+          "complexTypes": []
+        },
+        {
+          "text": "'inactive'",
+          "complexTypes": []
+        },
+        {
+          "text": "'background'",
+          "complexTypes": []
+        },
+        {
+          "text": "'unknown'",
+          "complexTypes": []
+        }
+      ]
+    }
+  ],
+  "pluginConfigs": []
+}

package/dist/esm/definitions.d.ts

@@ -0,0 +1,139 @@
+import type { PluginListenerHandle } from '@capacitor/core';
+declare module '@capacitor/cli' {
+    interface PluginsConfig {
+        /**
+         * Configure native WebView restart behavior for `@capgo/capacitor-webview-crash`.
+         */
+        WebViewCrash?: WebViewCrashPluginConfig;
+    }
+}
+/**
+ * Native WebView restart behavior configured in `capacitor.config.ts`.
+ */
+export interface WebViewCrashPluginConfig {
+    /**
+     * Restart the WebView from native code when the renderer process dies.
+     *
+     * @default true
+     */
+    restartOnCrash?: boolean;
+    /**
+     * Fixed native interval, in milliseconds, for proactively replacing long-running WebViews.
+     *
+     * Set to `0` to disable interval restarts. Do not combine an active interval
+     * with `restartCron`; native initialization fails fast when both schedules are configured.
+     *
+     * @default 0
+     */
+    restartIntervalMs?: number;
+    /**
+     * Cron schedule for proactively replacing long-running WebViews.
+     *
+     * Uses standard 5-field cron syntax in the device local timezone:
+     * `minute hour day-of-month month day-of-week`.
+     *
+     * Examples:
+     * - `0 3 * * *` restarts every day at 03:00.
+     * - `0,30 * * * *` restarts every 30 minutes.
+     *
+     * Do not combine this with an active `restartIntervalMs`; native initialization
+     * fails fast when both schedules are configured.
+     */
+    restartCron?: string;
+    /**
+     * Delay, in milliseconds, before restarting after a crash.
+     *
+     * @default 0
+     */
+    restartAfterCrashDelayMs?: number;
+}
+/**
+ * Native reason reported for the previous WebView failure or restart.
+ */
+export type WebViewCrashReason = 'renderProcessGone' | 'webContentProcessDidTerminate' | 'periodicRestart' | 'manualRestart' | 'simulated';
+/**
+ * Platform that produced the stored marker.
+ */
+export type WebViewCrashPlatform = 'android' | 'ios' | 'web';
+/**
+ * Best-effort application state captured on iOS when the WebView process died.
+ */
+export type WebViewCrashAppState = 'active' | 'inactive' | 'background' | 'unknown';
+/**
+ * Metadata captured natively after the previous WebView process died or was restarted.
+ */
+export interface WebViewCrashInfo {
+    /**
+     * Platform that detected and stored the marker.
+     */
+    platform: WebViewCrashPlatform;
+    /**
+     * Unix timestamp in milliseconds for when the marker was written.
+     */
+    timestamp: number;
+    /**
+     * ISO-8601 version of `timestamp`.
+     */
+    timestampISO: string;
+    /**
+     * Platform-specific reason for the crash or restart marker.
+     */
+    reason: WebViewCrashReason;
+    /**
+     * Last known WebView URL when the marker was written.
+     */
+    url?: string;
+    /**
+     * Android-only hint from `RenderProcessGoneDetail.didCrash()`.
+     */
+    didCrash?: boolean;
+    /**
+     * Android-only renderer priority reported at exit.
+     */
+    rendererPriorityAtExit?: number;
+    /**
+     * iOS-only application state captured when the marker was written.
+     */
+    appState?: WebViewCrashAppState;
+}
+/**
+ * Pending crash or restart marker returned to JavaScript.
+ */
+export interface PendingCrashInfoResult {
+    /**
+     * Stored crash or restart metadata, or `null` when no marker is pending.
+     */
+    value: WebViewCrashInfo | null;
+}
+/**
+ * Capacitor API for recovered WebView crash and restart detection.
+ */
+export interface WebViewCrashPlugin {
+    /**
+     * Returns the pending native crash or restart marker, if one exists.
+     */
+    getPendingCrashInfo(): Promise<PendingCrashInfoResult>;
+    /**
+     * Clears the stored marker after the app has handled recovery.
+     */
+    clearPendingCrashInfo(): Promise<void>;
+    /**
+     * Creates a fake crash marker so recovery flows can be tested locally.
+     */
+    simulateCrashRecovery(): Promise<PendingCrashInfoResult>;
+    /**
+     * Stores a manual restart marker and asks native code to create a fresh WebView.
+     *
+     * On Android this recreates the host Activity. On iOS this rebuilds the Capacitor bridge view so a new `WKWebView`
+     * instance is created instead of reloading the current page.
+     */
+    restartWebView(): Promise<PendingCrashInfoResult>;
+    /**
+     * Fires after a new JavaScript runtime attaches a listener and a matching marker is still pending.
+     */
+    addListener(eventName: 'webViewRestoredAfterCrash' | 'webViewRestoredAfterRestart', listenerFunc: (info: WebViewCrashInfo) => void): Promise<PluginListenerHandle>;
+    /**
+     * Removes all plugin listeners.
+     */
+    removeAllListeners(): Promise<void>;
+}

package/dist/esm/definitions.js

@@ -0,0 +1,3 @@
+/// <reference types="@capacitor/cli" />
+export {};
+//# sourceMappingURL=definitions.js.map

package/dist/esm/definitions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"definitions.js","sourceRoot":"","sources":["../../src/definitions.ts"],"names":[],"mappings":"AAAA,wCAAwC","sourcesContent":["/// <reference types=\"@capacitor/cli\" />\n\nimport type { PluginListenerHandle } from '@capacitor/core';\n\ndeclare module '@capacitor/cli' {\n  export interface PluginsConfig {\n    /**\n     * Configure native WebView restart behavior for `@capgo/capacitor-webview-crash`.\n     */\n    WebViewCrash?: WebViewCrashPluginConfig;\n  }\n}\n\n/**\n * Native WebView restart behavior configured in `capacitor.config.ts`.\n */\nexport interface WebViewCrashPluginConfig {\n  /**\n   * Restart the WebView from native code when the renderer process dies.\n   *\n   * @default true\n   */\n  restartOnCrash?: boolean;\n\n  /**\n   * Fixed native interval, in milliseconds, for proactively replacing long-running WebViews.\n   *\n   * Set to `0` to disable interval restarts. Do not combine an active interval\n   * with `restartCron`; native initialization fails fast when both schedules are configured.\n   *\n   * @default 0\n   */\n  restartIntervalMs?: number;\n\n  /**\n   * Cron schedule for proactively replacing long-running WebViews.\n   *\n   * Uses standard 5-field cron syntax in the device local timezone:\n   * `minute hour day-of-month month day-of-week`.\n   *\n   * Examples:\n   * - `0 3 * * *` restarts every day at 03:00.\n   * - `0,30 * * * *` restarts every 30 minutes.\n   *\n   * Do not combine this with an active `restartIntervalMs`; native initialization\n   * fails fast when both schedules are configured.\n   */\n  restartCron?: string;\n\n  /**\n   * Delay, in milliseconds, before restarting after a crash.\n   *\n   * @default 0\n   */\n  restartAfterCrashDelayMs?: number;\n}\n\n/**\n * Native reason reported for the previous WebView failure or restart.\n */\nexport type WebViewCrashReason =\n  | 'renderProcessGone'\n  | 'webContentProcessDidTerminate'\n  | 'periodicRestart'\n  | 'manualRestart'\n  | 'simulated';\n\n/**\n * Platform that produced the stored marker.\n */\nexport type WebViewCrashPlatform = 'android' | 'ios' | 'web';\n\n/**\n * Best-effort application state captured on iOS when the WebView process died.\n */\nexport type WebViewCrashAppState = 'active' | 'inactive' | 'background' | 'unknown';\n\n/**\n * Metadata captured natively after the previous WebView process died or was restarted.\n */\nexport interface WebViewCrashInfo {\n  /**\n   * Platform that detected and stored the marker.\n   */\n  platform: WebViewCrashPlatform;\n  /**\n   * Unix timestamp in milliseconds for when the marker was written.\n   */\n  timestamp: number;\n  /**\n   * ISO-8601 version of `timestamp`.\n   */\n  timestampISO: string;\n  /**\n   * Platform-specific reason for the crash or restart marker.\n   */\n  reason: WebViewCrashReason;\n  /**\n   * Last known WebView URL when the marker was written.\n   */\n  url?: string;\n  /**\n   * Android-only hint from `RenderProcessGoneDetail.didCrash()`.\n   */\n  didCrash?: boolean;\n  /**\n   * Android-only renderer priority reported at exit.\n   */\n  rendererPriorityAtExit?: number;\n  /**\n   * iOS-only application state captured when the marker was written.\n   */\n  appState?: WebViewCrashAppState;\n}\n\n/**\n * Pending crash or restart marker returned to JavaScript.\n */\nexport interface PendingCrashInfoResult {\n  /**\n   * Stored crash or restart metadata, or `null` when no marker is pending.\n   */\n  value: WebViewCrashInfo | null;\n}\n\n/**\n * Capacitor API for recovered WebView crash and restart detection.\n */\nexport interface WebViewCrashPlugin {\n  /**\n   * Returns the pending native crash or restart marker, if one exists.\n   */\n  getPendingCrashInfo(): Promise<PendingCrashInfoResult>;\n\n  /**\n   * Clears the stored marker after the app has handled recovery.\n   */\n  clearPendingCrashInfo(): Promise<void>;\n\n  /**\n   * Creates a fake crash marker so recovery flows can be tested locally.\n   */\n  simulateCrashRecovery(): Promise<PendingCrashInfoResult>;\n\n  /**\n   * Stores a manual restart marker and asks native code to create a fresh WebView.\n   *\n   * On Android this recreates the host Activity. On iOS this rebuilds the Capacitor bridge view so a new `WKWebView`\n   * instance is created instead of reloading the current page.\n   */\n  restartWebView(): Promise<PendingCrashInfoResult>;\n\n  /**\n   * Fires after a new JavaScript runtime attaches a listener and a matching marker is still pending.\n   */\n  addListener(\n    eventName: 'webViewRestoredAfterCrash' | 'webViewRestoredAfterRestart',\n    listenerFunc: (info: WebViewCrashInfo) => void,\n  ): Promise<PluginListenerHandle>;\n\n  /**\n   * Removes all plugin listeners.\n   */\n  removeAllListeners(): Promise<void>;\n}\n"]}

package/dist/esm/index.d.ts

@@ -0,0 +1,4 @@
+import type { WebViewCrashPlugin } from './definitions';
+declare const WebViewCrash: WebViewCrashPlugin;
+export * from './definitions';
+export { WebViewCrash };

package/dist/esm/index.js

@@ -0,0 +1,7 @@
+import { registerPlugin } from '@capacitor/core';
+const WebViewCrash = registerPlugin('WebViewCrash', {
+    web: () => import('./web').then((m) => new m.WebViewCrashWeb()),
+});
+export * from './definitions';
+export { WebViewCrash };
+//# sourceMappingURL=index.js.map

package/dist/esm/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAIjD,MAAM,YAAY,GAAG,cAAc,CAAqB,cAAc,EAAE;IACtE,GAAG,EAAE,GAAG,EAAE,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,IAAI,CAAC,CAAC,eAAe,EAAE,CAAC;CAChE,CAAC,CAAC;AAEH,cAAc,eAAe,CAAC;AAC9B,OAAO,EAAE,YAAY,EAAE,CAAC","sourcesContent":["import { registerPlugin } from '@capacitor/core';\n\nimport type { WebViewCrashPlugin } from './definitions';\n\nconst WebViewCrash = registerPlugin<WebViewCrashPlugin>('WebViewCrash', {\n  web: () => import('./web').then((m) => new m.WebViewCrashWeb()),\n});\n\nexport * from './definitions';\nexport { WebViewCrash };\n"]}

package/dist/esm/web.d.ts

@@ -0,0 +1,20 @@
+import type { PluginListenerHandle } from '@capacitor/core';
+import { WebPlugin } from '@capacitor/core';
+import type { PendingCrashInfoResult, WebViewCrashPlugin } from './definitions';
+export declare class WebViewCrashWeb extends WebPlugin implements WebViewCrashPlugin {
+    private dispatchedPendingEvents;
+    getPendingCrashInfo(): Promise<PendingCrashInfoResult>;
+    clearPendingCrashInfo(): Promise<void>;
+    simulateCrashRecovery(): Promise<PendingCrashInfoResult>;
+    restartWebView(): Promise<PendingCrashInfoResult>;
+    addListener(eventName: string, listenerFunc: (...args: any[]) => any): Promise<PluginListenerHandle>;
+    private flushPendingCrashEvent;
+    private shouldDispatchEvent;
+    private buildCrashInfo;
+    private readPendingCrashInfo;
+    private writePendingCrashInfo;
+    private removePendingCrashInfo;
+    private static readonly crashEventName;
+    private static readonly restartEventName;
+    private static readonly storageKey;
+}