@dvirus-js/angular-signals 0.0.1

package/fesm2022/dvirus-js-angular-signals.mjs

@@ -0,0 +1,2192 @@
+import { signal, isSignal, inject, Injector, DestroyRef, effect, untracked, computed } from '@angular/core';
+import { FormGroup, FormArray } from '@angular/forms';
+import { startWith } from 'rxjs';
+
+/**
+ * Converts a plain object into a writable signal object.
+ * Each property of the source object becomes a WritableSignal initialized with the property's value.
+ *
+ * @param src - The source object to convert.
+ * @returns An object with the same keys as the source, but with values wrapped in WritableSignals.
+ */
+function toSignalObj(src) {
+    return Object.entries(src).reduce((prev, [key, value]) => ({ ...prev, [key]: signal(value) }), {});
+}
+/**
+ * Converts a signal object into a plain object.
+ * Each property of the signal object becomes a value from the signal.
+ *
+ * @param src - The signal object to convert.
+ * @returns An object with the same keys as the source, but with values from the signals.
+ */
+function fromSignalObj(src) {
+    return Object.entries(src).reduce((prev, [key, $value]) => ({ ...prev, [key]: signalOrValue($value) }), {});
+}
+/**
+ * Unwraps a value that might be a Signal.
+ * If the input is a Signal, it returns the signal's value.
+ * If the input is a raw value, it returns the value itself.
+ *
+ * @param value - The signal or value to unwrap.
+ * @returns The raw value of type T.
+ */
+function signalOrValue(value) {
+    return isSignal(value) ? value() : value;
+}
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function signalOrFunction(value, ...fnArgs) {
+    let res = value;
+    if (isSignal(res)) {
+        res = res();
+    }
+    if (typeof res == 'function') {
+        res = res(...fnArgs);
+    }
+    return res;
+}
+// function main() {
+//   const signalOrValue1: SignalOrValue<number> = signal(42);
+//   const signalOrValue2: SignalOrValue<string> = 'Hello, World!';
+//   console.log(signalOrValue(signalOrValue1)); // 42
+//   console.log(signalOrValue(signalOrValue2)); // "Hello, World!"
+//   // #############################################################
+//   const signalOrFunction1: SignalOrValue<number> | (() => number) = signal(100);
+//   const signalOrFunction2: SignalOrValue<number> | (() => number) = () => 200;
+//   const signalOrFunction3: SignalOrValue<number> | (() => number) = 300;
+//   const signalOrFunction4: SignalOrValue<number> | ((a: number, b: number) => number) = (a, b) => {
+//     return a + b;
+//   };
+//   console.log(signalOrFunction(signalOrFunction1)); // 100
+//   console.log(signalOrFunction(signalOrFunction2)); // 200
+//   console.log(signalOrFunction(signalOrFunction3)); // 300
+//   console.log(signalOrFunction(signalOrFunction4, 5, 10)); // 15
+//   // #############################################################
+//   const signalObj1: SignalObj<{ a: number; b: string }> = {
+//     a: signal(10),
+//     b: computed(() => 'Test'),
+//   };
+//   console.log(signalObj1); // { a: Signal<number>, b: Signal<string> }
+//   const signalObjWritable1: SignalObjWritable<{ a: number; b: string }> = toSignalObj({
+//     a: 10,
+//     b: 'Test',
+//   });
+//   console.log(signalObjWritable1); // { a: WritableSignal<number>, b: WritableSignal<string> }
+//   const plainObj1 = fromSignalObj(signalObj1);
+//   console.log(plainObj1); // { a: 10, b: 'Test' }
+//   const plainObj2 = fromSignalObj(signalObjWritable1);
+//   console.log(plainObj2); // { a: 10, b: 'Test' }
+// }
+
+/**
+ * Normalizes a validation error object by filtering out empty/null values.
+ *
+ * Converts a raw validation result into a clean error map containing only
+ * non-empty string messages. Filters out undefined, null, and empty strings.
+ *
+ * @param error - Raw validation error object or null
+ * @returns Clean error map with only valid error messages
+ *
+ * @example
+ * ```typescript
+ * normalizeValidationError({ required: 'Error', empty: '', invalid: null });
+ * // Returns: { required: 'Error' }
+ * ```
+ */
+function normalizeValidationError(error) {
+    if (!error)
+        return {};
+    return Object.entries(error).reduce((acc, [key, val]) => {
+        if (typeof val === 'string' && val.length > 0) {
+            acc[key] = val;
+        }
+        return acc;
+    }, {});
+}
+/**
+ * Executes an array of validators and collects all error messages.
+ *
+ * Runs each validator function with the provided context and merges all
+ * error messages into a single error map. Empty/null results are filtered out.
+ *
+ * @template TControls - Object type defining available sibling controls
+ * @template TValue - The type of value being validated
+ *
+ * @param validators - Array of validator functions to execute
+ * @param ctx - Validation context with current value and control accessor
+ * @returns Combined error map from all validators
+ *
+ * @example
+ * ```typescript
+ * const errors = collectValidationErrors(
+ *   [signalFormValidators.required, signalFormValidators.minLength(3)],
+ *   { item: { value: '' }, getControl: () => {} }
+ * );
+ * // Returns: { required: 'This field is required' }
+ * ```
+ */
+function collectValidationErrors(validators, ctx) {
+    if (!validators?.length)
+        return {};
+    return validators.reduce((acc, validator) => {
+        const normalized = normalizeValidationError(validator(ctx));
+        Object.entries(normalized).forEach(([key, val]) => {
+            acc[key] = val;
+        });
+        return acc;
+    }, {});
+}
+/**
+ * Checks if an error map contains any errors.
+ *
+ * Simple utility to determine if a control has validation errors by
+ * checking if the error map object has any keys.
+ *
+ * @param errorMap - Error map to check
+ * @returns True if there are any errors, false if empty
+ *
+ * @example
+ * ```typescript
+ * hasErrors({ required: 'Error' }); // true
+ * hasErrors({}); // false
+ * ```
+ */
+function hasErrors(errorMap) {
+    return Object.keys(errorMap).length > 0;
+}
+/**
+ * Recursively checks if an error tree structure is completely empty.
+ *
+ * Traverses nested error structures (objects and arrays) to determine if
+ * there are any actual error messages anywhere in the tree. Returns true
+ * only when the entire structure contains no errors.
+ *
+ * @param value - Error tree to check (can be nested objects/arrays)
+ * @returns True if no errors exist anywhere in the tree
+ *
+ * @example
+ * ```typescript
+ * isEmptyErrorTree({ name: undefined, address: { street: undefined } }); // true
+ * isEmptyErrorTree({ name: { required: 'Error' } }); // false
+ * isEmptyErrorTree([undefined, undefined]); // true
+ * ```
+ */
+function isEmptyErrorTree(value) {
+    if (value === null || value === undefined)
+        return true;
+    if (Array.isArray(value)) {
+        return value.every(isEmptyErrorTree);
+    }
+    if (typeof value === 'object') {
+        return Object.values(value).every(isEmptyErrorTree);
+    }
+    return false;
+}
+
+/**
+ * Creates a signal-based notifier function.
+ *
+ * Each call to the returned function returns the current notification count.
+ * Calling `notify()` increments the count, triggering any listeners.
+ *
+ * @returns {SignalNotifier} A notifier function with a `notify` method.
+ *
+ * @example
+ * const notifier = signalNotifier();
+ * effect(() => {
+ *   notifier(); // Reacts to notifications
+ * });
+ * notifier.notify(); // Triggers the effect
+ */
+function signalNotifier() {
+    const _signal = signal(0, ...(ngDevMode ? [{ debugName: "_signal" }] : []));
+    function get() {
+        return _signal();
+    }
+    get.notify = () => _signal.update((n) => n + 1);
+    return get;
+}
+
+/**
+ * Main wrapper function to handle promise with try-catch
+ * @template T - Type of the successful result
+ * @template E - Type of the error, defaults to Error
+ * @param {()=> T} fn - The function to handle
+ * @returns {TryResult<T, E>} - A tuple with either the result or the error
+ */
+function tryCatch(fn) {
+    try {
+        const val = fn();
+        return [val, null];
+    }
+    catch (error) {
+        return [null, error];
+    }
+}
+
+/**
+ * Creates a debounced writable signal.
+ *
+ * The returned signal can be written to instantly via its `WritableSignal` interface
+ * **or** through `setDebounced(value)` which delays the commit by `debounceTime` ms.
+ * While a debounced write is pending, `isLoading()` returns `true`.
+ *
+ * If a reactive `params` function is supplied, the signal will also track that
+ * source and debounce upstream changes (requires an injection context).
+ *
+ * @typeParam T - The type of the signal's value.
+ * @param options - Configuration object.
+ * @param options.params - Optional reactive source function whose return value
+ *   is tracked and debounced into the signal.
+ * @param options.debounceTime - Delay in milliseconds before a debounced value
+ *   is committed.
+ * @param options.initialValue - Optional initial value for the signal.
+ * @param options.injector - Optional Angular `Injector` to use for setting up
+ *   reactive tracking. Required if `params` is provided and this function is called
+ *   outside of an injection context.
+ * @returns A `SignalDebounce<T>` instance.
+ *
+ * @example
+ * ```ts
+ * // Simple debounced signal with an initial value
+ * const search = signalDebounce<string>({ debounceTime: 300, initialValue: '' });
+ * search.setDebounced('hello'); // commits after 300 ms
+ *
+ * // Tracking a reactive source
+ * const query = signal('angular');
+ * const debounced = signalDebounce({ params: () => query(), debounceTime: 500 });
+ * ```
+ */
+function signalDebounce(options) {
+    const timeout = signal(null, ...(ngDevMode ? [{ debugName: "timeout" }] : []));
+    const isLoading = signal(false, ...(ngDevMode ? [{ debugName: "isLoading" }] : []));
+    const _sig = signal(options.initialValue);
+    const scheduleDebounce = (value) => {
+        clearPendingTimeout(timeout);
+        isLoading.set(true);
+        timeout.set(setTimeout(() => {
+            isLoading.set(false);
+            _sig.set(value);
+        }, options.debounceTime));
+    };
+    if (options.params) {
+        trackSource({
+            source: options.params,
+            scheduleDebounce,
+            timeout,
+            injector: options.injector,
+        });
+    }
+    return Object.assign(_sig, {
+        setDebounced: scheduleDebounce,
+        isLoading: isLoading.asReadonly(),
+    });
+}
+/**
+ * Clears a pending debounce timeout if one exists.
+ * @internal
+ */
+function clearPendingTimeout(timeout) {
+    const t = timeout();
+    if (t)
+        clearTimeout(t);
+}
+/**
+ * Sets up an effect that tracks a reactive source and debounces its changes.
+ *
+ * Requires an Angular injection context. If called outside one, logs a warning
+ * and returns without setting up tracking (manual `setDebounced` still works).
+ *
+ * @typeParam T - The type of the source value.
+ * @param source - Reactive function to track.
+ * @param scheduleDebounce - Callback that schedules a debounced write.
+ * @param timeout - Shared timeout handle for cleanup on destroy.
+ * @internal
+ */
+function trackSource({ source, scheduleDebounce, timeout, injector }) {
+    if (!isInInjectionContext() && !injector) {
+        console.error('Warning: signalDebounce is being used outside of an injection context. The debounced signal will not update based on the provided signal.\n\n', "Still can be used with manual value updates via setDebounced, but won't react to changes in the provided signal.");
+        return;
+    }
+    const _injector = injector ?? inject(Injector);
+    const destroyRef = _injector.get(DestroyRef) ?? inject(DestroyRef);
+    effect(() => {
+        const val = source();
+        untracked(() => scheduleDebounce(val));
+    }, { injector: _injector });
+    destroyRef.onDestroy(() => clearPendingTimeout(timeout));
+}
+/**
+ * Checks if the current execution context has access to Angular's dependency injection.
+ * @returns `true` when inside an injection context, `false` otherwise.
+ * @internal
+ */
+function isInInjectionContext() {
+    const [, error] = tryCatch(() => inject(DestroyRef));
+    return !error;
+}
+
+function writableSignal(computationOrOptions, maybeOptions) {
+    // Determine if input is a function or options object
+    const isFunction = typeof computationOrOptions === 'function';
+    if (isFunction) {
+        const computation = computationOrOptions;
+        const opts = maybeOptions ?? {};
+        // Create a fresh token whenever the source recomputes, even if the value is equal.
+        const sourceState = computed(() => ({ value: computation() }), { ...(ngDevMode ? { debugName: "sourceState" } : {}), equal: (a, b) => opts.equal ? opts.equal(a.value, b.value) : a.value === b.value });
+        // Manual overrides are only valid for the source-state token they were set against.
+        const override = signal(undefined, ...(ngDevMode ? [{ debugName: "override" }] : []));
+        const result = computed(() => {
+            const state = sourceState();
+            const currentOverride = override();
+            if (currentOverride !== undefined && currentOverride.state === state) {
+                return currentOverride.value;
+            }
+            return state.value;
+        }, { ...(ngDevMode ? { debugName: "result" } : {}), equal: opts.equal });
+        return Object.assign(result, {
+            set(v) {
+                override.set({ state: untracked(sourceState), value: v });
+            },
+            update(updater) {
+                override.set({
+                    state: untracked(sourceState),
+                    value: updater(untracked(result)),
+                });
+            },
+            asReadonly() {
+                return result;
+            },
+        });
+    }
+    else {
+        const opts = computationOrOptions;
+        let previousState;
+        const sourceState = computed(() => ({ value: opts.source() }), ...(ngDevMode ? [{ debugName: "sourceState" }] : []));
+        const override = signal(undefined, ...(ngDevMode ? [{ debugName: "override" }] : []));
+        const result = computed(() => {
+            const state = sourceState();
+            const currentOverride = override();
+            if (currentOverride !== undefined &&
+                currentOverride.state === state) {
+                // Update previous state for next computation
+                previousState = { source: state.value, value: currentOverride.value };
+                return currentOverride.value;
+            }
+            const computedValue = opts.computation(state.value, previousState);
+            // Update previous state for next computation
+            previousState = { source: state.value, value: computedValue };
+            return computedValue;
+        }, { ...(ngDevMode ? { debugName: "result" } : {}), equal: opts.equal });
+        return Object.assign(result, {
+            set(v) {
+                override.set({
+                    state: untracked(sourceState),
+                    value: v,
+                });
+            },
+            update(updater) {
+                override.set({
+                    state: untracked(sourceState),
+                    value: updater(untracked(result)),
+                });
+            },
+            asReadonly() {
+                return result;
+            },
+        });
+    }
+}
+
+/**
+ * Creates a reactive `SignalSet` backed by Angular signals.
+ *
+ * Every mutation creates a new `Set`, so Angular's signal equality check triggers updates.
+ *
+ * @template T The element type. Defaults to `number`.
+ * @param initialValue An optional iterable to seed the set with.
+ * @returns A {@link SignalSet} instance.
+ *
+ * @example
+ * ```ts
+ * const selected = signalSet<number>();
+ * selected.add(1);
+ * selected.toggle(2);
+ * console.log(selected.toArray()); // [1, 2]
+ * selected.toggle(1);
+ * console.log(selected.has(1));    // false
+ * ```
+ */
+function signalSet(initialValue = new Set()) {
+    // writableSignal = linkedSignal 
+    const setSignal = writableSignal(() => new Set(typeof initialValue === 'function' ? initialValue() : initialValue));
+    const toArray = computed(() => Array.from(setSignal()), ...(ngDevMode ? [{ debugName: "toArray" }] : []));
+    return Object.assign(() => setSignal(), {
+        toArray,
+        size: computed(() => setSignal().size),
+        toggle: (id) => {
+            setSignal.update((set) => {
+                const next = new Set(set);
+                if (next.has(id))
+                    next.delete(id);
+                else
+                    next.add(id);
+                return next;
+            });
+        },
+        has: (id) => setSignal().has(id),
+        add: (id) => {
+            setSignal.update((set) => {
+                const next = new Set(set);
+                next.add(id);
+                return next;
+            });
+        },
+        delete: (id) => {
+            setSignal.update((set) => {
+                const next = new Set(set);
+                next.delete(id);
+                return next;
+            });
+        },
+        clear: (values) => {
+            setSignal.set(new Set(values));
+        },
+        toString: () => {
+            return `SignalSet(${toArray().join(', ')})`;
+        },
+        toJSON: () => {
+            return toArray();
+        },
+    });
+}
+
+/**
+ * if an object have Symbol.iterator, treat it as Iterable<[K, V]>
+ * @param value Iterable<[K, V]> or Record<ToKey<K>, V>
+ * @returns Iterable<[K, V]>
+ */
+function getIterable(value) {
+    if (Symbol.iterator in Object(value)) {
+        return value;
+    }
+    else {
+        return Object.entries(value);
+    }
+}
+/**
+ * Creates a reactive `SignalMap` backed by Angular signals.
+ *
+ * Every mutation creates a new `Map`, so Angular's signal equality check triggers updates.
+ * Accepts either an iterable of `[key, value]` pairs or a plain object as the initial value.
+ *
+ * @template K The key type. Defaults to `string`.
+ * @template V The value type. Defaults to `unknown`.
+ * @param initialValue An optional iterable of entries or a plain object to seed the map.
+ * @returns A {@link SignalMap} instance.
+ *
+ * @example
+ * ```ts
+ * const cache = signalMap<string, number>({ a: 1, b: 2 });
+ * cache.set('c', 3);
+ * console.log(cache.keys());   // ['a', 'b', 'c']
+ * cache.delete('a');            // true
+ * console.log(cache.toJSON());  // {b:2,c:3}
+ * ```
+ */
+function signalMap(initialValue = new Map()) {
+    // writableSignal = linkedSignal 
+    const mapSignal = writableSignal(() => {
+        const _val = typeof initialValue === 'function' ? initialValue() : initialValue;
+        const init = getIterable(_val);
+        return new Map(init);
+    });
+    const entries = computed(() => Array.from(mapSignal().entries()), ...(ngDevMode ? [{ debugName: "entries" }] : []));
+    const keys = computed(() => Array.from(mapSignal().keys()), ...(ngDevMode ? [{ debugName: "keys" }] : []));
+    const values = computed(() => Array.from(mapSignal().values()), ...(ngDevMode ? [{ debugName: "values" }] : []));
+    const size = computed(() => mapSignal().size, ...(ngDevMode ? [{ debugName: "size" }] : []));
+    return Object.assign(() => mapSignal(), {
+        entries,
+        keys,
+        values,
+        size,
+        get: (key) => mapSignal().get(key),
+        has: (key) => mapSignal().has(key),
+        set: (key, value) => {
+            mapSignal.update((map) => {
+                const next = new Map(map);
+                next.set(key, value);
+                return next;
+            });
+            return mapSignal();
+        },
+        delete: (key) => {
+            let deleted = false;
+            mapSignal.update((map) => {
+                const next = new Map(map);
+                deleted = next.delete(key);
+                return next;
+            });
+            return deleted;
+        },
+        clear: (values) => {
+            mapSignal.set(new Map(values ? getIterable(values) : undefined));
+        },
+        toString: () => {
+            return `SignalMap(${entries()
+                .map(([k, v]) => `${k} => ${v}`)
+                .join(', ')})`;
+        },
+        toJSON: () => {
+            return Object.fromEntries(entries());
+        },
+        toObject: () => {
+            return Object.fromEntries(entries());
+        },
+    });
+}
+
+const SIGNAL_OBJECT = Symbol('SignalObject');
+/**
+ * A reactive object backed by Angular signals.
+ * Each property is stored as a WritableSignal, so reads are tracked
+ * by Angular's reactive system (templates, computed, effect).
+ *
+ * Usage:
+ *   const person = signalObject({ name: 'dvirus', age: 30 });
+ *   person.name;              // reads the signal → 'dvirus' (tracked)
+ *   person['name'] = 'new';   // sets the signal (triggers reactivity)
+ *   person.age;               // reads the signal → 30 (tracked)
+ */
+class _SignalObject {
+    [SIGNAL_OBJECT] = true;
+    #signals = new Map();
+    #version = signal(0, ...(ngDevMode ? [{ debugName: "#version" }] : []));
+    #boundCache = new Map();
+    constructor(initialValue) {
+        for (const [key, value] of Object.entries(initialValue)) {
+            this.#signals.set(key, signal(value));
+        }
+        // Use a function as the proxy target so the `apply` trap works (makes it callable).
+        // All traps delegate to `self` (the real class instance) for property/signal access.
+        // eslint-disable-next-line @typescript-eslint/no-this-alias
+        const self = this;
+        // eslint-disable-next-line @typescript-eslint/no-empty-function
+        const callable = (() => { });
+        return new Proxy(callable, {
+            apply() {
+                return self.$snapshot();
+            },
+            get(_, prop) {
+                // Symbols & class own members go through normally
+                if (typeof prop === 'symbol' || prop in self) {
+                    const value = Reflect.get(self, prop, self);
+                    // Bind methods to the real target so private fields (#signals) work.
+                    // Cache the bound function so the same reference is returned each time
+                    // (important for Angular signal identity tracking on $snapshot).
+                    if (typeof value === 'function') {
+                        let bound = self.#boundCache.get(prop);
+                        if (!bound) {
+                            bound = value.bind(self);
+                            self.#boundCache.set(prop, bound);
+                        }
+                        return bound;
+                    }
+                    return value;
+                }
+                // Read the signal — this is tracked by Angular's reactive context
+                return self.#signals.get(prop)?.();
+            },
+            set(_, prop, value) {
+                if (typeof prop === 'symbol' || prop in self) {
+                    return Reflect.set(self, prop, value);
+                }
+                const existing = self.#signals.get(prop);
+                if (existing) {
+                    existing.set(value);
+                }
+                else {
+                    // Dynamic property — create a new signal and bump version
+                    self.#signals.set(prop, signal(value));
+                    self.#version.update((v) => v + 1);
+                }
+                return true;
+            },
+            has(_, prop) {
+                if (typeof prop === 'string' && self.#signals.has(prop)) {
+                    return true;
+                }
+                return Reflect.has(self, prop);
+            },
+            ownKeys() {
+                return Array.from(self.#signals.keys());
+            },
+            getOwnPropertyDescriptor(_, prop) {
+                if (typeof prop === 'string' && self.#signals.has(prop)) {
+                    return {
+                        configurable: true,
+                        enumerable: true,
+                        writable: true,
+                        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                        value: self.#signals.get(prop)(),
+                    };
+                }
+                return Reflect.getOwnPropertyDescriptor(self, prop);
+            },
+        });
+    }
+    /**
+     * A computed signal that returns a plain snapshot of all properties.
+     * Reading this tracks ALL properties — so any property change triggers reactivity.
+     *
+     * Usage:
+     *   effect(() => console.log(person.$snapshot()));
+     *   // logs whenever ANY property changes
+     */
+    $snapshot = computed(() => {
+        this.#version(); // track structural changes (new/removed props)
+        return this.toJSON();
+    }, ...(ngDevMode ? [{ debugName: "$snapshot" }] : []));
+    /**
+     * Spreads one or more objects (plain or reactive) into this SignalObject.
+     * Mimics `Object.assign(this, ...sources)` / `{ ...this, ...a, ...b }`.
+     *
+     * - Existing keys → updates the signal (triggers reactivity)
+     * - New keys → creates a new signal and bumps the version
+     * - Accepts plain objects and ReactiveObjects interchangeably
+     *
+     * @example
+     *   const person = signalObject({ name: 'dvirus' });
+     *   person.$assign({ age: 30 }, otherSignalObj);
+     */
+    $assign(...sources) {
+        for (const source of sources) {
+            const entries = isSignalObject(source)
+                ? Object.entries(source.$snapshot())
+                : Object.entries(source);
+            for (const [key, value] of entries) {
+                const existing = this.#signals.get(key);
+                if (existing) {
+                    existing.set(value);
+                }
+                else {
+                    this.#signals.set(key, signal(value));
+                }
+            }
+        }
+        this.#version.update((v) => v + 1);
+    }
+    toJSON() {
+        const result = {};
+        for (const [key, sig] of this.#signals) {
+            result[key] = sig();
+        }
+        return result;
+    }
+    toString() {
+        return JSON.stringify(this.toJSON());
+    }
+}
+/**
+ * Creates a reactive object backed by Angular signals.
+ *
+ * Every property is stored as a `WritableSignal`. Reading a property
+ * (e.g. `obj.name` or `obj['name']`) calls the signal — so it's
+ * automatically tracked in templates, `computed()`, and `effect()`.
+ * Setting a property calls `signal.set()`, which triggers reactivity.
+ *
+ * @param initialValue - The plain object to make reactive
+ * @returns A `SignalObject<T>` proxy with reactive property access, `$snapshot`, and `$assign`
+ *
+ * @example
+ * // In a component:
+ * protected person = signalObject({ name: 'dvirus', age: 30 });
+ *
+ * // In the template (reactive — updates automatically):
+ * // {{ person.name }}
+ *
+ * // In the class:
+ * person.name = 'changed';   // triggers re-render
+ * person['age'] = 31;        // triggers re-render
+ *
+ * // Spread (plain snapshot):
+ * const copy = { ...person }; // { name: 'changed', age: 31 }
+ *
+ * // Track all properties reactively:
+ * effect(() => console.log(person.$snapshot()));
+ */
+function signalObject(initialValue) {
+    return new _SignalObject(initialValue);
+}
+/**
+ * Type guard — checks if a value is a reactive SignalObject proxy.
+ *
+ * @example
+ * isSignalObject(signalObject({ a: 1 })); // true
+ * isSignalObject({ a: 1 });               // false
+ * isSignalObject({ ...signalObject({ a: 1 }) }); // false (spread = plain copy)
+ */
+function isSignalObject(value) {
+    return (typeof value === 'object' &&
+        value !== null &&
+        value[SIGNAL_OBJECT] === true);
+}
+/**
+ * Reactively merges multiple SignalObjects (like `{ ...a, ...b }`).
+ * Returns a `Signal` that re-evaluates whenever any source property changes.
+ * Later sources win on key conflicts, just like spread.
+ *
+ * same as `computed(() => ({ ...a, ...b }))`
+ * but with proper tracking of nested properties and support for non-reactive objects as sources.
+ *
+ * @example
+ * const objA = signalObject({ name: 'dvirus', role: 'dev' });
+ * const objB = signalObject({ age: 30, role: 'admin' });
+ * const merged = mergeSignalObjects(objA, objB);
+ * merged(); // { name: 'dvirus', role: 'admin', age: 30 }
+ */
+function mergeSignalObjects(...sources) {
+    return computed(() => {
+        let result = {};
+        for (const source of sources) {
+            // Spreading a SignalObject triggers its Proxy traps (ownKeys + getOwnPropertyDescriptor),
+            // which reads every signal — so it's automatically tracked by Angular's reactive context.
+            // Plain objects are just spread normally.
+            result = { ...result, ...source };
+        }
+        return result;
+    });
+}
+
+/**
+ * Creates a {@link ControlSignal} that mirrors an `AbstractControl`'s
+ * reactive state as Angular signals.
+ *
+ * **Important:** If called outside an injection context, you must manually handle
+ * un-subscription by either:
+ * - Calling the `unsubscribe()` method on the returned {@link ControlSignal}, or
+ * - Passing a `DestroyRef` via the `options` parameter for automatic cleanup.
+ *
+ * If called within an injection context without providing a `DestroyRef`, the
+ * subscriptions will be automatically cleaned up on component destruction.
+ *
+ * @template T - The value type of the form control.
+ * @param control - The form control or a signal wrapping one.
+ * @param options - Optional configuration object containing:
+ *   - `destroyRef`: A `DestroyRef` used for automatic cleanup on destruction.
+ *     If not provided, the function will attempt to inject one from the current
+ *     injection context. If neither is available, manual un-subscription is required.
+ * @returns A {@link ControlSignal} exposing the control's state as signals.
+ * @throws If `control` is a signal and no `Injector` is available.
+ */
+function controlSignal(control, options) {
+    const destroyRef = options?.destroyRef ??
+        tryCatch(() => inject(DestroyRef, { optional: true }))[0];
+    let subscriptions = [];
+    const unsubscribe = () => {
+        subscriptions.forEach((s) => s.unsubscribe());
+        subscriptions = [];
+    };
+    // cleanUp
+    unsubscribe();
+    destroyRef?.onDestroy(() => unsubscribe());
+    const $value = signal(undefined, ...(ngDevMode ? [{ debugName: "$value" }] : []));
+    const $status = signal(undefined, ...(ngDevMode ? [{ debugName: "$status" }] : []));
+    const _events = signal(null, ...(ngDevMode ? [{ debugName: "_events" }] : []));
+    const $events = writableSignal(() => {
+        $value();
+        $status();
+        return _events();
+    });
+    subscriptions.push(control.valueChanges
+        .pipe(startWith(control.value))
+        .subscribe((x) => untracked(() => $value.set(x))), control.statusChanges
+        .pipe(startWith(control.status))
+        .subscribe((x) => untracked(() => $status.set(x))));
+    // Subscribe to control.events if available (Angular v18+)
+    const ctrl = control;
+    if (ctrl.events && typeof ctrl.events.subscribe === 'function') {
+        subscriptions.push(ctrl.events.subscribe((x) => untracked(() => {
+            _events.set(x);
+        })));
+    }
+    const invalid = computed(() => ($status(), control.invalid), ...(ngDevMode ? [{ debugName: "invalid" }] : []));
+    const touched = computed(() => ($events(), control.touched), ...(ngDevMode ? [{ debugName: "touched" }] : []));
+    const errors = computed(() => ($events(), control.errors), ...(ngDevMode ? [{ debugName: "errors" }] : []));
+    return {
+        control: control,
+        value: computed(() => {
+            $value();
+            $events();
+            return control.value;
+        }),
+        status: $status.asReadonly(),
+        events: $events.asReadonly(),
+        invalid: invalid,
+        errors: errors,
+        touched: touched,
+        valid: computed(() => ($status(), control.valid)),
+        dirty: computed(() => ($events(), control.dirty)),
+        disabled: computed(() => ($status(), control.disabled)),
+        touchedAndInvalid: computed(() => touched() && invalid()),
+        firstErrorKey: computed(() => Object.keys(errors() ?? {})[0] ?? null),
+        validators: computed(() => ($events(), control.validator?.({}) ?? null)),
+        unsubscribe: () => unsubscribe(),
+    };
+}
+/**
+ * Creates a {@link FormGroupSignal} for a `FormGroup`. Child controls are
+ * converted recursively, so nested `FormGroup` and `FormArray` structures
+ * are supported.
+ *
+ * @template TControls - A typed map of control names to `AbstractControl` instances.
+ * @param formGroup - The `FormGroup` to wrap.
+ * @param options - Optional `DestroyRef` and `Injector` forwarded to
+ *   each underlying {@link controlSignal} call.
+ * @returns A {@link FormGroupSignal} with both group-level and per-control signals.
+ */
+function formGroupSignal(formGroup, options) {
+    const destroyRef = options?.destroyRef ??
+        tryCatch(() => inject(DestroyRef, { optional: true }))[0];
+    const controls = Object.fromEntries(Object.entries(formGroup.controls).map(([key, ctrl]) => {
+        return [key, nestedControlSignal(ctrl, { destroyRef })];
+    }));
+    const groupSignal = controlSignal(formGroup);
+    const selfUnsubscribe = groupSignal.unsubscribe.bind(groupSignal);
+    return Object.assign(groupSignal, {
+        controls,
+        unsubscribe: () => {
+            selfUnsubscribe();
+            Object.values(controls).forEach((c) => c.unsubscribe());
+        },
+    });
+}
+/**
+ * Creates a {@link FormArraySignal} for a `FormArray`. Child controls are
+ * converted recursively, so arrays of `FormGroup`, arrays of `FormArray`,
+ * and arrays of `FormControl` are all supported.
+ */
+function formArraySignal(formArray, options) {
+    const destroyRef = options?.destroyRef ??
+        tryCatch(() => inject(DestroyRef, { optional: true }))[0];
+    const controls = formArray.controls.map((ctrl) => nestedControlSignal(ctrl, { destroyRef }));
+    const arraySignal = controlSignal(formArray);
+    const selfUnsubscribe = arraySignal.unsubscribe.bind(arraySignal);
+    return Object.assign(arraySignal, {
+        controls,
+        unsubscribe: () => {
+            selfUnsubscribe();
+            controls.forEach((c) => c.unsubscribe());
+        },
+    });
+}
+function nestedControlSignal(control, options) {
+    if (control instanceof FormGroup) {
+        return formGroupSignal(control, options);
+    }
+    if (control instanceof FormArray) {
+        return formArraySignal(control, options);
+    }
+    return controlSignal(control, options);
+}
+
+/**
+ * Shared empty error map object to avoid creating new objects.
+ *
+ * @internal
+ */
+const EMPTY_ERROR_MAP = {};
+/**
+ * Checks if a value is a plain JavaScript object (not array, not null, not class instance).
+ *
+ * @internal
+ * @param value - Value to check
+ * @returns True if value is a plain object
+ */
+function isPlainObject(value) {
+    if (!value || typeof value !== 'object')
+        return false;
+    const proto = Object.getPrototypeOf(value);
+    return proto === Object.prototype || proto === null;
+}
+/**
+ * Checks if an object contains any Angular signal values.
+ *
+ * @internal
+ * @param obj - Object to check for signal values
+ * @returns True if any property value is a signal
+ */
+function hasSignalValues(obj) {
+    return Object.values(obj).some((value) => isSignal(value));
+}
+/**
+ * Resolves a SignalOrValue to its actual value, handling nested signal objects.
+ *
+ * If the resolved value is a plain object containing signals, it converts
+ * all signal properties to their values using fromSignalObj.
+ *
+ * @internal
+ * @template TValue - The type of value to resolve
+ * @param value - Signal or static value to resolve
+ * @returns The resolved value
+ */
+function resolveControlValue(value) {
+    const resolved = signalOrValue(value);
+    if (isPlainObject(resolved) && hasSignalValues(resolved)) {
+        return fromSignalObj(resolved);
+    }
+    return resolved;
+}
+/**
+ * Normalizes various control input formats to a standard SignalFormControlConfig.
+ *
+ * Handles three input types:
+ * - SignalFormControl: extracts current value
+ * - Config object with 'value' property: uses as-is
+ * - Raw value: wraps in config object
+ *
+ * @internal
+ * @template TValue - The type of control value
+ * @template TControls - Object type defining available sibling controls
+ * @param input - Input in any accepted format
+ * @returns Normalized control configuration
+ */
+function normalizeControlInput(input) {
+    if (isSignalFormControl(input)) {
+        return { value: input.value() };
+    }
+    if (typeof input === 'object' && input !== null && 'value' in input) {
+        return input;
+    }
+    return { value: input };
+}
+/**
+ * Type guard to check if an object is a SignalFormControl.
+ *
+ * @template TValue - The type of value the control manages
+ * @param obj - Object to check
+ * @returns True if obj is a SignalFormControl
+ *
+ * @example
+ * ```typescript
+ * if (isSignalFormControl(value)) {
+ *   console.log(value.value()); // TypeScript knows this is a control
+ * }
+ * ```
+ */
+function isSignalFormControl(obj) {
+    return (!!obj &&
+        typeof obj === 'object' &&
+        obj.kind === 'control');
+}
+/**
+ * Creates a reactive form control with signal-based state management.
+ *
+ * Builds a control that wraps a primitive value (string, number, boolean, etc.)
+ * with validation, state tracking, and reactive updates using Angular signals.
+ *
+ * Features:
+ * - Reactive value updates through signals
+ * - Validators for errors (mark control as invalid)
+ * - Warnings (validation messages without invalidating)
+ * - Dynamic disabled state based on form context
+ * - State tracking (touched, dirty)
+ * - Manual error/warning management
+ *
+ * @template TControls - Object type defining available sibling controls for cross-field validation
+ * @template TValue - The type of value this control manages
+ *
+ * @param input - Control input (raw value, config object, or existing control)
+ * @param getControl - Optional accessor function for sibling controls
+ * @returns Fully configured SignalFormControl instance
+ *
+ * @example
+ * ```typescript
+ * // Simple control
+ * const nameControl = createSignalFormControl('John');
+ *
+ * // With validators
+ * const ageControl = createSignalFormControl({
+ *   value: 25,
+ *   validators: [signalFormValidators.required, signalFormValidators.min(0)],
+ *   warnings: [signalFormValidators.max(120)]
+ * });
+ *
+ * // With dynamic disabled
+ * const emailControl = createSignalFormControl({
+ *   value: '',
+ *   disabled: (ctx) => ctx.getControl('accountType').value() === 'guest'
+ * });
+ * ```
+ */
+function createSignalFormControl(input, getControl) {
+    if (isSignalFormControl(input)) {
+        return input;
+    }
+    const config = normalizeControlInput(input);
+    const accessControl = getControl ??
+        (() => {
+            throw new Error('getControl is not available for this control.');
+        });
+    const initialValue = resolveControlValue(config.value);
+    const value = writableSignal(() => resolveControlValue(config.value));
+    const manualErrors = signal({}, ...(ngDevMode ? [{ debugName: "manualErrors" }] : []));
+    const manualWarnings = signal({}, ...(ngDevMode ? [{ debugName: "manualWarnings" }] : []));
+    const selfTouched = signal(false, ...(ngDevMode ? [{ debugName: "selfTouched" }] : []));
+    const selfDirty = signal(false, ...(ngDevMode ? [{ debugName: "selfDirty" }] : []));
+    const selfDisabled = signal(false, ...(ngDevMode ? [{ debugName: "selfDisabled" }] : []));
+    const disabledResolver = config.disabled;
+    const disabled = computed(() => {
+        const derived = typeof disabledResolver === 'function'
+            ? disabledResolver({
+                item: { value: value() },
+                getControl: accessControl,
+            })
+            : disabledResolver
+                ? signalOrValue(disabledResolver)
+                : false;
+        return selfDisabled() || derived;
+    }, ...(ngDevMode ? [{ debugName: "disabled" }] : []));
+    const errors = computed(() => {
+        if (disabled())
+            return EMPTY_ERROR_MAP;
+        const ctx = {
+            item: { value: value() },
+            getControl: accessControl,
+        };
+        return {
+            ...collectValidationErrors(config.validators, ctx),
+            ...manualErrors(),
+        };
+    }, ...(ngDevMode ? [{ debugName: "errors" }] : []));
+    const warnings = computed(() => {
+        if (disabled())
+            return EMPTY_ERROR_MAP;
+        const ctx = {
+            item: { value: value() },
+            getControl: accessControl,
+        };
+        return {
+            ...collectValidationErrors(config.warnings, ctx),
+            ...manualWarnings(),
+        };
+    }, ...(ngDevMode ? [{ debugName: "warnings" }] : []));
+    const invalid = computed(() => !disabled() && hasErrors(errors()), ...(ngDevMode ? [{ debugName: "invalid" }] : []));
+    const valid = computed(() => !invalid(), ...(ngDevMode ? [{ debugName: "valid" }] : []));
+    const firstError = computed(() => {
+        const entries = Object.entries(errors());
+        if (!entries.length)
+            return undefined;
+        const [name, message] = entries[0] ?? ['', ''];
+        return { name, message, type: 'error' };
+    }, ...(ngDevMode ? [{ debugName: "firstError" }] : []));
+    const firstWarning = computed(() => {
+        const entries = Object.entries(warnings());
+        if (!entries.length)
+            return undefined;
+        const [name, message] = entries[0] ?? ['', ''];
+        return { name, message, type: 'warning' };
+    }, ...(ngDevMode ? [{ debugName: "firstWarning" }] : []));
+    const firstErrorOrWarning = computed(() => {
+        return firstError() ?? firstWarning();
+    }, ...(ngDevMode ? [{ debugName: "firstErrorOrWarning" }] : []));
+    const setValue = (next, options) => {
+        value.set(next);
+        if (options?.markDirty ?? true)
+            selfDirty.set(true);
+        if (options?.markTouched)
+            selfTouched.set(true);
+    };
+    const reset = (next) => {
+        value.set(next ?? initialValue);
+        selfDirty.set(false);
+        selfTouched.set(false);
+        manualErrors.set({});
+        manualWarnings.set({});
+    };
+    return {
+        kind: 'control',
+        value,
+        disabled,
+        touched: computed(() => selfTouched()),
+        dirty: computed(() => selfDirty()),
+        errors,
+        warnings,
+        selfErrors: errors,
+        selfWarnings: warnings,
+        invalid,
+        valid,
+        firstError,
+        firstWarning,
+        firstErrorOrWarning,
+        setValue,
+        reset,
+        markTouched: () => selfTouched.set(true),
+        markUntouched: () => selfTouched.set(false),
+        markDirty: () => selfDirty.set(true),
+        markPristine: () => selfDirty.set(false),
+        setDisabled: (next) => selfDisabled.set(next),
+        setError: (key, message) => manualErrors.update((current) => ({ ...current, [key]: message })),
+        clearError: (key) => manualErrors.update((current) => {
+            // eslint-disable-next-line @typescript-eslint/no-unused-vars
+            const { [key]: _removed, ...rest } = current;
+            return rest;
+        }),
+        clearErrors: () => manualErrors.set({}),
+        setWarning: (key, message) => manualWarnings.update((current) => ({ ...current, [key]: message })),
+        clearWarning: (key) => manualWarnings.update((current) => {
+            // eslint-disable-next-line @typescript-eslint/no-unused-vars
+            const { [key]: _removed, ...rest } = current;
+            return rest;
+        }),
+        clearWarnings: () => manualWarnings.set({}),
+    };
+}
+
+/**
+ * Set of valid keys for control configuration objects.
+ * Used to distinguish config objects from plain value objects.
+ *
+ * @internal
+ */
+const CONTROL_CONFIG_KEYS$1 = new Set([
+    'value',
+    'validators',
+    'warnings',
+    'disabled',
+]);
+/**
+ * Checks if a value is a control configuration object.
+ *
+ * Determines if the value has a 'value' property and only contains
+ * valid control config keys (value, validators, warnings, disabled).
+ *
+ * @internal
+ * @param value - Value to check
+ * @returns True if value is a control config object
+ */
+function isControlConfig$1(value) {
+    if (!value || typeof value !== 'object')
+        return false;
+    if (!('value' in value))
+        return false;
+    return Object.keys(value).every(key => CONTROL_CONFIG_KEYS$1.has(key));
+}
+/**
+ * Creates the appropriate control node from various input types.
+ *
+ * Recursively determines and creates the correct control type:
+ * - Existing controls are returned as-is
+ * - Arrays become SignalFormArray
+ * - Objects (non-config) become SignalForm (group)
+ * - Primitives/configs become SignalFormControl
+ *
+ * @internal
+ * @template TValue - The type of value to create a control for
+ * @template TControls - Object type defining available sibling controls
+ * @param input - Input value in any accepted format
+ * @param getControl - Accessor for sibling controls
+ * @returns Appropriate control type for the input
+ */
+function createNodeFromInput$1(input, getControl) {
+    if (isSignalFormControl(input)) {
+        return input;
+    }
+    if (isSignalFormGroup(input)) {
+        return input;
+    }
+    if (isSignalFormArray(input)) {
+        return input;
+    }
+    if (Array.isArray(input)) {
+        return createSignalFormArray(input, getControl);
+    }
+    if (typeof input === 'object' && input !== null && !isControlConfig$1(input)) {
+        return createSignalFormGroup(input);
+    }
+    return createSignalFormControl(input, getControl);
+}
+/**
+ * Type guard to check if an object is a SignalForm (form group).
+ *
+ * @template TData - Object type defining the form structure
+ * @param obj - Object to check
+ * @returns True if obj is a SignalForm
+ *
+ * @example
+ * ```typescript
+ * if (isSignalFormGroup(value)) {
+ *   console.log(value.controls.name); // TypeScript knows this is a form group
+ * }
+ * ```
+ */
+function isSignalFormGroup(obj) {
+    return (!!obj &&
+        typeof obj === 'object' &&
+        obj.kind === 'group');
+}
+/**
+ * Creates a reactive form group for managing structured form data.
+ *
+ * Builds a typed form container that holds multiple named controls, groups, or arrays.
+ * Each property in the input object becomes a control with full signal-based reactivity.
+ * Provides type-safe access to controls and tracks collective validation state.
+ *
+ * Features:
+ * - Type-safe control access via `.controls` property
+ * - Reactive value and error tracking across all controls
+ * - Collective state management (touched, dirty, valid)
+ * - Manual error/warning management at group level
+ * - Support for nested groups and arrays
+ * - Cross-field validation via getControl accessor
+ *
+ * @template TData - Object type defining the structure and types of all controls
+ *
+ * @param inputs - Object mapping property names to their control inputs
+ * @returns Fully configured SignalForm instance
+ *
+ * @example
+ * ```typescript
+ * // Simple form
+ * const form = createSignalFormGroup({
+ *   name: 'John',
+ *   age: 25
+ * });
+ *
+ * // With validators and nested structure
+ * const form = createSignalFormGroup<User>({
+ *   email: {
+ *     value: '',
+ *     validators: [signalFormValidators.required, signalFormValidators.email]
+ *   },
+ *   age: {
+ *     value: 25,
+ *     validators: [signalFormValidators.min(0)],
+ *     warnings: [signalFormValidators.max(120)]
+ *   },
+ *   address: {
+ *     street: '123 Main St',
+ *     city: 'NYC'
+ *   },
+ *   hobbies: ['coding', 'gaming']
+ * });
+ *
+ * // Access controls
+ * form.controls.email.value(); // Type-safe access
+ * form.getControl('age').setValue(30);
+ * ```
+ */
+function createSignalFormGroup(inputs) {
+    const controls = {};
+    const getControl = key => controls[key];
+    Object.entries(inputs).forEach(([key, value]) => {
+        controls[key] = createNodeFromInput$1(value, getControl);
+    });
+    const selfDirty = signal(false, ...(ngDevMode ? [{ debugName: "selfDirty" }] : []));
+    const selfTouched = signal(false, ...(ngDevMode ? [{ debugName: "selfTouched" }] : []));
+    const selfDisabled = signal(false, ...(ngDevMode ? [{ debugName: "selfDisabled" }] : []));
+    const manualErrors = signal({}, ...(ngDevMode ? [{ debugName: "manualErrors" }] : []));
+    const manualWarnings = signal({}, ...(ngDevMode ? [{ debugName: "manualWarnings" }] : []));
+    const value = computed(() => {
+        return Object.entries(controls).reduce((acc, [key, control]) => {
+            acc[key] = control.value();
+            return acc;
+        }, {});
+    }, ...(ngDevMode ? [{ debugName: "value" }] : []));
+    const errors = computed(() => {
+        const all = {};
+        Object.entries(controls).forEach(([key, control]) => {
+            if (control.kind === 'control') {
+                const map = control.errors();
+                all[key] = (hasErrors(map) ? map : undefined);
+                return;
+            }
+            const childErrors = control.errors();
+            all[key] = (isEmptyErrorTree(childErrors) ? undefined : childErrors);
+        });
+        return all;
+    }, ...(ngDevMode ? [{ debugName: "errors" }] : []));
+    const warnings = computed(() => {
+        const all = {};
+        Object.entries(controls).forEach(([key, control]) => {
+            if (control.kind === 'control') {
+                const map = control.warnings();
+                all[key] = (hasErrors(map) ? map : undefined);
+                return;
+            }
+            const childWarnings = control.warnings();
+            all[key] = (isEmptyErrorTree(childWarnings) ? undefined : childWarnings);
+        });
+        return all;
+    }, ...(ngDevMode ? [{ debugName: "warnings" }] : []));
+    const selfErrors = computed(() => {
+        if (selfDisabled())
+            return {};
+        return { ...manualErrors() };
+    }, ...(ngDevMode ? [{ debugName: "selfErrors" }] : []));
+    const selfWarnings = computed(() => {
+        if (selfDisabled())
+            return {};
+        return { ...manualWarnings() };
+    }, ...(ngDevMode ? [{ debugName: "selfWarnings" }] : []));
+    const invalid = computed(() => {
+        if (selfDisabled())
+            return false;
+        return (hasErrors(selfErrors()) ||
+            Object.values(controls).some(control => control.invalid()));
+    }, ...(ngDevMode ? [{ debugName: "invalid" }] : []));
+    const valid = computed(() => !invalid(), ...(ngDevMode ? [{ debugName: "valid" }] : []));
+    const touched = computed(() => selfTouched() ||
+        Object.values(controls).some(control => control.touched()), ...(ngDevMode ? [{ debugName: "touched" }] : []));
+    const dirty = computed(() => selfDirty() ||
+        Object.values(controls).some(control => control.dirty()), ...(ngDevMode ? [{ debugName: "dirty" }] : []));
+    const setValue = (nextValues, options) => {
+        Object.entries(nextValues).forEach(([key, nextValue]) => {
+            const control = controls[key];
+            control?.setValue(nextValue, options);
+        });
+        if (options?.markDirty ?? true)
+            selfDirty.set(true);
+        if (options?.markTouched)
+            selfTouched.set(true);
+    };
+    const reset = (nextValues) => {
+        if (nextValues) {
+            setValue(nextValues, { markDirty: false });
+        }
+        else {
+            Object.values(controls).forEach(control => control.reset());
+        }
+        selfDirty.set(false);
+        selfTouched.set(false);
+        manualErrors.set({});
+        manualWarnings.set({});
+    };
+    const setDisabled = (disabled, options) => {
+        selfDisabled.set(disabled);
+        if (!options?.onlySelf) {
+            Object.values(controls).forEach(control => control.setDisabled(disabled));
+        }
+    };
+    return {
+        kind: 'group',
+        controls,
+        value,
+        errors,
+        warnings,
+        selfErrors,
+        selfWarnings,
+        disabled: computed(() => selfDisabled()),
+        touched,
+        dirty,
+        invalid,
+        valid,
+        getControl,
+        setValue,
+        reset,
+        markTouched: () => selfTouched.set(true),
+        markUntouched: () => selfTouched.set(false),
+        markDirty: () => selfDirty.set(true),
+        markPristine: () => selfDirty.set(false),
+        markAllTouched: () => Object.values(controls).forEach(control => control.markTouched()),
+        setDisabled,
+        setError: (key, message) => manualErrors.update(current => ({ ...current, [key]: message })),
+        clearError: (key) => manualErrors.update(current => {
+            // eslint-disable-next-line @typescript-eslint/no-unused-vars
+            const { [key]: _removed, ...rest } = current;
+            return rest;
+        }),
+        clearErrors: () => manualErrors.set({}),
+        setWarning: (key, message) => manualWarnings.update(current => ({ ...current, [key]: message })),
+        clearWarning: (key) => manualWarnings.update(current => {
+            // eslint-disable-next-line @typescript-eslint/no-unused-vars
+            const { [key]: _removed, ...rest } = current;
+            return rest;
+        }),
+        clearWarnings: () => manualWarnings.set({}),
+    };
+}
+/**
+ * Helper function to create a standalone form control.
+ *
+ * Creates a control without sibling control access. Useful for creating
+ * individual controls outside of a form group context.
+ *
+ * @template TValue - The type of value the control manages
+ * @param input - Control input (raw value, config object, or existing control)
+ * @returns SignalFormControl instance
+ *
+ * @example
+ * ```typescript
+ * const nameControl = formControl('John');
+ * const ageControl = formControl({
+ *   value: 25,
+ *   validators: [signalFormValidators.min(0)]
+ * });
+ * ```
+ */
+function formControl(input) {
+    return createSignalFormControl(input, undefined);
+}
+/**
+ * Helper function to create a standalone form array.
+ *
+ * Creates an array without sibling control access. Useful for creating
+ * array controls outside of a form group context.
+ *
+ * @template TValue - The type of each item in the array
+ * @param input - Array of initial items
+ * @returns SignalFormArray instance
+ *
+ * @example
+ * ```typescript
+ * const tagsArray = formArray(['tag1', 'tag2', 'tag3']);
+ * const addressesArray = formArray<Address>([
+ *   { street: '123 Main', city: 'NYC' }
+ * ]);
+ * ```
+ */
+function formArray(input) {
+    return createSignalFormArray(input, undefined);
+}
+/**
+ * Helper function to create a form group.
+ *
+ * Alias for createSignalFormGroup. Creates a typed form with multiple controls.
+ *
+ * @template TData - Object type defining the form structure
+ * @param input - Object mapping property names to control inputs
+ * @returns SignalForm instance
+ *
+ * @example
+ * ```typescript
+ * const form = formGroup({
+ *   name: 'John',
+ *   email: {
+ *     value: 'john@example.com',
+ *     validators: [signalFormValidators.email]
+ *   }
+ * });
+ * ```
+ */
+function formGroup(input) {
+    return createSignalFormGroup(input);
+}
+/**
+ * Primary API for creating signal-based reactive forms.
+ *
+ * Alias for `formGroup`. This is the main entry point for creating forms.
+ * Provides type-safe, signal-based form state management with built-in validation.
+ *
+ * @example
+ * ```typescript
+ * // Basic form
+ * const form = signalForm({ name: 'John', age: 25 });
+ *
+ * // Complex form with validation
+ * const form = signalForm<Person>({
+ *   name: {
+ *     value: '',
+ *     validators: [signalFormValidators.required, signalFormValidators.minLength(2)]
+ *   },
+ *   age: {
+ *     value: 30,
+ *     validators: [signalFormValidators.min(0)],
+ *     warnings: [signalFormValidators.max(120)],
+ *     disabled: (ctx) => ctx.getControl('name').value() === 'admin'
+ *   },
+ *   address: {
+ *     street: '123 Main St',
+ *     city: 'NYC'
+ *   },
+ *   hobbies: ['coding', 'gaming']
+ * });
+ *
+ * // Access form state
+ * console.log(form.value()); // { name: '', age: 30, address: {...}, hobbies: [...] }
+ * console.log(form.valid()); // boolean
+ * console.log(form.controls.name.errors()); // { required: 'This field is required' }
+ * ```
+ */
+const signalForm = formGroup;
+
+/**
+ * Set of valid keys for control configuration objects.
+ * Used to distinguish config objects from plain value objects.
+ *
+ * @internal
+ */
+const CONTROL_CONFIG_KEYS = new Set([
+    'value',
+    'validators',
+    'warnings',
+    'disabled',
+]);
+/**
+ * Checks if a value is a control configuration object.
+ *
+ * Determines if the value has a 'value' property and only contains
+ * valid control config keys (value, validators, warnings, disabled).
+ *
+ * @internal
+ * @param value - Value to check
+ * @returns True if value is a control config object
+ */
+function isControlConfig(value) {
+    if (!value || typeof value !== 'object')
+        return false;
+    if (!('value' in value))
+        return false;
+    return Object.keys(value).every(key => CONTROL_CONFIG_KEYS.has(key));
+}
+/**
+ * Creates the appropriate control node from various input types.
+ *
+ * Recursively determines and creates the correct control type:
+ * - Existing controls are returned as-is
+ * - Arrays become SignalFormArray
+ * - Objects (non-config) become SignalForm (group)
+ * - Primitives/configs become SignalFormControl
+ *
+ * @internal
+ * @template TItem - The type of item to create a control for
+ * @template TControls - Object type defining available sibling controls
+ * @param input - Input value in any accepted format
+ * @param getControl - Accessor for sibling controls
+ * @returns Appropriate control type for the input
+ */
+function createNodeFromInput(input, getControl) {
+    if (isSignalFormControl(input)) {
+        return input;
+    }
+    if (isSignalFormGroup(input)) {
+        return input;
+    }
+    if (isSignalFormArray(input)) {
+        return input;
+    }
+    if (Array.isArray(input)) {
+        return createSignalFormArray(input, getControl);
+    }
+    if (typeof input === 'object' && input !== null && !isControlConfig(input)) {
+        return createSignalFormGroup(input);
+    }
+    return createSignalFormControl(input, getControl);
+}
+/**
+ * Type guard to check if an object is a SignalFormArray.
+ *
+ * @template TValue - The type of items in the array
+ * @param obj - Object to check
+ * @returns True if obj is a SignalFormArray
+ *
+ * @example
+ * ```typescript
+ * if (isSignalFormArray(value)) {
+ *   console.log(value.controls().length); // TypeScript knows this is an array
+ * }
+ * ```
+ */
+function isSignalFormArray(obj) {
+    return (!!obj &&
+        typeof obj === 'object' &&
+        obj.kind === 'array');
+}
+/**
+ * Creates a reactive form array for managing dynamic collections of controls.
+ *
+ * Builds an array container that can hold multiple controls (primitives, groups, or nested arrays)
+ * with full signal-based reactivity. Provides methods for dynamic addition/removal of items
+ * and tracks collective validation state.
+ *
+ * Features:
+ * - Dynamic array operations (push, insert, remove, clear)
+ * - Reactive value and error tracking across all items
+ * - Collective state management (touched, dirty, valid)
+ * - Manual error/warning management at array level
+ * - Type-safe access to individual controls
+ *
+ * @template TItem - The type of each item in the array
+ * @template TControls - Object type defining available sibling controls
+ *
+ * @param inputItems - Array of initial items (values, configs, or controls)
+ * @param getControl - Optional accessor for sibling controls
+ * @returns Fully configured SignalFormArray instance
+ *
+ * @example
+ * ```typescript
+ * // Array of primitives
+ * const tagsArray = createSignalFormArray(['tag1', 'tag2']);
+ * tagsArray.push('tag3');
+ *
+ * // Array of objects
+ * const addressesArray = createSignalFormArray<Address>([
+ *   { street: '123 Main', city: 'NYC' },
+ *   { street: '456 Oak', city: 'LA' }
+ * ]);
+ *
+ * // Array with validators
+ * const hobbiesArray = createSignalFormArray([
+ *   { value: 'coding', validators: [signalFormValidators.minLength(3)] },
+ *   'gaming'
+ * ]);
+ * ```
+ */
+function createSignalFormArray(inputItems, getControl) {
+    const accessControl = getControl ??
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        ((_) => {
+            throw new Error('getControl is not available for this array.');
+        });
+    const controls = signal(inputItems.map(item => createNodeFromInput(item, accessControl)), ...(ngDevMode ? [{ debugName: "controls" }] : []));
+    const selfDirty = signal(false, ...(ngDevMode ? [{ debugName: "selfDirty" }] : []));
+    const selfTouched = signal(false, ...(ngDevMode ? [{ debugName: "selfTouched" }] : []));
+    const selfDisabled = signal(false, ...(ngDevMode ? [{ debugName: "selfDisabled" }] : []));
+    const manualErrors = signal({}, ...(ngDevMode ? [{ debugName: "manualErrors" }] : []));
+    const manualWarnings = signal({}, ...(ngDevMode ? [{ debugName: "manualWarnings" }] : []));
+    const value = computed(() => controls().map(control => control.value()), ...(ngDevMode ? [{ debugName: "value" }] : []));
+    const errors = computed(() => controls().map(control => {
+        if (control.kind === 'control') {
+            const map = control.errors();
+            return hasErrors(map) ? map : undefined;
+        }
+        const childErrors = control.errors();
+        return isEmptyErrorTree(childErrors) ? undefined : childErrors;
+    }), ...(ngDevMode ? [{ debugName: "errors" }] : []));
+    const warnings = computed(() => controls().map(control => {
+        if (control.kind === 'control') {
+            const map = control.warnings();
+            return hasErrors(map) ? map : undefined;
+        }
+        const childWarnings = control.warnings();
+        return isEmptyErrorTree(childWarnings) ? undefined : childWarnings;
+    }), ...(ngDevMode ? [{ debugName: "warnings" }] : []));
+    const selfErrors = computed(() => {
+        if (selfDisabled())
+            return {};
+        return { ...manualErrors() };
+    }, ...(ngDevMode ? [{ debugName: "selfErrors" }] : []));
+    const selfWarnings = computed(() => {
+        if (selfDisabled())
+            return {};
+        return { ...manualWarnings() };
+    }, ...(ngDevMode ? [{ debugName: "selfWarnings" }] : []));
+    const invalid = computed(() => {
+        if (selfDisabled())
+            return false;
+        return (hasErrors(selfErrors()) || controls().some(control => control.invalid()));
+    }, ...(ngDevMode ? [{ debugName: "invalid" }] : []));
+    const valid = computed(() => !invalid(), ...(ngDevMode ? [{ debugName: "valid" }] : []));
+    const touched = computed(() => selfTouched() || controls().some(control => control.touched()), ...(ngDevMode ? [{ debugName: "touched" }] : []));
+    const dirty = computed(() => selfDirty() || controls().some(control => control.dirty()), ...(ngDevMode ? [{ debugName: "dirty" }] : []));
+    const insert = (item, index) => {
+        const node = createNodeFromInput(item, accessControl);
+        const position = index ?? controls().length;
+        controls.update(old => {
+            const newArray = [...old];
+            newArray.splice(position, 0, node);
+            return newArray;
+        });
+        selfDirty.set(true);
+        return position;
+    };
+    const push = (item) => insert(item);
+    const removeAt = (index) => {
+        controls.update(old => {
+            const newArray = [...old];
+            newArray.splice(index, 1);
+            return newArray;
+        });
+        selfDirty.set(true);
+    };
+    const clear = () => {
+        controls.set([]);
+        selfDirty.set(true);
+    };
+    const at = (index) => controls()[index];
+    const setValue = (nextValues, options) => {
+        controls.update(old => {
+            if (nextValues.length !== old.length) {
+                return nextValues.map(_value => createNodeFromInput(_value, accessControl));
+            }
+            old.forEach((control, index) => {
+                control.setValue(nextValues[index], options);
+            });
+            return old;
+        });
+        if (options?.markDirty ?? true)
+            selfDirty.set(true);
+        if (options?.markTouched)
+            selfTouched.set(true);
+    };
+    const reset = (nextValues) => {
+        if (nextValues) {
+            setValue(nextValues, { markDirty: false });
+        }
+        else {
+            controls().forEach(control => control.reset());
+        }
+        selfDirty.set(false);
+        selfTouched.set(false);
+        manualErrors.set({});
+        manualWarnings.set({});
+    };
+    const setDisabled = (disabled, options) => {
+        selfDisabled.set(disabled);
+        if (!options?.onlySelf) {
+            controls().forEach(control => control.setDisabled(disabled));
+        }
+    };
+    return {
+        kind: 'array',
+        controls,
+        value,
+        errors,
+        warnings,
+        selfErrors,
+        selfWarnings,
+        disabled: computed(() => selfDisabled()),
+        touched,
+        dirty,
+        invalid,
+        valid,
+        insert,
+        push,
+        removeAt,
+        clear,
+        at,
+        setValue,
+        reset,
+        markTouched: () => selfTouched.set(true),
+        markUntouched: () => selfTouched.set(false),
+        markDirty: () => selfDirty.set(true),
+        markPristine: () => selfDirty.set(false),
+        markAllTouched: () => controls().forEach(control => control.markTouched()),
+        setDisabled,
+        setError: (key, message) => manualErrors.update(current => ({ ...current, [key]: message })),
+        clearError: (key) => manualErrors.update(current => {
+            // eslint-disable-next-line @typescript-eslint/no-unused-vars
+            const { [key]: _removed, ...rest } = current;
+            return rest;
+        }),
+        clearErrors: () => manualErrors.set({}),
+        setWarning: (key, message) => manualWarnings.update(current => ({ ...current, [key]: message })),
+        clearWarning: (key) => manualWarnings.update(current => {
+            // eslint-disable-next-line @typescript-eslint/no-unused-vars
+            const { [key]: _removed, ...rest } = current;
+            return rest;
+        }),
+        clearWarnings: () => manualWarnings.set({}),
+    };
+}
+
+/**
+ * Regular expression for email validation.
+ *
+ * Aligned with Angular's built-in email validator. Validates standard email formats
+ * with proper domain and local parts.
+ *
+ * Pattern requirements:
+ * - Total length: 1-254 characters
+ * - Local part (before @): 1-64 characters
+ * - Allows alphanumeric and special characters: !#$%&'*+/=?^_`{|}~-
+ * - Domain must have valid format with optional subdomains
+ */
+const EMAIL_REGEXP = /^(?=.{1,254}$)(?=.{1,64}@)[a-zA-Z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-zA-Z0-9!#$%&'*+/=?^_`{|}~-]+)*@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$/;
+/**
+ * Determines if a value is considered empty for validation purposes.
+ *
+ * Checks various types:
+ * - null/undefined: always empty
+ * - Numbers: empty when equals 0
+ * - Strings/Arrays: empty when length is 0
+ * - Sets: empty when size is 0
+ *
+ * @param value - Value to check for emptiness
+ * @returns True if the value is considered empty
+ *
+ * @example
+ * ```typescript
+ * isEmptyInputValue(null); // true
+ * isEmptyInputValue(''); // true
+ * isEmptyInputValue(0); // true
+ * isEmptyInputValue('hello'); // false
+ * ```
+ */
+function isEmptyInputValue(value) {
+    if (value === null || value === undefined)
+        return true;
+    // TODO 1: check if number==0 is empty or number.length==0 is empty
+    if (typeof value === 'number' /* or - isNumber(value) */) {
+        return value == 0;
+    }
+    if (Array.isArray(value) || typeof value === 'string') {
+        return value.length === 0;
+    }
+    if (value instanceof Set) {
+        return value.size === 0;
+    }
+    return false;
+}
+/**
+ * Type guard that checks if a value can be coerced to a valid number.
+ *
+ * Uses JavaScript's Number coercion and checks for NaN to determine
+ * if a value represents a valid numeric value.
+ *
+ * @param value - Value to check
+ * @returns True if value is or can be coerced to a number
+ *
+ * @example
+ * ```typescript
+ * isNumber(42); // true
+ * isNumber('42'); // true
+ * isNumber('hello'); // false
+ * ```
+ */
+function isNumber(value) {
+    return !Number.isNaN(Number(value));
+}
+/**
+ * Validator that requires a non-empty value.
+ *
+ * Fails when the value is null, undefined, empty string, empty array,
+ * zero (for numbers), or empty Set.
+ *
+ * @param ctx - Validation context with the value to check
+ * @returns Error object with 'required' key if validation fails, null otherwise
+ *
+ * @example
+ * ```typescript
+ * const control = signalForm({ name: { value: '', validators: [signalFormValidators.required] } });
+ * // control.controls.name.errors() => { required: 'This field is required' }
+ * ```
+ */
+const required = ({ item: { value } }) => isEmptyInputValue(value) ? { required: 'This field is required' } : null;
+/**
+ * Validator that enforces a maximum string or number length.
+ *
+ * Converts the value to string and checks if its length exceeds the specified maximum.
+ * Works with both string and number types.
+ *
+ * @param num - Maximum allowed length (inclusive)
+ * @returns Validator function
+ *
+ * @example
+ * ```typescript
+ * const control = signalForm({
+ *   username: { value: 'verylongusername', validators: [signalFormValidators.maxLength(10)] }
+ * });
+ * // control.controls.username.errors() => { maxLength: 'To long' }
+ * ```
+ */
+function maxLength(num) {
+    return ({ item: { value } }) => (typeof value == 'string' || typeof value == 'number') &&
+        value.toString().length > num
+        ? { maxLength: 'To long' }
+        : null;
+}
+/**
+ * Validator that enforces a minimum string or number length.
+ *
+ * Converts the value to string and checks if its length is less than or equal to the specified minimum.
+ * Works with both string and number types.
+ *
+ * @param num - Minimum required length (inclusive)
+ * @returns Validator function
+ *
+ * @example
+ * ```typescript
+ * const control = signalForm({
+ *   code: { value: 'ab', validators: [signalFormValidators.minLength(3)] }
+ * });
+ * // control.controls.code.errors() => { minLength: 'To short' }
+ * ```
+ */
+function minLength(num) {
+    return ({ item: { value } }) => (typeof value == 'string' || typeof value == 'number') &&
+        value.toString().length <= num
+        ? { minLength: 'To short' }
+        : null;
+}
+/**
+ * Validator that enforces a minimum numeric value.
+ *
+ * Checks if a numeric value is less than or equal to the specified minimum.
+ * Value is coerced to a number for comparison.
+ *
+ * @param num - Minimum allowed value (exclusive - value must be greater than this)
+ * @returns Validator function
+ *
+ * @example
+ * ```typescript
+ * const control = signalForm({
+ *   age: { value: -5, validators: [signalFormValidators.min(0)] }
+ * });
+ * // control.controls.age.errors() => { minLength: 'To small' }
+ * ```
+ */
+function min(num) {
+    return ({ item: { value } }) => isNumber(value) && value <= num ? { minLength: 'To small' } : null;
+}
+/**
+ * Validator that enforces a maximum numeric value.
+ *
+ * Checks if a numeric value exceeds the specified maximum.
+ * Value is coerced to a number for comparison.
+ *
+ * @param num - Maximum allowed value (inclusive)
+ * @returns Validator function
+ *
+ * @example
+ * ```typescript
+ * const control = signalForm({
+ *   age: { value: 150, validators: [signalFormValidators.max(120)] }
+ * });
+ * // control.controls.age.errors() => { minLength: 'To big' }
+ * ```
+ */
+function max(num) {
+    return ({ item: { value } }) => isNumber(value) && value > num ? { minLength: 'To big' } : null;
+}
+/**
+ * Validator that checks if a value is a valid email address.
+ *
+ * Uses Angular-compatible email regex pattern to validate email format.
+ * Skips validation for empty values (use with `required` if needed).
+ *
+ * @param ctx - Validation context with the email value to check
+ * @returns Error object with 'email' key if validation fails, null otherwise
+ *
+ * @example
+ * ```typescript
+ * const control = signalForm({
+ *   email: { value: 'invalid-email', validators: [signalFormValidators.email] }
+ * });
+ * // control.controls.email.errors() => { email: 'Invalid email' }
+ * ```
+ */
+const email = ({ item: { value } }) => {
+    if (isEmptyInputValue(value))
+        return null;
+    return EMAIL_REGEXP.test(String(value)) ? null : { email: 'Invalid email' };
+};
+/**
+ * Validator that checks if a value matches a specified regular expression pattern.
+ *
+ * Accepts either a RegExp object or a string pattern. String patterns are automatically
+ * wrapped with ^ and $ anchors to match the entire value.
+ *
+ * Skips validation for empty values (use with `required` if needed).
+ *
+ * @param valuePattern - Regular expression or pattern string to match against
+ * @returns Validator function
+ *
+ * @example
+ * ```typescript
+ * // Using regex
+ * const control1 = signalForm({
+ *   code: { value: 'abc', validators: [signalFormValidators.pattern(/^[0-9]+$/)] }
+ * });
+ * // control1.controls.code.errors() => { pattern: 'RequiredPattern: ^[0-9]+$, ActualValue: abc' }
+ *
+ * // Using string pattern
+ * const control2 = signalForm({
+ *   zipCode: { value: 'ABC', validators: [signalFormValidators.pattern('[0-9]{5}')] }
+ * });
+ * ```
+ */
+function pattern(valuePattern) {
+    if (!valuePattern)
+        return () => null;
+    let regex;
+    let regexStr;
+    if (typeof valuePattern === 'string') {
+        regexStr = '';
+        if (valuePattern.charAt(0) !== '^')
+            regexStr += '^';
+        regexStr += valuePattern;
+        if (valuePattern.charAt(valuePattern.length - 1) !== '$')
+            regexStr += '$';
+        regex = new RegExp(regexStr);
+    }
+    else {
+        regexStr = valuePattern.toString();
+        regex = valuePattern;
+    }
+    return ({ item: { value } }) => {
+        if (isEmptyInputValue(value))
+            return null;
+        const valueStr = String(value);
+        return regex.test(valueStr)
+            ? null
+            : {
+                pattern: `RequiredPattern: ${regexStr}, ActualValue: ${valueStr}`,
+            };
+    };
+}
+/**
+ * Collection of built-in validators for signal-form controls.
+ *
+ * Provides common validation functions that can be used in the `validators` or `warnings`
+ * arrays of form controls. All validators skip empty values except `required`.
+ *
+ * @property required - Ensures the value is not empty (null, undefined, '', [], 0, empty Set)
+ * @property maxLength - Ensures string/number length doesn't exceed maximum
+ * @property minLength - Ensures string/number length meets minimum requirement
+ * @property min - Ensures numeric value is greater than minimum (exclusive)
+ * @property max - Ensures numeric value doesn't exceed maximum (inclusive)
+ * @property email - Validates email address format using Angular-compatible regex
+ * @property pattern - Validates value matches a regular expression pattern
+ *
+ * @example
+ * ```typescript
+ * const form = signalForm({
+ *   email: {
+ *     value: '',
+ *     validators: [signalFormValidators.required, signalFormValidators.email]
+ *   },
+ *   age: {
+ *     value: 25,
+ *     validators: [signalFormValidators.min(0), signalFormValidators.max(120)],
+ *     warnings: [signalFormValidators.max(100)] // Warning but doesn't invalidate
+ *   },
+ *   username: {
+ *     value: '',
+ *     validators: [
+ *       signalFormValidators.required,
+ *       signalFormValidators.minLength(3),
+ *       signalFormValidators.maxLength(20),
+ *       signalFormValidators.pattern(/^[a-zA-Z0-9_]+$/)
+ *     ]
+ *   }
+ * });
+ * ```
+ */
+const signalFormValidators = {
+    required,
+    maxLength,
+    minLength,
+    min,
+    max,
+    email,
+    pattern,
+};
+
+/**
+ * Example demonstrating the usage of signal-based reactive forms.
+ *
+ * Shows various features including:
+ * - Simple value initialization
+ * - Validators that mark controls as invalid
+ * - Warnings that don't affect validity
+ * - Dynamic disabled state based on other controls
+ * - Nested objects and arrays
+ * - Type-safe control access
+ *
+ * This function is exported as an example and reference implementation.
+ * It's not meant to be called in production code.
+ *
+ * @example
+ * ```typescript
+ * // Basic usage pattern from the example
+ * const form = signalForm<Person>({
+ *   name: 'dvirus',
+ *   age: {
+ *     value: 130,
+ *     validators: [signalFormValidators.required, signalFormValidators.min(0)],
+ *     warnings: [signalFormValidators.max(120)],
+ *     disabled: (ctx) => ctx.getControl('name').value() === 'admin'
+ *   },
+ *   address: {
+ *     street: { value: '123 Main St', validators: [signalFormValidators.required] }
+ *   },
+ *   hobbies: [
+ *     { value: 'coding', validators: [signalFormValidators.minLength(3)] },
+ *     'programming'
+ *   ]
+ * });
+ *
+ * // Access form state
+ * form.getControl('address').value(); // { street: '123 Main St' }
+ * form.controls.hobbies.controls()[0].errors(); // {}
+ * form.controls.age.firstErrorOrWarning(); // { name: 'max', message: 'To big', type: 'warning' }
+ * ```
+ */
+// function main() {
+//   type Person = {
+//     name: string;
+//     age: number;
+//     address: {
+//       street: string;
+//       city: string;
+//     };
+//     hobbies: string[];
+//   };
+//   /**
+//    * Example 1: Simple form with direct value initialization.
+//    *
+//    * Creates a form from a plain object. Each property becomes
+//    * a control with the provided value.
+//    */
+//   const model1: Person = {
+//     name: 'dvirus',
+//     age: 30,
+//     address: {
+//       street: '123 Main St',
+//       city: 'Any-town',
+//     },
+//     hobbies: ['coding', 'gaming'],
+//   };
+//   const form1 = signalForm(model1);
+//   /**
+//    * Example 2: Advanced form with validators, warnings, and dynamic disabled state.
+//    *
+//    * Demonstrates:
+//    * - Simple value for name field
+//    * - Age control with validators (required, min) and warnings (max)
+//    * - Dynamic disabled logic based on name value
+//    * - Nested address object with validated street field
+//    * - Array of hobbies with mixed control configs and simple values
+//    */
+//   const form2 = signalForm<Person>({
+//     name: 'dvirus',
+//     age: {
+//       // initial value
+//       value: 130,
+//       // example of validators, they add error messages and mark the control as invalid if the validation fails
+//       validators: [signalFormValidators.required, signalFormValidators.min(0)],
+//       // warning are like validators but they don't make the control invalid, just add a warning message
+//       warnings: [signalFormValidators.max(120)],
+//       // example of dynamic disabling based on another control's value
+//       disabled: (ctx) => ctx.getControl('name').value() === 'admin',
+//     },
+//     address: {
+//       street: {
+//         value: '123 Main St',
+//         validators: [signalFormValidators.required],
+//         disabled: false,
+//       },
+//     },
+//     hobbies: [
+//       {
+//         value: 'coding',
+//         validators: [signalFormValidators.minLength(3)],
+//         disabled: computed(() => false),
+//       },
+//       'programming',
+//       'Typing',
+//     ],
+//   });
+//   // Example outputs demonstrating form access patterns
+//   console.log(form2.getControl('address').value()); // { street: '123 Main St' }
+//   console.log(form2.controls.hobbies.controls()[0].errors()); // {}
+//   console.log(form2.controls.age.firstErrorOrWarning()); // {name: 'minLength', message: 'To big', type: 'warning'}
+//   console.log(form2.controls.age.warnings()); // { minLength: 'To big' }
+// }
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { controlSignal, createSignalFormArray, createSignalFormControl, createSignalFormGroup, formArray, formArraySignal, formControl, formGroup, formGroupSignal, fromSignalObj, isSignalFormArray, isSignalFormControl, isSignalFormGroup, isSignalObject, mergeSignalObjects, signalDebounce, signalForm, signalFormValidators, signalMap, signalNotifier, signalObject, signalOrFunction, signalOrValue, signalSet, toSignalObj, tryCatch, writableSignal };
+//# sourceMappingURL=dvirus-js-angular-signals.mjs.map