@signaltree/ng-forms 4.2.1 → 5.0.0

package/dist/core/ng-forms.js

@@ -1,880 +0,0 @@
-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 };