@graffy/client 0.15.25-alpha.4 → 0.15.25-alpha.5

package/package.json

@@ -2,13 +2,8 @@
   "name": "@graffy/client",
   "description": "Graffy client library for the browser, usin the `fetch()` or `WebSocket` APIs. This module is intended to be used with a Node.js server running Graffy Server.",
   "author": "aravind (https://github.com/aravindet)",
-  "version": "0.15.25-alpha.4",
-  "main": "./index.cjs",
-  "exports": {
-    "import": "./index.mjs",
-    "require": "./index.cjs"
-  },
-  "module": "./index.mjs",
+  "version": "0.15.25-alpha.5",
+  "main": "./index.mjs",
   "types": "./types/index.d.ts",
   "repository": {
     "type": "git",
@@ -16,8 +11,8 @@
   },
   "license": "Apache-2.0",
   "dependencies": {
-    "@graffy/stream": "0.15.25-alpha.4",
-    "@graffy/common": "0.15.25-alpha.4",
+    "@graffy/stream": "0.15.25-alpha.5",
+    "@graffy/common": "0.15.25-alpha.5",
     "debug": "^4.3.3"
   }
 }

package/index.cjs

@@ -1,319 +0,0 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField = (obj, key, value) => {
-  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
-  return value;
-};
-const common = require("@graffy/common");
-const stream = require("@graffy/stream");
-const debug = require("debug");
-const _interopDefaultLegacy = (e) => e && typeof e === "object" && "default" in e ? e : { default: e };
-const debug__default = /* @__PURE__ */ _interopDefaultLegacy(debug);
-function getOptionsParam(options) {
-  if (!options)
-    return "";
-  return encodeURIComponent(common.serialize(options));
-}
-const aggregateQueries = {};
-class AggregateQuery {
-  constructor(url) {
-    __publicField(this, "combinedQuery", []);
-    __publicField(this, "readers", []);
-    __publicField(this, "timer", null);
-    this.url = url;
-  }
-  add(query) {
-    common.add(this.combinedQuery, query);
-    if (this.timer)
-      clearTimeout(this.timer);
-    this.timer = setTimeout(() => this.doFetch(), 0);
-    return new Promise((resolve, reject) => {
-      this.readers.push({ query, resolve, reject });
-    });
-  }
-  async doFetch() {
-    delete aggregateQueries[this.url];
-    const response = await fetch(this.url, {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: common.serialize(this.combinedQuery)
-    });
-    if (response.status !== 200) {
-      const message = await response.text();
-      const err = new Error(message);
-      for (const reader of this.readers) {
-        reader.reject(err);
-      }
-      return;
-    }
-    const data = await response.json();
-    for (const reader of this.readers) {
-      reader.resolve(data);
-    }
-  }
-}
-function makeQuery(url, query) {
-  if (!aggregateQueries[url])
-    aggregateQueries[url] = new AggregateQuery(url);
-  return aggregateQueries[url].add(query);
-}
-const httpClient = (baseUrl, {
-  getOptions = async () => {
-  },
-  watch = "sse",
-  connInfoPath = "connection"
-} = {}) => (store) => {
-  store.onWrite(connInfoPath, ({ url }) => {
-    baseUrl = url;
-    return { url };
-  });
-  store.onRead(connInfoPath, () => ({ url: baseUrl }));
-  store.on("read", async (query, options) => {
-    if (!fetch)
-      throw Error("client.fetch.unavailable");
-    const optionsParam = getOptionsParam(await getOptions("read", options));
-    const url = `${baseUrl}?opts=${optionsParam}&op=read`;
-    return makeQuery(url, query);
-  });
-  store.on("watch", async function* (query, options) {
-    if (watch === "none")
-      throw Error("client.no_watch");
-    if (watch === "hang") {
-      yield* stream.makeStream((push) => {
-        push(void 0);
-      });
-      return;
-    }
-    if (!EventSource)
-      throw Error("client.sse.unavailable");
-    const optionsParam = getOptionsParam(await getOptions("watch", options));
-    const url = `${baseUrl}?q=${common.encodeUrl(query)}&opts=${optionsParam}`;
-    const source = new EventSource(url);
-    yield* stream.makeStream((push, end) => {
-      source.onmessage = ({ data }) => {
-        push(common.deserialize(data));
-      };
-      source.onerror = (e) => {
-        end(Error("client.sse.transport: " + e.message));
-      };
-      source.addEventListener("graffyerror", (e) => {
-        end(Error("server." + e.data));
-      });
-      return () => {
-        source.close();
-      };
-    });
-  });
-  store.on("write", async (change, options) => {
-    if (!fetch)
-      throw Error("client.fetch.unavailable");
-    const optionsParam = getOptionsParam(await getOptions("write", options));
-    const url = `${baseUrl}?opts=${optionsParam}&op=write`;
-    return fetch(url, {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: common.serialize(change)
-    }).then((res) => {
-      if (res.status === 200)
-        return res.json();
-      return res.text().then((message) => {
-        throw Error("server." + message);
-      });
-    });
-  });
-};
-const log = debug__default.default("graffy:client:socket");
-log.log = console.log.bind(console);
-const MIN_DELAY = 1e3;
-const MAX_DELAY = 3e5;
-const DELAY_GROWTH = 1.5;
-const INTERVAL = 2e3;
-const PING_TIMEOUT = 4e4;
-const RESET_TIMEOUT = 1e4;
-function Socket(url, { onUnhandled = void 0, onStatusChange = void 0 } = {}) {
-  const handlers = {};
-  const buffer = [];
-  let isOpen = false;
-  let isConnecting = false;
-  let socket;
-  let lastAlive;
-  let lastAttempt;
-  let attempts = 0;
-  let connectTimer;
-  let aliveTimer;
-  function start(params, callback) {
-    const id = common.makeId();
-    const request = [id, ...params];
-    handlers[id] = { request, callback };
-    if (isAlive())
-      send(request);
-    return id;
-  }
-  function stop(id, params) {
-    delete handlers[id];
-    if (params)
-      send([id, ...params]);
-  }
-  function connect() {
-    log("Trying to connect to", url);
-    isOpen = false;
-    isConnecting = true;
-    lastAttempt = Date.now();
-    attempts++;
-    socket = new globalThis.WebSocket(url);
-    socket.onmessage = received;
-    socket.onerror = closed;
-    socket.onclose = closed;
-    socket.onopen = opened;
-  }
-  function received(event) {
-    const [id, ...data] = common.deserialize(event.data);
-    setAlive();
-    if (id === ":ping") {
-      send([":pong"]);
-    } else if (handlers[id]) {
-      handlers[id].callback(...data);
-    } else {
-      onUnhandled && onUnhandled(id, ...data);
-    }
-  }
-  function closed(_event) {
-    log("Closed");
-    if (isOpen && onStatusChange)
-      onStatusChange(false);
-    const wasOpen = isOpen;
-    isOpen = false;
-    isConnecting = false;
-    lastAttempt = Date.now();
-    if (wasOpen && !attempts) {
-      connect();
-      return;
-    }
-    maybeConnect();
-  }
-  function maybeConnect() {
-    const connDelay = lastAttempt + Math.min(MAX_DELAY, MIN_DELAY * Math.pow(DELAY_GROWTH, attempts)) - Date.now();
-    log("Will reconnect in", connDelay, "ms");
-    if (connDelay <= 0) {
-      connect();
-      return;
-    }
-    clearTimeout(connectTimer);
-    connectTimer = setTimeout(connect, connDelay);
-  }
-  function opened() {
-    log("Connected", buffer.length, Object.keys(handlers).length);
-    isOpen = true;
-    isConnecting = false;
-    lastAttempt = Date.now();
-    setAlive();
-    if (onStatusChange)
-      onStatusChange(true);
-    for (const id in handlers)
-      send(handlers[id].request);
-    while (buffer.length)
-      send(buffer.shift());
-  }
-  function setAlive() {
-    lastAlive = Date.now();
-    log("Set alive", lastAlive - lastAttempt);
-    if (lastAlive - lastAttempt > RESET_TIMEOUT)
-      attempts = 0;
-  }
-  function isAlive() {
-    log("Liveness check", isOpen ? "open" : "closed", Date.now() - lastAlive);
-    clearTimeout(aliveTimer);
-    aliveTimer = setTimeout(isAlive, INTERVAL);
-    if (!isOpen) {
-      if (!isConnecting)
-        maybeConnect();
-      return false;
-    }
-    if (Date.now() - lastAlive < PING_TIMEOUT)
-      return true;
-    socket.close();
-    return false;
-  }
-  function send(req) {
-    if (isAlive()) {
-      socket.send(common.serialize(req));
-    } else {
-      buffer.push(req);
-    }
-  }
-  connect();
-  aliveTimer = setTimeout(isAlive, INTERVAL);
-  return {
-    start,
-    stop,
-    isAlive
-  };
-}
-const wsClient = (url, {
-  getOptions = (..._) => false,
-  watch = void 0,
-  connInfoPath = "connection"
-} = {}) => (store) => {
-  if (!WebSocket)
-    throw Error("client.websocket.unavailable");
-  const socket = Socket(url, { onUnhandled, onStatusChange });
-  let status = false;
-  const statusWatcher = common.makeWatcher();
-  function onUnhandled(id) {
-    socket.stop(id, ["unwatch"]);
-  }
-  function onStatusChange(newStatus) {
-    status = newStatus;
-    statusWatcher.write({ status });
-  }
-  function once(op, payload, options) {
-    return new Promise((resolve, reject) => {
-      const id = socket.start(
-        [op, payload, getOptions(op, options) || {}],
-        (error, result) => {
-          socket.stop(id);
-          error ? reject(Error("server." + error)) : resolve(result);
-        }
-      );
-    });
-  }
-  store.onWrite(connInfoPath, () => {
-    status = socket.isAlive();
-    return { status };
-  });
-  store.onRead(connInfoPath, () => ({ status }));
-  store.onWatch(connInfoPath, () => statusWatcher.watch({ status }));
-  store.on("read", (query, options) => once("read", query, options));
-  store.on("write", (change, options) => once("write", change, options));
-  store.on("watch", (query, options) => {
-    if (watch === "none")
-      throw Error("client.no_watch");
-    const op = "watch";
-    return stream.makeStream((push, end) => {
-      const id = socket.start(
-        [op, query, getOptions(op, options) || {}],
-        (error, result) => {
-          if (error) {
-            socket.stop(id);
-            end(Error("server." + error));
-            return;
-          }
-          push(result);
-        }
-      );
-      return () => {
-        socket.stop(id, ["unwatch"]);
-      };
-    });
-  });
-};
-const WSRE = /^wss?:\/\//;
-function GraffyClient(baseUrl, options) {
-  if (WSRE.test(baseUrl)) {
-    return wsClient(baseUrl, options);
-  } else {
-    return httpClient(baseUrl, options);
-  }
-}
-module.exports = GraffyClient;