@fitzzero/quickdraw-core 5.1.1 → 5.1.3

package/dist/chunk-ASAMUGHG.js

@@ -0,0 +1,651 @@
+import {
+  MAX_SCOPE_LENGTH
+} from "./chunk-X4ZU4QH5.js";
+import {
+  utf8ByteLength
+} from "./chunk-7Y5ROPXL.js";
+import {
+  isName,
+  isRecord
+} from "./chunk-QSU47XEX.js";
+
+// src/client/peer/clock.ts
+var CLOCK_WINDOW = 24;
+var CLOCK_SYNC_SAMPLES = 5;
+var CLOCK_SLEW_MS = 5;
+var CLOCK_JUMP_MS = 250;
+var MAX_RTT_MS = 1e4;
+function fastest(samples) {
+  let best;
+  for (const sample of samples) {
+    if (best === void 0 || sample.rtt <= best.rtt) {
+      best = sample;
+    }
+  }
+  return best?.offset ?? 0;
+}
+function createClock(local = () => performance.now()) {
+  const samples = [];
+  let pongs = 0;
+  let offset = 0;
+  let rtt = 0;
+  let jitter = 0;
+  return {
+    now: () => local() + offset,
+    get offset() {
+      return offset;
+    },
+    get rtt() {
+      return rtt;
+    },
+    get jitter() {
+      return jitter;
+    },
+    get synced() {
+      return pongs >= CLOCK_SYNC_SAMPLES;
+    },
+    pong(t, u, at) {
+      const trip = at - t;
+      if (!(trip >= 0 && trip <= MAX_RTT_MS)) {
+        return;
+      }
+      samples.push({ rtt: trip, offset: u + trip / 2 - at });
+      if (samples.length > CLOCK_WINDOW) {
+        samples.shift();
+      }
+      pongs += 1;
+      if (pongs === 1) {
+        rtt = trip;
+        jitter = trip / 2;
+      } else {
+        jitter += (Math.abs(trip - rtt) - jitter) / 4;
+        rtt += (trip - rtt) / 8;
+      }
+      const target = fastest(samples);
+      const step = target - offset;
+      offset = pongs <= CLOCK_SYNC_SAMPLES || Math.abs(step) > CLOCK_JUMP_MS ? target : offset + Math.max(-CLOCK_SLEW_MS, Math.min(CLOCK_SLEW_MS, step));
+    }
+  };
+}
+
+// src/client/peer/codec.ts
+function encodeMessage(message) {
+  return JSON.stringify(message);
+}
+var messageBytes = utf8ByteLength;
+var decoder;
+function textOf(data) {
+  if (typeof data === "string") {
+    return data;
+  }
+  if (data instanceof ArrayBuffer || ArrayBuffer.isView(data)) {
+    decoder ??= new TextDecoder();
+    return decoder.decode(data);
+  }
+  return void 0;
+}
+function isTime(value) {
+  return typeof value === "number" && Number.isFinite(value);
+}
+function isHostName(value) {
+  return isName(value) && value.length <= MAX_SCOPE_LENGTH;
+}
+function readHostMessage(value) {
+  const [kind, service, name, third, fourth, fifth] = value;
+  if (!isHostName(service) || !isHostName(name)) {
+    return void 0;
+  }
+  if (kind === 3) {
+    return value.length >= 4 ? [3, service, name, third] : void 0;
+  }
+  if (!isHostName(third)) {
+    return void 0;
+  }
+  switch (kind) {
+    case 4:
+    case 5:
+      return [kind, service, name, third];
+    case 6:
+      return Array.isArray(fourth) && typeof fifth === "boolean" ? [6, service, name, third, fourth, fifth] : void 0;
+    case 7:
+      return value.length >= 5 ? [7, service, name, third, fourth] : void 0;
+    case 8:
+      return isRecord(fourth) && isName(fourth.code) && typeof fourth.message === "string" ? [8, service, name, third, { code: fourth.code, message: fourth.message }] : void 0;
+    default:
+      return void 0;
+  }
+}
+function decodeMessage(data) {
+  const text = textOf(data);
+  if (text === void 0) {
+    return void 0;
+  }
+  let value;
+  try {
+    value = JSON.parse(text);
+  } catch {
+    return void 0;
+  }
+  if (!Array.isArray(value)) {
+    return void 0;
+  }
+  const [kind, first, second] = value;
+  if (kind === 0 && value.length >= 2) {
+    return [0, first];
+  }
+  if (kind === 1 && isTime(first)) {
+    return [1, first];
+  }
+  if (kind === 2) {
+    return isTime(first) && isTime(second) ? [2, first, second] : void 0;
+  }
+  return readHostMessage(value);
+}
+
+// src/client/peer/lag.ts
+var LAG_RETRY_MS = 50;
+var MAX_RETRY_MS = 1e3;
+function checkLag(options, owner) {
+  const part = (name, max = Number.POSITIVE_INFINITY) => {
+    const value = options[name] ?? 0;
+    if (typeof value !== "number" || !Number.isFinite(value) || value < 0 || value > max) {
+      throw new TypeError(`${owner}: ${name} must be a number from 0${max === 1 ? " to 1" : ""}`);
+    }
+    return value;
+  };
+  const lag = Object.freeze({ ms: part("ms"), jitter: part("jitter"), loss: part("loss", 1) });
+  if (options.random !== void 0 && typeof options.random !== "function") {
+    throw new TypeError(`${owner}: random must be a function returning numbers from 0 to 1`);
+  }
+  return lag;
+}
+function handOn(item) {
+  try {
+    return item.deliver();
+  } catch (error) {
+    queueMicrotask(() => {
+      throw error;
+    });
+    return true;
+  }
+}
+function deliverRel(queue, item) {
+  if (handOn(item) === false && !queue.closed) {
+    queue.retry = setTimeout(() => {
+      queue.retry = void 0;
+      drain(queue);
+    }, queue.retryMs);
+    queue.retryMs = Math.min(MAX_RETRY_MS, queue.retryMs * 2);
+    return false;
+  }
+  queue.retryMs = LAG_RETRY_MS;
+  if (queue.rel[0] === item) {
+    queue.rel.shift();
+    clearTimeout(item.timer);
+  }
+  return true;
+}
+function deliverFast(queue, item) {
+  if (queue.fast.delete(item)) {
+    clearTimeout(item.timer);
+    handOn(item);
+  }
+}
+function drain(queue) {
+  if (queue.delivering || queue.retry !== void 0) {
+    return;
+  }
+  queue.delivering = true;
+  try {
+    for (let item = queue.rel[0]; item?.ready === true; item = queue.rel[0]) {
+      if (queue.closed || !deliverRel(queue, item)) {
+        return;
+      }
+    }
+  } finally {
+    queue.delivering = false;
+  }
+}
+function due(queue, item) {
+  item.timer = void 0;
+  const at = queue.rel.indexOf(item);
+  for (const ahead of queue.rel.slice(0, at + 1)) {
+    ahead.ready = true;
+  }
+  drain(queue);
+}
+function arm(queue, item) {
+  item.timer = setTimeout(
+    () => {
+      if (item.at > performance.now()) {
+        arm(queue, item);
+      } else if (item.label === "rel") {
+        due(queue, item);
+      } else {
+        deliverFast(queue, item);
+      }
+    },
+    Math.max(0, Math.ceil(item.at - performance.now()))
+  );
+}
+function nextHeld(queue) {
+  const [first] = queue.fast;
+  const rel = queue.retry === void 0 ? queue.rel[0] : void 0;
+  return rel !== void 0 && (first === void 0 || rel.seq < first.seq) ? rel : first;
+}
+function flush(queue) {
+  clearTimeout(queue.flushing);
+  queue.flushing = void 0;
+  if (queue.delivering) {
+    return;
+  }
+  const until = queue.seq;
+  for (const item of queue.rel) {
+    item.ready = true;
+  }
+  queue.delivering = true;
+  try {
+    for (let item = nextHeld(queue); item !== void 0; item = nextHeld(queue)) {
+      if (queue.closed || item.seq >= until) {
+        return;
+      }
+      if (item.label === "rel") {
+        deliverRel(queue, item);
+      } else {
+        deliverFast(queue, item);
+      }
+    }
+  } finally {
+    queue.delivering = false;
+  }
+}
+function push(queue, label, deliver) {
+  const { lag } = queue;
+  if (queue.closed) {
+    return true;
+  }
+  if (lag !== null && label === "fast" && queue.random() < lag.loss) {
+    return false;
+  }
+  let at = performance.now();
+  if (lag !== null) {
+    at += lag.ms + queue.random() * lag.jitter;
+  }
+  if (label === "rel") {
+    at = Math.max(at, queue.rel.at(-1)?.at ?? at);
+  }
+  const item = { label, seq: queue.seq, deliver, at, ready: false, timer: void 0 };
+  queue.seq += 1;
+  if (label === "rel") {
+    queue.rel.push(item);
+  } else {
+    queue.fast.add(item);
+  }
+  arm(queue, item);
+  return true;
+}
+function close(queue) {
+  queue.closed = true;
+  for (const item of [...queue.rel, ...queue.fast]) {
+    clearTimeout(item.timer);
+  }
+  queue.rel.length = 0;
+  queue.fast.clear();
+  clearTimeout(queue.retry);
+  clearTimeout(queue.flushing);
+  queue.retry = void 0;
+  queue.flushing = void 0;
+}
+function createLagQueue(lag, random = Math.random) {
+  const queue = {
+    lag,
+    random,
+    rel: [],
+    fast: /* @__PURE__ */ new Set(),
+    seq: 0,
+    retry: void 0,
+    retryMs: LAG_RETRY_MS,
+    flushing: void 0,
+    delivering: false,
+    closed: false
+  };
+  return Object.freeze({
+    get idle() {
+      return queue.lag === null && queue.rel.length === 0 && queue.fast.size === 0;
+    },
+    get blocked() {
+      return queue.retry !== void 0;
+    },
+    push: (label, deliver) => push(queue, label, deliver),
+    set(next, nextRandom = Math.random) {
+      if (queue.closed) {
+        return;
+      }
+      queue.lag = next;
+      queue.random = nextRandom;
+      if (next === null && (queue.rel.length > 0 || queue.fast.size > 0)) {
+        queue.flushing ??= setTimeout(() => {
+          flush(queue);
+        }, 0);
+      }
+    },
+    flush: () => {
+      flush(queue);
+    },
+    close: () => {
+      close(queue);
+    }
+  });
+}
+
+// src/client/peer/core.ts
+var QUICK_PINGS = 6;
+var QUICK_PING_MS = 80;
+var PING_MS = 500;
+var WATCHDOG_MS = 8e3;
+function throwLater(error) {
+  queueMicrotask(() => {
+    throw error;
+  });
+}
+function emit(core, event, ...args) {
+  for (const listener of [...core.listeners[event]]) {
+    try {
+      listener(...args);
+    } catch (error) {
+      throwLater(error);
+    }
+  }
+}
+function finish(core, reason, fromHere) {
+  if (core.state === "closed") {
+    return;
+  }
+  core.state = "closed";
+  core.path = void 0;
+  core.closeReason = reason;
+  clearTimeout(core.timer);
+  core.outgoing.close();
+  core.incoming.close();
+  core.options.hooks.closed(reason, fromHere);
+  emit(core, "state", "closed", void 0);
+  emit(core, "close", reason);
+  for (const set of Object.values(core.listeners)) {
+    set.clear();
+  }
+  core.control.clear();
+}
+function tick(core) {
+  core.timer = void 0;
+  if (core.state !== "open") {
+    return;
+  }
+  if (core.options.watchdog !== false && core.now() - core.lastHeard > WATCHDOG_MS) {
+    finish(core, "lost", true);
+    return;
+  }
+  transmit(core, "fast", encodeMessage([1, core.now()]), false);
+  core.pingsLeft = Math.max(0, core.pingsLeft - 1);
+  core.timer = setTimeout(
+    () => {
+      tick(core);
+    },
+    core.pingsLeft > 0 ? QUICK_PING_MS : PING_MS
+  );
+}
+function textOf2(core, message, what) {
+  const text = encodeMessage(message);
+  const bytes = messageBytes(text);
+  const max = core.options.maxMessageBytes();
+  if (bytes > max) {
+    throw new RangeError(
+      `${what}: a message holds at most ${max} bytes as JSON; this one has ${bytes}: split it`
+    );
+  }
+  return text;
+}
+function transmit(core, label, text, app) {
+  const { stats, outgoing } = core;
+  const put = () => {
+    const sent = core.state === "open" && core.options.hooks.send(label, text);
+    if (app && sent) {
+      stats.sent += 1;
+    }
+    return sent;
+  };
+  if (outgoing.idle) {
+    const sent = put();
+    if (app && !sent) {
+      stats.dropped += 1;
+    }
+    return sent;
+  }
+  if (label === "rel" && outgoing.blocked) {
+    if (app) {
+      stats.dropped += 1;
+    }
+    return false;
+  }
+  const held = outgoing.push(label, () => {
+    const sent = put();
+    if (app && !sent && label === "fast") {
+      stats.dropped += 1;
+    }
+    return sent;
+  });
+  if (app && !held) {
+    stats.simulatedLoss += 1;
+  }
+  return true;
+}
+function send(core, label, data) {
+  if (label !== "rel" && label !== "fast") {
+    throw new TypeError(`PeerLink.send: label must be "rel" or "fast", not ${String(label)}`);
+  }
+  const text = textOf2(core, [0, data], "PeerLink.send");
+  if (core.state !== "open") {
+    core.stats.dropped += 1;
+    return false;
+  }
+  return transmit(core, label, text, true);
+}
+function hear(core, message, label) {
+  if (core.state === "closed") {
+    return;
+  }
+  core.lastHeard = core.now();
+  if (message[0] === 0) {
+    core.stats.received += 1;
+    emit(core, "message", message[1], label);
+  } else if (message[0] === 1) {
+    if (core.state === "open") {
+      transmit(core, "fast", encodeMessage([2, message[1], core.now()]), false);
+    }
+  } else if (message[0] === 2) {
+    core.clock.pong(message[1], message[2], core.now());
+  } else {
+    for (const listener of [...core.control]) {
+      try {
+        listener(message, label);
+      } catch (error) {
+        throwLater(error);
+      }
+    }
+  }
+}
+function receive(core, data, label) {
+  const message = core.state === "closed" ? void 0 : decodeMessage(data);
+  if (message === void 0) {
+    return;
+  }
+  if (core.incoming.idle) {
+    hear(core, message, label);
+    return;
+  }
+  const held = core.incoming.push(label, () => {
+    hear(core, message, label);
+  });
+  if (!held && message[0] === 0) {
+    core.stats.simulatedLoss += 1;
+  }
+}
+function setLag(core, options) {
+  if (options !== null && typeof options !== "object") {
+    throw new TypeError("PeerLink.setLag: pass { ms, jitter, loss }, or null for none");
+  }
+  const lag = options === null ? null : checkLag(options, "PeerLink.setLag");
+  if (core.state === "closed") {
+    return;
+  }
+  core.lag = lag === null || lag.ms === 0 && lag.jitter === 0 && lag.loss === 0 ? null : lag;
+  const random = options?.random ?? Math.random;
+  core.outgoing.set(core.lag, random);
+  core.incoming.set(core.lag, random);
+}
+function carry(core, path) {
+  if (core.state === "closed" || core.state === "open" && core.path === path) {
+    return;
+  }
+  const opening = core.state === "connecting";
+  core.state = "open";
+  core.path = path;
+  if (opening) {
+    core.lastHeard = core.now();
+    core.pingsLeft = QUICK_PINGS;
+    emit(core, "open", path);
+  }
+  emit(core, "state", "open", path);
+  if (opening && core.state === "open") {
+    tick(core);
+  }
+}
+function clockView(clock) {
+  return Object.freeze({
+    now: () => clock.now(),
+    get offset() {
+      return clock.offset;
+    },
+    get rtt() {
+      return clock.rtt;
+    },
+    get jitter() {
+      return clock.jitter;
+    },
+    get synced() {
+      return clock.synced;
+    }
+  });
+}
+function linkOf(core) {
+  const { listeners } = core;
+  return Object.freeze({
+    room: core.options.room,
+    peer: core.options.peer,
+    get userId() {
+      return core.userId;
+    },
+    get state() {
+      return core.state;
+    },
+    get path() {
+      return core.path;
+    },
+    get closeReason() {
+      return core.closeReason;
+    },
+    send: (label, data) => send(core, label, data),
+    on(event, listener) {
+      if (!Object.hasOwn(listeners, event)) {
+        throw new TypeError(`PeerLink.on: no event "${String(event)}"`);
+      }
+      listeners[event].add(listener);
+      return () => {
+        listeners[event].delete(listener);
+      };
+    },
+    clock: clockView(core.clock),
+    get stats() {
+      return Object.freeze({ ...core.stats });
+    },
+    setLag: (options) => {
+      setLag(core, options);
+    },
+    get lag() {
+      return core.lag;
+    },
+    close: () => {
+      finish(core, "closed", true);
+    }
+  });
+}
+var CORES = /* @__PURE__ */ new WeakMap();
+function controlOf(link) {
+  const core = CORES.get(link);
+  if (core === void 0) {
+    return void 0;
+  }
+  return {
+    send: (label, message) => core.state === "open" && transmit(core, label, textOf2(core, message, "host mode"), false),
+    on(listener) {
+      if (core.state === "closed") {
+        return () => void 0;
+      }
+      core.control.add(listener);
+      return () => {
+        core.control.delete(listener);
+      };
+    }
+  };
+}
+function createLinkCore(options) {
+  const now = options.now ?? (() => performance.now());
+  const core = {
+    options,
+    now,
+    clock: createClock(now),
+    listeners: { message: /* @__PURE__ */ new Set(), open: /* @__PURE__ */ new Set(), state: /* @__PURE__ */ new Set(), close: /* @__PURE__ */ new Set() },
+    state: "connecting",
+    path: void 0,
+    closeReason: void 0,
+    userId: void 0,
+    lastHeard: 0,
+    pingsLeft: 0,
+    timer: void 0,
+    stats: { sent: 0, received: 0, dropped: 0, simulatedLoss: 0 },
+    control: /* @__PURE__ */ new Set(),
+    lag: null,
+    outgoing: createLagQueue(null),
+    incoming: createLagQueue(null)
+  };
+  const link = linkOf(core);
+  CORES.set(link, core);
+  return {
+    link,
+    receive: (data, label) => {
+      receive(core, data, label);
+    },
+    carry: (path) => {
+      carry(core, path);
+    },
+    end: (reason) => {
+      finish(core, reason, false);
+    },
+    fail: (reason) => {
+      finish(core, reason, true);
+    },
+    identify: (userId) => {
+      core.userId ??= userId;
+    }
+  };
+}
+
+export {
+  encodeMessage,
+  messageBytes,
+  checkLag,
+  createLagQueue,
+  throwLater,
+  controlOf,
+  createLinkCore
+};
+//# sourceMappingURL=chunk-ASAMUGHG.js.map