cojson 0.8.12 → 0.8.17

package/src/tests/testUtils.ts

@@ -1,96 +1,128 @@
 import { expect } from "vitest";
-import { LocalNode } from "../localNode.js";
-import { expectGroup } from "../typeUtils/expectGroup.js";
 import { ControlledAgent } from "../coValues/account.js";
-import { SessionID } from "../ids.js";
 import { WasmCrypto } from "../crypto/WasmCrypto.js";
+import { SessionID } from "../ids.js";
+import { LocalNode } from "../localNode.js";
+import { expectGroup } from "../typeUtils/expectGroup.js";
 
 const Crypto = await WasmCrypto.create();
 
 export function randomAnonymousAccountAndSessionID(): [
-    ControlledAgent,
-    SessionID,
+  ControlledAgent,
+  SessionID,
 ] {
-    const agentSecret = Crypto.newRandomAgentSecret();
+  const agentSecret = Crypto.newRandomAgentSecret();
+
+  const sessionID = Crypto.newRandomSessionID(Crypto.getAgentID(agentSecret));
 
-    const sessionID = Crypto.newRandomSessionID(Crypto.getAgentID(agentSecret));
+  return [new ControlledAgent(agentSecret, Crypto), sessionID];
+}
 
-    return [new ControlledAgent(agentSecret, Crypto), sessionID];
+export function createTestNode() {
+  const [admin, session] = randomAnonymousAccountAndSessionID();
+  return new LocalNode(admin, session, Crypto);
 }
 
 export function newGroup() {
-    const [admin, sessionID] = randomAnonymousAccountAndSessionID();
+  const [admin, sessionID] = randomAnonymousAccountAndSessionID();
 
-    const node = new LocalNode(admin, sessionID, Crypto);
+  const node = new LocalNode(admin, sessionID, Crypto);
 
-    const groupCore = node.createCoValue({
-        type: "comap",
-        ruleset: { type: "group", initialAdmin: admin.id },
-        meta: null,
-        ...Crypto.createdNowUnique(),
-    });
+  const groupCore = node.createCoValue({
+    type: "comap",
+    ruleset: { type: "group", initialAdmin: admin.id },
+    meta: null,
+    ...Crypto.createdNowUnique(),
+  });
 
-    const group = expectGroup(groupCore.getCurrentContent());
+  const group = expectGroup(groupCore.getCurrentContent());
 
-    group.set(admin.id, "admin", "trusting");
-    expect(group.get(admin.id)).toEqual("admin");
+  group.set(admin.id, "admin", "trusting");
+  expect(group.get(admin.id)).toEqual("admin");
 
-    return { node, groupCore, admin };
+  return { node, groupCore, admin };
 }
 
 export function groupWithTwoAdmins() {
-    const { groupCore, admin, node } = newGroup();
+  const { groupCore, admin, node } = newGroup();
 
-    const otherAdmin = node.createAccount();
+  const otherAdmin = node.createAccount();
 
-    const group = expectGroup(groupCore.getCurrentContent());
+  const group = expectGroup(groupCore.getCurrentContent());
 
-    group.set(otherAdmin.id, "admin", "trusting");
-    expect(group.get(otherAdmin.id)).toEqual("admin");
+  group.set(otherAdmin.id, "admin", "trusting");
+  expect(group.get(otherAdmin.id)).toEqual("admin");
 
-    if (group.type !== "comap") {
-        throw new Error("Expected map");
-    }
+  if (group.type !== "comap") {
+    throw new Error("Expected map");
+  }
 
-    expect(group.get(otherAdmin.id)).toEqual("admin");
-    return { groupCore, admin, otherAdmin, node };
+  expect(group.get(otherAdmin.id)).toEqual("admin");
+  return { groupCore, admin, otherAdmin, node };
 }
 
 export function newGroupHighLevel() {
-    const [admin, sessionID] = randomAnonymousAccountAndSessionID();
+  const [admin, sessionID] = randomAnonymousAccountAndSessionID();
 
-    const node = new LocalNode(admin, sessionID, Crypto);
+  const node = new LocalNode(admin, sessionID, Crypto);
 
-    const group = node.createGroup();
+  const group = node.createGroup();
 
-    return { admin, node, group };
+  return { admin, node, group };
 }
 
 export function groupWithTwoAdminsHighLevel() {
-    const { admin, node, group } = newGroupHighLevel();
+  const { admin, node, group } = newGroupHighLevel();
 
-    const otherAdmin = node.createAccount();
+  const otherAdmin = node.createAccount();
 
-    group.addMember(otherAdmin, "admin");
+  group.addMember(otherAdmin, "admin");
 
-    return { admin, node, group, otherAdmin };
+  return { admin, node, group, otherAdmin };
 }
 
 export function shouldNotResolve<T>(
-    promise: Promise<T>,
-    ops: { timeout: number },
+  promise: Promise<T>,
+  ops: { timeout: number },
 ): Promise<void> {
-    return new Promise((resolve, reject) => {
-        promise
-            .then((v) =>
-                reject(
-                    new Error(
-                        "Should not have resolved, but resolved to " +
-                            JSON.stringify(v),
-                    ),
-                ),
-            )
-            .catch(reject);
-        setTimeout(resolve, ops.timeout);
-    });
+  return new Promise((resolve, reject) => {
+    promise
+      .then((v) =>
+        reject(
+          new Error(
+            "Should not have resolved, but resolved to " + JSON.stringify(v),
+          ),
+        ),
+      )
+      .catch(reject);
+    setTimeout(resolve, ops.timeout);
+  });
+}
+
+export function waitFor(callback: () => boolean | void) {
+  return new Promise<void>((resolve, reject) => {
+    const checkPassed = () => {
+      try {
+        return { ok: callback(), error: null };
+      } catch (error) {
+        return { ok: false, error };
+      }
+    };
+
+    let retries = 0;
+
+    const interval = setInterval(() => {
+      const { ok, error } = checkPassed();
+
+      if (ok !== false) {
+        clearInterval(interval);
+        resolve();
+      }
+
+      if (++retries > 10) {
+        clearInterval(interval);
+        reject(error);
+      }
+    }, 100);
+  });
 }

package/src/typeUtils/accountOrAgentIDfromSessionID.ts

@@ -1,9 +1,9 @@
-import { AgentID, SessionID } from "../ids.js";
 import { RawAccountID } from "../coValues/account.js";
+import { AgentID, SessionID } from "../ids.js";
 
 export function accountOrAgentIDfromSessionID(
-    sessionID: SessionID,
+  sessionID: SessionID,
 ): RawAccountID | AgentID {
-    const until = sessionID.indexOf("_session");
-    return sessionID.slice(0, until) as RawAccountID | AgentID;
+  const until = sessionID.indexOf("_session");
+  return sessionID.slice(0, until) as RawAccountID | AgentID;
 }

package/src/typeUtils/expectGroup.ts

@@ -1,15 +1,15 @@
-import { expectMap, type RawCoValue } from "../coValue.js";
+import { type RawCoValue, expectMap } from "../coValue.js";
 import { RawGroup } from "../coValues/group.js";
 
 export function expectGroup(content: RawCoValue): RawGroup {
-    const map = expectMap(content);
-    if (map.core.header.ruleset.type !== "group") {
-        throw new Error("Expected group ruleset in group");
-    }
+  const map = expectMap(content);
+  if (map.core.header.ruleset.type !== "group") {
+    throw new Error("Expected group ruleset in group");
+  }
 
-    if (!(map instanceof RawGroup)) {
-        throw new Error("Expected group");
-    }
+  if (!(map instanceof RawGroup)) {
+    throw new Error("Expected group");
+  }
 
-    return map;
+  return map;
 }

package/src/typeUtils/isAccountID.ts

@@ -2,5 +2,5 @@ import type { RawAccountID } from "../coValues/account.js";
 import type { AgentID } from "../ids.js";
 
 export function isAccountID(id: RawAccountID | AgentID): id is RawAccountID {
-    return id.startsWith("co_");
+  return id.startsWith("co_");
 }

package/src/typeUtils/isCoValue.ts

@@ -1,17 +1,17 @@
 import { type RawCoValue } from "../coValue.js";
-import type { JsonValue } from "../jsonValue.js";
-import { RawCoMap } from "../coValues/coMap.js";
 import { RawCoList } from "../coValues/coList.js";
+import { RawCoMap } from "../coValues/coMap.js";
 import { RawCoStream } from "../coValues/coStream.js";
 import { RawBinaryCoStream } from "../coValues/coStream.js";
+import type { JsonValue } from "../jsonValue.js";
 
 export function isCoValue(
-    value: JsonValue | RawCoValue | undefined,
+  value: JsonValue | RawCoValue | undefined,
 ): value is RawCoValue {
-    return (
-        value instanceof RawCoMap ||
-        value instanceof RawCoList ||
-        value instanceof RawCoStream ||
-        value instanceof RawBinaryCoStream
-    );
+  return (
+    value instanceof RawCoMap ||
+    value instanceof RawCoList ||
+    value instanceof RawCoStream ||
+    value instanceof RawBinaryCoStream
+  );
 }

package/tsconfig.json

@@ -1,8 +1,6 @@
 {
   "compilerOptions": {
-    "lib": [
-      "ESNext"
-    ],
+    "lib": ["ESNext"],
     "module": "esnext",
     "target": "ES2020",
     "moduleResolution": "bundler",
@@ -11,6 +9,6 @@
     "skipLibCheck": true,
     "forceConsistentCasingInFileNames": true,
     "noUncheckedIndexedAccess": true,
-    "esModuleInterop": true,
-  },
-}
+    "esModuleInterop": true
+  }
+}

package/tsconfig.native.json

@@ -1,12 +1,10 @@
 {
-    "extends": "./tsconfig.json",
-    "include": [
-        "./src/**/*.ts"
-    ],
-    "exclude": [
-        "./node_modules",
-        "./src/tests",
-        "./src/crypto/WasmCrypto.ts",
-        "./src/index.web.ts"
-    ],
-}
+  "extends": "./tsconfig.json",
+  "include": ["./src/**/*.ts"],
+  "exclude": [
+    "./node_modules",
+    "./src/tests",
+    "./src/crypto/WasmCrypto.ts",
+    "./src/index.web.ts"
+  ]
+}

package/tsconfig.web.json

@@ -1,11 +1,5 @@
 {
-    "extends": "./tsconfig.json",
-    "include": [
-        "./src/**/*.ts"
-    ],
-    "exclude": [
-        "./node_modules",
-        "./src/tests",
-        "./src/index.native.ts"
-    ]
-}
+  "extends": "./tsconfig.json",
+  "include": ["./src/**/*.ts"],
+  "exclude": ["./node_modules", "./src/tests", "./src/index.native.ts"]
+}

package/.eslintrc.cjs

@@ -1,25 +0,0 @@
-module.exports = {
-    extends: [
-        "eslint:recommended",
-        "plugin:@typescript-eslint/recommended",
-        "plugin:require-extensions/recommended",
-        "prettier",
-    ],
-    parser: "@typescript-eslint/parser",
-    plugins: ["@typescript-eslint", "require-extensions", "neverthrow"],
-    parserOptions: {
-        project: "./tsconfig.json",
-        tsconfigRootDir: __dirname,
-    },
-    ignorePatterns: [".eslint.cjs"],
-    root: true,
-    rules: {
-        "no-unused-vars": "off",
-        "@typescript-eslint/no-unused-vars": [
-            "error",
-            { argsIgnorePattern: "^_", varsIgnorePattern: "^_" },
-        ],
-        "@typescript-eslint/no-floating-promises": "error",
-        "neverthrow/must-use-result": "error",
-    },
-};

package/.prettierrc.js

@@ -1,9 +0,0 @@
-/** @type {import("prettier").Config} */
-const config = {
-    trailingComma: "all",
-    tabWidth: 4,
-    semi: true,
-    singleQuote: false,
-};
-
-export default config;