@voidhash/mimic 1.0.0-beta.15 → 1.0.0-beta.17

package/tests/primitives/Lazy.test.ts

@@ -1,143 +0,0 @@
-import { describe, expect, it } from "@effect/vitest";
-import * as Primitive from "../../src/Primitive";
-import * as ProxyEnvironment from "../../src/ProxyEnvironment";
-import * as OperationPath from "../../src/OperationPath";
-import * as Operation from "../../src/Operation";
-
-describe("LazyPrimitive", () => {
-  describe("proxy", () => {
-    it("delegates proxy creation to resolved primitive", () => {
-      const operations: Operation.Operation<any, any, any>[] = [];
-      const env = ProxyEnvironment.make((op) => operations.push(op));
-
-      const lazyPrimitive = Primitive.Lazy(() => Primitive.String());
-      const proxy = lazyPrimitive._internal.createProxy(env, OperationPath.make(""));
-
-      proxy.set("lazy value");
-
-      expect(operations).toHaveLength(1);
-      expect(operations[0]!.kind).toBe("string.set");
-      expect(operations[0]!.payload).toBe("lazy value");
-    });
-
-    it("works with lazy struct", () => {
-      const operations: Operation.Operation<any, any, any>[] = [];
-      const env = ProxyEnvironment.make((op) => operations.push(op));
-
-      const lazyPrimitive = Primitive.Lazy(() =>
-        Primitive.Struct({
-          name: Primitive.String(),
-        })
-      );
-      const proxy = lazyPrimitive._internal.createProxy(env, OperationPath.make(""));
-
-      proxy.name.set("lazy struct field");
-
-      expect(operations).toHaveLength(1);
-      expect(operations[0]!.kind).toBe("string.set");
-      expect(operations[0]!.path.toTokens()).toEqual(["name"]);
-    });
-  });
-
-  describe("applyOperation", () => {
-    it("delegates operation application to resolved primitive", () => {
-      const lazyPrimitive = Primitive.Lazy(() => Primitive.String());
-      const operation: Operation.Operation<any, any, any> = {
-        kind: "string.set",
-        path: OperationPath.make(""),
-        payload: "lazy applied",
-      };
-
-      const result = lazyPrimitive._internal.applyOperation(undefined, operation);
-      expect(result).toBe("lazy applied");
-    });
-
-    it("works with lazy struct operations", () => {
-      const lazyPrimitive = Primitive.Lazy(() =>
-        Primitive.Struct({
-          name: Primitive.String(),
-        })
-      );
-      const operation: Operation.Operation<any, any, any> = {
-        kind: "string.set",
-        path: OperationPath.make("name"),
-        payload: "Updated",
-      };
-
-      const result = lazyPrimitive._internal.applyOperation({ name: "Original" }, operation);
-      expect(result).toEqual({ name: "Updated" });
-    });
-  });
-
-  describe("getInitialState", () => {
-    it("delegates to resolved primitive", () => {
-      const lazyPrimitive = Primitive.Lazy(() => Primitive.String().default("lazy default"));
-      expect(lazyPrimitive._internal.getInitialState()).toBe("lazy default");
-    });
-
-    it("returns undefined when resolved primitive has no default", () => {
-      const lazyPrimitive = Primitive.Lazy(() => Primitive.String());
-      expect(lazyPrimitive._internal.getInitialState()).toBeUndefined();
-    });
-  });
-
-  describe("recursive structures", () => {
-    it("supports self-referential structures", () => {
-      const operations: Operation.Operation<any, any, any>[] = [];
-      const env = ProxyEnvironment.make((op) => operations.push(op));
-
-      // Define a recursive node structure
-      const Node: Primitive.LazyPrimitive<any> = Primitive.Lazy(() =>
-        Primitive.Struct({
-          name: Primitive.String(),
-          children: Primitive.Array(Node),
-        })
-      );
-
-      const proxy = Node._internal.createProxy(env, OperationPath.make("")) as any;
-
-      // Access nested child
-      proxy.children.at(0).name.set("Child Name");
-
-      expect(operations).toHaveLength(1);
-      expect(operations[0]!.kind).toBe("string.set");
-      expect(operations[0]!.path.toTokens()).toEqual(["children", "0", "name"]);
-    });
-
-    it("applies operations to recursive structures", () => {
-      const Node: Primitive.LazyPrimitive<any> = Primitive.Lazy(() =>
-        Primitive.Struct({
-          name: Primitive.String(),
-          children: Primitive.Array(Node),
-        })
-      );
-
-      // Use entry ID in path (arrays now use ID-based addressing)
-      const operation: Operation.Operation<any, any, any> = {
-        kind: "string.set",
-        path: OperationPath.make("children/child-entry-1/name"),
-        payload: "Updated Child",
-      };
-
-      // State with array entries format { id, pos, value }
-      const state = {
-        name: "Root",
-        children: [
-          { id: "child-entry-1", pos: "a0", value: { name: "Child", children: [] } }
-        ],
-      };
-
-      const result = Node._internal.applyOperation(state, operation);
-      expect(result).toEqual({
-        name: "Root",
-        children: [
-          { id: "child-entry-1", pos: "a0", value: { name: "Updated Child", children: [] } }
-        ],
-      });
-    });
-  });
-});
-
-// =============================================================================
-// Union Primitive Tests
-// =============================================================================

package/tests/primitives/Literal.test.ts

@@ -1,122 +0,0 @@
-import { describe, expect, it } from "@effect/vitest";
-import * as Primitive from "../../src/Primitive";
-import * as ProxyEnvironment from "../../src/ProxyEnvironment";
-import * as OperationPath from "../../src/OperationPath";
-import * as Operation from "../../src/Operation";
-
-describe("LiteralPrimitive", () => {
-  describe("proxy", () => {
-    it("set() generates correct operation with string literal", () => {
-      const operations: Operation.Operation<any, any, any>[] = [];
-      const env = ProxyEnvironment.make((op) => operations.push(op));
-
-      const literalPrimitive = Primitive.Literal("active" as const);
-      const proxy = literalPrimitive._internal.createProxy(env, OperationPath.make(""));
-
-      proxy.set("active");
-
-      expect(operations).toHaveLength(1);
-      expect(operations[0]!.kind).toBe("literal.set");
-      expect(operations[0]!.payload).toBe("active");
-    });
-
-    it("set() generates correct operation with number literal", () => {
-      const operations: Operation.Operation<any, any, any>[] = [];
-      const env = ProxyEnvironment.make((op) => operations.push(op));
-
-      const literalPrimitive = Primitive.Literal(42 as const);
-      const proxy = literalPrimitive._internal.createProxy(env, OperationPath.make(""));
-
-      proxy.set(42);
-
-      expect(operations[0]!.payload).toBe(42);
-    });
-
-    it("set() generates correct operation with boolean literal", () => {
-      const operations: Operation.Operation<any, any, any>[] = [];
-      const env = ProxyEnvironment.make((op) => operations.push(op));
-
-      const literalPrimitive = Primitive.Literal(true as const);
-      const proxy = literalPrimitive._internal.createProxy(env, OperationPath.make(""));
-
-      proxy.set(true);
-
-      expect(operations[0]!.payload).toBe(true);
-    });
-
-    it("set() generates correct operation with null literal", () => {
-      const operations: Operation.Operation<any, any, any>[] = [];
-      const env = ProxyEnvironment.make((op) => operations.push(op));
-
-      const literalPrimitive = Primitive.Literal(null);
-      const proxy = literalPrimitive._internal.createProxy(env, OperationPath.make(""));
-
-      proxy.set(null);
-
-      expect(operations[0]!.payload).toBe(null);
-    });
-  });
-
-  describe("applyOperation", () => {
-    it("returns the literal value from literal.set operation", () => {
-      const literalPrimitive = Primitive.Literal("foo" as const);
-      const operation: Operation.Operation<any, any, any> = {
-        kind: "literal.set",
-        path: OperationPath.make(""),
-        payload: "foo",
-      };
-
-      const result = literalPrimitive._internal.applyOperation(undefined, operation);
-      expect(result).toBe("foo");
-    });
-
-    it("throws ValidationError for wrong literal value", () => {
-      const literalPrimitive = Primitive.Literal("foo" as const);
-      const operation: Operation.Operation<any, any, any> = {
-        kind: "literal.set",
-        path: OperationPath.make(""),
-        payload: "bar",
-      };
-
-      expect(() => literalPrimitive._internal.applyOperation(undefined, operation)).toThrow(
-        Primitive.ValidationError
-      );
-    });
-
-    it("throws ValidationError for wrong operation kind", () => {
-      const literalPrimitive = Primitive.Literal("foo" as const);
-      const operation: Operation.Operation<any, any, any> = {
-        kind: "string.set",
-        path: OperationPath.make(""),
-        payload: "foo",
-      };
-
-      expect(() => literalPrimitive._internal.applyOperation(undefined, operation)).toThrow(
-        Primitive.ValidationError
-      );
-    });
-  });
-
-  describe("getInitialState", () => {
-    it("returns undefined when no default is set", () => {
-      const literalPrimitive = Primitive.Literal("test" as const);
-      expect(literalPrimitive._internal.getInitialState()).toBeUndefined();
-    });
-
-    it("returns the default value when set", () => {
-      const literalPrimitive = Primitive.Literal("active" as const).default("active");
-      expect(literalPrimitive._internal.getInitialState()).toBe("active");
-    });
-  });
-
-  describe("literal accessor", () => {
-    it("returns the literal value", () => {
-      const literalPrimitive = Primitive.Literal("myLiteral" as const);
-      expect(literalPrimitive.literal).toBe("myLiteral");
-    });
-  });
-});
-
-// =============================================================================
-// Struct Primitive Tests
-// =============================================================================

package/tests/primitives/Number.test.ts

@@ -1,133 +0,0 @@
-import { describe, expect, it } from "@effect/vitest";
-import * as Primitive from "../../src/Primitive";
-import * as ProxyEnvironment from "../../src/ProxyEnvironment";
-import * as OperationPath from "../../src/OperationPath";
-import * as Operation from "../../src/Operation";
-
-describe("NumberPrimitive", () => {
-  describe("proxy", () => {
-    it("set() generates correct operation with path and payload", () => {
-      const operations: Operation.Operation<any, any, any>[] = [];
-      const env = ProxyEnvironment.make((op) => operations.push(op));
-
-      const numberPrimitive = Primitive.Number().required();
-      const proxy = numberPrimitive._internal.createProxy(env, OperationPath.make(""));
-
-      proxy.set(42);
-
-      expect(operations).toHaveLength(1);
-      expect(operations[0]!.kind).toBe("number.set");
-      expect(operations[0]!.payload).toBe(42);
-    });
-
-    it("set() works with decimal numbers", () => {
-      const operations: Operation.Operation<any, any, any>[] = [];
-      const env = ProxyEnvironment.make((op) => operations.push(op));
-
-      const numberPrimitive = Primitive.Number();
-      const proxy = numberPrimitive._internal.createProxy(env, OperationPath.make(""));
-
-      proxy.set(3.14159);
-
-      expect(operations[0]!.payload).toBe(3.14159);
-    });
-
-    it("set() works with negative numbers", () => {
-      const operations: Operation.Operation<any, any, any>[] = [];
-      const env = ProxyEnvironment.make((op) => operations.push(op));
-
-      const numberPrimitive = Primitive.Number();
-      const proxy = numberPrimitive._internal.createProxy(env, OperationPath.make(""));
-
-      proxy.set(-100);
-
-      expect(operations[0]!.payload).toBe(-100);
-    });
-  });
-
-  describe("applyOperation", () => {
-    it("returns the new number value from number.set operation", () => {
-      const numberPrimitive = Primitive.Number();
-      const operation: Operation.Operation<any, any, any> = {
-        kind: "number.set",
-        path: OperationPath.make(""),
-        payload: 123,
-      };
-
-      const result = numberPrimitive._internal.applyOperation(undefined, operation);
-      expect(result).toBe(123);
-    });
-
-    it("replaces existing state with new value", () => {
-      const numberPrimitive = Primitive.Number();
-      const operation: Operation.Operation<any, any, any> = {
-        kind: "number.set",
-        path: OperationPath.make(""),
-        payload: 999,
-      };
-
-      const result = numberPrimitive._internal.applyOperation(100, operation);
-      expect(result).toBe(999);
-    });
-
-    it("throws ValidationError for non-number payload", () => {
-      const numberPrimitive = Primitive.Number();
-      const operation: Operation.Operation<any, any, any> = {
-        kind: "number.set",
-        path: OperationPath.make(""),
-        payload: "42",
-      };
-
-      expect(() => numberPrimitive._internal.applyOperation(undefined, operation)).toThrow(
-        Primitive.ValidationError
-      );
-    });
-
-    it("throws ValidationError for wrong operation kind", () => {
-      const numberPrimitive = Primitive.Number();
-      const operation: Operation.Operation<any, any, any> = {
-        kind: "string.set",
-        path: OperationPath.make(""),
-        payload: 42,
-      };
-
-      expect(() => numberPrimitive._internal.applyOperation(undefined, operation)).toThrow(
-        Primitive.ValidationError
-      );
-    });
-  });
-
-  describe("getInitialState", () => {
-    it("returns undefined when no default is set", () => {
-      const numberPrimitive = Primitive.Number();
-      expect(numberPrimitive._internal.getInitialState()).toBeUndefined();
-    });
-
-    it("returns the default value when set", () => {
-      const numberPrimitive = Primitive.Number().default(0);
-      expect(numberPrimitive._internal.getInitialState()).toBe(0);
-    });
-  });
-
-  describe("schema modifiers", () => {
-    it("required() returns a new NumberPrimitive", () => {
-      const original = Primitive.Number();
-      const required = original.required();
-
-      expect(required).toBeInstanceOf(Primitive.NumberPrimitive);
-      expect(required).not.toBe(original);
-    });
-
-    it("default() returns a new NumberPrimitive with default value", () => {
-      const original = Primitive.Number();
-      const withDefault = original.default(100);
-
-      expect(withDefault).toBeInstanceOf(Primitive.NumberPrimitive);
-      expect(withDefault._internal.getInitialState()).toBe(100);
-    });
-  });
-});
-
-// =============================================================================
-// Literal Primitive Tests
-// =============================================================================

package/tests/primitives/String.test.ts

@@ -1,128 +0,0 @@
-import { describe, expect, it } from "@effect/vitest";
-import * as Primitive from "../../src/Primitive";
-import * as ProxyEnvironment from "../../src/ProxyEnvironment";
-import * as OperationPath from "../../src/OperationPath";
-import * as Operation from "../../src/Operation";
-
-describe("StringPrimitive", () => {
-  describe("proxy", () => {
-    it("set() generates correct operation with path and payload", () => {
-      const operations: Operation.Operation<any, any, any>[] = [];
-      const env = ProxyEnvironment.make((op) => {
-        operations.push(op);
-      });
-
-      const stringPrimitive = Primitive.String().required();
-      const proxy = stringPrimitive._internal.createProxy(env, OperationPath.make(""));
-
-      proxy.set("Hello World");
-
-      expect(operations).toHaveLength(1);
-      expect(operations[0]!.kind).toBe("string.set");
-      expect(operations[0]!.payload).toBe("Hello World");
-    });
-
-    it("set() includes the correct path in operation", () => {
-      const operations: Operation.Operation<any, any, any>[] = [];
-      const env = ProxyEnvironment.make((op) => {
-        operations.push(op);
-      });
-
-      const stringPrimitive = Primitive.String();
-      const proxy = stringPrimitive._internal.createProxy(env, OperationPath.make("users/0/name"));
-
-      proxy.set("John");
-
-      expect(operations).toHaveLength(1);
-      expect(operations[0]!.path.toTokens()).toEqual(["users", "0", "name"]);
-    });
-  });
-
-  describe("applyOperation", () => {
-    it("returns the new string value from string.set operation", () => {
-      const stringPrimitive = Primitive.String();
-      const operation: Operation.Operation<any, any, any> = {
-        kind: "string.set",
-        path: OperationPath.make(""),
-        payload: "New Value",
-      };
-
-      const result = stringPrimitive._internal.applyOperation(undefined, operation);
-
-      expect(result).toBe("New Value");
-    });
-
-    it("replaces existing state with new value", () => {
-      const stringPrimitive = Primitive.String();
-      const operation: Operation.Operation<any, any, any> = {
-        kind: "string.set",
-        path: OperationPath.make(""),
-        payload: "Updated",
-      };
-
-      const result = stringPrimitive._internal.applyOperation("Original", operation);
-
-      expect(result).toBe("Updated");
-    });
-
-    it("throws ValidationError for non-string payload", () => {
-      const stringPrimitive = Primitive.String();
-      const operation: Operation.Operation<any, any, any> = {
-        kind: "string.set",
-        path: OperationPath.make(""),
-        payload: 123,
-      };
-
-      expect(() => stringPrimitive._internal.applyOperation(undefined, operation)).toThrow(
-        Primitive.ValidationError
-      );
-    });
-
-    it("throws ValidationError for wrong operation kind", () => {
-      const stringPrimitive = Primitive.String();
-      const operation: Operation.Operation<any, any, any> = {
-        kind: "wrong.kind",
-        path: OperationPath.make(""),
-        payload: "value",
-      };
-
-      expect(() => stringPrimitive._internal.applyOperation(undefined, operation)).toThrow(
-        Primitive.ValidationError
-      );
-    });
-  });
-
-  describe("getInitialState", () => {
-    it("returns undefined when no default is set", () => {
-      const stringPrimitive = Primitive.String();
-      expect(stringPrimitive._internal.getInitialState()).toBeUndefined();
-    });
-
-    it("returns the default value when set", () => {
-      const stringPrimitive = Primitive.String().default("Default Text");
-      expect(stringPrimitive._internal.getInitialState()).toBe("Default Text");
-    });
-  });
-
-  describe("schema modifiers", () => {
-    it("required() returns a new StringPrimitive", () => {
-      const original = Primitive.String();
-      const required = original.required();
-
-      expect(required).toBeInstanceOf(Primitive.StringPrimitive);
-      expect(required).not.toBe(original);
-    });
-
-    it("default() returns a new StringPrimitive with default value", () => {
-      const original = Primitive.String();
-      const withDefault = original.default("test");
-
-      expect(withDefault).toBeInstanceOf(Primitive.StringPrimitive);
-      expect(withDefault._internal.getInitialState()).toBe("test");
-    });
-  });
-});
-
-// =============================================================================
-// Boolean Primitive Tests
-// =============================================================================