cojson 0.8.11 → 0.8.16

package/src/PeerKnownStates.ts

@@ -1,108 +1,110 @@
 import { RawCoID, SessionID } from "./ids.js";
-import { CoValueKnownState, emptyKnownState, combinedKnownStates } from "./sync.js";
+import {
+  CoValueKnownState,
+  combinedKnownStates,
+  emptyKnownState,
+} from "./sync.js";
 
-type PeerKnownStateActions = {
-    type: "SET_AS_EMPTY";
-    id: RawCoID;
-} | {
-    type: "UPDATE_HEADER";
-    id: RawCoID;
-    header: boolean;
-} |
-{
-    type: "UPDATE_SESSION_COUNTER";
-    id: RawCoID;
-    sessionId: SessionID;
-    value: number;
-} |
-{
-    type: "SET";
-    id: RawCoID;
-    value: CoValueKnownState;
-} |
-{
-    type: "COMBINE_WITH";
-    id: RawCoID;
-    value: CoValueKnownState;
-};
+type PeerKnownStateActions =
+  | {
+      type: "SET_AS_EMPTY";
+      id: RawCoID;
+    }
+  | {
+      type: "UPDATE_HEADER";
+      id: RawCoID;
+      header: boolean;
+    }
+  | {
+      type: "UPDATE_SESSION_COUNTER";
+      id: RawCoID;
+      sessionId: SessionID;
+      value: number;
+    }
+  | {
+      type: "SET";
+      id: RawCoID;
+      value: CoValueKnownState;
+    }
+  | {
+      type: "COMBINE_WITH";
+      id: RawCoID;
+      value: CoValueKnownState;
+    };
 
 export class PeerKnownStates {
-    private coValues = new Map<RawCoID, CoValueKnownState>();
+  private coValues = new Map<RawCoID, CoValueKnownState>();
 
-    private updateHeader(id: RawCoID, header: boolean) {
-        const knownState = this.coValues.get(id) ?? emptyKnownState(id);
-        knownState.header = header;
-        this.coValues.set(id, knownState);
-    }
+  private updateHeader(id: RawCoID, header: boolean) {
+    const knownState = this.coValues.get(id) ?? emptyKnownState(id);
+    knownState.header = header;
+    this.coValues.set(id, knownState);
+  }
 
-    private combineWith(id: RawCoID, value: CoValueKnownState) {
-        const knownState = this.coValues.get(id) ?? emptyKnownState(id);
-        this.coValues.set(id, combinedKnownStates(knownState, value));
-    }
+  private combineWith(id: RawCoID, value: CoValueKnownState) {
+    const knownState = this.coValues.get(id) ?? emptyKnownState(id);
+    this.coValues.set(id, combinedKnownStates(knownState, value));
+  }
 
-    private updateSessionCounter(
-        id: RawCoID,
-        sessionId: SessionID,
-        value: number
-    ) {
-        const knownState = this.coValues.get(id) ?? emptyKnownState(id);
-        const currentValue = knownState.sessions[sessionId] || 0;
-        knownState.sessions[sessionId] = Math.max(currentValue, value);
+  private updateSessionCounter(
+    id: RawCoID,
+    sessionId: SessionID,
+    value: number,
+  ) {
+    const knownState = this.coValues.get(id) ?? emptyKnownState(id);
+    const currentValue = knownState.sessions[sessionId] || 0;
+    knownState.sessions[sessionId] = Math.max(currentValue, value);
 
-        this.coValues.set(id, knownState);
-    }
+    this.coValues.set(id, knownState);
+  }
 
-    get(id: RawCoID) {
-        return this.coValues.get(id);
-    }
-
-    has(id: RawCoID) {
-        return this.coValues.has(id);
-    }
+  get(id: RawCoID) {
+    return this.coValues.get(id);
+  }
 
-    dispatch(action: PeerKnownStateActions) {
-        switch (action.type) {
-            case "UPDATE_HEADER":
-                this.updateHeader(action.id, action.header);
-                break;
-            case "UPDATE_SESSION_COUNTER":
-                this.updateSessionCounter(
-                    action.id,
-                    action.sessionId,
-                    action.value
-                );
-                break;
-            case "SET":
-                this.coValues.set(action.id, action.value);
-                break;
-            case "COMBINE_WITH":
-                this.combineWith(action.id, action.value);
-                break;
-            case "SET_AS_EMPTY":
-                this.coValues.set(action.id, emptyKnownState(action.id));
-                break;
-        }
+  has(id: RawCoID) {
+    return this.coValues.has(id);
+  }
 
-        this.triggerUpdate(action.id);
+  dispatch(action: PeerKnownStateActions) {
+    switch (action.type) {
+      case "UPDATE_HEADER":
+        this.updateHeader(action.id, action.header);
+        break;
+      case "UPDATE_SESSION_COUNTER":
+        this.updateSessionCounter(action.id, action.sessionId, action.value);
+        break;
+      case "SET":
+        this.coValues.set(action.id, action.value);
+        break;
+      case "COMBINE_WITH":
+        this.combineWith(action.id, action.value);
+        break;
+      case "SET_AS_EMPTY":
+        this.coValues.set(action.id, emptyKnownState(action.id));
+        break;
     }
 
-    listeners = new Set<(id: RawCoID, knownState: CoValueKnownState) => void>();
+    this.triggerUpdate(action.id);
+  }
 
-    triggerUpdate(id: RawCoID) {
-        this.trigger(id, this.coValues.get(id) ?? emptyKnownState(id));
-    }
+  listeners = new Set<(id: RawCoID, knownState: CoValueKnownState) => void>();
+
+  triggerUpdate(id: RawCoID) {
+    this.trigger(id, this.coValues.get(id) ?? emptyKnownState(id));
+  }
 
-    private trigger(id: RawCoID, knownState: CoValueKnownState) {
-        for (const listener of this.listeners) {
-            listener(id, knownState);
-        }
+  private trigger(id: RawCoID, knownState: CoValueKnownState) {
+    for (const listener of this.listeners) {
+      listener(id, knownState);
     }
+  }
 
-    subscribe(listener: (id: RawCoID, knownState: CoValueKnownState) => void) {
-        this.listeners.add(listener);
+  subscribe(listener: (id: RawCoID, knownState: CoValueKnownState) => void) {
+    this.listeners.add(listener);
 
-        return () => {
-            this.listeners.delete(listener);
-        };
-    }
+    return () => {
+      this.listeners.delete(listener);
+    };
+  }
 }

package/src/PeerState.ts

@@ -1,87 +1,90 @@
-import { RawCoID } from "./ids.js";
 import { PeerKnownStates } from "./PeerKnownStates.js";
-import { CO_VALUE_PRIORITY } from "./priority.js";
 import {
-    PriorityBasedMessageQueue,
-    QueueEntry,
+  PriorityBasedMessageQueue,
+  QueueEntry,
 } from "./PriorityBasedMessageQueue.js";
+import { RawCoID } from "./ids.js";
+import { CO_VALUE_PRIORITY } from "./priority.js";
 import { Peer, SyncMessage } from "./sync.js";
 
 export class PeerState {
-    constructor(private peer: Peer) {}
-
-    readonly optimisticKnownStates = new PeerKnownStates();
-    readonly toldKnownState: Set<RawCoID> = new Set();
-
-    get id() {
-        return this.peer.id;
+  constructor(private peer: Peer) {}
+
+  readonly optimisticKnownStates = new PeerKnownStates();
+  readonly toldKnownState: Set<RawCoID> = new Set();
+
+  get id() {
+    return this.peer.id;
+  }
+
+  get role() {
+    return this.peer.role;
+  }
+
+  get priority() {
+    return this.peer.priority;
+  }
+
+  get crashOnClose() {
+    return this.peer.crashOnClose;
+  }
+
+  isServerOrStoragePeer() {
+    return this.peer.role === "server" || this.peer.role === "storage";
+  }
+
+  /**
+   * We set as default priority HIGH to handle all the messages without a
+   * priority property as HIGH priority.
+   *
+   * This way we consider all the non-content messsages as HIGH priority.
+   */
+  private queue = new PriorityBasedMessageQueue(CO_VALUE_PRIORITY.HIGH);
+  private processing = false;
+  public closed = false;
+
+  async processQueue() {
+    if (this.processing) {
+      return;
     }
 
-    get role() {
-        return this.peer.role;
+    this.processing = true;
+
+    let entry: QueueEntry | undefined;
+    while ((entry = this.queue.pull())) {
+      // Awaiting the push to send one message at a time
+      // This way when the peer is "under pressure" we can enqueue all
+      // the coming messages and organize them by priority
+      await this.peer.outgoing
+        .push(entry.msg)
+        .then(entry.resolve)
+        .catch(entry.reject);
     }
 
-    get priority() {
-        return this.peer.priority;
-    }
+    this.processing = false;
+  }
 
-    get crashOnClose() {
-        return this.peer.crashOnClose;
-    }
-
-    /**
-     * We set as default priority HIGH to handle all the messages without a
-     * priority property as HIGH priority.
-     *
-     * This way we consider all the non-content messsages as HIGH priority.
-     */
-    private queue = new PriorityBasedMessageQueue(CO_VALUE_PRIORITY.HIGH);
-    private processing = false;
-    public closed = false;
-
-    async processQueue() {
-        if (this.processing) {
-            return;
-        }
-
-        this.processing = true;
-
-
-        let entry: QueueEntry | undefined;
-        while ((entry = this.queue.pull())) {
-            // Awaiting the push to send one message at a time
-            // This way when the peer is "under pressure" we can enqueue all
-            // the coming messages and organize them by priority
-            await this.peer.outgoing
-                .push(entry.msg)
-                .then(entry.resolve)
-                .catch(entry.reject);
-        }
-
-        this.processing = false;
-    }
+  pushOutgoingMessage(msg: SyncMessage) {
+    const promise = this.queue.push(msg);
 
-    pushOutgoingMessage(msg: SyncMessage) {
-        const promise = this.queue.push(msg);
+    void this.processQueue();
 
-        void this.processQueue();
+    return promise;
+  }
 
-        return promise;
+  get incoming() {
+    if (this.closed) {
+      return (async function* () {
+        yield "Disconnected" as const;
+      })();
     }
 
-    get incoming() {
-        if (this.closed) {
-            return (async function* () {
-                yield "Disconnected" as const;
-            })();
-        }
+    return this.peer.incoming;
+  }
 
-        return this.peer.incoming;
-    }
-
-    gracefulShutdown() {
-        console.debug("Gracefully closing", this.id);
-        this.peer.outgoing.close();
-        this.closed = true;
-    }
+  gracefulShutdown() {
+    console.debug("Gracefully closing", this.id);
+    this.peer.outgoing.close();
+    this.closed = true;
+  }
 }

package/src/PriorityBasedMessageQueue.ts

@@ -2,76 +2,69 @@ import { CoValuePriority } from "./priority.js";
 import { SyncMessage } from "./sync.js";
 
 function promiseWithResolvers<R>() {
-    let resolve = (_: R) => {};
-    let reject = (_: unknown) => {};
+  let resolve = (_: R) => {};
+  let reject = (_: unknown) => {};
 
-    const promise = new Promise<R>((_resolve, _reject) => {
-        resolve = _resolve;
-        reject = _reject;
-    });
+  const promise = new Promise<R>((_resolve, _reject) => {
+    resolve = _resolve;
+    reject = _reject;
+  });
 
-    return {
-        promise,
-        resolve,
-        reject,
-    };
+  return {
+    promise,
+    resolve,
+    reject,
+  };
 }
 
 export type QueueEntry = {
-    msg: SyncMessage;
-    promise: Promise<void>;
-    resolve: () => void;
-    reject: (_: unknown) => void;
+  msg: SyncMessage;
+  promise: Promise<void>;
+  resolve: () => void;
+  reject: (_: unknown) => void;
 };
 
 /**
  * Since we have a fixed range of priority values (0-7) we can create a fixed array of queues.
  */
-type Tuple<T, N extends number, A extends unknown[] = []> = A extends { length: N } ? A : Tuple<T, N, [...A, T]>;
+type Tuple<T, N extends number, A extends unknown[] = []> = A extends {
+  length: N;
+}
+  ? A
+  : Tuple<T, N, [...A, T]>;
 type QueueTuple = Tuple<QueueEntry[], 8>;
 
 export class PriorityBasedMessageQueue {
-    private queues: QueueTuple = [
-        [],
-        [],
-        [],
-        [],
-        [],
-        [],
-        [],
-        [],
-    ];
-
-    private getQueue(priority: CoValuePriority) {
-        return this.queues[priority];
-    }
+  private queues: QueueTuple = [[], [], [], [], [], [], [], []];
 
-    constructor(
-        private defaultPriority: CoValuePriority,
-    ) {}
+  private getQueue(priority: CoValuePriority) {
+    return this.queues[priority];
+  }
 
-    public push(msg: SyncMessage) {
-        const { promise, resolve, reject } = promiseWithResolvers<void>();
-        const entry: QueueEntry = { msg, promise, resolve, reject };
+  constructor(private defaultPriority: CoValuePriority) {}
 
-        if ("priority" in msg) {
-            const queue = this.getQueue(msg.priority);
+  public push(msg: SyncMessage) {
+    const { promise, resolve, reject } = promiseWithResolvers<void>();
+    const entry: QueueEntry = { msg, promise, resolve, reject };
 
-            queue?.push(entry);
-        } else {
-            this.getQueue(this.defaultPriority).push(entry);
-        }
+    if ("priority" in msg) {
+      const queue = this.getQueue(msg.priority);
 
-        return promise;
+      queue?.push(entry);
+    } else {
+      this.getQueue(this.defaultPriority).push(entry);
     }
 
-    public pull() {
-        const activeQueue = this.queues.find((queue) => queue.length > 0);
+    return promise;
+  }
 
-        if (!activeQueue) {
-            return undefined;
-        }
+  public pull() {
+    const activeQueue = this.queues.find((queue) => queue.length > 0);
 
-        return activeQueue.shift();
+    if (!activeQueue) {
+      return undefined;
     }
+
+    return activeQueue.shift();
+  }
 }

package/src/base64url.test.ts

@@ -1,33 +1,33 @@
+import { expect, test } from "vitest";
 import { base64URLtoBytes, bytesToBase64url } from "./base64url.js";
-import { test, expect } from "vitest";
 
 const txt = new TextEncoder();
 
 test("Test our Base64 URL encoding and decoding", () => {
-    // tests from the RFC
+  // tests from the RFC
 
-    expect(base64URLtoBytes("")).toEqual(new Uint8Array([]));
-    expect(bytesToBase64url(new Uint8Array([]))).toEqual("");
+  expect(base64URLtoBytes("")).toEqual(new Uint8Array([]));
+  expect(bytesToBase64url(new Uint8Array([]))).toEqual("");
 
-    expect(bytesToBase64url(txt.encode("f"))).toEqual("Zg==");
-    expect(bytesToBase64url(txt.encode("fo"))).toEqual("Zm8=");
-    expect(bytesToBase64url(txt.encode("foo"))).toEqual("Zm9v");
-    expect(bytesToBase64url(txt.encode("foob"))).toEqual("Zm9vYg==");
-    expect(bytesToBase64url(txt.encode("fooba"))).toEqual("Zm9vYmE=");
-    expect(bytesToBase64url(txt.encode("foobar"))).toEqual("Zm9vYmFy");
-    // reverse
-    expect(base64URLtoBytes("Zg==")).toEqual(txt.encode("f"));
-    expect(base64URLtoBytes("Zm8=")).toEqual(txt.encode("fo"));
-    expect(base64URLtoBytes("Zm9v")).toEqual(txt.encode("foo"));
-    expect(base64URLtoBytes("Zm9vYg==")).toEqual(txt.encode("foob"));
-    expect(base64URLtoBytes("Zm9vYmE=")).toEqual(txt.encode("fooba"));
-    expect(base64URLtoBytes("Zm9vYmFy")).toEqual(txt.encode("foobar"));
+  expect(bytesToBase64url(txt.encode("f"))).toEqual("Zg==");
+  expect(bytesToBase64url(txt.encode("fo"))).toEqual("Zm8=");
+  expect(bytesToBase64url(txt.encode("foo"))).toEqual("Zm9v");
+  expect(bytesToBase64url(txt.encode("foob"))).toEqual("Zm9vYg==");
+  expect(bytesToBase64url(txt.encode("fooba"))).toEqual("Zm9vYmE=");
+  expect(bytesToBase64url(txt.encode("foobar"))).toEqual("Zm9vYmFy");
+  // reverse
+  expect(base64URLtoBytes("Zg==")).toEqual(txt.encode("f"));
+  expect(base64URLtoBytes("Zm8=")).toEqual(txt.encode("fo"));
+  expect(base64URLtoBytes("Zm9v")).toEqual(txt.encode("foo"));
+  expect(base64URLtoBytes("Zm9vYg==")).toEqual(txt.encode("foob"));
+  expect(base64URLtoBytes("Zm9vYmE=")).toEqual(txt.encode("fooba"));
+  expect(base64URLtoBytes("Zm9vYmFy")).toEqual(txt.encode("foobar"));
 
-    expect(
-        base64URLtoBytes("V2hhdCBkb2VzIDIgKyAyLjEgZXF1YWw_PyB-IDQ="),
-    ).toEqual(txt.encode("What does 2 + 2.1 equal?? ~ 4"));
-    // reverse
-    expect(
-        bytesToBase64url(txt.encode("What does 2 + 2.1 equal?? ~ 4")),
-    ).toEqual("V2hhdCBkb2VzIDIgKyAyLjEgZXF1YWw_PyB-IDQ=");
+  expect(base64URLtoBytes("V2hhdCBkb2VzIDIgKyAyLjEgZXF1YWw_PyB-IDQ=")).toEqual(
+    txt.encode("What does 2 + 2.1 equal?? ~ 4"),
+  );
+  // reverse
+  expect(bytesToBase64url(txt.encode("What does 2 + 2.1 equal?? ~ 4"))).toEqual(
+    "V2hhdCBkb2VzIDIgKyAyLjEgZXF1YWw_PyB-IDQ=",
+  );
 });

package/src/base64url.ts

@@ -2,67 +2,66 @@ const encoder = new TextEncoder();
 const decoder = new TextDecoder();
 
 export function base64URLtoBytes(base64: string) {
-    base64 = base64.replace(/=/g, "");
-    const n = base64.length;
-    const rem = n % 4;
-    const k = rem && rem - 1; // how many bytes the last base64 chunk encodes
-    const m = (n >> 2) * 3 + k; // total encoded bytes
+  base64 = base64.replace(/=/g, "");
+  const n = base64.length;
+  const rem = n % 4;
+  const k = rem && rem - 1; // how many bytes the last base64 chunk encodes
+  const m = (n >> 2) * 3 + k; // total encoded bytes
 
-    const encoded = new Uint8Array(n + 3);
-    encoder.encodeInto(base64 + "===", encoded);
+  const encoded = new Uint8Array(n + 3);
+  encoder.encodeInto(base64 + "===", encoded);
 
-    for (let i = 0, j = 0; i < n; i += 4, j += 3) {
-        const x =
-            (lookup[encoded[i]!]! << 18) +
-            (lookup[encoded[i + 1]!]! << 12) +
-            (lookup[encoded[i + 2]!]! << 6) +
-            lookup[encoded[i + 3]!]!;
-        encoded[j] = x >> 16;
-        encoded[j + 1] = (x >> 8) & 0xff;
-        encoded[j + 2] = x & 0xff;
-    }
-    return new Uint8Array(encoded.buffer, 0, m);
+  for (let i = 0, j = 0; i < n; i += 4, j += 3) {
+    const x =
+      (lookup[encoded[i]!]! << 18) +
+      (lookup[encoded[i + 1]!]! << 12) +
+      (lookup[encoded[i + 2]!]! << 6) +
+      lookup[encoded[i + 3]!]!;
+    encoded[j] = x >> 16;
+    encoded[j + 1] = (x >> 8) & 0xff;
+    encoded[j + 2] = x & 0xff;
+  }
+  return new Uint8Array(encoded.buffer, 0, m);
 }
 
 export function bytesToBase64url(bytes: Uint8Array) {
-    // const before = performance.now();
-    const m = bytes.length;
-    const k = m % 3;
-    const n = Math.floor(m / 3) * 4 + (k && k + 1);
-    const N = Math.ceil(m / 3) * 4;
-    const encoded = new Uint8Array(N);
+  // const before = performance.now();
+  const m = bytes.length;
+  const k = m % 3;
+  const n = Math.floor(m / 3) * 4 + (k && k + 1);
+  const N = Math.ceil(m / 3) * 4;
+  const encoded = new Uint8Array(N);
 
-    for (let i = 0, j = 0; j < m; i += 4, j += 3) {
-        const y =
-            (bytes[j]! << 16) + (bytes[j + 1]! << 8) + (bytes[j + 2]! | 0);
-        encoded[i] = encodeLookup[y >> 18]!;
-        encoded[i + 1] = encodeLookup[(y >> 12) & 0x3f]!;
-        encoded[i + 2] = encodeLookup[(y >> 6) & 0x3f]!;
-        encoded[i + 3] = encodeLookup[y & 0x3f]!;
-    }
+  for (let i = 0, j = 0; j < m; i += 4, j += 3) {
+    const y = (bytes[j]! << 16) + (bytes[j + 1]! << 8) + (bytes[j + 2]! | 0);
+    encoded[i] = encodeLookup[y >> 18]!;
+    encoded[i + 1] = encodeLookup[(y >> 12) & 0x3f]!;
+    encoded[i + 2] = encodeLookup[(y >> 6) & 0x3f]!;
+    encoded[i + 3] = encodeLookup[y & 0x3f]!;
+  }
 
-    let base64 = decoder.decode(new Uint8Array(encoded.buffer, 0, n));
-    if (k === 1) base64 += "==";
-    if (k === 2) base64 += "=";
-    // const after = performance.now();
-    // console.log(
-    //     "bytesToBase64url bandwidth in MB/s for length",
-    //     (1000 * bytes.length / (after - before)) / (1024 * 1024),
-    //     bytes.length
-    // );
-    return base64;
+  let base64 = decoder.decode(new Uint8Array(encoded.buffer, 0, n));
+  if (k === 1) base64 += "==";
+  if (k === 2) base64 += "=";
+  // const after = performance.now();
+  // console.log(
+  //     "bytesToBase64url bandwidth in MB/s for length",
+  //     (1000 * bytes.length / (after - before)) / (1024 * 1024),
+  //     bytes.length
+  // );
+  return base64;
 }
 
 const alphabet =
-    "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_";
+  "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_";
 
 const lookup = new Uint8Array(128);
 for (const [i, a] of Array.from(alphabet).entries()) {
-    lookup[a.charCodeAt(0)] = i;
+  lookup[a.charCodeAt(0)] = i;
 }
 lookup["=".charCodeAt(0)] = 0;
 
 const encodeLookup = new Uint8Array(64);
 for (const [i, a] of Array.from(alphabet).entries()) {
-    encodeLookup[i] = a.charCodeAt(0);
+  encodeLookup[i] = a.charCodeAt(0);
 }