ngxsmk-datepicker 2.0.2 → 2.0.4

package/README.md

@@ -7,7 +7,7 @@
 
 **npm i ngxsmk-datepicker**
 
-> **Stable Version**: `2.0.2` is the current stable release. For production use, install the latest version from npm.
+> **Stable Version**: `2.0.3` is the current stable release. For production use, install the latest version from npm.
 > 
 > ⚠️ **Warning**: Version `1.9.26` contains broken styles. If you are using `1.9.26`, please upgrade to `1.9.28` or downgrade to `1.9.25` immediately.
 
@@ -127,7 +127,7 @@ For details, see [CONTRIBUTING.md](https://github.com/NGXSMK/ngxsmk-datepicker/b
 
 Install the package using npm:
 
-    npm install ngxsmk-datepicker  
+    npm install ngxsmk-datepicker@2.0.3  
 
 ## **Usage**
 

package/docs/API.md

@@ -2180,7 +2180,7 @@ type DateInput =
 ```
 
 
-### SignalFormField (v2.0.2+)
+### SignalFormField (v2.0.3+)
 
 **Status**: Stable
 
@@ -2190,7 +2190,7 @@ Type representing a signal-based form field.
 type SignalFormField = any; // Compatible with Angular 21 FieldTree
 ```
 
-### SignalFormFieldConfig (v2.0.2+)
+### SignalFormFieldConfig (v2.0.3+)
 
 **Status**: Stable
 

package/docs/signal-forms.md

@@ -113,7 +113,7 @@ export class TwoWayComponent {
 }
 ```
 
-### Signal Field Resolution (v2.0.2+)
+### Signal Field Resolution (v2.0.3+)
 
 The datepicker includes a robust resolution mechanism for signal-based fields. It can handle:
 - **Direct Signals**: A signal that contains the field configuration.
@@ -136,6 +136,15 @@ const config: SignalFormFieldConfig = {
 };
 ```
 
+**TypeScript Compatibility (v2.0.3+):**
+
+The datepicker is fully compatible with Angular 21+ `FieldTree<string | Date | null, string>` structure. The types accept:
+- `WritableSignal<Date | null>` for date values
+- `WritableSignal<string | null>` for string date values (automatically converted to Date)
+- Any Angular Signal Forms field configuration
+
+String values from Signal Forms are automatically normalized to Date objects internally, ensuring seamless integration with Angular 21+ forms.
+
 ## Dirty State Tracking
 
 When using the `[field]` binding, the datepicker automatically tracks the form's dirty state. The form will be marked as dirty when a user selects a date:

package/fesm2022/ngxsmk-datepicker.mjs

@@ -1659,48 +1659,26 @@ function provideDatepickerConfig(config) {
     };
 }
 
-// Safe isSignal detection - works with all Angular 17+ versions including 17.0.0
-// In Angular 17.0.0, isSignal might not be available, so we use function-based detection
-// We avoid importing isSignal directly to prevent build errors in Angular 17.0.0
-// This function provides compatibility across all Angular 17 sub-versions
 function safeIsSignal(value) {
     if (value === null || value === undefined) {
         return false;
     }
-    // For Angular 17.1.0+, try to use isSignal if available via dynamic access
-    // We check at runtime to avoid build-time import resolution issues
     try {
-        // Access Angular core module dynamically to check for isSignal
-        // This avoids the @angular/core/primitives/signals resolution issue in Angular 17.0.0
         const ngCore = globalThis.ng?.core;
         if (ngCore?.isSignal && typeof ngCore.isSignal === 'function') {
             return ngCore.isSignal(value);
         }
     }
     catch {
-        // isSignal not available - use fallback detection
     }
-    // Fallback detection for Angular 17.0.0 and all versions
-    // This works by detecting signal-like function characteristics
-    // Signals in Angular are functions that can be called without arguments
     if (typeof value === 'function') {
         const fn = value;
-        // Signals are typically:
-        // 1. Functions without a prototype (or minimal prototype)
-        // 2. Callable without arguments
-        // 3. Return values when called
-        // In Angular 17.0.0, we treat callable functions as potential signals
-        // This is safe because we're in a reactive context (effect) where signals can be read
         try {
-            // Check if it's callable - if it is, treat it as a potential signal
-            // This works for Angular 17.0.0 where isSignal might not be available
             if (fn.length === 0 || fn.length === undefined) {
-                // No required arguments - likely a signal getter
                 return true;
             }
         }
         catch {
-            // Not callable - not a signal
             return false;
         }
     }
@@ -1713,36 +1691,25 @@ class FieldSyncService {
         this._isUpdatingFromInternal = false;
         this.injector = inject(Injector);
     }
-    /**
-     * Helper function to safely read a field value, handling both functions and signals
-     * This handles Angular 21 Signal Forms where field.value can be a signal directly
-     * Note: Angular signals (including computed) are detected as 'function' type
-     */
     readFieldValue(field) {
         if (!field || typeof field !== 'object' || field.value === undefined) {
             return null;
         }
         try {
             const fieldValue = field.value;
-            // For Angular 21 Signal Forms, field.value might be a function that returns the signal
-            // Try calling it first if it's a function (this handles FieldTree<Date, string> structure)
             if (typeof fieldValue === 'function') {
                 try {
                     const result = fieldValue();
-                    // If result is a signal, call it again to get the actual value
                     if (safeIsSignal(result)) {
                         const signalResult = result();
                         return signalResult !== undefined && signalResult !== null ? signalResult : null;
                     }
-                    // If result is a value (Date, object, etc.), return it
                     if (result !== undefined && result !== null) {
                         return result;
                     }
                     return null;
                 }
                 catch {
-                    // If calling fails, it might be a signal itself that needs to be called
-                    // Try checking if it's a signal
                     if (safeIsSignal(fieldValue)) {
                         try {
                             const signalResult = fieldValue();
@@ -1755,17 +1722,14 @@ class FieldSyncService {
                     return null;
                 }
             }
-            // Explicitly check for Angular Signal (compatible with all Angular 17+ versions)
             if (safeIsSignal(fieldValue)) {
                 const result = fieldValue();
                 return result !== undefined && result !== null ? result : null;
             }
-            // If it's an object, it might be a Date, range object, or a signal that isSignal didn't catch
             if (fieldValue !== null && typeof fieldValue === 'object') {
                 if (fieldValue instanceof Date) {
                     return fieldValue;
                 }
-                // Try calling it as a last resort (for computed signals that isSignal missed)
                 try {
                     const result = fieldValue();
                     if (result !== undefined && result !== null) {
@@ -1773,7 +1737,6 @@ class FieldSyncService {
                     }
                 }
                 catch {
-                    // Not callable, treat as value (could be range object {start, end} or array)
                     return fieldValue;
                 }
             }
@@ -1787,26 +1750,19 @@ class FieldSyncService {
             return null;
         }
     }
-    /**
-     * Helper function to safely read disabled state
-     * Handles both direct values, functions, and signals (Angular 21 Signal Forms)
-     */
     readDisabledState(field) {
         if (!field || (typeof field !== 'object' && typeof field !== 'function')) {
             return false;
         }
         try {
-            // Check disabled property first
             if ('disabled' in field && field.disabled !== undefined) {
                 const disabledVal = field.disabled;
-                // Explicitly check for Angular Signal (compatible with all Angular 17+ versions)
                 if (safeIsSignal(disabledVal)) {
                     return !!disabledVal();
                 }
                 if (typeof disabledVal === 'function') {
                     return !!disabledVal();
                 }
-                // Handle signals detected as objects
                 if (typeof disabledVal === 'object' && disabledVal !== null) {
                     try {
                         return !!disabledVal();
@@ -1824,10 +1780,6 @@ class FieldSyncService {
             return false;
         }
     }
-    /**
-     * Helper function to safely read validation errors from Angular Signal Forms
-     * Returns the errors array from the field's errors signal
-     */
     readFieldErrors(field) {
         if (!field || (typeof field !== 'object' && typeof field !== 'function')) {
             return [];
@@ -1835,7 +1787,6 @@ class FieldSyncService {
         try {
             if ('errors' in field && field.errors !== undefined) {
                 const errorsVal = field.errors;
-                // Check for Angular Signal
                 if (safeIsSignal(errorsVal)) {
                     const result = errorsVal();
                     return Array.isArray(result) ? result : [];
@@ -1844,7 +1795,6 @@ class FieldSyncService {
                     const result = errorsVal();
                     return Array.isArray(result) ? result : [];
                 }
-                // Handle signals detected as objects
                 if (typeof errorsVal === 'object' && errorsVal !== null) {
                     try {
                         const result = errorsVal();
@@ -1862,34 +1812,24 @@ class FieldSyncService {
             return [];
         }
     }
-    /**
-     * Helper function to safely read required state
-     * Handles both direct values, functions, and signals (Angular 21 Signal Forms)
-     * Also checks for 'required' validation errors in Angular Signal Forms
-     */
     readRequiredState(field) {
         if (!field || (typeof field !== 'object' && typeof field !== 'function')) {
             return false;
         }
         try {
-            // First, check for 'required' validation error in Angular Signal Forms
-            // This handles schema-based validation like required(p.dateDue)
             const errors = this.readFieldErrors(field);
             const hasRequiredError = errors.some(error => error.kind === 'required');
             if (hasRequiredError) {
                 return true;
             }
-            // Check required property (for direct required attribute)
             if ('required' in field && field.required !== undefined) {
                 const requiredVal = field.required;
-                // Explicitly check for Angular Signal (compatible with all Angular 17+ versions)
                 if (safeIsSignal(requiredVal)) {
                     return !!requiredVal();
                 }
                 if (typeof requiredVal === 'function') {
                     return !!requiredVal();
                 }
-                // Handle signals detected as objects
                 if (typeof requiredVal === 'object' && requiredVal !== null) {
                     try {
                         return !!requiredVal();
@@ -1906,16 +1846,11 @@ class FieldSyncService {
             return false;
         }
     }
-    /**
-     * Helper function to determine if the field has validation errors
-     * Used to set the error state on the datepicker component
-     */
     hasValidationErrors(field) {
         if (!field || (typeof field !== 'object' && typeof field !== 'function')) {
             return false;
         }
         try {
-            // Check invalid signal first (Angular Signal Forms)
             if ('invalid' in field && field.invalid !== undefined) {
                 const invalidVal = field.invalid;
                 if (safeIsSignal(invalidVal)) {
@@ -1942,38 +1877,27 @@ class FieldSyncService {
             return false;
         }
     }
-    /**
-     * Helper to resolve the actual field object from a potential signal or function
-     */
     resolveField(field) {
         if (!field)
             return null;
-        // Handle objects directly
         if (typeof field === 'object') {
             return field;
         }
-        // Handle functions (Signals or getters)
         if (typeof field === 'function') {
             const fieldFn = field;
-            // If the function itself has field properties (like value, disabled, setValue),
-            // it's likely a Signal that IS the field (Angular Signal Forms pattern).
-            // We check for some common properties to identify it as a field config.
             const hasFieldProps = 'value' in fieldFn || 'disabled' in fieldFn || 'required' in fieldFn ||
                 'setValue' in fieldFn || 'markAsDirty' in fieldFn || 'errors' in fieldFn;
             if (hasFieldProps) {
                 return fieldFn;
             }
-            // If it doesn't have properties, it might be a getter or a Signal returning the field config
             if (safeIsSignal(field)) {
                 try {
                     const result = field();
-                    // If the result is an object, that's our field config
                     if (result && typeof result === 'object') {
                         return result;
                     }
                 }
                 catch {
-                    // Fall through
                 }
             }
             // Generic fallback for getters
@@ -1996,17 +1920,13 @@ class FieldSyncService {
         }
         try {
             const effectRef = runInInjectionContext(this.injector, () => effect(() => {
-                // Skip if we're updating from internal to prevent circular updates
                 if (this._isUpdatingFromInternal) {
                     return;
                 }
-                // Resolve the field object. If fieldInput is a signal, this line tracks it as a dependency.
                 const field = this.resolveField(fieldInput);
                 if (!field) {
                     return;
                 }
-                // Read the field value directly in the effect context
-                // This ensures all signal dependencies (including computed signals) are properly tracked
                 let fieldValue = null;
                 try {
                     const fieldValueRef = field.value;
@@ -2014,28 +1934,21 @@ class FieldSyncService {
                         fieldValue = null;
                     }
                     else if (typeof fieldValueRef === 'function') {
-                        // For Angular 21 Signal Forms, field.value is often a function that returns a signal
-                        // Call it in effect context to track dependencies properly
                         try {
                             const funcResult = fieldValueRef();
-                            // Check if the result is a signal (common in Angular 21 Signal Forms)
                             if (safeIsSignal(funcResult)) {
-                                // Read the signal value in effect context to track dependencies
                                 const signalResult = funcResult();
                                 fieldValue = (signalResult !== undefined && signalResult !== null) ? signalResult : null;
                             }
                             else if (safeIsSignal(fieldValueRef)) {
-                                // If fieldValueRef itself is a signal, read it directly
                                 const signalResult = fieldValueRef();
                                 fieldValue = (signalResult !== undefined && signalResult !== null) ? signalResult : null;
                             }
                             else {
-                                // Result is a direct value
                                 fieldValue = (funcResult !== undefined && funcResult !== null) ? funcResult : null;
                             }
                         }
                         catch {
-                            // If calling fails, try checking if it's a signal itself
                             if (safeIsSignal(fieldValueRef)) {
                                 try {
                                     const signalResult = fieldValueRef();
@@ -2051,46 +1964,29 @@ class FieldSyncService {
                         }
                     }
                     else if (safeIsSignal(fieldValueRef)) {
-                        // For signals (including computed), read directly in effect context
-                        // This ensures computed signals track their underlying dependencies
-                        // Reading the signal here automatically tracks all its dependencies
                         const signalResult = fieldValueRef();
                         fieldValue = (signalResult !== undefined && signalResult !== null) ? signalResult : null;
                     }
                     else if (fieldValueRef instanceof Date) {
-                        // Direct Date value
                         fieldValue = fieldValueRef;
                     }
                     else if (typeof fieldValueRef === 'object') {
-                        // Could be a range object or array
                         fieldValue = fieldValueRef;
                     }
                     else {
-                        // Fallback to helper
                         fieldValue = this.readFieldValue(field);
                     }
                 }
                 catch {
-                    // Fallback to helper on any error
                     fieldValue = this.readFieldValue(field);
                 }
-                // Normalize the value using the same normalization function as the component
-                // This ensures consistent value comparison
                 const normalizedValue = callbacks.normalizeValue(fieldValue);
-                // Determine if we should update
-                // Always update on initial load (even if null) to ensure component is initialized
                 const isInitialLoad = this._lastKnownFieldValue === undefined;
-                // Use isValueEqual to compare values - this handles date normalization and equality correctly
-                // This prevents overwriting values that were just set internally, even if effect runs after flag reset
                 const valuesAreEqual = this._lastKnownFieldValue !== undefined &&
                     callbacks.isValueEqual(normalizedValue, this._lastKnownFieldValue);
                 const valueChanged = !isInitialLoad && !valuesAreEqual;
                 const isValueTransition = (this._lastKnownFieldValue === null || this._lastKnownFieldValue === undefined) &&
                     fieldValue !== null && fieldValue !== undefined;
-                // Always update on initial load (even if null), value change, or value transition
-                // BUT skip if values are equal (prevents overwriting values set internally)
-                // This ensures the component value is always set, including null values
-                // but prevents circular updates when we just set the value internally
                 if ((isInitialLoad || valueChanged || isValueTransition) && !valuesAreEqual) {
                     this._lastKnownFieldValue = normalizedValue;
                     callbacks.onValueChanged(normalizedValue);
@@ -2098,25 +1994,16 @@ class FieldSyncService {
                     callbacks.onStateChanged?.();
                 }
                 else if (!valuesAreEqual && this._lastKnownFieldValue !== normalizedValue) {
-                    // Update last known value even if we don't trigger callbacks
-                    // This handles edge cases where values are equal but references differ
-                    // But only if values are not equal according to isValueEqual
                     this._lastKnownFieldValue = normalizedValue;
                 }
-                // Always update disabled state
                 const disabled = this.readDisabledState(field);
                 callbacks.onDisabledChanged(disabled);
-                // Always update required state
                 const required = this.readRequiredState(field);
                 callbacks.onRequiredChanged?.(required);
-                // Always update error state (for Angular Signal Forms validation)
                 const hasError = this.hasValidationErrors(field);
                 callbacks.onErrorStateChanged?.(hasError);
             }));
             this._fieldEffectRef = effectRef;
-            // Effects run immediately when created, so the effect has already run
-            // and read the signal value in a reactive context. This ensures computed
-            // signals are properly tracked and all dependencies are registered.
             return effectRef;
         }
         catch (error) {
@@ -2132,13 +2019,10 @@ class FieldSyncService {
             return false;
         const fieldValue = this.readFieldValue(field);
         const normalizedValue = callbacks.normalizeValue(fieldValue);
-        // Check if value has changed or if this is initial load
         const hasValueChanged = !callbacks.isValueEqual(normalizedValue, this._lastKnownFieldValue);
         const isInitialLoad = this._lastKnownFieldValue === undefined;
         const isValueTransition = (this._lastKnownFieldValue === null || this._lastKnownFieldValue === undefined) &&
             fieldValue !== null && fieldValue !== undefined;
-        // Always sync on initial load (even if null), value change, or value transition
-        // This ensures the component value is set correctly, including null values
         if (isInitialLoad || hasValueChanged || isValueTransition) {
             this._lastKnownFieldValue = normalizedValue;
             callbacks.onValueChanged(normalizedValue);
@@ -2152,7 +2036,6 @@ class FieldSyncService {
             callbacks.onErrorStateChanged?.(hasError);
             return true;
         }
-        // Update last known value even if we don't trigger callbacks
         if (this._lastKnownFieldValue !== normalizedValue) {
             this._lastKnownFieldValue = normalizedValue;
         }
@@ -2169,61 +2052,43 @@ class FieldSyncService {
         if (!field || typeof field !== 'object') {
             return;
         }
-        // Set flag to prevent effect from processing this update
-        // This prevents circular updates when we update the field from component
         this._isUpdatingFromInternal = true;
         try {
-            // The value passed in should already be normalized by the component
-            // Store it as the last known value BEFORE updating the field
-            // This ensures the effect sees a match if it runs, preventing overwrites
             const normalizedValue = value;
             this._lastKnownFieldValue = normalizedValue;
-            // Try setValue first (preferred method for Angular 21 Signal Forms)
-            // This works with computed signal patterns where setValue updates the underlying signal
             if (typeof field.setValue === 'function') {
                 try {
                     field.setValue(normalizedValue);
                     if (typeof field.markAsDirty === 'function') {
                         field.markAsDirty();
                     }
-                    // Use microtask delay to ensure effect has time to see the flag
-                    // This prevents race condition where effect runs after flag is reset
                     Promise.resolve().then(() => {
                         this._isUpdatingFromInternal = false;
                     });
                     return;
                 }
                 catch {
-                    // If setValue fails, try updateValue as fallback
-                    // Don't return here, continue to try updateValue
                 }
             }
-            // Try updateValue as alternative method
             if (typeof field.updateValue === 'function') {
                 try {
                     field.updateValue(() => normalizedValue);
                     if (typeof field.markAsDirty === 'function') {
                         field.markAsDirty();
                     }
-                    // Use microtask delay to ensure effect has time to see the flag
                     Promise.resolve().then(() => {
                         this._isUpdatingFromInternal = false;
                     });
                     return;
                 }
                 catch {
-                    // If updateValue also fails, continue to fallback
                 }
             }
-            // Fallback: try to update the underlying signal directly if field.value is a signal
-            // This handles cases where field.value is a writable signal or a function returning a signal
             try {
                 const val = field.value;
-                // For Angular 21 Signal Forms, field.value might be a function that returns the signal
                 if (typeof val === 'function') {
                     try {
                         const signalOrValue = val();
-                        // If it's a signal, try to update it
                         if (safeIsSignal(signalOrValue)) {
                             const writableSignal = signalOrValue;
                             if (typeof writableSignal.set === 'function') {
@@ -2231,7 +2096,6 @@ class FieldSyncService {
                                 if (typeof field.markAsDirty === 'function') {
                                     field.markAsDirty();
                                 }
-                                // Use microtask delay to ensure effect has time to see the flag
                                 Promise.resolve().then(() => {
                                     this._isUpdatingFromInternal = false;
                                 });
@@ -2240,11 +2104,8 @@ class FieldSyncService {
                         }
                     }
                     catch {
-                        // If calling fails, continue to check if val itself is a signal
                     }
                 }
-                // Check if it's a writable signal (has .set method)
-                // Compatible with all Angular 17+ versions
                 if (safeIsSignal(val)) {
                     const writableSignal = val;
                     if (typeof writableSignal.set === 'function') {
@@ -2252,7 +2113,6 @@ class FieldSyncService {
                         if (typeof field.markAsDirty === 'function') {
                             field.markAsDirty();
                         }
-                        // Use microtask delay to ensure effect has time to see the flag
                         Promise.resolve().then(() => {
                             this._isUpdatingFromInternal = false;
                         });
@@ -2261,15 +2121,10 @@ class FieldSyncService {
                 }
             }
             catch {
-                // Silently handle - field might not support direct signal updates
-                // This is expected for computed signals which are read-only
             }
-            // If no update method worked, reset flag immediately
             this._isUpdatingFromInternal = false;
         }
         catch (error) {
-            // Silently handle errors to prevent breaking the application
-            // The error might be due to readonly signals or other constraints
             if (isDevMode()) {
                 console.warn('[ngxsmk-datepicker] Field sync error:', error);
             }
@@ -2279,6 +2134,20 @@ class FieldSyncService {
     getLastKnownValue() {
         return this._lastKnownFieldValue;
     }
+    markAsTouched(fieldInput) {
+        const field = this.resolveField(fieldInput);
+        if (!field || typeof field !== 'object') {
+            return;
+        }
+        try {
+            if (typeof field.markAsTouched === 'function') {
+                field.markAsTouched();
+            }
+        }
+        catch {
+            // Ignore errors when marking as touched
+        }
+    }
     cleanup() {
         if (this._fieldEffectRef) {
             this._fieldEffectRef.destroy();
@@ -5618,6 +5487,9 @@ class NgxsmkDatepickerComponent {
         this.valueChange.emit(normalizedVal);
         this.onChange(normalizedVal);
         this.onTouched();
+        if (this._field) {
+            this.fieldSyncService.markAsTouched(this._field);
+        }
         if (!this.isInlineMode && val !== null && !this.timeOnly) {
             if (this.mode === 'single' || (this.mode === 'range' && this.startDate && this.endDate)) {
                 this.isCalendarOpen = false;
@@ -6886,6 +6758,9 @@ class NgxsmkDatepickerComponent {
             this._focused = false;
             this.stateChanges.next();
             this.onTouched();
+            if (this._field) {
+                this.fieldSyncService.markAsTouched(this._field);
+            }
         }
         if (!this.allowTyping)
             return;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ngxsmk-datepicker",
-  "version": "2.0.2",
+  "version": "2.0.4",
   "author": {
     "name": "Sachin Dilshan",
     "url": "https://www.linkedin.com/in/sachindilshan/"

package/types/ngxsmk-datepicker.d.ts

@@ -1,5 +1,5 @@
 import * as i0 from '@angular/core';
-import { AfterViewInit, OnDestroy, EventEmitter, ElementRef, Signal, EffectRef, OnInit, OnChanges, TemplateRef, SimpleChanges, InjectionToken, Provider } from '@angular/core';
+import { AfterViewInit, OnDestroy, EventEmitter, ElementRef, EffectRef, Signal, OnInit, OnChanges, TemplateRef, SimpleChanges, InjectionToken, Provider } from '@angular/core';
 import { ControlValueAccessor } from '@angular/forms';
 import { Subject } from 'rxjs';
 
@@ -160,9 +160,9 @@ interface ValidationError {
     message?: string;
 }
 type SignalFormFieldConfig = {
-    value?: DatepickerValue | (() => DatepickerValue) | {
-        (): DatepickerValue;
-    } | Signal<DatepickerValue>;
+    value?: DatepickerValue | string | (() => DatepickerValue | string) | {
+        (): DatepickerValue | string;
+    } | Signal<DatepickerValue | string>;
     disabled?: boolean | (() => boolean) | {
         (): boolean;
     } | Signal<boolean>;
@@ -181,13 +181,12 @@ type SignalFormFieldConfig = {
     touched?: boolean | (() => boolean) | {
         (): boolean;
     } | Signal<boolean>;
-    setValue?: (value: DatepickerValue) => void;
-    updateValue?: (updater: () => DatepickerValue) => void;
+    setValue?: (value: DatepickerValue | string) => void;
+    updateValue?: (updater: () => DatepickerValue | string) => void;
     markAsDirty?: () => void;
-} & {
-    [key: string]: unknown;
+    markAsTouched?: () => void;
 };
-type SignalFormField = SignalFormFieldConfig | Signal<SignalFormFieldConfig> | (() => SignalFormFieldConfig) | null | undefined;
+type SignalFormField = any;
 interface FieldSyncCallbacks {
     onValueChanged: (value: DatepickerValue) => void;
     onDisabledChanged: (disabled: boolean) => void;
@@ -204,41 +203,17 @@ declare class FieldSyncService {
     private _lastKnownFieldValue;
     private _isUpdatingFromInternal;
     private readonly injector;
-    /**
-     * Helper function to safely read a field value, handling both functions and signals
-     * This handles Angular 21 Signal Forms where field.value can be a signal directly
-     * Note: Angular signals (including computed) are detected as 'function' type
-     */
     private readFieldValue;
-    /**
-     * Helper function to safely read disabled state
-     * Handles both direct values, functions, and signals (Angular 21 Signal Forms)
-     */
     private readDisabledState;
-    /**
-     * Helper function to safely read validation errors from Angular Signal Forms
-     * Returns the errors array from the field's errors signal
-     */
     private readFieldErrors;
-    /**
-     * Helper function to safely read required state
-     * Handles both direct values, functions, and signals (Angular 21 Signal Forms)
-     * Also checks for 'required' validation errors in Angular Signal Forms
-     */
     private readRequiredState;
-    /**
-     * Helper function to determine if the field has validation errors
-     * Used to set the error state on the datepicker component
-     */
     private hasValidationErrors;
-    /**
-     * Helper to resolve the actual field object from a potential signal or function
-     */
     private resolveField;
     setupFieldSync(fieldInput: SignalFormField, callbacks: FieldSyncCallbacks): EffectRef | null;
     syncFieldValue(fieldInput: SignalFormField | Signal<SignalFormField> | (() => unknown) | unknown, callbacks: FieldSyncCallbacks): boolean;
     updateFieldFromInternal(value: DatepickerValue, fieldInput: SignalFormField | Signal<SignalFormField> | (() => unknown) | unknown): void;
     getLastKnownValue(): DatepickerValue | undefined;
+    markAsTouched(fieldInput: SignalFormField | Signal<SignalFormField> | (() => unknown) | unknown): void;
     cleanup(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<FieldSyncService, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<FieldSyncService>;