cojson 0.8.12 → 0.8.16

package/src/PeerState.ts

@@ -1,91 +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;
-    }
+  pushOutgoingMessage(msg: SyncMessage) {
+    const promise = this.queue.push(msg);
 
-    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;
-        }
-
-        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);
+    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);
 }

package/src/coValue.ts

@@ -1,68 +1,68 @@
-import { JsonObject, JsonValue } from "./jsonValue.js";
-import { RawCoID } from "./ids.js";
+import { CoValueCore } from "./coValueCore.js";
+import { RawProfile as Profile, RawAccount } from "./coValues/account.js";
+import { RawCoList } from "./coValues/coList.js";
 import { RawCoMap } from "./coValues/coMap.js";
 import { RawBinaryCoStream, RawCoStream } from "./coValues/coStream.js";
-import { RawCoList } from "./coValues/coList.js";
-import { CoValueCore } from "./coValueCore.js";
 import { RawGroup } from "./coValues/group.js";
-import { RawAccount, RawProfile as Profile } from "./coValues/account.js";
+import { RawCoID } from "./ids.js";
+import { JsonObject, JsonValue } from "./jsonValue.js";
 
 export type CoID<T extends RawCoValue> = RawCoID & {
-    readonly __type: T;
+  readonly __type: T;
 };
 
 export interface RawCoValue {
-    /** The `CoValue`'s (precisely typed) `CoID` */
-    id: CoID<this>;
-    core: CoValueCore;
-    /** Specifies which kind of `CoValue` this is */
-    type: string;
-    /** The `CoValue`'s (precisely typed) static metadata */
-    headerMeta: JsonObject | null;
-    /** The `Group` this `CoValue` belongs to (determining permissions) */
-    group: RawGroup;
-    /** Returns an immutable JSON presentation of this `CoValue` */
-    toJSON(): JsonValue;
-    atTime(time: number): this;
-    /** Lets you subscribe to future updates to this CoValue (whether made locally or by other users).
-     *
-     * Takes a listener function that will be called with the current state for each update.
-     *
-     * Returns an unsubscribe function.
-     *
-     * Used internally by `useTelepathicData()` for reactive updates on changes to a `CoValue`. */
-    subscribe(listener: (coValue: this) => void): () => void;
+  /** The `CoValue`'s (precisely typed) `CoID` */
+  id: CoID<this>;
+  core: CoValueCore;
+  /** Specifies which kind of `CoValue` this is */
+  type: string;
+  /** The `CoValue`'s (precisely typed) static metadata */
+  headerMeta: JsonObject | null;
+  /** The `Group` this `CoValue` belongs to (determining permissions) */
+  group: RawGroup;
+  /** Returns an immutable JSON presentation of this `CoValue` */
+  toJSON(): JsonValue;
+  atTime(time: number): this;
+  /** Lets you subscribe to future updates to this CoValue (whether made locally or by other users).
+   *
+   * Takes a listener function that will be called with the current state for each update.
+   *
+   * Returns an unsubscribe function.
+   *
+   * Used internally by `useTelepathicData()` for reactive updates on changes to a `CoValue`. */
+  subscribe(listener: (coValue: this) => void): () => void;
 }
 
 export type AnyRawCoValue =
-    | RawCoMap
-    | RawGroup
-    | RawAccount
-    | Profile
-    | RawCoList
-    | RawCoStream
-    | RawBinaryCoStream;
+  | RawCoMap
+  | RawGroup
+  | RawAccount
+  | Profile
+  | RawCoList
+  | RawCoStream
+  | RawBinaryCoStream;
 
 export function expectMap(content: RawCoValue): RawCoMap {
-    if (content.type !== "comap") {
-        throw new Error("Expected map");
-    }
+  if (content.type !== "comap") {
+    throw new Error("Expected map");
+  }
 
-    return content as RawCoMap;
+  return content as RawCoMap;
 }
 
 export function expectList(content: RawCoValue): RawCoList {
-    if (content.type !== "colist") {
-        throw new Error("Expected list");
-    }
+  if (content.type !== "colist") {
+    throw new Error("Expected list");
+  }
 
-    return content as RawCoList;
+  return content as RawCoList;
 }
 
 export function expectStream(content: RawCoValue): RawCoStream {
-    if (content.type !== "costream") {
-        throw new Error("Expected stream");
-    }
+  if (content.type !== "costream") {
+    throw new Error("Expected stream");
+  }
 
-    return content as RawCoStream;
+  return content as RawCoStream;
 }