@robosystems/report-components 0.1.4 → 0.2.1

package/dist/index.d.ts

@@ -1,5 +1,5 @@
-import { P as PeriodInfo, E as ElementInfo, N as NormalizedReport, S as Statement, a as StatementRow } from './index-DDFpPfUd.js';
-export { B as BalanceType, C as CalcAssociation, b as CypherAdapterConfig, c as EntityInfo, F as Fact, I as InformationBlock, d as PeriodType, e as PresAssociation, R as ReportAdapter, f as RowCell, g as StatementColumn, h as StructureInfo, U as UnitInfo, i as cypherAdapter, j as jsonldFileAdapter, p as parseJsonld, k as parseStore } from './index-DDFpPfUd.js';
+import { N as NumericKind, P as PeriodInfo, E as ElementInfo, a as NormalizedReport, I as InformationBlock, b as PivotConfig, c as PivotTable, d as PivotRow, U as UnitInfo } from './index-WkjE6dZu.js';
+export { A as AspectKey, B as BalanceType, C as CalcAssociation, e as CypherAdapterConfig, D as DimensionQualifier, f as EntityInfo, F as Fact, g as PeriodType, h as PivotCell, i as PivotColumn, j as PivotColumnHeader, k as PivotSlicer, l as PresAssociation, R as ReportAdapter, m as ResolvedScale, n as RowCell, S as Scale, o as SecQuery, p as SecReportShell, q as SecSection, r as Statement, s as StatementColumn, t as StatementRow, u as StructureInfo, v as cypherAdapter, w as fetchSecReportShell, x as fetchSecSection, y as jsonldFileAdapter, z as mergeSecSections, G as parseJsonld, H as parseStore, J as parseStructureDefinition } from './index-WkjE6dZu.js';
 import * as react from 'react';
 import 'n3';
 
@@ -28,6 +28,13 @@ declare function qname(iri: string): string;
  * fallback for bundles that predate label emit.
  */
 declare function humanize(iri: string): string;
+/**
+ * A large text-block / policy fact whose HTML (or plain-text) body is too big to
+ * store inline, so the platform externalizes it to the public CDN and the fact's
+ * value is the URL (`…/fact_<hash>.html` or `.txt`). The renderer fetches and
+ * embeds these instead of printing the raw link.
+ */
+declare function isExternalFactUrl(value: string | null | undefined): boolean;
 /** Stable display order for the canonical statement blocks; others fall after. */
 declare const BLOCK_ORDER: Record<string, number>;
 /** Friendly section headings keyed by block type. */
@@ -47,8 +54,72 @@ declare function formatMoney(value: number | null | undefined, opts?: {
 }): string;
 /** `2024-03-31` → `Mar 31, 2024`. Falls back to the raw string if unparseable. */
 declare function formatDate(iso: string | null | undefined): string;
+/**
+ * Humanize an ISO-8601 duration value (`P10Y` → "10 years", `P1Y6M` → "1 year 6
+ * months", `P30D` → "30 days"), or null when the string is not a duration — so a
+ * non-numeric fact that happens to start with "P" (a company name) is untouched.
+ * XBRL `durationItemType` facts (debt maturities, lease terms) arrive as these
+ * strings in the text path.
+ */
+declare function humanizeDuration(value: string | null | undefined): string | null;
 /** A human description of a period — "As of …" for instants, a span for durations. */
 declare function formatPeriod(period: PeriodInfo): string;
+/** The effective numeric kind of an element (explicit, else derived from monetary). */
+declare function numericKindOf(el: ElementInfo): NumericKind;
+/**
+ * A display prefix for a monetary unit measure (`iso4217:USD` → `$`), else null.
+ * Unknown currencies fall back to their code (`CHF `, `SEK `) rather than a wrong
+ * dollar sign — this is what fixes non-USD facts rendering as `$`.
+ */
+declare function currencySymbolFor(measure: string | null | undefined): string | null;
+interface ValueFormat {
+    /** Drives symbol, scaling opt-out, and decimal places. Defaults to `monetary`. */
+    numericKind?: NumericKind;
+    /** Currency symbol for monetary/per-share values (from the fact's unit). */
+    symbol?: string | null;
+    /** Divide monetary values by this (e.g. 1e6 to show millions); default 1. */
+    scaleFactor?: number;
+}
+/**
+ * Format a fact value for display: accounting style (negatives in parentheses,
+ * em-dash for absent), the fact's own currency symbol (never a hard-coded `$`),
+ * and the section scale — with per-share amounts and share counts never rescaled
+ * (an EPS of 4.93 stays 4.93 under "in millions"). A `percent` fact stores a
+ * decimal fraction, so it is scaled ×100 and suffixed with `%` (0.10 → 10%); a
+ * `pure` fact is a bare ratio, shown as a plain decimal (no `%`).
+ */
+declare function formatValue(value: number | null | undefined, fmt?: ValueFormat): string;
+
+/**
+ * Derive the default pivot for a section from the aspects its facts actually
+ * carry: concept on rows, period on columns, entity a slicer, and each dimension
+ * axis on columns when it has more than one member (a real breakdown) or a slicer
+ * when it has just one (diced to a single member, e.g. `Consolidated [Domain]`).
+ */
+declare function defaultPivotConfig(model: NormalizedReport, ib: InformationBlock): PivotConfig;
+/**
+ * Move every dimension axis to one side of the pivot — the toggle behind a
+ * "dimensions as rows / columns" control. Concept stays on rows and period on
+ * columns; only `dim:*` aspects move. Rows (nested breakdowns) is the default;
+ * columns gives the side-by-side matrix (equity components across the top).
+ */
+declare function pivotDimensionsOn(config: PivotConfig, placement: 'rows' | 'columns'): PivotConfig;
+/**
+ * Pivot one section into a `PivotTable`. Pass `config` to override the default
+ * arrangement (e.g. move a high-arity axis from columns to rows).
+ */
+declare function buildPivot(model: NormalizedReport, ib: InformationBlock, config?: PivotConfig): PivotTable;
+/** Section metadata (id + display title) for a report, in canonical order. */
+declare function reportSections(model: NormalizedReport): Array<{
+    id: string;
+    title: string;
+}>;
+/**
+ * Pivot every section of a report, in canonical block order. `configFor` may
+ * transform each section's default config before it is built — e.g. to apply a
+ * "dimensions as rows / columns" toggle across the whole report.
+ */
+declare function buildPivots(model: NormalizedReport, configFor?: (ib: InformationBlock, defaultConfig: PivotConfig) => PivotConfig): PivotTable[];
 
 interface OrderEntry {
     order: number;
@@ -57,14 +128,20 @@ interface OrderEntry {
 /**
  * Post-order the presentation arcs of one structure → `{element: {order, depth}}`.
  * Roots (a `from` that is never a `to`) are visited by their subtree's leading
- * arc order, so a balance sheet's roots (Assets, then Liabilities and Equity)
- * come out in the right sequence.
+ * arc order. Retained as a reusable utility; the pivot engine builds its own
+ * pre-order tree (it needs abstract headers), but external callers may still want
+ * a flat order map.
  */
 declare function presentationOrder(model: NormalizedReport, structureId: string): Map<string, OrderEntry>;
 /** Concepts that are calculation parents — the authoritative subtotal set. */
 declare function calcSubtotals(model: NormalizedReport): Set<string>;
-/** Reconstruct every statement in the report, in canonical block order. */
-declare function buildStatements(model: NormalizedReport): Statement[];
+/**
+ * Narrow a whole report to a single section (one Information Block) so it can be
+ * rendered on its own. `buildPivots` only iterates `informationBlocks`, so
+ * restricting to one yields exactly that section — facts, structures, and
+ * networks stay intact because the pivot filters them by the block.
+ */
+declare function sliceReportSection(model: NormalizedReport, informationBlockId: string): NormalizedReport;
 interface FootTerm {
     element: ElementInfo;
     weight: number;
@@ -83,40 +160,50 @@ interface FootCheck {
 /**
  * Foot a subtotal live: sum its calculation children (× weight) and compare to
  * its reported value, e.g. `13,550 + 900 = 14,450 ✓`. Returns `null` when the
- * element is not a calculation parent (nothing to foot).
+ * element is not a calculation parent (nothing to foot). Values are read from the
+ * consolidated (undimensioned) row for each concept.
  */
-declare function footCheck(model: NormalizedReport, statement: Statement, elementId: string, columnIndex: number): FootCheck | null;
+declare function footCheck(model: NormalizedReport, table: PivotTable, elementId: string, columnIndex: number): FootCheck | null;
+
+interface ExternalTextBlockProps {
+    url: string;
+}
+declare function ExternalTextBlock({ url }: ExternalTextBlockProps): react.JSX.Element;
 
 interface FactInspectorProps {
     report: NormalizedReport;
-    statement: Statement;
-    row: StatementRow;
+    table: PivotTable;
+    row: PivotRow;
     columnIndex: number;
     onClose?: () => void;
-    currencySymbol?: string;
 }
-declare function FactInspector({ report, statement, row, columnIndex, onClose, currencySymbol, }: FactInspectorProps): react.JSX.Element;
+declare function FactInspector({ report, table, row, columnIndex, onClose }: FactInspectorProps): react.JSX.Element;
 
 interface ReportViewProps {
     report: NormalizedReport;
-    currencySymbol?: string;
     /** Disable the click-to-inspect fact panel (render-only). */
     inspect?: boolean;
+    /** Initial placement for dimension breakdowns (default `rows`). */
+    dimensionAxis?: 'rows' | 'columns';
 }
-declare function ReportView({ report, currencySymbol, inspect }: ReportViewProps): react.JSX.Element;
+declare function ReportView({ report, inspect, dimensionAxis }: ReportViewProps): react.JSX.Element;
 
 interface StatementTableProps {
-    statement: Statement;
+    table: PivotTable;
+    /** The report's units, to resolve each cell's currency symbol. */
+    units?: Record<string, UnitInfo>;
     /** Called when a value cell is clicked — drives fact inspection. */
-    onCellClick?: (row: StatementRow, columnIndex: number) => void;
-    /** Currency symbol for values (default `$`). */
-    currencySymbol?: string;
+    onCellClick?: (row: PivotRow, columnIndex: number) => void;
     /** The currently-selected cell, highlighted. */
     selected?: {
-        elementId: string;
+        rowKey: string;
         columnIndex: number;
     } | null;
+    /** Current dimension placement — set with `onDimensionPlacementChange` to show the toggle. */
+    dimensionPlacement?: 'rows' | 'columns';
+    /** Setter for the dimension placement; when provided (and the section is dimensional), a rows/columns toggle renders below the slicers. */
+    onDimensionPlacementChange?: (placement: 'rows' | 'columns') => void;
 }
-declare function StatementTable({ statement, onCellClick, currencySymbol, selected, }: StatementTableProps): react.JSX.Element;
+declare function StatementTable({ table, units, onCellClick, selected, dimensionPlacement, onDimensionPlacementChange, }: StatementTableProps): react.JSX.Element;
 
-export { BLOCK_ORDER, BLOCK_TITLES, ElementInfo, FactInspector, type FactInspectorProps, type FootCheck, type FootTerm, NS, NormalizedReport, PeriodInfo, ReportView, type ReportViewProps, Statement, StatementRow, StatementTable, type StatementTableProps, buildStatements, calcSubtotals, footCheck, formatDate, formatMoney, formatPeriod, humanize, presentationOrder, qname };
+export { BLOCK_ORDER, BLOCK_TITLES, ElementInfo, ExternalTextBlock, type ExternalTextBlockProps, FactInspector, type FactInspectorProps, type FootCheck, type FootTerm, InformationBlock, NS, NormalizedReport, NumericKind, PeriodInfo, PivotConfig, PivotRow, PivotTable, ReportView, type ReportViewProps, StatementTable, type StatementTableProps, UnitInfo, type ValueFormat, buildPivot, buildPivots, calcSubtotals, currencySymbolFor, defaultPivotConfig, footCheck, formatDate, formatMoney, formatPeriod, formatValue, humanize, humanizeDuration, isExternalFactUrl, numericKindOf, pivotDimensionsOn, presentationOrder, qname, reportSections, sliceReportSection };