@signaltree/ng-forms 4.1.4 → 4.1.5

package/dist/constants.js

@@ -0,0 +1,6 @@
+const SHARED_DEFAULTS = Object.freeze({
+  PATH_CACHE_SIZE: 1000
+});
+const DEFAULT_PATH_CACHE_SIZE = SHARED_DEFAULTS.PATH_CACHE_SIZE;
+
+export { DEFAULT_PATH_CACHE_SIZE, SHARED_DEFAULTS };

package/dist/core/async-validators.js

@@ -0,0 +1,24 @@
+import { isObservable, firstValueFrom } from 'rxjs';
+
+function unique(checkFn, message = 'Already exists') {
+  return async value => {
+    if (!value) return null;
+    const exists = await checkFn(value);
+    return exists ? message : null;
+  };
+}
+function debounce(validator, delayMs) {
+  let timeoutId;
+  return async value => {
+    return new Promise(resolve => {
+      clearTimeout(timeoutId);
+      timeoutId = setTimeout(async () => {
+        const maybeAsync = validator(value);
+        const result = isObservable(maybeAsync) ? await firstValueFrom(maybeAsync) : await maybeAsync;
+        resolve(result);
+      }, delayMs);
+    });
+  };
+}
+
+export { debounce, unique };

package/dist/core/ng-forms.js

@@ -0,0 +1,880 @@
+import { __decorate, __metadata } from '../tslib.es6.js';
+import { signal, computed, isSignal, inject, DestroyRef, EventEmitter, ElementRef, Renderer2, effect, Input, Output, HostListener, Directive, forwardRef } from '@angular/core';
+import { FormControl, FormArray, FormGroup, NG_VALUE_ACCESSOR } from '@angular/forms';
+import { signalTree } from '@signaltree/core';
+import { isObservable, firstValueFrom } from 'rxjs';
+import { deepClone } from '../deep-clone.js';
+import { parsePath } from '../parse-path.js';
+import { mergeDeep } from '../merge-deep.js';
+import { matchPath } from '../match-path.js';
+
+class FormValidationError extends Error {
+  errors;
+  asyncErrors;
+  constructor(errors, asyncErrors) {
+    super('Form validation failed');
+    this.errors = errors;
+    this.asyncErrors = asyncErrors;
+    this.name = 'FormValidationError';
+  }
+}
+const SYNC_ERROR_KEY = 'signaltree';
+const ASYNC_ERROR_KEY = 'signaltreeAsync';
+function createFormTree(initialValues, config = {}) {
+  const {
+    validators: baseValidators = {},
+    asyncValidators: baseAsyncValidators = {},
+    destroyRef: providedDestroyRef,
+    fieldConfigs = {},
+    conditionals = [],
+    persistKey,
+    storage,
+    persistDebounceMs = 100,
+    validationBatchMs = 0,
+    ...treeConfig
+  } = config;
+  const syncValidators = normalizeSyncValidators(baseValidators, fieldConfigs);
+  const asyncValidators = normalizeAsyncValidators(baseAsyncValidators, fieldConfigs);
+  const {
+    values: hydratedInitialValues
+  } = hydrateInitialValues(initialValues, persistKey, storage);
+  const initialSnapshot = deepClone(hydratedInitialValues);
+  const valuesTree = signalTree(hydratedInitialValues, treeConfig);
+  assertTreeNode(valuesTree.state);
+  const flattenedState = valuesTree.state;
+  enhanceArraysRecursively(flattenedState);
+  const formGroup = createAbstractControl(hydratedInitialValues, '', syncValidators, asyncValidators);
+  const destroyRef = providedDestroyRef ?? tryInjectDestroyRef();
+  const cleanupCallbacks = [];
+  const errors = signal({});
+  const asyncErrors = signal({});
+  const touched = signal({});
+  const asyncValidating = signal({});
+  const dirty = signal(formGroup.dirty);
+  const valid = signal(formGroup.valid && !formGroup.pending);
+  const submitting = signal(false);
+  const refreshRunner = () => {
+    const snapshot = collectControlSnapshot(formGroup);
+    errors.set(snapshot.syncErrors);
+    asyncErrors.set(snapshot.asyncErrors);
+    touched.set(snapshot.touched);
+    asyncValidating.set(snapshot.pending);
+    dirty.set(formGroup.dirty);
+    valid.set(formGroup.valid && !formGroup.pending);
+  };
+  let refreshTimer = null;
+  const refreshAggregates = (immediate = false) => {
+    if (immediate || validationBatchMs <= 0) {
+      if (refreshTimer) {
+        clearTimeout(refreshTimer);
+        refreshTimer = null;
+      }
+      refreshRunner();
+      return;
+    }
+    if (refreshTimer) {
+      clearTimeout(refreshTimer);
+    }
+    refreshTimer = setTimeout(() => {
+      refreshTimer = null;
+      refreshRunner();
+    }, validationBatchMs);
+  };
+  refreshAggregates(true);
+  const persistController = createPersistController(formGroup, persistKey, storage, persistDebounceMs, cleanupCallbacks);
+  const fieldErrorKeys = new Set([...Object.keys(syncValidators), ...Object.keys(asyncValidators)]);
+  const fieldErrors = {};
+  const fieldAsyncErrors = {};
+  fieldErrorKeys.forEach(fieldPath => {
+    fieldErrors[fieldPath] = computed(() => errors()[fieldPath]);
+    fieldAsyncErrors[fieldPath] = computed(() => asyncErrors()[fieldPath]);
+  });
+  const fieldConfigLookup = path => resolveFieldConfig(fieldConfigs, path);
+  const connectControlRecursive = (control, path) => {
+    if (control instanceof FormGroup) {
+      Object.entries(control.controls).forEach(([key, child]) => {
+        connectControlRecursive(child, joinPath(path, key));
+      });
+      return;
+    }
+    if (control instanceof FormArray) {
+      const arraySignal = getSignalAtPath(flattenedState, path);
+      if (arraySignal) {
+        connectFormArrayAndSignal(control, arraySignal, path, syncValidators, asyncValidators, cleanupCallbacks, connectControlRecursive);
+      }
+      control.controls.forEach((child, index) => {
+        connectControlRecursive(child, joinPath(path, String(index)));
+      });
+      return;
+    }
+    const signalAtPath = getSignalAtPath(flattenedState, path);
+    if (signalAtPath) {
+      connectControlAndSignal(control, signalAtPath, cleanupCallbacks, fieldConfigLookup(path));
+    }
+  };
+  connectControlRecursive(formGroup, '');
+  const conditionalState = new Map();
+  const applyConditionals = conditionals.length > 0 ? () => {
+    const values = formGroup.getRawValue();
+    conditionals.forEach(({
+      when,
+      fields
+    }) => {
+      let visible = true;
+      try {
+        visible = when(values);
+      } catch {
+        visible = true;
+      }
+      fields.forEach(fieldPath => {
+        const control = formGroup.get(fieldPath);
+        if (!control) {
+          return;
+        }
+        const previous = conditionalState.get(fieldPath);
+        if (previous === visible) {
+          return;
+        }
+        conditionalState.set(fieldPath, visible);
+        if (visible) {
+          const signalAtPath = getSignalAtPath(flattenedState, fieldPath);
+          if (signalAtPath && 'set' in signalAtPath) {
+            signalAtPath.set(control.value);
+          }
+          control.enable({
+            emitEvent: true
+          });
+        } else {
+          control.disable({
+            emitEvent: false
+          });
+        }
+      });
+    });
+  } : () => undefined;
+  applyConditionals();
+  const aggregateSubscriptions = [];
+  aggregateSubscriptions.push(formGroup.valueChanges.subscribe(() => {
+    refreshAggregates();
+    persistController.schedulePersist();
+    applyConditionals();
+  }));
+  aggregateSubscriptions.push(formGroup.statusChanges.subscribe(() => refreshAggregates()));
+  if (formGroup.events) {
+    aggregateSubscriptions.push(formGroup.events.subscribe(() => refreshAggregates()));
+  }
+  cleanupCallbacks.push(() => {
+    aggregateSubscriptions.forEach(sub => sub.unsubscribe());
+    if (refreshTimer) {
+      clearTimeout(refreshTimer);
+    }
+  });
+  if (destroyRef) {
+    destroyRef.onDestroy(() => {
+      cleanupCallbacks.splice(0).forEach(fn => fn());
+    });
+  }
+  const setValue = (field, value) => {
+    const targetSignal = getSignalAtPath(flattenedState, field);
+    const control = formGroup.get(field);
+    if (targetSignal && 'set' in targetSignal) {
+      targetSignal.set(value);
+    } else if (control) {
+      control.setValue(value, {
+        emitEvent: true
+      });
+    }
+    if (control) {
+      const untypedControl = control;
+      untypedControl.markAsTouched();
+      untypedControl.markAsDirty();
+      untypedControl.updateValueAndValidity({
+        emitEvent: true
+      });
+    }
+    refreshAggregates(true);
+    persistController.schedulePersist();
+  };
+  const setValues = values => {
+    Object.entries(values).forEach(([key, value]) => {
+      setValue(key, value);
+    });
+  };
+  const reset = () => {
+    formGroup.reset(initialSnapshot);
+    submitting.set(false);
+    refreshAggregates(true);
+    persistController.persistImmediately();
+    applyConditionals();
+  };
+  const validate = async field => {
+    if (field) {
+      const control = formGroup.get(field);
+      if (!control) {
+        return;
+      }
+      control.markAsTouched();
+      control.updateValueAndValidity({
+        emitEvent: true
+      });
+      refreshAggregates(true);
+      await waitForPending(control);
+      refreshAggregates(true);
+      return;
+    }
+    formGroup.markAllAsTouched();
+    formGroup.updateValueAndValidity({
+      emitEvent: true
+    });
+    refreshAggregates(true);
+    await waitForPending(formGroup);
+    refreshAggregates(true);
+  };
+  const submit = async submitFn => {
+    submitting.set(true);
+    try {
+      await validate();
+      if (!valid()) {
+        throw new FormValidationError(errors(), asyncErrors());
+      }
+      const currentValues = formGroup.getRawValue();
+      const result = await submitFn(currentValues);
+      return result;
+    } finally {
+      submitting.set(false);
+      refreshAggregates(true);
+    }
+  };
+  const destroy = () => {
+    cleanupCallbacks.splice(0).forEach(fn => fn());
+  };
+  const formTree = {
+    state: flattenedState,
+    $: flattenedState,
+    form: formGroup,
+    errors,
+    asyncErrors,
+    touched,
+    asyncValidating,
+    dirty,
+    valid,
+    submitting,
+    unwrap: () => valuesTree(),
+    setValue,
+    setValues,
+    reset,
+    submit,
+    validate,
+    getFieldError: field => fieldErrors[field] || computed(() => undefined),
+    getFieldAsyncError: field => fieldAsyncErrors[field] || computed(() => undefined),
+    getFieldTouched: field => computed(() => formGroup.get(field)?.touched ?? false),
+    isFieldValid: field => computed(() => {
+      const control = formGroup.get(field);
+      return !!control && control.valid && !control.pending;
+    }),
+    isFieldAsyncValidating: field => computed(() => !!formGroup.get(field)?.pending),
+    fieldErrors,
+    fieldAsyncErrors,
+    values: valuesTree,
+    destroy
+  };
+  return formTree;
+}
+function createVirtualFormArray(items, visibleRange, controlFactory = value => new FormControl(value)) {
+  const start = Math.max(0, visibleRange.start);
+  const end = Math.max(start, visibleRange.end);
+  const controls = items.slice(start, end).map((item, offset) => controlFactory(item, start + offset));
+  return new FormArray(controls);
+}
+function enhanceArraysRecursively(obj, visited = new WeakSet()) {
+  if (visited.has(obj)) {
+    return;
+  }
+  visited.add(obj);
+  for (const key in obj) {
+    const value = obj[key];
+    if (isSignal(value)) {
+      const signalValue = value();
+      if (Array.isArray(signalValue)) {
+        obj[key] = enhanceArray(value);
+      }
+    } else if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
+      enhanceArraysRecursively(value, visited);
+    }
+  }
+}
+const enhanceArray = arraySignal => {
+  const enhanced = arraySignal;
+  enhanced.push = item => {
+    arraySignal.update(arr => [...arr, item]);
+  };
+  enhanced.removeAt = index => {
+    arraySignal.update(arr => arr.filter((_, i) => i !== index));
+  };
+  enhanced.setAt = (index, value) => {
+    arraySignal.update(arr => arr.map((item, i) => i === index ? value : item));
+  };
+  enhanced.insertAt = (index, item) => {
+    arraySignal.update(arr => [...arr.slice(0, index), item, ...arr.slice(index)]);
+  };
+  enhanced.move = (from, to) => {
+    arraySignal.update(arr => {
+      const newArr = [...arr];
+      const [item] = newArr.splice(from, 1);
+      if (item !== undefined) {
+        newArr.splice(to, 0, item);
+      }
+      return newArr;
+    });
+  };
+  enhanced.clear = () => {
+    arraySignal.set([]);
+  };
+  return enhanced;
+};
+function getSignalAtPath(node, path) {
+  if (!path) {
+    return null;
+  }
+  const segments = parsePath(path);
+  let current = node;
+  for (let i = 0; i < segments.length; i++) {
+    const segment = segments[i];
+    if (!current || typeof current !== 'object' && typeof current !== 'function') {
+      return null;
+    }
+    current = current[segment];
+    if (isSignal(current) && i < segments.length - 1) {
+      current = current();
+    }
+  }
+  if (isSignal(current)) {
+    return current;
+  }
+  return null;
+}
+function joinPath(parent, segment) {
+  return parent ? `${parent}.${segment}` : segment;
+}
+function wrapSyncValidator(validator) {
+  return control => {
+    const result = validator(control.value);
+    return result ? {
+      [SYNC_ERROR_KEY]: result
+    } : null;
+  };
+}
+function wrapAsyncValidator(validator) {
+  return async control => {
+    try {
+      const maybeAsync = validator(control.value);
+      const resolved = isObservable(maybeAsync) ? await firstValueFrom(maybeAsync) : await maybeAsync;
+      return resolved ? {
+        [ASYNC_ERROR_KEY]: resolved
+      } : null;
+    } catch {
+      return {
+        [ASYNC_ERROR_KEY]: 'Validation error'
+      };
+    }
+  };
+}
+function createAbstractControl(value, path, validators, asyncValidators) {
+  const syncValidator = findValidator(validators, path);
+  const asyncValidator = findValidator(asyncValidators, path);
+  const syncFns = syncValidator ? [wrapSyncValidator(syncValidator)] : undefined;
+  const asyncFns = asyncValidator ? [wrapAsyncValidator(asyncValidator)] : undefined;
+  if (Array.isArray(value)) {
+    const controls = value.map((item, index) => createAbstractControl(item, joinPath(path, String(index)), validators, asyncValidators));
+    return new FormArray(controls, syncFns, asyncFns);
+  }
+  if (isPlainObject(value)) {
+    const controls = {};
+    for (const [key, child] of Object.entries(value)) {
+      controls[key] = createAbstractControl(child, joinPath(path, key), validators, asyncValidators);
+    }
+    return new FormGroup(controls, {
+      validators: syncFns,
+      asyncValidators: asyncFns
+    });
+  }
+  return new FormControl(value, {
+    validators: syncFns,
+    asyncValidators: asyncFns,
+    nonNullable: false
+  });
+}
+function connectControlAndSignal(control, valueSignal, cleanupCallbacks, fieldConfig) {
+  const maybeConnect = control.connect;
+  if (typeof maybeConnect === 'function') {
+    try {
+      const res = maybeConnect.call(control, valueSignal);
+      if (res && typeof res.unsubscribe === 'function') {
+        cleanupCallbacks.push(() => res.unsubscribe());
+      }
+      return;
+    } catch {}
+  }
+  let updatingFromControl = false;
+  let updatingFromSignal = false;
+  let versionCounter = 0;
+  let lastControlVersion = 0;
+  let controlDebounceTimer = null;
+  const debounceMs = fieldConfig?.debounceMs ?? 0;
+  const originalSet = valueSignal.set.bind(valueSignal);
+  const originalUpdate = valueSignal.update.bind(valueSignal);
+  const applyControlValue = value => {
+    updatingFromSignal = true;
+    if (!Object.is(control.value, value)) {
+      const untypedControl = control;
+      untypedControl.setValue(value, {
+        emitEvent: true
+      });
+      untypedControl.markAsDirty();
+    }
+    updatingFromSignal = false;
+  };
+  valueSignal.set = value => {
+    const currentVersion = ++versionCounter;
+    originalSet(value);
+    if (updatingFromControl) {
+      return;
+    }
+    if (lastControlVersion > currentVersion) {
+      return;
+    }
+    applyControlValue(value);
+  };
+  valueSignal.update = updater => {
+    const next = updater(valueSignal());
+    valueSignal.set(next);
+  };
+  const pushUpdateFromControl = value => {
+    updatingFromControl = true;
+    lastControlVersion = ++versionCounter;
+    originalSet(value);
+    updatingFromControl = false;
+  };
+  const handleControlChange = value => {
+    if (updatingFromSignal) {
+      return;
+    }
+    if (debounceMs > 0) {
+      if (controlDebounceTimer) {
+        clearTimeout(controlDebounceTimer);
+      }
+      controlDebounceTimer = setTimeout(() => {
+        controlDebounceTimer = null;
+        pushUpdateFromControl(value);
+      }, debounceMs);
+      return;
+    }
+    pushUpdateFromControl(value);
+  };
+  const subscription = control.valueChanges.subscribe(value => {
+    handleControlChange(value);
+  });
+  cleanupCallbacks.push(() => {
+    subscription.unsubscribe();
+    valueSignal.set = originalSet;
+    valueSignal.update = originalUpdate;
+    if (controlDebounceTimer) {
+      clearTimeout(controlDebounceTimer);
+    }
+  });
+}
+function connectFormArrayAndSignal(formArray, arraySignal, path, validators, asyncValidators, cleanupCallbacks, connectControlRecursive) {
+  const maybeConnect = formArray.connect;
+  if (typeof maybeConnect === 'function') {
+    try {
+      const res = maybeConnect.call(formArray, arraySignal);
+      if (res && typeof res.unsubscribe === 'function') {
+        cleanupCallbacks.push(() => res.unsubscribe());
+      }
+      return;
+    } catch {}
+  }
+  let updatingFromControl = false;
+  let updatingFromSignal = false;
+  const originalSet = arraySignal.set.bind(arraySignal);
+  const originalUpdate = arraySignal.update.bind(arraySignal);
+  arraySignal.set = value => {
+    originalSet(value);
+    if (updatingFromControl) {
+      return;
+    }
+    updatingFromSignal = true;
+    syncFormArrayFromValue(formArray, value, path, validators, asyncValidators, connectControlRecursive);
+    formArray.markAsDirty();
+    updatingFromSignal = false;
+  };
+  arraySignal.update = updater => {
+    const next = updater(arraySignal());
+    arraySignal.set(next);
+  };
+  const subscription = formArray.valueChanges.subscribe(value => {
+    if (updatingFromSignal) {
+      return;
+    }
+    updatingFromControl = true;
+    originalSet(value);
+    updatingFromControl = false;
+  });
+  cleanupCallbacks.push(() => {
+    subscription.unsubscribe();
+    arraySignal.set = originalSet;
+    arraySignal.update = originalUpdate;
+  });
+  syncFormArrayFromValue(formArray, arraySignal(), path, validators, asyncValidators, connectControlRecursive);
+}
+function syncFormArrayFromValue(formArray, nextValue, path, validators, asyncValidators, connectControlRecursive) {
+  if (!Array.isArray(nextValue)) {
+    nextValue = [];
+  }
+  while (formArray.length > nextValue.length) {
+    formArray.removeAt(formArray.length - 1);
+  }
+  nextValue.forEach((item, index) => {
+    const childPath = joinPath(path, String(index));
+    const existing = formArray.at(index);
+    if (!existing) {
+      const control = createAbstractControl(item, childPath, validators, asyncValidators);
+      formArray.insert(index, control);
+      connectControlRecursive(control, childPath);
+      return;
+    }
+    if (existing instanceof FormArray) {
+      syncFormArrayFromValue(existing, Array.isArray(item) ? item : [], childPath, validators, asyncValidators, connectControlRecursive);
+      return;
+    }
+    if (existing instanceof FormGroup) {
+      if (isPlainObject(item)) {
+        existing.setValue(item, {
+          emitEvent: false
+        });
+      }
+      return;
+    }
+    if (!Object.is(existing.value, item)) {
+      const untypedExisting = existing;
+      untypedExisting.setValue(item, {
+        emitEvent: false
+      });
+    }
+  });
+}
+function collectControlSnapshot(control) {
+  const snapshot = {
+    syncErrors: {},
+    asyncErrors: {},
+    touched: {},
+    pending: {}
+  };
+  traverseControls(control, (currentPath, currentControl) => {
+    if (!currentPath) {
+      return;
+    }
+    if (currentControl.touched) {
+      snapshot.touched[currentPath] = true;
+    }
+    if (currentControl.pending) {
+      snapshot.pending[currentPath] = true;
+    }
+    const errors = currentControl.errors;
+    if (!errors) {
+      return;
+    }
+    const syncMessage = errors[SYNC_ERROR_KEY];
+    if (typeof syncMessage === 'string') {
+      snapshot.syncErrors[currentPath] = syncMessage;
+    }
+    const asyncMessage = errors[ASYNC_ERROR_KEY];
+    if (typeof asyncMessage === 'string') {
+      snapshot.asyncErrors[currentPath] = asyncMessage;
+    }
+  }, '');
+  return snapshot;
+}
+function traverseControls(control, visitor, path = '') {
+  visitor(path, control);
+  if (control instanceof FormGroup) {
+    Object.entries(control.controls).forEach(([key, child]) => {
+      traverseControls(child, visitor, joinPath(path, key));
+    });
+    return;
+  }
+  if (control instanceof FormArray) {
+    control.controls.forEach((child, index) => {
+      traverseControls(child, visitor, joinPath(path, String(index)));
+    });
+  }
+}
+function waitForPending(control) {
+  if (!control.pending) {
+    return Promise.resolve();
+  }
+  return new Promise(resolve => {
+    const subscription = control.statusChanges.subscribe(() => {
+      if (!control.pending) {
+        subscription.unsubscribe();
+        resolve();
+      }
+    });
+  });
+}
+function isPlainObject(value) {
+  return !!value && typeof value === 'object' && !Array.isArray(value) && Object.prototype.toString.call(value) === '[object Object]';
+}
+function tryInjectDestroyRef() {
+  try {
+    return inject(DestroyRef);
+  } catch {
+    return null;
+  }
+}
+function normalizeSyncValidators(base, fieldConfigs) {
+  const buckets = new Map();
+  for (const [path, validator] of Object.entries(base)) {
+    const existing = buckets.get(path) ?? [];
+    existing.push(validator);
+    buckets.set(path, existing);
+  }
+  for (const [path, config] of Object.entries(fieldConfigs)) {
+    const validators = toValidatorArray(config.validators);
+    if (validators.length === 0) {
+      continue;
+    }
+    const existing = buckets.get(path) ?? [];
+    existing.push(...validators);
+    buckets.set(path, existing);
+  }
+  const normalized = {};
+  buckets.forEach((validators, path) => {
+    normalized[path] = value => {
+      for (const validator of validators) {
+        const result = validator(value);
+        if (result) {
+          return result;
+        }
+      }
+      return null;
+    };
+  });
+  return {
+    ...base,
+    ...normalized
+  };
+}
+function normalizeAsyncValidators(base, fieldConfigs) {
+  const buckets = new Map();
+  for (const [path, validator] of Object.entries(base)) {
+    const existing = buckets.get(path) ?? [];
+    existing.push(validator);
+    buckets.set(path, existing);
+  }
+  for (const [path, config] of Object.entries(fieldConfigs)) {
+    const validators = toValidatorArray(config.asyncValidators);
+    if (validators.length === 0) {
+      continue;
+    }
+    const existing = buckets.get(path) ?? [];
+    existing.push(...validators);
+    buckets.set(path, existing);
+  }
+  const normalized = {};
+  buckets.forEach((validators, path) => {
+    normalized[path] = async value => {
+      for (const validator of validators) {
+        const maybeAsync = validator(value);
+        const result = isObservable(maybeAsync) ? await firstValueFrom(maybeAsync) : await maybeAsync;
+        if (result) {
+          return result;
+        }
+      }
+      return null;
+    };
+  });
+  return {
+    ...base,
+    ...normalized
+  };
+}
+function toValidatorArray(input) {
+  if (!input) {
+    return [];
+  }
+  if (Array.isArray(input)) {
+    return input;
+  }
+  return Object.values(input);
+}
+function hydrateInitialValues(initialValues, persistKey, storage) {
+  const baseClone = deepClone(initialValues);
+  if (!persistKey || !storage) {
+    return {
+      values: baseClone
+    };
+  }
+  try {
+    const storedRaw = storage.getItem(persistKey);
+    if (!storedRaw) {
+      return {
+        values: baseClone
+      };
+    }
+    const parsed = JSON.parse(storedRaw);
+    const merged = mergeDeep(baseClone, parsed);
+    return {
+      values: merged
+    };
+  } catch {
+    return {
+      values: baseClone
+    };
+  }
+}
+function assertTreeNode(state) {
+  if (!state || typeof state !== 'object') {
+    throw new Error('Invalid state structure for form tree');
+  }
+}
+function resolveFieldConfig(fieldConfigs, path) {
+  if (fieldConfigs[path]) {
+    return fieldConfigs[path];
+  }
+  const keys = Object.keys(fieldConfigs);
+  let match;
+  for (const key of keys) {
+    if (!key.includes('*')) {
+      continue;
+    }
+    if (matchPath(key, path)) {
+      if (!match || match.key.length < key.length) {
+        match = {
+          key,
+          config: fieldConfigs[key]
+        };
+      }
+    }
+  }
+  if (match) {
+    return match.config;
+  }
+  return fieldConfigs['*'];
+}
+function findValidator(map, path) {
+  if (map[path]) {
+    return map[path];
+  }
+  let candidate;
+  for (const key of Object.keys(map)) {
+    if (!key.includes('*')) {
+      continue;
+    }
+    if (matchPath(key, path)) {
+      if (!candidate || candidate.key.length < key.length) {
+        candidate = {
+          key,
+          value: map[key]
+        };
+      }
+    }
+  }
+  if (candidate) {
+    return candidate.value;
+  }
+  return map['*'];
+}
+function createPersistController(formGroup, persistKey, storage, debounceMs, cleanupCallbacks) {
+  if (!persistKey || !storage) {
+    return {
+      schedulePersist: () => undefined,
+      persistImmediately: () => undefined
+    };
+  }
+  let timer = null;
+  const persist = () => {
+    try {
+      const payload = JSON.stringify(formGroup.getRawValue());
+      storage.setItem(persistKey, payload);
+    } catch {}
+  };
+  const schedulePersist = () => {
+    if (debounceMs <= 0) {
+      persist();
+      return;
+    }
+    if (timer) {
+      clearTimeout(timer);
+    }
+    timer = setTimeout(() => {
+      timer = null;
+      persist();
+    }, debounceMs);
+  };
+  cleanupCallbacks.push(() => {
+    if (timer) {
+      clearTimeout(timer);
+    }
+  });
+  return {
+    schedulePersist,
+    persistImmediately: persist
+  };
+}
+let SignalValueDirective = class SignalValueDirective {
+  signalTreeSignalValue;
+  signalTreeSignalValueChange = new EventEmitter();
+  elementRef = inject(ElementRef);
+  renderer = inject(Renderer2);
+  onChange = () => {};
+  onTouched = () => {};
+  ngOnInit() {
+    effect(() => {
+      const value = this.signalTreeSignalValue();
+      this.renderer.setProperty(this.elementRef.nativeElement, 'value', value);
+    });
+  }
+  handleChange(event) {
+    const target = event.target;
+    const value = target?.value;
+    if (value !== undefined) {
+      this.signalTreeSignalValue.set(value);
+      this.signalTreeSignalValueChange.emit(value);
+      this.onChange(value);
+    }
+  }
+  handleBlur() {
+    this.onTouched();
+  }
+  writeValue(value) {
+    if (value !== undefined) {
+      this.signalTreeSignalValue.set(value);
+    }
+  }
+  registerOnChange(fn) {
+    this.onChange = fn;
+  }
+  registerOnTouched(fn) {
+    this.onTouched = fn;
+  }
+  setDisabledState(isDisabled) {
+    this.renderer.setProperty(this.elementRef.nativeElement, 'disabled', isDisabled);
+  }
+};
+__decorate([Input(), __metadata("design:type", Function)], SignalValueDirective.prototype, "signalTreeSignalValue", void 0);
+__decorate([Output(), __metadata("design:type", Object)], SignalValueDirective.prototype, "signalTreeSignalValueChange", void 0);
+__decorate([HostListener('input', ['$event']), HostListener('change', ['$event']), __metadata("design:type", Function), __metadata("design:paramtypes", [Event]), __metadata("design:returntype", void 0)], SignalValueDirective.prototype, "handleChange", null);
+__decorate([HostListener('blur'), __metadata("design:type", Function), __metadata("design:paramtypes", []), __metadata("design:returntype", void 0)], SignalValueDirective.prototype, "handleBlur", null);
+SignalValueDirective = __decorate([Directive({
+  selector: '[signalTreeSignalValue]',
+  providers: [{
+    provide: NG_VALUE_ACCESSOR,
+    useExisting: forwardRef(() => SignalValueDirective),
+    multi: true
+  }],
+  standalone: true
+})], SignalValueDirective);
+const SIGNAL_FORM_DIRECTIVES = [SignalValueDirective];
+
+export { FormValidationError, SIGNAL_FORM_DIRECTIVES, SignalValueDirective, createFormTree, createVirtualFormArray };

package/dist/core/validators.js

@@ -0,0 +1,56 @@
+function required(message = 'Required') {
+  return value => !value ? message : null;
+}
+function email(message = 'Invalid email') {
+  return value => {
+    const strValue = value;
+    return strValue && !strValue.includes('@') ? message : null;
+  };
+}
+function minLength(min, message) {
+  return value => {
+    const strValue = value;
+    const errorMsg = message ?? `Min ${min} characters`;
+    return strValue && strValue.length < min ? errorMsg : null;
+  };
+}
+function maxLength(max, message) {
+  return value => {
+    const strValue = value;
+    const errorMsg = message ?? `Max ${max} characters`;
+    return strValue && strValue.length > max ? errorMsg : null;
+  };
+}
+function pattern(regex, message = 'Invalid format') {
+  return value => {
+    const strValue = value;
+    return strValue && !regex.test(strValue) ? message : null;
+  };
+}
+function min(min, message) {
+  return value => {
+    const numValue = value;
+    const errorMsg = message ?? `Must be at least ${min}`;
+    return numValue < min ? errorMsg : null;
+  };
+}
+function max(max, message) {
+  return value => {
+    const numValue = value;
+    const errorMsg = message ?? `Must be at most ${max}`;
+    return numValue > max ? errorMsg : null;
+  };
+}
+function compose(validators) {
+  return value => {
+    for (const validator of validators) {
+      const error = validator(value);
+      if (error) {
+        return error;
+      }
+    }
+    return null;
+  };
+}
+
+export { compose, email, max, maxLength, min, minLength, pattern, required };

package/dist/deep-clone.js

@@ -0,0 +1,80 @@
+const globalStructuredClone = typeof globalThis === 'object' && globalThis !== null ? globalThis.structuredClone : undefined;
+function deepClone(value) {
+  if (globalStructuredClone) {
+    try {
+      return globalStructuredClone(value);
+    } catch (_a) {}
+  }
+  return cloneValue(value, new WeakMap());
+}
+function cloneValue(value, seen) {
+  if (value === null || typeof value !== 'object') {
+    return value;
+  }
+  if (typeof value === 'function') {
+    return value;
+  }
+  const existing = seen.get(value);
+  if (existing) {
+    return existing;
+  }
+  if (value instanceof Date) {
+    return new Date(value.getTime());
+  }
+  if (value instanceof RegExp) {
+    return new RegExp(value.source, value.flags);
+  }
+  if (value instanceof Map) {
+    const result = new Map();
+    seen.set(value, result);
+    for (const [key, entryValue] of value) {
+      result.set(cloneValue(key, seen), cloneValue(entryValue, seen));
+    }
+    return result;
+  }
+  if (value instanceof Set) {
+    const result = new Set();
+    seen.set(value, result);
+    for (const entry of value) {
+      result.add(cloneValue(entry, seen));
+    }
+    return result;
+  }
+  if (Array.isArray(value)) {
+    const result = new Array(value.length);
+    seen.set(value, result);
+    for (let i = 0; i < value.length; i++) {
+      result[i] = cloneValue(value[i], seen);
+    }
+    return result;
+  }
+  if (ArrayBuffer.isView(value)) {
+    if (value instanceof DataView) {
+      const bufferClone = cloneValue(value.buffer, seen);
+      return new DataView(bufferClone, value.byteOffset, value.byteLength);
+    }
+    const viewWithSlice = value;
+    if (typeof viewWithSlice.slice === 'function') {
+      return viewWithSlice.slice();
+    }
+    const bufferClone = cloneValue(value.buffer, seen);
+    return new value.constructor(bufferClone, value.byteOffset, value.length);
+  }
+  if (value instanceof ArrayBuffer) {
+    return value.slice(0);
+  }
+  const proto = Object.getPrototypeOf(value);
+  const result = proto ? Object.create(proto) : {};
+  seen.set(value, result);
+  for (const key of Reflect.ownKeys(value)) {
+    const descriptor = Object.getOwnPropertyDescriptor(value, key);
+    if (!descriptor) continue;
+    if ('value' in descriptor) {
+      descriptor.value = cloneValue(descriptor.value, seen);
+    }
+    Object.defineProperty(result, key, descriptor);
+  }
+  return result;
+}
+
+export { deepClone };

package/dist/history/history.js

@@ -0,0 +1,113 @@
+import { signal } from '@angular/core';
+import { deepClone } from '../deep-clone.js';
+import { snapshotsEqual } from '../snapshots-equal.js';
+
+function withFormHistory(formTree, options = {}) {
+  const capacity = Math.max(1, options.capacity ?? 10);
+  const historySignal = signal({
+    past: [],
+    present: deepClone(formTree.form.getRawValue()),
+    future: []
+  });
+  let recording = true;
+  let suppressUpdates = 0;
+  let internalHistory = {
+    past: [],
+    present: deepClone(formTree.form.getRawValue()),
+    future: []
+  };
+  const subscription = formTree.form.valueChanges.subscribe(() => {
+    if (suppressUpdates > 0) {
+      suppressUpdates--;
+      return;
+    }
+    if (!recording) {
+      internalHistory = {
+        ...internalHistory,
+        present: deepClone(formTree.form.getRawValue())
+      };
+      return;
+    }
+    const snapshot = deepClone(formTree.form.getRawValue());
+    if (snapshotsEqual(internalHistory.present, snapshot)) {
+      internalHistory = {
+        ...internalHistory,
+        present: snapshot
+      };
+      historySignal.set(cloneHistory(internalHistory));
+      return;
+    }
+    const updatedPast = [...internalHistory.past, internalHistory.present];
+    if (updatedPast.length > capacity) {
+      updatedPast.shift();
+    }
+    internalHistory = {
+      past: updatedPast,
+      present: snapshot,
+      future: []
+    };
+    historySignal.set(cloneHistory(internalHistory));
+  });
+  const originalDestroy = formTree.destroy;
+  formTree.destroy = () => {
+    subscription.unsubscribe();
+    originalDestroy();
+  };
+  const undo = () => {
+    const history = historySignal();
+    if (history.past.length === 0) {
+      return;
+    }
+    const previous = deepClone(history.past[history.past.length - 1]);
+    recording = false;
+    suppressUpdates++;
+    formTree.setValues(previous);
+    recording = true;
+    internalHistory = {
+      past: history.past.slice(0, -1),
+      present: previous,
+      future: [history.present, ...history.future]
+    };
+    historySignal.set(cloneHistory(internalHistory));
+  };
+  const redo = () => {
+    const history = historySignal();
+    if (history.future.length === 0) {
+      return;
+    }
+    const next = deepClone(history.future[0]);
+    recording = false;
+    suppressUpdates++;
+    formTree.setValues(next);
+    recording = true;
+    internalHistory = {
+      past: [...history.past, history.present],
+      present: next,
+      future: history.future.slice(1)
+    };
+    historySignal.set(cloneHistory(internalHistory));
+  };
+  const clearHistory = () => {
+    internalHistory = {
+      past: [],
+      present: deepClone(formTree.form.getRawValue()),
+      future: []
+    };
+    historySignal.set(cloneHistory(internalHistory));
+  };
+  function cloneHistory(state) {
+    return {
+      past: state.past.map(entry => deepClone(entry)),
+      present: deepClone(state.present),
+      future: state.future.map(entry => deepClone(entry))
+    };
+  }
+  return Object.assign(formTree, {
+    undo,
+    redo,
+    clearHistory,
+    history: historySignal.asReadonly()
+  });
+}
+
+export { withFormHistory };

package/dist/index.d.ts

@@ -0,0 +1 @@
+export * from "./src/index";

package/dist/index.js

@@ -0,0 +1,4 @@
+export { FormValidationError, SIGNAL_FORM_DIRECTIVES, SignalValueDirective, createFormTree, createVirtualFormArray } from './core/ng-forms.js';
+export { compose, email, max, maxLength, min, minLength, pattern, required } from './core/validators.js';
+export { debounce, unique } from './core/async-validators.js';
+export { withFormHistory } from './history/history.js';

package/dist/lru-cache.js

@@ -0,0 +1,64 @@
+class LRUCache {
+  constructor(maxSize) {
+    this.maxSize = maxSize;
+    this.cache = new Map();
+    if (!Number.isFinite(maxSize) || maxSize <= 0) {
+      throw new Error('LRUCache maxSize must be a positive, finite number');
+    }
+  }
+  set(key, value) {
+    if (this.cache.has(key)) {
+      this.cache.delete(key);
+    }
+    this.cache.set(key, value);
+    if (this.cache.size > this.maxSize) {
+      const oldestKey = this.cache.keys().next().value;
+      if (oldestKey !== undefined) {
+        this.cache.delete(oldestKey);
+      }
+    }
+  }
+  get(key) {
+    if (!this.cache.has(key)) return undefined;
+    const value = this.cache.get(key);
+    if (value !== undefined) {
+      this.cache.delete(key);
+      this.cache.set(key, value);
+    }
+    return value;
+  }
+  delete(key) {
+    this.cache.delete(key);
+  }
+  has(key) {
+    return this.cache.has(key);
+  }
+  clear() {
+    this.cache.clear();
+  }
+  size() {
+    return this.cache.size;
+  }
+  forEach(callback) {
+    this.cache.forEach((value, key) => callback(value, key));
+  }
+  entries() {
+    return this.cache.entries();
+  }
+  keys() {
+    return this.cache.keys();
+  }
+  resize(newSize) {
+    if (!Number.isFinite(newSize) || newSize <= 0) {
+      throw new Error('LRUCache newSize must be a positive, finite number');
+    }
+    this.maxSize = newSize;
+    while (this.cache.size > this.maxSize) {
+      const oldestKey = this.cache.keys().next().value;
+      if (oldestKey === undefined) break;
+      this.cache.delete(oldestKey);
+    }
+  }
+}
+
+export { LRUCache };

package/dist/match-path.js

@@ -0,0 +1,13 @@
+function matchPath(pattern, path) {
+  if (pattern === path) {
+    return true;
+  }
+  const patternSegments = pattern.split('.');
+  const pathSegments = path.split('.');
+  if (patternSegments.length !== pathSegments.length) {
+    return false;
+  }
+  return patternSegments.every((segment, index) => segment === '*' || segment === pathSegments[index]);
+}
+
+export { matchPath };

package/dist/merge-deep.js

@@ -0,0 +1,26 @@
+import { deepClone } from './deep-clone.js';
+
+function mergeDeep(target, source) {
+  if (!source || typeof source !== 'object') {
+    return target;
+  }
+  const targetObj = target;
+  const sourceObj = source;
+  for (const [key, value] of Object.entries(sourceObj)) {
+    if (value === undefined) {
+      continue;
+    }
+    const current = targetObj[key];
+    if (isPlainObject(current) && isPlainObject(value)) {
+      targetObj[key] = mergeDeep(deepClone(current), value);
+      continue;
+    }
+    targetObj[key] = deepClone(value);
+  }
+  return target;
+}
+function isPlainObject(value) {
+  return !!value && typeof value === 'object' && !Array.isArray(value) && Object.prototype.toString.call(value) === '[object Object]';
+}
+
+export { mergeDeep };

package/dist/parse-path.js

@@ -0,0 +1,13 @@
+import { DEFAULT_PATH_CACHE_SIZE } from './constants.js';
+import { LRUCache } from './lru-cache.js';
+
+const pathCache = new LRUCache(DEFAULT_PATH_CACHE_SIZE);
+function parsePath(path) {
+  const cached = pathCache.get(path);
+  if (cached) return cached;
+  const segments = path.split('.');
+  pathCache.set(path, segments);
+  return segments;
+}
+
+export { parsePath };

package/dist/snapshots-equal.js

@@ -0,0 +1,5 @@
+function snapshotsEqual(a, b) {
+  return JSON.stringify(a) === JSON.stringify(b);
+}
+
+export { snapshotsEqual };

package/dist/tslib.es6.js

@@ -0,0 +1,34 @@
+/******************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+/* global Reflect, Promise, SuppressedError, Symbol, Iterator */
+
+
+function __decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+
+function __metadata(metadataKey, metadataValue) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(metadataKey, metadataValue);
+}
+
+typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+};
+
+export { __decorate, __metadata };

package/package.json

@@ -1,13 +1,18 @@
 {
   "name": "@signaltree/ng-forms",
-  "version": "4.1.4",
+  "version": "4.1.5",
   "description": "Complete Angular forms integration for SignalTree. FormTree creation, custom directives, validators, form state tracking, and RxJS bridge.",
   "peerDependencies": {
     "@angular/core": "^20.3.0",
     "@angular/forms": "^20.3.0",
-    "@signaltree/core": "4.1.4",
+    "@signaltree/core": "4.1.5",
     "rxjs": "^7.0.0"
   },
+  "devDependencies": {
+    "@signaltree/core": "workspace:*",
+    "@signaltree/shared": "workspace:*",
+    "jest-preset-angular": "^14.0.0"
+  },
   "sideEffects": false,
   "publishConfig": {
     "access": "public"
@@ -16,31 +21,5 @@
     "dist",
     "README.md",
     "package.json"
-  ],
-  "module": "fesm2022/signaltree-ng-forms.mjs",
-  "typings": "index.d.ts",
-  "exports": {
-    "./package.json": {
-      "default": "./package.json"
-    },
-    ".": {
-      "types": "./index.d.ts",
-      "default": "./fesm2022/signaltree-ng-forms.mjs"
-    },
-    "./src/audit": {
-      "types": "./src/audit/index.d.ts",
-      "default": "./fesm2022/signaltree-ng-forms-src-audit.mjs"
-    },
-    "./src/history": {
-      "types": "./src/history/index.d.ts",
-      "default": "./fesm2022/signaltree-ng-forms-src-history.mjs"
-    },
-    "./src/rxjs": {
-      "types": "./src/rxjs/index.d.ts",
-      "default": "./fesm2022/signaltree-ng-forms-src-rxjs.mjs"
-    }
-  },
-  "dependencies": {
-    "tslib": "^2.3.0"
-  }
+  ]
 }