@govbr-ds/webcomponents 2.1.2 → 2.2.0

package/dist/cjs/{isValid-Fu3kaWNn.js → datetime-picker-props-validation-DmNKSXsy.js}

@@ -5,6 +5,7 @@
 'use strict';
 
 var datetimePickerConstants = require('./datetime-picker-constants-B5pWeOn1.js');
+var propWarning = require('./prop-warning-xvEHQz8H.js');
 
 var eachDayOfInterval = {};
 
@@ -3677,18 +3678,494 @@ function resolveSsrLocalDate(host, fallback) {
     return fallback;
 }
 
-function warnInvalidPropValue(componentTag, propName, receivedValue, defaultValue) {
-    console.warn(`[${componentTag}]: valor invalido para "${propName}": "${String(receivedValue)}". Usando valor padrao "${defaultValue}".`);
+var isValidExports = /*@__PURE__*/ datetimePickerConstants.requireIsValid();
+
+var parseISO = {};
+
+var hasRequiredParseISO;
+
+function requireParseISO () {
+	if (hasRequiredParseISO) return parseISO;
+	hasRequiredParseISO = 1;
+	parseISO.parseISO = parseISO$1;
+	var _index = /*@__PURE__*/ datetimePickerConstants.requireConstants();
+
+	var _index2 = /*@__PURE__*/ datetimePickerConstants.requireConstructFrom();
+	var _index3 = /*@__PURE__*/ datetimePickerConstants.requireToDate();
+
+	/**
+	 * The {@link parseISO} function options.
+	 */
+
+	/**
+	 * @name parseISO
+	 * @category Common Helpers
+	 * @summary Parse ISO string
+	 *
+	 * @description
+	 * Parse the given string in ISO 8601 format and return an instance of Date.
+	 *
+	 * Function accepts complete ISO 8601 formats as well as partial implementations.
+	 * ISO 8601: http://en.wikipedia.org/wiki/ISO_8601
+	 *
+	 * If the argument isn't a string, the function cannot parse the string or
+	 * the values are invalid, it returns Invalid Date.
+	 *
+	 * @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
+	 * @typeParam ResultDate - The result `Date` type, it is the type returned from the context function if it is passed, or inferred from the arguments.
+	 *
+	 * @param argument - The value to convert
+	 * @param options - An object with options
+	 *
+	 * @returns The parsed date in the local time zone
+	 *
+	 * @example
+	 * // Convert string '2014-02-11T11:30:30' to date:
+	 * const result = parseISO('2014-02-11T11:30:30')
+	 * //=> Tue Feb 11 2014 11:30:30
+	 *
+	 * @example
+	 * // Convert string '+02014101' to date,
+	 * // if the additional number of digits in the extended year format is 1:
+	 * const result = parseISO('+02014101', { additionalDigits: 1 })
+	 * //=> Fri Apr 11 2014 00:00:00
+	 */
+	function parseISO$1(argument, options) {
+	  const invalidDate = () => (0, _index2.constructFrom)(options?.in, NaN);
+
+	  const additionalDigits = options?.additionalDigits ?? 2;
+	  const dateStrings = splitDateString(argument);
+
+	  let date;
+	  if (dateStrings.date) {
+	    const parseYearResult = parseYear(dateStrings.date, additionalDigits);
+	    date = parseDate(parseYearResult.restDateString, parseYearResult.year);
+	  }
+
+	  if (!date || isNaN(+date)) return invalidDate();
+
+	  const timestamp = +date;
+	  let time = 0;
+	  let offset;
+
+	  if (dateStrings.time) {
+	    time = parseTime(dateStrings.time);
+	    if (isNaN(time)) return invalidDate();
+	  }
+
+	  if (dateStrings.timezone) {
+	    offset = parseTimezone(dateStrings.timezone);
+	    if (isNaN(offset)) return invalidDate();
+	  } else {
+	    const tmpDate = new Date(timestamp + time);
+	    const result = (0, _index3.toDate)(0, options?.in);
+	    result.setFullYear(
+	      tmpDate.getUTCFullYear(),
+	      tmpDate.getUTCMonth(),
+	      tmpDate.getUTCDate(),
+	    );
+	    result.setHours(
+	      tmpDate.getUTCHours(),
+	      tmpDate.getUTCMinutes(),
+	      tmpDate.getUTCSeconds(),
+	      tmpDate.getUTCMilliseconds(),
+	    );
+	    return result;
+	  }
+
+	  return (0, _index3.toDate)(timestamp + time + offset, options?.in);
+	}
+
+	const patterns = {
+	  dateTimeDelimiter: /[T ]/,
+	  timeZoneDelimiter: /[Z ]/i,
+	  timezone: /([Z+-].*)$/,
+	};
+
+	const dateRegex =
+	  /^-?(?:(\d{3})|(\d{2})(?:-?(\d{2}))?|W(\d{2})(?:-?(\d{1}))?|)$/;
+	const timeRegex =
+	  /^(\d{2}(?:[.,]\d*)?)(?::?(\d{2}(?:[.,]\d*)?))?(?::?(\d{2}(?:[.,]\d*)?))?$/;
+	const timezoneRegex = /^([+-])(\d{2})(?::?(\d{2}))?$/;
+
+	function splitDateString(dateString) {
+	  const dateStrings = {};
+	  const array = dateString.split(patterns.dateTimeDelimiter);
+	  let timeString;
+
+	  // The regex match should only return at maximum two array elements.
+	  // [date], [time], or [date, time].
+	  if (array.length > 2) {
+	    return dateStrings;
+	  }
+
+	  if (/:/.test(array[0])) {
+	    timeString = array[0];
+	  } else {
+	    dateStrings.date = array[0];
+	    timeString = array[1];
+	    if (patterns.timeZoneDelimiter.test(dateStrings.date)) {
+	      dateStrings.date = dateString.split(patterns.timeZoneDelimiter)[0];
+	      timeString = dateString.substr(
+	        dateStrings.date.length,
+	        dateString.length,
+	      );
+	    }
+	  }
+
+	  if (timeString) {
+	    const token = patterns.timezone.exec(timeString);
+	    if (token) {
+	      dateStrings.time = timeString.replace(token[1], "");
+	      dateStrings.timezone = token[1];
+	    } else {
+	      dateStrings.time = timeString;
+	    }
+	  }
+
+	  return dateStrings;
+	}
+
+	function parseYear(dateString, additionalDigits) {
+	  const regex = new RegExp(
+	    "^(?:(\\d{4}|[+-]\\d{" +
+	      (4 + additionalDigits) +
+	      "})|(\\d{2}|[+-]\\d{" +
+	      (2 + additionalDigits) +
+	      "})$)",
+	  );
+
+	  const captures = dateString.match(regex);
+	  // Invalid ISO-formatted year
+	  if (!captures) return { year: NaN, restDateString: "" };
+
+	  const year = captures[1] ? parseInt(captures[1]) : null;
+	  const century = captures[2] ? parseInt(captures[2]) : null;
+
+	  // either year or century is null, not both
+	  return {
+	    year: century === null ? year : century * 100,
+	    restDateString: dateString.slice((captures[1] || captures[2]).length),
+	  };
+	}
+
+	function parseDate(dateString, year) {
+	  // Invalid ISO-formatted year
+	  if (year === null) return new Date(NaN);
+
+	  const captures = dateString.match(dateRegex);
+	  // Invalid ISO-formatted string
+	  if (!captures) return new Date(NaN);
+
+	  const isWeekDate = !!captures[4];
+	  const dayOfYear = parseDateUnit(captures[1]);
+	  const month = parseDateUnit(captures[2]) - 1;
+	  const day = parseDateUnit(captures[3]);
+	  const week = parseDateUnit(captures[4]);
+	  const dayOfWeek = parseDateUnit(captures[5]) - 1;
+
+	  if (isWeekDate) {
+	    if (!validateWeekDate(year, week, dayOfWeek)) {
+	      return new Date(NaN);
+	    }
+	    return dayOfISOWeekYear(year, week, dayOfWeek);
+	  } else {
+	    const date = new Date(0);
+	    if (
+	      !validateDate(year, month, day) ||
+	      !validateDayOfYearDate(year, dayOfYear)
+	    ) {
+	      return new Date(NaN);
+	    }
+	    date.setUTCFullYear(year, month, Math.max(dayOfYear, day));
+	    return date;
+	  }
+	}
+
+	function parseDateUnit(value) {
+	  return value ? parseInt(value) : 1;
+	}
+
+	function parseTime(timeString) {
+	  const captures = timeString.match(timeRegex);
+	  if (!captures) return NaN; // Invalid ISO-formatted time
+
+	  const hours = parseTimeUnit(captures[1]);
+	  const minutes = parseTimeUnit(captures[2]);
+	  const seconds = parseTimeUnit(captures[3]);
+
+	  if (!validateTime(hours, minutes, seconds)) {
+	    return NaN;
+	  }
+
+	  return (
+	    hours * _index.millisecondsInHour +
+	    minutes * _index.millisecondsInMinute +
+	    seconds * 1000
+	  );
+	}
+
+	function parseTimeUnit(value) {
+	  return (value && parseFloat(value.replace(",", "."))) || 0;
+	}
+
+	function parseTimezone(timezoneString) {
+	  if (timezoneString === "Z") return 0;
+
+	  const captures = timezoneString.match(timezoneRegex);
+	  if (!captures) return 0;
+
+	  const sign = captures[1] === "+" ? -1 : 1;
+	  const hours = parseInt(captures[2]);
+	  const minutes = (captures[3] && parseInt(captures[3])) || 0;
+
+	  if (!validateTimezone(hours, minutes)) {
+	    return NaN;
+	  }
+
+	  return (
+	    sign *
+	    (hours * _index.millisecondsInHour + minutes * _index.millisecondsInMinute)
+	  );
+	}
+
+	function dayOfISOWeekYear(isoWeekYear, week, day) {
+	  const date = new Date(0);
+	  date.setUTCFullYear(isoWeekYear, 0, 4);
+	  const fourthOfJanuaryDay = date.getUTCDay() || 7;
+	  const diff = (week - 1) * 7 + day + 1 - fourthOfJanuaryDay;
+	  date.setUTCDate(date.getUTCDate() + diff);
+	  return date;
+	}
+
+	// Validation functions
+
+	// February is null to handle the leap year (using ||)
+	const daysInMonths = [31, null, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
+
+	function isLeapYearIndex(year) {
+	  return year % 400 === 0 || (year % 4 === 0 && year % 100 !== 0);
+	}
+
+	function validateDate(year, month, date) {
+	  return (
+	    month >= 0 &&
+	    month <= 11 &&
+	    date >= 1 &&
+	    date <= (daysInMonths[month] || (isLeapYearIndex(year) ? 29 : 28))
+	  );
+	}
+
+	function validateDayOfYearDate(year, dayOfYear) {
+	  return dayOfYear >= 1 && dayOfYear <= (isLeapYearIndex(year) ? 366 : 365);
+	}
+
+	function validateWeekDate(_year, week, day) {
+	  return week >= 1 && week <= 53 && day >= 0 && day <= 6;
+	}
+
+	function validateTime(hours, minutes, seconds) {
+	  if (hours === 24) {
+	    return minutes === 0 && seconds === 0;
+	  }
+
+	  return (
+	    seconds >= 0 &&
+	    seconds < 60 &&
+	    minutes >= 0 &&
+	    minutes < 60 &&
+	    hours >= 0 &&
+	    hours < 25
+	  );
+	}
+
+	function validateTimezone(_hours, minutes) {
+	  return minutes >= 0 && minutes <= 59;
+	}
+	return parseISO;
 }
 
-var isValidExports = /*@__PURE__*/ datetimePickerConstants.requireIsValid();
+var parseISOExports = /*@__PURE__*/ requireParseISO();
+
+const VALID_WEEK_START_DAYS = [0, 1, 2, 3, 4, 5, 6];
+const INITIAL_MOMENT_DATE_FORMATS = ['dd/MM/yyyy HH:mm', 'dd/MM/yyyy', 'yyyy-MM-dd HH:mm', 'yyyy-MM-dd'];
+function parseInitialMomentString(value) {
+    const trimmedValue = value.trim();
+    if (trimmedValue === '') {
+        return null;
+    }
+    const isoDate = parseISOExports.parseISO(trimmedValue);
+    if (isValidExports.isValid(isoDate)) {
+        return isoDate;
+    }
+    for (const formatPattern of INITIAL_MOMENT_DATE_FORMATS) {
+        const parsedDate = parseExports.parse(trimmedValue, formatPattern, new Date());
+        if (isValidExports.isValid(parsedDate)) {
+            return parsedDate;
+        }
+    }
+    return null;
+}
+function normalizeDateCandidate(value) {
+    if (value instanceof Date) {
+        if (!Number.isNaN(value.getTime())) {
+            return new Date(value);
+        }
+        return null;
+    }
+    if (typeof value === 'string') {
+        return parseInitialMomentString(value);
+    }
+    return null;
+}
+/** Verifica se um intervalo público contém datas válidas ou `null` em ambos os lados. */
+function isValidDatetimePickerDateRange(value) {
+    if (typeof value !== 'object' || value === null)
+        return false;
+    const range = value;
+    const isValidDateOrNull = (candidate) => candidate === null || (candidate instanceof Date && !Number.isNaN(candidate.getTime()));
+    return isValidDateOrNull(range.start) && isValidDateOrNull(range.end);
+}
+function tokenizeDisabledDatesString(value) {
+    return value
+        .trim()
+        .split(/\s+/)
+        .filter((token) => token.length > 0);
+}
+/**
+ * Verifica se o valor informado corresponde a um modo suportado pelo componente.
+ *
+ * @param value - Valor recebido via prop ou atributo.
+ * @returns `true` quando o valor pertence ao conjunto aceito de modos.
+ */
+function isValidDatetimePickerMode(value) {
+    return Object.values(datetimePickerConstants.DATETIME_PICKER_MODE).includes(value);
+}
+/**
+ * Normaliza o modo informado e aplica o valor padrão quando necessário.
+ *
+ * @param value - Valor bruto recebido do consumidor do componente.
+ * @returns O modo válido correspondente, ou o valor padrão quando o input for inválido.
+ */
+function normalizeDatetimePickerMode(value) {
+    if (isValidDatetimePickerMode(value))
+        return value;
+    propWarning.warnInvalidPropValue('br-datetime-picker', 'mode', value, datetimePickerConstants.DATETIME_PICKER_MODE.DEFAULT);
+    return datetimePickerConstants.DATETIME_PICKER_MODE.DEFAULT;
+}
+/**
+ * Verifica se o valor representa um modo de seleção suportado.
+ *
+ * @param value - Valor bruto recebido via prop.
+ * @returns `true` quando o valor é `'single'` ou `'range'`.
+ */
+function isValidDatetimePickerSelectionMode(value) {
+    return value === 'single' || value === 'range';
+}
+/**
+ * Normaliza o modo de seleção informado e aplica o valor padrão quando necessário.
+ *
+ * @param value - Valor bruto recebido do consumidor do componente.
+ * @returns O modo de seleção válido correspondente, ou `'single'` quando o input for inválido.
+ */
+function normalizeDatetimePickerSelectionMode(value) {
+    if (isValidDatetimePickerSelectionMode(value))
+        return value;
+    propWarning.warnInvalidPropValue('br-datetime-picker', 'selectionMode', value, 'single');
+    return 'single';
+}
+/**
+ * Normaliza a seleção inicial para um valor aplicável pelo componente.
+ *
+ * @param value - Valor bruto recebido via prop.
+ * @returns `'now'`, `Date` normalizada ou `null` quando inválido.
+ */
+function normalizeDatetimePickerInitialMoment(value) {
+    if (value === null)
+        return null;
+    if (value === 'now')
+        return 'now';
+    const normalizedDate = normalizeDateCandidate(value);
+    if (normalizedDate !== null) {
+        return normalizedDate;
+    }
+    propWarning.warnInvalidPropValue('br-datetime-picker', 'initialMoment', value, 'null');
+    return null;
+}
+/**
+ * Normaliza a lista de datas desabilitadas para uma coleção de `Date` válidas.
+ *
+ * @param value - Valor bruto recebido via prop.
+ * @returns Lista normalizada de datas; retorna array vazio quando inválido.
+ */
+function normalizeDatetimePickerDisabledDates(value, componentTag = 'br-datetime-picker') {
+    if (value === null) {
+        return [];
+    }
+    if (typeof value === 'string') {
+        const tokens = tokenizeDisabledDatesString(value);
+        if (tokens.length === 0) {
+            propWarning.warnInvalidPropValue(componentTag, 'disabledDates', value, '[]');
+            return [];
+        }
+        const normalizedDates = tokens
+            .map((dateCandidate) => normalizeDateCandidate(dateCandidate))
+            .filter((dateCandidate) => dateCandidate !== null);
+        if (normalizedDates.length !== tokens.length) {
+            propWarning.warnInvalidPropValue(componentTag, 'disabledDates', value, '[]');
+        }
+        return normalizedDates;
+    }
+    if (!Array.isArray(value)) {
+        propWarning.warnInvalidPropValue(componentTag, 'disabledDates', value, '[]');
+        return [];
+    }
+    const normalizedDates = value
+        .map((dateCandidate) => normalizeDateCandidate(dateCandidate))
+        .filter((dateCandidate) => dateCandidate !== null);
+    if (normalizedDates.length !== value.length) {
+        propWarning.warnInvalidPropValue(componentTag, 'disabledDates', value, '[]');
+    }
+    return normalizedDates;
+}
+/**
+ * Verifica se o valor informado representa um índice válido de início da semana.
+ *
+ * @param value - Valor bruto recebido via prop.
+ * @returns `true` quando o valor está entre `0` e `6`.
+ */
+function isValidDatetimePickerWeekStartsOn(value) {
+    return VALID_WEEK_START_DAYS.includes(value);
+}
+/**
+ * Normaliza o índice de início da semana e aplica `0` quando o valor é inválido.
+ *
+ * @param value - Valor bruto recebido do consumidor do componente.
+ * @returns Índice normalizado para o primeiro dia da semana.
+ */
+function normalizeDatetimePickerWeekStartsOn(value) {
+    const numericValue = typeof value === 'string' ? Number(value) : value;
+    if (typeof numericValue === 'number' &&
+        Number.isInteger(numericValue) &&
+        isValidDatetimePickerWeekStartsOn(numericValue)) {
+        return numericValue;
+    }
+    propWarning.warnInvalidPropValue('br-datetime-picker', 'weekStartsOn', String(value), '0');
+    return 0;
+}
 
 exports.eachDayOfIntervalExports = eachDayOfIntervalExports;
 exports.isSameDayExports = isSameDayExports;
+exports.isValidDatetimePickerDateRange = isValidDatetimePickerDateRange;
 exports.isValidExports = isValidExports;
+exports.normalizeDatetimePickerDisabledDates = normalizeDatetimePickerDisabledDates;
+exports.normalizeDatetimePickerInitialMoment = normalizeDatetimePickerInitialMoment;
+exports.normalizeDatetimePickerMode = normalizeDatetimePickerMode;
+exports.normalizeDatetimePickerSelectionMode = normalizeDatetimePickerSelectionMode;
+exports.normalizeDatetimePickerWeekStartsOn = normalizeDatetimePickerWeekStartsOn;
 exports.parseExports = parseExports;
+exports.parseISOExports = parseISOExports;
 exports.requireParse = requireParse;
 exports.resolveSsrLocalDate = resolveSsrLocalDate;
 exports.setExports = setExports;
 exports.toDateExports = toDateExports;
-exports.warnInvalidPropValue = warnInvalidPropValue;

package/dist/cjs/{floating-ui-MBI1osio.js → floating-ui-B6nsdYUU.js}

@@ -4,7 +4,7 @@
  */
 'use strict';
 
-var floatingUi_dom = require('./floating-ui.dom-BUSTaaxR.js');
+var floatingUi_dom = require('./floating-ui.dom-wzdGZjyG.js');
 
 /**
  * Utilitários para gerenciamento de posicionamento flutuante (Floating UI).
@@ -25,6 +25,7 @@ class FloatingUIManager {
         this.strategy = options.strategy ?? 'absolute';
         this.boundary = options.boundary ?? 'clippingAncestors';
         this.offsetDistance = options.offset ?? 8;
+        this.matchReferenceWidth = options.matchReferenceWidth ?? false;
         this.onUpdate = options.onUpdate;
     }
     /**
@@ -32,6 +33,9 @@ class FloatingUIManager {
      */
     start() {
         this.stop();
+        if (this.matchReferenceWidth) {
+            this.previousInlineWidth = this.contentElement.style.width;
+        }
         this.contentElement.style.position = this.strategy;
         this.cleanupAutoUpdate = floatingUi_dom.autoUpdate(this.triggerElement, this.contentElement, () => this.updatePosition());
     }
@@ -42,6 +46,15 @@ class FloatingUIManager {
         const cleanup = this.cleanupAutoUpdate;
         this.cleanupAutoUpdate = undefined;
         cleanup?.();
+        if (this.previousInlineWidth !== undefined) {
+            if (this.previousInlineWidth) {
+                this.contentElement.style.width = this.previousInlineWidth;
+            }
+            else {
+                this.contentElement.style.removeProperty('width');
+            }
+            this.previousInlineWidth = undefined;
+        }
     }
     /**
      * Atualiza a posição do elemento flutuante com base no elemento disparador e no elemento de conteúdo.
@@ -78,6 +91,16 @@ class FloatingUIManager {
         if (this.arrowElement != null) {
             middleware.push(floatingUi_dom.arrow({ element: this.arrowElement }));
         }
+        if (this.matchReferenceWidth) {
+            middleware.push(floatingUi_dom.size({
+                apply: ({ elements, rects }) => {
+                    if (this.previousInlineWidth === undefined) {
+                        this.previousInlineWidth = elements.floating.style.width;
+                    }
+                    elements.floating.style.width = `${rects.reference.width}px`;
+                },
+            }));
+        }
         return middleware;
     }
     /**