tinybase 5.0.0-beta.1 → 5.0.0-beta.11

package/lib/debug/synchronizers/synchronizer-ws-server.js

@@ -0,0 +1,241 @@
+const EMPTY_STRING = '';
+const UTF8 = 'utf8';
+
+const isUndefined = (thing) => thing == void 0;
+const ifNotUndefined = (value, then, otherwise) =>
+  isUndefined(value) ? otherwise?.() : then(value);
+const isArray = (thing) => Array.isArray(thing);
+const slice = (arrayOrString, start, end) => arrayOrString.slice(start, end);
+const size = (arrayOrString) => arrayOrString.length;
+const test = (regex, subject) => regex.test(subject);
+
+const arrayForEach = (array, cb) => array.forEach(cb);
+const arrayReduce = (array, cb, initial) => array.reduce(cb, initial);
+const arrayPush = (array, ...values) => array.push(...values);
+const arrayShift = (array) => array.shift();
+
+const object = Object;
+const objFreeze = object.freeze;
+
+const collSizeN = (collSizer) => (coll) =>
+  arrayReduce(collValues(coll), (total, coll2) => total + collSizer(coll2), 0);
+const collSize = (coll) => coll?.size ?? 0;
+const collSize2 = collSizeN(collSize);
+const collHas = (coll, keyOrValue) => coll?.has(keyOrValue) ?? false;
+const collIsEmpty = (coll) => isUndefined(coll) || collSize(coll) == 0;
+const collValues = (coll) => [...(coll?.values() ?? [])];
+const collClear = (coll) => coll.clear();
+const collForEach = (coll, cb) => coll?.forEach(cb);
+const collDel = (coll, keyOrValue) => coll?.delete(keyOrValue);
+
+const mapNew = (entries) => new Map(entries);
+const mapKeys = (map) => [...(map?.keys() ?? [])];
+const mapGet = (map, key) => map?.get(key);
+const mapForEach = (map, cb) =>
+  collForEach(map, (value, key) => cb(key, value));
+const mapSet = (map, key, value) =>
+  isUndefined(value) ? (collDel(map, key), map) : map?.set(key, value);
+const mapEnsure = (map, key, getDefaultValue, hadExistingValue) => {
+  if (!collHas(map, key)) {
+    mapSet(map, key, getDefaultValue());
+  } else {
+    hadExistingValue?.(mapGet(map, key));
+  }
+  return mapGet(map, key);
+};
+const visitTree = (node, path, ensureLeaf, pruneLeaf, p = 0) =>
+  ifNotUndefined(
+    (ensureLeaf ? mapEnsure : mapGet)(
+      node,
+      path[p],
+      p > size(path) - 2 ? ensureLeaf : mapNew,
+    ),
+    (nodeOrLeaf) => {
+      if (p > size(path) - 2) {
+        if (pruneLeaf?.(nodeOrLeaf)) {
+          mapSet(node, path[p]);
+        }
+        return nodeOrLeaf;
+      }
+      const leaf = visitTree(nodeOrLeaf, path, ensureLeaf, pruneLeaf, p + 1);
+      if (collIsEmpty(nodeOrLeaf)) {
+        mapSet(node, path[p]);
+      }
+      return leaf;
+    },
+  );
+
+const MESSAGE_SEPARATOR = '\n';
+
+const setNew = (entryOrEntries) =>
+  new Set(
+    isArray(entryOrEntries) || isUndefined(entryOrEntries)
+      ? entryOrEntries
+      : [entryOrEntries],
+  );
+const setAdd = (set, value) => set?.add(value);
+
+const INTEGER = /^\d+$/;
+const getPoolFunctions = () => {
+  const pool = [];
+  let nextId = 0;
+  return [
+    (reuse) => (reuse ? arrayShift(pool) : null) ?? EMPTY_STRING + nextId++,
+    (id) => {
+      if (test(INTEGER, id) && size(pool) < 1e3) {
+        arrayPush(pool, id);
+      }
+    },
+  ];
+};
+
+const getWildcardedLeaves = (deepIdSet, path = [EMPTY_STRING]) => {
+  const leaves = [];
+  const deep = (node, p) =>
+    p == size(path)
+      ? arrayPush(leaves, node)
+      : path[p] === null
+        ? collForEach(node, (node2) => deep(node2, p + 1))
+        : arrayForEach([path[p], null], (id) => deep(mapGet(node, id), p + 1));
+  deep(deepIdSet, 0);
+  return leaves;
+};
+const getListenerFunctions = (getThing) => {
+  let thing;
+  const [getId, releaseId] = getPoolFunctions();
+  const allListeners = mapNew();
+  const addListener = (
+    listener,
+    idSetNode,
+    path,
+    pathGetters = [],
+    extraArgsGetter = () => [],
+  ) => {
+    thing ??= getThing();
+    const id = getId(1);
+    mapSet(allListeners, id, [
+      listener,
+      idSetNode,
+      path,
+      pathGetters,
+      extraArgsGetter,
+    ]);
+    setAdd(visitTree(idSetNode, path ?? [EMPTY_STRING], setNew), id);
+    return id;
+  };
+  const callListeners = (idSetNode, ids, ...extraArgs) =>
+    arrayForEach(getWildcardedLeaves(idSetNode, ids), (set) =>
+      collForEach(set, (id) =>
+        mapGet(allListeners, id)[0](thing, ...(ids ?? []), ...extraArgs),
+      ),
+    );
+  const delListener = (id) =>
+    ifNotUndefined(mapGet(allListeners, id), ([, idSetNode, idOrNulls]) => {
+      visitTree(idSetNode, idOrNulls ?? [EMPTY_STRING], void 0, (idSet) => {
+        collDel(idSet, id);
+        return collIsEmpty(idSet) ? 1 : 0;
+      });
+      mapSet(allListeners, id);
+      releaseId(id);
+      return idOrNulls;
+    });
+  const callListener = (id) =>
+    ifNotUndefined(
+      mapGet(allListeners, id),
+      ([listener, , path = [], pathGetters, extraArgsGetter]) => {
+        const callWithIds = (...ids) => {
+          const index = size(ids);
+          index == size(path)
+            ? listener(thing, ...ids, ...extraArgsGetter(ids))
+            : isUndefined(path[index])
+              ? arrayForEach(pathGetters[index]?.(...ids) ?? [], (id2) =>
+                  callWithIds(...ids, id2),
+                )
+              : callWithIds(...ids, path[index]);
+        };
+        callWithIds();
+      },
+    );
+  return [addListener, callListeners, delListener, callListener];
+};
+
+const PATH_REGEX = /\/([^?]*)/;
+const createWsServer = (webSocketServer) => {
+  const pathIdListeners = mapNew();
+  const clientIdListeners = mapNew();
+  const clientsByPath = mapNew();
+  const [addListener, callListeners, delListenerImpl] = getListenerFunctions(
+    () => wsServer,
+  );
+  webSocketServer.on('connection', (webSocket, request) =>
+    ifNotUndefined(request.url?.match(PATH_REGEX), ([, pathId]) =>
+      ifNotUndefined(request.headers['sec-websocket-key'], (clientId) => {
+        const clients = mapEnsure(clientsByPath, pathId, mapNew);
+        mapSet(clients, clientId, webSocket);
+        if (clients.size == 1) {
+          callListeners(pathIdListeners, void 0, () => ({[pathId]: 1}));
+        }
+        callListeners(clientIdListeners, [pathId], () => ({[clientId]: 1}));
+        webSocket.on('message', (data) => {
+          const payload = data.toString(UTF8);
+          const splitAt = payload.indexOf(MESSAGE_SEPARATOR);
+          if (splitAt !== -1) {
+            const toClientId = slice(payload, 0, splitAt);
+            const message = slice(payload, splitAt + 1);
+            toClientId === EMPTY_STRING
+              ? mapForEach(clients, (otherClientId, otherWebSocket) =>
+                  otherClientId != clientId
+                    ? otherWebSocket.send(
+                        clientId + MESSAGE_SEPARATOR + message,
+                      )
+                    : 0,
+                )
+              : mapGet(clients, toClientId)?.send(
+                  clientId + MESSAGE_SEPARATOR + message,
+                );
+          }
+        });
+        webSocket.on('close', () => {
+          collDel(clients, clientId);
+          callListeners(clientIdListeners, [pathId], () => ({[clientId]: -1}));
+          if (collIsEmpty(clients)) {
+            collDel(clientsByPath, pathId);
+            callListeners(pathIdListeners, void 0, () => ({[pathId]: -1}));
+          }
+        });
+      }),
+    ),
+  );
+  const getWebSocketServer = () => webSocketServer;
+  const getPathIds = () => mapKeys(clientsByPath);
+  const getClientIds = (path) => mapKeys(mapGet(clientsByPath, path));
+  const addPathIdsListener = (listener) =>
+    addListener(listener, pathIdListeners);
+  const addClientIdsListener = (pathId, listener) =>
+    addListener(listener, clientIdListeners, [pathId]);
+  const delListener = (listenerId) => {
+    delListenerImpl(listenerId);
+    return wsServer;
+  };
+  const getStats = () => ({
+    paths: collSize(clientsByPath),
+    clients: collSize2(clientsByPath),
+  });
+  const destroy = () => {
+    webSocketServer.close();
+    collClear(clientsByPath);
+  };
+  const wsServer = {
+    getWebSocketServer,
+    getPathIds,
+    getClientIds,
+    addPathIdsListener,
+    addClientIdsListener,
+    delListener,
+    getStats,
+    destroy,
+  };
+  return objFreeze(wsServer);
+};
+
+export {createWsServer};