@govbr-ds/webcomponents 2.1.0 → 2.1.2

package/dist/cjs/id-CjRFMzf6.js

@@ -0,0 +1,20 @@
+/*!
+ * Construído por SERPRO
+ * © https://serpro.gov.br/ - MIT License.
+ */
+'use strict';
+
+/**
+ * Utilitário para geração de IDs únicos para Web Components.
+ *
+ * Utiliza um contador sequencial em memória combinado com um sufixo aleatório em base36
+ * para oferecer alta performance O(1) e garantia de unicidade sem colisões.
+ *
+ * @returns String de ID único compatível com seletores CSS (ex.: "b0k9f2z").
+ */
+let idCounter = 0;
+function generateUniqueId() {
+    return `b${(idCounter++).toString(36)}${Math.random().toString(36).slice(2, 7)}`;
+}
+
+exports.generateUniqueId = generateUniqueId;

package/dist/cjs/index-C92n55ch.js

@@ -0,0 +1,678 @@
+/*!
+ * Construído por SERPRO
+ * © https://serpro.gov.br/ - MIT License.
+ */
+'use strict';
+
+var datetimePickerConstants = require('./datetime-picker-constants-B5pWeOn1.js');
+
+var addDaysExports = /*@__PURE__*/ datetimePickerConstants.requireAddDays();
+
+var ptBR = {};
+
+var formatDistance = {};
+
+var hasRequiredFormatDistance;
+
+function requireFormatDistance () {
+	if (hasRequiredFormatDistance) return formatDistance;
+	hasRequiredFormatDistance = 1;
+	formatDistance.formatDistance = void 0;
+
+	const formatDistanceLocale = {
+	  lessThanXSeconds: {
+	    one: "menos de um segundo",
+	    other: "menos de {{count}} segundos",
+	  },
+
+	  xSeconds: {
+	    one: "1 segundo",
+	    other: "{{count}} segundos",
+	  },
+
+	  halfAMinute: "meio minuto",
+
+	  lessThanXMinutes: {
+	    one: "menos de um minuto",
+	    other: "menos de {{count}} minutos",
+	  },
+
+	  xMinutes: {
+	    one: "1 minuto",
+	    other: "{{count}} minutos",
+	  },
+
+	  aboutXHours: {
+	    one: "cerca de 1 hora",
+	    other: "cerca de {{count}} horas",
+	  },
+
+	  xHours: {
+	    one: "1 hora",
+	    other: "{{count}} horas",
+	  },
+
+	  xDays: {
+	    one: "1 dia",
+	    other: "{{count}} dias",
+	  },
+
+	  aboutXWeeks: {
+	    one: "cerca de 1 semana",
+	    other: "cerca de {{count}} semanas",
+	  },
+
+	  xWeeks: {
+	    one: "1 semana",
+	    other: "{{count}} semanas",
+	  },
+
+	  aboutXMonths: {
+	    one: "cerca de 1 mês",
+	    other: "cerca de {{count}} meses",
+	  },
+
+	  xMonths: {
+	    one: "1 mês",
+	    other: "{{count}} meses",
+	  },
+
+	  aboutXYears: {
+	    one: "cerca de 1 ano",
+	    other: "cerca de {{count}} anos",
+	  },
+
+	  xYears: {
+	    one: "1 ano",
+	    other: "{{count}} anos",
+	  },
+
+	  overXYears: {
+	    one: "mais de 1 ano",
+	    other: "mais de {{count}} anos",
+	  },
+
+	  almostXYears: {
+	    one: "quase 1 ano",
+	    other: "quase {{count}} anos",
+	  },
+	};
+
+	const formatDistance$1 = (token, count, options) => {
+	  let result;
+
+	  const tokenValue = formatDistanceLocale[token];
+	  if (typeof tokenValue === "string") {
+	    result = tokenValue;
+	  } else if (count === 1) {
+	    result = tokenValue.one;
+	  } else {
+	    result = tokenValue.other.replace("{{count}}", String(count));
+	  }
+
+	  if (options?.addSuffix) {
+	    if (options.comparison && options.comparison > 0) {
+	      return "em " + result;
+	    } else {
+	      return "há " + result;
+	    }
+	  }
+
+	  return result;
+	};
+	formatDistance.formatDistance = formatDistance$1;
+	return formatDistance;
+}
+
+var formatLong = {};
+
+var hasRequiredFormatLong;
+
+function requireFormatLong () {
+	if (hasRequiredFormatLong) return formatLong;
+	hasRequiredFormatLong = 1;
+	formatLong.formatLong = void 0;
+	var _index = /*@__PURE__*/ datetimePickerConstants.requireBuildFormatLongFn();
+
+	const dateFormats = {
+	  full: "EEEE, d 'de' MMMM 'de' y",
+	  long: "d 'de' MMMM 'de' y",
+	  medium: "d MMM y",
+	  short: "dd/MM/yyyy",
+	};
+
+	const timeFormats = {
+	  full: "HH:mm:ss zzzz",
+	  long: "HH:mm:ss z",
+	  medium: "HH:mm:ss",
+	  short: "HH:mm",
+	};
+
+	const dateTimeFormats = {
+	  full: "{{date}} 'às' {{time}}",
+	  long: "{{date}} 'às' {{time}}",
+	  medium: "{{date}}, {{time}}",
+	  short: "{{date}}, {{time}}",
+	};
+
+	(formatLong.formatLong = {
+	  date: (0, _index.buildFormatLongFn)({
+	    formats: dateFormats,
+	    defaultWidth: "full",
+	  }),
+
+	  time: (0, _index.buildFormatLongFn)({
+	    formats: timeFormats,
+	    defaultWidth: "full",
+	  }),
+
+	  dateTime: (0, _index.buildFormatLongFn)({
+	    formats: dateTimeFormats,
+	    defaultWidth: "full",
+	  }),
+	});
+	return formatLong;
+}
+
+var formatRelative = {};
+
+var hasRequiredFormatRelative;
+
+function requireFormatRelative () {
+	if (hasRequiredFormatRelative) return formatRelative;
+	hasRequiredFormatRelative = 1;
+	formatRelative.formatRelative = void 0;
+
+	const formatRelativeLocale = {
+	  lastWeek: (date) => {
+	    const weekday = date.getDay();
+	    const last = weekday === 0 || weekday === 6 ? "último" : "última";
+	    return "'" + last + "' eeee 'às' p";
+	  },
+	  yesterday: "'ontem às' p",
+	  today: "'hoje às' p",
+	  tomorrow: "'amanhã às' p",
+	  nextWeek: "eeee 'às' p",
+	  other: "P",
+	};
+
+	const formatRelative$1 = (token, date, _baseDate, _options) => {
+	  const format = formatRelativeLocale[token];
+
+	  if (typeof format === "function") {
+	    return format(date);
+	  }
+
+	  return format;
+	};
+	formatRelative.formatRelative = formatRelative$1;
+	return formatRelative;
+}
+
+var localize = {};
+
+var hasRequiredLocalize;
+
+function requireLocalize () {
+	if (hasRequiredLocalize) return localize;
+	hasRequiredLocalize = 1;
+	localize.localize = void 0;
+	var _index = /*@__PURE__*/ datetimePickerConstants.requireBuildLocalizeFn();
+
+	const eraValues = {
+	  narrow: ["AC", "DC"],
+	  abbreviated: ["AC", "DC"],
+	  wide: ["antes de cristo", "depois de cristo"],
+	};
+
+	const quarterValues = {
+	  narrow: ["1", "2", "3", "4"],
+	  abbreviated: ["T1", "T2", "T3", "T4"],
+	  wide: ["1º trimestre", "2º trimestre", "3º trimestre", "4º trimestre"],
+	};
+
+	const monthValues = {
+	  narrow: ["j", "f", "m", "a", "m", "j", "j", "a", "s", "o", "n", "d"],
+	  abbreviated: [
+	    "jan",
+	    "fev",
+	    "mar",
+	    "abr",
+	    "mai",
+	    "jun",
+	    "jul",
+	    "ago",
+	    "set",
+	    "out",
+	    "nov",
+	    "dez",
+	  ],
+
+	  wide: [
+	    "janeiro",
+	    "fevereiro",
+	    "março",
+	    "abril",
+	    "maio",
+	    "junho",
+	    "julho",
+	    "agosto",
+	    "setembro",
+	    "outubro",
+	    "novembro",
+	    "dezembro",
+	  ],
+	};
+
+	const dayValues = {
+	  narrow: ["D", "S", "T", "Q", "Q", "S", "S"],
+	  short: ["dom", "seg", "ter", "qua", "qui", "sex", "sab"],
+	  abbreviated: [
+	    "domingo",
+	    "segunda",
+	    "terça",
+	    "quarta",
+	    "quinta",
+	    "sexta",
+	    "sábado",
+	  ],
+
+	  wide: [
+	    "domingo",
+	    "segunda-feira",
+	    "terça-feira",
+	    "quarta-feira",
+	    "quinta-feira",
+	    "sexta-feira",
+	    "sábado",
+	  ],
+	};
+
+	const dayPeriodValues = {
+	  narrow: {
+	    am: "a",
+	    pm: "p",
+	    midnight: "mn",
+	    noon: "md",
+	    morning: "manhã",
+	    afternoon: "tarde",
+	    evening: "tarde",
+	    night: "noite",
+	  },
+	  abbreviated: {
+	    am: "AM",
+	    pm: "PM",
+	    midnight: "meia-noite",
+	    noon: "meio-dia",
+	    morning: "manhã",
+	    afternoon: "tarde",
+	    evening: "tarde",
+	    night: "noite",
+	  },
+	  wide: {
+	    am: "a.m.",
+	    pm: "p.m.",
+	    midnight: "meia-noite",
+	    noon: "meio-dia",
+	    morning: "manhã",
+	    afternoon: "tarde",
+	    evening: "tarde",
+	    night: "noite",
+	  },
+	};
+
+	const formattingDayPeriodValues = {
+	  narrow: {
+	    am: "a",
+	    pm: "p",
+	    midnight: "mn",
+	    noon: "md",
+	    morning: "da manhã",
+	    afternoon: "da tarde",
+	    evening: "da tarde",
+	    night: "da noite",
+	  },
+	  abbreviated: {
+	    am: "AM",
+	    pm: "PM",
+	    midnight: "meia-noite",
+	    noon: "meio-dia",
+	    morning: "da manhã",
+	    afternoon: "da tarde",
+	    evening: "da tarde",
+	    night: "da noite",
+	  },
+	  wide: {
+	    am: "a.m.",
+	    pm: "p.m.",
+	    midnight: "meia-noite",
+	    noon: "meio-dia",
+	    morning: "da manhã",
+	    afternoon: "da tarde",
+	    evening: "da tarde",
+	    night: "da noite",
+	  },
+	};
+
+	const ordinalNumber = (dirtyNumber, options) => {
+	  const number = Number(dirtyNumber);
+
+	  if (options?.unit === "week") {
+	    return number + "ª";
+	  }
+	  return number + "º";
+	};
+
+	(localize.localize = {
+	  ordinalNumber,
+
+	  era: (0, _index.buildLocalizeFn)({
+	    values: eraValues,
+	    defaultWidth: "wide",
+	  }),
+
+	  quarter: (0, _index.buildLocalizeFn)({
+	    values: quarterValues,
+	    defaultWidth: "wide",
+	    argumentCallback: (quarter) => quarter - 1,
+	  }),
+
+	  month: (0, _index.buildLocalizeFn)({
+	    values: monthValues,
+	    defaultWidth: "wide",
+	  }),
+
+	  day: (0, _index.buildLocalizeFn)({
+	    values: dayValues,
+	    defaultWidth: "wide",
+	  }),
+
+	  dayPeriod: (0, _index.buildLocalizeFn)({
+	    values: dayPeriodValues,
+	    defaultWidth: "wide",
+	    formattingValues: formattingDayPeriodValues,
+	    defaultFormattingWidth: "wide",
+	  }),
+	});
+	return localize;
+}
+
+var match = {};
+
+var hasRequiredMatch;
+
+function requireMatch () {
+	if (hasRequiredMatch) return match;
+	hasRequiredMatch = 1;
+	match.match = void 0;
+
+	var _index = /*@__PURE__*/ datetimePickerConstants.requireBuildMatchFn();
+	var _index2 = /*@__PURE__*/ datetimePickerConstants.requireBuildMatchPatternFn();
+
+	const matchOrdinalNumberPattern = /^(\d+)[ºªo]?/i;
+	const parseOrdinalNumberPattern = /\d+/i;
+
+	const matchEraPatterns = {
+	  narrow: /^(ac|dc|a|d)/i,
+	  abbreviated: /^(a\.?\s?c\.?|d\.?\s?c\.?)/i,
+	  wide: /^(antes de cristo|depois de cristo)/i,
+	};
+	const parseEraPatterns = {
+	  any: [/^ac/i, /^dc/i],
+	  wide: [/^antes de cristo/i, /^depois de cristo/i],
+	};
+
+	const matchQuarterPatterns = {
+	  narrow: /^[1234]/i,
+	  abbreviated: /^T[1234]/i,
+	  wide: /^[1234](º)? trimestre/i,
+	};
+	const parseQuarterPatterns = {
+	  any: [/1/i, /2/i, /3/i, /4/i],
+	};
+
+	const matchMonthPatterns = {
+	  narrow: /^[jfmajsond]/i,
+	  abbreviated: /^(jan|fev|mar|abr|mai|jun|jul|ago|set|out|nov|dez)/i,
+	  wide: /^(janeiro|fevereiro|março|abril|maio|junho|julho|agosto|setembro|outubro|novembro|dezembro)/i,
+	};
+	const parseMonthPatterns = {
+	  narrow: [
+	    /^j/i,
+	    /^f/i,
+	    /^m/i,
+	    /^a/i,
+	    /^m/i,
+	    /^j/i,
+	    /^j/i,
+	    /^a/i,
+	    /^s/i,
+	    /^o/i,
+	    /^n/i,
+	    /^d/i,
+	  ],
+
+	  any: [
+	    /^ja/i,
+	    /^fev/i,
+	    /^mar/i,
+	    /^abr/i,
+	    /^mai/i,
+	    /^jun/i,
+	    /^jul/i,
+	    /^ago/i,
+	    /^set/i,
+	    /^out/i,
+	    /^nov/i,
+	    /^dez/i,
+	  ],
+	};
+
+	const matchDayPatterns = {
+	  narrow: /^(dom|[23456]ª?|s[aá]b)/i,
+	  short: /^(dom|[23456]ª?|s[aá]b)/i,
+	  abbreviated: /^(dom|seg|ter|qua|qui|sex|s[aá]b)/i,
+	  wide: /^(domingo|(segunda|ter[cç]a|quarta|quinta|sexta)([- ]feira)?|s[aá]bado)/i,
+	};
+	const parseDayPatterns = {
+	  short: [/^d/i, /^2/i, /^3/i, /^4/i, /^5/i, /^6/i, /^s[aá]/i],
+	  narrow: [/^d/i, /^2/i, /^3/i, /^4/i, /^5/i, /^6/i, /^s[aá]/i],
+	  any: [/^d/i, /^seg/i, /^t/i, /^qua/i, /^qui/i, /^sex/i, /^s[aá]b/i],
+	};
+
+	const matchDayPeriodPatterns = {
+	  narrow: /^(a|p|mn|md|(da) (manhã|tarde|noite))/i,
+	  any: /^([ap]\.?\s?m\.?|meia[-\s]noite|meio[-\s]dia|(da) (manhã|tarde|noite))/i,
+	};
+	const parseDayPeriodPatterns = {
+	  any: {
+	    am: /^a/i,
+	    pm: /^p/i,
+	    midnight: /^mn|^meia[-\s]noite/i,
+	    noon: /^md|^meio[-\s]dia/i,
+	    morning: /manhã/i,
+	    afternoon: /tarde/i,
+	    evening: /tarde/i,
+	    night: /noite/i,
+	  },
+	};
+
+	(match.match = {
+	  ordinalNumber: (0, _index2.buildMatchPatternFn)({
+	    matchPattern: matchOrdinalNumberPattern,
+	    parsePattern: parseOrdinalNumberPattern,
+	    valueCallback: (value) => parseInt(value, 10),
+	  }),
+
+	  era: (0, _index.buildMatchFn)({
+	    matchPatterns: matchEraPatterns,
+	    defaultMatchWidth: "wide",
+	    parsePatterns: parseEraPatterns,
+	    defaultParseWidth: "any",
+	  }),
+
+	  quarter: (0, _index.buildMatchFn)({
+	    matchPatterns: matchQuarterPatterns,
+	    defaultMatchWidth: "wide",
+	    parsePatterns: parseQuarterPatterns,
+	    defaultParseWidth: "any",
+	    valueCallback: (index) => index + 1,
+	  }),
+
+	  month: (0, _index.buildMatchFn)({
+	    matchPatterns: matchMonthPatterns,
+	    defaultMatchWidth: "wide",
+	    parsePatterns: parseMonthPatterns,
+	    defaultParseWidth: "any",
+	  }),
+
+	  day: (0, _index.buildMatchFn)({
+	    matchPatterns: matchDayPatterns,
+	    defaultMatchWidth: "wide",
+	    parsePatterns: parseDayPatterns,
+	    defaultParseWidth: "any",
+	  }),
+
+	  dayPeriod: (0, _index.buildMatchFn)({
+	    matchPatterns: matchDayPeriodPatterns,
+	    defaultMatchWidth: "any",
+	    parsePatterns: parseDayPeriodPatterns,
+	    defaultParseWidth: "any",
+	  }),
+	});
+	return match;
+}
+
+var hasRequiredPtBR;
+
+function requirePtBR () {
+	if (hasRequiredPtBR) return ptBR;
+	hasRequiredPtBR = 1;
+	ptBR.ptBR = void 0;
+	var _index = /*@__PURE__*/ requireFormatDistance();
+	var _index2 = /*@__PURE__*/ requireFormatLong();
+	var _index3 = /*@__PURE__*/ requireFormatRelative();
+	var _index4 = /*@__PURE__*/ requireLocalize();
+	var _index5 = /*@__PURE__*/ requireMatch();
+
+	/**
+	 * @category Locales
+	 * @summary Portuguese locale (Brazil).
+	 * @language Portuguese
+	 * @iso-639-2 por
+	 * @author Lucas Duailibe [@duailibe](https://github.com/duailibe)
+	 * @author Yago Carballo [@yagocarballo](https://github.com/YagoCarballo)
+	 */
+	(ptBR.ptBR = {
+	  code: "pt-BR",
+	  formatDistance: _index.formatDistance,
+	  formatLong: _index2.formatLong,
+	  formatRelative: _index3.formatRelative,
+	  localize: _index4.localize,
+	  match: _index5.match,
+	  options: {
+	    weekStartsOn: 0 /* Sunday */,
+	    firstWeekContainsDate: 1,
+	  },
+	});
+	return ptBR;
+}
+
+var ptBRExports = /*@__PURE__*/ requirePtBR();
+
+var setDayExports = /*@__PURE__*/ datetimePickerConstants.requireSetDay();
+
+var setMonthExports = /*@__PURE__*/ datetimePickerConstants.requireSetMonth();
+
+var startOfWeekExports = /*@__PURE__*/ datetimePickerConstants.requireStartOfWeek();
+
+const registeredLocales = new Map([[localeCodeToKey(datetimePickerConstants.DATETIME_PICKER_LOCALE.DEFAULT), ptBRExports.ptBR]]);
+/**
+ * Converte um rótulo para capitalização de frase.
+ *
+ * @param label - Texto a ser ajustado.
+ * @returns Texto com a primeira letra em maiúscula.
+ */
+function toLabelCase(label) {
+    if (label.length === 0)
+        return label;
+    return label[0].toUpperCase() + label.slice(1);
+}
+/**
+ * Converte um código de locale IETF (ex.: "pt-BR") para a chave
+ * camelCase usada pelos exports do date-fns (ex.: "ptBR").
+ *
+ * @param localeCode - Código de locale no formato IETF.
+ * @returns Chave compatível com os exports do date-fns.
+ */
+function localeCodeToKey(localeCode) {
+    return localeCode.replace(/-/g, '');
+}
+/**
+ * Registra um locale adicional para uso pelos date pickers.
+ *
+ * O locale padrão `pt-BR` já é incluído no bundle. Outros locales podem ser
+ * importados pela aplicação consumidora e registrados somente quando forem
+ * necessários, evitando que o catálogo completo do date-fns seja empacotado.
+ *
+ * @param localeCode - Código usado na propriedade `locale` do componente.
+ * @param locale - Locale compatível com o date-fns.
+ * @throws {TypeError} Quando o código ou o objeto de locale são inválidos.
+ */
+function registerDatePickerLocale(localeCode, locale) {
+    if (typeof localeCode !== 'string' || localeCode.trim().length === 0) {
+        throw new TypeError('localeCode deve ser uma string não vazia');
+    }
+    if (locale == null || typeof locale !== 'object') {
+        throw new TypeError('locale deve ser um objeto compatível com date-fns');
+    }
+    registeredLocales.set(localeCodeToKey(localeCode), locale);
+}
+/**
+ * Resolve o objeto `Locale` do date-fns a partir do código público informado.
+ *
+ * @param localeCode - Código de locale aceito pelo componente.
+ * @returns Locale resolvido ou `ptBR` quando não houver correspondência.
+ */
+function resolveDateFnsLocale(localeCode = datetimePickerConstants.DATETIME_PICKER_LOCALE.DEFAULT) {
+    const key = localeCodeToKey(localeCode);
+    return registeredLocales.get(key) ?? ptBRExports.ptBR;
+}
+/**
+ * Gera os rótulos de mês no locale informado.
+ *
+ * @param localeCode - Código de locale aceito pelo componente.
+ * @returns Lista com os 12 meses formatados para exibição.
+ */
+function getMonthLabels(localeCode) {
+    const locale = resolveDateFnsLocale(localeCode);
+    const baseDate = new Date(2026, 0, 1);
+    return Array.from({ length: 12 }, (_, monthIndex) => {
+        const monthDate = setMonthExports.setMonth(baseDate, monthIndex);
+        return toLabelCase(datetimePickerConstants.formatExports.format(monthDate, 'MMMM', { locale }));
+    });
+}
+/**
+ * Gera os rótulos dos dias da semana considerando o início informado.
+ *
+ * @param localeCode - Código de locale aceito pelo componente.
+ * @param weekStartsOn - Índice do primeiro dia da semana.
+ * @returns Lista com abreviações dos sete dias da semana.
+ */
+function getWeekdayLabels(localeCode, weekStartsOn) {
+    const locale = resolveDateFnsLocale(localeCode);
+    const baseDate = new Date(2026, 0, 4);
+    const weekStartDate = startOfWeekExports.startOfWeek(setDayExports.setDay(baseDate, weekStartsOn), { weekStartsOn });
+    return Array.from({ length: 7 }, (_, dayIndex) => {
+        const dayDate = addDaysExports.addDays(weekStartDate, dayIndex);
+        const abbreviated = datetimePickerConstants.formatExports.format(dayDate, 'EEE', { locale }).slice(0, 3);
+        return toLabelCase(abbreviated);
+    });
+}
+
+exports.addDaysExports = addDaysExports;
+exports.getMonthLabels = getMonthLabels;
+exports.getWeekdayLabels = getWeekdayLabels;
+exports.registerDatePickerLocale = registerDatePickerLocale;
+exports.resolveDateFnsLocale = resolveDateFnsLocale;
+exports.startOfWeekExports = startOfWeekExports;