@lerianstudio/sindarian-ui 1.2.0-beta.13 → 1.2.0-beta.14

package/dist/esm/components/ui/toast/index.d.ts

@@ -0,0 +1,18 @@
+import * as React from 'react';
+/**
+ * Backward-compatible type exports.
+ *
+ * The Radix Toast primitives (ToastProvider, ToastViewport, Toast, etc.) are
+ * no longer used -- Sonner manages rendering internally. These types are kept
+ * so that any downstream code referencing ToastProps or ToastActionElement
+ * continues to compile.
+ */
+export type ToastActionElement = React.ReactElement;
+export type ToastProps = {
+    variant?: 'default' | 'success' | 'warning' | 'destructive';
+    className?: string;
+    open?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    duration?: number;
+};
+//# sourceMappingURL=index.d.ts.map

package/dist/esm/components/ui/toast/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/components/ui/toast/index.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAE9B;;;;;;;GAOG;AAEH,MAAM,MAAM,kBAAkB,GAAG,KAAK,CAAC,YAAY,CAAA;AAEnD,MAAM,MAAM,UAAU,GAAG;IACvB,OAAO,CAAC,EAAE,SAAS,GAAG,SAAS,GAAG,SAAS,GAAG,aAAa,CAAA;IAC3D,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,IAAI,CAAC,EAAE,OAAO,CAAA;IACd,YAAY,CAAC,EAAE,CAAC,IAAI,EAAE,OAAO,KAAK,IAAI,CAAA;IACtC,QAAQ,CAAC,EAAE,MAAM,CAAA;CAClB,CAAA"}

package/dist/esm/components/ui/toast/index.js

@@ -0,0 +1,2 @@
+'use client';
+export {};

package/dist/esm/components/ui/toast/toaster.d.ts

@@ -0,0 +1,6 @@
+type ToasterProps = {
+    theme?: 'light' | 'dark' | 'system';
+};
+export declare function Toaster({ theme }: ToasterProps): import("react").JSX.Element;
+export {};
+//# sourceMappingURL=toaster.d.ts.map

package/dist/esm/components/ui/toast/toaster.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"toaster.d.ts","sourceRoot":"","sources":["../../../../../src/components/ui/toast/toaster.tsx"],"names":[],"mappings":"AAIA,KAAK,YAAY,GAAG;IAClB,KAAK,CAAC,EAAE,OAAO,GAAG,MAAM,GAAG,QAAQ,CAAA;CACpC,CAAA;AAED,wBAAgB,OAAO,CAAC,EAAE,KAAgB,EAAE,EAAE,YAAY,+BAiBzD"}

package/dist/esm/components/ui/toast/toaster.js

@@ -0,0 +1,8 @@
+'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Toaster as SonnerToaster } from 'sonner';
+export function Toaster({ theme = 'system' }) {
+    return (_jsx(SonnerToaster, { theme: theme, position: "bottom-right", visibleToasts: 3, duration: 10000, expand: false, closeButton: true, richColors: false, offset: 16, gap: 8, toastOptions: {
+            className: 'font-sans !text-sm !font-medium'
+        } }));
+}

package/dist/esm/components/ui/toggle-group/index.d.ts

@@ -0,0 +1,18 @@
+import * as React from 'react';
+import * as ToggleGroupPrimitive from '@radix-ui/react-toggle-group';
+import { type VariantProps } from 'class-variance-authority';
+/**
+ * Item styling for the group. Kept local: sindarian-ui has no standalone
+ * `Toggle` primitive and the retirement census does not ask for one, so the
+ * variants live with their only consumer instead of leaking a new export.
+ */
+declare const toggleVariants: (props?: ({
+    variant?: "default" | "outline" | null | undefined;
+    size?: "default" | "sm" | "lg" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+declare function ToggleGroup({ className, variant, size, spacing, children, style, ...props }: React.ComponentProps<typeof ToggleGroupPrimitive.Root> & VariantProps<typeof toggleVariants> & {
+    spacing?: number;
+}): React.JSX.Element;
+declare function ToggleGroupItem({ className, children, variant, size, ...props }: React.ComponentProps<typeof ToggleGroupPrimitive.Item> & VariantProps<typeof toggleVariants>): React.JSX.Element;
+export { ToggleGroup, ToggleGroupItem };
+//# sourceMappingURL=index.d.ts.map

package/dist/esm/components/ui/toggle-group/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/components/ui/toggle-group/index.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAC9B,OAAO,KAAK,oBAAoB,MAAM,8BAA8B,CAAA;AACpE,OAAO,EAAO,KAAK,YAAY,EAAE,MAAM,0BAA0B,CAAA;AAIjE;;;;GAIG;AACH,QAAA,MAAM,cAAc;;;8EAoBnB,CAAA;AAYD,iBAAS,WAAW,CAAC,EACnB,SAAS,EACT,OAAO,EACP,IAAI,EACJ,OAAW,EACX,QAAQ,EACR,KAAK,EACL,GAAG,KAAK,EACT,EAAE,KAAK,CAAC,cAAc,CAAC,OAAO,oBAAoB,CAAC,IAAI,CAAC,GACvD,YAAY,CAAC,OAAO,cAAc,CAAC,GAAG;IACpC,OAAO,CAAC,EAAE,MAAM,CAAA;CACjB,qBAwBF;AAED,iBAAS,eAAe,CAAC,EACvB,SAAS,EACT,QAAQ,EACR,OAAO,EACP,IAAI,EACJ,GAAG,KAAK,EACT,EAAE,KAAK,CAAC,cAAc,CAAC,OAAO,oBAAoB,CAAC,IAAI,CAAC,GACvD,YAAY,CAAC,OAAO,cAAc,CAAC,qBAuBpC;AAED,OAAO,EAAE,WAAW,EAAE,eAAe,EAAE,CAAA"}

package/dist/esm/components/ui/toggle-group/index.js

@@ -0,0 +1,51 @@
+'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
+import * as React from 'react';
+import * as ToggleGroupPrimitive from '@radix-ui/react-toggle-group';
+import { cva } from 'class-variance-authority';
+import { cn } from '../../../lib/utils.js';
+/**
+ * Item styling for the group. Kept local: sindarian-ui has no standalone
+ * `Toggle` primitive and the retirement census does not ask for one, so the
+ * variants live with their only consumer instead of leaking a new export.
+ */
+const toggleVariants = cva("hover:bg-muted hover:text-muted-foreground focus-visible:border-ring focus-visible:ring-ring/50 aria-invalid:border-destructive aria-invalid:ring-destructive/20 data-[state=on]:bg-accent data-[state=on]:text-accent-foreground dark:aria-invalid:ring-destructive/40 inline-flex items-center justify-center gap-2 rounded-md text-sm font-medium whitespace-nowrap transition-[color,box-shadow] outline-none focus-visible:ring-[3px] disabled:pointer-events-none disabled:opacity-50 [&_svg]:pointer-events-none [&_svg]:shrink-0 [&_svg:not([class*='size-'])]:size-4", {
+    variants: {
+        variant: {
+            default: 'bg-transparent',
+            outline: 'border-input hover:bg-accent hover:text-accent-foreground border bg-transparent shadow-xs'
+        },
+        size: {
+            default: 'h-9 min-w-9 px-2',
+            sm: 'h-8 min-w-8 px-1.5',
+            lg: 'h-10 min-w-10 px-2.5'
+        }
+    },
+    defaultVariants: {
+        variant: 'default',
+        size: 'default'
+    }
+});
+const ToggleGroupContext = React.createContext({
+    size: 'default',
+    variant: 'default',
+    spacing: 0
+});
+function ToggleGroup({ className, variant, size, spacing = 0, children, style, ...props }) {
+    return (_jsx(ToggleGroupPrimitive.Root, { "data-slot": "toggle-group", "data-variant": variant, "data-size": size, "data-spacing": spacing, 
+        // Caller style first: `--gap` is ours and must survive, but everything
+        // else the caller passes has to reach the element.
+        style: { ...style, '--gap': spacing }, className: cn(
+        // Legacy carried a `data-[spacing=default]:...:shadow-xs` rule here that
+        // never matched — `data-spacing` is always a number. Removed rather than
+        // activated, so the rendered pixels stay identical to sindarian-x.
+        'group/toggle-group flex w-fit items-center gap-[--spacing(var(--gap))] rounded-md', className), ...props, children: _jsx(ToggleGroupContext.Provider, { value: { variant, size, spacing }, children: children }) }));
+}
+function ToggleGroupItem({ className, children, variant, size, ...props }) {
+    const context = React.useContext(ToggleGroupContext);
+    return (_jsx(ToggleGroupPrimitive.Item, { "data-slot": "toggle-group-item", "data-variant": context.variant || variant, "data-size": context.size || size, "data-spacing": context.spacing, className: cn(toggleVariants({
+            variant: context.variant || variant,
+            size: context.size || size
+        }), 'w-auto min-w-0 shrink-0 px-3 focus:z-10 focus-visible:z-10', 'data-[spacing=0]:rounded-none data-[spacing=0]:shadow-none data-[spacing=0]:first:rounded-l-md data-[spacing=0]:last:rounded-r-md data-[spacing=0]:data-[variant=outline]:border-l-0 data-[spacing=0]:data-[variant=outline]:first:border-l', className), ...props, children: children }));
+}
+export { ToggleGroup, ToggleGroupItem };

package/dist/esm/components/ui/tooltip/index.d.ts

@@ -0,0 +1,11 @@
+import * as React from 'react';
+import * as TooltipPrimitive from '@radix-ui/react-tooltip';
+declare function TooltipProvider({ delayDuration, ...props }: React.ComponentProps<typeof TooltipPrimitive.Provider>): React.JSX.Element;
+export type TooltipProps = React.ComponentProps<typeof TooltipPrimitive.Root> & {
+    disabled?: boolean;
+};
+declare function Tooltip({ open: _open, onOpenChange, disabled, ...props }: TooltipProps): React.JSX.Element;
+declare function TooltipTrigger({ ...props }: React.ComponentProps<typeof TooltipPrimitive.Trigger>): React.JSX.Element;
+declare function TooltipContent({ className, sideOffset, children, ...props }: React.ComponentProps<typeof TooltipPrimitive.Content>): React.JSX.Element;
+export { Tooltip, TooltipTrigger, TooltipContent, TooltipProvider };
+//# sourceMappingURL=index.d.ts.map

package/dist/esm/components/ui/tooltip/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/components/ui/tooltip/index.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAC9B,OAAO,KAAK,gBAAgB,MAAM,yBAAyB,CAAA;AAI3D,iBAAS,eAAe,CAAC,EACvB,aAAiB,EACjB,GAAG,KAAK,EACT,EAAE,KAAK,CAAC,cAAc,CAAC,OAAO,gBAAgB,CAAC,QAAQ,CAAC,qBAQxD;AAED,MAAM,MAAM,YAAY,GAAG,KAAK,CAAC,cAAc,CAC7C,OAAO,gBAAgB,CAAC,IAAI,CAC7B,GAAG;IACF,QAAQ,CAAC,EAAE,OAAO,CAAA;CACnB,CAAA;AAED,iBAAS,OAAO,CAAC,EACf,IAAI,EAAE,KAAK,EACX,YAAY,EACZ,QAAQ,EACR,GAAG,KAAK,EACT,EAAE,YAAY,qBAwBd;AAED,iBAAS,cAAc,CAAC,EACtB,GAAG,KAAK,EACT,EAAE,KAAK,CAAC,cAAc,CAAC,OAAO,gBAAgB,CAAC,OAAO,CAAC,qBAEvD;AAED,iBAAS,cAAc,CAAC,EACtB,SAAS,EACT,UAAc,EACd,QAAQ,EACR,GAAG,KAAK,EACT,EAAE,KAAK,CAAC,cAAc,CAAC,OAAO,gBAAgB,CAAC,OAAO,CAAC,qBAiBvD;AAED,OAAO,EAAE,OAAO,EAAE,cAAc,EAAE,cAAc,EAAE,eAAe,EAAE,CAAA"}

package/dist/esm/components/ui/tooltip/index.js

@@ -0,0 +1,28 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import * as React from 'react';
+import * as TooltipPrimitive from '@radix-ui/react-tooltip';
+import { cn } from '../../../lib/utils.js';
+function TooltipProvider({ delayDuration = 0, ...props }) {
+    return (_jsx(TooltipPrimitive.Provider, { "data-slot": "tooltip-provider", delayDuration: delayDuration, ...props }));
+}
+function Tooltip({ open: _open, onOpenChange, disabled, ...props }) {
+    const [open, setOpen] = React.useState(_open ?? false);
+    const handleOpenChange = (open) => {
+        if (disabled) {
+            onOpenChange?.(false);
+            setOpen(false);
+            return;
+        }
+        setOpen(open);
+        onOpenChange?.(open);
+    };
+    return (_jsx(TooltipProvider, { children: _jsx(TooltipPrimitive.Root, { "data-slot": "tooltip", open: open, onOpenChange: handleOpenChange, ...props }) }));
+}
+function TooltipTrigger({ ...props }) {
+    return _jsx(TooltipPrimitive.Trigger, { "data-slot": "tooltip-trigger", ...props });
+}
+function TooltipContent({ className, sideOffset = 0, children, ...props }) {
+    return (_jsx(TooltipPrimitive.Portal, { children: _jsxs(TooltipPrimitive.Content, { "data-slot": "tooltip-content", sideOffset: sideOffset, className: cn('bg-shadcn-600 text-shadcn-400 animate-in fade-in-0 zoom-in-95 data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=closed]:zoom-out-95 data-[side=bottom]:slide-in-from-top-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2 z-50 rounded-md px-3 py-1.5 text-sm shadow-md', className), ...props, children: [children, _jsx(TooltipPrimitive.Arrow, { className: "bg-shadcn-600 fill-shadcn-600 z-50 size-2.5 translate-y-[calc(-50%_-_2px)] rotate-45 rounded-[2px]" })] }) }));
+}
+export { Tooltip, TooltipTrigger, TooltipContent, TooltipProvider };

package/dist/esm/domain/blotter/index.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Blotter + BlotterRow — the mono key/value readout of the console.
+ *
+ * Clean key/value rows separated by hairline borders (`divide-y divide-border`)
+ * — no zebra fills. Each row: an uppercase 11px sans label on the left, a mono
+ * `tabular-nums` value on the right, `hover:bg-body-surface` as the quiet row
+ * affordance (the recessed page surface, one step behind `bg-card`, in both
+ * themes). Escalate the value color (`text-credit`, `text-system-alert`) only
+ * when a metric crosses a threshold.
+ *
+ *   <Blotter>
+ *     <BlotterRow label="Resolved on time" value="128" />
+ *     <BlotterRow label="Pending overdue" value="3" valueClassName="text-credit" />
+ *   </Blotter>
+ *
+ * Renders a `<dl>`; rows are `<div>`s with `<dt>`/`<dd>`.
+ */
+import type { ReactNode } from 'react';
+export type BlotterProps = {
+    children: ReactNode;
+    className?: string;
+};
+export declare function Blotter({ children, className }: BlotterProps): import("react").JSX.Element;
+export type BlotterRowProps = {
+    label: ReactNode;
+    value: ReactNode;
+    /** Threshold-escalation class on the value (e.g. `text-credit`). */
+    valueClassName?: string;
+    className?: string;
+    /**
+     * Stack the label above a full-width value instead of the inline
+     * label-left / value-right layout. Use for long-form prose (reasons,
+     * descriptions, notes) where a justified single line would squish the text.
+     * The value renders as wrapping sans body copy, not the mono tabular figure
+     * used by inline rows.
+     */
+    stacked?: boolean;
+};
+export declare function BlotterRow({ label, value, valueClassName, className, stacked }: BlotterRowProps): import("react").JSX.Element;
+//# sourceMappingURL=index.d.ts.map

package/dist/esm/domain/blotter/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/domain/blotter/index.tsx"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AACH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,OAAO,CAAA;AAKtC,MAAM,MAAM,YAAY,GAAG;IACzB,QAAQ,EAAE,SAAS,CAAA;IACnB,SAAS,CAAC,EAAE,MAAM,CAAA;CACnB,CAAA;AAED,wBAAgB,OAAO,CAAC,EAAE,QAAQ,EAAE,SAAS,EAAE,EAAE,YAAY,+BAE5D;AAED,MAAM,MAAM,eAAe,GAAG;IAC5B,KAAK,EAAE,SAAS,CAAA;IAChB,KAAK,EAAE,SAAS,CAAA;IAChB,oEAAoE;IACpE,cAAc,CAAC,EAAE,MAAM,CAAA;IACvB,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB;;;;;;OAMG;IACH,OAAO,CAAC,EAAE,OAAO,CAAA;CAClB,CAAA;AAED,wBAAgB,UAAU,CAAC,EACzB,KAAK,EACL,KAAK,EACL,cAAc,EACd,SAAS,EACT,OAAe,EAChB,EAAE,eAAe,+BAwCjB"}

package/dist/esm/domain/blotter/index.js

@@ -0,0 +1,12 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { LABEL_VOICE_CLASS } from '../../lib/typography.js';
+import { cn } from '../../lib/utils.js';
+export function Blotter({ children, className }) {
+    return _jsx("dl", { className: cn('divide-border divide-y', className), children: children });
+}
+export function BlotterRow({ label, value, valueClassName, className, stacked = false }) {
+    if (stacked) {
+        return (_jsxs("div", { className: cn('hover:bg-body-surface space-y-1 px-2 py-2 transition-colors duration-150 ease-out', className), children: [_jsx("dt", { className: LABEL_VOICE_CLASS, children: label }), _jsx("dd", { className: cn('text-foreground text-sm break-words whitespace-pre-wrap', valueClassName), children: value })] }));
+    }
+    return (_jsxs("div", { className: cn('hover:bg-body-surface flex items-center justify-between gap-3 px-2 py-2 transition-colors duration-150 ease-out', className), children: [_jsx("dt", { className: LABEL_VOICE_CLASS, children: label }), _jsx("dd", { className: cn('font-mono text-sm font-medium tabular-nums', valueClassName), children: value })] }));
+}

package/dist/esm/domain/delinquency-aging/aging-buckets.d.ts

@@ -0,0 +1,37 @@
+export interface AgingBucket {
+    /** Human label for the band, e.g. "A vencer", "31–60", "90+". */
+    label: string;
+    /** Number of items in the band. A zero is shown explicitly, never omitted. */
+    count: number;
+    /** Money total for the band. Pass a decimal STRING for lossless sums. */
+    total: string | number;
+}
+export interface AgingBucketsProps {
+    /** Ordered current → oldest. Order carries meaning; not reordered internally. */
+    buckets: AgingBucket[];
+    /** ISO 4217 currency code, e.g. "BRL". Drives the minor-unit sum scale. */
+    currency?: string;
+    /** BCP 47 locale for grouping/decimal marks. Defaults to the runtime locale. */
+    locale?: string;
+    /** Render a money-math-exact grand total row across all buckets. */
+    showTotal?: boolean;
+    className?: string;
+}
+export type AgingBand = 'current' | 'recent' | 'aging' | 'overdue';
+/**
+ * Resolve a bucket's severity band from its ORDINAL POSITION, not its amount —
+ * the order is the information (older = worse). The first bucket is `current`;
+ * the LAST bucket (the oldest, the 90+ tail) is always `overdue`; the middle
+ * escalates `recent` → `aging` toward the tail. A single-bucket list reads as
+ * `current` (there is no escalation to show). Pure: no React, unit-tested.
+ */
+export declare function bucketBand(index: number, count: number): AgingBand;
+/**
+ * Sum the bucket totals through integer minor units (BigInt) at `scale`, then
+ * render losslessly to a decimal string. Returns null if ANY bucket total is
+ * unparseable (indeterminate) — the caller renders NO_VALUE rather than a wrong
+ * grand total. Pure: the money-math third rail, unit-tested.
+ */
+export declare function sumBucketTotals(buckets: AgingBucket[], scale: number): string | null;
+export declare function AgingBuckets({ buckets, currency, locale, showTotal, className }: AgingBucketsProps): import("react").JSX.Element;
+//# sourceMappingURL=aging-buckets.d.ts.map

package/dist/esm/domain/delinquency-aging/aging-buckets.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"aging-buckets.d.ts","sourceRoot":"","sources":["../../../../src/domain/delinquency-aging/aging-buckets.tsx"],"names":[],"mappings":"AAsCA,MAAM,WAAW,WAAW;IAC1B,iEAAiE;IACjE,KAAK,EAAE,MAAM,CAAA;IACb,8EAA8E;IAC9E,KAAK,EAAE,MAAM,CAAA;IACb,yEAAyE;IACzE,KAAK,EAAE,MAAM,GAAG,MAAM,CAAA;CACvB;AAED,MAAM,WAAW,iBAAiB;IAChC,iFAAiF;IACjF,OAAO,EAAE,WAAW,EAAE,CAAA;IACtB,2EAA2E;IAC3E,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,gFAAgF;IAChF,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,oEAAoE;IACpE,SAAS,CAAC,EAAE,OAAO,CAAA;IACnB,SAAS,CAAC,EAAE,MAAM,CAAA;CACnB;AAED,MAAM,MAAM,SAAS,GAAG,SAAS,GAAG,QAAQ,GAAG,OAAO,GAAG,SAAS,CAAA;AA2BlE;;;;;;GAMG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,SAAS,CAMlE;AAED;;;;;GAKG;AACH,wBAAgB,eAAe,CAC7B,OAAO,EAAE,WAAW,EAAE,EACtB,KAAK,EAAE,MAAM,GACZ,MAAM,GAAG,IAAI,CAMf;AAED,wBAAgB,YAAY,CAAC,EAC3B,OAAO,EACP,QAAQ,EACR,MAAM,EACN,SAAiB,EACjB,SAAS,EACV,EAAE,iBAAiB,+BAwFnB"}

package/dist/esm/domain/delinquency-aging/aging-buckets.js

@@ -0,0 +1,92 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * AgingBuckets — an ordered, exhaustive bucketed distribution (the receivables
+ * aging schedule: current / 1–30 / 31–60 / 61–90 / 90+), each bucket carrying a
+ * count and a money total.
+ *
+ * INTERNAL to `DelinquencyAging`: not re-exported from `src/domain/index.ts`,
+ * because the port census only lists the composite. It lives here as the
+ * distribution half of that composite.
+ *
+ * INVARIANT: the buckets are ordered current → oldest and are exhaustive. The
+ * ORDER carries the information — older money is worse money — so the ordinal
+ * position and its label are the PRIMARY cue; the band glyph + sr-only word are
+ * the accessible reinforcement (WCAG 1.4.1 — the escalation survives grayscale
+ * and color-vision deficiency), and the color tint is reinforcement only, never
+ * the sole carrier of severity. The caller supplies the order; the component
+ * never reorders, because a sorted-by-amount view would destroy the one fact the
+ * widget exists to show.
+ *
+ * THIRD RAIL (money): a zero bucket renders an explicit `0` — a zero in the 90+
+ * bucket is information ("nothing slipped that far"), never an omission. When a
+ * grand total is shown it is summed through `money-math` integer minor units
+ * (BigInt, at the currency's CLDR scale) — never IEEE-754 — and rendered via
+ * `MoneyText`. A single unparseable bucket total poisons the sum to NO_VALUE
+ * rather than silently displaying a wrong number.
+ *
+ * Pure display: no directive, no interactivity, server-safe for RSC.
+ */
+import { AlertOctagon, AlertTriangle, CircleDot, Clock } from 'lucide-react';
+import { LABEL_VOICE_CLASS } from '../../lib/typography.js';
+import { cn } from '../../lib/utils.js';
+import { Figure } from '../figure/index.js';
+import { formatCount, NO_VALUE } from '../format.js';
+import { minorDigitsOf, minorToDecimal, sumMinor } from '../money-math.js';
+import { MoneyText } from '../money-text/index.js';
+/** Band → glyph + tint + accessible word. The glyph (and the sr-only word) is
+ *  the load-bearing severity cue; the tint only reinforces it, so the
+ *  escalation survives grayscale and color-vision deficiency. */
+const BAND = {
+    current: {
+        Icon: CircleDot,
+        tint: 'text-system-success',
+        word: 'Em dia'
+    },
+    recent: {
+        Icon: Clock,
+        tint: 'text-muted-foreground',
+        word: 'Vencido recentemente'
+    },
+    aging: {
+        Icon: AlertTriangle,
+        tint: 'text-system-alert',
+        word: 'Em atraso'
+    },
+    overdue: { Icon: AlertOctagon, tint: 'text-credit', word: 'Vencido' }
+};
+/**
+ * Resolve a bucket's severity band from its ORDINAL POSITION, not its amount —
+ * the order is the information (older = worse). The first bucket is `current`;
+ * the LAST bucket (the oldest, the 90+ tail) is always `overdue`; the middle
+ * escalates `recent` → `aging` toward the tail. A single-bucket list reads as
+ * `current` (there is no escalation to show). Pure: no React, unit-tested.
+ */
+export function bucketBand(index, count) {
+    if (count <= 1)
+        return 'current';
+    if (index === 0)
+        return 'current';
+    if (index === count - 1)
+        return 'overdue';
+    // Middle buckets: the second-oldest reads `aging`, the rest `recent`.
+    return index === count - 2 ? 'aging' : 'recent';
+}
+/**
+ * Sum the bucket totals through integer minor units (BigInt) at `scale`, then
+ * render losslessly to a decimal string. Returns null if ANY bucket total is
+ * unparseable (indeterminate) — the caller renders NO_VALUE rather than a wrong
+ * grand total. Pure: the money-math third rail, unit-tested.
+ */
+export function sumBucketTotals(buckets, scale) {
+    const total = sumMinor(buckets.map((b) => b.total), scale);
+    return total === null ? null : minorToDecimal(total, scale);
+}
+export function AgingBuckets({ buckets, currency, locale, showTotal = false, className }) {
+    const scale = currency ? minorDigitsOf(currency) : 2;
+    const grandTotal = showTotal ? sumBucketTotals(buckets, scale) : null;
+    return (_jsxs("div", { className: cn('flex flex-col', className), children: [_jsx("ul", { className: "flex flex-col", children: buckets.map((bucket, i) => {
+                    const band = bucketBand(i, buckets.length);
+                    const { Icon, tint, word } = BAND[band];
+                    return (_jsxs("li", { className: "border-border flex items-center gap-3 border-b py-2.5 last:border-b-0", children: [_jsx(Icon, { "aria-hidden": true, className: cn('size-4 shrink-0', tint) }), _jsxs("span", { className: "sr-only", children: [word, ": "] }), _jsx("span", { className: cn(LABEL_VOICE_CLASS, 'text-foreground min-w-0 flex-1 tracking-normal normal-case'), children: bucket.label }), _jsxs("span", { className: "flex shrink-0 flex-col items-end leading-none", children: [_jsx(Figure, { size: "row", className: "text-foreground", children: formatCount(bucket.count, locale) }), _jsx("span", { className: cn(LABEL_VOICE_CLASS, 'mt-1'), children: "Itens" })] }), _jsxs("span", { className: "flex w-32 shrink-0 flex-col items-end leading-none sm:w-40", children: [_jsx(Figure, { size: "row", className: cn(band === 'overdue' && 'text-credit'), children: _jsx(MoneyText, { amount: bucket.total, currency: currency, locale: locale, signColor: false }) }), _jsx("span", { className: cn(LABEL_VOICE_CLASS, 'mt-1'), children: "Total" })] })] }, `${bucket.label}-${i}`));
+                }) }), showTotal ? (_jsxs("div", { className: "border-border flex items-center gap-3 border-t-2 pt-2.5", children: [_jsx("span", { "aria-hidden": true, className: "size-4 shrink-0" }), _jsx("span", { className: cn(LABEL_VOICE_CLASS, 'text-foreground min-w-0 flex-1'), children: "Total geral" }), _jsx("span", { className: "w-32 shrink-0 text-right sm:w-40", children: grandTotal === null ? (_jsx(Figure, { size: "row", className: "text-muted-foreground", children: NO_VALUE })) : (_jsx(Figure, { size: "row", className: "text-foreground font-semibold", children: _jsx(MoneyText, { amount: grandTotal, currency: currency, locale: locale, signColor: false }) })) })] })) : null] }));
+}

package/dist/esm/domain/delinquency-aging/index.d.ts

@@ -0,0 +1,52 @@
+import type { AgingBucket } from './aging-buckets.js';
+/** A bucket in the aging schedule, plus the flag that marks it past due. The
+ *  `overdue` flag is what the rate's NUMERATOR sums — the caller declares which
+ *  bands count as delinquent (typically every band after "current"). */
+export interface DelinquencyBucket extends AgingBucket {
+    /** Whether this band counts toward the overdue (past-due) numerator. */
+    overdue?: boolean;
+}
+/** The delinquency rate resolved from EXACT integer minor-unit totals. `rate`
+ *  is null for a zero/empty/indeterminate portfolio — never NaN. */
+export interface DelinquencyRate {
+    /** overdueMinor / totalMinor as a 0..1 ratio; null when undefined. */
+    rate: number | null;
+    /** Σ(overdue bucket totals) in minor units; null if any total is unparseable. */
+    overdueMinor: bigint | null;
+    /** Σ(all bucket totals) in minor units; null if any total is unparseable. */
+    totalMinor: bigint | null;
+    /** True when the RATE cannot be determined: a bucket total that could not be
+     *  parsed, or a negative bucket total (parseable, but not a share of a
+     *  portfolio). The sums may still be present in the negative case. */
+    indeterminate: boolean;
+}
+/**
+ * THIRD RAIL: the delinquency rate = overdue total / portfolio total, with both
+ * totals summed through integer minor units (BigInt) at `scale`. The only float
+ * operation is the final division of two EXACT integers — never a float sum of
+ * decimals. A zero portfolio gives a null rate (explicit empty, no NaN); an
+ * unparseable total poisons everything to indeterminate. Pure: unit-tested.
+ *
+ * Internal: exported for its unit tests, never from `src/domain/index.ts`.
+ */
+export declare function delinquencyRate(buckets: DelinquencyBucket[], scale: number): DelinquencyRate;
+export interface DelinquencyAgingProps {
+    /** Ordered current → oldest. Order carries meaning; not reordered internally.
+     *  Each band's `overdue` flag selects it into the rate numerator. */
+    buckets: DelinquencyBucket[];
+    /** ISO 4217 currency code, e.g. "BRL". Drives the minor-unit rate scale. */
+    currency?: string;
+    /** BCP 47 locale for the percent decimal mark and the bucket figures. */
+    locale?: string;
+    /** Quiet caption above the rate readout. Defaults to "Inadimplência". */
+    rateLabel?: string;
+    /** Warn edge for the rate band (0..1 ratio). Crossing it strictly → elevated. */
+    warn?: number;
+    /** Breach edge for the rate band (0..1 ratio). Crossing it strictly → distressed. */
+    breach?: number;
+    /** Render the money-math-exact grand total row under the distribution. */
+    showTotal?: boolean;
+    className?: string;
+}
+export declare function DelinquencyAging({ buckets, currency, locale, rateLabel, warn, breach, showTotal, className }: DelinquencyAgingProps): import("react").JSX.Element;
+//# sourceMappingURL=index.d.ts.map

package/dist/esm/domain/delinquency-aging/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/domain/delinquency-aging/index.tsx"],"names":[],"mappings":"AAuDA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAA;AAOlD;;wEAEwE;AACxE,MAAM,WAAW,iBAAkB,SAAQ,WAAW;IACpD,wEAAwE;IACxE,OAAO,CAAC,EAAE,OAAO,CAAA;CAClB;AAED;oEACoE;AACpE,MAAM,WAAW,eAAe;IAC9B,sEAAsE;IACtE,IAAI,EAAE,MAAM,GAAG,IAAI,CAAA;IACnB,iFAAiF;IACjF,YAAY,EAAE,MAAM,GAAG,IAAI,CAAA;IAC3B,6EAA6E;IAC7E,UAAU,EAAE,MAAM,GAAG,IAAI,CAAA;IACzB;;0EAEsE;IACtE,aAAa,EAAE,OAAO,CAAA;CACvB;AAED;;;;;;;;GAQG;AACH,wBAAgB,eAAe,CAC7B,OAAO,EAAE,iBAAiB,EAAE,EAC5B,KAAK,EAAE,MAAM,GACZ,eAAe,CAuDjB;AAeD,MAAM,WAAW,qBAAqB;IACpC;yEACqE;IACrE,OAAO,EAAE,iBAAiB,EAAE,CAAA;IAC5B,4EAA4E;IAC5E,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,yEAAyE;IACzE,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,yEAAyE;IACzE,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,iFAAiF;IACjF,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,qFAAqF;IACrF,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,0EAA0E;IAC1E,SAAS,CAAC,EAAE,OAAO,CAAA;IACnB,SAAS,CAAC,EAAE,MAAM,CAAA;CACnB;AAED,wBAAgB,gBAAgB,CAAC,EAC/B,OAAO,EACP,QAAQ,EACR,MAAM,EACN,SAA2B,EAC3B,IAAW,EACX,MAAY,EACZ,SAAiB,EACjB,SAAS,EACV,EAAE,qBAAqB,+BAiEvB"}

package/dist/esm/domain/delinquency-aging/index.js

@@ -0,0 +1,147 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * DelinquencyAging — a loan/receivable delinquency surface: the ordered overdue
+ * aging distribution PLUS the headline delinquency rate (the share of portfolio
+ * value that is past due).
+ *
+ *   <DelinquencyAging
+ *     currency="BRL"
+ *     locale="pt-BR"
+ *     warn={0.05}
+ *     breach={0.1}
+ *     buckets={[
+ *       { label: 'A vencer', count: 312, total: '1840500.00', overdue: false },
+ *       { label: '1–30',     count: 84,  total: '402300.00',  overdue: true },
+ *       { label: '31–60',    count: 21,  total: '118900.00',  overdue: true },
+ *       { label: '61–90',    count: 9,   total: '54200.00',   overdue: true },
+ *       { label: '90+',      count: 4,   total: '38100.00',   overdue: true }
+ *     ]}
+ *   />
+ *
+ * The distribution is delegated whole to `AgingBuckets`: it owns the ordered
+ * current → 90+ schedule, the per-bucket count/total, the ordinal band cue, and
+ * the money-math-exact grand total. This composite adds only the one fact aging
+ * alone does not state — the delinquency RATE.
+ *
+ * THIRD RAIL (money): the rate is overdueTotal / portfolioTotal, and BOTH totals
+ * are summed in integer minor units (BigInt, at the currency's CLDR scale) via
+ * `money-math` — never an IEEE-754 sum of decimals (0.1 + 0.2 ≠ 0.3 in float, a
+ * silent basis-point error on a portfolio). The single floating-point operation
+ * is the FINAL division of two already-exact integers, which is the correct,
+ * lossless-enough place for it (a ratio is not money). A zero portfolio yields a
+ * null rate — an explicit empty readout, never a NaN. A single unparseable
+ * bucket total poisons the rate to indeterminate rather than reporting a wrong
+ * share.
+ *
+ * NON-COLOR CUE (WCAG 1.4.1): the rate band (healthy / elevated / distressed) is
+ * resolved through the gauge's strict-edge `gaugeBand` (higher-is-worse: more
+ * overdue is worse) and named with a glyph + an sr-only word + a tint — the tint
+ * is reinforcement only, so the band survives grayscale and color-vision
+ * deficiency. A distressed rate reads loud (credit-red, role='alert').
+ *
+ * Pure display: no directive, no interactivity, server-safe for RSC.
+ */
+import { AlertOctagon, ShieldCheck, TriangleAlert } from 'lucide-react';
+import { LABEL_VOICE_CLASS } from '../../lib/typography.js';
+import { cn } from '../../lib/utils.js';
+import { Figure } from '../figure/index.js';
+import { formatPercent, NO_VALUE } from '../format.js';
+import { minorDigitsOf, toMinor } from '../money-math.js';
+import { SectionLabel } from '../section-label/index.js';
+import { gaugeBand } from '../threshold-gauge/index.js';
+import { AgingBuckets } from './aging-buckets.js';
+/** Fixed-point scale for the rate division: 1e12 keeps twelve decimal places of
+ *  a 0..1 ratio, and both it and any in-range scaled quotient stay well inside
+ *  the exact-integer range of a double (2^53), so the conversion is lossless. */
+const RATE_PRECISION = 1000000000000n;
+/**
+ * THIRD RAIL: the delinquency rate = overdue total / portfolio total, with both
+ * totals summed through integer minor units (BigInt) at `scale`. The only float
+ * operation is the final division of two EXACT integers — never a float sum of
+ * decimals. A zero portfolio gives a null rate (explicit empty, no NaN); an
+ * unparseable total poisons everything to indeterminate. Pure: unit-tested.
+ *
+ * Internal: exported for its unit tests, never from `src/domain/index.ts`.
+ */
+export function delinquencyRate(buckets, scale) {
+    // Parse each bucket exactly once: the sums and the per-bucket SIGN check both
+    // come off the same pass, so the two can never disagree about the same input.
+    const parsed = buckets.map((b) => toMinor(b.total, scale));
+    if (parsed.some((m) => m === null)) {
+        return {
+            rate: null,
+            overdueMinor: null,
+            totalMinor: null,
+            indeterminate: true
+        };
+    }
+    let totalMinor = 0n;
+    let overdueMinor = 0n;
+    let hasNegativeBucket = false;
+    parsed.forEach((m, i) => {
+        const minor = m;
+        if (minor < 0n)
+            hasNegativeBucket = true;
+        totalMinor += minor;
+        if (buckets[i].overdue)
+            overdueMinor += minor;
+    });
+    // A NEGATIVE bucket total is parseable but not interpretable as a share of a
+    // portfolio: overdue/total stops being bounded by 0..1 the moment a component
+    // is negative (a -50 current band against a 100 overdue band yields "200%
+    // delinquent"), and it can also cancel the denominator toward zero. A credit
+    // adjustment is real data, but it is not aging data, so the honest answer is
+    // that the RATE cannot be determined — the sums stay, since they are still
+    // correct, and the readout takes the no-value path. Legacy divided anyway and
+    // printed the out-of-range percentage.
+    if (hasNegativeBucket) {
+        return { rate: null, overdueMinor, totalMinor, indeterminate: true };
+    }
+    // A zero portfolio has no rate to report — null, never overdueMinor/0 (NaN).
+    if (totalMinor === 0n) {
+        return { rate: null, overdueMinor, totalMinor, indeterminate: false };
+    }
+    // The division is done as a BOUNDED BigInt ratio first, then converted once.
+    // Converting the two totals to Number separately overflowed on a large
+    // portfolio: past ~1.8e308 each side becomes Infinity and Infinity/Infinity is
+    // NaN — a portfolio big enough to matter reported no rate at all. Scaling the
+    // numerator by RATE_PRECISION keeps the quotient the size of a ratio (not the
+    // size of the money), so the single Number() sees a value it can hold exactly.
+    const scaled = (overdueMinor * RATE_PRECISION) / totalMinor;
+    const rate = Number(scaled) / Number(RATE_PRECISION);
+    // A ratio that still cannot be represented is no rate at all — the readout
+    // shows the no-value placeholder rather than a NaN/Infinity artifact.
+    if (!Number.isFinite(rate)) {
+        return { rate: null, overdueMinor, totalMinor, indeterminate: false };
+    }
+    return { rate, overdueMinor, totalMinor, indeterminate: false };
+}
+/** Band → glyph + tint + accessible word. The glyph and sr-only word are the
+ *  load-bearing cue; the tint only reinforces, so the band survives grayscale
+ *  and color-vision deficiency. Mirrors the gauge's three-band canon, renamed
+ *  to the delinquency vocabulary. */
+const RATE_BAND = {
+    low: { Icon: ShieldCheck, tint: 'text-system-success', word: 'Saudável' },
+    warn: { Icon: TriangleAlert, tint: 'text-system-alert', word: 'Elevada' },
+    breach: { Icon: AlertOctagon, tint: 'text-credit', word: 'Em estresse' }
+};
+export function DelinquencyAging({ buckets, currency, locale, rateLabel = 'Inadimplência', warn = 0.05, breach = 0.1, showTotal = false, className }) {
+    // THIRD RAIL: the rate scale and the two totals come from money-math, never
+    // float. The division below is of two exact BigInt-derived integers.
+    const scale = currency ? minorDigitsOf(currency) : 2;
+    const { rate, indeterminate } = delinquencyRate(buckets, scale);
+    // The band is only meaningful when there is a rate; an empty/indeterminate
+    // portfolio has no band to name (rendered as the explicit no-value readout).
+    const hasRate = rate !== null;
+    // higher-is-worse: more value past due is worse. gaugeBand is strict-edge, so
+    // a rate exactly on a threshold stays in the calmer band.
+    const band = hasRate
+        ? gaugeBand(rate, { warn, breach }, 'higher-is-worse')
+        : 'low';
+    const { Icon, tint, word } = RATE_BAND[band];
+    const distressed = band === 'breach';
+    return (_jsxs("div", { className: cn('flex flex-col gap-4', className), children: [_jsxs("header", { className: "flex items-baseline justify-between gap-3", children: [_jsx(SectionLabel, { as: "span", children: rateLabel }), hasRate ? (_jsxs("span", { 
+                        // A distressed rate is a credit alarm: announced the moment it
+                        // crosses the band, so assistive tech does not lean on the tint.
+                        role: distressed ? 'alert' : undefined, className: cn('inline-flex items-center gap-1.5', tint), children: [_jsx(Icon, { "aria-hidden": true, className: "size-4 shrink-0" }), _jsxs("span", { className: "sr-only", children: [word, ": "] }), _jsx(Figure, { size: "row", className: tint, children: formatPercent(rate, { unit: 'ratio', locale }) })] })) : (_jsxs("span", { className: "text-muted-foreground inline-flex items-center gap-1.5", children: [_jsx("span", { className: cn(LABEL_VOICE_CLASS, 'tracking-normal normal-case'), children: indeterminate ? 'indeterminada' : 'sem carteira' }), _jsx(Figure, { size: "row", className: "text-muted-foreground", children: NO_VALUE })] }))] }), _jsx(AgingBuckets, { buckets: buckets, currency: currency, locale: locale, showTotal: showTotal })] }));
+}

package/dist/esm/domain/figure/index.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Figure — the locked mono figure type scale of the enterprise console.
+ *
+ * All numbers are the hero: mono, tabular, visually dominant. This file is the
+ * single source of truth for the canonical figure sizes so screens stop
+ * re-typing `font-mono … tabular-nums` strings and drifting on
+ * size/weight/tracking. Use `<Figure size>` for new markup, or import the
+ * `FIGURE_CLASS` constants when composing className strings inline.
+ *
+ * Scale:
+ *  - hero  : the dominant in-bar figure   — text-4xl/5xl, semibold, tracking-tight
+ *  - panel : compliance / exposure        — text-3xl, semibold, tracking-tight
+ *  - count : ledger count                 — text-2xl, semibold, tracking-tight
+ *  - row   : inline / row figure          — text-sm
+ *  - tick  : ruler / micro figure         — text-[10px], leading-none
+ */
+import type { ElementType, ReactNode } from 'react';
+export type FigureSize = 'hero' | 'panel' | 'count' | 'row' | 'tick';
+/** Canonical class strings per figure size. The `tabular-nums` and `font-mono`
+ *  invariants live here so they can never be forgotten at a call site. */
+export declare const FIGURE_CLASS: Record<FigureSize, string>;
+export type FigureProps = {
+    size: FigureSize;
+    children: ReactNode;
+    className?: string;
+    /** Render element. Defaults to `span` so figures nest inside `dd`/`p`/etc. */
+    as?: ElementType;
+};
+export declare function Figure({ size, children, className, as: Tag }: FigureProps): import("react").JSX.Element;
+//# sourceMappingURL=index.d.ts.map

package/dist/esm/domain/figure/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/domain/figure/index.tsx"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AACH,OAAO,KAAK,EAAE,WAAW,EAAE,SAAS,EAAE,MAAM,OAAO,CAAA;AAInD,MAAM,MAAM,UAAU,GAAG,MAAM,GAAG,OAAO,GAAG,OAAO,GAAG,KAAK,GAAG,MAAM,CAAA;AAEpE;0EAC0E;AAC1E,eAAO,MAAM,YAAY,EAAE,MAAM,CAAC,UAAU,EAAE,MAAM,CAMnD,CAAA;AAED,MAAM,MAAM,WAAW,GAAG;IACxB,IAAI,EAAE,UAAU,CAAA;IAChB,QAAQ,EAAE,SAAS,CAAA;IACnB,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,8EAA8E;IAC9E,EAAE,CAAC,EAAE,WAAW,CAAA;CACjB,CAAA;AAED,wBAAgB,MAAM,CAAC,EACrB,IAAI,EACJ,QAAQ,EACR,SAAS,EACT,EAAE,EAAE,GAAY,EACjB,EAAE,WAAW,+BAEb"}

package/dist/esm/domain/figure/index.js

@@ -0,0 +1,14 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { cn } from '../../lib/utils.js';
+/** Canonical class strings per figure size. The `tabular-nums` and `font-mono`
+ *  invariants live here so they can never be forgotten at a call site. */
+export const FIGURE_CLASS = {
+    hero: 'font-mono text-4xl font-semibold tracking-tight tabular-nums lg:text-5xl',
+    panel: 'font-mono text-3xl font-semibold tracking-tight tabular-nums',
+    count: 'font-mono text-2xl font-semibold tracking-tight tabular-nums',
+    row: 'font-mono text-sm tabular-nums',
+    tick: 'font-mono text-[10px] leading-none tabular-nums'
+};
+export function Figure({ size, children, className, as: Tag = 'span' }) {
+    return _jsx(Tag, { className: cn(FIGURE_CLASS[size], className), children: children });
+}