structra-ui 0.1.15 → 0.1.17

package/esm2022/app/_utils/date-pt-br.utils.mjs

@@ -0,0 +1,82 @@
+/**
+ * Formatação e normalização de data/hora no padrão pt-BR (lib ui-fields).
+ */
+function pad2(n) {
+    return n.toString().padStart(2, '0');
+}
+/**
+ * Exibe data como dd/mm/aaaa; com `showTimeHours`, dd/mm/aaaa hh:mm:ss (24h).
+ */
+export function formatDateTimePtBr(date, showTimeHours) {
+    const d = pad2(date.getDate());
+    const m = pad2(date.getMonth() + 1);
+    const y = date.getFullYear();
+    if (!showTimeHours) {
+        return `${d}/${m}/${y}`;
+    }
+    return `${d}/${m}/${y} ${pad2(date.getHours())}:${pad2(date.getMinutes())}:${pad2(date.getSeconds())}`;
+}
+/**
+ * Interpreta valor vindo do formulário / API.
+ * Aceita data local sem fuso (`YYYY-MM-DD` ou `YYYY-MM-DDTHH:mm:ss`), `Date`, número ou ISO com `Z`.
+ */
+export function parseUiFieldDateValue(value) {
+    if (value == null || value === '') {
+        return null;
+    }
+    if (value instanceof Date) {
+        return Number.isNaN(value.getTime()) ? null : value;
+    }
+    if (typeof value === 'number') {
+        const d = new Date(value);
+        return Number.isNaN(d.getTime()) ? null : d;
+    }
+    if (typeof value !== 'string') {
+        return null;
+    }
+    const s = value.trim();
+    const localDateOnly = /^(\d{4})-(\d{2})-(\d{2})$/.exec(s);
+    if (localDateOnly) {
+        const y = +localDateOnly[1];
+        const m = +localDateOnly[2] - 1;
+        const d = +localDateOnly[3];
+        const out = new Date(y, m, d, 0, 0, 0, 0);
+        return Number.isNaN(out.getTime()) ? null : out;
+    }
+    const localDt = /^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2}):(\d{2})$/.exec(s);
+    if (localDt) {
+        const out = new Date(+localDt[1], +localDt[2] - 1, +localDt[3], +localDt[4], +localDt[5], +localDt[6], 0);
+        return Number.isNaN(out.getTime()) ? null : out;
+    }
+    const d = new Date(s);
+    return Number.isNaN(d.getTime()) ? null : d;
+}
+/**
+ * Valor persistido no `FormControl`: horário de parede local, sem `Z`
+ * (evita 14:59 no input virar 17:59 no `JSON.stringify` de `Date`).
+ */
+export function formatUiFieldDateValue(d, showTimeHours) {
+    const y = d.getFullYear();
+    const mo = pad2(d.getMonth() + 1);
+    const day = pad2(d.getDate());
+    if (!showTimeHours) {
+        return `${y}-${mo}-${day}`;
+    }
+    return `${y}-${mo}-${day}T${pad2(d.getHours())}:${pad2(d.getMinutes())}:${pad2(d.getSeconds())}`;
+}
+/** @deprecated use {@link parseUiFieldDateValue} */
+export function normalizeFormDateValue(value) {
+    return parseUiFieldDateValue(value);
+}
+/**
+ * Data escolhida no calendário: meia-noite local, ou com `showTimeHours` a hora completa
+ * (h, min, s, ms) do instante da seleção.
+ */
+export function applyPickedCalendarDate(picked, showTimeHours) {
+    if (!showTimeHours) {
+        return new Date(picked.getFullYear(), picked.getMonth(), picked.getDate(), 0, 0, 0, 0);
+    }
+    const now = new Date();
+    return new Date(picked.getFullYear(), picked.getMonth(), picked.getDate(), now.getHours(), now.getMinutes(), now.getSeconds(), now.getMilliseconds());
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"date-pt-br.utils.js","sourceRoot":"","sources":["../../../../../src/app/_utils/date-pt-br.utils.ts"],"names":[],"mappings":"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","sourcesContent":["/**\r\n * Formatação e normalização de data/hora no padrão pt-BR (lib ui-fields).\r\n */\r\n\r\nfunction pad2(n: number): string {\r\n  return n.toString().padStart(2, '0');\r\n}\r\n\r\n/**\r\n * Exibe data como dd/mm/aaaa; com `showTimeHours`, dd/mm/aaaa hh:mm:ss (24h).\r\n */\r\nexport function formatDateTimePtBr(date: Date, showTimeHours: boolean): string {\r\n  const d = pad2(date.getDate());\r\n  const m = pad2(date.getMonth() + 1);\r\n  const y = date.getFullYear();\r\n  if (!showTimeHours) {\r\n    return `${d}/${m}/${y}`;\r\n  }\r\n  return `${d}/${m}/${y} ${pad2(date.getHours())}:${pad2(date.getMinutes())}:${pad2(date.getSeconds())}`;\r\n}\r\n\r\n/**\r\n * Interpreta valor vindo do formulário / API.\r\n * Aceita data local sem fuso (`YYYY-MM-DD` ou `YYYY-MM-DDTHH:mm:ss`), `Date`, número ou ISO com `Z`.\r\n */\r\nexport function parseUiFieldDateValue(value: unknown): Date | null {\r\n  if (value == null || value === '') {\r\n    return null;\r\n  }\r\n  if (value instanceof Date) {\r\n    return Number.isNaN(value.getTime()) ? null : value;\r\n  }\r\n  if (typeof value === 'number') {\r\n    const d = new Date(value);\r\n    return Number.isNaN(d.getTime()) ? null : d;\r\n  }\r\n  if (typeof value !== 'string') {\r\n    return null;\r\n  }\r\n  const s = value.trim();\r\n  const localDateOnly = /^(\\d{4})-(\\d{2})-(\\d{2})$/.exec(s);\r\n  if (localDateOnly) {\r\n    const y = +localDateOnly[1];\r\n    const m = +localDateOnly[2] - 1;\r\n    const d = +localDateOnly[3];\r\n    const out = new Date(y, m, d, 0, 0, 0, 0);\r\n    return Number.isNaN(out.getTime()) ? null : out;\r\n  }\r\n  const localDt = /^(\\d{4})-(\\d{2})-(\\d{2})T(\\d{2}):(\\d{2}):(\\d{2})$/.exec(s);\r\n  if (localDt) {\r\n    const out = new Date(\r\n      +localDt[1],\r\n      +localDt[2] - 1,\r\n      +localDt[3],\r\n      +localDt[4],\r\n      +localDt[5],\r\n      +localDt[6],\r\n      0,\r\n    );\r\n    return Number.isNaN(out.getTime()) ? null : out;\r\n  }\r\n  const d = new Date(s);\r\n  return Number.isNaN(d.getTime()) ? null : d;\r\n}\r\n\r\n/**\r\n * Valor persistido no `FormControl`: horário de parede local, sem `Z`\r\n * (evita 14:59 no input virar 17:59 no `JSON.stringify` de `Date`).\r\n */\r\nexport function formatUiFieldDateValue(d: Date, showTimeHours: boolean): string {\r\n  const y = d.getFullYear();\r\n  const mo = pad2(d.getMonth() + 1);\r\n  const day = pad2(d.getDate());\r\n  if (!showTimeHours) {\r\n    return `${y}-${mo}-${day}`;\r\n  }\r\n  return `${y}-${mo}-${day}T${pad2(d.getHours())}:${pad2(d.getMinutes())}:${pad2(d.getSeconds())}`;\r\n}\r\n\r\n/** @deprecated use {@link parseUiFieldDateValue} */\r\nexport function normalizeFormDateValue(value: unknown): Date | null {\r\n  return parseUiFieldDateValue(value);\r\n}\r\n\r\n/**\r\n * Data escolhida no calendário: meia-noite local, ou com `showTimeHours` a hora completa\r\n * (h, min, s, ms) do instante da seleção.\r\n */\r\nexport function applyPickedCalendarDate(\r\n  picked: Date,\r\n  showTimeHours: boolean,\r\n): Date {\r\n  if (!showTimeHours) {\r\n    return new Date(\r\n      picked.getFullYear(),\r\n      picked.getMonth(),\r\n      picked.getDate(),\r\n      0,\r\n      0,\r\n      0,\r\n      0,\r\n    );\r\n  }\r\n  const now = new Date();\r\n  return new Date(\r\n    picked.getFullYear(),\r\n    picked.getMonth(),\r\n    picked.getDate(),\r\n    now.getHours(),\r\n    now.getMinutes(),\r\n    now.getSeconds(),\r\n    now.getMilliseconds(),\r\n  );\r\n}\r\n"]}

package/esm2022/app/_utils/decimal-br.utils.mjs

@@ -0,0 +1,154 @@
+/**
+ * Utilitários pt-BR fixo: vírgula decimal, ponto milhar, duas casas na formatação final.
+ */
+import { formatIntegerThousandsBr } from './integer-br.utils';
+export { formatIntegerThousandsBr } from './integer-br.utils';
+export function sanitizeDecimalBrInput(raw) {
+    return raw.replace(/[^\d,.]/g, '');
+}
+/**
+ * Remove pontos e interpreta a última vírgula como separador decimal.
+ * Retorna apenas dígitos na parte inteira e até 2 na fracionária.
+ */
+export function extractDecimalBrParts(rawDisplay) {
+    const noDots = rawDisplay.replace(/\./g, '');
+    const lastComma = noDots.lastIndexOf(',');
+    if (lastComma === -1) {
+        return {
+            intDigits: noDots.replace(/\D/g, ''),
+            fracDigits: '',
+            hasComma: false,
+        };
+    }
+    const intDigits = noDots.slice(0, lastComma).replace(/\D/g, '');
+    const fracDigits = noDots
+        .slice(lastComma + 1)
+        .replace(/\D/g, '')
+        .slice(0, 2);
+    return { intDigits, fracDigits, hasComma: true };
+}
+/**
+ * Monta o texto exibido durante a digitação (milhares com ponto, vírgula decimal).
+ */
+export function buildDecimalBrDisplay(parts) {
+    const { intDigits, fracDigits, hasComma } = parts;
+    if (!hasComma) {
+        return formatIntegerThousandsBr(intDigits);
+    }
+    const intDisplay = intDigits === '' ? '0' : formatIntegerThousandsBr(intDigits);
+    return `${intDisplay},${fracDigits}`;
+}
+/**
+ * Posição semântica do cursor para remapear após reformatar.
+ */
+export function semanticCaretAt(value, caret) {
+    const left = value.slice(0, caret);
+    const noDots = left.replace(/\./g, '');
+    const commaIdx = noDots.indexOf(',');
+    if (commaIdx === -1) {
+        return {
+            intCount: noDots.replace(/\D/g, '').length,
+            afterComma: false,
+            fracCount: 0,
+        };
+    }
+    const before = noDots.slice(0, commaIdx).replace(/\D/g, '');
+    const after = noDots.slice(commaIdx + 1).replace(/\D/g, '');
+    return {
+        intCount: before.length,
+        afterComma: true,
+        fracCount: after.length,
+    };
+}
+/**
+ * Índice do caret no texto formatado a partir da posição semântica.
+ */
+export function caretIndexFromSemantic(display, target) {
+    let intCount = 0;
+    let afterComma = false;
+    let fracCount = 0;
+    for (let i = 0; i < display.length; i++) {
+        const ch = display[i];
+        if (ch === ',') {
+            if (!afterComma) {
+                afterComma = true;
+                if (target.afterComma &&
+                    target.fracCount === 0 &&
+                    target.intCount === intCount) {
+                    return i + 1;
+                }
+            }
+            continue;
+        }
+        if (ch === '.') {
+            continue;
+        }
+        if (/\d/.test(ch)) {
+            if (!afterComma) {
+                intCount++;
+                if (!target.afterComma && intCount === target.intCount) {
+                    return i + 1;
+                }
+            }
+            else {
+                fracCount++;
+                if (target.afterComma &&
+                    fracCount === target.fracCount &&
+                    intCount === target.intCount) {
+                    return i + 1;
+                }
+            }
+        }
+    }
+    return display.length;
+}
+/**
+ * String passível de parseDecimalBr a partir das partes editáveis.
+ */
+export function buildDecimalBrParseString(parts) {
+    if (!parts.hasComma) {
+        return parts.intDigits;
+    }
+    return `${parts.intDigits},${parts.fracDigits}`;
+}
+/**
+ * Interpreta string já sanitizada e retorna número com até 2 casas decimais (arredondamento).
+ * Vazio → null. Vírgula como separador decimal; pontos são removidos da parte inteira.
+ */
+export function parseDecimalBr(sanitized) {
+    const t = sanitized.trim();
+    if (t === '') {
+        return null;
+    }
+    const lastComma = t.lastIndexOf(',');
+    let intRaw;
+    let fracRaw;
+    if (lastComma >= 0) {
+        intRaw = t.slice(0, lastComma).replace(/\./g, '');
+        fracRaw = t.slice(lastComma + 1).replace(/\./g, '');
+    }
+    else {
+        intRaw = t.replace(/\./g, '');
+        fracRaw = '';
+    }
+    if (!/^\d*$/.test(intRaw) || !/^\d*$/.test(fracRaw)) {
+        return null;
+    }
+    if (intRaw === '' && fracRaw === '') {
+        return null;
+    }
+    const intPart = intRaw === '' ? '0' : intRaw;
+    const fracPadded = (fracRaw + '00').slice(0, 2);
+    const n = Number(`${intPart}.${fracPadded}`);
+    if (!Number.isFinite(n)) {
+        return null;
+    }
+    return Math.round(n * 100) / 100;
+}
+export function formatDecimalBr(value) {
+    return new Intl.NumberFormat('pt-BR', {
+        minimumFractionDigits: 2,
+        maximumFractionDigits: 2,
+    }).format(value);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"decimal-br.utils.js","sourceRoot":"","sources":["../../../../../src/app/_utils/decimal-br.utils.ts"],"names":[],"mappings":"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","sourcesContent":["/**\r\n * Utilitários pt-BR fixo: vírgula decimal, ponto milhar, duas casas na formatação final.\r\n */\r\n\r\nimport { formatIntegerThousandsBr } from './integer-br.utils';\r\n\r\nexport { formatIntegerThousandsBr } from './integer-br.utils';\r\n\r\nexport function sanitizeDecimalBrInput(raw: string): string {\r\n  return raw.replace(/[^\\d,.]/g, '');\r\n}\r\n\r\n/**\r\n * Remove pontos e interpreta a última vírgula como separador decimal.\r\n * Retorna apenas dígitos na parte inteira e até 2 na fracionária.\r\n */\r\nexport function extractDecimalBrParts(rawDisplay: string): {\r\n  intDigits: string;\r\n  fracDigits: string;\r\n  hasComma: boolean;\r\n} {\r\n  const noDots = rawDisplay.replace(/\\./g, '');\r\n  const lastComma = noDots.lastIndexOf(',');\r\n  if (lastComma === -1) {\r\n    return {\r\n      intDigits: noDots.replace(/\\D/g, ''),\r\n      fracDigits: '',\r\n      hasComma: false,\r\n    };\r\n  }\r\n  const intDigits = noDots.slice(0, lastComma).replace(/\\D/g, '');\r\n  const fracDigits = noDots\r\n    .slice(lastComma + 1)\r\n    .replace(/\\D/g, '')\r\n    .slice(0, 2);\r\n  return { intDigits, fracDigits, hasComma: true };\r\n}\r\n\r\n/**\r\n * Monta o texto exibido durante a digitação (milhares com ponto, vírgula decimal).\r\n */\r\nexport function buildDecimalBrDisplay(parts: {\r\n  intDigits: string;\r\n  fracDigits: string;\r\n  hasComma: boolean;\r\n}): string {\r\n  const { intDigits, fracDigits, hasComma } = parts;\r\n  if (!hasComma) {\r\n    return formatIntegerThousandsBr(intDigits);\r\n  }\r\n  const intDisplay =\r\n    intDigits === '' ? '0' : formatIntegerThousandsBr(intDigits);\r\n  return `${intDisplay},${fracDigits}`;\r\n}\r\n\r\n/**\r\n * Posição semântica do cursor para remapear após reformatar.\r\n */\r\nexport function semanticCaretAt(\r\n  value: string,\r\n  caret: number,\r\n): { intCount: number; afterComma: boolean; fracCount: number } {\r\n  const left = value.slice(0, caret);\r\n  const noDots = left.replace(/\\./g, '');\r\n  const commaIdx = noDots.indexOf(',');\r\n  if (commaIdx === -1) {\r\n    return {\r\n      intCount: noDots.replace(/\\D/g, '').length,\r\n      afterComma: false,\r\n      fracCount: 0,\r\n    };\r\n  }\r\n  const before = noDots.slice(0, commaIdx).replace(/\\D/g, '');\r\n  const after = noDots.slice(commaIdx + 1).replace(/\\D/g, '');\r\n  return {\r\n    intCount: before.length,\r\n    afterComma: true,\r\n    fracCount: after.length,\r\n  };\r\n}\r\n\r\n/**\r\n * Índice do caret no texto formatado a partir da posição semântica.\r\n */\r\nexport function caretIndexFromSemantic(\r\n  display: string,\r\n  target: { intCount: number; afterComma: boolean; fracCount: number },\r\n): number {\r\n  let intCount = 0;\r\n  let afterComma = false;\r\n  let fracCount = 0;\r\n\r\n  for (let i = 0; i < display.length; i++) {\r\n    const ch = display[i];\r\n    if (ch === ',') {\r\n      if (!afterComma) {\r\n        afterComma = true;\r\n        if (\r\n          target.afterComma &&\r\n          target.fracCount === 0 &&\r\n          target.intCount === intCount\r\n        ) {\r\n          return i + 1;\r\n        }\r\n      }\r\n      continue;\r\n    }\r\n    if (ch === '.') {\r\n      continue;\r\n    }\r\n    if (/\\d/.test(ch)) {\r\n      if (!afterComma) {\r\n        intCount++;\r\n        if (!target.afterComma && intCount === target.intCount) {\r\n          return i + 1;\r\n        }\r\n      } else {\r\n        fracCount++;\r\n        if (\r\n          target.afterComma &&\r\n          fracCount === target.fracCount &&\r\n          intCount === target.intCount\r\n        ) {\r\n          return i + 1;\r\n        }\r\n      }\r\n    }\r\n  }\r\n  return display.length;\r\n}\r\n\r\n/**\r\n * String passível de parseDecimalBr a partir das partes editáveis.\r\n */\r\nexport function buildDecimalBrParseString(parts: {\r\n  intDigits: string;\r\n  fracDigits: string;\r\n  hasComma: boolean;\r\n}): string {\r\n  if (!parts.hasComma) {\r\n    return parts.intDigits;\r\n  }\r\n  return `${parts.intDigits},${parts.fracDigits}`;\r\n}\r\n\r\n/**\r\n * Interpreta string já sanitizada e retorna número com até 2 casas decimais (arredondamento).\r\n * Vazio → null. Vírgula como separador decimal; pontos são removidos da parte inteira.\r\n */\r\nexport function parseDecimalBr(sanitized: string): number | null {\r\n  const t = sanitized.trim();\r\n  if (t === '') {\r\n    return null;\r\n  }\r\n\r\n  const lastComma = t.lastIndexOf(',');\r\n  let intRaw: string;\r\n  let fracRaw: string;\r\n\r\n  if (lastComma >= 0) {\r\n    intRaw = t.slice(0, lastComma).replace(/\\./g, '');\r\n    fracRaw = t.slice(lastComma + 1).replace(/\\./g, '');\r\n  } else {\r\n    intRaw = t.replace(/\\./g, '');\r\n    fracRaw = '';\r\n  }\r\n\r\n  if (!/^\\d*$/.test(intRaw) || !/^\\d*$/.test(fracRaw)) {\r\n    return null;\r\n  }\r\n  if (intRaw === '' && fracRaw === '') {\r\n    return null;\r\n  }\r\n\r\n  const intPart = intRaw === '' ? '0' : intRaw;\r\n  const fracPadded = (fracRaw + '00').slice(0, 2);\r\n  const n = Number(`${intPart}.${fracPadded}`);\r\n  if (!Number.isFinite(n)) {\r\n    return null;\r\n  }\r\n  return Math.round(n * 100) / 100;\r\n}\r\n\r\nexport function formatDecimalBr(value: number): string {\r\n  return new Intl.NumberFormat('pt-BR', {\r\n    minimumFractionDigits: 2,\r\n    maximumFractionDigits: 2,\r\n  }).format(value);\r\n}\r\n"]}

package/esm2022/app/_utils/estados-br.data.mjs

@@ -0,0 +1,37 @@
+/** Unidades federativas do Brasil (nome + sigla). Ordem alfabética por nome. */
+export const BR_ESTADOS_NOME_SIGLA = [
+    { nome: 'Acre', sigla: 'AC' },
+    { nome: 'Alagoas', sigla: 'AL' },
+    { nome: 'Amapá', sigla: 'AP' },
+    { nome: 'Amazonas', sigla: 'AM' },
+    { nome: 'Bahia', sigla: 'BA' },
+    { nome: 'Ceará', sigla: 'CE' },
+    { nome: 'Distrito Federal', sigla: 'DF' },
+    { nome: 'Espírito Santo', sigla: 'ES' },
+    { nome: 'Goiás', sigla: 'GO' },
+    { nome: 'Maranhão', sigla: 'MA' },
+    { nome: 'Mato Grosso', sigla: 'MT' },
+    { nome: 'Mato Grosso do Sul', sigla: 'MS' },
+    { nome: 'Minas Gerais', sigla: 'MG' },
+    { nome: 'Pará', sigla: 'PA' },
+    { nome: 'Paraíba', sigla: 'PB' },
+    { nome: 'Paraná', sigla: 'PR' },
+    { nome: 'Pernambuco', sigla: 'PE' },
+    { nome: 'Piauí', sigla: 'PI' },
+    { nome: 'Rio de Janeiro', sigla: 'RJ' },
+    { nome: 'Rio Grande do Norte', sigla: 'RN' },
+    { nome: 'Rio Grande do Sul', sigla: 'RS' },
+    { nome: 'Rondônia', sigla: 'RO' },
+    { nome: 'Roraima', sigla: 'RR' },
+    { nome: 'Santa Catarina', sigla: 'SC' },
+    { nome: 'São Paulo', sigla: 'SP' },
+    { nome: 'Sergipe', sigla: 'SE' },
+    { nome: 'Tocantins', sigla: 'TO' },
+];
+export function mapEstadosToOptions(slice) {
+    return slice.map((e) => ({
+        label: `${e.nome} (${e.sigla})`,
+        value: e.sigla,
+    }));
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXN0YWRvcy1ici5kYXRhLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vc3JjL2FwcC9fdXRpbHMvZXN0YWRvcy1ici5kYXRhLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUVBLGdGQUFnRjtBQUNoRixNQUFNLENBQUMsTUFBTSxxQkFBcUIsR0FBbUQ7SUFDbkYsRUFBRSxJQUFJLEVBQUUsTUFBTSxFQUFFLEtBQUssRUFBRSxJQUFJLEVBQUU7SUFDN0IsRUFBRSxJQUFJLEVBQUUsU0FBUyxFQUFFLEtBQUssRUFBRSxJQUFJLEVBQUU7SUFDaEMsRUFBRSxJQUFJLEVBQUUsT0FBTyxFQUFFLEtBQUssRUFBRSxJQUFJLEVBQUU7SUFDOUIsRUFBRSxJQUFJLEVBQUUsVUFBVSxFQUFFLEtBQUssRUFBRSxJQUFJLEVBQUU7SUFDakMsRUFBRSxJQUFJLEVBQUUsT0FBTyxFQUFFLEtBQUssRUFBRSxJQUFJLEVBQUU7SUFDOUIsRUFBRSxJQUFJLEVBQUUsT0FBTyxFQUFFLEtBQUssRUFBRSxJQUFJLEVBQUU7SUFDOUIsRUFBRSxJQUFJLEVBQUUsa0JBQWtCLEVBQUUsS0FBSyxFQUFFLElBQUksRUFBRTtJQUN6QyxFQUFFLElBQUksRUFBRSxnQkFBZ0IsRUFBRSxLQUFLLEVBQUUsSUFBSSxFQUFFO0lBQ3ZDLEVBQUUsSUFBSSxFQUFFLE9BQU8sRUFBRSxLQUFLLEVBQUUsSUFBSSxFQUFFO0lBQzlCLEVBQUUsSUFBSSxFQUFFLFVBQVUsRUFBRSxLQUFLLEVBQUUsSUFBSSxFQUFFO0lBQ2pDLEVBQUUsSUFBSSxFQUFFLGFBQWEsRUFBRSxLQUFLLEVBQUUsSUFBSSxFQUFFO0lBQ3BDLEVBQUUsSUFBSSxFQUFFLG9CQUFvQixFQUFFLEtBQUssRUFBRSxJQUFJLEVBQUU7SUFDM0MsRUFBRSxJQUFJLEVBQUUsY0FBYyxFQUFFLEtBQUssRUFBRSxJQUFJLEVBQUU7SUFDckMsRUFBRSxJQUFJLEVBQUUsTUFBTSxFQUFFLEtBQUssRUFBRSxJQUFJLEVBQUU7SUFDN0IsRUFBRSxJQUFJLEVBQUUsU0FBUyxFQUFFLEtBQUssRUFBRSxJQUFJLEVBQUU7SUFDaEMsRUFBRSxJQUFJLEVBQUUsUUFBUSxFQUFFLEtBQUssRUFBRSxJQUFJLEVBQUU7SUFDL0IsRUFBRSxJQUFJLEVBQUUsWUFBWSxFQUFFLEtBQUssRUFBRSxJQUFJLEVBQUU7SUFDbkMsRUFBRSxJQUFJLEVBQUUsT0FBTyxFQUFFLEtBQUssRUFBRSxJQUFJLEVBQUU7SUFDOUIsRUFBRSxJQUFJLEVBQUUsZ0JBQWdCLEVBQUUsS0FBSyxFQUFFLElBQUksRUFBRTtJQUN2QyxFQUFFLElBQUksRUFBRSxxQkFBcUIsRUFBRSxLQUFLLEVBQUUsSUFBSSxFQUFFO0lBQzVDLEVBQUUsSUFBSSxFQUFFLG1CQUFtQixFQUFFLEtBQUssRUFBRSxJQUFJLEVBQUU7SUFDMUMsRUFBRSxJQUFJLEVBQUUsVUFBVSxFQUFFLEtBQUssRUFBRSxJQUFJLEVBQUU7SUFDakMsRUFBRSxJQUFJLEVBQUUsU0FBUyxFQUFFLEtBQUssRUFBRSxJQUFJLEVBQUU7SUFDaEMsRUFBRSxJQUFJLEVBQUUsZ0JBQWdCLEVBQUUsS0FBSyxFQUFFLElBQUksRUFBRTtJQUN2QyxFQUFFLElBQUksRUFBRSxXQUFXLEVBQUUsS0FBSyxFQUFFLElBQUksRUFBRTtJQUNsQyxFQUFFLElBQUksRUFBRSxTQUFTLEVBQUUsS0FBSyxFQUFFLElBQUksRUFBRTtJQUNoQyxFQUFFLElBQUksRUFBRSxXQUFXLEVBQUUsS0FBSyxFQUFFLElBQUksRUFBRTtDQUMxQixDQUFDO0FBRVgsTUFBTSxVQUFVLG1CQUFtQixDQUNqQyxLQUFxRDtJQUVyRCxPQUFPLEtBQUssQ0FBQyxHQUFHLENBQUMsQ0FBQyxDQUFDLEVBQUUsRUFBRSxDQUFDLENBQUM7UUFDdkIsS0FBSyxFQUFFLEdBQUcsQ0FBQyxDQUFDLElBQUksS0FBSyxDQUFDLENBQUMsS0FBSyxHQUFHO1FBQy9CLEtBQUssRUFBRSxDQUFDLENBQUMsS0FBSztLQUNmLENBQUMsQ0FBQyxDQUFDO0FBQ04sQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB0eXBlIHsgVWlTZWxlY3RPcHRpb24gfSBmcm9tICcuLi9maWVsZHMvZHJvcGRvd24tZmllbGRzL19tb2RlbHMvc2VsZWN0LW9wdGlvbi5tb2RlbCc7XHJcblxyXG4vKiogVW5pZGFkZXMgZmVkZXJhdGl2YXMgZG8gQnJhc2lsIChub21lICsgc2lnbGEpLiBPcmRlbSBhbGZhYsOpdGljYSBwb3Igbm9tZS4gKi9cclxuZXhwb3J0IGNvbnN0IEJSX0VTVEFET1NfTk9NRV9TSUdMQTogUmVhZG9ubHlBcnJheTx7IG5vbWU6IHN0cmluZzsgc2lnbGE6IHN0cmluZyB9PiA9IFtcclxuICB7IG5vbWU6ICdBY3JlJywgc2lnbGE6ICdBQycgfSxcclxuICB7IG5vbWU6ICdBbGFnb2FzJywgc2lnbGE6ICdBTCcgfSxcclxuICB7IG5vbWU6ICdBbWFww6EnLCBzaWdsYTogJ0FQJyB9LFxyXG4gIHsgbm9tZTogJ0FtYXpvbmFzJywgc2lnbGE6ICdBTScgfSxcclxuICB7IG5vbWU6ICdCYWhpYScsIHNpZ2xhOiAnQkEnIH0sXHJcbiAgeyBub21lOiAnQ2VhcsOhJywgc2lnbGE6ICdDRScgfSxcclxuICB7IG5vbWU6ICdEaXN0cml0byBGZWRlcmFsJywgc2lnbGE6ICdERicgfSxcclxuICB7IG5vbWU6ICdFc3DDrXJpdG8gU2FudG8nLCBzaWdsYTogJ0VTJyB9LFxyXG4gIHsgbm9tZTogJ0dvacOhcycsIHNpZ2xhOiAnR08nIH0sXHJcbiAgeyBub21lOiAnTWFyYW5ow6NvJywgc2lnbGE6ICdNQScgfSxcclxuICB7IG5vbWU6ICdNYXRvIEdyb3NzbycsIHNpZ2xhOiAnTVQnIH0sXHJcbiAgeyBub21lOiAnTWF0byBHcm9zc28gZG8gU3VsJywgc2lnbGE6ICdNUycgfSxcclxuICB7IG5vbWU6ICdNaW5hcyBHZXJhaXMnLCBzaWdsYTogJ01HJyB9LFxyXG4gIHsgbm9tZTogJ1BhcsOhJywgc2lnbGE6ICdQQScgfSxcclxuICB7IG5vbWU6ICdQYXJhw61iYScsIHNpZ2xhOiAnUEInIH0sXHJcbiAgeyBub21lOiAnUGFyYW7DoScsIHNpZ2xhOiAnUFInIH0sXHJcbiAgeyBub21lOiAnUGVybmFtYnVjbycsIHNpZ2xhOiAnUEUnIH0sXHJcbiAgeyBub21lOiAnUGlhdcOtJywgc2lnbGE6ICdQSScgfSxcclxuICB7IG5vbWU6ICdSaW8gZGUgSmFuZWlybycsIHNpZ2xhOiAnUkonIH0sXHJcbiAgeyBub21lOiAnUmlvIEdyYW5kZSBkbyBOb3J0ZScsIHNpZ2xhOiAnUk4nIH0sXHJcbiAgeyBub21lOiAnUmlvIEdyYW5kZSBkbyBTdWwnLCBzaWdsYTogJ1JTJyB9LFxyXG4gIHsgbm9tZTogJ1JvbmTDtG5pYScsIHNpZ2xhOiAnUk8nIH0sXHJcbiAgeyBub21lOiAnUm9yYWltYScsIHNpZ2xhOiAnUlInIH0sXHJcbiAgeyBub21lOiAnU2FudGEgQ2F0YXJpbmEnLCBzaWdsYTogJ1NDJyB9LFxyXG4gIHsgbm9tZTogJ1PDo28gUGF1bG8nLCBzaWdsYTogJ1NQJyB9LFxyXG4gIHsgbm9tZTogJ1NlcmdpcGUnLCBzaWdsYTogJ1NFJyB9LFxyXG4gIHsgbm9tZTogJ1RvY2FudGlucycsIHNpZ2xhOiAnVE8nIH0sXHJcbl0gYXMgY29uc3Q7XHJcblxyXG5leHBvcnQgZnVuY3Rpb24gbWFwRXN0YWRvc1RvT3B0aW9ucyhcclxuICBzbGljZTogUmVhZG9ubHlBcnJheTx7IG5vbWU6IHN0cmluZzsgc2lnbGE6IHN0cmluZyB9PixcclxuKTogVWlTZWxlY3RPcHRpb248c3RyaW5nPltdIHtcclxuICByZXR1cm4gc2xpY2UubWFwKChlKSA9PiAoe1xyXG4gICAgbGFiZWw6IGAke2Uubm9tZX0gKCR7ZS5zaWdsYX0pYCxcclxuICAgIHZhbHVlOiBlLnNpZ2xhLFxyXG4gIH0pKTtcclxufVxyXG4iXX0=

package/esm2022/app/_utils/integer-br.utils.mjs

@@ -0,0 +1,48 @@
+/**
+ * Formatação pt-BR para inteiros: apenas separador de milhar com ponto.
+ * Usado pelo campo inteiro e pela parte inteira do decimal.
+ */
+/**
+ * Formata sequência de dígitos com pontos de milhar (ex.: 1234567 → 1.234.567).
+ * Aceita string vazia; não normaliza zeros à esquerda.
+ */
+export function formatIntegerThousandsBr(intDigits) {
+    if (intDigits === '') {
+        return '';
+    }
+    const reversed = intDigits.split('').reverse().join('');
+    const groups = reversed.match(/.{1,3}/g) ?? [];
+    return groups
+        .map((g) => g.split('').reverse().join(''))
+        .reverse()
+        .join('.');
+}
+/**
+ * Quantidade de dígitos à esquerda do caret na máscara (pontos ignorados).
+ */
+export function semanticIntegerDigitCountLeft(display, caret) {
+    return display.slice(0, caret).replace(/\D/g, '').length;
+}
+/**
+ * Índice do caret após o enésimo dígito na string formatada (fim se não houver tantos).
+ */
+export function caretIndexFromIntegerDigitCount(display, digitCount) {
+    if (digitCount <= 0) {
+        return 0;
+    }
+    let seen = 0;
+    for (let i = 0; i < display.length; i++) {
+        const ch = display[i];
+        if (ch === '.') {
+            continue;
+        }
+        if (/\d/.test(ch)) {
+            seen++;
+            if (seen === digitCount) {
+                return i + 1;
+            }
+        }
+    }
+    return display.length;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/app/_utils/integer-value.utils.mjs

@@ -0,0 +1,19 @@
+const DIGITS_ONLY = /^\d*$/;
+/**
+ * Mantém apenas dígitos (0–9). Primeira versão sem sinal negativo.
+ */
+export function sanitizeIntegerDigits(raw) {
+    return raw.replace(/\D/g, '');
+}
+export function parseIntegerString(digits) {
+    const t = digits.trim();
+    if (t === '') {
+        return null;
+    }
+    if (!DIGITS_ONLY.test(t)) {
+        return null;
+    }
+    const n = Number.parseInt(t, 10);
+    return Number.isFinite(n) ? n : null;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW50ZWdlci12YWx1ZS51dGlscy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3NyYy9hcHAvX3V0aWxzL2ludGVnZXItdmFsdWUudXRpbHMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsTUFBTSxXQUFXLEdBQUcsT0FBTyxDQUFDO0FBRTVCOztHQUVHO0FBQ0gsTUFBTSxVQUFVLHFCQUFxQixDQUFDLEdBQVc7SUFDL0MsT0FBTyxHQUFHLENBQUMsT0FBTyxDQUFDLEtBQUssRUFBRSxFQUFFLENBQUMsQ0FBQztBQUNoQyxDQUFDO0FBRUQsTUFBTSxVQUFVLGtCQUFrQixDQUFDLE1BQWM7SUFDL0MsTUFBTSxDQUFDLEdBQUcsTUFBTSxDQUFDLElBQUksRUFBRSxDQUFDO0lBQ3hCLElBQUksQ0FBQyxLQUFLLEVBQUUsRUFBRSxDQUFDO1FBQ2IsT0FBTyxJQUFJLENBQUM7SUFDZCxDQUFDO0lBQ0QsSUFBSSxDQUFDLFdBQVcsQ0FBQyxJQUFJLENBQUMsQ0FBQyxDQUFDLEVBQUUsQ0FBQztRQUN6QixPQUFPLElBQUksQ0FBQztJQUNkLENBQUM7SUFDRCxNQUFNLENBQUMsR0FBRyxNQUFNLENBQUMsUUFBUSxDQUFDLENBQUMsRUFBRSxFQUFFLENBQUMsQ0FBQztJQUNqQyxPQUFPLE1BQU0sQ0FBQyxRQUFRLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFDLENBQUMsSUFBSSxDQUFDO0FBQ3ZDLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJjb25zdCBESUdJVFNfT05MWSA9IC9eXFxkKiQvO1xyXG5cclxuLyoqXHJcbiAqIE1hbnTDqW0gYXBlbmFzIGTDrWdpdG9zICgw4oCTOSkuIFByaW1laXJhIHZlcnPDo28gc2VtIHNpbmFsIG5lZ2F0aXZvLlxyXG4gKi9cclxuZXhwb3J0IGZ1bmN0aW9uIHNhbml0aXplSW50ZWdlckRpZ2l0cyhyYXc6IHN0cmluZyk6IHN0cmluZyB7XHJcbiAgcmV0dXJuIHJhdy5yZXBsYWNlKC9cXEQvZywgJycpO1xyXG59XHJcblxyXG5leHBvcnQgZnVuY3Rpb24gcGFyc2VJbnRlZ2VyU3RyaW5nKGRpZ2l0czogc3RyaW5nKTogbnVtYmVyIHwgbnVsbCB7XHJcbiAgY29uc3QgdCA9IGRpZ2l0cy50cmltKCk7XHJcbiAgaWYgKHQgPT09ICcnKSB7XHJcbiAgICByZXR1cm4gbnVsbDtcclxuICB9XHJcbiAgaWYgKCFESUdJVFNfT05MWS50ZXN0KHQpKSB7XHJcbiAgICByZXR1cm4gbnVsbDtcclxuICB9XHJcbiAgY29uc3QgbiA9IE51bWJlci5wYXJzZUludCh0LCAxMCk7XHJcbiAgcmV0dXJuIE51bWJlci5pc0Zpbml0ZShuKSA/IG4gOiBudWxsO1xyXG59XHJcbiJdfQ==

package/esm2022/app/_utils/scroll/body-scroll-lock.util.mjs

@@ -0,0 +1,97 @@
+/**
+ * Bloqueio de scroll global **alinhado ao CDK** (`BlockScrollStrategy`):
+ * classe `cdk-global-scrollblock` no `documentElement` + deslocamento `left`/`top`
+ * para congelar a posição de scroll.
+ *
+ * Também define `overflow: hidden` no `body` enquanto o lock está activo — o `html`
+ * **não** usa `overflow-y: scroll` (isso forçava barra no viewport sem necessidade).
+ *
+ * Requer regras CSS em `styles.scss` para `.cdk-global-scrollblock` e
+ * `[data-app-scroll-lock]`.
+ */
+/** Aplica o mesmo padrão visual do overlay CDK Dialog (confirm, etc.). */
+export function lockPageScrollCdkStyle() {
+    const html = document.documentElement;
+    const body = document.body;
+    const scrollX = window.scrollX ?? html.scrollLeft;
+    const scrollY = window.scrollY ?? html.scrollTop;
+    const snapshot = {
+        htmlLeft: html.style.left,
+        htmlTop: html.style.top,
+        scrollX,
+        scrollY,
+        bodyOverflow: body.style.overflow,
+        bodyTouchAction: body.style.touchAction,
+    };
+    html.style.left = `${-scrollX}px`;
+    html.style.top = `${-scrollY}px`;
+    html.classList.add('cdk-global-scrollblock');
+    body.style.overflow = 'hidden';
+    body.style.touchAction = 'none';
+    return snapshot;
+}
+export function unlockPageScrollCdkStyle(s) {
+    const html = document.documentElement;
+    const body = document.body;
+    html.classList.remove('cdk-global-scrollblock');
+    html.style.left = s.htmlLeft;
+    html.style.top = s.htmlTop;
+    body.style.overflow = s.bodyOverflow;
+    body.style.touchAction = s.bodyTouchAction;
+    window.scroll(s.scrollX, s.scrollY);
+}
+let appDialogLightLockDepth = 0;
+let appDialogLightLockSnapshot = null;
+function applyAppDialogScrollLock() {
+    const html = document.documentElement;
+    const body = document.body;
+    const scrollX = window.scrollX ?? html.scrollLeft;
+    const scrollY = window.scrollY ?? html.scrollTop;
+    return {
+        scrollX,
+        scrollY,
+        htmlOverflow: html.style.overflow,
+        bodyOverflow: body.style.overflow,
+        bodyTouchAction: body.style.touchAction,
+    };
+}
+function installAppDialogScrollLockStyles(s) {
+    const html = document.documentElement;
+    const body = document.body;
+    html.classList.add('app-dialog-scroll-lock');
+    html.style.overflow = 'hidden';
+    body.style.overflow = 'hidden';
+    body.style.touchAction = 'none';
+}
+function restoreAppDialogScrollLock(s) {
+    const html = document.documentElement;
+    const body = document.body;
+    html.classList.remove('app-dialog-scroll-lock');
+    html.style.overflow = s.htmlOverflow;
+    body.style.overflow = s.bodyOverflow;
+    body.style.touchAction = s.bodyTouchAction;
+    window.scroll(s.scrollX, s.scrollY);
+}
+/**
+ * Incrementa um contador de aninhamento: o primeiro lock aplica o DOM; locks interiores
+ * (ex.: `app-dialog` + CDK Dialog) só incrementam a profundidade.
+ */
+export function lockPageScrollAppDialog() {
+    if (appDialogLightLockDepth === 0) {
+        appDialogLightLockSnapshot = applyAppDialogScrollLock();
+        installAppDialogScrollLockStyles(appDialogLightLockSnapshot);
+    }
+    appDialogLightLockDepth++;
+    return appDialogLightLockSnapshot;
+}
+/** Par com {@link lockPageScrollAppDialog}; o snapshot pode ser ignorado — usa-se a pilha interna. */
+export function unlockPageScrollAppDialog(_s) {
+    if (appDialogLightLockDepth > 0) {
+        appDialogLightLockDepth--;
+    }
+    if (appDialogLightLockDepth === 0 && appDialogLightLockSnapshot !== null) {
+        restoreAppDialogScrollLock(appDialogLightLockSnapshot);
+        appDialogLightLockSnapshot = null;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"body-scroll-lock.util.js","sourceRoot":"","sources":["../../../../../../src/app/_utils/scroll/body-scroll-lock.util.ts"],"names":[],"mappings":"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","sourcesContent":["/**\r\n * Bloqueio de scroll global **alinhado ao CDK** (`BlockScrollStrategy`):\r\n * classe `cdk-global-scrollblock` no `documentElement` + deslocamento `left`/`top`\r\n * para congelar a posição de scroll.\r\n *\r\n * Também define `overflow: hidden` no `body` enquanto o lock está activo — o `html`\r\n * **não** usa `overflow-y: scroll` (isso forçava barra no viewport sem necessidade).\r\n *\r\n * Requer regras CSS em `styles.scss` para `.cdk-global-scrollblock` e\r\n * `[data-app-scroll-lock]`.\r\n */\r\n\r\nexport interface ScrollLockSnapshot {\r\n  readonly htmlLeft: string;\r\n  readonly htmlTop: string;\r\n  readonly scrollX: number;\r\n  readonly scrollY: number;\r\n  readonly bodyOverflow: string;\r\n  readonly bodyTouchAction: string;\r\n}\r\n\r\n/** Aplica o mesmo padrão visual do overlay CDK Dialog (confirm, etc.). */\r\nexport function lockPageScrollCdkStyle(): ScrollLockSnapshot {\r\n  const html = document.documentElement;\r\n  const body = document.body;\r\n  const scrollX = window.scrollX ?? html.scrollLeft;\r\n  const scrollY = window.scrollY ?? html.scrollTop;\r\n  const snapshot: ScrollLockSnapshot = {\r\n    htmlLeft: html.style.left,\r\n    htmlTop: html.style.top,\r\n    scrollX,\r\n    scrollY,\r\n    bodyOverflow: body.style.overflow,\r\n    bodyTouchAction: body.style.touchAction,\r\n  };\r\n  html.style.left = `${-scrollX}px`;\r\n  html.style.top = `${-scrollY}px`;\r\n  html.classList.add('cdk-global-scrollblock');\r\n  body.style.overflow = 'hidden';\r\n  body.style.touchAction = 'none';\r\n  return snapshot;\r\n}\r\n\r\nexport function unlockPageScrollCdkStyle(s: ScrollLockSnapshot): void {\r\n  const html = document.documentElement;\r\n  const body = document.body;\r\n  html.classList.remove('cdk-global-scrollblock');\r\n  html.style.left = s.htmlLeft;\r\n  html.style.top = s.htmlTop;\r\n  body.style.overflow = s.bodyOverflow;\r\n  body.style.touchAction = s.bodyTouchAction;\r\n  window.scroll(s.scrollX, s.scrollY);\r\n}\r\n\r\n/**\r\n * Bloqueio de scroll para o `app-dialog` declarativo: **sem** `position: fixed` nem `left`/`top`\r\n * negativos no `documentElement` (padrão CDK em {@link lockPageScrollCdkStyle}).\r\n *\r\n * Com esse padrão, em Chromium/WebKit o `position: fixed` do scrim deixa de ficar ancorado ao\r\n * `html` deslocado — evita faixa de conteúdo visível no topo e scrim branco/cinza errado em\r\n * apps onde o `body` faz scroll (ex.: site de documentação).\r\n */\r\nexport interface AppDialogScrollLockSnapshot {\r\n  readonly scrollX: number;\r\n  readonly scrollY: number;\r\n  readonly htmlOverflow: string;\r\n  readonly bodyOverflow: string;\r\n  readonly bodyTouchAction: string;\r\n}\r\n\r\nlet appDialogLightLockDepth = 0;\r\nlet appDialogLightLockSnapshot: AppDialogScrollLockSnapshot | null = null;\r\n\r\nfunction applyAppDialogScrollLock(): AppDialogScrollLockSnapshot {\r\n  const html = document.documentElement;\r\n  const body = document.body;\r\n  const scrollX = window.scrollX ?? html.scrollLeft;\r\n  const scrollY = window.scrollY ?? html.scrollTop;\r\n  return {\r\n    scrollX,\r\n    scrollY,\r\n    htmlOverflow: html.style.overflow,\r\n    bodyOverflow: body.style.overflow,\r\n    bodyTouchAction: body.style.touchAction,\r\n  };\r\n}\r\n\r\nfunction installAppDialogScrollLockStyles(s: AppDialogScrollLockSnapshot): void {\r\n  const html = document.documentElement;\r\n  const body = document.body;\r\n  html.classList.add('app-dialog-scroll-lock');\r\n  html.style.overflow = 'hidden';\r\n  body.style.overflow = 'hidden';\r\n  body.style.touchAction = 'none';\r\n}\r\n\r\nfunction restoreAppDialogScrollLock(s: AppDialogScrollLockSnapshot): void {\r\n  const html = document.documentElement;\r\n  const body = document.body;\r\n  html.classList.remove('app-dialog-scroll-lock');\r\n  html.style.overflow = s.htmlOverflow;\r\n  body.style.overflow = s.bodyOverflow;\r\n  body.style.touchAction = s.bodyTouchAction;\r\n  window.scroll(s.scrollX, s.scrollY);\r\n}\r\n\r\n/**\r\n * Incrementa um contador de aninhamento: o primeiro lock aplica o DOM; locks interiores\r\n * (ex.: `app-dialog` + CDK Dialog) só incrementam a profundidade.\r\n */\r\nexport function lockPageScrollAppDialog(): AppDialogScrollLockSnapshot {\r\n  if (appDialogLightLockDepth === 0) {\r\n    appDialogLightLockSnapshot = applyAppDialogScrollLock();\r\n    installAppDialogScrollLockStyles(appDialogLightLockSnapshot);\r\n  }\r\n  appDialogLightLockDepth++;\r\n  return appDialogLightLockSnapshot!;\r\n}\r\n\r\n/** Par com {@link lockPageScrollAppDialog}; o snapshot pode ser ignorado — usa-se a pilha interna. */\r\nexport function unlockPageScrollAppDialog(_s: AppDialogScrollLockSnapshot): void {\r\n  if (appDialogLightLockDepth > 0) {\r\n    appDialogLightLockDepth--;\r\n  }\r\n  if (appDialogLightLockDepth === 0 && appDialogLightLockSnapshot !== null) {\r\n    restoreAppDialogScrollLock(appDialogLightLockSnapshot);\r\n    appDialogLightLockSnapshot = null;\r\n  }\r\n}\r\n"]}

package/esm2022/app/app-shell/_models/breadcrumb-item.model.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYnJlYWRjcnVtYi1pdGVtLm1vZGVsLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vc3JjL2FwcC9hcHAtc2hlbGwvX21vZGVscy9icmVhZGNydW1iLWl0ZW0ubW9kZWwudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxyXG4gKiBTZWdtZW50byBkbyBmaWxvIGRlIG5hdmVnYcOnw6NvIChgYXBwLWJyZWFkY3J1bWJgKS5cclxuICogUHJpb3JpZGFkZSBkZSBuYXZlZ2HDp8Ojbzogc2UgYHJvdXRlYCBlc3RpdmVyIGRlZmluaWRvLCB1c2Etc2UgYFJvdXRlckxpbmtgOyBzZW7Do28sIGBocmVmYCAow6JuY29yYSBuYXRpdmEpLlxyXG4gKi9cclxuZXhwb3J0IGludGVyZmFjZSBCcmVhZGNydW1iSXRlbSB7XHJcbiAgbGFiZWw6IHN0cmluZztcclxuICAvKiogUm90YSBBbmd1bGFyIChgcm91dGVyTGlua2ApIHF1YW5kbyBvIHNlZ21lbnRvIMOpIG5hdmVnw6F2ZWwgZGVudHJvIGRhIGFwcC4gKi9cclxuICByb3V0ZT86IHN0cmluZyB8IHJlYWRvbmx5IHVua25vd25bXTtcclxuICAvKipcclxuICAgKiBVUkwgcXVhbmRvIG7Do28gc2UgdXNhIG8gcm91dGVyIChleC46IGxpbmsgZXh0ZXJubykuIElnbm9yYWRvIHNlIGByb3V0ZWAgZXN0aXZlciBkZWZpbmlkby5cclxuICAgKi9cclxuICBocmVmPzogc3RyaW5nO1xyXG59XHJcbiJdfQ==

package/esm2022/app/app-shell/app-shell-sidebar-template.directive.mjs

@@ -0,0 +1,29 @@
+import { Directive, TemplateRef, inject } from '@angular/core';
+import * as i0 from "@angular/core";
+/**
+ * Marca o `ng-template` cuja instância é projectada na barra lateral (desktop) e no `app-drawer` (mobile).
+ *
+ * ```html
+ * <app-shell>
+ *   <ng-template appShellSidebar>
+ *     <app-sidebar ... />
+ *   </ng-template>
+ *   ...
+ * </app-shell>
+ * ```
+ */
+export class AppShellSidebarTemplateDirective {
+    constructor() {
+        this.templateRef = inject((TemplateRef));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: AppShellSidebarTemplateDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "17.3.12", type: AppShellSidebarTemplateDirective, isStandalone: true, selector: "ng-template[appShellSidebar]", ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: AppShellSidebarTemplateDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: 'ng-template[appShellSidebar]',
+                    standalone: true,
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXBwLXNoZWxsLXNpZGViYXItdGVtcGxhdGUuZGlyZWN0aXZlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vc3JjL2FwcC9hcHAtc2hlbGwvYXBwLXNoZWxsLXNpZGViYXItdGVtcGxhdGUuZGlyZWN0aXZlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxTQUFTLEVBQUUsV0FBVyxFQUFFLE1BQU0sRUFBRSxNQUFNLGVBQWUsQ0FBQzs7QUFFL0Q7Ozs7Ozs7Ozs7O0dBV0c7QUFLSCxNQUFNLE9BQU8sZ0NBQWdDO0lBSjdDO1FBS1csZ0JBQVcsR0FBRyxNQUFNLENBQUMsQ0FBQSxXQUFvQixDQUFBLENBQUMsQ0FBQztLQUNyRDsrR0FGWSxnQ0FBZ0M7bUdBQWhDLGdDQUFnQzs7NEZBQWhDLGdDQUFnQztrQkFKNUMsU0FBUzttQkFBQztvQkFDVCxRQUFRLEVBQUUsOEJBQThCO29CQUN4QyxVQUFVLEVBQUUsSUFBSTtpQkFDakIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBEaXJlY3RpdmUsIFRlbXBsYXRlUmVmLCBpbmplY3QgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcclxuXHJcbi8qKlxyXG4gKiBNYXJjYSBvIGBuZy10ZW1wbGF0ZWAgY3VqYSBpbnN0w6JuY2lhIMOpIHByb2plY3RhZGEgbmEgYmFycmEgbGF0ZXJhbCAoZGVza3RvcCkgZSBubyBgYXBwLWRyYXdlcmAgKG1vYmlsZSkuXHJcbiAqXHJcbiAqIGBgYGh0bWxcclxuICogPGFwcC1zaGVsbD5cclxuICogICA8bmctdGVtcGxhdGUgYXBwU2hlbGxTaWRlYmFyPlxyXG4gKiAgICAgPGFwcC1zaWRlYmFyIC4uLiAvPlxyXG4gKiAgIDwvbmctdGVtcGxhdGU+XHJcbiAqICAgLi4uXHJcbiAqIDwvYXBwLXNoZWxsPlxyXG4gKiBgYGBcclxuICovXHJcbkBEaXJlY3RpdmUoe1xyXG4gIHNlbGVjdG9yOiAnbmctdGVtcGxhdGVbYXBwU2hlbGxTaWRlYmFyXScsXHJcbiAgc3RhbmRhbG9uZTogdHJ1ZSxcclxufSlcclxuZXhwb3J0IGNsYXNzIEFwcFNoZWxsU2lkZWJhclRlbXBsYXRlRGlyZWN0aXZlIHtcclxuICByZWFkb25seSB0ZW1wbGF0ZVJlZiA9IGluamVjdChUZW1wbGF0ZVJlZjx1bmtub3duPik7XHJcbn1cclxuIl19