@mikeatlast/ponder 0.16.1-fork.1

package/src/utils/timer.ts

@@ -0,0 +1,8 @@
+/**
+ * Measures the elapsed wall clock time in milliseconds (ms) between two points.
+ * @returns A function returning the elapsed time in milliseconds (ms).
+ */
+export function startClock() {
+  const start = performance.now();
+  return () => performance.now() - start;
+}

package/src/utils/truncate.ts

@@ -0,0 +1,15 @@
+/**
+ * Truncates a given string to a specified maximum length, adding ellipsis in the middle if necessary.
+ *
+ * @param string - The string to be truncated.
+ * @param maxLength - The maximum length of the truncated string, including the ellipsis. Defaults to 36.
+ * @returns The truncated string with ellipsis in the middle if it exceeds the maximum length.
+ */
+export const truncate = (string: string, maxLength = 36): string => {
+  if (string.length <= maxLength) return string;
+
+  const prefixLength = Math.floor(maxLength / 2) - 2; // Keep half the start
+  const suffixLength = Math.ceil(maxLength / 2) - 2; // Keep half the end
+
+  return `${string.slice(0, prefixLength)}...${string.slice(-suffixLength)}`;
+};

package/src/utils/wait.ts

@@ -0,0 +1,8 @@
+/** Waits at least a specified amount of time.
+ *
+ * @param milliseconds Minimum number of milliseconds to wait.
+ */
+export async function wait(milliseconds: number) {
+  if (process.env.NODE_ENV === "ci") return;
+  return new Promise<void>((res) => setTimeout(res, milliseconds));
+}

package/src/utils/zipper.ts

@@ -0,0 +1,80 @@
+/**
+ * Merges two sorted arrays into a single sorted array.
+ *
+ * @param array1 - The first array to merge.
+ * @param array2 - The second array to merge.
+ * @param compare - The comparison function to use.
+ *
+ * @returns The merged array.
+ *
+ * @example
+ * ```ts
+ * const result = zipper([1, 3, 5], [2, 4, 6]);
+ * // result = [1, 2, 3, 4, 5, 6]
+ * ```
+ */
+export const zipper = <T>(
+  array1: T[],
+  array2: T[],
+  compare?: (a: T, b: T) => number,
+): T[] => {
+  const result: T[] = [];
+  let i = 0;
+  let j = 0;
+
+  while (i < array1.length && j < array2.length) {
+    if (
+      compare ? compare(array1[i]!, array2[j]!) < 0 : array1[i]! < array2[j]!
+    ) {
+      result.push(array1[i]!);
+      i++;
+    } else {
+      result.push(array2[j]!);
+      j++;
+    }
+  }
+
+  if (i < array1.length) {
+    result.push(...array1.slice(i));
+  }
+
+  if (j < array2.length) {
+    result.push(...array2.slice(j));
+  }
+
+  return result;
+};
+
+/**
+ * Merges many sorted arrays into a single sorted array.
+ *
+ * @param arrays - The arrays to merge.
+ * @param compare - The comparison function to use.
+ *
+ * @returns The merged array.
+ *
+ * @example
+ * ```ts
+ * const result = zipperMany([
+ *   [1, 3, 5],
+ *   [2, 4, 6],
+ *   [7, 8, 9],
+ * ]);
+ * // result = [1, 2, 3, 4, 5, 6, 7, 8, 9]
+ * ```
+ */
+export const zipperMany = <T>(
+  arrays: T[][],
+  compare?: (a: T, b: T) => number,
+): T[] => {
+  if (arrays.length === 0) return [];
+  if (arrays.length === 1) return arrays[0]!;
+
+  let result: T[] = arrays[0]!;
+
+  for (let i = 1; i < arrays.length; i++) {
+    result = zipper(result, arrays[i]!, compare);
+  }
+
+  return result;
+};