@statewalker/webrun-http-browser 0.3.3 → 0.4.2

package/dist/index-sw-umd.js

@@ -1,798 +0,0 @@
-// @statewalker/webrun-http-browser v0.3.3 https://github.com/statewalker/statewalker-webrun-http-browser Copyright 2023 Mikhail Kotelnikov
-(function (factory) {
-typeof define === 'function' && define.amd ? define(factory) :
-factory();
-})((function () { 'use strict';
-
-// 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
-  });
-}
-
-function promisifyRequest(request) {
-    return new Promise((resolve, reject) => {
-        // @ts-ignore - file size hacks
-        request.oncomplete = request.onsuccess = () => resolve(request.result);
-        // @ts-ignore - file size hacks
-        request.onabort = request.onerror = () => reject(request.error);
-    });
-}
-function createStore(dbName, storeName) {
-    const request = indexedDB.open(dbName);
-    request.onupgradeneeded = () => request.result.createObjectStore(storeName);
-    const dbp = promisifyRequest(request);
-    return (txMode, callback) => dbp.then((db) => callback(db.transaction(storeName, txMode).objectStore(storeName)));
-}
-let defaultGetStoreFunc;
-function defaultGetStore() {
-    if (!defaultGetStoreFunc) {
-        defaultGetStoreFunc = createStore('keyval-store', 'keyval');
-    }
-    return defaultGetStoreFunc;
-}
-/**
- * Get a value by its key.
- *
- * @param key
- * @param customStore Method to get a custom store. Use with caution (see the docs).
- */
-function get(key, customStore = defaultGetStore()) {
-    return customStore('readonly', (store) => promisifyRequest(store.get(key)));
-}
-/**
- * Set a value with a key.
- *
- * @param key
- * @param value
- * @param customStore Method to get a custom store. Use with caution (see the docs).
- */
-function set(key, value, customStore = defaultGetStore()) {
-    return customStore('readwrite', (store) => {
-        store.put(value, key);
-        return promisifyRequest(store.transaction);
-    });
-}
-
-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);
-}
-
-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();
-  }
-}
-
-/**
- * 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);
-  };
-}
-
-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,
-  };
-}
-
-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,
-  };
-}
-
-class HttpError extends Error {
-  constructor(options) {
-    super(options.message);
-    this.status = options.status;
-    this.statusText = options.statusText;
-  }
-  getResponseOptions(options = {}) {
-    return Object.assign(this.toJson(), options);
-  }
-  toJson() {
-    return {
-      status: this.status,
-      statusText: this.statusText,
-      message: this.message,
-    };
-  }
-
-  static fromError(error) {
-    if (!(error instanceof HttpError)) {
-      error = new HttpError(Object.assign({
-        status: 500,
-        statusText: "Bad Request",
-        reason: error.message,
-      }));
-    }
-    return error;
-  }
-
-  static errorResourceNotFound(options = {}) {
-    return new HttpError({
-      status: 404,
-      statusText: "Error 404: Resource not found",
-      ...options,
-    });
-  }
-  static errorForbidden(options = {}) {
-    return new HttpError({
-      status: 403,
-      statusText: "Error 403: Forbidden",
-      ...options,
-    });
-  }
-
-  static errorResourceGone(options = {}) {
-    return new HttpError({
-      status: 410,
-      statusText: "Error 410: Resource Gone",
-      ...options,
-    });
-  }
-
-  static errorInternalError(options) {
-    return new HttpError({
-      ...options,
-      status: 500,
-      statusText: "Error 500: Internal error",
-    });
-  }
-}
-
-function startRelayServiceWorker(self) {
-  const [register, clear] = newRegistry();
-
-  if (typeof self.skipWaiting === "function") {
-    console.log("self.skipWaiting() is supported.");
-    self.addEventListener("install", (e) => {
-      // See https://slightlyoff.github.io/ServiceWorker/spec/service_worker/index.html#service-worker-global-scope-skipwaiting
-      e.waitUntil(self.skipWaiting());
-    });
-  } else {
-    console.log("self.skipWaiting() is not supported.");
-  }
-
-  if (self.clients && (typeof self.clients.claim === "function")) {
-    console.log("self.clients.claim() is supported.");
-    self.addEventListener("activate", (e) => {
-      // See https://slightlyoff.github.io/ServiceWorker/spec/service_worker/index.html#clients-claim-method
-      e.waitUntil(self.clients.claim());
-    });
-  } else {
-    console.log("self.clients.claim() is not supported.");
-  }
-
-  const clientsRegistry = newClientsRegistry({
-    self,
-    get,
-    set,
-  });
-
-  // This listener handles the following message types:
-  // * registration: registers new clients as service providers
-  // * handles service calls rounting:
-  //   - it gets the clientKey defined in the call
-  //   - it uses the serviceKey to get the service-specifc channel
-  //   - it creates a new message channel and sent its ports to peers
-
-  register(handleChannelCalls(self, "REGISTER", async (event, data) => {
-    return await clientsRegistry.addClient(data.key, event.source);
-  }));
-  register(handleChannelCalls(self, "UNREGISTER", async (event, data) => {
-    return await clientsRegistry.removeClient(data.key);
-  }));
-
-  // Transfers all parameters (and ports) to the target client.
-  register(handleChannelCalls(self, "CONNECT", async (event, data, port) => {
-    const { key } = data;
-    const client = await clientsRegistry.getClient(key);
-    if (!client) {
-      throw new Error(`Target client was not found. Target key: "${key}".`);
-    }
-    return await callChannel(client, "CONNECT", data, port);
-  }));
-
-  const fetchListener = (event) => {
-    const request = event.request;
-    const params = splitServiceUrl(request.url);
-    const { key } = params;
-    if (key) {
-      const handler = async () => {
-        try {
-          const channel = new MessageChannel();
-          const client = await clientsRegistry.getClient(key);
-          if (!client) {
-            throw HttpError.errorResourceGone(params);
-          }
-          const data = {
-            type: "http",
-            key,
-          };
-          if (!await callChannel(client, "CONNECT", data, channel.port2)) {
-            throw HttpError.errorForbidden(params);
-          }
-          return await sendHttpRequest(channel.port1, request);
-        } catch (error) {
-          error = HttpError.fromError(error);
-          const options = error.getResponseOptions(params);
-          return new Response(JSON.stringify(options), {
-            ...options,
-            headers: {
-              "Content-Type": "text/javascript",
-            },
-          });
-        }
-      };
-      event.respondWith(handler());
-    }
-  };
-  self.addEventListener("fetch", fetchListener);
-  register(() => self.removeEventListener("fetch", fetchListener));
-
-  return clear;
-}
-
-// --------------------------------------------
-// errors.js
-
-// --------------------------------------------
-
-function newClientsRegistry({
-  self,
-  key = "clientsIds",
-  get,
-  set,
-}) {
-  let _index;
-  async function loadClientsIndex() {
-    if (!_index) {
-      const entries = (await get(key)) || [];
-      _index = Object.fromEntries(entries);
-    }
-    return _index;
-  }
-  async function storeClientsIndex() {
-    const index = await loadClientsIndex();
-    const entries = Object.entries(index);
-    await set(key, entries);
-    return index;
-  }
-
-  async function addClient(clientKey, client) {
-    const index = await loadClientsIndex();
-    const clientId = client.id;
-    let result = false;
-    if (!(clientId in index)) {
-      index[clientKey] = clientId;
-      await storeClientsIndex();
-      result = true;
-    }
-    return result;
-  }
-
-  async function removeClient(clientKey) {
-    const index = await loadClientsIndex();
-    let result = false;
-    if (clientKey in index) {
-      delete index[clientKey];
-      await storeClientsIndex();
-      result = true;
-    }
-    return result;
-  }
-
-  async function getClient(clientKey) {
-    const index = await loadClientsIndex();
-    const clientId = index[clientKey];
-    const client = await self.clients.get(clientId);
-    if (!client) {
-      delete index[clientKey];
-      await storeClientsIndex();
-    }
-    return client;
-  }
-
-  return {
-    getClient,
-    addClient,
-    removeClient,
-  };
-}
-// ----------------------------------------------------
-// Content of the "idb-keyval" package
-// import { get, set } from "idb-keyval";
-
-// function promisifyRequest(request) {
-//   return new Promise((resolve, reject) => {
-//     // @ts-ignore - file size hacks
-//     request.oncomplete = request.onsuccess = () => resolve(request.result);
-//     // @ts-ignore - file size hacks
-//     request.onabort = request.onerror = () => reject(request.error);
-//   });
-// }
-// function createStore(dbName, storeName) {
-//   const request = indexedDB.open(dbName);
-//   request.onupgradeneeded = () => request.result.createObjectStore(storeName);
-//   const dbp = promisifyRequest(request);
-//   return (txMode, callback) =>
-//     dbp.then((db) =>
-//       callback(db.transaction(storeName, txMode).objectStore(storeName))
-//     );
-// }
-// let defaultGetStoreFunc;
-// function defaultGetStore() {
-//   if (!defaultGetStoreFunc) {
-//     defaultGetStoreFunc = createStore("keyval-store", "keyval");
-//   }
-//   return defaultGetStoreFunc;
-// }
-// /**
-//  * Get a value by its key.
-//  *
-//  * @param key
-//  * @param customStore Method to get a custom store. Use with caution (see the docs).
-//  */
-// function get(key, customStore = defaultGetStore()) {
-//   return customStore("readonly", (store) => promisifyRequest(store.get(key)));
-// }
-// /**
-//  * Set a value with a key.
-//  *
-//  * @param key
-//  * @param value
-//  * @param customStore Method to get a custom store. Use with caution (see the docs).
-//  */
-// function set(key, value, customStore = defaultGetStore()) {
-//   return customStore("readwrite", (store) => {
-//     store.put(value, key);
-//     return promisifyRequest(store.transaction);
-//   });
-// }
-
-startRelayServiceWorker(self);
-//
-
-}));