Format code

Author: julienmalard

src/nested.ts

@@ -83,8 +83,7 @@ const Nested =
       onUpdate,
     });
 
-    const { put, set, get, del, move, iterator, all } =
-      NestedApi({ database });
+    const { put, set, get, del, move, iterator, all } = NestedApi({ database });
 
     return {
       ...database,
@@ -178,19 +177,28 @@ export const NestedApi = ({ database }: { database: InternalDatabase }) => {
 
   type PutFunction = {
     (object: NestedValueObject): Promise<string[]>;
-    (key: NestedKey, object: PossiblyNestedValue, position?: number): Promise<string[]>;
+    (
+      key: NestedKey,
+      object: PossiblyNestedValue,
+      position?: number,
+    ): Promise<string[]>;
   };
   const put: PutFunction = async (
     keyOrObject,
     object?: PossiblyNestedValue,
     position?: number,
   ): Promise<string[]> => {
-    let flattenedEntries: { key: string; value: DagCborEncodable, position?: number }[];
+    let flattenedEntries: {
+      key: string;
+      value: DagCborEncodable;
+      position?: number;
+    }[];
 
-    if (isNestedKey(keyOrObject)) {  // If a key was given
+    if (isNestedKey(keyOrObject)) {
+      // If a key was given
       // Join key
-      keyOrObject = asJoinedKey(keyOrObject)
-      
+      keyOrObject = asJoinedKey(keyOrObject);
+
       // Ensure value exists
       if (object === undefined) throw new Error("Must specify a value to add");
 
@@ -201,12 +209,15 @@ export const NestedApi = ({ database }: { database: InternalDatabase }) => {
           value: entry.value,
         }));
       } else {
-        flattenedEntries = [{key: keyOrObject, value: object, position}]
+        flattenedEntries = [{ key: keyOrObject, value: object, position }];
       }
-    } else {  // If no key was given
+    } else {
+      // If no key was given
       flattenedEntries = flatten(keyOrObject);
     }
-    return await Promise.all(flattenedEntries.map((e) => putEntry(e.key, e.value, e.position)));
+    return await Promise.all(
+      flattenedEntries.map((e) => putEntry(e.key, e.value, e.position)),
+    );
   };
 
   const iterator = async function* ({
@@ -277,7 +288,7 @@ export const NestedApi = ({ database }: { database: InternalDatabase }) => {
       values.unshift(entry);
     }
     const sorted = values.toSorted((a, b) => a.position - b.position);
-    
+
     return toNested(sorted);
   };
 

src/types.ts

@@ -16,7 +16,7 @@ export type NestedValueMap = Map<string, DagCborEncodable | NestedValueMap>;
 export type NestedValueObject = {
   [key: string]: DagCborEncodable | NestedValueObject;
 };
-export type NestedValue = NestedValueMap | NestedValueObject; 
+export type NestedValue = NestedValueMap | NestedValueObject;
 
 export type NestedMapToObject<T> =
   T extends NestedObjectToMap<infer R> ? R : never;

src/utils.ts

@@ -61,17 +61,22 @@ export const isNestedValueObject = (
   );
 };
 
-export const isNestedValueMap = (x: PossiblyNestedValue): x is NestedValueMap => {
+export const isNestedValueMap = (
+  x: PossiblyNestedValue,
+): x is NestedValueMap => {
   return x instanceof Map;
 };
 
 export const isNestedValue = (x: PossiblyNestedValue): x is NestedValue => {
   return isNestedValueObject(x) || isNestedValueMap(x);
-}
+};
 
 export const isNestedKey = (x: unknown): x is NestedKey => {
-  return typeof x === "string" || Array.isArray(x) && x.every(k=>typeof k === "string");
-}
+  return (
+    typeof x === "string" ||
+    (Array.isArray(x) && x.every((k) => typeof k === "string"))
+  );
+};
 
 export const flatten = (
   x: NestedValueMap | NestedValueObject,

test/nested.spec.ts

@@ -246,16 +246,16 @@ describe("Nested Database", () => {
       const actual = await db.all();
 
       // Check unordered structure
-      expect(toObject(actual)).to.deep.equal({ a: { b: 2, c: 3, d: 1}})
+      expect(toObject(actual)).to.deep.equal({ a: { b: 2, c: 3, d: 1 } });
 
       // Here we only check the middle value, because we don't know if key0 or key1 was
       // added first due to the race condition we intentionally introduced above.
-      const actualA = actual.get("a") as Map<string, number>
-      expect([...actualA?.keys()||[]][1]).to.equal("d");
+      const actualA = actual.get("a") as Map<string, number>;
+      expect([...(actualA?.keys() || [])][1]).to.equal("d");
     });
 
     it("move a value", async () => {
-      await fillKeys(db, 3)
+      await fillKeys(db, 3);
       await db.move("key0", 1);
 
       const actual = await db.all();
@@ -269,7 +269,7 @@ describe("Nested Database", () => {
     });
 
     it("move a value to index 0", async () => {
-      await fillKeys(db, 3)
+      await fillKeys(db, 3);
       await db.move("key2", 0);
 
       const actual = await db.all();

test/utils.ts

@@ -18,7 +18,7 @@ export const expectNestedMapEqual = (
   if (ref instanceof Map) {
     expect([...map.keys()]).to.deep.equal([...ref.keys()]);
     for (const key of ref.keys()) {
-      const value = ref.get(key)
+      const value = ref.get(key);
       if (value instanceof Map) {
         const mapBranch = map.get(key);
         expect(mapBranch).to.be.instanceOf(Map);
@@ -28,13 +28,17 @@ export const expectNestedMapEqual = (
   }
 };
 
-export const fillKeys = async (db: NestedDatabaseType, n: number): Promise<string[]> => {
-  const keyValues = (
-    [...Array(n).keys()].map((i) => ({key: `key${i}`, value: `value${i}`}))
-  )
+export const fillKeys = async (
+  db: NestedDatabaseType,
+  n: number,
+): Promise<string[]> => {
+  const keyValues = [...Array(n).keys()].map((i) => ({
+    key: `key${i}`,
+    value: `value${i}`,
+  }));
   const hashes: string[] = [];
-  for (const {key, value} of keyValues) {
-    hashes.push(...await db.put(key, value));
+  for (const { key, value } of keyValues) {
+    hashes.push(...(await db.put(key, value)));
   }
   return hashes;
-}
+};