@aurodesignsystem-dev/auro-formkit 0.0.0-pr1508.0 → 0.0.0-pr1509.0

package/components/input/demo/getting-started.min.js

@@ -10389,7 +10389,6 @@ class AuroInputUtilities {
     const maskOptions = this.getMaskOptions('date', normalizedFormat);
 
     if (!(valueObject instanceof Date) || Number.isNaN(valueObject.getTime()) || !maskOptions || typeof maskOptions.format !== 'function') {
-      console.debug('Invalid date object or mask options for formatting', { valueObject, maskOptions }); // eslint-disable-line no-console
       return undefined;
     }
 
@@ -10541,8 +10540,10 @@ class BaseInput extends AuroElement {
     this.layout = 'classic';
     this.locale = 'en-US';
     this.max = undefined;
+    this._maxObject = undefined;
     this.maxLength = undefined;
     this.min = undefined;
+    this._minObject = undefined;
     this.minLength = undefined;
     this.required = false;
     this.onDark = false;
@@ -10550,6 +10551,7 @@ class BaseInput extends AuroElement {
     this.size = 'lg';
     this.shape = 'classic';
     this.value = undefined;
+    this._valueObject = undefined;
 
     this._initializePrivateDefaults();
   }
@@ -11089,7 +11091,7 @@ class BaseInput extends AuroElement {
    * @returns {Date|undefined}
    */
   get valueObject() {
-    return this.value && dateFormatter.isValidDate(this.value) ? dateFormatter.stringToDateInstance(this.value) : undefined;
+    return this._valueObject || this._computeDateObjectFallback(this.value);
   }
 
   /**
@@ -11097,7 +11099,7 @@ class BaseInput extends AuroElement {
    * @returns {Date|undefined}
    */
   get minObject() {
-    return this.min && dateFormatter.isValidDate(this.min) ? dateFormatter.stringToDateInstance(this.min) : undefined;
+    return this._minObject || this._computeDateObjectFallback(this.min);
   }
 
   /**
@@ -11105,7 +11107,50 @@ class BaseInput extends AuroElement {
    * @returns {Date|undefined}
    */
   get maxObject() {
-    return this.max && dateFormatter.isValidDate(this.max) ? dateFormatter.stringToDateInstance(this.max) : undefined;
+    return this._maxObject || this._computeDateObjectFallback(this.max);
+  }
+
+  /**
+   * Parses a date string into a Date object when the corresponding `_*Object`
+   * field hasn't been synced yet by `updated()`. Returns undefined when the
+   * input type/format isn't a full date or the string is not a valid date.
+   *
+   * Why this exists: a parent (datepicker) can call `inputN.validate()` from
+   * inside its own `updated()` before this input's `updated()` has run
+   * `syncDateValues()` — so `_valueObject`/`_maxObject` are still `undefined`
+   * and range checks would otherwise silently no-op (flipping the result to
+   * `valid` or `patternMismatch`).
+   * @private
+   * @param {string|undefined} dateStr - ISO date string from `value`/`min`/`max`.
+   * @returns {Date|undefined}
+   */
+  _computeDateObjectFallback(dateStr) {
+    if (!dateStr || !this.util || !this.util.isFullDateFormat(this.type, this.format)) {
+      return undefined;
+    }
+    if (!dateFormatter.isValidDate(dateStr)) {
+      return undefined;
+    }
+    return dateFormatter.stringToDateInstance(dateStr);
+  }
+
+  /**
+   * Internal setter for readonly date object properties.
+   * @private
+   * @param {'valueObject'|'minObject'|'maxObject'} propertyName - Public object property name.
+   * @param {Date|undefined} propertyValue - Value to assign.
+   * @returns {void}
+   */
+  setDateObjectProperty(propertyName, propertyValue) {
+    const internalPropertyName = `_${propertyName}`;
+    const previousValue = this[internalPropertyName];
+
+    if (previousValue === propertyValue) {
+      return;
+    }
+
+    this[internalPropertyName] = propertyValue;
+    this.requestUpdate(propertyName, previousValue);
   }
 
   connectedCallback() {
@@ -11134,6 +11179,7 @@ class BaseInput extends AuroElement {
       format: this.format
     });
     this.configureDataForType();
+    this.syncDateValues();
   }
 
   disconnectedCallback() {
@@ -11153,6 +11199,15 @@ class BaseInput extends AuroElement {
       this.wrapperElement.addEventListener('click', this.handleClick);
     }
 
+    // add attribute for query selectors when auro-input is registered under a custom name
+    // COVERAGE: the body of this branch is unreachable in WTR — connectedCallback
+    // performs the same `setAttribute('auro-input', '')` earlier (see L665-667),
+    // so by the time firstUpdated runs the attribute is already present and the
+    // `!hasAttribute('auro-input')` guard is false. Retained as a defensive
+    // safety net in case connectedCallback is ever short-circuited.
+    if (this.tagName.toLowerCase() !== 'auro-input' && !this.hasAttribute('auro-input')) {
+      this.setAttribute('auro-input', '');
+    }
     this.inputId = this.id ? `${this.id}-input` : window.crypto.randomUUID();
 
     // use validity message override if declared when initializing the component
@@ -11163,6 +11218,7 @@ class BaseInput extends AuroElement {
     this.setCustomHelpTextMessage();
     this.configureAutoFormatting();
     this.configureDataForType();
+    this.syncDateValues();
   }
 
   /**
@@ -11238,6 +11294,13 @@ class BaseInput extends AuroElement {
 
     if (typeToI18n.includes(this.type)) {
       this.setCustomValidityForType = i18n(this.lang, this.type);
+    // COVERAGE: this `else if` branch is unreachable in WTR. connectedCallback
+    // (L682) calls configureDataForType, which at L1266-1268 assigns
+    // `this.format = this.util.getDateMaskFromLocale().toLowerCase()` for any
+    // type=date input whose `format` attribute is unset. That runs before
+    // firstUpdated invokes setCustomHelpTextMessage, so `!this.format` is
+    // always false here. Retained as a defensive fallback; the whole function
+    // is @deprecated per AB#1557296 and slated for removal.
     } else if (!this.format && this.type === 'date') {
       this.setCustomValidityForType = i18n(this.lang, 'dateMMDDYYYY');
     } else if (this.dateFormatMap[this.format]) {
@@ -11299,6 +11362,8 @@ class BaseInput extends AuroElement {
       this.configureDataForType();
     }
 
+    this.syncDateValues(changedProperties);
+
     if (changedProperties.has('value')) {
       if (this.value && this.value.length > 0) {
         this.hasValue = true;
@@ -11320,14 +11385,14 @@ class BaseInput extends AuroElement {
 
       if (formattedValue !== this.inputElement.value) {
         this.skipNextProgrammaticInputEvent = true;
-        if (this.maskInstance && this.type !== 'date') {
+        if (this.maskInstance && this.type === 'credit-card') {
           // Route through the mask so its _value and el.value stay in lock-step
           // (set value calls updateControl which writes el.value = displayValue).
           // Writing el.value directly leaves the mask thinking displayValue is
-          // stale; _saveSelection on the next focus/click then warns. Date is
-          // excluded because its formattedValue can be raw ISO when the calendar
-          // is invalid, and re-masking through mm/dd/yyyy would truncate it and
-          // flip validity from patternMismatch to tooShort.
+          // stale; _saveSelection on the next focus/click then warns. Scoped to
+          // credit-card so date's own formattedValue (raw ISO when calendar-invalid)
+          // isn't re-masked through the mm/dd/yyyy mask, which would truncate it
+          // and flip validity from patternMismatch to tooShort.
           this.maskInstance.value = formattedValue || '';
         } else if (formattedValue) {
           this.inputElement.value = formattedValue;
@@ -11369,65 +11434,120 @@ class BaseInput extends AuroElement {
     }));
   }
 
+
+  /**
+   * Synchronizes the ISO string values and Date object representations for date-related properties.
+   * This keeps the model and display values aligned when either side changes.
+   *
+   * When a full date format is in use, this method updates `value`, `min`, and `max` from their corresponding
+   * Date objects or vice versa, based on which properties have changed. It only runs when the current configuration
+   * represents a full year/month/day date format.
+   *
+   * @param {Map<string, unknown>|undefined} [changedProperties=undefined] - Optional map of changed properties used to limit which values are synchronized.
+   * @returns {void}
+   * @private
+   */
+  syncDateValues(changedProperties = undefined) {
+    if (!this.util.isFullDateFormat(this.type, this.format)) {
+      return;
+    }
+
+    this.syncSingleDateValue(changedProperties, 'valueObject', 'value');
+    this.syncSingleDateValue(changedProperties, 'minObject', 'min');
+    this.syncSingleDateValue(changedProperties, 'maxObject', 'max');
+  }
+
+  /**
+   * Synchronizes one date object/string property pair.
+   * @private
+   * @param {Map<string, unknown>|undefined} changedProperties - Map of changed properties from Lit.
+   * @param {string} objectProperty - Date object property name.
+   * @param {string} valueProperty - ISO string property name.
+   * @returns {void}
+   */
+  syncSingleDateValue(changedProperties, objectProperty, valueProperty) {
+    const objectPropertyChanged = !changedProperties || changedProperties.has(objectProperty);
+
+    // objectProperty wins over valueProperty when both changed
+    if (objectPropertyChanged && this[objectProperty]) {
+      this[valueProperty] = dateFormatter.toISOFormatString(this[objectProperty]);
+      return;
+    }
+
+    const valuePropertyChanged = !changedProperties || changedProperties.has(valueProperty);
+    if (!valuePropertyChanged) {
+      return;
+    }
+
+    // when value is newly set to the same ISO string that corresponds to the existing Date object, do not clear the Date object (avoid unnecessary updates)
+    if (
+      changedProperties &&
+      valueProperty === 'value' &&
+      changedProperties.get('value') === undefined &&
+      this[objectProperty] instanceof Date &&
+      this[valueProperty] === dateFormatter.toISOFormatString(this[objectProperty])
+    ) {
+      return;
+    }
+
+    if (dateFormatter.isValidDate(this[valueProperty])) {
+      this.setDateObjectProperty(objectProperty, dateFormatter.stringToDateInstance(this[valueProperty]));
+    } else {
+      this.setDateObjectProperty(objectProperty, undefined);
+    }
+  }
+
   /**
    * Sets up IMasks and logic based on auto-formatting requirements.
    * @private
    * @returns {void}
    */
   configureAutoFormatting() {
-    // _configuringMask gates two things: external re-entry into this method
-    // while setup is mid-flight (from property changes that call back here),
-    // and the accept/complete listeners below — both need to ignore the mask
-    // events fired by our own value-restore step.
+    // Re-entrancy guard. The patched-setter's synthetic input event (suppressed
+    // by _configuringMask above) could otherwise trigger handleInput →
+    // processCreditCard → configureAutoFormatting before the outer call's
+    // set value has finished its alignCursor pass.
     if (this._configuringMask) return;
     this._configuringMask = true;
     try {
-      // Destroy any prior mask so IMask can attach fresh under the new format.
-      // Null the reference too — if the new maskOptions.mask is falsy (e.g.
-      // type switched from credit-card to text) the IMask() reassignment
-      // below is skipped, and downstream writes at line ~823 would otherwise
-      // route through the destroyed instance.
       if (this.maskInstance) {
         this.maskInstance.destroy();
-        this.maskInstance = null;
       }
 
+      // Pass new format to util
       this.util.updateFormat(this.format);
 
       const maskOptions = this.util.getMaskOptions(this.type, this.format);
 
       if (this.inputElement && maskOptions.mask) {
-        // Capture the current display so it can be re-applied after IMask
-        // attaches. The restore at the bottom goes through maskInstance.value
-        // (not inputElement.value directly) so the mask's internal state and
-        // the input's displayed text stay in lock-step.
-        let existingValue = this.inputElement.value;
 
-        // Format-change case (e.g. locale switch): existingValue is the OLD
-        // mask's display string and may not parse under the new mask. When
-        // we have a valid date model, rebuild the display from valueObject
-        // (the canonical source) using the new mask's format function.
+        // Stash and clear any existing value before IMask init.
+        // IMask's constructor processes the current input value which requires
+        // selection state — clearing first avoids that scenario entirely.
+        // When the format changes (e.g. locale switch) and we have a valid ISO
+        // model value, compute the display string for the NEW format instead of
+        // re-using the old display string, which may be invalid in the new mask.
+        let existingValue = this.inputElement.value;
         if (
           this.util.isFullDateFormat(this.type, this.format) &&
           this.value &&
-          this.valueObject &&
+          dateFormatter.isValidDate(this.value) &&
+          this.valueObject instanceof Date &&
+          !Number.isNaN(this.valueObject.getTime()) &&
           typeof maskOptions.format === 'function'
         ) {
           existingValue = maskOptions.format(this.valueObject);
         }
 
-        // Clear before IMask attaches so the constructor seeds an empty
-        // internal value. Otherwise IMask reads the stale unmasked string
-        // and emits a spurious 'accept' before the restore below runs.
         this.skipNextProgrammaticInputEvent = true;
         this.inputElement.value = '';
 
         this.maskInstance = IMask(this.inputElement, maskOptions);
 
-        // Mask fires 'accept' on every value change, including the restore
-        // step below. Skip events fired during configureAutoFormatting so
-        // we don't overwrite a value the parent just pushed.
         this.maskInstance.on('accept', () => {
+          // Suppress propagation during configureAutoFormatting's own value-restoration
+          // (line below) — the mask emits 'accept' on every value-set, including ours,
+          // and we don't want to overwrite a value the parent just pushed.
           if (this._configuringMask) return;
           this.value = this.util.toModelValue(this.maskInstance.value, this.format);
           if (this.type === "date") {
@@ -11435,8 +11555,6 @@ class BaseInput extends AuroElement {
           }
         });
 
-        // Mask fires 'complete' on the restore step below for any value that
-        // happens to be a complete match. Same setup-suppression as 'accept'.
         this.maskInstance.on('complete', () => {
           if (this._configuringMask) return;
           this.value = this.util.toModelValue(this.maskInstance.value, this.format);
@@ -11445,9 +11563,7 @@ class BaseInput extends AuroElement {
           }
         });
 
-        // Write existingValue through the mask (not the input directly) so
-        // the mask reformats it under the new rules and keeps its internal
-        // _value aligned with the input's displayed text.
+        // Restore the stashed value through IMask so it's properly masked
         if (existingValue) {
           this.maskInstance.value = existingValue;
         }
@@ -11615,6 +11731,7 @@ class BaseInput extends AuroElement {
    */
   reset() {
     this.value = undefined;
+    this.setDateObjectProperty('valueObject', undefined);
     this.validation.reset(this);
   }
 
@@ -11623,6 +11740,7 @@ class BaseInput extends AuroElement {
    */
   clear() {
     this.value = undefined;
+    this.setDateObjectProperty('valueObject', undefined);
   }
 
   /**
@@ -11660,6 +11778,12 @@ class BaseInput extends AuroElement {
    */
   get placeholderStr() {
     if (!this.placeholder && this.type === 'date') {
+      // COVERAGE: the `'MM/DD/YYYY'` literal fallback is unreachable in WTR.
+      // connectedCallback (L682) calls configureDataForType, which at L1266-1268
+      // assigns `this.format = this.util.getDateMaskFromLocale().toLowerCase()`
+      // when type=date and format is unset. That runs before the first render
+      // reads this getter, so the ternary's truthy arm always wins. Retained
+      // as a defensive fallback for direct getter calls before connection.
       return this.format ? this.format.toUpperCase() : 'MM/DD/YYYY';
     }
     return this.placeholder || "";
@@ -12151,7 +12275,7 @@ class AuroHelpText extends i$3 {
   }
 }
 
-var formkitVersion = '202606231948';
+var formkitVersion = '202606232113';
 
 /**
  * @license