@statewalker/webrun-devtools/dist/webrun-devtools-ws.js

DevTools Extension for the StateWalker WebRun framework

async function M(t, n) {
  const s = new WebSocket(t);
  await new Promise(
    (b) => s.onopen = function() {
      s.onopen = null, b();
    }
  );
  const g = new MessageChannel(), l = g.port1, i = g.port2;
  s.onmessage = ({ data: b }) => l.postMessage(JSON.parse(b)), l.onmessage = ({ data: b }) => s.send(JSON.stringify(b));
  const u = l.close.bind(l), v = s.close.bind(s), h = i.close.bind(g.port2), S = () => {
    h(), u(), v();
  };
  return l.close = S, g.port2.close = S, n && (n.aborted && S(), n.addEventListener("abort", () => S())), g.port2;
}
function f({
  port: t,
  versionUrl: n = `http://127.0.0.1:${t}/json/version`,
  http: s = console.log,
  retryPeriod: g = 500,
  fetchJson: l = async (i) => await (await fetch(i, {
    mode: "cors"
  })).json()
}) {
  let i, u, v = new Promise((h, S) => {
    const b = h;
    u = S, i = setInterval(async () => {
      try {
        const O = await l(n);
        clearInterval(i), i = 0, b(O);
      } catch {
      }
    }, g);
  });
  return v.finally(() => i && clearInterval(i)), Object.assign(v, { close: u });
}
const T = [
  "Accessibility.disable",
  "Accessibility.enable",
  "Animation.disable",
  "Animation.enable",
  "Animation.releaseAnimations",
  "Animation.seekAnimations",
  "Animation.setPaused",
  "Animation.setPlaybackRate",
  "Animation.setTiming",
  "Audits.checkContrast",
  "Audits.disable",
  "Audits.enable",
  "Autofill.disable",
  "Autofill.enable",
  "Autofill.setAddresses",
  "Autofill.trigger",
  "BackgroundService.clearEvents",
  "BackgroundService.setRecording",
  "BackgroundService.startObserving",
  "BackgroundService.stopObserving",
  "Browser.addPrivacySandboxEnrollmentOverride",
  "Browser.cancelDownload",
  "Browser.close",
  "Browser.crash",
  "Browser.crashGpuProcess",
  "Browser.executeBrowserCommand",
  "Browser.grantPermissions",
  "Browser.resetPermissions",
  "Browser.setDockTile",
  "Browser.setDownloadBehavior",
  "Browser.setPermission",
  "Browser.setWindowBounds",
  "CSS.disable",
  "CSS.enable",
  "CSS.forcePseudoState",
  "CSS.setEffectivePropertyValueForNode",
  "CSS.setLocalFontsEnabled",
  "CSS.startRuleUsageTracking",
  "CSS.trackComputedStyleUpdates",
  "CacheStorage.deleteCache",
  "CacheStorage.deleteEntry",
  "Cast.disable",
  "Cast.enable",
  "Cast.setSinkToUse",
  "Cast.startDesktopMirroring",
  "Cast.startTabMirroring",
  "Cast.stopCasting",
  "Console.clearMessages",
  "Console.disable",
  "Console.enable",
  "DOM.disable",
  "DOM.discardSearchResults",
  "DOM.enable",
  "DOM.focus",
  "DOM.hideHighlight",
  "DOM.highlightNode",
  "DOM.highlightRect",
  "DOM.markUndoableState",
  "DOM.redo",
  "DOM.removeAttribute",
  "DOM.removeNode",
  "DOM.requestChildNodes",
  "DOM.scrollIntoViewIfNeeded",
  "DOM.setAttributeValue",
  "DOM.setAttributesAsText",
  "DOM.setFileInputFiles",
  "DOM.setInspectedNode",
  "DOM.setNodeStackTracesEnabled",
  "DOM.setNodeValue",
  "DOM.setOuterHTML",
  "DOM.undo",
  "DOMDebugger.removeDOMBreakpoint",
  "DOMDebugger.removeEventListenerBreakpoint",
  "DOMDebugger.removeInstrumentationBreakpoint",
  "DOMDebugger.removeXHRBreakpoint",
  "DOMDebugger.setBreakOnCSPViolation",
  "DOMDebugger.setDOMBreakpoint",
  "DOMDebugger.setEventListenerBreakpoint",
  "DOMDebugger.setInstrumentationBreakpoint",
  "DOMDebugger.setXHRBreakpoint",
  "DOMSnapshot.disable",
  "DOMSnapshot.enable",
  "DOMStorage.clear",
  "DOMStorage.disable",
  "DOMStorage.enable",
  "DOMStorage.removeDOMStorageItem",
  "DOMStorage.setDOMStorageItem",
  "Database.disable",
  "Database.enable",
  "Debugger.continueToLocation",
  "Debugger.disable",
  "Debugger.pause",
  "Debugger.pauseOnAsyncCall",
  "Debugger.removeBreakpoint",
  "Debugger.resume",
  "Debugger.setAsyncCallStackDepth",
  "Debugger.setBlackboxPatterns",
  "Debugger.setBlackboxedRanges",
  "Debugger.setBreakpointsActive",
  "Debugger.setPauseOnExceptions",
  "Debugger.setReturnValue",
  "Debugger.setSkipAllPauses",
  "Debugger.setVariableValue",
  "Debugger.stepInto",
  "Debugger.stepOut",
  "Debugger.stepOver",
  "DeviceAccess.cancelPrompt",
  "DeviceAccess.disable",
  "DeviceAccess.enable",
  "DeviceAccess.selectPrompt",
  "DeviceOrientation.clearDeviceOrientationOverride",
  "DeviceOrientation.setDeviceOrientationOverride",
  "Emulation.clearDeviceMetricsOverride",
  "Emulation.clearGeolocationOverride",
  "Emulation.clearIdleOverride",
  "Emulation.resetPageScaleFactor",
  "Emulation.setAutoDarkModeOverride",
  "Emulation.setAutomationOverride",
  "Emulation.setCPUThrottlingRate",
  "Emulation.setDefaultBackgroundColorOverride",
  "Emulation.setDeviceMetricsOverride",
  "Emulation.setDisabledImageTypes",
  "Emulation.setDocumentCookieDisabled",
  "Emulation.setEmitTouchEventsForMouse",
  "Emulation.setEmulatedMedia",
  "Emulation.setEmulatedVisionDeficiency",
  "Emulation.setFocusEmulationEnabled",
  "Emulation.setGeolocationOverride",
  "Emulation.setHardwareConcurrencyOverride",
  "Emulation.setIdleOverride",
  "Emulation.setLocaleOverride",
  "Emulation.setNavigatorOverrides",
  "Emulation.setPageScaleFactor",
  "Emulation.setScriptExecutionDisabled",
  "Emulation.setScrollbarsHidden",
  "Emulation.setTimezoneOverride",
  "Emulation.setTouchEmulationEnabled",
  "Emulation.setUserAgentOverride",
  "Emulation.setVisibleSize",
  "EventBreakpoints.removeInstrumentationBreakpoint",
  "EventBreakpoints.setInstrumentationBreakpoint",
  "FedCm.confirmIdpLogin",
  "FedCm.disable",
  "FedCm.dismissDialog",
  "FedCm.enable",
  "FedCm.resetCooldown",
  "FedCm.selectAccount",
  "Fetch.continueRequest",
  "Fetch.continueResponse",
  "Fetch.continueWithAuth",
  "Fetch.disable",
  "Fetch.enable",
  "Fetch.failRequest",
  "Fetch.fulfillRequest",
  "HeadlessExperimental.disable",
  "HeadlessExperimental.enable",
  "HeapProfiler.addInspectedHeapObject",
  "HeapProfiler.collectGarbage",
  "HeapProfiler.disable",
  "HeapProfiler.enable",
  "HeapProfiler.startSampling",
  "HeapProfiler.startTrackingHeapObjects",
  "HeapProfiler.stopTrackingHeapObjects",
  "HeapProfiler.takeHeapSnapshot",
  "IO.close",
  "IndexedDB.clearObjectStore",
  "IndexedDB.deleteDatabase",
  "IndexedDB.deleteObjectStoreEntries",
  "IndexedDB.disable",
  "IndexedDB.enable",
  "Input.cancelDragging",
  "Input.dispatchDragEvent",
  "Input.dispatchKeyEvent",
  "Input.dispatchMouseEvent",
  "Input.dispatchTouchEvent",
  "Input.emulateTouchFromMouseEvent",
  "Input.imeSetComposition",
  "Input.insertText",
  "Input.setIgnoreInputEvents",
  "Input.setInterceptDrags",
  "Input.synthesizePinchGesture",
  "Input.synthesizeScrollGesture",
  "Input.synthesizeTapGesture",
  "Inspector.disable",
  "Inspector.enable",
  "LayerTree.disable",
  "LayerTree.enable",
  "LayerTree.releaseSnapshot",
  "Log.clear",
  "Log.disable",
  "Log.enable",
  "Log.startViolationsReport",
  "Log.stopViolationsReport",
  "Media.disable",
  "Media.enable",
  "Memory.forciblyPurgeJavaScriptMemory",
  "Memory.prepareForLeakDetection",
  "Memory.setPressureNotificationsSuppressed",
  "Memory.simulatePressureNotification",
  "Memory.startSampling",
  "Memory.stopSampling",
  "Network.clearAcceptedEncodingsOverride",
  "Network.clearBrowserCache",
  "Network.clearBrowserCookies",
  "Network.continueInterceptedRequest",
  "Network.deleteCookies",
  "Network.disable",
  "Network.emulateNetworkConditions",
  "Network.enable",
  "Network.enableReportingApi",
  "Network.replayXHR",
  "Network.setAcceptedEncodings",
  "Network.setAttachDebugStack",
  "Network.setBlockedURLs",
  "Network.setBypassServiceWorker",
  "Network.setCacheDisabled",
  "Network.setCookies",
  "Network.setExtraHTTPHeaders",
  "Network.setRequestInterception",
  "Network.setUserAgentOverride",
  "Overlay.disable",
  "Overlay.enable",
  "Overlay.hideHighlight",
  "Overlay.highlightFrame",
  "Overlay.highlightNode",
  "Overlay.highlightQuad",
  "Overlay.highlightRect",
  "Overlay.highlightSourceOrder",
  "Overlay.setInspectMode",
  "Overlay.setPausedInDebuggerMessage",
  "Overlay.setShowAdHighlights",
  "Overlay.setShowContainerQueryOverlays",
  "Overlay.setShowDebugBorders",
  "Overlay.setShowFPSCounter",
  "Overlay.setShowFlexOverlays",
  "Overlay.setShowGridOverlays",
  "Overlay.setShowHinge",
  "Overlay.setShowHitTestBorders",
  "Overlay.setShowIsolatedElements",
  "Overlay.setShowLayoutShiftRegions",
  "Overlay.setShowPaintRects",
  "Overlay.setShowScrollBottleneckRects",
  "Overlay.setShowScrollSnapOverlays",
  "Overlay.setShowViewportSizeOnResize",
  "Overlay.setShowWebVitals",
  "Page.addCompilationCache",
  "Page.bringToFront",
  "Page.clearCompilationCache",
  "Page.clearDeviceMetricsOverride",
  "Page.clearDeviceOrientationOverride",
  "Page.clearGeolocationOverride",
  "Page.close",
  "Page.crash",
  "Page.deleteCookie",
  "Page.disable",
  "Page.enable",
  "Page.generateTestReport",
  "Page.handleJavaScriptDialog",
  "Page.navigateToHistoryEntry",
  "Page.produceCompilationCache",
  "Page.reload",
  "Page.removeScriptToEvaluateOnLoad",
  "Page.removeScriptToEvaluateOnNewDocument",
  "Page.resetNavigationHistory",
  "Page.screencastFrameAck",
  "Page.setAdBlockingEnabled",
  "Page.setBypassCSP",
  "Page.setDeviceMetricsOverride",
  "Page.setDeviceOrientationOverride",
  "Page.setDocumentContent",
  "Page.setDownloadBehavior",
  "Page.setFontFamilies",
  "Page.setFontSizes",
  "Page.setGeolocationOverride",
  "Page.setInterceptFileChooserDialog",
  "Page.setLifecycleEventsEnabled",
  "Page.setPrerenderingAllowed",
  "Page.setRPHRegistrationMode",
  "Page.setSPCTransactionMode",
  "Page.setTouchEmulationEnabled",
  "Page.setWebLifecycleState",
  "Page.startScreencast",
  "Page.stopLoading",
  "Page.stopScreencast",
  "Page.waitForDebugger",
  "Performance.disable",
  "Performance.enable",
  "Performance.setTimeDomain",
  "PerformanceTimeline.enable",
  "Preload.disable",
  "Preload.enable",
  "Profiler.disable",
  "Profiler.enable",
  "Profiler.setSamplingInterval",
  "Profiler.start",
  "Profiler.stopPreciseCoverage",
  "Runtime.addBinding",
  "Runtime.disable",
  "Runtime.discardConsoleEntries",
  "Runtime.enable",
  "Runtime.releaseObject",
  "Runtime.releaseObjectGroup",
  "Runtime.removeBinding",
  "Runtime.runIfWaitingForDebugger",
  "Runtime.setAsyncCallStackDepth",
  "Runtime.setCustomObjectFormatterEnabled",
  "Runtime.setMaxCallStackSizeToCapture",
  "Runtime.terminateExecution",
  "Security.disable",
  "Security.enable",
  "Security.handleCertificateError",
  "Security.setIgnoreCertificateErrors",
  "Security.setOverrideCertificateErrors",
  "ServiceWorker.deliverPushMessage",
  "ServiceWorker.disable",
  "ServiceWorker.dispatchPeriodicSyncEvent",
  "ServiceWorker.dispatchSyncEvent",
  "ServiceWorker.enable",
  "ServiceWorker.inspectWorker",
  "ServiceWorker.setForceUpdateOnPageLoad",
  "ServiceWorker.skipWaiting",
  "ServiceWorker.startWorker",
  "ServiceWorker.stopAllWorkers",
  "ServiceWorker.stopWorker",
  "ServiceWorker.unregister",
  "ServiceWorker.updateRegistration",
  "Storage.clearCookies",
  "Storage.clearDataForOrigin",
  "Storage.clearDataForStorageKey",
  "Storage.clearSharedStorageEntries",
  "Storage.deleteSharedStorageEntry",
  "Storage.deleteStorageBucket",
  "Storage.overrideQuotaForOrigin",
  "Storage.resetSharedStorageBudget",
  "Storage.setAttributionReportingLocalTestingMode",
  "Storage.setAttributionReportingTracking",
  "Storage.setCookies",
  "Storage.setInterestGroupTracking",
  "Storage.setSharedStorageEntry",
  "Storage.setSharedStorageTracking",
  "Storage.setStorageBucketTracking",
  "Storage.trackCacheStorageForOrigin",
  "Storage.trackCacheStorageForStorageKey",
  "Storage.trackIndexedDBForOrigin",
  "Storage.trackIndexedDBForStorageKey",
  "Storage.untrackCacheStorageForOrigin",
  "Storage.untrackCacheStorageForStorageKey",
  "Storage.untrackIndexedDBForOrigin",
  "Storage.untrackIndexedDBForStorageKey",
  "Target.activateTarget",
  "Target.autoAttachRelated",
  "Target.detachFromTarget",
  "Target.disposeBrowserContext",
  "Target.exposeDevToolsProtocol",
  "Target.sendMessageToTarget",
  "Target.setAutoAttach",
  "Target.setDiscoverTargets",
  "Target.setRemoteLocations",
  "Tethering.bind",
  "Tethering.unbind",
  "Tracing.end",
  "Tracing.recordClockSyncMarker",
  "Tracing.start",
  "WebAudio.disable",
  "WebAudio.enable",
  "WebAuthn.addCredential",
  "WebAuthn.clearCredentials",
  "WebAuthn.disable",
  "WebAuthn.enable",
  "WebAuthn.removeCredential",
  "WebAuthn.removeVirtualAuthenticator",
  "WebAuthn.setAutomaticPresenceSimulation",
  "WebAuthn.setResponseOverrideBits",
  "WebAuthn.setUserVerified"
], I = T.reduce((t, n) => (t[n] = !0, t), {});
function A(t) {
  return !I[t];
}
const B = [
  "Accessibility",
  "Audits",
  "CSS",
  "CacheStorage",
  "Console",
  "DOM",
  "DOMDebugger",
  "DOMSnapshot",
  "Database",
  "Debugger",
  "Emulation",
  "Fetch",
  "IO",
  "Input",
  "Inspector",
  "Log",
  "Network",
  "Overlay",
  "Page",
  "Performance",
  "Profiler",
  "Runtime",
  "Storage",
  "Target",
  "Tracing",
  "WebAudio",
  "WebAuthn"
];
B.reduce((t, n) => (t[n] = !0, t), {});
function F(t) {
  return A;
}
async function R(t, { inBrowser: n = !1, hasResponse: s = F() } = {}) {
  let g = 1;
  async function l(o, e = {}, ...r) {
    const c = g++, a = new Promise((d, p) => {
      try {
        const m = s(o);
        m && t.addEventListener("message", function D({ data: k }) {
          if (c !== k.id)
            return;
          t.removeEventListener("message", D);
          const { result: P, error: y } = k;
          y ? p(y) : d(P);
        }), t.postMessage(
          Object.assign(
            {
              id: c,
              method: o,
              params: e
            },
            ...r
          )
        ), m || d();
      } catch (m) {
        p(m);
      }
    });
    return console.log("[>>>]", { callId: c, method: o, params: e }), a.then(
      (d) => console.log("[<<<]", { callId: c, method: o, params: e, result: d })
    ).catch(
      (d) => console.log("[<<<]", { callId: c, method: o, params: e, error: d })
    ), a;
  }
  const i = {}, u = {};
  let v = [], h = [];
  async function S(o, e, r = {}) {
    const { targetId: c } = o, a = i[c];
    return await l(e, r, { sessionId: a });
  }
  async function b() {
    return (await l("Target.getTargets")).targetInfos;
  }
  async function O(o) {
    const { targetId: e } = o, { sessionId: r } = await l("Target.attachToTarget", {
      targetId: e,
      flatten: !0
    });
    i[e] = r, u[r] = e;
  }
  async function C(o) {
    const { targetId: e } = o, r = i[e];
    delete i[e], delete u[r], await l("Target.detachFromTarget", {
      // targetId, // depricated
      sessionId: r
    });
  }
  function E(o, e) {
    let r;
    return {
      addListener: (c) => {
        e.push(c), r || (r = ({ data: a }) => {
          if (!a.method || a.method === "Target.detachedFromTarget")
            return;
          const { method: d, params: p, sessionId: m } = a, k = { targetId: u[m], sessionId: m };
          for (let P of e)
            P(k, d, p);
        }, o.addEventListener("message", r));
      },
      removeListener: (c) => {
        for (let a = e.length - 1; a >= 0; a--)
          e[a] === c && e.splice(a, 1);
        !e.length && r && (o.removeEventListener("message", r), r = null);
      }
    };
  }
  function w(o, e) {
    let r;
    return {
      addListener: (c) => {
        e.push(c), r || (r = ({ data: a }) => {
          const { method: d, params: p } = a;
          if (d !== "Target.detachedFromTarget")
            return;
          const m = "canceled_by_user";
          for (let D of e)
            D(p, m);
        }, o.addEventListener("message", r));
      },
      removeListener: (c) => {
        for (let a = e.length - 1; a >= 0; a--)
          e[a] === c && e.splice(a, 1);
        !e.length && r && (o.removeEventListener("message", r), r = null);
      }
    };
  }
  return {
    sendCommand: S,
    attach: O,
    detach: C,
    getTargets: b,
    onEvent: E(t, v),
    onDetach: w(t, h)
  };
}
async function* L(t) {
  let n;
  try {
    for (; ; ) {
      const s = f(t);
      n = s.close, yield await s;
    }
  } finally {
    n && n();
  }
}
async function W({ wsUrl: t, ...n }) {
  t || (t = (await f(n)).webSocketDebuggerUrl);
  const s = new AbortController(), g = await M(t, s.signal);
  return {
    debugger: await R(g),
    close: () => s.abort()
  };
}
export {
  M as connectToWs,
  W as default,
  L as listenConnectionInfo,
  f as loadConnectionInfo,
  R as newDebuggerApi
};