rl-core-front 0.15.4 → 0.15.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rl-core-front",
-  "version": "0.15.4",
+  "version": "0.15.6",
   "description": "Telas e componentes Next.js do core: login com 2FA, usuários, RBAC, auditoria, logs e listagens com filtro dinâmico",
   "author": "Rodrigo Liberti",
   "license": "MIT",

package/src/_utils/calendar.ts

@@ -66,16 +66,19 @@ export const today = (): Date => {
 };
 
 /**
- * Grade do mês: 6 semanas × 7 dias, começando na segunda-feira.
+ * Grade do mês: 6 semanas × 7 dias, começando no domingo.
+ *
+ * Domingo na primeira coluna porque é como o calendário é lido aqui — o de
+ * parede, o do celular e o do banco começam nele, e uma grade que começa na
+ * segunda faz quem procura o dia 12 contar coluna por coluna.
  *
  * Seis semanas fixas de propósito — com 5 ou 6 conforme o mês, o painel muda de
  * altura ao navegar e o calendário "pula" na tela.
  */
 export const monthGrid = (month: Date): Date[] => {
   const first = dayOf(month.getFullYear(), month.getMonth(), 1);
-  // getDay(): 0 = domingo. Queremos segunda como primeira coluna.
-  const offset = (first.getDay() + 6) % 7;
-  const start = addDays(first, -offset);
+  // getDay(): 0 = domingo, que é a primeira coluna.
+  const start = addDays(first, -first.getDay());
   return Array.from({ length: 42 }, (_, index) => addDays(start, index));
 };
 
@@ -85,12 +88,12 @@ export const monthLabel = (month: Date, locale: string): string =>
     month,
   );
 
-/** Iniciais dos dias da semana, de segunda a domingo, no locale. */
+/** Iniciais dos dias da semana, de domingo a sábado, no locale. */
 export const weekdayLabels = (locale: string): string[] => {
   const formatter = new Intl.DateTimeFormat(locale, { weekday: "short" });
-  // 2026-06-01 é uma segunda-feira — âncora só para varrer a semana.
+  // Dia 0 de junho é 31/05/2026, um domingo — âncora só para varrer a semana.
   return Array.from({ length: 7 }, (_, index) =>
-    formatter.format(dayOf(2026, 5, 1 + index)).replace(".", ""),
+    formatter.format(dayOf(2026, 5, index)).replace(".", ""),
   );
 };
 
@@ -101,3 +104,204 @@ export const formatDay = (value: string, locale: string): string => {
     ? new Intl.DateTimeFormat(locale, { dateStyle: "short" }).format(date)
     : value;
 };
+
+/**
+ * A ordem em que o locale escreve dia, mês e ano.
+ *
+ * Sai do próprio `Intl` e não de uma tabela: `pt-BR` escreve 11/08/2026 e
+ * `en-US`, 08/11/2026 — a mesma sequência de dígitos significa dias
+ * diferentes, e é ela que o campo digitado precisa respeitar.
+ */
+export const dayFieldOrder = (locale: string): ("day" | "month" | "year")[] =>
+  new Intl.DateTimeFormat(locale, { dateStyle: "short" })
+    .formatToParts(dayOf(2026, 7, 11))
+    .map((part) => part.type)
+    .filter((type): type is "day" | "month" | "year" =>
+      type === "day" || type === "month" || type === "year",
+    );
+
+/** `dd/mm/aaaa` no locale — o que o campo mostra enquanto está vazio. */
+export const dayPlaceholder = (locale: string): string => {
+  const letra = { day: "dd", month: "mm", year: locale.startsWith("pt") ? "aaaa" : "yyyy" };
+
+  return dayFieldOrder(locale)
+    .map((field) => letra[field])
+    .join("/");
+};
+
+/** Quantos dígitos cabem em cada campo da data, e o maior valor de cada um. */
+const DAY_FIELD_SIZES: Record<"day" | "month" | "year", number> = {
+  day: 2,
+  month: 2,
+  year: 4,
+};
+const DAY_FIELD_MAX: Record<"day" | "month" | "year", number> = {
+  day: 31,
+  month: 12,
+  // O ano não tem teto que ajude enquanto se digita: 2 é o começo de 2026.
+  year: Infinity,
+};
+
+/** O campo formado e quantos dígitos ele consumiu — o resto vai para o próximo. */
+interface FittedField {
+  value: string;
+  used: number;
+}
+
+/**
+ * O campo enquanto ele é digitado, dentro do que existe no calendário.
+ *
+ * Três regras, todas para o campo nunca mostrar o que não existe:
+ *
+ * - dígito que não pode **começar** valor nenhum fecha o campo com zero na
+ *   frente — no mês, `3` só poderia virar 30 a 39, então já vira `03`;
+ * - dígito que estoura o par não é engolido, transborda: `3` e `2` no dia
+ *   viram `3/2`, que é o que quem digitou `3` e `2` queria dizer;
+ * - `00` não é dia nem mês.
+ *
+ * O zero na frente só entra quando se está **digitando**. Apagando, ele
+ * devolveria na hora o dígito recém-tirado, e o campo ficaria impossível de
+ * corrigir.
+ */
+const fitDayField = (
+  digits: string,
+  max: number,
+  size: number,
+  autoZero: boolean,
+): FittedField => {
+  const primeiro = digits.slice(0, 1);
+
+  if (autoZero && primeiro !== "" && Number(primeiro) * 10 > max) {
+    return { value: `0${primeiro}`, used: 1 };
+  }
+
+  const cheio = digits.slice(0, size);
+
+  // `00` não é dia nem mês, e o segundo zero não serve para o campo seguinte:
+  // some, em vez de virar um mês zero logo ali.
+  if (cheio.length === size && Number(cheio) === 0) {
+    return { value: cheio.slice(0, size - 1), used: size };
+  }
+
+  if (cheio.length === size && Number(cheio) > max) {
+    return { value: cheio.slice(0, size - 1), used: size - 1 };
+  }
+
+  return { value: cheio, used: cheio.length };
+};
+
+/**
+ * Põe as barras enquanto se digita: `1108` vira `11/08`.
+ *
+ * Campo a campo, e não recontando os dígitos do começo: apagar o `3` de
+ * `31/08/2026` deixa `1/08/2026`, e não `10/82/026` — o que sobra de um campo
+ * cheio transborda para o seguinte, mas nada é puxado de volta.
+ *
+ * O locale entra porque é ele que diz qual campo é o dia e qual é o mês, e os
+ * dois têm tetos diferentes: `13` é dia e não é mês. O texto anterior entra
+ * para separar quem digita de quem apaga — ver `fitDayField`.
+ */
+export const maskDay = (raw: string, locale: string, previous = ""): string => {
+  const order = dayFieldOrder(locale);
+  const partes = raw.replace(/[^\d/]/g, "").split("/").slice(0, order.length);
+  const apagando = raw.length < previous.length;
+  const saida: string[] = [];
+  let resto = "";
+
+  for (let posicao = 0; posicao < order.length; posicao += 1) {
+    const campo = order[posicao];
+    const tamanho = DAY_FIELD_SIZES[campo];
+    const digits = `${resto}${partes[posicao] ?? ""}`.replace(/\D/g, "");
+    const { value, used } = fitDayField(
+      digits,
+      DAY_FIELD_MAX[campo],
+      tamanho,
+      !apagando,
+    );
+
+    saida.push(value);
+
+    /*
+      O que sobra só empurra os campos seguintes quando eles ainda estão
+      vazios.
+
+      Digitando do zero, empurrar é o que faz `1108` virar `11/08`. Mas
+      corrigindo o dia de uma data já escrita, o dígito recusado empurrava o
+      resto inteiro: trocar o `31` de `31/02/2056` por `32` devolvia
+      `3/02/0220`, com mês e ano remontados a partir do que sobrou. Aqui ele
+      simplesmente não entra — a data continua a que estava, com o campo em
+      correção mais curto.
+
+      A exceção é o excedente de tamanho: quem digitou mais dígitos do que o
+      campo comporta (colando, ou apagando uma barra) quis mesmo dizer o campo
+      seguinte.
+    */
+    const temConteudoDepois = partes
+      .slice(posicao + 1)
+      .some((parte) => parte !== "");
+    const sobraPorTamanho = digits.length > tamanho;
+
+    resto = temConteudoDepois && !sobraPorTamanho ? "" : digits.slice(used);
+
+    // Sem transbordo e sem mais nada digitado, a data acaba aqui: acrescentar
+    // um campo vazio escreveria a barra que ninguém pediu.
+    if (resto === "" && partes.length <= posicao + 1) {
+      break;
+    }
+  }
+
+  return saida.join("/");
+};
+
+/**
+ * O que foi digitado vira `"yyyy-MM-dd"`, ou `null` enquanto não for uma data.
+ *
+ * Lê os campos separados pelas barras, na ordem do locale: `1/8/2026` é uma
+ * data tão boa quanto `01/08/2026`, e exigir o zero à esquerda faria o campo
+ * recusar o que ele mesmo acabou de mostrar.
+ *
+ * O ano pode faltar: `1108` é 11 de agosto do ano de referência — quase todo
+ * lançamento é do ano corrente, e obrigar a digitar `2026` toda vez é o tipo
+ * de exigência que faz o campo ser abandonado pelo calendário. Ano começado
+ * (`202`) ainda não é ano, e não vale como digitado.
+ *
+ * A conferência é de existência, não de formato: `31/02` casa com a máscara e
+ * não existe, e o `Date` do JavaScript o transformaria em 03/03 em silêncio.
+ */
+export const parseTypedDay = (
+  text: string,
+  locale: string,
+  fallbackYear: number,
+): string | null => {
+  const campos = maskDay(text, locale).split("/");
+
+  if (campos.length < 2) {
+    return null;
+  }
+
+  const order = dayFieldOrder(locale);
+  const campoDe = (field: "day" | "month" | "year"): string =>
+    campos[order.indexOf(field)] ?? "";
+
+  const anoDigitado = campoDe("year");
+
+  if (anoDigitado !== "" && anoDigitado.length < 4) {
+    return null;
+  }
+
+  const day = Number(campoDe("day"));
+  const month = Number(campoDe("month"));
+  const year = anoDigitado === "" ? fallbackYear : Number(anoDigitado);
+
+  if (!day || !month) {
+    return null;
+  }
+
+  const date = dayOf(year, month - 1, day);
+  const existe =
+    date.getFullYear() === year &&
+    date.getMonth() === month - 1 &&
+    date.getDate() === day;
+
+  return existe ? toIsoDay(date) : null;
+};