oxform-core 0.1.0

package/src/tests/field/set-errors.spec.ts

@@ -0,0 +1,254 @@
+import { FormApi } from '#form-api';
+import type { FormIssue } from '#form-api.types';
+import { describe, expect, it } from 'vitest';
+import z from 'zod';
+
+const schema = z.object({
+  name: z.string(),
+  email: z.string(),
+  nested: z.object({
+    value: z.string(),
+  }),
+});
+
+const defaultValues = {
+  name: 'John',
+  email: 'john@example.com',
+  nested: {
+    value: 'test',
+  },
+};
+
+const setup = () => {
+  const form = new FormApi({
+    schema,
+    defaultValues,
+  });
+
+  form['~mount']();
+  return { form };
+};
+
+const mockError: FormIssue = {
+  code: 'custom',
+  message: 'Custom error message',
+  path: ['name'],
+} as any;
+
+const mockError2: FormIssue = {
+  code: 'custom_2',
+  message: 'Second custom error',
+  path: ['name'],
+} as any;
+
+describe('replace mode (default)', () => {
+  it('should set errors for a field with no existing errors', () => {
+    const { form } = setup();
+
+    form.field.setErrors('name', [mockError]);
+
+    expect(form.field.errors('name')).toEqual([mockError]);
+  });
+
+  it('should replace existing errors by default', () => {
+    const { form } = setup();
+
+    form.field.setErrors('name', [mockError]);
+    expect(form.field.errors('name')).toEqual([mockError]);
+
+    form.field.setErrors('name', [mockError2]);
+    expect(form.field.errors('name')).toEqual([mockError2]);
+  });
+
+  it('should replace existing errors when mode is explicitly set to replace', () => {
+    const { form } = setup();
+
+    form.field.setErrors('name', [mockError]);
+    form.field.setErrors('name', [mockError2], { mode: 'replace' });
+
+    expect(form.field.errors('name')).toEqual([mockError2]);
+  });
+
+  it('should clear errors when setting empty array', () => {
+    const { form } = setup();
+
+    form.field.setErrors('name', [mockError]);
+    expect(form.field.errors('name')).toEqual([mockError]);
+
+    form.field.setErrors('name', []);
+    expect(form.field.errors('name')).toEqual([]);
+  });
+});
+
+describe('append mode', () => {
+  it('should append new errors to existing ones', () => {
+    const { form } = setup();
+
+    form.field.setErrors('name', [mockError]);
+    form.field.setErrors('name', [mockError2], { mode: 'append' });
+
+    expect(form.field.errors('name')).toEqual([mockError, mockError2]);
+  });
+
+  it('should append to empty error list', () => {
+    const { form } = setup();
+
+    form.field.setErrors('name', [mockError], { mode: 'append' });
+
+    expect(form.field.errors('name')).toEqual([mockError]);
+  });
+
+  it('should append multiple errors at once', () => {
+    const { form } = setup();
+
+    const additionalError: FormIssue = {
+      code: 'custom_3',
+      message: 'Third custom error',
+      path: ['name'],
+    } as any;
+
+    form.field.setErrors('name', [mockError]);
+    form.field.setErrors('name', [mockError2, additionalError], { mode: 'append' });
+
+    expect(form.field.errors('name')).toEqual([mockError, mockError2, additionalError]);
+  });
+});
+
+describe('keep mode', () => {
+  it('should keep existing errors when they exist', () => {
+    const { form } = setup();
+
+    form.field.setErrors('name', [mockError]);
+    form.field.setErrors('name', [mockError2], { mode: 'keep' });
+
+    expect(form.field.errors('name')).toEqual([mockError]);
+  });
+
+  it('should set new errors when no existing errors', () => {
+    const { form } = setup();
+
+    form.field.setErrors('name', [mockError], { mode: 'keep' });
+
+    expect(form.field.errors('name')).toEqual([mockError]);
+  });
+
+  it('should not change errors when trying to set empty array with existing errors', () => {
+    const { form } = setup();
+
+    form.field.setErrors('name', [mockError]);
+    form.field.setErrors('name', [], { mode: 'keep' });
+
+    expect(form.field.errors('name')).toEqual([mockError]);
+  });
+});
+
+describe('nested fields', () => {
+  it('should set errors for nested fields', () => {
+    const { form } = setup();
+
+    const nestedError: FormIssue = {
+      code: 'custom',
+      message: 'Nested error',
+      path: ['nested', 'value'],
+    } as any;
+
+    form.field.setErrors('nested.value', [nestedError]);
+
+    expect(form.field.errors('nested.value')).toEqual([nestedError]);
+  });
+
+  it('should work with all modes for nested fields', () => {
+    const { form } = setup();
+
+    const nestedError1: FormIssue = {
+      code: 'custom_1',
+      message: 'First nested error',
+      path: ['nested', 'value'],
+    } as any;
+
+    const nestedError2: FormIssue = {
+      code: 'custom_2',
+      message: 'Second nested error',
+      path: ['nested', 'value'],
+    } as any;
+
+    form.field.setErrors('nested.value', [nestedError1]);
+    form.field.setErrors('nested.value', [nestedError2], { mode: 'append' });
+    expect(form.field.errors('nested.value')).toEqual([nestedError1, nestedError2]);
+
+    form.field.setErrors('nested.value', [{ ...nestedError1, code: 'should_not_appear' } as any], { mode: 'keep' });
+    expect(form.field.errors('nested.value')).toEqual([nestedError1, nestedError2]);
+
+    form.field.setErrors('nested.value', [nestedError1], { mode: 'replace' });
+    expect(form.field.errors('nested.value')).toEqual([nestedError1]);
+  });
+});
+
+describe('multiple fields', () => {
+  it('should not affect other fields when setting errors', () => {
+    const { form } = setup();
+
+    const nameError: FormIssue = {
+      code: 'custom',
+      message: 'Name error',
+      path: ['name'],
+    } as any;
+
+    const emailError: FormIssue = {
+      code: 'custom',
+      message: 'Email error',
+      path: ['email'],
+    } as any;
+
+    form.field.setErrors('name', [nameError]);
+    form.field.setErrors('email', [emailError]);
+
+    expect(form.field.errors('name')).toEqual([nameError]);
+    expect(form.field.errors('email')).toEqual([emailError]);
+
+    form.field.setErrors('name', []);
+    expect(form.field.errors('name')).toEqual([]);
+    expect(form.field.errors('email')).toEqual([emailError]);
+  });
+});
+
+describe('form status updates', () => {
+  it('should update form validity when errors are set', () => {
+    const { form } = setup();
+
+    expect(form.store.state.status.valid).toBe(true);
+
+    form.field.setErrors('name', [mockError]);
+
+    expect(form.store.state.status.valid).toBe(false);
+  });
+
+  it('should update form validity when errors are cleared', () => {
+    const { form } = setup();
+
+    form.field.setErrors('name', [mockError]);
+    expect(form.store.state.status.valid).toBe(false);
+
+    form.field.setErrors('name', []);
+    expect(form.store.state.status.valid).toBe(true);
+  });
+
+  it('should maintain field meta state when setting errors manually', () => {
+    const { form } = setup();
+
+    form.field.change('name', 'Jane');
+    form.field.focus('name');
+    form.field.blur('name');
+
+    const metaBefore = form.field.meta('name');
+
+    form.field.setErrors('name', [mockError]);
+
+    const metaAfter = form.field.meta('name');
+
+    expect(metaAfter.dirty).toBe(metaBefore.dirty);
+    expect(metaAfter.touched).toBe(metaBefore.touched);
+    expect(metaAfter.blurred).toBe(metaBefore.blurred);
+    expect(metaAfter.valid).toBe(false); // This should change due to error
+  });
+});

package/src/tests/field-api/field-api.spec.ts

@@ -0,0 +1,341 @@
+import { FieldApi } from '#field-api';
+import { FormApi } from '#form-api';
+import type { FormIssue } from '#form-api.types';
+import { describe, expect, it } from 'vitest';
+import z from 'zod';
+
+const schema = z.object({
+  name: z.string().min(1, 'Name is required'),
+  email: z.string(),
+  nested: z.object({
+    value: z.string().min(1, 'Value is required'),
+  }),
+});
+
+const defaultValues = {
+  name: 'John',
+  email: 'john@example.com',
+  nested: {
+    value: 'test',
+  },
+};
+
+const setup = () => {
+  const form = new FormApi({
+    schema,
+    defaultValues,
+  });
+  form['~mount']();
+
+  const nameField = new FieldApi({ form, name: 'name' });
+  nameField['~mount']();
+
+  const emailField = new FieldApi({ form, name: 'email' });
+  emailField['~mount']();
+
+  const nestedField = new FieldApi({ form, name: 'nested.value' });
+  nestedField['~mount']();
+
+  return { form, nameField, emailField, nestedField };
+};
+
+describe('FieldApi methods', () => {
+  describe('validate method', () => {
+    it('should validate the specific field only', async () => {
+      const { nameField, form } = setup();
+
+      // Make the name field invalid
+      nameField.change('');
+
+      // Validate only the name field
+      const issues = await nameField.validate({ type: 'submit' });
+
+      expect(issues).toHaveLength(1);
+      expect(issues[0].path).toEqual(['name']);
+      expect(form.field.errors('name')).toHaveLength(1);
+      expect(form.field.errors('email')).toHaveLength(0);
+    });
+
+    it('should validate field with different validation types', async () => {
+      const { nameField } = setup();
+
+      // Test different validation types
+      await nameField.validate({ type: 'blur' });
+      await nameField.validate({ type: 'focus' });
+      await nameField.validate({ type: 'submit' });
+      await nameField.validate({ type: 'change' });
+
+      // Should not throw and should work with all types
+      expect(nameField.errors).toEqual([]);
+    });
+
+    it('should validate field without options (using default schema)', async () => {
+      const { nameField } = setup();
+
+      nameField.change(''); // Make invalid
+      const issues = await nameField.validate();
+
+      expect(issues).toHaveLength(1);
+      expect(issues[0].path).toEqual(['name']);
+    });
+  });
+
+  describe('setErrors method', () => {
+    const mockError: FormIssue = {
+      code: 'custom',
+      message: 'Custom field error',
+      path: ['name'],
+    } as any;
+
+    const mockError2: FormIssue = {
+      code: 'custom_2',
+      message: 'Second field error',
+      path: ['name'],
+    } as any;
+
+    it('should set errors in replace mode by default', () => {
+      const { nameField } = setup();
+
+      nameField.setErrors([mockError]);
+      expect(nameField.errors).toEqual([mockError]);
+
+      // Replace with new error
+      nameField.setErrors([mockError2]);
+      expect(nameField.errors).toEqual([mockError2]);
+    });
+
+    it('should set errors in append mode', () => {
+      const { nameField } = setup();
+
+      nameField.setErrors([mockError]);
+      nameField.setErrors([mockError2], { mode: 'append' });
+
+      expect(nameField.errors).toEqual([mockError, mockError2]);
+    });
+
+    it('should set errors in keep mode', () => {
+      const { nameField } = setup();
+
+      // Set initial error
+      nameField.setErrors([mockError]);
+
+      // Try to set new error with keep mode - should keep existing
+      nameField.setErrors([mockError2], { mode: 'keep' });
+      expect(nameField.errors).toEqual([mockError]);
+    });
+
+    it('should set errors in keep mode when no existing errors', () => {
+      const { nameField } = setup();
+
+      nameField.setErrors([mockError], { mode: 'keep' });
+      expect(nameField.errors).toEqual([mockError]);
+    });
+
+    it('should clear errors when setting empty array', () => {
+      const { nameField } = setup();
+
+      nameField.setErrors([mockError]);
+      expect(nameField.errors).toEqual([mockError]);
+
+      nameField.setErrors([]);
+      expect(nameField.errors).toEqual([]);
+    });
+
+    it('should work with nested fields', () => {
+      const { nestedField } = setup();
+
+      const nestedError: FormIssue = {
+        code: 'custom',
+        message: 'Nested field error',
+        path: ['nested', 'value'],
+      } as any;
+
+      nestedField.setErrors([nestedError]);
+      expect(nestedField.errors).toEqual([nestedError]);
+    });
+  });
+
+  describe('reset method', () => {
+    it('should reset field to default value', () => {
+      const { nameField } = setup();
+
+      // Change the field value
+      nameField.change('Jane');
+      expect(nameField.value).toBe('Jane');
+
+      // Reset the field
+      nameField.reset();
+      expect(nameField.value).toBe('John'); // back to default
+    });
+
+    it('should reset field to specific value', () => {
+      const { nameField } = setup();
+
+      nameField.change('Jane');
+      nameField.reset({ value: 'Bob' });
+
+      expect(nameField.value).toBe('Bob');
+    });
+
+    it('should reset field meta by default', () => {
+      const { nameField } = setup();
+
+      // Make the field dirty and touched
+      nameField.change('Jane');
+      nameField.focus();
+      nameField.blur();
+
+      expect(nameField.meta.dirty).toBe(true);
+      expect(nameField.meta.touched).toBe(true);
+      expect(nameField.meta.blurred).toBe(true);
+
+      // Reset the field
+      nameField.reset();
+
+      expect(nameField.meta.dirty).toBe(false);
+      expect(nameField.meta.touched).toBe(false);
+      expect(nameField.meta.blurred).toBe(false);
+    });
+
+    it('should keep field meta when specified', () => {
+      const { nameField } = setup();
+
+      // Make the field dirty and touched
+      nameField.change('Jane');
+      nameField.focus();
+      nameField.blur();
+
+      const metaBefore = { ...nameField.meta };
+
+      // Reset but keep meta
+      nameField.reset({ keep: { meta: true } });
+
+      expect(nameField.value).toBe('John'); // value should reset
+      expect(nameField.meta.dirty).toBe(metaBefore.dirty);
+      expect(nameField.meta.touched).toBe(metaBefore.touched);
+      expect(nameField.meta.blurred).toBe(metaBefore.blurred);
+    });
+
+    it('should reset field errors by default', () => {
+      const { nameField } = setup();
+
+      const mockError: FormIssue = {
+        code: 'custom',
+        message: 'Test error',
+        path: ['name'],
+      } as any;
+
+      nameField.setErrors([mockError]);
+      expect(nameField.errors).toEqual([mockError]);
+
+      nameField.reset();
+      expect(nameField.errors).toEqual([]);
+    });
+
+    it('should keep field errors when specified', () => {
+      const { nameField } = setup();
+
+      const mockError: FormIssue = {
+        code: 'custom',
+        message: 'Test error',
+        path: ['name'],
+      } as any;
+
+      nameField.setErrors([mockError]);
+      nameField.change('Jane');
+
+      nameField.reset({ keep: { errors: true } });
+
+      expect(nameField.value).toBe('John'); // value should reset
+      expect(nameField.errors).toEqual([mockError]); // errors should be kept
+    });
+
+    it('should work with nested fields', () => {
+      const { nestedField } = setup();
+
+      nestedField.change('changed');
+      expect(nestedField.value).toBe('changed');
+
+      nestedField.reset();
+      expect(nestedField.value).toBe('test'); // back to default
+    });
+  });
+
+  describe('integration with existing methods', () => {
+    it('should work with change and validation together', async () => {
+      const { nameField } = setup();
+
+      // Change to invalid value
+      nameField.change('');
+
+      // Validate the field
+      const issues = await nameField.validate({ type: 'submit' });
+      expect(issues).toHaveLength(1);
+      expect(nameField.errors).toHaveLength(1);
+
+      // Change to valid value
+      nameField.change('Jane');
+
+      // Validate again
+      const validIssues = await nameField.validate({ type: 'submit' });
+      expect(validIssues).toHaveLength(0);
+      expect(nameField.errors).toHaveLength(0);
+    });
+
+    it('should work with focus, blur, and validation', async () => {
+      const { nameField } = setup();
+
+      nameField.focus();
+      expect(nameField.meta.touched).toBe(true);
+
+      nameField.blur();
+      expect(nameField.meta.blurred).toBe(true);
+
+      await nameField.validate({ type: 'blur' });
+      // Should not throw and should work properly
+    });
+
+    it('should maintain consistency with form state', () => {
+      const { nameField, form } = setup();
+
+      const mockError: FormIssue = {
+        code: 'custom',
+        message: 'Test error',
+        path: ['name'],
+      } as any;
+
+      // Set error through field
+      nameField.setErrors([mockError]);
+
+      // Should be reflected in form
+      expect(form.field.errors('name')).toEqual([mockError]);
+      expect(form.store.state.status.valid).toBe(false);
+
+      // Clear error through field
+      nameField.setErrors([]);
+
+      // Should be reflected in form
+      expect(form.field.errors('name')).toEqual([]);
+      expect(form.store.state.status.valid).toBe(true);
+    });
+
+    it('should work with form-level operations', async () => {
+      const { nameField, form } = setup();
+
+      // Change field value
+      nameField.change('Jane');
+      expect(nameField.value).toBe('Jane');
+      expect(form.field.get('name')).toBe('Jane');
+
+      // Reset through form
+      form.field.reset('name');
+      expect(nameField.value).toBe('John');
+
+      // Validate through form
+      nameField.change('');
+      const issues = await form.validate('name', { type: 'submit' });
+      expect(issues).toHaveLength(1);
+      expect(nameField.errors).toHaveLength(1);
+    });
+  });
+});