cojson 0.8.50 → 0.9.9

package/src/exports.ts

@@ -6,14 +6,16 @@ import {
   MAX_RECOMMENDED_TX_SIZE,
   idforHeader,
 } from "./coValueCore.js";
-import { ControlledAgent, RawControlledAccount } from "./coValues/account.js";
 import {
+  ControlledAgent,
   RawAccount,
+  RawControlledAccount,
   RawProfile,
   accountHeaderForInitialAgentSecret,
 } from "./coValues/account.js";
-import { RawCoList } from "./coValues/coList.js";
+import { OpID, RawCoList } from "./coValues/coList.js";
 import { RawCoMap } from "./coValues/coMap.js";
+import { RawCoPlainText, stringifyOpID } from "./coValues/coPlainText.js";
 import {
   CoStreamItem,
   RawBinaryCoStream,
@@ -137,6 +139,8 @@ export {
   isRawCoID,
   LSMStorage,
   emptyKnownState,
+  RawCoPlainText,
+  stringifyOpID,
 };
 
 export type {
@@ -151,6 +155,7 @@ export type {
   CoValueUniqueness,
   Stringified,
   CoStreamItem,
+  OpID,
 };
 
 // eslint-disable-next-line @typescript-eslint/no-namespace

package/src/tests/coList.test.ts

@@ -75,6 +75,26 @@ test("Push is equivalent to append after last item", () => {
   expect(content.toJSON()).toEqual(["hello", "world", "hooray"]);
 });
 
+test("appendItems add an array of items at the end of the list", () => {
+  const node = new LocalNode(...randomAnonymousAccountAndSessionID(), Crypto);
+
+  const coValue = node.createCoValue({
+    type: "colist",
+    ruleset: { type: "unsafeAllowAll" },
+    meta: null,
+    ...Crypto.createdNowUnique(),
+  });
+
+  const content = expectList(coValue.getCurrentContent());
+
+  expect(content.type).toEqual("colist");
+
+  content.append("hello", 0, "trusting");
+  expect(content.toJSON()).toEqual(["hello"]);
+  content.appendItems(["world", "hooray", "universe"], undefined, "trusting");
+  expect(content.toJSON()).toEqual(["hello", "world", "hooray", "universe"]);
+});
+
 test("Can push into empty list", () => {
   const node = new LocalNode(...randomAnonymousAccountAndSessionID(), Crypto);
 
@@ -92,3 +112,42 @@ test("Can push into empty list", () => {
   content.append("hello", undefined, "trusting");
   expect(content.toJSON()).toEqual(["hello"]);
 });
+
+test("init the list correctly", () => {
+  const node = new LocalNode(...randomAnonymousAccountAndSessionID(), Crypto);
+
+  const group = node.createGroup();
+
+  const content = group.createList(["hello", "world", "hooray", "universe"]);
+
+  expect(content.type).toEqual("colist");
+  expect(content.toJSON()).toEqual(["hello", "world", "hooray", "universe"]);
+
+  content.append("hello", content.toJSON().length - 1, "trusting");
+  expect(content.toJSON()).toEqual([
+    "hello",
+    "world",
+    "hooray",
+    "universe",
+    "hello",
+  ]);
+});
+
+test("Items prepended to start appear with latest first", () => {
+  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.prepend("first", 0, "trusting");
+  content.prepend("second", 0, "trusting");
+  content.prepend("third", 0, "trusting");
+
+  expect(content.toJSON()).toEqual(["third", "second", "first"]);
+});

package/src/tests/coMap.test.ts

@@ -175,3 +175,35 @@ test("Can get last tx ID for a key in CoMap", () => {
   content.set("hello", "C", "trusting");
   expect(content.lastEditAt("hello")?.tx.txIndex).toEqual(2);
 });
+
+test("Can set items in bulk with assign", () => {
+  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("key1", "set1", "trusting");
+
+  content.assign(
+    {
+      key1: "assign1",
+      key2: "assign2",
+      key3: "assign3",
+    },
+    "trusting",
+  );
+
+  expect(content.toJSON()).toEqual({
+    key1: "assign1",
+    key2: "assign2",
+    key3: "assign3",
+  });
+});

package/src/tests/coPlainText.test.ts

@@ -0,0 +1,133 @@
+import { afterEach, expect, test, vi } from "vitest";
+import { expectPlainText } from "../coValue.js";
+import { WasmCrypto } from "../crypto/WasmCrypto.js";
+import { LocalNode } from "../localNode.js";
+import { randomAnonymousAccountAndSessionID } from "./testUtils.js";
+
+const Crypto = await WasmCrypto.create();
+
+afterEach(() => void vi.unstubAllGlobals());
+
+test("should throw on creation if Intl.Segmenter is not available", () => {
+  vi.stubGlobal("Intl", {
+    Segmenter: undefined,
+  });
+
+  const node = new LocalNode(...randomAnonymousAccountAndSessionID(), Crypto);
+  const group = node.createGroup();
+  expect(() => group.createPlainText()).toThrow(
+    "Intl.Segmenter is not supported. Use a polyfill to get coPlainText support in Jazz. (eg. https://formatjs.github.io/docs/polyfills/intl-segmenter/)",
+  );
+});
+
+test("Empty CoPlainText works", () => {
+  const node = new LocalNode(...randomAnonymousAccountAndSessionID(), Crypto);
+
+  const coValue = node.createCoValue({
+    type: "coplaintext",
+    ruleset: { type: "unsafeAllowAll" },
+    meta: null,
+    ...Crypto.createdNowUnique(),
+  });
+
+  const content = expectPlainText(coValue.getCurrentContent());
+
+  expect(content.type).toEqual("coplaintext");
+  expect(content.toString()).toEqual("");
+});
+
+test("Can insert into empty CoPlainText", () => {
+  const node = new LocalNode(...randomAnonymousAccountAndSessionID(), Crypto);
+
+  const coValue = node.createCoValue({
+    type: "coplaintext",
+    ruleset: { type: "unsafeAllowAll" },
+    meta: null,
+    ...Crypto.createdNowUnique(),
+  });
+
+  const content = expectPlainText(coValue.getCurrentContent());
+
+  expect(content.type).toEqual("coplaintext");
+
+  content.insertAfter(0, "a", "trusting");
+  expect(content.toString()).toEqual("a");
+});
+
+test("Can insert and delete in CoPlainText", () => {
+  const node = new LocalNode(...randomAnonymousAccountAndSessionID(), Crypto);
+
+  const coValue = node.createCoValue({
+    type: "coplaintext",
+    ruleset: { type: "unsafeAllowAll" },
+    meta: null,
+    ...Crypto.createdNowUnique(),
+  });
+
+  const content = expectPlainText(coValue.getCurrentContent());
+
+  expect(content.type).toEqual("coplaintext");
+
+  content.insertAfter(0, "hello", "trusting");
+  expect(content.toString()).toEqual("hello");
+
+  content.insertAfter(5, " world", "trusting");
+  expect(content.toString()).toEqual("hello world");
+
+  content.insertAfter(0, "Hello, ", "trusting");
+  expect(content.toString()).toEqual("Hello, hello world");
+
+  console.log("first delete");
+  content.deleteRange({ from: 6, to: 12 }, "trusting");
+  expect(content.toString()).toEqual("Hello, world");
+
+  content.insertAfter(2, "😍", "trusting");
+  expect(content.toString()).toEqual("He😍llo, world");
+
+  console.log("second delete");
+  content.deleteRange({ from: 2, to: 4 }, "trusting");
+  expect(content.toString()).toEqual("Hello, world");
+});
+
+test("Multiple items appended after start appear in correct order", () => {
+  const node = new LocalNode(...randomAnonymousAccountAndSessionID(), Crypto);
+
+  const coValue = node.createCoValue({
+    type: "coplaintext",
+    ruleset: { type: "unsafeAllowAll" },
+    meta: null,
+    ...Crypto.createdNowUnique(),
+  });
+
+  const content = expectPlainText(coValue.getCurrentContent());
+
+  // Add multiple items in a single transaction, all after start
+  content.insertAfter(0, "h", "trusting");
+  content.insertAfter(1, "e", "trusting");
+  content.insertAfter(2, "y", "trusting");
+
+  // They should appear in insertion order (hey), not reversed (yeh)
+  expect(content.toString()).toEqual("hey");
+});
+
+test("Items inserted at start appear with latest first", () => {
+  const node = new LocalNode(...randomAnonymousAccountAndSessionID(), Crypto);
+
+  const coValue = node.createCoValue({
+    type: "coplaintext",
+    ruleset: { type: "unsafeAllowAll" },
+    meta: null,
+    ...Crypto.createdNowUnique(),
+  });
+
+  const content = expectPlainText(coValue.getCurrentContent());
+
+  // Insert multiple items at the start
+  content.insertAfter(0, "first", "trusting");
+  content.insertAfter(0, "second", "trusting");
+  content.insertAfter(0, "third", "trusting");
+
+  // They should appear in reverse chronological order
+  // because newer items should appear before older items
+  expect(content.toString()).toEqual("thirdsecondfirst");
+});