@voidhash/mimic 0.0.1-alpha.7 → 0.0.1-alpha.8

package/src/primitives/Union.ts

@@ -4,11 +4,11 @@ import * as Operation from "../Operation";
 import * as OperationPath from "../OperationPath";
 import * as ProxyEnvironment from "../ProxyEnvironment";
 import * as Transform from "../Transform";
-import type { Primitive, PrimitiveInternal, MaybeUndefined, AnyPrimitive, InferState, InferProxy, InferSnapshot } from "../Primitive";
+import type { Primitive, PrimitiveInternal, MaybeUndefined, AnyPrimitive, InferState, InferProxy, InferSnapshot, InferSetInput } from "../Primitive";
 import { ValidationError } from "../Primitive";
 import { LiteralPrimitive } from "./Literal";
 import { StructPrimitive, InferStructState } from "./Struct";
-import { runValidators, applyDefaults, StructSetInput } from "./shared";
+import { runValidators, applyDefaults } from "./shared";
 
 
 /**
@@ -32,20 +32,18 @@ export type InferUnionSnapshot<TVariants extends UnionVariants> = {
 
 /**
  * Compute the input type for union.set() operations.
- * For each variant, uses StructSetInput to make fields with defaults optional.
+ * Uses each variant's TSetInput type.
  */
 export type UnionSetInput<TVariants extends UnionVariants> = {
-  [K in keyof TVariants]: TVariants[K] extends StructPrimitive<infer TFields, any, any>
-    ? StructSetInput<TFields>
-    : InferState<TVariants[K]>;
+  [K in keyof TVariants]: InferSetInput<TVariants[K]>;
 }[keyof TVariants];
 
 /**
  * Proxy for accessing union variants
  */
-export interface UnionProxy<TVariants extends UnionVariants, _TDiscriminator extends string, TDefined extends boolean = false> {
+export interface UnionProxy<TVariants extends UnionVariants, _TDiscriminator extends string, TRequired extends boolean = false, THasDefault extends boolean = false> {
   /** Gets the current union value */
-  get(): MaybeUndefined<InferUnionState<TVariants>, TDefined>;
+  get(): MaybeUndefined<InferUnionState<TVariants>, TRequired, THasDefault>;
   
   /** Sets the entire union value (applies defaults for variant fields) */
   set(value: UnionSetInput<TVariants>): void;
@@ -59,7 +57,7 @@ export interface UnionProxy<TVariants extends UnionVariants, _TDiscriminator ext
   }): R | undefined;
   
   /** Returns a readonly snapshot of the union for rendering */
-  toSnapshot(): MaybeUndefined<InferUnionSnapshot<TVariants>, TDefined>;
+  toSnapshot(): MaybeUndefined<InferUnionSnapshot<TVariants>, TRequired, THasDefault>;
 }
 
 interface UnionPrimitiveSchema<TVariants extends UnionVariants, TDiscriminator extends string> {
@@ -69,14 +67,16 @@ interface UnionPrimitiveSchema<TVariants extends UnionVariants, TDiscriminator e
   readonly variants: TVariants;
 }
 
-export class UnionPrimitive<TVariants extends UnionVariants, TDiscriminator extends string = "type", TDefined extends boolean = false, THasDefault extends boolean = false>
-  implements Primitive<InferUnionState<TVariants>, UnionProxy<TVariants, TDiscriminator, TDefined>, TDefined, THasDefault>
+export class UnionPrimitive<TVariants extends UnionVariants, TDiscriminator extends string = "type", TRequired extends boolean = false, THasDefault extends boolean = false>
+  implements Primitive<InferUnionState<TVariants>, UnionProxy<TVariants, TDiscriminator, TRequired, THasDefault>, TRequired, THasDefault, UnionSetInput<TVariants>, UnionSetInput<TVariants>>
 {
   readonly _tag = "UnionPrimitive" as const;
   readonly _State!: InferUnionState<TVariants>;
-  readonly _Proxy!: UnionProxy<TVariants, TDiscriminator, TDefined>;
-  readonly _TDefined!: TDefined;
+  readonly _Proxy!: UnionProxy<TVariants, TDiscriminator, TRequired, THasDefault>;
+  readonly _TRequired!: TRequired;
   readonly _THasDefault!: THasDefault;
+  readonly TSetInput!: UnionSetInput<TVariants>;
+  readonly TUpdateInput!: UnionSetInput<TVariants>;
 
   private readonly _schema: UnionPrimitiveSchema<TVariants, TDiscriminator>;
 
@@ -153,18 +153,18 @@ export class UnionPrimitive<TVariants extends UnionVariants, TDiscriminator exte
     return applyDefaults(variantPrimitive as AnyPrimitive, value) as InferUnionState<TVariants>;
   }
 
-  readonly _internal: PrimitiveInternal<InferUnionState<TVariants>, UnionProxy<TVariants, TDiscriminator, TDefined>> = {
+  readonly _internal: PrimitiveInternal<InferUnionState<TVariants>, UnionProxy<TVariants, TDiscriminator, TRequired, THasDefault>> = {
     createProxy: (
       env: ProxyEnvironment.ProxyEnvironment,
       operationPath: OperationPath.OperationPath
-    ): UnionProxy<TVariants, TDiscriminator, TDefined> => {
+    ): UnionProxy<TVariants, TDiscriminator, TRequired, THasDefault> => {
       const variants = this._schema.variants;
       const defaultValue = this._schema.defaultValue;
 
       return {
-        get: (): MaybeUndefined<InferUnionState<TVariants>, TDefined> => {
+        get: (): MaybeUndefined<InferUnionState<TVariants>, TRequired, THasDefault> => {
           const state = env.getState(operationPath) as InferUnionState<TVariants> | undefined;
-          return (state ?? defaultValue) as MaybeUndefined<InferUnionState<TVariants>, TDefined>;
+          return (state ?? defaultValue) as MaybeUndefined<InferUnionState<TVariants>, TRequired, THasDefault>;
         },
         set: (value: UnionSetInput<TVariants>) => {
           // Apply defaults for the variant
@@ -193,21 +193,21 @@ export class UnionPrimitive<TVariants extends UnionVariants, TDiscriminator exte
           const variantProxy = variants[variantKey]!._internal.createProxy(env, operationPath) as InferProxy<TVariants[typeof variantKey]>;
           return handler(variantProxy);
         },
-        toSnapshot: (): MaybeUndefined<InferUnionSnapshot<TVariants>, TDefined> => {
+        toSnapshot: (): MaybeUndefined<InferUnionSnapshot<TVariants>, TRequired, THasDefault> => {
           const state = env.getState(operationPath) as InferUnionState<TVariants> | undefined;
           const effectiveState = state ?? defaultValue;
           if (!effectiveState) {
-            return undefined as MaybeUndefined<InferUnionSnapshot<TVariants>, TDefined>;
+            return undefined as MaybeUndefined<InferUnionSnapshot<TVariants>, TRequired, THasDefault>;
           }
           
           const variantKey = this._findVariantKey(effectiveState);
           if (!variantKey) {
-            return undefined as MaybeUndefined<InferUnionSnapshot<TVariants>, TDefined>;
+            return undefined as MaybeUndefined<InferUnionSnapshot<TVariants>, TRequired, THasDefault>;
           }
           
           const variantPrimitive = variants[variantKey]!;
           const variantProxy = variantPrimitive._internal.createProxy(env, operationPath);
-          return (variantProxy as unknown as { toSnapshot(): InferUnionSnapshot<TVariants> }).toSnapshot() as MaybeUndefined<InferUnionSnapshot<TVariants>, TDefined>;
+          return (variantProxy as unknown as { toSnapshot(): InferUnionSnapshot<TVariants> }).toSnapshot() as MaybeUndefined<InferUnionSnapshot<TVariants>, TRequired, THasDefault>;
         },
       };
     },

package/src/primitives/shared.ts

@@ -17,13 +17,15 @@ import * as Transform from "../Transform";
  * @typeParam TDefined - Whether the value is guaranteed to be defined (via required() or default())
  * @typeParam THasDefault - Whether this primitive has a default value
  */
-export interface Primitive<TState, TProxy, TDefined extends boolean = false, THasDefault extends boolean = false> {
+export interface Primitive<TState, TProxy, TRequired extends boolean = false, THasDefault extends boolean = false, TSetInput = unknown, TUpdateInput = unknown> {
     readonly _tag: string;
     readonly _State: TState;
     readonly _Proxy: TProxy;
-    readonly _TDefined: TDefined;
+    readonly _TRequired: TRequired;
     readonly _THasDefault: THasDefault;
     readonly _internal: PrimitiveInternal<TState, TProxy>;
+    readonly TSetInput: TSetInput;
+    readonly TUpdateInput: TUpdateInput;
   }
   
   /**
@@ -64,13 +66,32 @@ export interface Primitive<TState, TProxy, TDefined extends boolean = false, THa
    * Infer the proxy type from a primitive.
    */
   export type InferProxy<T> = T extends Primitive<any, infer P, any, any> ? P : never;
+
+  /**
+   * Infer the SetInput type from a primitive.
+   */
+  export type InferSetInput<T> = T extends Primitive<any, any, any, any, infer S, any> ? S : never;
+
+  /**
+   * Infer the UpdateInput type from a primitive.
+   */
+  export type InferUpdateInput<T> = T extends Primitive<any, any, any, any, any, infer U> ? U : never;
   
   /**
-   * Helper type to conditionally add undefined based on TDefined.
-   * When TDefined is true, the value is guaranteed to be defined (via required() or default()).
-   * When TDefined is false, the value may be undefined.
+   * Helper type to conditionally add undefined based on TRequired and THasDefault.
+   * When TRequired is false and THasDefault is false, the value may be undefined.
+   * Otherwise, the value is guaranteed to be defined.
    */
-  export type MaybeUndefined<T, TDefined extends boolean> = TDefined extends true ? T : T | undefined;
+  export type MaybeUndefined<T, TRequired extends boolean, THasDefault extends boolean> = TRequired extends false ? THasDefault extends false ? Optional<T> : T : T;
+
+  export type Optional<T> = T | undefined;
+
+  /**
+   * Helper type to conditionally add undefined based on TRequired and THasDefault.
+   * When TRequired is true and THasDefault is false, the value must be provided.
+   * Otherwise, the value may be undefined.
+   */
+  export type NeedsValue<T, TRequired extends boolean, THasDefault extends boolean> = TRequired extends true ? THasDefault extends false ? T : Optional<T> : Optional<T>;
   
   /**
    * Infer the snapshot type from a primitive.
@@ -90,34 +111,6 @@ export interface Primitive<TState, TProxy, TDefined extends boolean = false, THa
    */
   export type IsDefined<T> = T extends Primitive<any, any, infer D, any> ? D : false;
 
-  /**
-   * Determines if a field is required for set() operations.
-   * A field is required if: TDefined is true AND THasDefault is false
-   */
-  export type IsRequiredForSet<T> = T extends Primitive<any, any, true, false> ? true : false;
-
-  /**
-   * Extract keys of fields that are required for set() (required without default).
-   */
-  export type RequiredSetKeys<TFields extends Record<string, AnyPrimitive>> = {
-    [K in keyof TFields]: IsRequiredForSet<TFields[K]> extends true ? K : never;
-  }[keyof TFields];
-
-  /**
-   * Extract keys of fields that are optional for set() (has default OR not required).
-   */
-  export type OptionalSetKeys<TFields extends Record<string, AnyPrimitive>> = {
-    [K in keyof TFields]: IsRequiredForSet<TFields[K]> extends true ? never : K;
-  }[keyof TFields];
-
-  /**
-   * Compute the input type for set() operations on a struct.
-   * Required fields (required without default) must be provided.
-   * Optional fields (has default or not required) can be omitted.
-   */
-  export type StructSetInput<TFields extends Record<string, AnyPrimitive>> = 
-    { readonly [K in RequiredSetKeys<TFields>]: InferState<TFields[K]> } &
-    { readonly [K in OptionalSetKeys<TFields>]?: InferState<TFields[K]> };
   
   // =============================================================================
   // Validation Errors

package/tests/primitives/Array.test.ts

@@ -411,6 +411,114 @@ describe("ArrayPrimitive", () => {
       expect(positions[1]! < positions[2]!).toBe(true);
     });
   });
+  describe("struct elements with defaults", () => {
+    // Define a struct element with required and optional fields
+    const TaskStruct = Primitive.Struct({
+      title: Primitive.String().required(),       // Must provide
+      priority: Primitive.Number().default(0),     // Has default, optional
+      completed: Primitive.Boolean().default(false), // Has default, optional
+    });
+
+    const taskArray = Primitive.Array(TaskStruct);
+
+    // Helper to create environment for task array
+    const createTaskEnv = (
+      state: Primitive.ArrayEntry<{ title: string; priority: number; completed: boolean }>[] = []
+    ): { env: ReturnType<typeof ProxyEnvironment.make>; operations: Operation.Operation<any, any, any>[] } => {
+      const operations: Operation.Operation<any, any, any>[] = [];
+      let currentState = [...state];
+      let idCounter = 0;
+
+      const env = ProxyEnvironment.make({
+        onOperation: (op) => {
+          operations.push(op);
+          if (op.kind === "array.insert") {
+            currentState.push(op.payload);
+          } else if (op.kind === "array.set") {
+            currentState = op.payload;
+          }
+        },
+        getState: () => currentState,
+        generateId: () => `task-${++idCounter}`,
+      });
+
+      return { env, operations };
+    };
+
+    it("push() only requires fields without defaults", () => {
+      const { env, operations } = createTaskEnv();
+      const proxy = taskArray._internal.createProxy(env, OperationPath.make(""));
+
+      // Only provide required 'title', priority and completed should use defaults
+      proxy.push({ title: "New Task" });
+
+      expect(operations).toHaveLength(1);
+      expect(operations[0]!.kind).toBe("array.insert");
+
+      const payload = operations[0]!.payload as { value: { title: string; priority: number; completed: boolean } };
+      expect(payload.value.title).toBe("New Task");
+      expect(payload.value.priority).toBe(0); // Default value
+      expect(payload.value.completed).toBe(false); // Default value
+    });
+
+    it("push() allows overriding defaults", () => {
+      const { env, operations } = createTaskEnv();
+      const proxy = taskArray._internal.createProxy(env, OperationPath.make(""));
+
+      // Provide title and override priority, let completed use default
+      proxy.push({ title: "Important Task", priority: 10 });
+
+      const payload = operations[0]!.payload as { value: { title: string; priority: number; completed: boolean } };
+      expect(payload.value.title).toBe("Important Task");
+      expect(payload.value.priority).toBe(10); // Overridden
+      expect(payload.value.completed).toBe(false); // Default value
+    });
+
+    it("insertAt() applies defaults for omitted fields", () => {
+      const existingEntry = {
+        id: "existing",
+        pos: "a0",
+        value: { title: "Existing", priority: 5, completed: true },
+      };
+      const { env, operations } = createTaskEnv([existingEntry]);
+      const proxy = taskArray._internal.createProxy(env, OperationPath.make(""));
+
+      // Insert with only required field
+      proxy.insertAt(0, { title: "First Task" });
+
+      const payload = operations[0]!.payload as { value: { title: string; priority: number; completed: boolean } };
+      expect(payload.value.title).toBe("First Task");
+      expect(payload.value.priority).toBe(0); // Default
+      expect(payload.value.completed).toBe(false); // Default
+    });
+
+    it("set() applies defaults to each element", () => {
+      const { env, operations } = createTaskEnv();
+      const proxy = taskArray._internal.createProxy(env, OperationPath.make(""));
+
+      // Set array with items that only have required fields
+      proxy.set([
+        { title: "Task 1" },
+        { title: "Task 2", priority: 5 },
+        { title: "Task 3", completed: true },
+      ]);
+
+      expect(operations).toHaveLength(1);
+      expect(operations[0]!.kind).toBe("array.set");
+
+      const entries = operations[0]!.payload as { value: { title: string; priority: number; completed: boolean } }[];
+      expect(entries).toHaveLength(3);
+
+      // First item: only title, defaults for others
+      expect(entries[0]!.value).toEqual({ title: "Task 1", priority: 0, completed: false });
+
+      // Second item: title and priority, default for completed
+      expect(entries[1]!.value).toEqual({ title: "Task 2", priority: 5, completed: false });
+
+      // Third item: title and completed, default for priority
+      expect(entries[2]!.value).toEqual({ title: "Task 3", priority: 0, completed: true });
+    });
+  });
 });
 
 // =============================================================================

package/tests/primitives/Struct.test.ts

@@ -93,10 +93,10 @@ describe("StructPrimitive", () => {
       });
 
       const structPrimitive = Primitive.Struct({
-        name: Primitive.String().required(),
+        name: Primitive.String().required().default("John Doe"),
         age: Primitive.Number().required(),
         email: Primitive.String(),
-      }).default({ name: "John Doe" });
+      }).default({ age: 30 });
 
       const proxy = structPrimitive._internal.createProxy(env, OperationPath.make(""));
       proxy.set({ age: 30 });

package/tests/primitives/Tree.test.ts

@@ -582,6 +582,134 @@ describe("TreePrimitive", () => {
       expect(operations[0]!.path.toTokens()).toEqual(["file1", "size"]);
     });
   });
+
+  describe("proxy - insert with defaults", () => {
+    // Define node types with defaults
+    const ItemNodeWithDefaults = Primitive.TreeNode("item", {
+      data: Primitive.Struct({ 
+        title: Primitive.String().required(), // Must provide
+        count: Primitive.Number().default(0), // Has default, optional
+        active: Primitive.Boolean().default(true), // Has default, optional
+      }),
+      children: [] as const,
+    });
+
+    const ContainerNodeWithDefaults = Primitive.TreeNode("container", {
+      data: Primitive.Struct({ 
+        name: Primitive.String().required(), // Must provide
+      }),
+      children: (): readonly Primitive.AnyTreeNodePrimitive[] => [ContainerNodeWithDefaults, ItemNodeWithDefaults],
+    });
+
+    const treeWithDefaults = Primitive.Tree({
+      root: ContainerNodeWithDefaults,
+    });
+
+    // Helper to create a mock environment
+    const createEnvWithDefaultsTree = (
+      state: Primitive.TreeState<typeof ContainerNodeWithDefaults> = []
+    ): { env: ReturnType<typeof ProxyEnvironment.make>; operations: Operation.Operation<any, any, any>[] } => {
+      const operations: Operation.Operation<any, any, any>[] = [];
+      let currentState = [...state] as Primitive.TreeState<typeof ContainerNodeWithDefaults>;
+      let idCounter = 0;
+
+      const env = ProxyEnvironment.make({
+        onOperation: (op) => {
+          operations.push(op);
+          currentState = treeWithDefaults._internal.applyOperation(currentState, op);
+        },
+        getState: () => currentState,
+        generateId: () => `node-${++idCounter}`,
+      });
+
+      return { env, operations };
+    };
+
+    it("insertFirst() only requires fields without defaults", () => {
+      const initialState: Primitive.TreeState<typeof ContainerNodeWithDefaults> = [
+        { id: "root", type: "container", parentId: null, pos: "a0", data: { name: "Root" } },
+      ];
+      const { env, operations } = createEnvWithDefaultsTree(initialState);
+      const proxy = treeWithDefaults._internal.createProxy(env, OperationPath.make(""));
+
+      // Only provide required field 'title', count and active should use defaults
+      const newId = proxy.insertFirst("root", ItemNodeWithDefaults, { title: "New Item" });
+
+      expect(operations).toHaveLength(1);
+      expect(operations[0]!.kind).toBe("tree.insert");
+      expect(newId).toBe("node-1");
+
+      const payload = operations[0]!.payload as { data: { title: string; count: number; active: boolean } };
+      expect(payload.data.title).toBe("New Item");
+      expect(payload.data.count).toBe(0); // Default value
+      expect(payload.data.active).toBe(true); // Default value
+    });
+
+    it("insertLast() applies defaults for omitted fields", () => {
+      const initialState: Primitive.TreeState<typeof ContainerNodeWithDefaults> = [
+        { id: "root", type: "container", parentId: null, pos: "a0", data: { name: "Root" } },
+      ];
+      const { env, operations } = createEnvWithDefaultsTree(initialState);
+      const proxy = treeWithDefaults._internal.createProxy(env, OperationPath.make(""));
+
+      // Provide title and override count, let active use default
+      proxy.insertLast("root", ItemNodeWithDefaults, { title: "Item", count: 42 });
+
+      const payload = operations[0]!.payload as { data: { title: string; count: number; active: boolean } };
+      expect(payload.data.title).toBe("Item");
+      expect(payload.data.count).toBe(42); // Overridden
+      expect(payload.data.active).toBe(true); // Default value
+    });
+
+    it("insertAt() allows omitting all optional fields with defaults", () => {
+      const initialState: Primitive.TreeState<typeof ContainerNodeWithDefaults> = [
+        { id: "root", type: "container", parentId: null, pos: "a0", data: { name: "Root" } },
+      ];
+      const { env, operations } = createEnvWithDefaultsTree(initialState);
+      const proxy = treeWithDefaults._internal.createProxy(env, OperationPath.make(""));
+
+      // Only provide required 'name' for container
+      proxy.insertAt("root", 0, ContainerNodeWithDefaults, { name: "Subfolder" });
+
+      const payload = operations[0]!.payload as { type: string; data: { name: string } };
+      expect(payload.type).toBe("container");
+      expect(payload.data.name).toBe("Subfolder");
+    });
+
+    it("insertAfter() uses defaults when fields are omitted", () => {
+      const initialState: Primitive.TreeState<typeof ContainerNodeWithDefaults> = [
+        { id: "root", type: "container", parentId: null, pos: "a0", data: { name: "Root" } },
+        { id: "item1", type: "item", parentId: "root", pos: "a0", data: { title: "First", count: 1, active: false } },
+      ];
+      const { env, operations } = createEnvWithDefaultsTree(initialState);
+      const proxy = treeWithDefaults._internal.createProxy(env, OperationPath.make(""));
+
+      // Insert after sibling with only required field
+      proxy.insertAfter("item1", ItemNodeWithDefaults, { title: "Second" });
+
+      const payload = operations[0]!.payload as { data: { title: string; count: number; active: boolean } };
+      expect(payload.data.title).toBe("Second");
+      expect(payload.data.count).toBe(0); // Default
+      expect(payload.data.active).toBe(true); // Default
+    });
+
+    it("insertBefore() uses defaults when fields are omitted", () => {
+      const initialState: Primitive.TreeState<typeof ContainerNodeWithDefaults> = [
+        { id: "root", type: "container", parentId: null, pos: "a0", data: { name: "Root" } },
+        { id: "item1", type: "item", parentId: "root", pos: "a0", data: { title: "First", count: 1, active: false } },
+      ];
+      const { env, operations } = createEnvWithDefaultsTree(initialState);
+      const proxy = treeWithDefaults._internal.createProxy(env, OperationPath.make(""));
+
+      // Insert before sibling with only required field, override active
+      proxy.insertBefore("item1", ItemNodeWithDefaults, { title: "Zeroth", active: false });
+
+      const payload = operations[0]!.payload as { data: { title: string; count: number; active: boolean } };
+      expect(payload.data.title).toBe("Zeroth");
+      expect(payload.data.count).toBe(0); // Default
+      expect(payload.data.active).toBe(false); // Overridden
+    });
+  });
 });
 
 // =============================================================================

package/tsdown.config.ts

@@ -1,6 +1,6 @@
 import { defineConfig } from "tsdown";
 
-export const input = ["./src/index.ts"];
+export const input = ["./src/index.ts", "./src/server/index.ts", "./src/client/index.ts"];
 
 export default defineConfig({
 	target: ["es2017"],