@wix/himalaya-cli 0.1520.0 → 0.1522.0

package/dist/authoring-runtime/node_modules/@wix/himalaya/dist/_types/core/sdk/webview-page/src/webTransport.d.ts

@@ -0,0 +1,21 @@
+import type { HimalayaWorkerBridge } from "./client.js";
+export declare const ANNOUNCE = "webview.announce";
+export declare const PORT = "webview.port";
+export declare const HOST_CONTROL = "webview.host";
+interface FrameWindow {
+    parent: unknown;
+    addEventListener(type: "message", listener: (event: MessageEvent) => void): void;
+    removeEventListener(type: "message", listener: (event: MessageEvent) => void): void;
+    setTimeout(handler: () => void, ms: number): unknown;
+    clearTimeout(id: unknown): void;
+    document?: Document;
+    console?: Console;
+    MutationObserver?: typeof MutationObserver;
+}
+/**
+ * The worker bridge for a page framed by a web host, or `undefined` when this page is not in a frame.
+ * Announces at once and keeps announcing until the host answers (the host may still be loading its
+ * bridge when the page is ready).
+ */
+export declare function createWebFrameBridge(win: FrameWindow): HimalayaWorkerBridge | undefined;
+export {};

package/dist/authoring-runtime/node_modules/@wix/himalaya/dist/webview-page.mjs

@@ -266,8 +266,230 @@ function createPageClient(getBridge) {
   return { call: call2, on: on2, enabledCapabilities: enabledCapabilities2, isEnabled: isEnabled2, probe: probe2, namespace, merge };
 }
 
+// ../../core/sdk/webview-page/src/webTransport.ts
+var ANNOUNCE = "webview.announce";
+var PORT = "webview.port";
+var HOST_CONTROL = "webview.host";
+var MAX_HELD = 256;
+var RETRANSMIT_FAST_MS = 250;
+var RETRANSMITS_FAST = 40;
+var RETRANSMIT_SLOW_MS = 2e3;
+var RETRANSMITS = 70;
+function randomDoc() {
+  const c = globalThis.crypto;
+  if (c && typeof c.getRandomValues === "function") {
+    const b = new Uint8Array(12);
+    c.getRandomValues(b);
+    return Array.from(b, (x) => x.toString(16).padStart(2, "0")).join("");
+  }
+  return Math.random().toString(36).slice(2) + Date.now().toString(36);
+}
+function createWebFrameBridge(win) {
+  const parent = win.parent;
+  if (!parent || parent === win || typeof parent.postMessage !== "function") return void 0;
+  const doc = randomDoc();
+  const handlers = [];
+  let port = null;
+  let held = [];
+  let retransmits = 0;
+  let timer = null;
+  const media = createMediaControls(win);
+  const announce = () => {
+    timer = null;
+    if (port) return;
+    try {
+      parent.postMessage({ himalaya: ANNOUNCE, v: 1, doc }, "*");
+    } catch {
+    }
+    if (retransmits < RETRANSMITS) {
+      timer = win.setTimeout(announce, retransmits < RETRANSMITS_FAST ? RETRANSMIT_FAST_MS : RETRANSMIT_SLOW_MS);
+      retransmits++;
+    }
+  };
+  const deliver = (message) => {
+    for (const h of [...handlers]) {
+      try {
+        h(message);
+      } catch {
+      }
+    }
+  };
+  const send = (raw) => {
+    if (port) {
+      try {
+        port.postMessage(raw);
+      } catch {
+      }
+    } else if (held.length < MAX_HELD) {
+      held.push(raw);
+    }
+  };
+  const onWindowMessage = (event) => {
+    if (port || event.source !== parent) return;
+    const data = event.data;
+    if (!data || typeof data !== "object" || data.himalaya !== PORT || data.v !== 1 || data.doc !== doc) return;
+    const p = event.ports?.[0];
+    if (!p) return;
+    port = p;
+    win.removeEventListener("message", onWindowMessage);
+    if (timer != null) {
+      win.clearTimeout(timer);
+      timer = null;
+    }
+    p.onmessage = (e) => {
+      const m = e.data;
+      if (typeof m === "string") {
+        let parsed = m;
+        try {
+          parsed = JSON.parse(m);
+        } catch {
+        }
+        deliver(parsed);
+        return;
+      }
+      const c = m;
+      if (c && typeof c === "object" && c.himalaya === HOST_CONTROL && c.v === 1 && typeof c.value === "boolean") {
+        if (c.op === "active") media.setActive(c.value);
+        else if (c.op === "muted") media.setMuted(c.value);
+      }
+    };
+    p.start?.();
+    if (data.active === false) media.setActive(false);
+    if (data.muted === true) media.setMuted(true);
+    const consoleCfg = data.console;
+    if (consoleCfg && typeof consoleCfg === "object") {
+      wrapConsole(
+        win,
+        (payload) => send(JSON.stringify({ kind: "worker.message", payload })),
+        typeof consoleCfg.maxArgs === "number" ? consoleCfg.maxArgs : 16,
+        typeof consoleCfg.argLength === "number" ? consoleCfg.argLength : 2048
+      );
+    }
+    const queued = held;
+    held = [];
+    for (const raw of queued) send(raw);
+  };
+  win.addEventListener("message", onWindowMessage);
+  announce();
+  return {
+    post(message) {
+      let raw;
+      try {
+        raw = JSON.stringify({ kind: "worker.message", payload: message === void 0 ? null : message });
+      } catch {
+        return false;
+      }
+      send(raw);
+      return true;
+    },
+    onMessage(handler) {
+      if (typeof handler === "function") handlers.push(handler);
+    }
+  };
+}
+function wrapConsole(win, post, maxArgs, maxLength) {
+  const c = win.console;
+  if (!c || c.__himalayaConsoleForwarding) return;
+  Object.defineProperty(c, "__himalayaConsoleForwarding", { value: true });
+  const text = (a) => {
+    if (a instanceof Error) a = String(a.stack || a);
+    let s;
+    try {
+      s = JSON.stringify(a);
+    } catch {
+      s = void 0;
+    }
+    if (typeof s !== "string") {
+      try {
+        s = JSON.stringify(String(a));
+      } catch {
+        s = '"[unserializable]"';
+      }
+    }
+    s = s.replace(/[<\u007f‪-‮⁦-⁩]/g, (ch) => "\\u" + ("000" + ch.charCodeAt(0).toString(16)).slice(-4));
+    return s.length > maxLength ? s.slice(0, maxLength) : s;
+  };
+  for (const level of ["log", "info", "warn", "error", "debug"]) {
+    const original = c[level];
+    c[level] = function(...args) {
+      try {
+        original?.apply(c, args);
+      } catch {
+      }
+      try {
+        post({ v: 1, sys: "console", iid: "", level, args: args.slice(0, maxArgs).map(text) });
+      } catch {
+      }
+    };
+  }
+}
+function createMediaControls(win) {
+  const document = win.document;
+  const pausedByUs = /* @__PURE__ */ new Set();
+  const mutedByUs = /* @__PURE__ */ new Set();
+  let observer = null;
+  const all = () => document ? Array.from(document.querySelectorAll("audio,video")) : [];
+  const mute = (el) => {
+    if (!el.muted) {
+      el.muted = true;
+      mutedByUs.add(el);
+    }
+  };
+  return {
+    setActive(active) {
+      if (!document) return;
+      if (!active) {
+        Object.defineProperty(document, "visibilityState", { configurable: true, get: () => "hidden" });
+        Object.defineProperty(document, "hidden", { configurable: true, get: () => true });
+        for (const el of all()) if (!el.paused) {
+          try {
+            el.pause();
+            pausedByUs.add(el);
+          } catch {
+          }
+        }
+      } else {
+        delete document.visibilityState;
+        delete document.hidden;
+        for (const el of pausedByUs) {
+          try {
+            void el.play()?.catch?.(() => {
+            });
+          } catch {
+          }
+        }
+        pausedByUs.clear();
+      }
+      try {
+        document.dispatchEvent(new Event("visibilitychange"));
+      } catch {
+      }
+    },
+    setMuted(muted) {
+      if (!document) return;
+      if (muted) {
+        for (const el of all()) mute(el);
+        const MO = win.MutationObserver;
+        if (!observer && MO && document.documentElement) {
+          observer = new MO(() => {
+            for (const el of all()) mute(el);
+          });
+          observer.observe(document.documentElement, { childList: true, subtree: true });
+        }
+      } else {
+        observer?.disconnect();
+        observer = null;
+        for (const el of mutedByUs) el.muted = false;
+        mutedByUs.clear();
+      }
+    }
+  };
+}
+
 // ../../core/sdk/webview-page/src/index.ts
-var client = createPageClient(() => globalThis.HimalayaWorker);
+var injected = () => globalThis.HimalayaWorker;
+var webFrame = injected() || typeof window === "undefined" ? void 0 : createWebFrameBridge(window);
+var client = createPageClient(() => injected() ?? webFrame);
 function call(capability, method, args = [], timeoutMs = 3e4) {
   return client.call(capability, method, args, timeoutMs);
 }