copy: new utility function to copy any Cell as ValueCell

src/copy.test.ts

@@ -0,0 +1,42 @@
+import { expect, test } from "vitest";
+
+import { copy } from "./copy";
+import { delayed } from "./promise";
+import { SheetProxy } from "./proxy";
+import { Sheet } from "./sheet";
+
+test("copy cell", async () => {
+  const sheet = new Sheet();
+  const proxy = new SheetProxy(sheet);
+
+  const a = proxy.new("foo");
+  const b = a.map((s) => s.length);
+  const c = copy(proxy, b);
+
+  await expect(c.get()).resolves.toBe(3);
+});
+
+test("copy cell async", async () => {
+  const sheet = new Sheet();
+  const proxy = new SheetProxy(sheet);
+
+  const a = proxy.new("foo");
+  const b = a.map((s) => delayed(s.length, 10));
+  const c = copy(proxy, b);
+
+  await expect(c.get()).resolves.toBe(3);
+});
+
+test("copy cell error", async () => {
+  const sheet = new Sheet();
+  const proxy = new SheetProxy(sheet);
+
+  const err = new Error("error");
+
+  const a = proxy.new("foo");
+  const b = a.map((_s) => {
+    throw err;
+  });
+  const c = copy(proxy, b);
+  await expect(c.get()).resolves.toBe(err);
+});

src/copy.ts

@@ -0,0 +1,16 @@
+import type { AnyCell, ValueCell } from "./cell";
+import type { SheetProxy } from "./proxy";
+
+// Copy any Cell as a ValueCell.
+export const copy = <T>(
+  proxy: SheetProxy,
+  cell: AnyCell<T>,
+  name = `copy:${cell.id}`
+): ValueCell<T> => {
+  return proxy.new(
+    new Promise((resolve, reject) => {
+      cell.get().then((v) => (v instanceof Error ? reject(v) : resolve(v)));
+    }),
+    name
+  );
+};

src/index.ts

@@ -52,6 +52,7 @@ export {
   type Uncellified
 } from "./cellify";
 export { clock, clockWork, type Clock } from "./clock";
+export { copy } from "./copy";
 export { Debugger } from "./debug";
 export { jsonStringify } from "./json";
 export { nextSubscriber } from "./next";

src/isEqual.test.ts

@@ -6,6 +6,7 @@ import { expect, test } from "vitest";
  * @param b
  * @returns
  */
+// biome-ignore lint/suspicious/noExportsInTest: used in tests only
 export function isEqual<T>(a: T, b: T): boolean {
   // Same instance or primitive values are equal
   if (a === b) return true;