jazz-tools 0.9.1 → 0.9.8

package/src/coValues/interfaces.ts

@@ -4,6 +4,7 @@ import type {
   RawCoValue,
 } from "cojson";
 import { RawAccount } from "cojson";
+import { activeAccountContext } from "../implementation/activeAccountContext.js";
 import { AnonymousJazzAgent } from "../implementation/anonymousJazzAgent.js";
 import type { DeeplyLoaded, DepthsIn } from "../internal.js";
 import {
@@ -154,6 +155,24 @@ export class CoValueBase implements CoValue {
   }
 }
 
+export function loadCoValueWithoutMe<V extends CoValue, Depth>(
+  cls: CoValueClass<V>,
+  id: ID<V>,
+  asOrDepth: Account | AnonymousJazzAgent | (Depth & DepthsIn<V>),
+  depth?: Depth & DepthsIn<V>,
+) {
+  if (isAccountInstance(asOrDepth) || isAnonymousAgentInstance(asOrDepth)) {
+    if (!depth) {
+      throw new Error(
+        "Depth is required when loading a CoValue as an Account or AnonymousJazzAgent",
+      );
+    }
+    return loadCoValue(cls, id, asOrDepth, depth);
+  }
+
+  return loadCoValue(cls, id, activeAccountContext.get(), asOrDepth);
+}
+
 export function loadCoValue<V extends CoValue, Depth>(
   cls: CoValueClass<V>,
   id: ID<V>,
@@ -189,6 +208,41 @@ export function ensureCoValueLoaded<V extends CoValue, Depth>(
   );
 }
 
+export function subscribeToCoValueWithoutMe<V extends CoValue, Depth>(
+  cls: CoValueClass<V>,
+  id: ID<V>,
+  asOrDepth: Account | AnonymousJazzAgent | (Depth & DepthsIn<V>),
+  depthOrListener:
+    | (Depth & DepthsIn<V>)
+    | ((value: DeeplyLoaded<V, Depth>) => void),
+  listener?: (value: DeeplyLoaded<V, Depth>) => void,
+) {
+  if (isAccountInstance(asOrDepth) || isAnonymousAgentInstance(asOrDepth)) {
+    if (typeof depthOrListener !== "function") {
+      return subscribeToCoValue<V, Depth>(
+        cls,
+        id,
+        asOrDepth,
+        depthOrListener,
+        listener!,
+      );
+    }
+    throw new Error("Invalid arguments");
+  }
+
+  if (typeof depthOrListener !== "function") {
+    throw new Error("Invalid arguments");
+  }
+
+  return subscribeToCoValue<V, Depth>(
+    cls,
+    id,
+    activeAccountContext.get(),
+    asOrDepth,
+    depthOrListener,
+  );
+}
+
 export function subscribeToCoValue<V extends CoValue, Depth>(
   cls: CoValueClass<V>,
   id: ID<V>,
@@ -304,20 +358,69 @@ export function subscribeToExistingCoValue<V extends CoValue, Depth>(
   );
 }
 
+export function isAccountInstance(instance: unknown): instance is Account {
+  if (typeof instance !== "object" || instance === null) {
+    return false;
+  }
+
+  return "_type" in instance && instance._type === "Account";
+}
+
+export function isAnonymousAgentInstance(
+  instance: unknown,
+): instance is AnonymousJazzAgent {
+  if (typeof instance !== "object" || instance === null) {
+    return false;
+  }
+
+  return "_type" in instance && instance._type === "Anonymous";
+}
+
 export function parseCoValueCreateOptions(
   options:
     | {
-        owner: Account | Group;
+        owner?: Account | Group;
         unique?: CoValueUniqueness["uniqueness"];
       }
     | Account
-    | Group,
+    | Group
+    | undefined,
 ) {
-  return "_type" in options &&
-    (options._type === "Account" || options._type === "Group")
-    ? { owner: options, uniqueness: undefined }
-    : {
-        owner: options.owner,
-        uniqueness: options.unique ? { uniqueness: options.unique } : undefined,
-      };
+  const Group = RegisteredSchemas["Group"];
+
+  if (!options) {
+    return { owner: Group.create(), uniqueness: undefined };
+  }
+
+  if ("_type" in options) {
+    if (options._type === "Account" || options._type === "Group") {
+      return { owner: options, uniqueness: undefined };
+    }
+  }
+
+  const uniqueness = options.unique
+    ? { uniqueness: options.unique }
+    : undefined;
+
+  return {
+    owner: options.owner ?? Group.create(),
+    uniqueness,
+  };
+}
+
+export function parseGroupCreateOptions(
+  options:
+    | {
+        owner?: Account;
+      }
+    | Account
+    | undefined,
+) {
+  if (!options) {
+    return { owner: activeAccountContext.get() };
+  }
+
+  return "_type" in options && isAccountInstance(options)
+    ? { owner: options }
+    : { owner: options.owner ?? activeAccountContext.get() };
 }

package/src/exports.ts

@@ -12,27 +12,31 @@ export type { CoValue, ID } from "./internal.js";
 
 export { Encoders, co } from "./internal.js";
 
-export {
-  Inbox,
-  InboxSender,
-} from "./coValues/inbox.js";
+export { Inbox, InboxSender } from "./coValues/inbox.js";
 
 export {
   Account,
   isControlledAccount,
   type AccountClass,
 } from "./coValues/account.js";
-export { Group } from "./coValues/group.js";
 export {
-  CoStream,
+  BinaryCoStream,
   CoFeed,
+  CoStream,
   FileStream,
-  BinaryCoStream,
 } from "./coValues/coFeed.js";
 export { CoList } from "./coValues/coList.js";
 export { CoMap, type CoMapInit } from "./coValues/coMap.js";
-export { CoValueBase } from "./coValues/interfaces.js";
+export { CoPlainText, type TextPos } from "./coValues/coPlainText.js";
+export {
+  CoRichText,
+  Marks,
+  type TreeLeaf,
+  type TreeNode,
+} from "./coValues/coRichText.js";
 export { ImageDefinition } from "./coValues/extensions/imageDef.js";
+export { Group } from "./coValues/group.js";
+export { CoValueBase } from "./coValues/interfaces.js";
 export { Profile } from "./coValues/profile.js";
 export { SchemaUnion } from "./coValues/schemaUnion.js";
 

package/src/implementation/activeAccountContext.ts

@@ -0,0 +1,33 @@
+import type { Account } from "../coValues/account.js";
+
+class ActiveAccountContext {
+  private activeAccount: Account | null = null;
+  private guestMode: boolean = false;
+
+  set(account: Account) {
+    this.activeAccount = account;
+    this.guestMode = false;
+  }
+
+  setGuestMode() {
+    this.guestMode = true;
+  }
+
+  get() {
+    if (!this.activeAccount) {
+      if (this.guestMode) {
+        throw new Error(
+          "Something that expects a full active account was called in guest mode.",
+        );
+      }
+
+      throw new Error("No active account");
+    }
+
+    return this.activeAccount;
+  }
+}
+
+export type { ActiveAccountContext };
+
+export const activeAccountContext = new ActiveAccountContext();

package/src/implementation/createContext.ts

@@ -12,6 +12,7 @@ import {
 import { type Account, type AccountClass } from "../coValues/account.js";
 import { RegisteredSchemas } from "../coValues/registeredSchemas.js";
 import type { ID } from "../internal.js";
+import { activeAccountContext } from "./activeAccountContext.js";
 import { AnonymousJazzAgent } from "./anonymousJazzAgent.js";
 
 export type Credentials = {
@@ -169,11 +170,14 @@ export async function createJazzContext<Acc extends Account>(
                 fromRaw: rawAccount,
               }) as Acc;
 
+              activeAccountContext.set(account);
+
               await account.applyMigration(creationProps);
             },
           });
 
           const account = AccountSchema.fromNode(node);
+          activeAccountContext.set(account);
 
           if (authResult.saveCredentials) {
             await authResult.saveCredentials({
@@ -217,12 +221,14 @@ export async function createJazzContext<Acc extends Account>(
             const account = new AccountSchema({
               fromRaw: rawAccount,
             }) as Acc;
+            activeAccountContext.set(account);
 
             await account.applyMigration(creationProps);
           },
         });
 
         const account = AccountSchema.fromNode(node);
+        activeAccountContext.set(account);
 
         await authResult.saveCredentials({
           accountID: node.account.id as unknown as ID<Account>,
@@ -267,6 +273,8 @@ export async function createAnonymousJazzContext({
     node.syncManager.addPeer(peer);
   }
 
+  activeAccountContext.setGuestMode();
+
   return {
     agent: new AnonymousJazzAgent(node),
     done: () => {},

package/src/testing.ts

@@ -2,6 +2,7 @@ import { AgentSecret, CryptoProvider, Peer } from "cojson";
 import { cojsonInternals } from "cojson";
 import { PureJSCrypto } from "cojson/crypto";
 import { Account, type AccountClass } from "./exports.js";
+import { activeAccountContext } from "./implementation/activeAccountContext.js";
 import {
   type AnonymousJazzAgent,
   type CoValueClass,
@@ -42,6 +43,7 @@ class TestJSCrypto extends PureJSCrypto {
 }
 
 export async function createJazzTestAccount<Acc extends Account>(options?: {
+  isCurrentActiveAccount?: boolean;
   AccountSchema?: CoValueClass<Acc>;
 }): Promise<Acc> {
   const AccountSchema = (options?.AccountSchema ??
@@ -52,10 +54,17 @@ export async function createJazzTestAccount<Acc extends Account>(options?: {
     },
     crypto: await TestJSCrypto.create(),
   });
+  if (options?.isCurrentActiveAccount) {
+    activeAccountContext.set(account);
+  }
 
   return account;
 }
 
+export function setActiveAccount(account: Account) {
+  activeAccountContext.set(account);
+}
+
 export async function createJazzTestGuest() {
   const ctx = await createAnonymousJazzContext({
     crypto: await PureJSCrypto.create(),

package/src/tests/account.test.ts

@@ -1,5 +1,6 @@
 import { expect, test } from "vitest";
 import { CoMap, co } from "../exports.js";
+import { createJazzTestAccount } from "../testing.js";
 import { setupTwoNodes } from "./utils.js";
 
 test("waitForAllCoValuesSync should resolve when all the values are synced", async () => {

package/src/tests/coFeed.test.ts

@@ -14,6 +14,7 @@ import {
   isControlledAccount,
 } from "../index.web.js";
 import { randomSessionProvider } from "../internal.js";
+import { createJazzTestAccount } from "../testing.js";
 import { setupTwoNodes } from "./utils.js";
 
 const Crypto = await WasmCrypto.create();
@@ -499,4 +500,16 @@ describe("waitForSync", async () => {
 
     expect(loadedStream).not.toBe("unavailable");
   });
+
+  test("should rely on the current active account if no account is provided", async () => {
+    const account = await createJazzTestAccount({
+      isCurrentActiveAccount: true,
+    });
+
+    const stream = FileStream.create();
+    expect(stream._owner._type).toEqual("Group");
+    expect(stream._owner.castAs(Group)._raw.roleOf(account._raw.id)).toEqual(
+      "admin",
+    );
+  });
 });

package/src/tests/coPlainText.test.ts

@@ -0,0 +1,33 @@
+import { describe, expect, test } from "vitest";
+import { Account, CoPlainText, WasmCrypto } from "../index.web.js";
+
+const Crypto = await WasmCrypto.create();
+
+describe("Simple CoPlainText operations", async () => {
+  const me = await Account.create({
+    creationProps: { name: "Hermes Puggington" },
+    crypto: Crypto,
+  });
+
+  const text = CoPlainText.create("hello world", { owner: me });
+
+  test("Construction", () => {
+    expect(text + "").toEqual("hello world");
+  });
+
+  describe("Mutation", () => {
+    test("insertion", () => {
+      const text = CoPlainText.create("hello world", { owner: me });
+
+      text.insertAfter(5, " cruel");
+      expect(text + "").toEqual("hello cruel world");
+    });
+
+    test("deletion", () => {
+      const text = CoPlainText.create("hello world", { owner: me });
+
+      text.deleteRange({ from: 3, to: 8 });
+      expect(text + "").toEqual("helrld");
+    });
+  });
+});

package/src/tests/coRichText.test.ts

@@ -0,0 +1,57 @@
+import { describe, expect, test } from "vitest";
+import { Account, CoRichText, Marks, WasmCrypto } from "../index.web.js";
+
+const Crypto = await WasmCrypto.create();
+
+describe("Simple CoRichText operations", async () => {
+  const me = await Account.create({
+    creationProps: { name: "Hermes Puggington" },
+    crypto: Crypto,
+  });
+
+  const text = CoRichText.createFromPlainText("hello world", { owner: me });
+
+  test("Construction", () => {
+    expect(text + "").toEqual("hello world");
+  });
+
+  describe("Mutation", () => {
+    test("insertion", () => {
+      const text = CoRichText.createFromPlainText("hello world", {
+        owner: me,
+      });
+
+      text.insertAfter(5, " cruel");
+      expect(text + "").toEqual("hello cruel world");
+    });
+
+    test("deletion", () => {
+      const text = CoRichText.createFromPlainText("hello world", {
+        owner: me,
+      });
+
+      text.deleteRange({ from: 3, to: 8 });
+      expect(text + "").toEqual("helrld");
+    });
+
+    test("inserting ranges", () => {
+      const text = CoRichText.createFromPlainText("hello world", {
+        owner: me,
+      });
+
+      text.insertMark(6, 9, Marks.Strong, { tag: "strong" });
+
+      expect(text.resolveMarks()).toEqual([
+        {
+          startAfter: 6,
+          startBefore: 7,
+          endAfter: 9,
+          endBefore: 10,
+          tag: "strong",
+          from: text.marks![0],
+          sourceMark: text.marks![0],
+        },
+      ]);
+    });
+  });
+});

package/src/tests/interfaces.test.ts

@@ -0,0 +1,90 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { Group } from "../coValues/group";
+import { Account } from "../exports";
+import {
+  parseCoValueCreateOptions,
+  parseGroupCreateOptions,
+} from "../internal";
+import { createJazzTestAccount } from "../testing";
+
+beforeEach(async () => {
+  await createJazzTestAccount({
+    isCurrentActiveAccount: true,
+  });
+});
+
+describe("parseCoValueCreateOptions", () => {
+  it("should create a new group when no options provided", () => {
+    const result = parseCoValueCreateOptions(undefined);
+    expect(result.owner._type).toBe("Group");
+    expect(
+      result.owner.castAs(Group)._raw.roleOf(Account.getMe()._raw.id),
+    ).toBe("admin");
+    expect(result.uniqueness).toBeUndefined();
+  });
+
+  it("should use the account as the owner when passing an Account", async () => {
+    const account = await createJazzTestAccount();
+    const result = parseCoValueCreateOptions(account);
+    expect(result.owner).toBe(account);
+    expect(result.uniqueness).toBeUndefined();
+  });
+
+  it("should use existing group when passing a Group", () => {
+    const group = Group.create();
+    const result = parseCoValueCreateOptions(group);
+    expect(result.owner).toBe(group);
+    expect(
+      result.owner.castAs(Group)._raw.roleOf(Account.getMe()._raw.id),
+    ).toBe("admin");
+    expect(result.uniqueness).toBeUndefined();
+  });
+
+  it("should handle options with uniqueness", () => {
+    const group = Group.create();
+    const result = parseCoValueCreateOptions({
+      unique: "per-group",
+      owner: group,
+    });
+    expect(result.owner).toBe(group);
+    expect(result.uniqueness?.uniqueness).toBe("per-group");
+  });
+
+  it("should use the account as the owner when passing an Account", async () => {
+    const account = await createJazzTestAccount();
+    const result = parseCoValueCreateOptions({
+      owner: account,
+      unique: "per-group",
+    });
+    expect(result.owner).toBe(account);
+    expect(result.uniqueness?.uniqueness).toBe("per-group");
+  });
+});
+
+describe("parseGroupCreateOptions", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it("should use active account when no options provided", () => {
+    const result = parseGroupCreateOptions(undefined);
+    expect(result.owner).toBe(Account.getMe());
+  });
+
+  it("should use provided account when passing an Account", async () => {
+    const account = await createJazzTestAccount();
+    const result = parseGroupCreateOptions(account);
+    expect(result.owner).toBe(account);
+  });
+
+  it("should use active account when passing empty options", () => {
+    const result = parseGroupCreateOptions({});
+    expect(result.owner).toBe(Account.getMe());
+  });
+
+  it("should use provided account in options.owner", async () => {
+    const account = await createJazzTestAccount();
+    const result = parseGroupCreateOptions({ owner: account });
+    expect(result.owner).toBe(account);
+  });
+});