cojson-storage-indexeddb 0.8.12 → 0.8.16

package/src/syncPromises.ts

@@ -2,9 +2,9 @@
 const isFunction = (func: any) => typeof func === "function";
 
 const isObject = (supposedObject: any) =>
-    typeof supposedObject === "object" &&
-    supposedObject !== null &&
-    !Array.isArray(supposedObject);
+  typeof supposedObject === "object" &&
+  supposedObject !== null &&
+  !Array.isArray(supposedObject);
 
 const isThenable = (obj: any) => isObject(obj) && isFunction(obj.then);
 
@@ -13,14 +13,14 @@ const identity = (co: any) => co;
 export { isObject, isThenable, identity, isFunction };
 
 enum States {
-    PENDING = "PENDING",
-    RESOLVED = "RESOLVED",
-    REJECTED = "REJECTED",
+  PENDING = "PENDING",
+  RESOLVED = "RESOLVED",
+  REJECTED = "REJECTED",
 }
 
 interface Handler<T, U> {
-    onSuccess: HandlerOnSuccess<T, U>;
-    onFail: HandlerOnFail<U>;
+  onSuccess: HandlerOnSuccess<T, U>;
+  onFail: HandlerOnFail<U>;
 }
 
 type HandlerOnSuccess<T, U = any> = (value: T) => U | Thenable<U>;
@@ -28,202 +28,197 @@ type HandlerOnFail<U = any> = (reason: any) => U | Thenable<U>;
 type Finally<U> = () => U | Thenable<U>;
 
 interface Thenable<T> {
-    then<U>(
-        onSuccess?: HandlerOnSuccess<T, U>,
-        onFail?: HandlerOnFail<U>,
-    ): Thenable<U>;
-    then<U>(
-        onSuccess?: HandlerOnSuccess<T, U>,
-        onFail?: (reason: any) => void,
-    ): Thenable<U>;
+  then<U>(
+    onSuccess?: HandlerOnSuccess<T, U>,
+    onFail?: HandlerOnFail<U>,
+  ): Thenable<U>;
+  then<U>(
+    onSuccess?: HandlerOnSuccess<T, U>,
+    onFail?: (reason: any) => void,
+  ): Thenable<U>;
 }
 
 type Resolve<R> = (value?: R | Thenable<R>) => void;
 type Reject = (value?: any) => void;
 
 export class SyncPromise<T> {
-    private state: States = States.PENDING;
-    private handlers: Handler<T, any>[] = [];
-    private value: T | any;
-
-    public constructor(
-        callback: (resolve: Resolve<T>, reject: Reject) => void,
-    ) {
-        try {
-            callback(this.resolve as Resolve<T>, this.reject);
-        } catch (e) {
-            this.reject(e);
-        }
+  private state: States = States.PENDING;
+  private handlers: Handler<T, any>[] = [];
+  private value: T | any;
+
+  public constructor(callback: (resolve: Resolve<T>, reject: Reject) => void) {
+    try {
+      callback(this.resolve as Resolve<T>, this.reject);
+    } catch (e) {
+      this.reject(e);
     }
+  }
 
-    private resolve = (value: T) => {
-        return this.setResult(value, States.RESOLVED);
-    };
-
-    private reject = (reason: any) => {
-        return this.setResult(reason, States.REJECTED);
-    };
+  private resolve = (value: T) => {
+    return this.setResult(value, States.RESOLVED);
+  };
 
-    private setResult = (value: T | any, state: States) => {
-        const set = () => {
-            if (this.state !== States.PENDING) {
-                return null;
-            }
+  private reject = (reason: any) => {
+    return this.setResult(reason, States.REJECTED);
+  };
 
-            if (isThenable(value)) {
-                return (value as Thenable<T>).then(this.resolve, this.reject);
-            }
+  private setResult = (value: T | any, state: States) => {
+    const set = () => {
+      if (this.state !== States.PENDING) {
+        return null;
+      }
 
-            this.value = value;
-            this.state = state;
+      if (isThenable(value)) {
+        return (value as Thenable<T>).then(this.resolve, this.reject);
+      }
 
-            return this.executeHandlers();
-        };
+      this.value = value;
+      this.state = state;
 
-        void set();
+      return this.executeHandlers();
     };
 
-    private executeHandlers = () => {
-        if (this.state === States.PENDING) {
-            return null;
-        }
-
-        this.handlers.forEach((handler) => {
-            if (this.state === States.REJECTED) {
-                return handler.onFail(this.value);
-            }
-
-            return handler.onSuccess(this.value);
-        });
-
-        this.handlers = [];
-    };
-
-    private attachHandler = (handler: Handler<T, any>) => {
-        this.handlers = [...this.handlers, handler];
-
-        this.executeHandlers();
-    };
-
-    public then<U>(
-        onSuccess: HandlerOnSuccess<T, U>,
-        onFail?: HandlerOnFail<U>,
-    ) {
-        return new SyncPromise<U>((resolve, reject) => {
-            return this.attachHandler({
-                onSuccess: (result) => {
-                    try {
-                        return resolve(onSuccess(result));
-                    } catch (e) {
-                        return reject(e);
-                    }
-                },
-                onFail: (reason) => {
-                    if (!onFail) {
-                        return reject(reason);
-                    }
-
-                    try {
-                        return resolve(onFail(reason));
-                    } catch (e) {
-                        return reject(e);
-                    }
-                },
-            });
-        });
-    }
-
-    public catch<U>(onFail: HandlerOnFail<U>) {
-        return this.then<U>(identity, onFail);
-    }
-
-    // methods
-
-    public toString() {
-        return `[object SyncPromise]`;
-    }
+    void set();
+  };
 
-    public finally<U>(cb: Finally<U>) {
-        return new SyncPromise<U>((resolve, reject) => {
-            let co: U | any;
-            let isRejected: boolean;
-
-            return this.then(
-                (value) => {
-                    isRejected = false;
-                    co = value;
-                    return cb();
-                },
-                (reason) => {
-                    isRejected = true;
-                    co = reason;
-                    return cb();
-                },
-            ).then(() => {
-                if (isRejected) {
-                    return reject(co);
-                }
-
-                return resolve(co);
-            });
-        });
+  private executeHandlers = () => {
+    if (this.state === States.PENDING) {
+      return null;
     }
 
-    public spread<U>(handler: (...args: any[]) => U) {
-        return this.then<U>((collection) => {
-            if (Array.isArray(collection)) {
-                return handler(...collection);
-            }
-
-            return handler(collection);
-        });
-    }
-
-    // static
-
-    public static resolve<U = any>(value?: U | Thenable<U>) {
-        return new SyncPromise<U>((resolve) => {
-            return resolve(value);
-        });
-    }
-
-    public static reject<U>(reason?: any) {
-        return new SyncPromise<U>((_resolve, reject) => {
+    this.handlers.forEach((handler) => {
+      if (this.state === States.REJECTED) {
+        return handler.onFail(this.value);
+      }
+
+      return handler.onSuccess(this.value);
+    });
+
+    this.handlers = [];
+  };
+
+  private attachHandler = (handler: Handler<T, any>) => {
+    this.handlers = [...this.handlers, handler];
+
+    this.executeHandlers();
+  };
+
+  public then<U>(onSuccess: HandlerOnSuccess<T, U>, onFail?: HandlerOnFail<U>) {
+    return new SyncPromise<U>((resolve, reject) => {
+      return this.attachHandler({
+        onSuccess: (result) => {
+          try {
+            return resolve(onSuccess(result));
+          } catch (e) {
+            return reject(e);
+          }
+        },
+        onFail: (reason) => {
+          if (!onFail) {
             return reject(reason);
-        });
-    }
+          }
+
+          try {
+            return resolve(onFail(reason));
+          } catch (e) {
+            return reject(e);
+          }
+        },
+      });
+    });
+  }
+
+  public catch<U>(onFail: HandlerOnFail<U>) {
+    return this.then<U>(identity, onFail);
+  }
+
+  // methods
+
+  public toString() {
+    return `[object SyncPromise]`;
+  }
+
+  public finally<U>(cb: Finally<U>) {
+    return new SyncPromise<U>((resolve, reject) => {
+      let co: U | any;
+      let isRejected: boolean;
+
+      return this.then(
+        (value) => {
+          isRejected = false;
+          co = value;
+          return cb();
+        },
+        (reason) => {
+          isRejected = true;
+          co = reason;
+          return cb();
+        },
+      ).then(() => {
+        if (isRejected) {
+          return reject(co);
+        }
 
-    public static all<U = any>(collection: (U | Thenable<U>)[]) {
-        return new SyncPromise<U[]>((resolve, reject) => {
-            if (!Array.isArray(collection)) {
-                return reject(new TypeError("An array must be provided."));
-            }
-
-            if (collection.length === 0) {
-                return resolve([]);
-            }
-
-            let counter = collection.length;
-            const resolvedCollection: U[] = [];
-
-            const tryResolve = (value: U, index: number) => {
-                counter -= 1;
-                resolvedCollection[index] = value;
-
-                if (counter !== 0) {
-                    return null;
-                }
-
-                return resolve(resolvedCollection);
-            };
-
-            return collection.forEach((item, index) => {
-                return SyncPromise.resolve(item)
-                    .then((value) => {
-                        return tryResolve(value, index);
-                    })
-                    .catch(reject);
-            });
-        });
-    }
+        return resolve(co);
+      });
+    });
+  }
+
+  public spread<U>(handler: (...args: any[]) => U) {
+    return this.then<U>((collection) => {
+      if (Array.isArray(collection)) {
+        return handler(...collection);
+      }
+
+      return handler(collection);
+    });
+  }
+
+  // static
+
+  public static resolve<U = any>(value?: U | Thenable<U>) {
+    return new SyncPromise<U>((resolve) => {
+      return resolve(value);
+    });
+  }
+
+  public static reject<U>(reason?: any) {
+    return new SyncPromise<U>((_resolve, reject) => {
+      return reject(reason);
+    });
+  }
+
+  public static all<U = any>(collection: (U | Thenable<U>)[]) {
+    return new SyncPromise<U[]>((resolve, reject) => {
+      if (!Array.isArray(collection)) {
+        return reject(new TypeError("An array must be provided."));
+      }
+
+      if (collection.length === 0) {
+        return resolve([]);
+      }
+
+      let counter = collection.length;
+      const resolvedCollection: U[] = [];
+
+      const tryResolve = (value: U, index: number) => {
+        counter -= 1;
+        resolvedCollection[index] = value;
+
+        if (counter !== 0) {
+          return null;
+        }
+
+        return resolve(resolvedCollection);
+      };
+
+      return collection.forEach((item, index) => {
+        return SyncPromise.resolve(item)
+          .then((value) => {
+            return tryResolve(value, index);
+          })
+          .catch(reject);
+      });
+    });
+  }
 }

package/src/tests/index.test.ts

@@ -1,68 +1,68 @@
 import "fake-indexeddb/auto"; // Polyfill for IndexedDB
 
-import { expect, test } from "vitest";
 import { ControlledAgent, LocalNode, WasmCrypto } from "cojson";
+import { expect, test } from "vitest";
 import { IDBStorage } from "../index.js";
 
 const Crypto = await WasmCrypto.create();
 
 test.skip("Should be able to initialize and load from empty DB", async () => {
-    const agentSecret = Crypto.newRandomAgentSecret();
+  const agentSecret = Crypto.newRandomAgentSecret();
 
-    const node = new LocalNode(
-        new ControlledAgent(agentSecret, Crypto),
-        Crypto.newRandomSessionID(Crypto.getAgentID(agentSecret)),
-        Crypto,
-    );
+  const node = new LocalNode(
+    new ControlledAgent(agentSecret, Crypto),
+    Crypto.newRandomSessionID(Crypto.getAgentID(agentSecret)),
+    Crypto,
+  );
 
-    node.syncManager.addPeer(await IDBStorage.asPeer({ trace: true }));
+  node.syncManager.addPeer(await IDBStorage.asPeer({ trace: true }));
 
-    console.log("yay!");
+  console.log("yay!");
 
-    const _group = node.createGroup();
+  const _group = node.createGroup();
 
-    await new Promise((resolve) => setTimeout(resolve, 200));
+  await new Promise((resolve) => setTimeout(resolve, 200));
 
-    expect(node.syncManager.peers["storage"]).toBeDefined();
+  expect(node.syncManager.peers["storage"]).toBeDefined();
 });
 
 test("Should be able to sync data to database and then load that from a new node", async () => {
-    const agentSecret = Crypto.newRandomAgentSecret();
+  const agentSecret = Crypto.newRandomAgentSecret();
 
-    const node1 = new LocalNode(
-        new ControlledAgent(agentSecret, Crypto),
-        Crypto.newRandomSessionID(Crypto.getAgentID(agentSecret)),
-        Crypto,
-    );
+  const node1 = new LocalNode(
+    new ControlledAgent(agentSecret, Crypto),
+    Crypto.newRandomSessionID(Crypto.getAgentID(agentSecret)),
+    Crypto,
+  );
 
-    node1.syncManager.addPeer(
-        await IDBStorage.asPeer({ trace: true, localNodeName: "node1" }),
-    );
+  node1.syncManager.addPeer(
+    await IDBStorage.asPeer({ trace: true, localNodeName: "node1" }),
+  );
 
-    console.log("yay!");
+  console.log("yay!");
 
-    const group = node1.createGroup();
+  const group = node1.createGroup();
 
-    const map = group.createMap();
+  const map = group.createMap();
 
-    map.set("hello", "world");
+  map.set("hello", "world");
 
-    await new Promise((resolve) => setTimeout(resolve, 200));
+  await new Promise((resolve) => setTimeout(resolve, 200));
 
-    const node2 = new LocalNode(
-        new ControlledAgent(agentSecret, Crypto),
-        Crypto.newRandomSessionID(Crypto.getAgentID(agentSecret)),
-        Crypto,
-    );
+  const node2 = new LocalNode(
+    new ControlledAgent(agentSecret, Crypto),
+    Crypto.newRandomSessionID(Crypto.getAgentID(agentSecret)),
+    Crypto,
+  );
 
-    node2.syncManager.addPeer(
-        await IDBStorage.asPeer({ trace: true, localNodeName: "node2" }),
-    );
+  node2.syncManager.addPeer(
+    await IDBStorage.asPeer({ trace: true, localNodeName: "node2" }),
+  );
 
-    const map2 = await node2.load(map.id);
-    if (map2 === "unavailable") {
-        throw new Error("Map is unavailable");
-    }
+  const map2 = await node2.load(map.id);
+  if (map2 === "unavailable") {
+    throw new Error("Map is unavailable");
+  }
 
-    expect(map2.get("hello")).toBe("world");
+  expect(map2.get("hello")).toBe("world");
 });

package/tsconfig.json

@@ -9,7 +9,7 @@
     "skipLibCheck": true,
     "forceConsistentCasingInFileNames": true,
     "noUncheckedIndexedAccess": true,
-    "esModuleInterop": true,
+    "esModuleInterop": true
   },
-  "include": ["./src/**/*"],
+  "include": ["./src/**/*"]
 }

package/.eslintrc.cjs

@@ -1,24 +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"],
-    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",
-    },
-}

package/.prettierrc.js

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