@statewalker/webrun-http-browser 0.3.3 → 0.3.4

package/dist/index-umd.js

@@ -1,853 +0,0 @@
-// @statewalker/webrun-http-browser v0.3.3 https://github.com/statewalker/statewalker-webrun-http-browser Copyright 2023 Mikhail Kotelnikov
-(function (global, factory) {
-typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
-typeof define === 'function' && define.amd ? define(['exports'], factory) :
-(global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory((global.statewalker = global.statewalker || {}, global.statewalker["webrun-http-browser"] = global.statewalker["webrun-http-browser"] || {})));
-})(this, (function (exports) { 'use strict';
-
-function serializeError(error) {
-  return Object.assign({
-    message: error,
-    stack: error.stack,
-  }, error);
-}
-
-function deserializeError(error) {
-  if (typeof error === "string") {
-    error = { message: error };
-  }
-  return Object.assign(new Error(error.message), error);
-}
-
-async function callChannel(mainChannel, callType, params, ...transfers) {
-  return new Promise((resolve, reject) => {
-    const channel = new MessageChannel();
-    channel.port1.onmessage = (ev) => {
-      const { result, error } = ev.data;
-      if (error) reject(deserializeError(error));
-      else resolve(result);
-    };
-    mainChannel.postMessage({ type: callType, params }, [
-      channel.port2,
-      ...transfers,
-    ]);
-  });
-}
-
-function handleChannelCalls(mainChannel, callType, handler) {
-  const messageListener = async (event) => {
-    if (!event.data || event.data.type !== callType) return;
-    const [port, ...transfers] = event.ports;
-    let response = {};
-    try {
-      const params = event.data.params;
-      response.result = await handler(event, params, ...transfers);
-    } catch (error) {
-      response.error = serializeError(error);
-    }
-    port.postMessage(response);
-  };
-  mainChannel.addEventListener("message", messageListener);
-  try {
-    mainChannel.start && mainChannel.start();
-  } catch (e) {}
-  return () => mainChannel.removeEventListener("message", messageListener);
-}
-
-// See https://github.com/agenjs/agen-utils/blob/main/src/iterator.js
-async function* iterate(init, queue = []) {
-  let promise, notify, push = async (error, value, done) => {
-    const slot = { error, value, done };
-    slot.promise = new Promise(n => slot.notify = n);
-    await queue.push(slot);
-    notify && notify();
-    notify = null;
-    return slot.promise;
-  };
-  const next = (value) => push(undefined, value, false);
-  const complete = () => push(undefined, undefined, true);
-  const error = err => push(err, undefined, true);
-  const unsubscribe = init(Object.assign([next, complete, error], { next, complete, error }));
-  let slot;
-  try {
-    while (true) {
-      slot = await queue.shift();
-      if (slot) {
-        try {
-          if (slot.error) { throw slot.error; }
-          else if (slot.done) { break; }
-          else { yield slot.value; }
-        } finally {
-          slot.notify(true);
-        }
-      } else {
-        await (promise = notify ? promise : new Promise(n => notify = n));
-      }
-    }
-  } finally {
-    notify && notify();
-    push = () => false; // Stop pushing in the queue...
-    ((typeof unsubscribe === 'function') && (await unsubscribe()));
-    while (slot = await queue.shift()) { slot.notify(false); }
-  }
-}
-
-function newRegistry(onError = console.error) {
-  let counter = 0;
-  const registrations = {};
-  const register = (action) => {
-    const id = counter++;
-    return (registrations[id] = Object.assign(
-      function (skip) {
-        try {
-          delete registrations[id];
-          return !skip && action && action();
-        } catch (error) {
-          onError(error);
-        }
-      },
-      { action }
-    ));
-  };
-  const unregister = (action) =>
-    Object.values(registrations).forEach((r) => r.action === action && r(true));
-  const clear = () => Object.values(registrations).forEach((r) => r());
-  return Object.assign([register, clear, unregister], {
-    register,
-    clear,
-    unregister
-  });
-}
-
-async function* recieveData(onMessage) {
-  yield* iterate((iterator) => {
-    return onMessage(async ({ done = true, value, error } = {}) => {
-      if (error) {
-        await iterator.error(error);
-      } else if (done) {
-        await iterator.complete();
-      } else {
-        await iterator.next(value);
-      }
-    });
-  });
-}
-
-async function sendData(send, it) {
-  let error;
-  try {
-    for await (let value of it) {
-      await send({ done: false, value });
-    }
-  } catch (err) {
-    error = err;
-  } finally {
-    await send({ done: true, error });
-  }
-}
-
-async function* sendStream(communicationPort, input, params = {}) {
-  const messageChannel = new MessageChannel();
-  communicationPort.postMessage({ type: "START_CALL", params }, [
-    messageChannel.port2,
-  ]);
-
-  const channel = newChannel(messageChannel.port1);
-  try {
-    await channel.start();
-    channel.sendAll(input);
-    yield* channel.recieveAll();
-  } finally {
-    await channel.close();
-  }
-}
-
-function handleStreams(communicationPort, handler) {
-  const listener = async (event) => {
-    const { type, params } = event.data || {};
-    if (type !== "START_CALL") return;
-    const port = event.ports[0];
-    const channel = newChannel(port);
-    try {
-      await channel.start();
-      const input = channel.recieveAll();
-      const response = await handler(input, params);
-      await channel.sendAll(response);
-    } finally {
-      await channel.close();
-    }
-  };
-  communicationPort.addEventListener("message", listener);
-  try {
-    communicationPort.start && communicationPort.start();
-  } catch (e) {}
-  return () => communicationPort.removeEventListener("message", listener);
-}
-
-/**
- * This method creates and returns methods allowing to send and recieve data over the specified port.
- * The main characteristics of the returned methods is that they properly manage backpressure - sender
- * iterators are waiting to send the next value until the previous one is consumed on the other side.
- * @param {*} port
- * @returns an object with the following methods:
- *  * `start` - starts the connection over the specified port
- *  * `close`- stops all iterators and closes the port
- *  * `recieveAll() : AsyncIterator` - returns an AsyncIterator over all values send by the peer
- *  * `sendAll(it : AsyncIterator) : Promise<any>` - sends all values defined by the given
- *     AsyncIterator to the peer
- */
-function newChannel(port) {
-  let listeners = [];
-  let iterators = [];
-
-  const notifyAll = async (data) => {
-    for (let listener of listeners) {
-      await listener(data);
-    }
-  };
-  const channel = newInvokationChannel({
-    port,
-    handler: notifyAll,
-  });
-
-  const start = () => channel.start();
-
-  const close = async () => {
-    await notifyAll({ done: true });
-    [...iterators].forEach((it) => it.return && it.return());
-    await channel.close();
-  };
-
-  async function* recieveAll() {
-    yield* recieveData((listener) => {
-      listeners.push(listener);
-      return () => listeners = listeners.filter((l) => l !== listener);
-    });
-  }
-
-  async function sendAll(it) {
-    await sendData(
-      channel.invoke,
-      (async function* () {
-        try {
-          iterators.push(it);
-          yield* it;
-        } finally {
-          iterators = iterators.filter((i) => i !== it);
-        }
-      })(),
-    );
-  }
-  return {
-    start,
-    close,
-    recieveAll,
-    sendAll,
-  };
-}
-
-function newInvokationChannel({
-  port,
-  handler = () => {
-    throw new Error("Handler not implemented");
-  },
-  onError = console.error,
-  newCallId = () =>
-    newInvokationChannel.__counter = (newInvokationChannel.__counter || 0) + 1,
-}) {
-  const MESSAGE_TYPE_REQUEST = "REQUEST";
-  const MESSAGE_TYPE_RESPONSE = "RESPONSE";
-  const EVENT_MESSAGE = "message";
-
-  const requests = {};
-  const listener = async (event) => {
-    const data = event.data || {};
-    const { type, callId } = data;
-    if (type === MESSAGE_TYPE_REQUEST) {
-      try {
-        const { request } = data;
-        let result = await handler(request, ...(event.ports || []));
-        const [response, ...transfers] = Array.isArray(result)
-          ? result
-          : result !== undefined
-          ? [result]
-          : [];
-        port.postMessage(
-          { type: MESSAGE_TYPE_RESPONSE, callId, response },
-          transfers,
-        );
-      } catch (error) {
-        port.postMessage({
-          type: MESSAGE_TYPE_RESPONSE,
-          callId,
-          error: serializeError(error),
-        });
-      }
-    } else if (type === MESSAGE_TYPE_RESPONSE) {
-      const { callId, response, error } = data;
-      const request = requests[callId];
-      delete requests[callId];
-      if (request) {
-        error
-          ? request.reject(deserializeError(error))
-          : request.resolve(response);
-      }
-    }
-  };
-
-  const start = async () => {
-    try {
-      port.addEventListener(EVENT_MESSAGE, listener);
-      port.start && await port.start();
-    } catch (e) {
-      onError(e);
-    }
-  };
-
-  const close = async () => {
-    try {
-      port.removeEventListener(EVENT_MESSAGE, listener);
-      port.close && await port.close();
-    } catch (e) {
-      onError(e);
-    }
-  };
-
-  const invoke = async function (request = {}, ...transfers) {
-    const callId = newCallId();
-    return new Promise((resolve, reject) => {
-      try {
-        requests[callId] = { resolve, reject };
-        port.postMessage(
-          { type: MESSAGE_TYPE_REQUEST, callId, request },
-          transfers,
-        );
-      } catch (error) {
-        reject(error);
-        delete request[callId];
-      }
-    });
-  };
-
-  return {
-    start,
-    close,
-    invoke,
-  };
-}
-
-function toReadableStream(it) {
-  return new ReadableStream({
-    type: "bytes",
-    async pull(controller) {
-      let handled = false;
-      try {
-        while (true) {
-          const slot = await it.next();
-          if (!slot || slot.done) {
-            break;
-          }
-          controller.enqueue(await slot.value);
-        }
-      } catch (error) {
-        handled = true;
-        controller.error(error);
-      } finally {
-        !handled && controller.close();
-      }
-    },
-  });
-}
-
-async function* fromReadableStream(stream) {
-  const reader = await stream.getReader();
-  let done, value;
-  while (({ done, value } = await reader.read())) {
-    if (done) {
-      break;
-    }
-    yield await value;
-  }
-}
-
-/**
- * This method returns an HTTP handlers transforming
- * HTTP Request instances to binary representations and
- * sending them to a transport layer.
- * Results of these transport ivokations are deserialized
- * as meaningful Response instances and returned back to the caller.
- *
- * The specified `send` method is used to dispatch serialized
- * requests to return the serialized remote results.
- * This transport method accepts and returns objects with
- * the same structure:
- * * `options` - contains serialized request or response parameters
- * * `content` - an async iterator over binary blocks for
- *    the request or response
- *
- * @param {*} send transport function accepting serialized requests
- * and returning back serialized responses
- * @returns an async handler accepting standard
- *   HTTP `Request` instances and returning `Response` instances
- */
-function newHttpClientStub(send) {
-  return async (request) => {
-    request = await request;
-    const fields = [
-      "url",
-      "method",
-      "mode",
-      "credentials",
-      "cache",
-      "redirect",
-      "referrer",
-      "referrerPolicy",
-      "integrity",
-      "keepalive"
-    ];
-    const headers = [...request.headers].map(([key, value]) => {
-      return [key, value]
-    });
-    const requestOptions = fields.reduce((options, key) => {
-      const val = request[key];
-      if (val !== undefined) options[key] = val;
-      return options;
-    }, {
-      headers
-    });
-    const requestContent = (request.body)
-      ? fromReadableStream(request.body)
-      : [];
-    const result = await send({
-      options: requestOptions,
-      content: requestContent,
-    });
-    let responseBody = null;
-    let responseOptions = {};
-    if (!result) {
-      responseOptions = {
-        status: 404,
-        statusText: "Error 404: Not Found",
-      };
-    } else {
-      responseOptions = result.options;
-      const responseContent = result.content;
-      if (
-        requestOptions.method !== "HEAD" &&
-        requestOptions.method !== "OPTIONS"
-      ) {
-        responseBody = toReadableStream(responseContent);
-      } else if (responseContent && responseContent.return) {
-        responseContent.return();
-      }
-    }
-    return new Response(responseBody, responseOptions);
-  };
-}
-
-/**
- * This method returns the server-side call handler transforming
- * serialized requests to HTTP Request instances, delegating
- * their handing to the given `handler` method. This handler
- * should handle the HTTP request and return a valid Response instance.
- * The resulting instance is serialized as an object with the same
- * structure as the initial serialized request:
- * - `options` - contains serialized request or response parameters
- * - `content` - an async iterator over binary blocks for
- *    the request or response
- * @param {*} handler this handler method accepts standard HTTP Request
- * and returns back an HTTP Response instance
- * @returns a method deserializing HTTP requests and returning back
- * serialized HTTP responses
- */
-function newHttpServerStub(handler) {
-  return async (params) => {
-    const {
-      options: requestOptions,
-      content: requestContent,
-    } = await params;
-    let requestBody = undefined;
-    const { url, mode, headers = [] } = requestOptions;
-    const requestHeaders = new Headers();
-    for (let  [key, value] of headers) {
-      requestHeaders.append(key, value);
-    }
-    delete requestOptions.mode;
-    delete requestOptions.url;
-    if (
-      requestOptions.method !== "GET" &&
-      requestOptions.method !== "HEAD" &&
-      requestOptions.method !== "OPTIONS"
-    ) {
-      requestBody = toReadableStream(requestContent);
-      requestOptions.duplex = "half";
-    } else if (requestContent && requestContent.return) {
-      requestContent.return();
-    }
-    const request = new Request(url, {
-      ...requestOptions,
-      headers: requestHeaders,
-      // duplex: 'full',
-      body: requestBody,
-    });
-    const response = await handler(request);
-    const responseOptions = {
-      status: response.status,
-      statusText: response.statusText,
-      headers: Object.fromEntries([...response.headers]),
-    };
-    const responseContent = await fromReadableStream(await response.body);
-    return {
-      options: responseOptions,
-      content: responseContent,
-    };
-  };
-}
-
-async function* httpToIterator(params) {
-  const { options, content } = await params;
-  const encoder = new TextEncoder();
-  yield encoder.encode(JSON.stringify(options));
-  yield* content;
-}
-
-async function httpFromIterator(it) {
-  it = await it;
-  const { done, value } = await it.next();
-  let options = {};
-  if (!done && value) {
-    const decoder = new TextDecoder();
-    const str = decoder.decode(value);
-    options = JSON.parse(str);
-  }
-  return {
-    options,
-    content: it,
-  };
-}
-
-function handleHttpRequests(communicationPort, handler) {
-  const serverStub = newHttpServerStub(handler);
-  return handleStreams(communicationPort, (it) => {
-    return httpToIterator(serverStub(httpFromIterator(it)));
-  });
-}
-
-async function sendHttpRequest(communicationPort, request) {
-  const clientStub = newHttpClientStub(async (req) => {
-    return await httpFromIterator(
-      sendStream(communicationPort, httpToIterator(req)),
-    );
-  });
-  return await clientStub(request);
-}
-
-function splitServiceUrl(url, separator = "~") {
-  let key = "";
-  let path = "";
-  let str = url + "";
-  const idx = str.indexOf(separator);
-  let baseUrl = "";
-  if (idx >= 0) {
-    baseUrl = str.substring(0, idx + separator.length);
-    str.substring(idx + separator.length)
-      .replace(/^([^\/]+)/, (match, $1) => {
-        baseUrl += match;
-        if (baseUrl.length < str.length) baseUrl += "/";
-        key = $1;
-        path = str.substring(baseUrl.length);
-        return "";
-      });
-  }
-  return {
-    url,
-    key,
-    baseUrl,
-    path,
-  };
-}
-
-function newServiceWorkerPort() {
-  // Bind the service worker to
-  const channel = new MessageChannel();
-  channel.port1.onmessage = (event) => {
-    navigator.serviceWorker.controller.postMessage(event.data, event.ports);
-  };
-  navigator.serviceWorker.addEventListener("message", (event) => {
-    channel.port1.postMessage(event.data, event.ports);
-  });
-  return channel.port2;
-}
-
-async function initServiceWorker1({ swUrl, scopeUrl, type }) {
-  const {
-    installing,
-    waiting,
-    active,
-  } = await navigator.serviceWorker.register(swUrl, {
-    // type: "module",
-    scope: scopeUrl,
-  });
-  (installing || waiting || active).addEventListener("statechange", (e) => {
-    console.log("state", e.target.state);
-  });
-
-  const serviceWorker = navigator.serviceWorker;
-  await new Promise((resolve) => {
-    // Resolve right away if this page is already controlled.
-    if (serviceWorker.controller) {
-      resolve();
-    } else {
-      const onChange = () => {
-        resolve();
-        serviceWorker.removeEventListener("controllerchange", onChange);
-        serviceWorker.oncontrollerchange = null;
-      };
-      serviceWorker.addEventListener("controllerchange", onChange);
-      serviceWorker.oncontrollerchange = onChange;
-    }
-  });
-  const worker = serviceWorker.controller;
-  const isActivated = () => worker.state === "activated";
-  return await new Promise(async (resolve) => {
-    if (isActivated()) resolve(worker);
-    else {
-      worker.onstatechange = () => {
-        if (!isActivated()) return;
-        worker.onstatechange = null;
-        resolve(worker);
-      };
-    }
-  });
-}
-
-async function initServiceWorker({ swUrl, scopeUrl, type }) {
-  await navigator.serviceWorker.register(swUrl, {
-    type,
-    scope: scopeUrl,
-  });
-  const worker = await getServiceWorkerController();
-  await awaitServiceWorkerActivation(worker);
-  return worker;
-
-  async function getServiceWorkerController() {
-    return await new Promise((resolve) => {
-      // Resolve right away if this page is already controlled.
-      const serviceWorker = navigator.serviceWorker;
-      if (serviceWorker.controller) {
-        resolve(serviceWorker.controller);
-      } else {
-        const onChange = () => {
-          resolve(serviceWorker.controller);
-          serviceWorker.removeEventListener("controllerchange", onChange);
-          serviceWorker.oncontrollerchange = null;
-        };
-        serviceWorker.addEventListener("controllerchange", onChange);
-        serviceWorker.oncontrollerchange = onChange;
-      }
-    });
-  }
-
-  // ------------------------------
-  // Await until the service is ready
-  async function awaitServiceWorkerActivation(worker) {
-    const isActivated = () => worker.state === "activated";
-    await new Promise(async (resolve) => {
-      if (isActivated()) resolve();
-      else {
-        worker.onstatechange = () => {
-          if (!isActivated()) return;
-          worker.onstatechange = null;
-          resolve();
-        };
-      }
-    });
-  }
-}
-
-async function initHttpService(handler, {
-  key,
-  port,
-}) {
-  return await registerConnectionsHandler({
-    key,
-    communicationPort: port,
-    handler: async (event, data, callPort) => {
-      handleHttpRequests(callPort, handler);
-      return true;
-    },
-  });
-}
-
-async function callHttpService(request, {
-  key,
-  port,
-}) {
-  const callPort = await initializeConnection({
-    key,
-    communicationPort: port,
-  });
-  const result = await sendHttpRequest(callPort, request);
-  return result;
-}
-
-function getRelayWindowMessageHandler({
-  swUrl = new URL("./index-sw.js", (typeof document === 'undefined' && typeof location === 'undefined' ? new (require('u' + 'rl').URL)('file:' + __filename).href : typeof document === 'undefined' ? location.href : (document.currentScript && document.currentScript.src || new URL('index-umd.js', document.baseURI).href))) + "",
-  scopeUrl = new URL("../", (typeof document === 'undefined' && typeof location === 'undefined' ? new (require('u' + 'rl').URL)('file:' + __filename).href : typeof document === 'undefined' ? location.href : (document.currentScript && document.currentScript.src || new URL('index-umd.js', document.baseURI).href))) + "",
-} = {}) {
-  let externalPort;
-  return async (ev) => {
-    if (ev.data.type === "CONNECT") {
-      const newExternalPort = (ev.ports || [])[0];
-      if (externalPort) {
-        newExternalPort.close();
-        return;
-      }
-      externalPort = newExternalPort;
-      await initServiceWorker({
-        swUrl,
-        scopeUrl,
-      });
-      const serviceWorkerPort = newServiceWorkerPort();
-      serviceWorkerPort.onmessage = (event) => {
-        externalPort.postMessage(event.data, event.ports);
-      };
-
-      externalPort.onmessage = (event) => {
-        serviceWorkerPort.postMessage(event.data, event.ports);
-      };
-    }
-  };
-}
-
-async function newRemoteRelayChannel({
-  baseUrl = new URL("../public-relay/", (typeof document === 'undefined' && typeof location === 'undefined' ? new (require('u' + 'rl').URL)('file:' + __filename).href : typeof document === 'undefined' ? location.href : (document.currentScript && document.currentScript.src || new URL('index-umd.js', document.baseURI).href))),
-  url = new URL("relay.html", baseUrl),
-  container = document.body,
-} = {}) {
-  const messageChannel = new MessageChannel();
-  const { iframe, promise } = await newIFrame(url);
-  Object.assign(iframe.style, {
-    // height: "100px"
-    position: "fixed",
-    width: "1px",
-    height: "1px",
-    top: "-1000",
-    left: "-1000",
-    display: "block",
-    opacity: "0",
-    border: "none",
-    outline: "none",
-  });
-  container.appendChild(iframe);
-  promise.then(() => {
-    iframe.contentWindow.postMessage(
-      {
-        type: "CONNECT",
-      },
-      "*",
-      [messageChannel.port1],
-    );
-  });
-  return {
-    baseUrl,
-    port: messageChannel.port2,
-    close: () => {
-      iframe.parentElement && iframe.parentElement.removeChild(iframe);
-      messageChannel.port1.close();
-      messageChannel.port2.close();
-    },
-  };
-
-  async function newIFrame(url) {
-    const iframe = document.createElement("iframe");
-    iframe.src = url;
-    Object.assign(iframe.style, {
-      padding: 0,
-      margin: 0,
-      border: "none",
-      outline: "none",
-      width: "100%",
-      height: "100%",
-    });
-    return {
-      iframe,
-      promise: new Promise((resolve, reject) => {
-        try {
-          iframe.onerror = reject;
-          iframe.onload = () => resolve(iframe);
-        } catch (error) {
-          reject(error);
-        }
-      }),
-    };
-  }
-}
-// -------------------------------------------------------
-
-async function initializeConnection({
-  key,
-  communicationPort,
-  ...options
-}) {
-  const channel = new MessageChannel();
-  const accepted = await callChannel(
-    communicationPort,
-    "CONNECT",
-    { key, ...options },
-    channel.port2,
-  );
-  if (!accepted) {
-    channel.port1.close();
-    channel.port2.close();
-    return null;
-  }
-  return channel.port1;
-}
-
-async function registerConnectionsHandler({
-  key,
-  handler,
-  communicationPort,
-}) {
-  const [register, cleanup] = newRegistry();
-  await callChannel(communicationPort, "REGISTER", { key });
-  register(() => callChannel(communicationPort, "UNREGISTER", { key }));
-  register(
-    handleChannelCalls(
-      communicationPort,
-      "CONNECT",
-      handler,
-    ),
-  );
-  return cleanup;
-}
-
-exports.callChannel = callChannel;
-exports.callHttpService = callHttpService;
-exports.deserializeError = deserializeError;
-exports.fromReadableStream = fromReadableStream;
-exports.getRelayWindowMessageHandler = getRelayWindowMessageHandler;
-exports.handleChannelCalls = handleChannelCalls;
-exports.handleHttpRequests = handleHttpRequests;
-exports.handleStreams = handleStreams;
-exports.initHttpService = initHttpService;
-exports.initServiceWorker = initServiceWorker;
-exports.initServiceWorker1 = initServiceWorker1;
-exports.initializeConnection = initializeConnection;
-exports.newHttpClientStub = newHttpClientStub;
-exports.newHttpServerStub = newHttpServerStub;
-exports.newInvokationChannel = newInvokationChannel;
-exports.newRegistry = newRegistry;
-exports.newRemoteRelayChannel = newRemoteRelayChannel;
-exports.newServiceWorkerPort = newServiceWorkerPort;
-exports.recieveData = recieveData;
-exports.registerConnectionsHandler = registerConnectionsHandler;
-exports.sendData = sendData;
-exports.sendHttpRequest = sendHttpRequest;
-exports.sendStream = sendStream;
-exports.serializeError = serializeError;
-exports.splitServiceUrl = splitServiceUrl;
-exports.toReadableStream = toReadableStream;
-
-}));