cojson 0.8.12 → 0.8.16

package/src/tests/coList.test.ts

@@ -1,94 +1,94 @@
 import { expect, test } from "vitest";
 import { expectList } from "../coValue.js";
+import { WasmCrypto } from "../crypto/WasmCrypto.js";
 import { LocalNode } from "../localNode.js";
 import { randomAnonymousAccountAndSessionID } from "./testUtils.js";
-import { WasmCrypto } from "../crypto/WasmCrypto.js";
 
 const Crypto = await WasmCrypto.create();
 
 test("Empty CoList works", () => {
-    const node = new LocalNode(...randomAnonymousAccountAndSessionID(), Crypto);
+  const node = new LocalNode(...randomAnonymousAccountAndSessionID(), Crypto);
 
-    const coValue = node.createCoValue({
-        type: "colist",
-        ruleset: { type: "unsafeAllowAll" },
-        meta: null,
-        ...Crypto.createdNowUnique(),
-    });
+  const coValue = node.createCoValue({
+    type: "colist",
+    ruleset: { type: "unsafeAllowAll" },
+    meta: null,
+    ...Crypto.createdNowUnique(),
+  });
 
-    const content = expectList(coValue.getCurrentContent());
+  const content = expectList(coValue.getCurrentContent());
 
-    expect(content.type).toEqual("colist");
-    expect(content.toJSON()).toEqual([]);
+  expect(content.type).toEqual("colist");
+  expect(content.toJSON()).toEqual([]);
 });
 
 test("Can append, prepend, delete and replace items in CoList", () => {
-    const node = new LocalNode(...randomAnonymousAccountAndSessionID(), Crypto);
-
-    const coValue = node.createCoValue({
-        type: "colist",
-        ruleset: { type: "unsafeAllowAll" },
-        meta: null,
-        ...Crypto.createdNowUnique(),
-    });
-
-    const content = expectList(coValue.getCurrentContent());
-
-    content.append("hello", 0, "trusting");
-    expect(content.toJSON()).toEqual(["hello"]);
-    content.append("world", 0, "trusting");
-    expect(content.toJSON()).toEqual(["hello", "world"]);
-    content.prepend("beautiful", 1, "trusting");
-    expect(content.toJSON()).toEqual(["hello", "beautiful", "world"]);
-    content.prepend("hooray", 3, "trusting");
-    expect(content.toJSON()).toEqual(["hello", "beautiful", "world", "hooray"]);
-    content.replace(2, "universe", "trusting");
-    expect(content.toJSON()).toEqual([
-        "hello",
-        "beautiful",
-        "universe",
-        "hooray",
-    ]);
-    content.delete(2, "trusting");
-    expect(content.toJSON()).toEqual(["hello", "beautiful", "hooray"]);
+  const node = new LocalNode(...randomAnonymousAccountAndSessionID(), Crypto);
+
+  const coValue = node.createCoValue({
+    type: "colist",
+    ruleset: { type: "unsafeAllowAll" },
+    meta: null,
+    ...Crypto.createdNowUnique(),
+  });
+
+  const content = expectList(coValue.getCurrentContent());
+
+  content.append("hello", 0, "trusting");
+  expect(content.toJSON()).toEqual(["hello"]);
+  content.append("world", 0, "trusting");
+  expect(content.toJSON()).toEqual(["hello", "world"]);
+  content.prepend("beautiful", 1, "trusting");
+  expect(content.toJSON()).toEqual(["hello", "beautiful", "world"]);
+  content.prepend("hooray", 3, "trusting");
+  expect(content.toJSON()).toEqual(["hello", "beautiful", "world", "hooray"]);
+  content.replace(2, "universe", "trusting");
+  expect(content.toJSON()).toEqual([
+    "hello",
+    "beautiful",
+    "universe",
+    "hooray",
+  ]);
+  content.delete(2, "trusting");
+  expect(content.toJSON()).toEqual(["hello", "beautiful", "hooray"]);
 });
 
 test("Push is equivalent to append after last item", () => {
-    const node = new LocalNode(...randomAnonymousAccountAndSessionID(), Crypto);
+  const node = new LocalNode(...randomAnonymousAccountAndSessionID(), Crypto);
 
-    const coValue = node.createCoValue({
-        type: "colist",
-        ruleset: { type: "unsafeAllowAll" },
-        meta: null,
-        ...Crypto.createdNowUnique(),
-    });
+  const coValue = node.createCoValue({
+    type: "colist",
+    ruleset: { type: "unsafeAllowAll" },
+    meta: null,
+    ...Crypto.createdNowUnique(),
+  });
 
-    const content = expectList(coValue.getCurrentContent());
+  const content = expectList(coValue.getCurrentContent());
 
-    expect(content.type).toEqual("colist");
+  expect(content.type).toEqual("colist");
 
-    content.append("hello", 0, "trusting");
-    expect(content.toJSON()).toEqual(["hello"]);
-    content.append("world", undefined, "trusting");
-    expect(content.toJSON()).toEqual(["hello", "world"]);
-    content.append("hooray", undefined, "trusting");
-    expect(content.toJSON()).toEqual(["hello", "world", "hooray"]);
+  content.append("hello", 0, "trusting");
+  expect(content.toJSON()).toEqual(["hello"]);
+  content.append("world", undefined, "trusting");
+  expect(content.toJSON()).toEqual(["hello", "world"]);
+  content.append("hooray", undefined, "trusting");
+  expect(content.toJSON()).toEqual(["hello", "world", "hooray"]);
 });
 
 test("Can push into empty list", () => {
-    const node = new LocalNode(...randomAnonymousAccountAndSessionID(), Crypto);
+  const node = new LocalNode(...randomAnonymousAccountAndSessionID(), Crypto);
 
-    const coValue = node.createCoValue({
-        type: "colist",
-        ruleset: { type: "unsafeAllowAll" },
-        meta: null,
-        ...Crypto.createdNowUnique(),
-    });
+  const coValue = node.createCoValue({
+    type: "colist",
+    ruleset: { type: "unsafeAllowAll" },
+    meta: null,
+    ...Crypto.createdNowUnique(),
+  });
 
-    const content = expectList(coValue.getCurrentContent());
+  const content = expectList(coValue.getCurrentContent());
 
-    expect(content.type).toEqual("colist");
+  expect(content.type).toEqual("colist");
 
-    content.append("hello", undefined, "trusting");
-    expect(content.toJSON()).toEqual(["hello"]);
+  content.append("hello", undefined, "trusting");
+  expect(content.toJSON()).toEqual(["hello"]);
 });

package/src/tests/coMap.test.ts

@@ -1,162 +1,162 @@
 import { expect, test } from "vitest";
 import { expectMap } from "../coValue.js";
+import { WasmCrypto } from "../crypto/WasmCrypto.js";
 import { LocalNode } from "../localNode.js";
 import { accountOrAgentIDfromSessionID } from "../typeUtils/accountOrAgentIDfromSessionID.js";
 import { randomAnonymousAccountAndSessionID } from "./testUtils.js";
-import { WasmCrypto } from "../crypto/WasmCrypto.js";
 
 const Crypto = await WasmCrypto.create();
 
 test("Empty CoMap works", () => {
-    const node = new LocalNode(...randomAnonymousAccountAndSessionID(), Crypto);
+  const node = new LocalNode(...randomAnonymousAccountAndSessionID(), Crypto);
 
-    const coValue = node.createCoValue({
-        type: "comap",
-        ruleset: { type: "unsafeAllowAll" },
-        meta: null,
-        ...Crypto.createdNowUnique(),
-    });
+  const coValue = node.createCoValue({
+    type: "comap",
+    ruleset: { type: "unsafeAllowAll" },
+    meta: null,
+    ...Crypto.createdNowUnique(),
+  });
 
-    const content = expectMap(coValue.getCurrentContent());
+  const content = expectMap(coValue.getCurrentContent());
 
-    expect(content.type).toEqual("comap");
-    expect([...content.keys()]).toEqual([]);
-    expect(content.toJSON()).toEqual({});
+  expect(content.type).toEqual("comap");
+  expect([...content.keys()]).toEqual([]);
+  expect(content.toJSON()).toEqual({});
 });
 
 test("Can insert and delete CoMap entries in edit()", () => {
-    const node = new LocalNode(...randomAnonymousAccountAndSessionID(), Crypto);
-
-    const coValue = node.createCoValue({
-        type: "comap",
-        ruleset: { type: "unsafeAllowAll" },
-        meta: null,
-        ...Crypto.createdNowUnique(),
-    });
-
-    const content = expectMap(coValue.getCurrentContent());
-
-    expect(content.type).toEqual("comap");
-
-    content.set("hello", "world", "trusting");
-    expect(content.get("hello")).toEqual("world");
-    content.set("foo", "bar", "trusting");
-    expect(content.get("foo")).toEqual("bar");
-    expect([...content.keys()]).toEqual(["hello", "foo"]);
-    content.delete("foo", "trusting");
-    expect(content.get("foo")).toEqual(undefined);
-    expect(content.keys()).toEqual(["hello"]);
+  const node = new LocalNode(...randomAnonymousAccountAndSessionID(), Crypto);
+
+  const coValue = node.createCoValue({
+    type: "comap",
+    ruleset: { type: "unsafeAllowAll" },
+    meta: null,
+    ...Crypto.createdNowUnique(),
+  });
+
+  const content = expectMap(coValue.getCurrentContent());
+
+  expect(content.type).toEqual("comap");
+
+  content.set("hello", "world", "trusting");
+  expect(content.get("hello")).toEqual("world");
+  content.set("foo", "bar", "trusting");
+  expect(content.get("foo")).toEqual("bar");
+  expect([...content.keys()]).toEqual(["hello", "foo"]);
+  content.delete("foo", "trusting");
+  expect(content.get("foo")).toEqual(undefined);
+  expect(content.keys()).toEqual(["hello"]);
 });
 
 test("Can get CoMap entry values at different points in time", () => {
-    const node = new LocalNode(...randomAnonymousAccountAndSessionID(), Crypto);
-
-    const coValue = node.createCoValue({
-        type: "comap",
-        ruleset: { type: "unsafeAllowAll" },
-        meta: null,
-        ...Crypto.createdNowUnique(),
-    });
-
-    const content = expectMap(coValue.getCurrentContent());
-
-    expect(content.type).toEqual("comap");
-
-    const beforeA = Date.now();
-    while (Date.now() < beforeA + 10) {
-        /* hot sleep */
-    }
-    content.set("hello", "A", "trusting");
-    const beforeB = Date.now();
-    while (Date.now() < beforeB + 10) {
-        /* hot sleep */
-    }
-    content.set("hello", "B", "trusting");
-    const beforeC = Date.now();
-    while (Date.now() < beforeC + 10) {
-        /* hot sleep */
-    }
-    content.set("hello", "C", "trusting");
-    expect(content.get("hello")).toEqual("C");
-    expect(content.atTime(Date.now()).get("hello")).toEqual("C");
-    expect(content.atTime(beforeA).get("hello")).toEqual(undefined);
-    expect(content.atTime(beforeB).get("hello")).toEqual("A");
-    expect(content.atTime(beforeC).get("hello")).toEqual("B");
+  const node = new LocalNode(...randomAnonymousAccountAndSessionID(), Crypto);
+
+  const coValue = node.createCoValue({
+    type: "comap",
+    ruleset: { type: "unsafeAllowAll" },
+    meta: null,
+    ...Crypto.createdNowUnique(),
+  });
+
+  const content = expectMap(coValue.getCurrentContent());
+
+  expect(content.type).toEqual("comap");
+
+  const beforeA = Date.now();
+  while (Date.now() < beforeA + 10) {
+    /* hot sleep */
+  }
+  content.set("hello", "A", "trusting");
+  const beforeB = Date.now();
+  while (Date.now() < beforeB + 10) {
+    /* hot sleep */
+  }
+  content.set("hello", "B", "trusting");
+  const beforeC = Date.now();
+  while (Date.now() < beforeC + 10) {
+    /* hot sleep */
+  }
+  content.set("hello", "C", "trusting");
+  expect(content.get("hello")).toEqual("C");
+  expect(content.atTime(Date.now()).get("hello")).toEqual("C");
+  expect(content.atTime(beforeA).get("hello")).toEqual(undefined);
+  expect(content.atTime(beforeB).get("hello")).toEqual("A");
+  expect(content.atTime(beforeC).get("hello")).toEqual("B");
 });
 
 test("Can get all historic values of key in CoMap", () => {
-    const node = new LocalNode(...randomAnonymousAccountAndSessionID(), Crypto);
-
-    const coValue = node.createCoValue({
-        type: "comap",
-        ruleset: { type: "unsafeAllowAll" },
-        meta: null,
-        ...Crypto.createdNowUnique(),
-    });
-
-    const content = expectMap(coValue.getCurrentContent());
-
-    expect(content.type).toEqual("comap");
-
-    content.set("hello", "A", "trusting");
-    const editA = content.lastEditAt("hello");
-    content.set("hello", "B", "trusting");
-    const editB = content.lastEditAt("hello");
-    content.delete("hello", "trusting");
-    const editDel = content.lastEditAt("hello");
-    content.set("hello", "C", "trusting");
-    const editC = content.lastEditAt("hello");
-    expect([...content.editsAt("hello")]).toEqual([
-        {
-            tx: editA!.tx,
-            by: node.account.id,
-            value: "A",
-            at: editA?.at,
-        },
-        {
-            tx: editB!.tx,
-            by: node.account.id,
-            value: "B",
-            at: editB?.at,
-        },
-        {
-            tx: editDel!.tx,
-            by: node.account.id,
-            value: undefined,
-            at: editDel?.at,
-        },
-        {
-            tx: editC!.tx,
-            by: node.account.id,
-            value: "C",
-            at: editC?.at,
-        },
-    ]);
+  const node = new LocalNode(...randomAnonymousAccountAndSessionID(), Crypto);
+
+  const coValue = node.createCoValue({
+    type: "comap",
+    ruleset: { type: "unsafeAllowAll" },
+    meta: null,
+    ...Crypto.createdNowUnique(),
+  });
+
+  const content = expectMap(coValue.getCurrentContent());
+
+  expect(content.type).toEqual("comap");
+
+  content.set("hello", "A", "trusting");
+  const editA = content.lastEditAt("hello");
+  content.set("hello", "B", "trusting");
+  const editB = content.lastEditAt("hello");
+  content.delete("hello", "trusting");
+  const editDel = content.lastEditAt("hello");
+  content.set("hello", "C", "trusting");
+  const editC = content.lastEditAt("hello");
+  expect([...content.editsAt("hello")]).toEqual([
+    {
+      tx: editA!.tx,
+      by: node.account.id,
+      value: "A",
+      at: editA?.at,
+    },
+    {
+      tx: editB!.tx,
+      by: node.account.id,
+      value: "B",
+      at: editB?.at,
+    },
+    {
+      tx: editDel!.tx,
+      by: node.account.id,
+      value: undefined,
+      at: editDel?.at,
+    },
+    {
+      tx: editC!.tx,
+      by: node.account.id,
+      value: "C",
+      at: editC?.at,
+    },
+  ]);
 });
 
 test("Can get last tx ID for a key in CoMap", () => {
-    const node = new LocalNode(...randomAnonymousAccountAndSessionID(), Crypto);
-
-    const coValue = node.createCoValue({
-        type: "comap",
-        ruleset: { type: "unsafeAllowAll" },
-        meta: null,
-        ...Crypto.createdNowUnique(),
-    });
-
-    const content = expectMap(coValue.getCurrentContent());
-
-    expect(content.type).toEqual("comap");
-
-    expect(content.lastEditAt("hello")).toEqual(undefined);
-    content.set("hello", "A", "trusting");
-    const sessionID = content.lastEditAt("hello")?.tx.sessionID;
-    expect(sessionID && accountOrAgentIDfromSessionID(sessionID)).toEqual(
-        node.account.id,
-    );
-    expect(content.lastEditAt("hello")?.tx.txIndex).toEqual(0);
-    content.set("hello", "B", "trusting");
-    expect(content.lastEditAt("hello")?.tx.txIndex).toEqual(1);
-    content.set("hello", "C", "trusting");
-    expect(content.lastEditAt("hello")?.tx.txIndex).toEqual(2);
+  const node = new LocalNode(...randomAnonymousAccountAndSessionID(), Crypto);
+
+  const coValue = node.createCoValue({
+    type: "comap",
+    ruleset: { type: "unsafeAllowAll" },
+    meta: null,
+    ...Crypto.createdNowUnique(),
+  });
+
+  const content = expectMap(coValue.getCurrentContent());
+
+  expect(content.type).toEqual("comap");
+
+  expect(content.lastEditAt("hello")).toEqual(undefined);
+  content.set("hello", "A", "trusting");
+  const sessionID = content.lastEditAt("hello")?.tx.sessionID;
+  expect(sessionID && accountOrAgentIDfromSessionID(sessionID)).toEqual(
+    node.account.id,
+  );
+  expect(content.lastEditAt("hello")?.tx.txIndex).toEqual(0);
+  content.set("hello", "B", "trusting");
+  expect(content.lastEditAt("hello")?.tx.txIndex).toEqual(1);
+  content.set("hello", "C", "trusting");
+  expect(content.lastEditAt("hello")?.tx.txIndex).toEqual(2);
 });