structra-ui 0.1.4 → 0.1.6

package/app/menus/index.d.ts

@@ -0,0 +1,11 @@
+export { DropdownMenuComponent, } from './dropdown-menu/dropdown-menu.component';
+export { ContextMenuComponent, } from './context-menu/context-menu.component';
+export { DrawerComponent } from './drawer/drawer.component';
+export { MenuListComponent } from './menu-list/menu-list.component';
+export { ActionMenuComponent } from './action-menu/action-menu.component';
+export { MenuDividerComponent } from './menu-divider/menu-divider.component';
+export { MenuGroupComponent } from './menu-group/menu-group.component';
+export type { MenuItemKind, MenuLeafItem, MenuItemAction, MenuItemDivider, MenuItemGroup, MenuItemSubmenu, MenuNodeItem, } from './_models/menu-item.model';
+export { MenuDropdownPlacement } from './_models/menu-dropdown-placement.model';
+export { DrawerSize } from './_models/drawer-size.model';
+export { DrawerSide } from './_models/drawer-side.model';

package/app/menus/menu-divider/menu-divider.component.d.ts

@@ -0,0 +1,8 @@
+import * as i0 from "@angular/core";
+/**
+ * Separador semântico reutilizável — mesma apresentação que o divisor do modelo de dados (`kind: 'divider'`).
+ */
+export declare class MenuDividerComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<MenuDividerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MenuDividerComponent, "app-menu-divider", never, {}, {}, never, never, true, never>;
+}

package/app/menus/menu-group/menu-group.component.d.ts

@@ -0,0 +1,13 @@
+import * as i0 from "@angular/core";
+/**
+ * Cabeçalho opcional de grupo — alinhado a `MenuItemGroup` (`kind: 'group'`).
+ * Os itens do grupo continuam a ser renderizados pelo `menu-list` (renderização única).
+ */
+export declare class MenuGroupComponent {
+    label?: string;
+    /** Quando `true`, não mostra o título (ex.: sidebar colapsada só com ícones). */
+    hideLabel: boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MenuGroupComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MenuGroupComponent, "app-menu-group", never, { "label": { "alias": "label"; "required": false; }; "hideLabel": { "alias": "hideLabel"; "required": false; }; }, {}, never, never, true, never>;
+    static ngAcceptInputType_hideLabel: unknown;
+}

package/app/menus/menu-list/menu-list.component.d.ts

@@ -0,0 +1,77 @@
+import { ElementRef, EventEmitter, OnChanges, SimpleChanges } from '@angular/core';
+import type { MenuItemAction, MenuNodeItem } from '../_models/menu-item.model';
+import { type MenuRow } from '../_utils/menu-rows.util';
+import * as i0 from "@angular/core";
+export declare class MenuListComponent<T = string> implements OnChanges {
+    private readonly cdr;
+    private readonly appTheme;
+    readonly hostRef: ElementRef<any>;
+    items: readonly MenuNodeItem<T>[];
+    /** Prefixo dos `id` das opções focáveis (`${menuId}-opt-${focusIndex}`). */
+    menuId: string;
+    dense: boolean;
+    /** Quando `true`, o menu está dentro de um submenu — seta ← regressa um nível. */
+    nested: boolean;
+    /**
+     * Destaca visualmente o item cuja `id` coincide (navegação actual / rota activa).
+     * Só aplica a linhas `kind: 'item'` neste nível.
+     */
+    selectedItemId: T | null;
+    /**
+     * Oculta rótulos e descrições (ex.: sidebar colapsada), mantendo ícones; define `title` nativo para hover.
+     */
+    compressText: boolean;
+    readonly itemSelect: EventEmitter<T>;
+    readonly closeRequest: EventEmitter<void>;
+    readonly submenuBack: EventEmitter<void>;
+    private nestedLists?;
+    rows: MenuRow<T>[];
+    private focusableCount;
+    /** Índice entre `0` e `focusableCount - 1`, ou `-1` = nenhum realce. */
+    activeIndex: number;
+    /** Painel de submenu aberto (um por instância de lista). */
+    openSubmenuKey: string | null;
+    private submenuOpenTimer;
+    private submenuCloseTimer;
+    readonly submenuPositions: import("@angular/cdk/overlay").ConnectedPosition[];
+    readonly panelThemeNgClass: import("@angular/core").Signal<{
+        [x: string]: boolean;
+        'app-library-theme': boolean;
+    }>;
+    overlayPanelClasses(): string[];
+    onNestedItemSelect(id: T): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    submenuRowKey(row: MenuRow<T>, index: number): string;
+    isSubmenuOpen(row: MenuRow<T>, index: number): boolean;
+    submenuMenuId(row: MenuRow<T>): string;
+    onRowMouseEnter(row: MenuRow<T>): void;
+    onSubmenuTriggerEnter(row: MenuRow<T>, index: number): void;
+    onSubmenuTriggerLeave(_row: MenuRow<T>, index: number): void;
+    onSubmenuPanelEnter(): void;
+    onSubmenuPanelLeave(row: MenuRow<T>, index: number): void;
+    private scheduleSubmenuClose;
+    private cancelSubmenuOpenTimer;
+    private cancelSubmenuCloseTimer;
+    /** Fecha o submenu deste nível (seta ← no filho ou fecho de irmão). */
+    closeOpenSubmenu(): void;
+    onSubmenuRowClick(ev: MouseEvent, row: MenuRow<T>, index: number): void;
+    onSubmenuOutsideClick(row: MenuRow<T>, index: number): void;
+    private openSubmenuForRowAt;
+    private queueFocusNestedFirst;
+    /** Primeira opção focável (abertura por teclado). */
+    focusFirstOption(): void;
+    onItemClick(ev: MouseEvent, item: MenuItemAction<T>): void;
+    optionId(focusIndex: number): string;
+    isActiveRow(row: MenuRow<T>): boolean;
+    /** Realce de selecção persistente (ex.: item de navegação activo). */
+    isRowSelected(row: MenuRow<T>): boolean;
+    resetHighlight(): void;
+    onMenuSurfaceLeave(): void;
+    private focusActiveDom;
+    onKeydown(ev: KeyboardEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MenuListComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MenuListComponent<any>, "app-menu-list", never, { "items": { "alias": "items"; "required": true; }; "menuId": { "alias": "menuId"; "required": false; }; "dense": { "alias": "dense"; "required": false; }; "nested": { "alias": "nested"; "required": false; }; "selectedItemId": { "alias": "selectedItemId"; "required": false; }; "compressText": { "alias": "compressText"; "required": false; }; }, { "itemSelect": "itemSelect"; "closeRequest": "closeRequest"; "submenuBack": "submenuBack"; }, never, never, true, never>;
+    static ngAcceptInputType_dense: unknown;
+    static ngAcceptInputType_nested: unknown;
+    static ngAcceptInputType_compressText: unknown;
+}

package/app/overlay/_models/overlay-placement.model.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Posição preferencial do painel em relação à âncora (com fallbacks via CDK `push` / ordem de posições).
+ */
+export declare enum OverlayPlacement {
+    Top = "top",
+    Bottom = "bottom",
+    Left = "left",
+    Right = "right"
+}

package/app/overlay/_utils/anchored-overlay-positions.util.d.ts

@@ -0,0 +1,9 @@
+import type { ConnectedPosition } from '@angular/cdk/overlay';
+import { OverlayPlacement } from '../_models/overlay-placement.model';
+/**
+ * Constrói posições CDK para overlay ancorado (tooltip, popover, autocomplete, etc.).
+ * Inclui alternativas para inverter quando não há espaço (`push` no componente).
+ *
+ * Menus dropdown usam {@link menuConnectedPositions} em `menus/_utils` (alinhamento `start`, gap tipicamente menor).
+ */
+export declare function anchoredOverlayPositions(placement: OverlayPlacement, offsetPx?: number): ConnectedPosition[];

package/app/overlay/anchored-overlay/anchored-overlay.component.d.ts

@@ -0,0 +1,51 @@
+import { EventEmitter, TemplateRef } from '@angular/core';
+import { type ConnectedPosition, type ScrollStrategy } from '@angular/cdk/overlay';
+import * as i0 from "@angular/core";
+/**
+ * Fundação reutilizável para painéis ancorados (tooltip, popover, autocomplete, datepicker, etc.).
+ * Usa `CdkConnectedOverlay` + tema da lib.
+ *
+ * @see `DropdownBaseComponent` — overlay para painéis de **campo** (menus/select): backdrop e fecho por omissão
+ *   alinhados a esse caso; mantido separado para não quebrar contratos públicos.
+ */
+export declare class AnchoredOverlayComponent {
+    private readonly appTheme;
+    private readonly overlay;
+    open: boolean;
+    readonly openChange: EventEmitter<boolean>;
+    panelTemplate: TemplateRef<unknown>;
+    connectedPositions: ConnectedPosition[];
+    pushConnectedOverlay: boolean;
+    hasBackdrop: boolean;
+    closeOnEscape: boolean;
+    /** Fecha ao clicar fora do painel e fora da âncora (popover, dialogs leves). */
+    closeOnOutsideClick: boolean;
+    panelWidthPx: number | null;
+    panelMinWidthPx: number | null;
+    panelMaxWidthPx: number | null;
+    /**
+     * Estratégia de scroll (predefinição: reposicionar; `close` para fechar ao scroll em certos modais).
+     */
+    scrollStrategy: ScrollStrategy | null;
+    readonly overlayPanelClasses: import("@angular/core").Signal<string[]>;
+    readonly panelThemeNgClass: import("@angular/core").Signal<{
+        [x: string]: boolean;
+        'app-library-theme': boolean;
+    }>;
+    readonly defaultScrollStrategy: import("@angular/cdk/overlay").RepositionScrollStrategy;
+    get effectiveScrollStrategy(): ScrollStrategy;
+    get overlayWidthCss(): number | string | undefined;
+    get overlayMinWidthCss(): number | string | undefined;
+    onBackdropClick(): void;
+    onOverlayOutsideClick(): void;
+    onOverlayKeydown(ev: KeyboardEvent): void;
+    onDetach(): void;
+    setOpen(next: boolean): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AnchoredOverlayComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AnchoredOverlayComponent, "app-anchored-overlay", never, { "open": { "alias": "open"; "required": false; }; "panelTemplate": { "alias": "panelTemplate"; "required": true; }; "connectedPositions": { "alias": "connectedPositions"; "required": false; }; "pushConnectedOverlay": { "alias": "pushConnectedOverlay"; "required": false; }; "hasBackdrop": { "alias": "hasBackdrop"; "required": false; }; "closeOnEscape": { "alias": "closeOnEscape"; "required": false; }; "closeOnOutsideClick": { "alias": "closeOnOutsideClick"; "required": false; }; "panelWidthPx": { "alias": "panelWidthPx"; "required": false; }; "panelMinWidthPx": { "alias": "panelMinWidthPx"; "required": false; }; "panelMaxWidthPx": { "alias": "panelMaxWidthPx"; "required": false; }; "scrollStrategy": { "alias": "scrollStrategy"; "required": false; }; }, { "openChange": "openChange"; }, never, ["*"], true, never>;
+    static ngAcceptInputType_open: unknown;
+    static ngAcceptInputType_pushConnectedOverlay: unknown;
+    static ngAcceptInputType_hasBackdrop: unknown;
+    static ngAcceptInputType_closeOnEscape: unknown;
+    static ngAcceptInputType_closeOnOutsideClick: unknown;
+}

package/app/overlay/index.d.ts

@@ -0,0 +1,20 @@
+/**
+ * **Overlay (camada de UI flutuante)**
+ *
+ * - **`AnchoredOverlayComponent`**: primitives CDK (`CdkConnectedOverlay`) + tema (`AppThemeService`).
+ *   Usado por **tooltip** e **popover** (comportamento genérico: `open`/`openChange`, Escape, clique fora opcional).
+ * - **Menus** (`app-dropdown-menu`, campos): usam **`DropdownBaseComponent`** em `fields/dropdown-fields` — contrato
+ *   estável (backdrop, fecho, largura de painel alinhada ao campo); não foi fundido com `AnchoredOverlay` para
+ *   não alterar comportamento dos formulários.
+ * - **Enums**: `OverlayPlacement` (tooltip/popover, centro do trigger) vs `MenuDropdownPlacement` (menus alinhados
+ *   ao início do trigger, gap menor — ver `menu-connected-positions.util`).
+ */
+export { AnchoredOverlayComponent } from './anchored-overlay/anchored-overlay.component';
+export { TooltipComponent } from './tooltip/tooltip.component';
+export { TooltipPanelTemplateDirective } from './tooltip/tooltip-panel-template.directive';
+export { PopoverComponent } from './popover/popover.component';
+export { PopoverTriggerDirective } from './popover/popover-trigger.directive';
+export { PopoverBodyTemplateDirective } from './popover/popover-body-template.directive';
+export { PopoverFooterTemplateDirective } from './popover/popover-footer-template.directive';
+export { OverlayPlacement } from './_models/overlay-placement.model';
+export { anchoredOverlayPositions } from './_utils/anchored-overlay-positions.util';

package/app/overlay/popover/popover-body-template.directive.d.ts

@@ -0,0 +1,7 @@
+import { TemplateRef } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class PopoverBodyTemplateDirective {
+    readonly templateRef: TemplateRef<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PopoverBodyTemplateDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<PopoverBodyTemplateDirective, "ng-template[appPopoverBody]", never, {}, {}, never, never, true, never>;
+}

package/app/overlay/popover/popover-footer-template.directive.d.ts

@@ -0,0 +1,7 @@
+import { TemplateRef } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class PopoverFooterTemplateDirective {
+    readonly templateRef: TemplateRef<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PopoverFooterTemplateDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<PopoverFooterTemplateDirective, "ng-template[appPopoverFooter]", never, {}, {}, never, never, true, never>;
+}

package/app/overlay/popover/popover-trigger.directive.d.ts

@@ -0,0 +1,6 @@
+import * as i0 from "@angular/core";
+/** Marca o elemento que abre/fecha o popover ao clicar. */
+export declare class PopoverTriggerDirective {
+    static ɵfac: i0.ɵɵFactoryDeclaration<PopoverTriggerDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<PopoverTriggerDirective, "[appPopoverTrigger]", never, {}, {}, never, never, true, never>;
+}

package/app/overlay/popover/popover.component.d.ts

@@ -0,0 +1,38 @@
+import { EventEmitter, TemplateRef } from '@angular/core';
+import { OverlayPlacement } from '../_models/overlay-placement.model';
+import { PopoverBodyTemplateDirective } from './popover-body-template.directive';
+import { PopoverFooterTemplateDirective } from './popover-footer-template.directive';
+import * as i0 from "@angular/core";
+/**
+ * Painel flutuante ancorado (ações contextuais, ajuda rica, mini-formulários).
+ * Conteúdo: `ng-template appPopoverBody` obrigatório; `appPopoverFooter` opcional; trigger com `appPopoverTrigger`.
+ */
+export declare class PopoverComponent {
+    private readonly cdr;
+    title: string;
+    /** Modo controlado: `open` + `openChange`. */
+    open: boolean;
+    readonly openChange: EventEmitter<boolean>;
+    placement: OverlayPlacement;
+    offsetPx: number;
+    minWidthPx: number;
+    maxWidthPx: number;
+    /** Rótulo acessível quando não há título visível. */
+    ariaLabel: string;
+    readonly bodyDirective?: PopoverBodyTemplateDirective;
+    readonly footerDirective?: PopoverFooterTemplateDirective;
+    panelTpl: TemplateRef<unknown>;
+    readonly popoverId: string;
+    get bodyTpl(): TemplateRef<unknown> | null;
+    get footerTpl(): TemplateRef<unknown> | null;
+    get positions(): import("@angular/cdk/overlay").ConnectedPosition[];
+    get titleId(): string;
+    get effectiveAriaLabel(): string | null;
+    onTriggerClick(ev: Event): void;
+    toggle(): void;
+    /** Sincroniza com `app-anchored-overlay` e notifica o pai (`[(open)]`). */
+    setOpen(next: boolean): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PopoverComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PopoverComponent, "app-popover", never, { "title": { "alias": "title"; "required": false; }; "open": { "alias": "open"; "required": false; }; "placement": { "alias": "placement"; "required": false; }; "offsetPx": { "alias": "offsetPx"; "required": false; }; "minWidthPx": { "alias": "minWidthPx"; "required": false; }; "maxWidthPx": { "alias": "maxWidthPx"; "required": false; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; }; }, { "openChange": "openChange"; }, ["bodyDirective", "footerDirective"], ["[appPopoverTrigger]"], true, never>;
+    static ngAcceptInputType_open: unknown;
+}

package/app/overlay/tooltip/tooltip-panel-template.directive.d.ts

@@ -0,0 +1,10 @@
+import { TemplateRef } from '@angular/core';
+import * as i0 from "@angular/core";
+/**
+ * Marca um `ng-template` como conteúdo do painel do tooltip (em alternativa a `text`).
+ */
+export declare class TooltipPanelTemplateDirective {
+    readonly templateRef: TemplateRef<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TooltipPanelTemplateDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TooltipPanelTemplateDirective, "ng-template[appTooltipPanel]", never, {}, {}, never, never, true, never>;
+}

package/app/overlay/tooltip/tooltip.component.d.ts

@@ -0,0 +1,40 @@
+import { TemplateRef } from '@angular/core';
+import { OverlayPlacement } from '../_models/overlay-placement.model';
+import * as i0 from "@angular/core";
+/**
+ * Tooltip ancorado ao conteúdo projectado (trigger).
+ * — Texto: `text` ou `ng-template` com `appTooltipPanel`.
+ */
+export declare class TooltipComponent {
+    private readonly cdr;
+    text: string;
+    placement: OverlayPlacement;
+    offsetPx: number;
+    showDelayMs: number;
+    hideDelayMs: number;
+    disabled: boolean;
+    private readonly panelDirective?;
+    panelTpl: TemplateRef<unknown>;
+    readonly placementEnum: typeof OverlayPlacement;
+    readonly tooltipId: string;
+    open: boolean;
+    private showTimer;
+    private hideTimer;
+    get panelContentTpl(): TemplateRef<unknown> | null;
+    get positions(): import("@angular/cdk/overlay").ConnectedPosition[];
+    get describedByWhenOpen(): string | null;
+    onTriggerMouseEnter(): void;
+    onTriggerMouseLeave(): void;
+    onTriggerFocusIn(): void;
+    onTriggerFocusOut(): void;
+    onPanelMouseEnter(): void;
+    onPanelMouseLeave(): void;
+    private scheduleShow;
+    private scheduleHide;
+    private cancelShow;
+    private cancelHide;
+    onAnchoredOpenChange(next: boolean): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TooltipComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TooltipComponent, "app-tooltip", never, { "text": { "alias": "text"; "required": false; }; "placement": { "alias": "placement"; "required": false; }; "offsetPx": { "alias": "offsetPx"; "required": false; }; "showDelayMs": { "alias": "showDelayMs"; "required": false; }; "hideDelayMs": { "alias": "hideDelayMs"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, {}, ["panelDirective"], ["*"], true, never>;
+    static ngAcceptInputType_disabled: unknown;
+}

package/app/theme/app-theme.service.d.ts

@@ -0,0 +1,25 @@
+import * as i0 from "@angular/core";
+export declare const APP_THEME_IDS: readonly ["blue", "green", "purple", "orange", "white", "gray", "sepia", "black"];
+export type AppThemeId = (typeof APP_THEME_IDS)[number];
+/** Opção de tema para UI (selector, documentação). */
+export interface AppThemeOption {
+    readonly id: AppThemeId;
+    readonly label: string;
+}
+/**
+ * Estado global do tema da library: classe CSS `theme-*` em conjunto com `.app-library-theme`.
+ * Os tokens `--app-color-*` são definidos em `src/app/_theme/`; paletas em `_theme-palettes.scss`.
+ */
+export declare class AppThemeService {
+    private readonly activeId;
+    /** Identificador do tema activo (`blue`, `green`, …). */
+    readonly activeThemeId: import("@angular/core").Signal<"blue" | "green" | "purple" | "orange" | "white" | "gray" | "sepia" | "black">;
+    /** Classe CSS do tema (ex.: `theme-green`) para `[ngClass]` no host tematizado. */
+    readonly themeClass: import("@angular/core").Signal<string>;
+    /** Lista fixa de temas suportados pela library. */
+    readonly themeOptions: readonly AppThemeOption[];
+    setTheme(id: AppThemeId): void;
+    isActive(id: AppThemeId): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AppThemeService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AppThemeService>;
+}

package/app/theme/index.d.ts

@@ -0,0 +1 @@
+export { APP_THEME_IDS, AppThemeService, type AppThemeId, type AppThemeOption, } from './app-theme.service';

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":"AAAA;;GAEG;AAEH,OAAO,EAAE,wBAAwB,EAAE,MAAM,oBAAoB,CAAC;AAE9D,OAAO,EAAE,wBAAwB,EAAE,MAAM,oBAAoB,CAAC;AAE9D,MAAM,UAAU,sBAAsB,CAAC,GAAW;IAChD,OAAO,GAAG,CAAC,OAAO,CAAC,UAAU,EAAE,EAAE,CAAC,CAAC;AACrC,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,qBAAqB,CAAC,UAAkB;IAKtD,MAAM,MAAM,GAAG,UAAU,CAAC,OAAO,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC;IAC7C,MAAM,SAAS,GAAG,MAAM,CAAC,WAAW,CAAC,GAAG,CAAC,CAAC;IAC1C,IAAI,SAAS,KAAK,CAAC,CAAC,EAAE,CAAC;QACrB,OAAO;YACL,SAAS,EAAE,MAAM,CAAC,OAAO,CAAC,KAAK,EAAE,EAAE,CAAC;YACpC,UAAU,EAAE,EAAE;YACd,QAAQ,EAAE,KAAK;SAChB,CAAC;IACJ,CAAC;IACD,MAAM,SAAS,GAAG,MAAM,CAAC,KAAK,CAAC,CAAC,EAAE,SAAS,CAAC,CAAC,OAAO,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC;IAChE,MAAM,UAAU,GAAG,MAAM;SACtB,KAAK,CAAC,SAAS,GAAG,CAAC,CAAC;SACpB,OAAO,CAAC,KAAK,EAAE,EAAE,CAAC;SAClB,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;IACf,OAAO,EAAE,SAAS,EAAE,UAAU,EAAE,QAAQ,EAAE,IAAI,EAAE,CAAC;AACnD,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,qBAAqB,CAAC,KAIrC;IACC,MAAM,EAAE,SAAS,EAAE,UAAU,EAAE,QAAQ,EAAE,GAAG,KAAK,CAAC;IAClD,IAAI,CAAC,QAAQ,EAAE,CAAC;QACd,OAAO,wBAAwB,CAAC,SAAS,CAAC,CAAC;IAC7C,CAAC;IACD,MAAM,UAAU,GACd,SAAS,KAAK,EAAE,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,wBAAwB,CAAC,SAAS,CAAC,CAAC;IAC/D,OAAO,GAAG,UAAU,IAAI,UAAU,EAAE,CAAC;AACvC,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,eAAe,CAC7B,KAAa,EACb,KAAa;IAEb,MAAM,IAAI,GAAG,KAAK,CAAC,KAAK,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC;IACnC,MAAM,MAAM,GAAG,IAAI,CAAC,OAAO,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC;IACvC,MAAM,QAAQ,GAAG,MAAM,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC;IACrC,IAAI,QAAQ,KAAK,CAAC,CAAC,EAAE,CAAC;QACpB,OAAO;YACL,QAAQ,EAAE,MAAM,CAAC,OAAO,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC,MAAM;YAC1C,UAAU,EAAE,KAAK;YACjB,SAAS,EAAE,CAAC;SACb,CAAC;IACJ,CAAC;IACD,MAAM,MAAM,GAAG,MAAM,CAAC,KAAK,CAAC,CAAC,EAAE,QAAQ,CAAC,CAAC,OAAO,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC;IAC5D,MAAM,KAAK,GAAG,MAAM,CAAC,KAAK,CAAC,QAAQ,GAAG,CAAC,CAAC,CAAC,OAAO,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC;IAC5D,OAAO;QACL,QAAQ,EAAE,MAAM,CAAC,MAAM;QACvB,UAAU,EAAE,IAAI;QAChB,SAAS,EAAE,KAAK,CAAC,MAAM;KACxB,CAAC;AACJ,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,sBAAsB,CACpC,OAAe,EACf,MAAoE;IAEpE,IAAI,QAAQ,GAAG,CAAC,CAAC;IACjB,IAAI,UAAU,GAAG,KAAK,CAAC;IACvB,IAAI,SAAS,GAAG,CAAC,CAAC;IAElB,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;QACxC,MAAM,EAAE,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC;QACtB,IAAI,EAAE,KAAK,GAAG,EAAE,CAAC;YACf,IAAI,CAAC,UAAU,EAAE,CAAC;gBAChB,UAAU,GAAG,IAAI,CAAC;gBAClB,IACE,MAAM,CAAC,UAAU;oBACjB,MAAM,CAAC,SAAS,KAAK,CAAC;oBACtB,MAAM,CAAC,QAAQ,KAAK,QAAQ,EAC5B,CAAC;oBACD,OAAO,CAAC,GAAG,CAAC,CAAC;gBACf,CAAC;YACH,CAAC;YACD,SAAS;QACX,CAAC;QACD,IAAI,EAAE,KAAK,GAAG,EAAE,CAAC;YACf,SAAS;QACX,CAAC;QACD,IAAI,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC,EAAE,CAAC;YAClB,IAAI,CAAC,UAAU,EAAE,CAAC;gBAChB,QAAQ,EAAE,CAAC;gBACX,IAAI,CAAC,MAAM,CAAC,UAAU,IAAI,QAAQ,KAAK,MAAM,CAAC,QAAQ,EAAE,CAAC;oBACvD,OAAO,CAAC,GAAG,CAAC,CAAC;gBACf,CAAC;YACH,CAAC;iBAAM,CAAC;gBACN,SAAS,EAAE,CAAC;gBACZ,IACE,MAAM,CAAC,UAAU;oBACjB,SAAS,KAAK,MAAM,CAAC,SAAS;oBAC9B,QAAQ,KAAK,MAAM,CAAC,QAAQ,EAC5B,CAAC;oBACD,OAAO,CAAC,GAAG,CAAC,CAAC;gBACf,CAAC;YACH,CAAC;QACH,CAAC;IACH,CAAC;IACD,OAAO,OAAO,CAAC,MAAM,CAAC;AACxB,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,yBAAyB,CAAC,KAIzC;IACC,IAAI,CAAC,KAAK,CAAC,QAAQ,EAAE,CAAC;QACpB,OAAO,KAAK,CAAC,SAAS,CAAC;IACzB,CAAC;IACD,OAAO,GAAG,KAAK,CAAC,SAAS,IAAI,KAAK,CAAC,UAAU,EAAE,CAAC;AAClD,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,cAAc,CAAC,SAAiB;IAC9C,MAAM,CAAC,GAAG,SAAS,CAAC,IAAI,EAAE,CAAC;IAC3B,IAAI,CAAC,KAAK,EAAE,EAAE,CAAC;QACb,OAAO,IAAI,CAAC;IACd,CAAC;IAED,MAAM,SAAS,GAAG,CAAC,CAAC,WAAW,CAAC,GAAG,CAAC,CAAC;IACrC,IAAI,MAAc,CAAC;IACnB,IAAI,OAAe,CAAC;IAEpB,IAAI,SAAS,IAAI,CAAC,EAAE,CAAC;QACnB,MAAM,GAAG,CAAC,CAAC,KAAK,CAAC,CAAC,EAAE,SAAS,CAAC,CAAC,OAAO,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC;QAClD,OAAO,GAAG,CAAC,CAAC,KAAK,CAAC,SAAS,GAAG,CAAC,CAAC,CAAC,OAAO,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC;IACtD,CAAC;SAAM,CAAC;QACN,MAAM,GAAG,CAAC,CAAC,OAAO,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC;QAC9B,OAAO,GAAG,EAAE,CAAC;IACf,CAAC;IAED,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,OAAO,CAAC,EAAE,CAAC;QACpD,OAAO,IAAI,CAAC;IACd,CAAC;IACD,IAAI,MAAM,KAAK,EAAE,IAAI,OAAO,KAAK,EAAE,EAAE,CAAC;QACpC,OAAO,IAAI,CAAC;IACd,CAAC;IAED,MAAM,OAAO,GAAG,MAAM,KAAK,EAAE,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,MAAM,CAAC;IAC7C,MAAM,UAAU,GAAG,CAAC,OAAO,GAAG,IAAI,CAAC,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;IAChD,MAAM,CAAC,GAAG,MAAM,CAAC,GAAG,OAAO,IAAI,UAAU,EAAE,CAAC,CAAC;IAC7C,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC,CAAC,EAAE,CAAC;QACxB,OAAO,IAAI,CAAC;IACd,CAAC;IACD,OAAO,IAAI,CAAC,KAAK,CAAC,CAAC,GAAG,GAAG,CAAC,GAAG,GAAG,CAAC;AACnC,CAAC;AAED,MAAM,UAAU,eAAe,CAAC,KAAa;IAC3C,OAAO,IAAI,IAAI,CAAC,YAAY,CAAC,OAAO,EAAE;QACpC,qBAAqB,EAAE,CAAC;QACxB,qBAAqB,EAAE,CAAC;KACzB,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;AACnB,CAAC","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"]}