@angular/forms 21.1.0-next.1 → 21.1.0-next.2

package/fesm2022/signals.mjs

@@ -1,280 +1,17 @@
 /**
- * @license Angular v21.1.0-next.1
+ * @license Angular v21.1.0-next.2
  * (c) 2010-2025 Google LLC. https://angular.dev/
  * License: MIT
  */
 
-import { httpResource } from '@angular/common/http';
 import * as i0 from '@angular/core';
-import { computed, InjectionToken, inject, Injector, input, ɵCONTROL as _CONTROL, effect, Directive, ɵɵcontrolCreate as __controlCreate, ɵcontrolUpdate as _controlUpdate, ɵisPromise as _isPromise, resource } from '@angular/core';
-import { isArray, assertPathIsCurrent, addDefaultField, FieldPathNode, createMetadataKey, DEBOUNCER, REQUIRED, MAX, MAX_LENGTH, MIN, MIN_LENGTH, PATTERN } from './_structure-chunk.mjs';
-export { AggregateMetadataKey, MetadataKey, andMetadataKey, apply, applyEach, applyWhen, applyWhenValue, form, listMetadataKey, maxMetadataKey, minMetadataKey, orMetadataKey, reducedMetadataKey, schema, submit } from './_structure-chunk.mjs';
+import { InjectionToken, inject, ElementRef, Injector, input, computed, ɵCONTROL as _CONTROL, effect, Directive, ɵɵcontrolCreate as __controlCreate, ɵcontrolUpdate as _controlUpdate, ɵisPromise as _isPromise, resource } from '@angular/core';
 import { Validators, NG_VALUE_ACCESSOR, NgControl } from '@angular/forms';
+import { assertPathIsCurrent, FieldPathNode, isArray, addDefaultField, metadata, createMetadataKey, MAX, MAX_LENGTH, MIN, MIN_LENGTH, PATTERN, REQUIRED, createManagedMetadataKey, DEBOUNCER } from './_structure-chunk.mjs';
+export { MetadataKey, MetadataReducer, apply, applyEach, applyWhen, applyWhenValue, form, schema, submit } from './_structure-chunk.mjs';
+import { httpResource } from '@angular/common/http';
 import '@angular/core/primitives/signals';
 
-function requiredError(options) {
-  return new RequiredValidationError(options);
-}
-function minError(min, options) {
-  return new MinValidationError(min, options);
-}
-function maxError(max, options) {
-  return new MaxValidationError(max, options);
-}
-function minLengthError(minLength, options) {
-  return new MinLengthValidationError(minLength, options);
-}
-function maxLengthError(maxLength, options) {
-  return new MaxLengthValidationError(maxLength, options);
-}
-function patternError(pattern, options) {
-  return new PatternValidationError(pattern, options);
-}
-function emailError(options) {
-  return new EmailValidationError(options);
-}
-function standardSchemaError(issue, options) {
-  return new StandardSchemaValidationError(issue, options);
-}
-function customError(obj) {
-  return new CustomValidationError(obj);
-}
-class CustomValidationError {
-  __brand = undefined;
-  kind = '';
-  field;
-  message;
-  constructor(options) {
-    if (options) {
-      Object.assign(this, options);
-    }
-  }
-}
-class _NgValidationError {
-  __brand = undefined;
-  kind = '';
-  field;
-  message;
-  constructor(options) {
-    if (options) {
-      Object.assign(this, options);
-    }
-  }
-}
-class RequiredValidationError extends _NgValidationError {
-  kind = 'required';
-}
-class MinValidationError extends _NgValidationError {
-  min;
-  kind = 'min';
-  constructor(min, options) {
-    super(options);
-    this.min = min;
-  }
-}
-class MaxValidationError extends _NgValidationError {
-  max;
-  kind = 'max';
-  constructor(max, options) {
-    super(options);
-    this.max = max;
-  }
-}
-class MinLengthValidationError extends _NgValidationError {
-  minLength;
-  kind = 'minLength';
-  constructor(minLength, options) {
-    super(options);
-    this.minLength = minLength;
-  }
-}
-class MaxLengthValidationError extends _NgValidationError {
-  maxLength;
-  kind = 'maxLength';
-  constructor(maxLength, options) {
-    super(options);
-    this.maxLength = maxLength;
-  }
-}
-class PatternValidationError extends _NgValidationError {
-  pattern;
-  kind = 'pattern';
-  constructor(pattern, options) {
-    super(options);
-    this.pattern = pattern;
-  }
-}
-class EmailValidationError extends _NgValidationError {
-  kind = 'email';
-}
-class StandardSchemaValidationError extends _NgValidationError {
-  issue;
-  kind = 'standardSchema';
-  constructor(issue, options) {
-    super(options);
-    this.issue = issue;
-  }
-}
-const NgValidationError = _NgValidationError;
-
-function getLengthOrSize(value) {
-  const v = value;
-  return typeof v.length === 'number' ? v.length : v.size;
-}
-function getOption(opt, ctx) {
-  return opt instanceof Function ? opt(ctx) : opt;
-}
-function isEmpty(value) {
-  if (typeof value === 'number') {
-    return isNaN(value);
-  }
-  return value === '' || value === false || value == null;
-}
-function isPlainError(error) {
-  return typeof error === 'object' && (Object.getPrototypeOf(error) === Object.prototype || Object.getPrototypeOf(error) === null);
-}
-function ensureCustomValidationError(error) {
-  if (isPlainError(error)) {
-    return customError(error);
-  }
-  return error;
-}
-function ensureCustomValidationResult(result) {
-  if (result === null || result === undefined) {
-    return result;
-  }
-  if (isArray(result)) {
-    return result.map(ensureCustomValidationError);
-  }
-  return ensureCustomValidationError(result);
-}
-
-function disabled(path, logic) {
-  assertPathIsCurrent(path);
-  const pathNode = FieldPathNode.unwrapFieldPath(path);
-  pathNode.builder.addDisabledReasonRule(ctx => {
-    let result = true;
-    if (typeof logic === 'string') {
-      result = logic;
-    } else if (logic) {
-      result = logic(ctx);
-    }
-    if (typeof result === 'string') {
-      return {
-        field: ctx.field,
-        message: result
-      };
-    }
-    return result ? {
-      field: ctx.field
-    } : undefined;
-  });
-}
-function readonly(path, logic = () => true) {
-  assertPathIsCurrent(path);
-  const pathNode = FieldPathNode.unwrapFieldPath(path);
-  pathNode.builder.addReadonlyRule(logic);
-}
-function hidden(path, logic) {
-  assertPathIsCurrent(path);
-  const pathNode = FieldPathNode.unwrapFieldPath(path);
-  pathNode.builder.addHiddenRule(logic);
-}
-function validate(path, logic) {
-  assertPathIsCurrent(path);
-  const pathNode = FieldPathNode.unwrapFieldPath(path);
-  pathNode.builder.addSyncErrorRule(ctx => {
-    return ensureCustomValidationResult(addDefaultField(logic(ctx), ctx.field));
-  });
-}
-function validateTree(path, logic) {
-  assertPathIsCurrent(path);
-  const pathNode = FieldPathNode.unwrapFieldPath(path);
-  pathNode.builder.addSyncTreeErrorRule(ctx => addDefaultField(logic(ctx), ctx.field));
-}
-function aggregateMetadata(path, key, logic) {
-  assertPathIsCurrent(path);
-  const pathNode = FieldPathNode.unwrapFieldPath(path);
-  pathNode.builder.addAggregateMetadataRule(key, logic);
-}
-function metadata(path, ...rest) {
-  assertPathIsCurrent(path);
-  let key;
-  let factory;
-  if (rest.length === 2) {
-    [key, factory] = rest;
-  } else {
-    [factory] = rest;
-  }
-  key ??= createMetadataKey();
-  const pathNode = FieldPathNode.unwrapFieldPath(path);
-  pathNode.builder.addMetadataFactory(key, factory);
-  return key;
-}
-
-function validateAsync(path, opts) {
-  assertPathIsCurrent(path);
-  const pathNode = FieldPathNode.unwrapFieldPath(path);
-  const RESOURCE = metadata(path, ctx => {
-    const params = computed(() => {
-      const node = ctx.stateOf(path);
-      const validationState = node.validationState;
-      if (validationState.shouldSkipValidation() || !validationState.syncValid()) {
-        return undefined;
-      }
-      return opts.params(ctx);
-    }, ...(ngDevMode ? [{
-      debugName: "params"
-    }] : []));
-    return opts.factory(params);
-  });
-  pathNode.builder.addAsyncErrorRule(ctx => {
-    const res = ctx.state.metadata(RESOURCE);
-    let errors;
-    switch (res.status()) {
-      case 'idle':
-        return undefined;
-      case 'loading':
-      case 'reloading':
-        return 'pending';
-      case 'resolved':
-      case 'local':
-        if (!res.hasValue()) {
-          return undefined;
-        }
-        errors = opts.onSuccess(res.value(), ctx);
-        return addDefaultField(errors, ctx.field);
-      case 'error':
-        errors = opts.onError(res.error(), ctx);
-        return addDefaultField(errors, ctx.field);
-    }
-  });
-}
-function validateHttp(path, opts) {
-  validateAsync(path, {
-    params: opts.request,
-    factory: request => httpResource(request, opts.options),
-    onSuccess: opts.onSuccess,
-    onError: opts.onError
-  });
-}
-
-function debounce(path, durationOrDebouncer) {
-  assertPathIsCurrent(path);
-  const pathNode = FieldPathNode.unwrapFieldPath(path);
-  const debouncer = typeof durationOrDebouncer === 'function' ? durationOrDebouncer : durationOrDebouncer > 0 ? debounceForDuration(durationOrDebouncer) : immediate;
-  pathNode.builder.addAggregateMetadataRule(DEBOUNCER, () => debouncer);
-}
-function debounceForDuration(durationInMilliseconds) {
-  return (_context, abortSignal) => {
-    return new Promise(resolve => {
-      const timeoutId = setTimeout(resolve, durationInMilliseconds);
-      abortSignal.addEventListener('abort', () => clearTimeout(timeoutId));
-    });
-  };
-}
-function immediate() {}
-
 const SIGNAL_FORMS_CONFIG = new InjectionToken(typeof ngDevMode !== 'undefined' && ngDevMode ? 'SIGNAL_FORMS_CONFIG' : '');
 
 function provideSignalFormsConfig(config) {
@@ -349,24 +86,21 @@ class InteropNgControl {
   valueAccessor = null;
   hasValidator(validator) {
     if (validator === Validators.required) {
-      return this.field().metadata(REQUIRED)();
+      return this.field().required();
     }
     return false;
   }
   updateValueAndValidity() {}
 }
 
-const FIELD = new InjectionToken(typeof ngDevMode !== undefined && ngDevMode ? 'FIELD' : '');
+const FIELD = new InjectionToken(typeof ngDevMode !== 'undefined' && ngDevMode ? 'FIELD' : '');
 const controlInstructions = {
   create: __controlCreate,
   update: _controlUpdate
 };
 class Field {
+  element = inject(ElementRef).nativeElement;
   injector = inject(Injector);
-  config = inject(SIGNAL_FORMS_CONFIG, {
-    optional: true
-  });
-  classes = Object.entries(this.config?.classes ?? {}).map(([className, computation]) => [className, computed(() => computation(this.state()))]);
   field = input.required(...(ngDevMode ? [{
     debugName: "field"
   }] : []));
@@ -374,6 +108,10 @@ class Field {
     debugName: "state"
   }] : []));
   [_CONTROL] = controlInstructions;
+  config = inject(SIGNAL_FORMS_CONFIG, {
+    optional: true
+  });
+  classes = Object.entries(this.config?.classes ?? {}).map(([className, computation]) => [className, computed(() => computation(this.state()))]);
   controlValueAccessors = inject(NG_VALUE_ACCESSOR, {
     optional: true,
     self: true
@@ -398,7 +136,7 @@ class Field {
   }
   static ɵfac = i0.ɵɵngDeclareFactory({
     minVersion: "12.0.0",
-    version: "21.1.0-next.1",
+    version: "21.1.0-next.2",
     ngImport: i0,
     type: Field,
     deps: [],
@@ -406,7 +144,7 @@ class Field {
   });
   static ɵdir = i0.ɵɵngDeclareDirective({
     minVersion: "17.1.0",
-    version: "21.1.0-next.1",
+    version: "21.1.0-next.2",
     type: Field,
     isStandalone: true,
     selector: "[field]",
@@ -431,7 +169,7 @@ class Field {
 }
 i0.ɵɵngDeclareClassMetadata({
   minVersion: "12.0.0",
-  version: "21.1.0-next.1",
+  version: "21.1.0-next.2",
   ngImport: i0,
   type: Field,
   decorators: [{
@@ -459,6 +197,185 @@ i0.ɵɵngDeclareClassMetadata({
   }
 });
 
+function disabled(path, logic) {
+  assertPathIsCurrent(path);
+  const pathNode = FieldPathNode.unwrapFieldPath(path);
+  pathNode.builder.addDisabledReasonRule(ctx => {
+    let result = true;
+    if (typeof logic === 'string') {
+      result = logic;
+    } else if (logic) {
+      result = logic(ctx);
+    }
+    if (typeof result === 'string') {
+      return {
+        field: ctx.field,
+        message: result
+      };
+    }
+    return result ? {
+      field: ctx.field
+    } : undefined;
+  });
+}
+
+function hidden(path, logic) {
+  assertPathIsCurrent(path);
+  const pathNode = FieldPathNode.unwrapFieldPath(path);
+  pathNode.builder.addHiddenRule(logic);
+}
+
+function readonly(path, logic = () => true) {
+  assertPathIsCurrent(path);
+  const pathNode = FieldPathNode.unwrapFieldPath(path);
+  pathNode.builder.addReadonlyRule(logic);
+}
+
+function requiredError(options) {
+  return new RequiredValidationError(options);
+}
+function minError(min, options) {
+  return new MinValidationError(min, options);
+}
+function maxError(max, options) {
+  return new MaxValidationError(max, options);
+}
+function minLengthError(minLength, options) {
+  return new MinLengthValidationError(minLength, options);
+}
+function maxLengthError(maxLength, options) {
+  return new MaxLengthValidationError(maxLength, options);
+}
+function patternError(pattern, options) {
+  return new PatternValidationError(pattern, options);
+}
+function emailError(options) {
+  return new EmailValidationError(options);
+}
+function standardSchemaError(issue, options) {
+  return new StandardSchemaValidationError(issue, options);
+}
+function customError(obj) {
+  return new CustomValidationError(obj);
+}
+class CustomValidationError {
+  __brand = undefined;
+  kind = '';
+  field;
+  message;
+  constructor(options) {
+    if (options) {
+      Object.assign(this, options);
+    }
+  }
+}
+class _NgValidationError {
+  __brand = undefined;
+  kind = '';
+  field;
+  message;
+  constructor(options) {
+    if (options) {
+      Object.assign(this, options);
+    }
+  }
+}
+class RequiredValidationError extends _NgValidationError {
+  kind = 'required';
+}
+class MinValidationError extends _NgValidationError {
+  min;
+  kind = 'min';
+  constructor(min, options) {
+    super(options);
+    this.min = min;
+  }
+}
+class MaxValidationError extends _NgValidationError {
+  max;
+  kind = 'max';
+  constructor(max, options) {
+    super(options);
+    this.max = max;
+  }
+}
+class MinLengthValidationError extends _NgValidationError {
+  minLength;
+  kind = 'minLength';
+  constructor(minLength, options) {
+    super(options);
+    this.minLength = minLength;
+  }
+}
+class MaxLengthValidationError extends _NgValidationError {
+  maxLength;
+  kind = 'maxLength';
+  constructor(maxLength, options) {
+    super(options);
+    this.maxLength = maxLength;
+  }
+}
+class PatternValidationError extends _NgValidationError {
+  pattern;
+  kind = 'pattern';
+  constructor(pattern, options) {
+    super(options);
+    this.pattern = pattern;
+  }
+}
+class EmailValidationError extends _NgValidationError {
+  kind = 'email';
+}
+class StandardSchemaValidationError extends _NgValidationError {
+  issue;
+  kind = 'standardSchema';
+  constructor(issue, options) {
+    super(options);
+    this.issue = issue;
+  }
+}
+const NgValidationError = _NgValidationError;
+
+function getLengthOrSize(value) {
+  const v = value;
+  return typeof v.length === 'number' ? v.length : v.size;
+}
+function getOption(opt, ctx) {
+  return opt instanceof Function ? opt(ctx) : opt;
+}
+function isEmpty(value) {
+  if (typeof value === 'number') {
+    return isNaN(value);
+  }
+  return value === '' || value === false || value == null;
+}
+function isPlainError(error) {
+  return typeof error === 'object' && (Object.getPrototypeOf(error) === Object.prototype || Object.getPrototypeOf(error) === null);
+}
+function ensureCustomValidationError(error) {
+  if (isPlainError(error)) {
+    return customError(error);
+  }
+  return error;
+}
+function ensureCustomValidationResult(result) {
+  if (result === null || result === undefined) {
+    return result;
+  }
+  if (isArray(result)) {
+    return result.map(ensureCustomValidationError);
+  }
+  return ensureCustomValidationError(result);
+}
+
+function validate(path, logic) {
+  assertPathIsCurrent(path);
+  const pathNode = FieldPathNode.unwrapFieldPath(path);
+  pathNode.builder.addSyncErrorRule(ctx => {
+    return ensureCustomValidationResult(addDefaultField(logic(ctx), ctx.field));
+  });
+}
+
 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])?)*$/;
 function email(path, config) {
   validate(path, ctx => {
@@ -479,8 +396,8 @@ function email(path, config) {
 }
 
 function max(path, maxValue, config) {
-  const MAX_MEMO = metadata(path, ctx => computed(() => typeof maxValue === 'number' ? maxValue : maxValue(ctx)));
-  aggregateMetadata(path, MAX, ({
+  const MAX_MEMO = metadata(path, createMetadataKey(), ctx => typeof maxValue === 'number' ? maxValue : maxValue(ctx));
+  metadata(path, MAX, ({
     state
   }) => state.metadata(MAX_MEMO)());
   validate(path, ctx => {
@@ -507,8 +424,8 @@ function max(path, maxValue, config) {
 }
 
 function maxLength(path, maxLength, config) {
-  const MAX_LENGTH_MEMO = metadata(path, ctx => computed(() => typeof maxLength === 'number' ? maxLength : maxLength(ctx)));
-  aggregateMetadata(path, MAX_LENGTH, ({
+  const MAX_LENGTH_MEMO = metadata(path, createMetadataKey(), ctx => typeof maxLength === 'number' ? maxLength : maxLength(ctx));
+  metadata(path, MAX_LENGTH, ({
     state
   }) => state.metadata(MAX_LENGTH_MEMO)());
   validate(path, ctx => {
@@ -533,8 +450,8 @@ function maxLength(path, maxLength, config) {
 }
 
 function min(path, minValue, config) {
-  const MIN_MEMO = metadata(path, ctx => computed(() => typeof minValue === 'number' ? minValue : minValue(ctx)));
-  aggregateMetadata(path, MIN, ({
+  const MIN_MEMO = metadata(path, createMetadataKey(), ctx => typeof minValue === 'number' ? minValue : minValue(ctx));
+  metadata(path, MIN, ({
     state
   }) => state.metadata(MIN_MEMO)());
   validate(path, ctx => {
@@ -561,8 +478,8 @@ function min(path, minValue, config) {
 }
 
 function minLength(path, minLength, config) {
-  const MIN_LENGTH_MEMO = metadata(path, ctx => computed(() => typeof minLength === 'number' ? minLength : minLength(ctx)));
-  aggregateMetadata(path, MIN_LENGTH, ({
+  const MIN_LENGTH_MEMO = metadata(path, createMetadataKey(), ctx => typeof minLength === 'number' ? minLength : minLength(ctx));
+  metadata(path, MIN_LENGTH, ({
     state
   }) => state.metadata(MIN_LENGTH_MEMO)());
   validate(path, ctx => {
@@ -587,8 +504,8 @@ function minLength(path, minLength, config) {
 }
 
 function pattern(path, pattern, config) {
-  const PATTERN_MEMO = metadata(path, ctx => computed(() => pattern instanceof RegExp ? pattern : pattern(ctx)));
-  aggregateMetadata(path, PATTERN, ({
+  const PATTERN_MEMO = metadata(path, createMetadataKey(), ctx => pattern instanceof RegExp ? pattern : pattern(ctx));
+  metadata(path, PATTERN, ({
     state
   }) => state.metadata(PATTERN_MEMO)());
   validate(path, ctx => {
@@ -613,8 +530,8 @@ function pattern(path, pattern, config) {
 }
 
 function required(path, config) {
-  const REQUIRED_MEMO = metadata(path, ctx => computed(() => config?.when ? config.when(ctx) : true));
-  aggregateMetadata(path, REQUIRED, ({
+  const REQUIRED_MEMO = metadata(path, createMetadataKey(), ctx => config?.when ? config.when(ctx) : true);
+  metadata(path, REQUIRED, ({
     state
   }) => state.metadata(REQUIRED_MEMO)());
   validate(path, ctx => {
@@ -631,11 +548,52 @@ function required(path, config) {
   });
 }
 
+function validateAsync(path, opts) {
+  assertPathIsCurrent(path);
+  const pathNode = FieldPathNode.unwrapFieldPath(path);
+  const RESOURCE = createManagedMetadataKey(opts.factory);
+  metadata(path, RESOURCE, ctx => {
+    const node = ctx.stateOf(path);
+    const validationState = node.validationState;
+    if (validationState.shouldSkipValidation() || !validationState.syncValid()) {
+      return undefined;
+    }
+    return opts.params(ctx);
+  });
+  pathNode.builder.addAsyncErrorRule(ctx => {
+    const res = ctx.state.metadata(RESOURCE);
+    let errors;
+    switch (res.status()) {
+      case 'idle':
+        return undefined;
+      case 'loading':
+      case 'reloading':
+        return 'pending';
+      case 'resolved':
+      case 'local':
+        if (!res.hasValue()) {
+          return undefined;
+        }
+        errors = opts.onSuccess(res.value(), ctx);
+        return addDefaultField(errors, ctx.field);
+      case 'error':
+        errors = opts.onError(res.error(), ctx);
+        return addDefaultField(errors, ctx.field);
+    }
+  });
+}
+
+function validateTree(path, logic) {
+  assertPathIsCurrent(path);
+  const pathNode = FieldPathNode.unwrapFieldPath(path);
+  pathNode.builder.addSyncTreeErrorRule(ctx => addDefaultField(logic(ctx), ctx.field));
+}
+
 function validateStandardSchema(path, schema) {
-  const VALIDATOR_MEMO = metadata(path, ({
+  const VALIDATOR_MEMO = metadata(path, createMetadataKey(), ({
     value
   }) => {
-    return computed(() => schema['~standard'].validate(value()));
+    return schema['~standard'].validate(value());
   });
   validateTree(path, ({
     state,
@@ -645,7 +603,7 @@ function validateStandardSchema(path, schema) {
     if (_isPromise(result)) {
       return [];
     }
-    return result.issues?.map(issue => standardIssueToFormTreeError(fieldTreeOf(path), issue)) ?? [];
+    return result?.issues?.map(issue => standardIssueToFormTreeError(fieldTreeOf(path), issue)) ?? [];
   });
   validateAsync(path, {
     params: ({
@@ -681,5 +639,30 @@ function standardIssueToFormTreeError(field, issue) {
   }), target);
 }
 
-export { CustomValidationError, EmailValidationError, FIELD, Field, MAX, MAX_LENGTH, MIN, MIN_LENGTH, MaxLengthValidationError, MaxValidationError, MinLengthValidationError, MinValidationError, NgValidationError, PATTERN, PatternValidationError, REQUIRED, RequiredValidationError, StandardSchemaValidationError, aggregateMetadata, createMetadataKey, customError, debounce, disabled, email, emailError, hidden, max, maxError, maxLength, maxLengthError, metadata, min, minError, minLength, minLengthError, pattern, patternError, provideSignalFormsConfig, readonly, required, requiredError, standardSchemaError, validate, validateAsync, validateHttp, validateStandardSchema, validateTree };
+function validateHttp(path, opts) {
+  validateAsync(path, {
+    params: opts.request,
+    factory: request => httpResource(request, opts.options),
+    onSuccess: opts.onSuccess,
+    onError: opts.onError
+  });
+}
+
+function debounce(path, durationOrDebouncer) {
+  assertPathIsCurrent(path);
+  const pathNode = FieldPathNode.unwrapFieldPath(path);
+  const debouncer = typeof durationOrDebouncer === 'function' ? durationOrDebouncer : durationOrDebouncer > 0 ? debounceForDuration(durationOrDebouncer) : immediate;
+  pathNode.builder.addMetadataRule(DEBOUNCER, () => debouncer);
+}
+function debounceForDuration(durationInMilliseconds) {
+  return (_context, abortSignal) => {
+    return new Promise(resolve => {
+      const timeoutId = setTimeout(resolve, durationInMilliseconds);
+      abortSignal.addEventListener('abort', () => clearTimeout(timeoutId));
+    });
+  };
+}
+function immediate() {}
+
+export { CustomValidationError, EmailValidationError, FIELD, Field, MAX, MAX_LENGTH, MIN, MIN_LENGTH, MaxLengthValidationError, MaxValidationError, MinLengthValidationError, MinValidationError, NgValidationError, PATTERN, PatternValidationError, REQUIRED, RequiredValidationError, StandardSchemaValidationError, createManagedMetadataKey, createMetadataKey, customError, debounce, disabled, email, emailError, hidden, max, maxError, maxLength, maxLengthError, metadata, min, minError, minLength, minLengthError, pattern, patternError, provideSignalFormsConfig, readonly, required, requiredError, standardSchemaError, validate, validateAsync, validateHttp, validateStandardSchema, validateTree };
 //# sourceMappingURL=signals.mjs.map