@voltro/testing 0.83.1 → 0.85.0

package/dist/client.d.ts

@@ -1,12 +1,11 @@
 import { Effect } from 'effect';
 import { Exit } from 'effect/Exit';
+import { Fiber } from 'effect/Fiber';
 import { FieldErrors } from '@voltro/client';
 import { FormBinding } from '@voltro/client';
 import { FormStateSnapshot } from '@voltro/client';
 import { ReactElement } from 'react';
 import { ReactNode } from 'react';
-import { RunForkOptions } from 'effect/Runtime';
-import { RuntimeFiber } from 'effect/Fiber';
 import { UseFormBindingOptions } from '@voltro/client';
 
 /** The snapshot shape `useConnectionStatus` subscribes to. */
@@ -38,13 +37,9 @@ declare interface ConnectionFacts {
  * starts calling goes red here instead of in whichever hook reaches it first.
  */
 export declare const FAKE_RUNTIME: {
-    runPromise: <A, E>(effect: Effect.Effect<A, E, never>, options?: {
-        readonly signal?: AbortSignal | undefined;
-    } | undefined) => Promise<A>;
-    runPromiseExit: <A, E>(effect: Effect.Effect<A, E, never>, options?: {
-        readonly signal?: AbortSignal;
-    } | undefined) => Promise< Exit<A, E>>;
-    runFork: <A, E>(effect: Effect.Effect<A, E>, options?: RunForkOptions) => RuntimeFiber<A, E>;
+    runPromise: <A, E>(effect: Effect.Effect<A, E>, options?: Effect.RunOptions | undefined) => Promise<A>;
+    runPromiseExit: <A, E>(effect: Effect.Effect<A, E>, options?: Effect.RunOptions | undefined) => Promise< Exit<A, E>>;
+    runFork: <A, E>(effect: Effect.Effect<A, E, never>, options?: Effect.RunOptions | undefined) => Fiber<A, E>;
     dispose: () => Effect.Effect<void, never, never>;
 };
 

package/dist/client.js

@@ -84,6 +84,9 @@ var o = async (e, r = {}) => {
 			} };
 		},
 		autoApply: () => {},
+		hasIntent: () => !1,
+		rowsOf: () => [],
+		subscribeAny: () => () => {},
 		revertByMutation: () => {},
 		confirmByMutation: () => {},
 		update: () => {},
@@ -104,7 +107,8 @@ var o = async (e, r = {}) => {
 			_.delete(e);
 		}),
 		getSnapshot: () => g,
-		reportExternalSuccess: () => {}
+		reportExternalSuccess: () => {},
+		subjectSignal: new AbortController().signal
 	}, y = {}, b = (t, n, r) => {
 		let i = t.split("."), a = y;
 		for (let e of i.slice(0, -1)) a[e] = a[e] ?? {}, a = a[e];

package/dist/crdt.d.ts

@@ -0,0 +1,11 @@
+import { CrdtBackend } from '@voltro/local-first';
+
+/** Register the conformance suite with vitest. */
+export declare const crdtBackendConformance: (name: string, options: CrdtBackendConformanceOptions) => void;
+
+export declare interface CrdtBackendConformanceOptions {
+    /** The backend under test. */
+    readonly backend: CrdtBackend;
+}
+
+export { }

package/dist/crdt.js

@@ -0,0 +1,77 @@
+import { describe as e, expect as t, it as n } from "vitest";
+//#region src/crdtBackendConformance.ts
+var r = (r, i) => {
+	let a = i.backend, o = (e) => a.createText(e).encodeState(), s = (e, t, n) => {
+		let r = a.createText();
+		return r.applyState(e), r.insert(t, n), r.encodeState();
+	};
+	e(`crdt backend conformance — ${r}`, () => {
+		n("merge: commutative, idempotent, empty state is the identity", () => {
+			let e = o("base"), n = s(e, 0, "X"), r = s(e, 4, "Y");
+			t(a.decodeText(a.merge(n, r))).toBe(a.decodeText(a.merge(r, n))), t(a.decodeText(a.merge(a.merge(n, r), n))).toBe(a.decodeText(a.merge(n, r))), t(a.decodeText(a.merge(a.emptyState(), n))).toBe(a.decodeText(n)), t(a.decodeText(a.emptyState())).toBe("");
+		}), n("text handles converge under concurrent edits; undo reverts only their own edits", () => {
+			let e = o("ab"), n = a.createText(void 0, { undoCaptureMs: 0 });
+			n.applyState(e), t(n.canUndo()).toBe(!1), n.insert(1, "1");
+			let r = s(e, 2, "2");
+			n.applyState(r), t(n.toString()).toBe(a.decodeText(a.merge(s(e, 1, "1"), r))), t(n.undo()).toBe(!0), t(n.toString()).toBe(a.decodeText(r)), t(n.redo()).toBe(!0), t(n.toString()).toContain("1");
+		}), n("doc handles: folds are reported as remote, own edits as local; incremental updates apply", () => {
+			let e = a.createDoc(), n = [];
+			e.onUpdate((e, t) => {
+				n.push(t.local);
+			}), e.applyState(o("remote")), a.counterAdd(e, 1), t(n).toEqual([!1, !0]);
+			let r = a.createDoc(e.encodeState()), i = r.stateVector();
+			a.counterAdd(e, 2), r.applyState(e.encodeUpdateSince(i)), t(a.counterValue(r.encodeState())).toBe(3), t(e.epoch()).toBeUndefined();
+		}), n("local updates coalesce without a base: merging two queued edits loses neither", () => {
+			let e = a.createDoc();
+			a.counterAdd(e, 5);
+			let n = e.encodeState(), r = a.createDoc(n), i = [];
+			r.onUpdate((e, t) => {
+				t.local && i.push(e);
+			}), a.counterAdd(r, 1), a.counterAdd(r, 2);
+			let o = a.merge(i[0], i[1]);
+			t(a.counterValue(a.merge(n, o))).toBe(8);
+		}), n("compact keeps the content and still merges with the old lineage", () => {
+			let e = s(s(o("seed"), 4, "!"), 0, ">"), n = a.compact(e);
+			t(a.decodeText(n)).toBe(a.decodeText(e)), t(a.decodeText(a.merge(n, e))).toBe(a.decodeText(e));
+		}), n("restoreTo is an edit on the current lineage that merges with concurrent edits", () => {
+			let e = o("version one"), n = s(e, 11, " and more"), r = a.restoreTo(n, e);
+			t(a.decodeText(a.merge(n, r))).toBe("version one");
+			let i = s(n, 0, "# ");
+			t(a.decodeText(a.merge(a.merge(n, i), r))).toContain("version one");
+		}), n("rebase keeps the content, stamps the epoch and shares no author with the old lineage", () => {
+			let e = s(o("kept"), 4, "."), n = a.rebase(e, "epoch-x");
+			t(a.decodeText(n)).toBe("kept."), t(a.epochOf(n)).toBe("epoch-x"), t(a.epochOf(e)).toBeUndefined();
+			let r = a.authorsOf(e);
+			t([...a.authorsOf(n)].some((e) => r.has(e))).toBe(!1);
+		}), n("translate carries a text edit made on an archived lineage over to the current one", () => {
+			let e = o("shared text"), n = s(e, 11, " + offline"), r = a.rebase(s(e, 0, "> "), "e1"), i = a.translate(e, n, r);
+			t(i).toBeDefined(), t(a.decodeText(a.merge(r, i))).toBe("> shared text + offline");
+		}), n("the content schema version is recorded, travels with the state and survives a rebase", () => {
+			let e = a.createDoc(o("content"));
+			t(e.schemaVersion()).toBe(0), e.setSchemaVersion(3);
+			let n = e.encodeState();
+			t(a.createDoc(n).schemaVersion()).toBe(3);
+			let r = a.createDoc(a.rebase(n, "e2"));
+			t(r.schemaVersion()).toBe(3), t(a.decodeText(r.encodeState())).toBe("content");
+		}), n("an increment over a delivered state merges into it; over a state that lacks its base it is refused or reported", () => {
+			let e = o("base"), n = a.createDoc(s(e, 4, "!")).encodeUpdateSince(a.createDoc(e).stateVector());
+			t(a.decodeText(a.merge(e, n))).toBe("base!");
+			let r = !1;
+			try {
+				let e = a.merge(a.emptyState(), n);
+				r = a.missingDependencies?.(e) === !0;
+			} catch {
+				r = !0;
+			}
+			t(r).toBe(!0);
+		}), n("carryReplaced, when implemented, carries nothing for content no migration replaced", () => {
+			let e = o("kept as is");
+			t(a.carryReplaced?.(e, s(e, 4, "!"))).toBeUndefined(), t(a.carryReplaced?.(a.emptyState(), e)).toBeUndefined();
+		}), n("counter steps from different writers commute", () => {
+			let e = a.createDoc(), n = a.createDoc();
+			a.counterAdd(e, 5), a.counterAdd(n, -2), a.counterAdd(e, 1), t(a.counterValue(a.merge(e.encodeState(), n.encodeState()))).toBe(4), t(a.counterValue(a.merge(n.encodeState(), e.encodeState()))).toBe(4), t(a.counterValue(a.emptyState())).toBe(0);
+		});
+	});
+};
+//#endregion
+export { r as crdtBackendConformance };

package/dist/dialect.d.ts

@@ -1,7 +1,7 @@
 import { applySchema } from '@voltro/database/sql';
 import { DataStore } from '@voltro/database';
 import { Effect } from 'effect';
-import { SqlClient } from '@effect/sql';
+import { SqlClient } from 'effect/sql';
 import { SqlDialect } from '@voltro/database';
 
 export { applySchema }