@wix/himalaya-cli 0.1451.0 → 0.1453.0

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

@@ -1,157 +1,289 @@
-// ../../core/sdk/webview-page/src/index.ts
-var pending = /* @__PURE__ */ new Map();
-var installedOn;
-var nextId = 1;
-function workerBridge() {
-  const bridge = globalThis.HimalayaWorker;
-  if (!bridge || typeof bridge.post !== "function" || typeof bridge.onMessage !== "function") {
-    throw new Error(
-      "@himalaya/webview-page: this page is not inside a worker-backed Himalaya WebView."
-    );
-  }
-  if (installedOn !== bridge) {
-    bridge.onMessage(receive);
-    installedOn = bridge;
-  }
-  return bridge;
-}
-function isResponse(value) {
-  if (!value || typeof value !== "object") return false;
-  const r = value;
-  return r.v === 1 && typeof r.id === "string" && typeof r.ok === "boolean";
+// ../../core/sdk/webview-page/src/client.ts
+var TIMEOUT_PREFIX = "Himalaya capability call timed out";
+function pageError(error) {
+  const out = new Error(error?.message ?? "Himalaya capability call failed");
+  if (error?.code) Object.assign(out, { code: error.code });
+  return out;
 }
-function receive(message) {
-  if (!isResponse(message)) return;
-  const call2 = pending.get(message.id);
-  if (!call2) return;
-  pending.delete(message.id);
-  clearTimeout(call2.timeout);
-  if (message.ok) {
-    call2.resolve(message.result);
-    return;
-  }
-  const error = new Error(message.error?.message ?? "Himalaya capability call failed");
-  if (message.error?.code) Object.assign(error, { code: message.error.code });
-  call2.reject(error);
-}
-function call(capability, method, args = [], timeoutMs = 3e4) {
-  const bridge = workerBridge();
-  const id = `page-${Date.now().toString(36)}-${nextId++}`;
-  const request = { v: 1, id, capability, method, args };
-  return new Promise((resolve, reject) => {
-    const timeout = setTimeout(() => {
-      pending.delete(id);
-      reject(new Error(`Himalaya capability call timed out: ${capability}.${method}`));
-    }, timeoutMs);
-    pending.set(id, { resolve, reject, timeout });
-    if (!bridge.post(request)) {
-      clearTimeout(timeout);
-      pending.delete(id);
-      reject(new Error("@himalaya/webview-page: the native page-to-worker bridge refused the request."));
+function createPageClient(getBridge) {
+  const pending = /* @__PURE__ */ new Map();
+  const abandoned = /* @__PURE__ */ new Set();
+  const streams = /* @__PURE__ */ new Map();
+  const listeners = /* @__PURE__ */ new Map();
+  let installedOn;
+  let nextId = 1;
+  const clientTag = Math.random().toString(36).slice(2, 10) || "0";
+  function workerBridge() {
+    const bridge = getBridge();
+    if (!bridge || typeof bridge.post !== "function" || typeof bridge.onMessage !== "function") {
+      throw new Error(
+        "@himalaya/webview-page: this page is not inside a worker-backed Himalaya WebView."
+      );
     }
-  });
-}
-var manifest;
-function currentBridge() {
-  try {
-    return workerBridge();
-  } catch {
-    return void 0;
+    if (installedOn !== bridge) {
+      bridge.onMessage(receive);
+      installedOn = bridge;
+    }
+    return bridge;
   }
-}
-function timedOut(error) {
-  return error instanceof Error && error.message.startsWith("Himalaya capability call timed out");
-}
-var asking;
-function askShared(target, budget) {
-  const until = Date.now() + budget;
-  if (asking?.on === target) {
-    asking.until = Math.max(asking.until, until);
-    return asking.answer;
-  }
-  const state = { on: target, until, answer: Promise.resolve(null) };
-  asking = state;
-  state.answer = new Promise((resolve) => {
-    let done = false;
-    const finish = (list) => {
-      if (done) return;
-      done = true;
-      clearInterval(again);
-      if (asking === state) asking = void 0;
-      if (list) manifest = { on: target, list };
-      resolve(list);
-    };
-    const ask = () => {
-      if (done) return;
-      const left = state.until - Date.now();
-      if (left <= 0 || currentBridge() !== target) return finish(null);
-      call("himalaya", "capabilities", [], Math.max(1, Math.min(2e3, left))).then(
-        (reply) => finish(reply?.capabilities ?? null),
-        // A timed-out question is not an answer; the deadline decides. Anything else is final.
-        (error) => {
-          if (!timedOut(error)) finish(null);
+  function receive(message) {
+    if (!message || typeof message !== "object" || message.v !== 1) return;
+    const m = message;
+    if (typeof m.id === "string" && typeof m.ok === "boolean") return respond(m);
+    if (typeof m.ev === "string" && typeof m.ns === "string") return emit(m);
+    if (typeof m.sid === "string") return feed(m);
+  }
+  function respond(message) {
+    const call3 = pending.get(message.id);
+    if (!call3) {
+      if (abandoned.delete(message.id) && message.ok && message.stream === true) cancelStream(message.id);
+      return;
+    }
+    pending.delete(message.id);
+    clearTimeout(call3.timeout);
+    if (!message.ok) return call3.reject(pageError(message.error));
+    if (message.stream === true) return call3.resolve(openStream(message.id));
+    call3.resolve(message.result);
+  }
+  function emit(event) {
+    const handlers = listeners.get(event.ns)?.get(event.ev);
+    if (!handlers) return;
+    for (const handler of [...handlers]) {
+      try {
+        handler(event.data);
+      } catch {
+      }
+    }
+  }
+  function feed(envelope) {
+    const state = streams.get(envelope.sid);
+    if (!state) return;
+    if (!("chunk" in envelope) && !("end" in envelope && envelope.end === true) && !("error" in envelope && envelope.error)) return;
+    if ("chunk" in envelope) {
+      const waiter = state.waiters.shift();
+      if (waiter) waiter.resolve({ value: envelope.chunk, done: false });
+      else state.queue.push(envelope.chunk);
+      return;
+    }
+    streams.delete(envelope.sid);
+    if ("error" in envelope && envelope.error) {
+      state.error = pageError(envelope.error);
+      if (state.waiters.length > 0) {
+        for (const waiter of state.waiters.splice(0)) waiter.reject(state.error);
+        state.error = void 0;
+        state.done = true;
+      }
+    } else if ("end" in envelope && envelope.end === true) {
+      state.done = true;
+      for (const waiter of state.waiters.splice(0)) waiter.resolve({ value: void 0, done: true });
+    }
+  }
+  function cancelStream(sid) {
+    try {
+      installedOn?.post({ v: 1, sys: "cancel", sid });
+    } catch {
+    }
+  }
+  function openStream(sid) {
+    const state = { queue: [], waiters: [], done: false, error: void 0 };
+    streams.set(sid, state);
+    const iterator = {
+      next() {
+        if (state.queue.length > 0) return Promise.resolve({ value: state.queue.shift(), done: false });
+        if (state.error) {
+          const error = state.error;
+          state.error = void 0;
+          state.done = true;
+          return Promise.reject(error);
         }
-      );
+        if (state.done) return Promise.resolve({ value: void 0, done: true });
+        return new Promise((resolve, reject) => state.waiters.push({ resolve, reject }));
+      },
+      return() {
+        if (streams.get(sid) === state) {
+          streams.delete(sid);
+          cancelStream(sid);
+        }
+        state.done = true;
+        state.queue.length = 0;
+        for (const waiter of state.waiters.splice(0)) waiter.resolve({ value: void 0, done: true });
+        return Promise.resolve({ value: void 0, done: true });
+      }
     };
-    const again = setInterval(ask, 500);
-    ask();
-  });
-  return state.answer;
-}
-async function enabledCapabilities(timeoutMs = 3e3) {
-  const bridge = currentBridge();
-  if (!bridge) return null;
-  if (manifest?.on === bridge) return manifest.list;
-  if (!(timeoutMs > 0)) return null;
-  const budget = Math.min(timeoutMs, 2147483647);
-  const answer = askShared(bridge, budget);
-  return new Promise((resolve) => {
-    const stop = setTimeout(() => resolve(manifest?.on === bridge ? manifest.list : null), budget);
-    void answer.then((list) => {
-      clearTimeout(stop);
-      resolve(list);
+    return { [Symbol.asyncIterator]: () => iterator };
+  }
+  function call2(capability, method, args = [], timeoutMs = 3e4) {
+    const bridge = workerBridge();
+    const id = `page-${Date.now().toString(36)}-${clientTag}-${nextId++}`;
+    const request = { v: 1, id, capability, method, args };
+    return new Promise((resolve, reject) => {
+      const timeout = setTimeout(() => {
+        pending.delete(id);
+        abandoned.add(id);
+        if (abandoned.size > 256) abandoned.delete(abandoned.values().next().value);
+        reject(new Error(`${TIMEOUT_PREFIX}: ${capability}.${method}`));
+      }, timeoutMs);
+      pending.set(id, { resolve, reject, timeout });
+      if (!bridge.post(request)) {
+        clearTimeout(timeout);
+        pending.delete(id);
+        reject(new Error("@himalaya/webview-page: the native page-to-worker bridge refused the request."));
+      }
     });
-  });
+  }
+  function on2(namespace2, event, handler) {
+    workerBridge();
+    if (typeof handler !== "function") throw new Error("@himalaya/webview-page: on() needs a handler function");
+    let byEvent = listeners.get(namespace2);
+    if (!byEvent) listeners.set(namespace2, byEvent = /* @__PURE__ */ new Map());
+    let handlers = byEvent.get(event);
+    if (!handlers) byEvent.set(event, handlers = /* @__PURE__ */ new Set());
+    const entry = (data) => handler(data);
+    handlers.add(entry);
+    return () => {
+      handlers.delete(entry);
+    };
+  }
+  let manifest;
+  function currentBridge() {
+    try {
+      return workerBridge();
+    } catch {
+      return void 0;
+    }
+  }
+  function timedOut(error) {
+    return error instanceof Error && error.message.startsWith(TIMEOUT_PREFIX);
+  }
+  let asking;
+  function askShared(target, budget) {
+    const until = Date.now() + budget;
+    if (asking?.on === target) {
+      asking.until = Math.max(asking.until, until);
+      return asking.answer;
+    }
+    const state = { on: target, until, answer: Promise.resolve(null) };
+    asking = state;
+    state.answer = new Promise((resolve) => {
+      let done = false;
+      const finish = (list) => {
+        if (done) return;
+        done = true;
+        clearInterval(again);
+        if (asking === state) asking = void 0;
+        if (list) manifest = { on: target, list };
+        resolve(list);
+      };
+      const ask = () => {
+        if (done) return;
+        const left = state.until - Date.now();
+        if (left <= 0 || currentBridge() !== target) return finish(null);
+        call2("himalaya", "capabilities", [], Math.max(1, Math.min(2e3, left))).then(
+          (reply) => finish(reply?.capabilities ?? null),
+          // A timed-out question is not an answer; the deadline decides. Anything else is final.
+          (error) => {
+            if (!timedOut(error)) finish(null);
+          }
+        );
+      };
+      const again = setInterval(ask, 500);
+      ask();
+    });
+    return state.answer;
+  }
+  async function enabledCapabilities2(timeoutMs = 3e3) {
+    const bridge = currentBridge();
+    if (!bridge) return null;
+    if (manifest?.on === bridge) return manifest.list;
+    if (!(timeoutMs > 0)) return null;
+    const budget = Math.min(timeoutMs, 2147483647);
+    const answer = askShared(bridge, budget);
+    return new Promise((resolve) => {
+      const stop = setTimeout(() => resolve(manifest?.on === bridge ? manifest.list : null), budget);
+      void answer.then((list) => {
+        clearTimeout(stop);
+        resolve(list);
+      });
+    });
+  }
+  async function isEnabled2(capability, method, timeoutMs = 3e3) {
+    const enabled = await enabledCapabilities2(timeoutMs);
+    return enabled?.[capability]?.includes(method) ?? false;
+  }
+  async function probe2(capability, method, args = [], timeoutMs = 3e3) {
+    if (!currentBridge()) return false;
+    try {
+      const result = await call2(capability, method, args, timeoutMs);
+      const iterate = result?.[Symbol.asyncIterator];
+      if (typeof iterate === "function") void iterate.call(result).return?.();
+      return true;
+    } catch (error) {
+      if (error.code === "unknown_method") return false;
+      return !(timedOut(error) || /refused the request/.test(error.message));
+    }
+  }
+  const members = /* @__PURE__ */ new Map();
+  function pageMember(capability, path) {
+    const key = `${capability}:${path.join(".")}`;
+    let member = members.get(key);
+    if (member) return member;
+    const label = `[himalaya.${[capability, ...path].join(".")}]`;
+    member = new Proxy((() => {
+    }), {
+      get(_target, property) {
+        if (typeof property !== "string" || property === "then") return void 0;
+        if (property === "toString" || property === "valueOf") return () => label;
+        if (path.length === 0 && property === "on") {
+          return (event, handler) => on2(capability, event, handler);
+        }
+        return pageMember(capability, [...path, property]);
+      },
+      apply(_target, _thisArg, args) {
+        if (path.length === 0) throw new Error(`Himalaya capability namespace is not callable: ${capability}`);
+        return call2(capability, path.join("."), args);
+      }
+    });
+    members.set(key, member);
+    return member;
+  }
+  const namespace = (capability) => pageMember(capability, []);
+  function merge(target) {
+    const own = { call: call2, on: on2, enabledCapabilities: enabledCapabilities2, isEnabled: isEnabled2, probe: probe2, version: 1 };
+    for (const name of Object.keys(own)) {
+      if (!Object.prototype.hasOwnProperty.call(target, name)) {
+        Object.defineProperty(target, name, { value: own[name], enumerable: true, writable: false, configurable: false });
+      }
+    }
+    Object.freeze(target);
+    return new Proxy(target, {
+      get(t, property, receiver) {
+        if (typeof property !== "string" || property in t) return Reflect.get(t, property, receiver);
+        if (property === "then") return void 0;
+        return namespace(property);
+      }
+    });
+  }
+  return { call: call2, on: on2, enabledCapabilities: enabledCapabilities2, isEnabled: isEnabled2, probe: probe2, namespace, merge };
+}
+
+// ../../core/sdk/webview-page/src/index.ts
+var client = createPageClient(() => globalThis.HimalayaWorker);
+function call(capability, method, args = [], timeoutMs = 3e4) {
+  return client.call(capability, method, args, timeoutMs);
 }
-async function isEnabled(capability, method, timeoutMs = 3e3) {
-  const enabled = await enabledCapabilities(timeoutMs);
-  return enabled?.[capability]?.includes(method) ?? false;
+function on(namespace, event, handler) {
+  return client.on(namespace, event, handler);
 }
-async function probe(capability, method, args = [], timeoutMs = 3e3) {
-  if (!currentBridge()) return false;
-  try {
-    await call(capability, method, args, timeoutMs);
-    return true;
-  } catch (error) {
-    return !(timedOut(error) || /refused the request/.test(error.message));
-  }
+function enabledCapabilities(timeoutMs = 3e3) {
+  return client.enabledCapabilities(timeoutMs);
 }
-var members = /* @__PURE__ */ new Map();
-function pageMember(capability, path) {
-  const key = `${capability}:${path.join(".")}`;
-  let member = members.get(key);
-  if (member) return member;
-  member = new Proxy(function() {
-  }, {
-    get(_target, property) {
-      if (typeof property !== "string" || property === "then") return void 0;
-      return pageMember(capability, [...path, property]);
-    },
-    apply(_target, _thisArg, args) {
-      if (path.length === 0) throw new Error(`Himalaya capability namespace is not callable: ${capability}`);
-      return call(capability, path.join("."), args);
-    }
-  });
-  members.set(key, member);
-  return member;
+function isEnabled(capability, method, timeoutMs = 3e3) {
+  return client.isEnabled(capability, method, timeoutMs);
 }
-var himalaya = new Proxy({ version: 1 }, {
-  get(target, property) {
-    if (property === "version") return target.version;
-    if (typeof property !== "string" || property === "then") return void 0;
-    return pageMember(property, []);
-  }
-});
+function probe(capability, method, args = [], timeoutMs = 3e3) {
+  return client.probe(capability, method, args, timeoutMs);
+}
+var himalaya = client.merge({});
 var health = himalaya.health;
 var version = 1;
 export {
@@ -160,6 +292,7 @@ export {
   health,
   himalaya,
   isEnabled,
+  on,
   probe,
   version
 };