version

Author: julienmalard

src/ordered-keyvalue.ts

@@ -12,7 +12,7 @@ import {
 import type { HeliaLibp2p } from "helia";
 import type { Libp2p } from "libp2p";
 import type { ServiceMap } from "@libp2p/interface";
-import itAll from 'it-all'
+import itAll from "it-all";
 import { getScalePosition } from "./utils.js";
 
 export type OrderedKeyValueDatabaseType = Awaited<
@@ -92,7 +92,6 @@ export const OrderedKeyValueApi = ({
 }: {
   database: InternalDatabase;
 }) => {
-
   const put = async (
     key: string,
     value: DagCborEncodable,
@@ -102,26 +101,24 @@ export const OrderedKeyValueApi = ({
     const entries = await itAll(iterator());
     const entryValue: { value: DagCborEncodable; position: number } = {
       value,
-      position: await getScalePosition({entries, key, position}),
+      position: await getScalePosition({ entries, key, position }),
     };
     return database.addOperation({ op: "PUT", key, value: entryValue });
   };
 
   const move = async (key: string, position: number): Promise<void> => {
     // Somewhat inefficient, I suppose, but we need to know which entries are already present.
     const entries = await itAll(iterator());
-    position = await getScalePosition({entries, key, position});
-    
+    position = await getScalePosition({ entries, key, position });
+
     await database.addOperation({ op: "MOVE", key, value: position });
   };
 
   const del = async (key: string): Promise<string> => {
     return database.addOperation({ op: "DEL", key, value: null });
   };
 
-  const get = async (
-    key: string,
-  ): Promise<DagCborEncodable | undefined> => {
+  const get = async (key: string): Promise<DagCborEncodable | undefined> => {
     for await (const entry of database.log.traverse()) {
       const { op, key: k, value } = entry.payload;
       if (op === "PUT" && k === key) {
@@ -146,8 +143,8 @@ export const OrderedKeyValueApi = ({
     unknown
   > {
     let count = 0;
-    const keys: {[key: string]: true} = {};
-    const positions: {[key: string]: number} = {};
+    const keys: { [key: string]: true } = {};
+    const positions: { [key: string]: number } = {};
 
     for await (const entry of database.log.traverse()) {
       const { op, key, value } = entry.payload;
@@ -157,17 +154,16 @@ export const OrderedKeyValueApi = ({
       if (op === "PUT") {
         const hash = entry.hash;
         const putValue = value as { value: unknown; position?: number };
-        
+
         keys[key] = true;
         count++;
-        
+
         yield {
           key,
           value: putValue.value,
           position: positions[key] ?? putValue.position ?? -1,
           hash,
-        }
-        
+        };
       } else if (op === "MOVE") {
         if (positions[key] !== undefined || keys[key]) continue;
         positions[key] = value as number;
@@ -178,7 +174,6 @@ export const OrderedKeyValueApi = ({
         break;
       }
     }
-
   };
 
   const all = async () => {
@@ -191,11 +186,13 @@ export const OrderedKeyValueApi = ({
     for await (const entry of iterator()) {
       entries.push(entry);
     }
-    return entries.sort((a, b) => a.position - b.position).map(e=>({
-      key: e.key,
-      value: e.value,
-      hash: e.hash,
-    }));
+    return entries
+      .sort((a, b) => a.position - b.position)
+      .map((e) => ({
+        key: e.key,
+        value: e.value,
+        hash: e.hash,
+      }));
   };
 
   return {

src/utils.ts

@@ -1,29 +1,42 @@
-export const getScalePosition = async ({ entries, key, position }: { entries:  {
+export const getScalePosition = async ({
+  entries,
+  key,
+  position,
+}: {
+  entries: {
     key: string;
     value: unknown;
     position: number;
     hash: string;
-}[]; key: string; position: number }): Promise<number> => {
-    // Firstly, sort entries by position
-    entries = entries.sort((a, b) => a.position - b.position);
+  }[];
+  key: string;
+  position: number;
+}): Promise<number> => {
+  // Firstly, sort entries by position
+  entries = entries.sort((a, b) => a.position - b.position);
 
-    // Negative values mean insert from end of list.
-    if (position < 0) position = entries.length - (position + 1)
+  // Negative values mean insert from end of list.
+  if (position < 0) position = entries.length - (position + 1);
 
-    // Find any previous position
-    const previousPosition = entries.find(x=>x.key === key)?.position;
+  // Find any previous position
+  const previousPosition = entries.find((x) => x.key === key)?.position;
 
-    // If we are moving upwards, need to add 1 to adjust for the now-deleted slot where our entry used to be
-    if (previousPosition !== undefined && position > previousPosition) position = position + 1
+  // If we are moving upwards, need to add 1 to adjust for the now-deleted slot where our entry used to be
+  if (previousPosition !== undefined && position > previousPosition)
+    position = position + 1;
 
-    // Calculate scale positions of previous and next entries, if they exist
-    const beforePosition = entries[Math.min(position, entries.length) - 1]?.position;
-    const afterPosition = entries[Math.max(position, 0)]?.position;
+  // Calculate scale positions of previous and next entries, if they exist
+  const beforePosition =
+    entries[Math.min(position, entries.length) - 1]?.position;
+  const afterPosition = entries[Math.max(position, 0)]?.position;
 
-    // Insert to beginning of list if there is no preceding entry
-    if (beforePosition === undefined) return afterPosition === undefined ? 0 : afterPosition - 1;
+  // Insert to beginning of list if there is no preceding entry
+  if (beforePosition === undefined)
+    return afterPosition === undefined ? 0 : afterPosition - 1;
 
-    // Insert to end of list if there is no following entry, or somewhere between adjacent entries 
-    // Note: use Math.random() rather than mean to reduce risk of collisions in concurrent edits
-    return afterPosition === undefined ? beforePosition + 1 : beforePosition + (afterPosition - beforePosition) * Math.random()
-  }
+  // Insert to end of list if there is no following entry, or somewhere between adjacent entries
+  // Note: use Math.random() rather than mean to reduce risk of collisions in concurrent edits
+  return afterPosition === undefined
+    ? beforePosition + 1
+    : beforePosition + (afterPosition - beforePosition) * Math.random();
+};

src/version.ts

@@ -1,2 +1,2 @@
 // Generated by genversion.
-export const version = "1.2.2";
+export const version = "1.3.0";