@govbr-ds/webcomponents 2.1.3 → 2.3.0

package/dist/esm/{isValid-DIUZX1qS.js → datetime-picker-props-validation-BeTcUTnE.js}

@@ -2,7 +2,8 @@
  * Construído por SERPRO
  * © https://serpro.gov.br/ - MIT License.
  */
-import { g as requireNormalizeDates, a as requireConstructFrom, i as requireStartOfDay, e as requireDefaultOptions, c as requireConstants$1, j as requireGetWeekYear, k as requireStartOfWeek, l as requireStartOfISOWeek, b as requireToDate, m as requireGetWeek, n as requireGetISOWeek, o as requireSetDay, p as requireAddDays, q as requireGetTimezoneOffsetInMilliseconds, s as requireLongFormatters, t as requireDefaultLocale, u as requireProtectedTokens, v as requireSetMonth, r as requireIsValid } from './datetime-picker-constants-Bfm58jO6.js';
+import { e as requireNormalizeDates, c as requireConstructFrom, i as requireStartOfDay, d as requireDefaultOptions, h as requireConstants$1, j as requireGetWeekYear, k as requireStartOfWeek, l as requireStartOfISOWeek, b as requireToDate, m as requireGetWeek, n as requireGetISOWeek, o as requireSetDay, p as requireAddDays, q as requireGetTimezoneOffsetInMilliseconds, s as requireLongFormatters, t as requireDefaultLocale, u as requireProtectedTokens, v as requireSetMonth, r as requireIsValid, D as DATETIME_PICKER_MODE } from './datetime-picker-constants-BtRPYRvA.js';
+import { w as warnInvalidPropValue } from './prop-warning-BlGV-x0w.js';
 
 var eachDayOfInterval = {};
 
@@ -3675,10 +3676,480 @@ 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__*/ requireIsValid();
+
+var parseISO = {};
+
+var hasRequiredParseISO;
+
+function requireParseISO () {
+	if (hasRequiredParseISO) return parseISO;
+	hasRequiredParseISO = 1;
+	parseISO.parseISO = parseISO$1;
+	var _index = /*@__PURE__*/ requireConstants$1();
+
+	var _index2 = /*@__PURE__*/ requireConstructFrom();
+	var _index3 = /*@__PURE__*/ 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__*/ 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(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;
+    warnInvalidPropValue('br-datetime-picker', 'mode', value, DATETIME_PICKER_MODE.DEFAULT);
+    return 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;
+    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;
+    }
+    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) {
+            warnInvalidPropValue(componentTag, 'disabledDates', value, '[]');
+            return [];
+        }
+        const normalizedDates = tokens
+            .map((dateCandidate) => normalizeDateCandidate(dateCandidate))
+            .filter((dateCandidate) => dateCandidate !== null);
+        if (normalizedDates.length !== tokens.length) {
+            warnInvalidPropValue(componentTag, 'disabledDates', value, '[]');
+        }
+        return normalizedDates;
+    }
+    if (!Array.isArray(value)) {
+        warnInvalidPropValue(componentTag, 'disabledDates', value, '[]');
+        return [];
+    }
+    const normalizedDates = value
+        .map((dateCandidate) => normalizeDateCandidate(dateCandidate))
+        .filter((dateCandidate) => dateCandidate !== null);
+    if (normalizedDates.length !== value.length) {
+        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;
+    }
+    warnInvalidPropValue('br-datetime-picker', 'weekStartsOn', String(value), '0');
+    return 0;
+}
 
-export { resolveSsrLocalDate as a, isSameDayExports as b, eachDayOfIntervalExports as e, isValidExports as i, parseExports as p, requireParse as r, setExports as s, toDateExports as t, warnInvalidPropValue as w };
+export { parseISOExports as a, isValidDatetimePickerDateRange as b, resolveSsrLocalDate as c, normalizeDatetimePickerWeekStartsOn as d, normalizeDatetimePickerDisabledDates as e, normalizeDatetimePickerInitialMoment as f, eachDayOfIntervalExports as g, isSameDayExports as h, isValidExports as i, normalizeDatetimePickerMode as j, normalizeDatetimePickerSelectionMode as n, parseExports as p, requireParse as r, setExports as s, toDateExports as t };

package/dist/esm/{event-DFN_so7I.js → event-CfuJQ1DY.js}

@@ -45,4 +45,4 @@ const dispatchNativeFormEvent = (host, type) => {
     return host.dispatchEvent(event);
 };
 
-export { getEventTarget as a, isEventTargetOutside as b, redispatchNativeEvent as c, dispatchNativeFormEvent as d, getEventPath as g, isEventTargetInside as i, redispatchNativeFormEvent as r };
+export { isEventTargetOutside as a, getEventTarget as b, redispatchNativeEvent as c, dispatchNativeFormEvent as d, getEventPath as g, isEventTargetInside as i, redispatchNativeFormEvent as r };

package/dist/esm/{floating-ui-BavFwMnx.js → floating-ui-CskvaxD5.js}

@@ -2,7 +2,7 @@
  * Construído por SERPRO
  * © https://serpro.gov.br/ - MIT License.
  */
-import { a as autoUpdate, c as computePosition, o as offset, f as flip, s as shift, h as hide, b as arrow } from './floating-ui.dom-DIK54tTj.js';
+import { a as autoUpdate, c as computePosition, o as offset, f as flip, s as shift, h as hide, b as arrow, d as size } from './floating-ui.dom-D9Zo6FlV.js';
 
 /**
  * Utilitários para gerenciamento de posicionamento flutuante (Floating UI).
@@ -23,6 +23,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;
     }
     /**
@@ -30,6 +31,9 @@ class FloatingUIManager {
      */
     start() {
         this.stop();
+        if (this.matchReferenceWidth) {
+            this.previousInlineWidth = this.contentElement.style.width;
+        }
         this.contentElement.style.position = this.strategy;
         this.cleanupAutoUpdate = autoUpdate(this.triggerElement, this.contentElement, () => this.updatePosition());
     }
@@ -40,6 +44,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.
@@ -76,6 +89,16 @@ class FloatingUIManager {
         if (this.arrowElement != null) {
             middleware.push(arrow({ element: this.arrowElement }));
         }
+        if (this.matchReferenceWidth) {
+            middleware.push(size({
+                apply: ({ elements, rects }) => {
+                    if (this.previousInlineWidth === undefined) {
+                        this.previousInlineWidth = elements.floating.style.width;
+                    }
+                    elements.floating.style.width = `${rects.reference.width}px`;
+                },
+            }));
+        }
         return middleware;
     }
     /**