fieldwise 0.1.0

package/dist/Form.js

@@ -0,0 +1,162 @@
+export class Form {
+    constructor(initialValues) {
+        this.fieldSubscribers = new Map();
+        this.eventHandlers = new Map();
+        this.eventQueue = new Map();
+        this.emit = (event, ...args) => {
+            this.doEmit(event, ...args);
+        };
+        this.emitLater = (event, ...args) => {
+            setTimeout(() => {
+                this.doEmit(event, ...args);
+            }, 0);
+        };
+        this.initialValues = initialValues;
+        this.fields = this.valuesToFields(initialValues);
+    }
+    getValue(key) {
+        return this.fields[key].value;
+    }
+    getValues() {
+        return Object.entries(this.fields).reduce((acc, [key, field]) => {
+            acc[key] = field.value;
+            return acc;
+        }, {});
+    }
+    get(key) {
+        return this.fields[key];
+    }
+    setValue(key, value) {
+        if (key in this.fields && this.fields[key].value !== value) {
+            this.fields[key].value = value;
+            this.fields[key].error = null;
+            this.fields[key].isTouched = true;
+            this.notify(key, this.fields[key]);
+        }
+    }
+    setValues(newValues) {
+        Object.keys(newValues).forEach((key) => {
+            this.setValue(key, newValues[key]);
+        });
+    }
+    touch(key) {
+        const field = this.fields[key];
+        if (!field.isTouched) {
+            field.isTouched = true;
+            this.notify(key, field);
+        }
+    }
+    setError(key, error) {
+        if (this.fields[key].error !== error) {
+            this.fields[key].error = error;
+            this.notify(key, this.fields[key]);
+        }
+    }
+    setErrors(newErrors) {
+        Object.keys(this.fields).forEach((key) => {
+            this.setError(key, newErrors[key] || null);
+        });
+    }
+    reset(snapshot) {
+        this.fields = this.valuesToFields(snapshot);
+        Object.entries(this.fields).forEach(([name, field]) => {
+            this.notify(name, field);
+        });
+    }
+    getSlice(keys) {
+        return keys.reduce((acc, key) => {
+            acc[key] = this.fields[key];
+            return acc;
+        }, {});
+    }
+    subscribeField(key, callback) {
+        if (!this.fieldSubscribers.has(key)) {
+            this.fieldSubscribers.set(key, new Set());
+        }
+        const subscribers = this.fieldSubscribers.get(key);
+        subscribers.add(callback);
+        return () => {
+            subscribers.delete(callback);
+        };
+    }
+    on(event, handler) {
+        if (!this.eventHandlers.has(event)) {
+            this.eventHandlers.set(event, new Set());
+        }
+        const handlers = this.eventHandlers.get(event);
+        handlers.add(handler);
+        // Process queued events when first handler is added
+        this.processQueuedEvents(event);
+        return () => {
+            handlers.delete(handler);
+        };
+    }
+    once(event, handler) {
+        const wrapper = (...args) => {
+            handler(...args);
+            this.eventHandlers
+                .get(event)
+                ?.delete(wrapper);
+        };
+        if (!this.eventHandlers.has(event)) {
+            this.eventHandlers.set(event, new Set());
+        }
+        this.eventHandlers
+            .get(event)
+            .add(wrapper);
+        // Process queued events when first handler is added
+        this.processQueuedEvents(event);
+    }
+    doEmit(event, ...args) {
+        const handlers = this.eventHandlers.get(event);
+        if (!handlers || handlers.size === 0) {
+            // Queue event if no handlers exist
+            if (!this.eventQueue.has(event)) {
+                this.eventQueue.set(event, []);
+            }
+            this.eventQueue.get(event).push(args);
+        }
+        else {
+            // Emit to handlers immediately
+            handlers.forEach((handler) => {
+                handler(...args);
+            });
+        }
+    }
+    processQueuedEvents(event) {
+        const queue = this.eventQueue.get(event);
+        if (!queue || queue.length === 0)
+            return;
+        const handlers = this.eventHandlers.get(event);
+        // Process all queued events in FIFO order while handlers exist
+        while (queue.length > 0 && handlers && handlers.size > 0) {
+            const args = queue.shift();
+            handlers.forEach((handler) => {
+                handler(...args);
+            });
+        }
+        // Clean up empty queue
+        if (queue.length === 0) {
+            this.eventQueue.delete(event);
+        }
+    }
+    notify(key, field) {
+        const subscribers = this.fieldSubscribers.get(key);
+        if (subscribers) {
+            subscribers.forEach((callback) => {
+                callback(field);
+            });
+        }
+    }
+    valuesToFields(values) {
+        return Object.keys(values).reduce((acc, key) => {
+            acc[key] = {
+                value: values[key],
+                error: null,
+                isTouched: false
+            };
+            return acc;
+        }, {});
+    }
+}
+Form.debugMode = false;

package/dist/changeHandlers.d.ts

@@ -0,0 +1,3 @@
+import type { Values, Form } from './Form';
+export default function changeHandlers<T extends Values>(form: Form<T>): void;
+//# sourceMappingURL=changeHandlers.d.ts.map

package/dist/changeHandlers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"changeHandlers.d.ts","sourceRoot":"","sources":["../src/changeHandlers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAE3C,MAAM,CAAC,OAAO,UAAU,cAAc,CAAC,CAAC,SAAS,MAAM,EAAE,IAAI,EAAE,IAAI,CAAC,CAAC,CAAC,QAsBrE"}

package/dist/changeHandlers.js

@@ -0,0 +1,19 @@
+export default function changeHandlers(form) {
+    form.on('change', (name, value) => {
+        form.setValue(name, value);
+    });
+    form.on('changeSome', (newValues) => {
+        form.setValues(newValues);
+    });
+    form.on('touch', (name) => {
+        form.touch(name);
+    });
+    form.on('touchSome', (names) => {
+        names.forEach((name) => {
+            form.touch(name);
+        });
+    });
+    form.on('reset', (values) => {
+        form.reset(values || form.initialValues);
+    });
+}

package/dist/errorHandlers.d.ts

@@ -0,0 +1,3 @@
+import type { Values, Form } from './Form';
+export default function errorHandlers<T extends Values>(form: Form<T>): void;
+//# sourceMappingURL=errorHandlers.d.ts.map

package/dist/errorHandlers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errorHandlers.d.ts","sourceRoot":"","sources":["../src/errorHandlers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAE3C,MAAM,CAAC,OAAO,UAAU,aAAa,CAAC,CAAC,SAAS,MAAM,EAAE,IAAI,EAAE,IAAI,CAAC,CAAC,CAAC,QAIpE"}

package/dist/errorHandlers.js

@@ -0,0 +1,5 @@
+export default function errorHandlers(form) {
+    form.on('errors', (newErrors) => {
+        form.setErrors(newErrors);
+    });
+}

package/dist/fieldwise.d.ts

@@ -0,0 +1,38 @@
+import { Form } from './Form';
+import type { Values, FieldSet, EmitFn } from './Form';
+type EmitFnWithLater<T extends Values> = EmitFn<T> & {
+    later: EmitFn<T>;
+};
+type FormCommons<T extends Values> = {
+    emit: EmitFnWithLater<T>;
+    once: typeof Form.prototype.once;
+    isTouched: boolean;
+    i: <K extends keyof T>(key: K) => InputProps<K, T[K]>;
+};
+type InputProps<K, T> = {
+    name: K;
+    value: T;
+    onChange: (value: T) => void;
+    error: string | null;
+};
+type FormHooks<T extends Values> = {
+    useSlice<K extends keyof T>(keys: readonly K[]): FormCommons<T> & {
+        fields: FieldSet<Pick<T, K>>;
+    };
+    useForm(): FormCommons<T> & {
+        fields: FieldSet<T>;
+    };
+};
+type PluginFunction<T extends Values, TArgs extends unknown[] = []> = (form: Form<T>, ...args: TArgs) => void;
+export declare class FormBuilder<T extends Values> {
+    private form;
+    constructor(initialValues: T);
+    get useSlice(): FormHooks<T>['useSlice'];
+    get useForm(): FormHooks<T>['useForm'];
+    use<TArgs extends unknown[]>(plugin: PluginFunction<T, TArgs>, ...args: TArgs): FormBuilder<T>;
+    hooks(): FormHooks<T>;
+}
+export declare const fieldwise: <T extends Values>(initialValues: T) => FormBuilder<T>;
+export declare const getValues: <T extends Values>(fields: Form<T>["fields"]) => T;
+export {};
+//# sourceMappingURL=fieldwise.d.ts.map

package/dist/fieldwise.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fieldwise.d.ts","sourceRoot":"","sources":["../src/fieldwise.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAK9B,OAAO,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAsB,MAAM,QAAQ,CAAC;AAE3E,KAAK,eAAe,CAAC,CAAC,SAAS,MAAM,IAAI,MAAM,CAAC,CAAC,CAAC,GAAG;IACnD,KAAK,EAAE,MAAM,CAAC,CAAC,CAAC,CAAC;CAClB,CAAC;AAEF,KAAK,WAAW,CAAC,CAAC,SAAS,MAAM,IAAI;IACnC,IAAI,EAAE,eAAe,CAAC,CAAC,CAAC,CAAC;IACzB,IAAI,EAAE,OAAO,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC;IACjC,SAAS,EAAE,OAAO,CAAC;IACnB,CAAC,EAAE,CAAC,CAAC,SAAS,MAAM,CAAC,EAAE,GAAG,EAAE,CAAC,KAAK,UAAU,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;CACvD,CAAC;AAEF,KAAK,UAAU,CAAC,CAAC,EAAE,CAAC,IAAI;IACtB,IAAI,EAAE,CAAC,CAAC;IACR,KAAK,EAAE,CAAC,CAAC;IACT,QAAQ,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,IAAI,CAAC;IAC7B,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;CACtB,CAAC;AACF,KAAK,SAAS,CAAC,CAAC,SAAS,MAAM,IAAI;IACjC,QAAQ,CAAC,CAAC,SAAS,MAAM,CAAC,EACxB,IAAI,EAAE,SAAS,CAAC,EAAE,GACjB,WAAW,CAAC,CAAC,CAAC,GAAG;QAAE,MAAM,EAAE,QAAQ,CAAC,IAAI,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAA;KAAE,CAAC;IACrD,OAAO,IAAI,WAAW,CAAC,CAAC,CAAC,GAAG;QAAE,MAAM,EAAE,QAAQ,CAAC,CAAC,CAAC,CAAA;KAAE,CAAC;CACrD,CAAC;AAEF,KAAK,cAAc,CAAC,CAAC,SAAS,MAAM,EAAE,KAAK,SAAS,OAAO,EAAE,GAAG,EAAE,IAAI,CACpE,IAAI,EAAE,IAAI,CAAC,CAAC,CAAC,EACb,GAAG,IAAI,EAAE,KAAK,KACX,IAAI,CAAC;AAEV,qBAAa,WAAW,CAAC,CAAC,SAAS,MAAM;IACvC,OAAO,CAAC,IAAI,CAAU;gBAEV,aAAa,EAAE,CAAC;IAS5B,IAAI,QAAQ,IAAI,SAAS,CAAC,CAAC,CAAC,CAAC,UAAU,CAAC,CAwDvC;IAED,IAAI,OAAO,IAAI,SAAS,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,CAMrC;IAED,GAAG,CAAC,KAAK,SAAS,OAAO,EAAE,EACzB,MAAM,EAAE,cAAc,CAAC,CAAC,EAAE,KAAK,CAAC,EAChC,GAAG,IAAI,EAAE,KAAK,GACb,WAAW,CAAC,CAAC,CAAC;IAKjB,KAAK,IAAI,SAAS,CAAC,CAAC,CAAC;CAMtB;AAED,eAAO,MAAM,SAAS,GAAI,CAAC,SAAS,MAAM,EACxC,eAAe,CAAC,KACf,WAAW,CAAC,CAAC,CAEf,CAAC;AAEF,eAAO,MAAM,SAAS,GAAI,CAAC,SAAS,MAAM,EAAE,QAAQ,IAAI,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,KAAG,CAKvE,CAAC"}

package/dist/fieldwise.js

@@ -0,0 +1,86 @@
+import { useEffect, useState, useCallback, useMemo } from 'react';
+import { Form } from './Form';
+import logFormEvents from './logFormEvents';
+import changeHandlers from './changeHandlers';
+import errorHandlers from './errorHandlers';
+export class FormBuilder {
+    constructor(initialValues) {
+        this.form = new Form(initialValues);
+        if (Form.debugMode) {
+            logFormEvents(this.form);
+        }
+        changeHandlers(this.form);
+        errorHandlers(this.form);
+    }
+    get useSlice() {
+        return (keys) => {
+            const [fields, setFields] = useState(() => this.form.getSlice(keys));
+            useEffect(() => {
+                const unsubscribers = [];
+                let pendingUpdate = false;
+                const scheduleUpdate = () => {
+                    if (!pendingUpdate) {
+                        pendingUpdate = true;
+                        queueMicrotask(() => {
+                            pendingUpdate = false;
+                            setFields(this.form.getSlice(keys));
+                        });
+                    }
+                };
+                keys.forEach((key) => {
+                    const unsubscribe = this.form.subscribeField(key, scheduleUpdate);
+                    unsubscribers.push(unsubscribe);
+                });
+                return () => {
+                    unsubscribers.forEach((unsubscribe) => unsubscribe());
+                };
+            }, [keys]);
+            const emit = useMemo(() => {
+                const emitFn = this.form.emit.bind(this.form);
+                return Object.assign(emitFn, {
+                    later: this.form.emitLater.bind(this.form)
+                });
+            }, []);
+            const once = useMemo(() => this.form.once.bind(this.form), []);
+            const isTouched = useMemo(() => {
+                return keys.some((key) => this.form.get(key).isTouched);
+            }, [keys]);
+            const inputProps = useCallback((name) => {
+                return {
+                    name,
+                    value: this.form.getValue(name),
+                    onChange: (value) => {
+                        this.form.emit('change', name, value);
+                    },
+                    error: this.form.get(name).error
+                };
+            }, []);
+            return { fields, isTouched, emit, once, i: inputProps };
+        };
+    }
+    get useForm() {
+        return () => {
+            const allKeys = Object.keys(this.form['initialValues']);
+            return this.useSlice(allKeys);
+        };
+    }
+    use(plugin, ...args) {
+        plugin(this.form, ...args);
+        return this;
+    }
+    hooks() {
+        return {
+            useSlice: this.useSlice,
+            useForm: this.useForm
+        };
+    }
+}
+export const fieldwise = (initialValues) => {
+    return new FormBuilder(initialValues);
+};
+export const getValues = (fields) => {
+    return Object.entries(fields).reduce((acc, [key, field]) => {
+        acc[key] = field.value;
+        return acc;
+    }, {});
+};

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export * from './fieldwise';
+export * from './validateZodSchema';
+export * from './Form';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAC;AAC5B,cAAc,qBAAqB,CAAC;AACpC,cAAc,QAAQ,CAAC"}

package/dist/index.js

@@ -0,0 +1,3 @@
+export * from './fieldwise';
+export * from './validateZodSchema';
+export * from './Form';

package/dist/logFormEvents.d.ts

@@ -0,0 +1,3 @@
+import type { Values, Form } from './Form';
+export default function logFormEvents<T extends Values>(form: Form<T>): void;
+//# sourceMappingURL=logFormEvents.d.ts.map

package/dist/logFormEvents.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logFormEvents.d.ts","sourceRoot":"","sources":["../src/logFormEvents.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,MAAM,EAAE,IAAI,EAA8B,MAAM,QAAQ,CAAC;AAevE,MAAM,CAAC,OAAO,UAAU,aAAa,CAAC,CAAC,SAAS,MAAM,EAAE,IAAI,EAAE,IAAI,CAAC,CAAC,CAAC,GAAG,IAAI,CAa3E"}

package/dist/logFormEvents.js

@@ -0,0 +1,22 @@
+import { Form as FormClass } from './Form';
+const allEventTypes = [
+    'change',
+    'changeSome',
+    'reset',
+    'errors',
+    'validate',
+    'validated'
+];
+const isDebugModeObject = (mode) => {
+    return typeof mode === 'object' && mode !== null && Array.isArray(mode.only);
+};
+export default function logFormEvents(form) {
+    const eventsToLog = isDebugModeObject(FormClass.debugMode)
+        ? FormClass.debugMode.only
+        : allEventTypes;
+    eventsToLog.forEach((eventType) => {
+        form.on(eventType, (...args) => {
+            console.log(`[Form Event] ${eventType}:`, ...(args.length === 0 ? ['[no payload]'] : args));
+        });
+    });
+}

package/dist/test/Form.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=Form.test.d.ts.map

package/dist/test/Form.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Form.test.d.ts","sourceRoot":"","sources":["../../src/test/Form.test.ts"],"names":[],"mappings":""}

package/dist/test/Form.test.js

@@ -0,0 +1,218 @@
+import { describe, it, expect, vi } from 'vitest';
+import { FormBuilder } from '../fieldwise';
+describe('Form', () => {
+    describe('initialization', () => {
+        it('should initialize with provided values', () => {
+            const initialValues = { name: 'John', email: 'john@example.com' };
+            const builder = new FormBuilder(initialValues);
+            const form = builder.form;
+            expect(form.getValues()).toEqual(initialValues);
+        });
+        it('should set all fields as not touched initially', () => {
+            const builder = new FormBuilder({ name: '', email: '' });
+            const form = builder.form;
+            expect(form.get('name').isTouched).toBe(false);
+            expect(form.get('email').isTouched).toBe(false);
+        });
+        it('should set all field errors to null initially', () => {
+            const builder = new FormBuilder({ name: '', email: '' });
+            const form = builder.form;
+            expect(form.get('name').error).toBe(null);
+            expect(form.get('email').error).toBe(null);
+        });
+    });
+    describe('change event', () => {
+        it('should update field value on change', () => {
+            const builder = new FormBuilder({ name: '', email: '' });
+            const form = builder.form;
+            form.emit('change', 'name', 'Jane');
+            expect(form.getValue('name')).toBe('Jane');
+        });
+        it('should mark field as touched on change', () => {
+            const builder = new FormBuilder({ name: '', email: '' });
+            const form = builder.form;
+            form.emit('change', 'name', 'Jane');
+            expect(form.get('name').isTouched).toBe(true);
+        });
+        it('should trigger change event listeners', () => {
+            const builder = new FormBuilder({ name: '', email: '' });
+            const form = builder.form;
+            const listener = vi.fn();
+            form.on('change', listener);
+            form.emit('change', 'name', 'Jane');
+            expect(listener).toHaveBeenCalledWith('name', 'Jane');
+        });
+        it('should notify field subscribers', () => {
+            const builder = new FormBuilder({ name: '', email: '' });
+            const form = builder.form;
+            const subscriber = vi.fn();
+            form.subscribeField('name', subscriber);
+            form.emit('change', 'name', 'Jane');
+            expect(subscriber).toHaveBeenCalled();
+        });
+    });
+    describe('changeSome event', () => {
+        it('should update multiple fields at once', () => {
+            const builder = new FormBuilder({ name: '', email: '', age: 0 });
+            const form = builder.form;
+            form.emit('changeSome', { name: 'Jane', email: 'jane@example.com' });
+            expect(form.getValue('name')).toBe('Jane');
+            expect(form.getValue('email')).toBe('jane@example.com');
+            expect(form.getValue('age')).toBe(0);
+        });
+        it('should mark updated fields as touched', () => {
+            const builder = new FormBuilder({ name: '', email: '' });
+            const form = builder.form;
+            form.emit('changeSome', { name: 'Jane' });
+            expect(form.get('name').isTouched).toBe(true);
+            expect(form.get('email').isTouched).toBe(false);
+        });
+    });
+    describe('touch event', () => {
+        it('should mark field as touched without changing value', () => {
+            const builder = new FormBuilder({ name: 'John', email: '' });
+            const form = builder.form;
+            expect(form.get('name').isTouched).toBe(false);
+            expect(form.getValue('name')).toBe('John');
+            form.emit('touch', 'name');
+            expect(form.get('name').isTouched).toBe(true);
+            expect(form.getValue('name')).toBe('John');
+        });
+        it('should notify field subscribers', () => {
+            const builder = new FormBuilder({ name: '' });
+            const form = builder.form;
+            const subscriber = vi.fn();
+            form.subscribeField('name', subscriber);
+            form.emit('touch', 'name');
+            expect(subscriber).toHaveBeenCalled();
+        });
+        it('should not notify if already touched', () => {
+            const builder = new FormBuilder({ name: '' });
+            const form = builder.form;
+            const subscriber = vi.fn();
+            form.emit('touch', 'name');
+            form.subscribeField('name', subscriber);
+            form.emit('touch', 'name');
+            expect(subscriber).not.toHaveBeenCalled();
+        });
+    });
+    describe('touchSome event', () => {
+        it('should mark multiple fields as touched', () => {
+            const builder = new FormBuilder({ name: '', email: '', age: 0 });
+            const form = builder.form;
+            form.emit('touchSome', ['name', 'email']);
+            expect(form.get('name').isTouched).toBe(true);
+            expect(form.get('email').isTouched).toBe(true);
+            expect(form.get('age').isTouched).toBe(false);
+        });
+        it('should not change field values', () => {
+            const builder = new FormBuilder({
+                name: 'John',
+                email: 'john@example.com'
+            });
+            const form = builder.form;
+            form.emit('touchSome', ['name', 'email']);
+            expect(form.getValue('name')).toBe('John');
+            expect(form.getValue('email')).toBe('john@example.com');
+        });
+    });
+    describe('reset event', () => {
+        it('should reset to initial values', () => {
+            const builder = new FormBuilder({
+                name: 'John',
+                email: 'john@example.com'
+            });
+            const form = builder.form;
+            form.emit('change', 'name', 'Jane');
+            form.emit('reset');
+            expect(form.getValue('name')).toBe('John');
+        });
+        it('should reset to provided snapshot', () => {
+            const builder = new FormBuilder({
+                name: 'John',
+                email: 'john@example.com'
+            });
+            const form = builder.form;
+            form.emit('reset', { name: 'Jane', email: 'jane@example.com' });
+            expect(form.getValue('name')).toBe('Jane');
+            expect(form.getValue('email')).toBe('jane@example.com');
+        });
+        it('should clear touched state', () => {
+            const builder = new FormBuilder({ name: '', email: '' });
+            const form = builder.form;
+            form.emit('change', 'name', 'Jane');
+            expect(form.get('name').isTouched).toBe(true);
+            form.emit('reset');
+            expect(form.get('name').isTouched).toBe(false);
+        });
+        it('should clear errors', () => {
+            const builder = new FormBuilder({ name: '', email: '' });
+            const form = builder.form;
+            form.emit('errors', { name: 'Required' });
+            expect(form.get('name').error).toBe('Required');
+            form.emit('reset');
+            expect(form.get('name').error).toBe(null);
+        });
+    });
+    describe('once method', () => {
+        it('should trigger handler only once', () => {
+            const builder = new FormBuilder({ name: '' });
+            const form = builder.form;
+            const handler = vi.fn();
+            form.once('change', handler);
+            form.emit('change', 'name', 'First');
+            form.emit('change', 'name', 'Second');
+            expect(handler).toHaveBeenCalledTimes(1);
+            expect(handler).toHaveBeenCalledWith('name', 'First');
+        });
+    });
+    describe('field subscriptions', () => {
+        it('should notify subscriber when field changes', () => {
+            const builder = new FormBuilder({ name: '', email: '' });
+            const form = builder.form;
+            const subscriber = vi.fn();
+            form.subscribeField('name', subscriber);
+            form.emit('change', 'name', 'Jane');
+            expect(subscriber).toHaveBeenCalled();
+        });
+        it('should not notify subscriber for other field changes', () => {
+            const builder = new FormBuilder({ name: '', email: '' });
+            const form = builder.form;
+            const subscriber = vi.fn();
+            form.subscribeField('name', subscriber);
+            form.emit('change', 'email', 'jane@example.com');
+            expect(subscriber).not.toHaveBeenCalled();
+        });
+        it('should allow unsubscribing', () => {
+            const builder = new FormBuilder({ name: '' });
+            const form = builder.form;
+            const subscriber = vi.fn();
+            const unsubscribe = form.subscribeField('name', subscriber);
+            unsubscribe();
+            form.emit('change', 'name', 'Jane');
+            expect(subscriber).not.toHaveBeenCalled();
+        });
+    });
+    describe('getSlice', () => {
+        it('should return only requested fields', () => {
+            const builder = new FormBuilder({
+                name: 'John',
+                email: 'john@example.com',
+                age: 30
+            });
+            const form = builder.form;
+            const slice = form.getSlice(['name', 'email']);
+            expect(slice).toHaveProperty('name');
+            expect(slice).toHaveProperty('email');
+            expect(slice).not.toHaveProperty('age');
+        });
+        it('should include field metadata', () => {
+            const builder = new FormBuilder({ name: 'John' });
+            const form = builder.form;
+            const slice = form.getSlice(['name']);
+            expect(slice.name).toHaveProperty('value', 'John');
+            expect(slice.name).toHaveProperty('error', null);
+            expect(slice.name).toHaveProperty('isTouched', false);
+        });
+    });
+});

package/dist/test/fieldwise.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=fieldwise.test.d.ts.map

package/dist/test/fieldwise.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fieldwise.test.d.ts","sourceRoot":"","sources":["../../src/test/fieldwise.test.tsx"],"names":[],"mappings":""}