@iota-uz/sdk 0.4.43 → 0.5.0

package/dist/lens/print/PrintReport.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PrintReport.d.ts","sourceRoot":"","sources":["../../src/print/PrintReport.tsx"],"names":[],"mappings":"AAgBA,OAAO,KAAK,EAAE,WAAW,IAAI,gBAAgB,EAAgB,MAAM,kBAAkB,CAAA;AAgmCrF;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,EAAE,MAAM,EAAE,EAAE;IAAE,MAAM,EAAE,gBAAgB,CAAA;CAAE,2CAsBvE;AAED,wBAAgB,WAAW,uCAmB1B"}

package/dist/lens/print/footnotes.d.ts

@@ -0,0 +1,29 @@
+import type { PrintFigure } from './outline';
+import { type Translate } from './quality';
+/**
+ * Footnotes for a printed chapter.
+ *
+ * A dashboard keeps its qualifications behind hover: the ⓘ explaining how a
+ * figure is obtained, the chip saying it is an estimate, the small badge on a
+ * table row saying that row is unmatched. Paper has no hover, and a reader
+ * cannot ask. So each qualification is numbered where it applies and printed in
+ * full under the first figure that carries it — the same page, not the back of
+ * the report, and once per chapter rather than under every figure that repeats
+ * the same caveat.
+ */
+export interface PrintFootnote {
+    number: number;
+    text: string;
+}
+export interface FigureFootnotes {
+    /** Numbers printed as markers beside this figure's heading. */
+    markers: Array<number>;
+    /** Notes printed in full under this figure — those it introduced. */
+    notes: Array<PrintFootnote>;
+}
+/**
+ * Assigns footnote numbers over a chapter's figures in printing order. The same
+ * caveat carried by three figures is one number, printed once.
+ */
+export declare function buildChapterFootnotes(figures: Array<PrintFigure>, translate: Translate): Map<string, FigureFootnotes>;
+//# sourceMappingURL=footnotes.d.ts.map

package/dist/lens/print/footnotes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"footnotes.d.ts","sourceRoot":"","sources":["../../src/print/footnotes.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,WAAW,CAAA;AAC5C,OAAO,EAAmB,KAAK,SAAS,EAAE,MAAM,WAAW,CAAA;AAG3D;;;;;;;;;;GAUG;AAEH,MAAM,WAAW,aAAa;IAC5B,MAAM,EAAE,MAAM,CAAA;IACd,IAAI,EAAE,MAAM,CAAA;CACb;AAED,MAAM,WAAW,eAAe;IAC9B,+DAA+D;IAC/D,OAAO,EAAE,KAAK,CAAC,MAAM,CAAC,CAAA;IACtB,qEAAqE;IACrE,KAAK,EAAE,KAAK,CAAC,aAAa,CAAC,CAAA;CAC5B;AA+BD;;;GAGG;AACH,wBAAgB,qBAAqB,CACnC,OAAO,EAAE,KAAK,CAAC,WAAW,CAAC,EAC3B,SAAS,EAAE,SAAS,GACnB,GAAG,CAAC,MAAM,EAAE,eAAe,CAAC,CA6B9B"}

package/dist/lens/print/formula.d.ts

@@ -0,0 +1,9 @@
+import type { PrintSection } from '../runtime/print';
+/**
+ * The printed form of a metric panel, or nothing when the panel is not one of
+ * the three — the caller then falls back to a chart and its evidence table.
+ */
+export declare function PrintFormula({ section }: {
+    section: PrintSection;
+}): import("react/jsx-runtime").JSX.Element | null;
+//# sourceMappingURL=formula.d.ts.map

package/dist/lens/print/formula.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"formula.d.ts","sourceRoot":"","sources":["../../src/print/formula.tsx"],"names":[],"mappings":"AAaA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAA;AA+JpD;;;GAGG;AACH,wBAAgB,YAAY,CAAC,EAAE,OAAO,EAAE,EAAE;IAAE,OAAO,EAAE,YAAY,CAAA;CAAE,kDAWlE"}

package/dist/lens/print/narrative.d.ts

@@ -0,0 +1,41 @@
+import type { Frame, Panel } from '../contract';
+/**
+ * A sentence the report can print under a figure, expressed as a translation
+ * key with its variables so a catalogue keeps word order.
+ *
+ * Every fact is a restatement of numbers printed on the same page: the largest
+ * share, the biggest deduction, the change between the first and last point.
+ * Nothing here explains, attributes or projects — a printed report must not say
+ * more than its own table does.
+ */
+export interface NarrativeFact {
+    labelKey: string;
+    fallback: string;
+    vars: Record<string, string | number>;
+}
+/** A chapter's own headline: one reading per figure, in printing order. */
+export interface HeadlineReading {
+    id: string;
+    label: string;
+    value: string;
+}
+/**
+ * What a chapter says in one line, before its figures.
+ *
+ * A reader arriving at «Формирование результата» should not have to assemble
+ * the chapter's outcome from six figures. Each figure contributes exactly one
+ * number — the value it states when it states only one, or the total it is
+ * taken against — so the opener is a restatement of the pages below it and
+ * never an interpretation of them.
+ */
+export declare function headlineReadings(figures: Array<{
+    id: string;
+    panel: Panel;
+    frame?: Frame;
+}>, locale: string, limit?: number): Array<HeadlineReading>;
+/**
+ * The one sentence worth printing under this figure, or nothing when the frame
+ * carries no reading that a sentence would add to.
+ */
+export declare function narrativeFact(panel: Panel, frame: Frame | undefined, locale: string): NarrativeFact | undefined;
+//# sourceMappingURL=narrative.d.ts.map

package/dist/lens/print/narrative.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"narrative.d.ts","sourceRoot":"","sources":["../../src/print/narrative.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM,aAAa,CAAA;AAI/C;;;;;;;;GAQG;AACH,MAAM,WAAW,aAAa;IAC5B,QAAQ,EAAE,MAAM,CAAA;IAChB,QAAQ,EAAE,MAAM,CAAA;IAChB,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAAC,CAAA;CACtC;AAuMD,2EAA2E;AAC3E,MAAM,WAAW,eAAe;IAC9B,EAAE,EAAE,MAAM,CAAA;IACV,KAAK,EAAE,MAAM,CAAA;IACb,KAAK,EAAE,MAAM,CAAA;CACd;AAED;;;;;;;;GAQG;AACH,wBAAgB,gBAAgB,CAC9B,OAAO,EAAE,KAAK,CAAC;IAAE,EAAE,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,KAAK,CAAC;IAAC,KAAK,CAAC,EAAE,KAAK,CAAA;CAAE,CAAC,EAC3D,MAAM,EAAE,MAAM,EACd,KAAK,SAAI,GACR,KAAK,CAAC,eAAe,CAAC,CAsBxB;AAED;;;GAGG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK,GAAG,SAAS,EAAE,MAAM,EAAE,MAAM,GAAG,aAAa,GAAG,SAAS,CAa/G"}

package/dist/lens/print/outline.d.ts

@@ -0,0 +1,94 @@
+import { type QualityInput } from '../panels/QualityChip';
+import type { PrintReport, PrintSection } from '../runtime/print';
+/**
+ * A figure printed in a chapter body: the dashboard's own reading of a panel,
+ * numbered so the text can point at it.
+ */
+export interface PrintFigure {
+    section: PrintSection;
+    /** "2.1" — chapter number, then position inside the chapter. */
+    number: string;
+    /** Rendered as a chart, rather than as evidence rows only. */
+    chart: boolean;
+    /**
+     * A single value: printed as a metric tile. A chart of one point and a table
+     * of one row are both worse than the number itself.
+     */
+    metric: boolean;
+    width: 'half' | 'full';
+    /** The metric strip this reading was authored inside, when it was. */
+    group?: {
+        id: string;
+        label?: string;
+        caption?: string;
+    };
+    /**
+     * A headline reading the cover lifts into its "at a glance" strip. It is not
+     * printed a second time in the chapter body.
+     */
+    kpi: boolean;
+    /**
+     * What the dashboard shows when this reading is clicked: the numerator and
+     * denominator of a ratio, the components of a total. It prints with the
+     * figure it explains, not as loose fragments at the back of the report.
+     */
+    breakdown: Array<PrintSection>;
+}
+/** A drill reading, printed as a dense table in the detail appendix. */
+export interface PrintDetail {
+    section: PrintSection;
+    /** "A2.3" — appendix, owning chapter, position. */
+    number: string;
+    /** Where the reading sits in the dashboard's drill graph. */
+    trail: string;
+}
+export interface PrintChapter {
+    id: string;
+    number: number;
+    title: string;
+    caption?: string;
+    figures: Array<PrintFigure>;
+    details: Array<PrintDetail>;
+}
+/** An entry of the closing methodology appendix. */
+export interface PrintNote {
+    id: string;
+    label: string;
+    detail?: string;
+}
+export interface PrintOutline {
+    chapters: Array<PrintChapter>;
+    /** Chapters that carry detail readings, in chapter order. */
+    appendix: Array<PrintChapter>;
+    /** Headline readings printed on the cover instead of inside a chapter. */
+    kpis: Array<PrintFigure>;
+    notes: Array<PrintNote>;
+    /** Readings that resolved to nothing, disclosed instead of printed empty. */
+    missing: Array<string>;
+    /**
+     * Printed readings that are an estimate, a proxy or an unreconciled figure.
+     * The cover states the count, because "how much of this is settled" is the
+     * first thing a reader of a management report is entitled to know.
+     */
+    estimated: number;
+    /**
+     * Every quality the document declares anywhere — panel, formula stage,
+     * hierarchy row, relationship end. The closing appendix defines the words
+     * this report actually used, and only those.
+     */
+    qualities: Array<QualityInput>;
+    figureCount: number;
+    detailCount: number;
+}
+/**
+ * Groups the flat walk of the drill graph into the document's own chapters.
+ *
+ * `buildPrintReport` answers "what readings exist"; the printed document also
+ * needs "in what order does a person read them". That order is already
+ * authored: `layout.rows` carries the headings, spans and group captions the
+ * dashboard itself is read by. Following it turns a numbered dump into a
+ * document — and keeps the two in step, because a re-authored dashboard
+ * re-authors its report.
+ */
+export declare function buildOutline(report: PrintReport, fallbackTitle: string, otherTitle: string): PrintOutline;
+//# sourceMappingURL=outline.d.ts.map

package/dist/lens/print/outline.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"outline.d.ts","sourceRoot":"","sources":["../../src/print/outline.ts"],"names":[],"mappings":"AACA,OAAO,EAAkB,KAAK,YAAY,EAAE,MAAM,uBAAuB,CAAA;AACzE,OAAO,KAAK,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAA;AAGjE;;;GAGG;AACH,MAAM,WAAW,WAAW;IAC1B,OAAO,EAAE,YAAY,CAAA;IACrB,gEAAgE;IAChE,MAAM,EAAE,MAAM,CAAA;IACd,8DAA8D;IAC9D,KAAK,EAAE,OAAO,CAAA;IACd;;;OAGG;IACH,MAAM,EAAE,OAAO,CAAA;IACf,KAAK,EAAE,MAAM,GAAG,MAAM,CAAA;IACtB,sEAAsE;IACtE,KAAK,CAAC,EAAE;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,KAAK,CAAC,EAAE,MAAM,CAAC;QAAC,OAAO,CAAC,EAAE,MAAM,CAAA;KAAE,CAAA;IACxD;;;OAGG;IACH,GAAG,EAAE,OAAO,CAAA;IACZ;;;;OAIG;IACH,SAAS,EAAE,KAAK,CAAC,YAAY,CAAC,CAAA;CAC/B;AAED,wEAAwE;AACxE,MAAM,WAAW,WAAW;IAC1B,OAAO,EAAE,YAAY,CAAA;IACrB,mDAAmD;IACnD,MAAM,EAAE,MAAM,CAAA;IACd,6DAA6D;IAC7D,KAAK,EAAE,MAAM,CAAA;CACd;AAED,MAAM,WAAW,YAAY;IAC3B,EAAE,EAAE,MAAM,CAAA;IACV,MAAM,EAAE,MAAM,CAAA;IACd,KAAK,EAAE,MAAM,CAAA;IACb,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,OAAO,EAAE,KAAK,CAAC,WAAW,CAAC,CAAA;IAC3B,OAAO,EAAE,KAAK,CAAC,WAAW,CAAC,CAAA;CAC5B;AAED,oDAAoD;AACpD,MAAM,WAAW,SAAS;IACxB,EAAE,EAAE,MAAM,CAAA;IACV,KAAK,EAAE,MAAM,CAAA;IACb,MAAM,CAAC,EAAE,MAAM,CAAA;CAChB;AAED,MAAM,WAAW,YAAY;IAC3B,QAAQ,EAAE,KAAK,CAAC,YAAY,CAAC,CAAA;IAC7B,6DAA6D;IAC7D,QAAQ,EAAE,KAAK,CAAC,YAAY,CAAC,CAAA;IAC7B,0EAA0E;IAC1E,IAAI,EAAE,KAAK,CAAC,WAAW,CAAC,CAAA;IACxB,KAAK,EAAE,KAAK,CAAC,SAAS,CAAC,CAAA;IACvB,6EAA6E;IAC7E,OAAO,EAAE,KAAK,CAAC,MAAM,CAAC,CAAA;IACtB;;;;OAIG;IACH,SAAS,EAAE,MAAM,CAAA;IACjB;;;;OAIG;IACH,SAAS,EAAE,KAAK,CAAC,YAAY,CAAC,CAAA;IAC9B,WAAW,EAAE,MAAM,CAAA;IACnB,WAAW,EAAE,MAAM,CAAA;CACpB;AAwCD;;;;;;;;;GASG;AACH,wBAAgB,YAAY,CAC1B,MAAM,EAAE,WAAW,EACnB,aAAa,EAAE,MAAM,EACrB,UAAU,EAAE,MAAM,GACjB,YAAY,CAoLd"}

package/dist/lens/print/palette.d.ts

@@ -0,0 +1,23 @@
+import type { Theme } from '../contract';
+import type { PrintReport } from '../runtime/print';
+/**
+ * One colour per name, for the whole report.
+ *
+ * On screen a panel is looked at alone, so colouring its rows by position is
+ * enough. Bound into one document that stops being true: «Операционные
+ * расходы» was green in the result bridge and blue in the expense ring three
+ * pages later, and a reader who has learned the first legend is misled by the
+ * second. So the report assigns a colour to a *name* once, in reading order,
+ * and every figure that mentions that name again uses it.
+ *
+ * A producer that pinned a colour to a label keeps it: an authored
+ * `theme.series[label]` always wins.
+ */
+export declare function buildLabelPalette(report: PrintReport): Map<string, string>;
+/**
+ * The document theme as the printed report reads it: the shared label palette
+ * folded into `theme.series`, with the panel-positional entries dropped so a
+ * chart and the table under it cannot disagree about which colour a row is.
+ */
+export declare function printTheme(theme: Theme, labels: Map<string, string>): Theme;
+//# sourceMappingURL=palette.d.ts.map

package/dist/lens/print/palette.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"palette.d.ts","sourceRoot":"","sources":["../../src/print/palette.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,aAAa,CAAA;AACxC,OAAO,KAAK,EAAE,WAAW,EAAgB,MAAM,kBAAkB,CAAA;AAGjE;;;;;;;;;;;;GAYG;AACH,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,WAAW,GAAG,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAmB1E;AAWD;;;;GAIG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,KAAK,CAU3E"}

package/dist/lens/print/quality.d.ts

@@ -0,0 +1,32 @@
+import type { Availability, Confidence } from '../contract';
+import { type QualityInput } from '../panels/QualityChip';
+/**
+ * Data quality on paper.
+ *
+ * On screen every number carries a chip saying how it was obtained — verified,
+ * calculated, a proxy, or not available at all — and the chip's tooltip repeats
+ * the word. The printed report dropped both, so a management estimate and a
+ * ledger figure sat side by side looking equally settled. The chip prints; what
+ * the chip means prints once per chapter, as a footnote.
+ */
+export type Translate = (key: string, fallback: string, vars?: Record<string, string | number>) => string;
+/** The chip's own word: the same catalogue the dashboard uses, no icon. */
+export declare function qualityLabel(input: QualityInput, translate: Translate): string | undefined;
+/**
+ * What the chip means, for a reader who cannot hover it. Only qualities that
+ * change how a figure may be used are explained: "verified" and "calculated"
+ * are the ordinary case and would turn every page into boilerplate.
+ */
+export declare function qualityFootnote(input: QualityInput, translate: Translate): string | undefined;
+export interface QualityDefinition {
+    value: string;
+    label: string;
+    definition: string;
+}
+/** The quality vocabulary this document actually used, in a fixed reading order. */
+export declare function qualityDefinitions(inputs: Array<QualityInput>, translate: Translate): Array<QualityDefinition>;
+export declare function PrintQualityChip({ confidence, availability }: {
+    confidence?: Confidence;
+    availability?: Availability;
+}): import("react/jsx-runtime").JSX.Element | null;
+//# sourceMappingURL=quality.d.ts.map

package/dist/lens/print/quality.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"quality.d.ts","sourceRoot":"","sources":["../../src/print/quality.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,UAAU,EAAE,MAAM,aAAa,CAAA;AAC3D,OAAO,EAAkB,KAAK,YAAY,EAAE,MAAM,uBAAuB,CAAA;AAKzE;;;;;;;;GAQG;AAEH,MAAM,MAAM,SAAS,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAAC,KAAK,MAAM,CAAA;AAEzG,2EAA2E;AAC3E,wBAAgB,YAAY,CAAC,KAAK,EAAE,YAAY,EAAE,SAAS,EAAE,SAAS,GAAG,MAAM,GAAG,SAAS,CAG1F;AAED;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,YAAY,EAAE,SAAS,EAAE,SAAS,GAAG,MAAM,GAAG,SAAS,CAsB7F;AA0CD,MAAM,WAAW,iBAAiB;IAChC,KAAK,EAAE,MAAM,CAAA;IACb,KAAK,EAAE,MAAM,CAAA;IACb,UAAU,EAAE,MAAM,CAAA;CACnB;AAED,oFAAoF;AACpF,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,KAAK,CAAC,YAAY,CAAC,EAAE,SAAS,EAAE,SAAS,GAAG,KAAK,CAAC,iBAAiB,CAAC,CAoB9G;AAED,wBAAgB,gBAAgB,CAAC,EAAE,UAAU,EAAE,YAAY,EAAE,EAAE;IAC7D,UAAU,CAAC,EAAE,UAAU,CAAA;IACvB,YAAY,CAAC,EAAE,YAAY,CAAA;CAC5B,kDASA"}

package/dist/lens/print/units.d.ts

@@ -0,0 +1,23 @@
+import type { FieldFormat } from '../contract';
+/**
+ * How one column of numbers is printed once its unit has been said in the
+ * header rather than on every cell.
+ */
+export interface ColumnUnit {
+    /** The unit, for the column head: «млрд UZS», «UZS», «%». */
+    note?: string;
+    format(value: unknown): string;
+}
+/**
+ * Decides how a whole column of one field prints.
+ *
+ * Two things a table repeats without needing to: the currency, which is the
+ * same three letters on every row, and — when the rows are of comparable size —
+ * the magnitude, which forces a reader to compare «4.00 млрд» against «312.20
+ * млн» digit by digit. Both belong in the column head, said once.
+ *
+ * Returns a formatter that always produces a cell; when nothing can be hoisted
+ * it is `formatFieldValue` unchanged.
+ */
+export declare function columnUnit(values: Array<unknown>, field: FieldFormat | undefined, locale: string): ColumnUnit;
+//# sourceMappingURL=units.d.ts.map

package/dist/lens/print/units.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"units.d.ts","sourceRoot":"","sources":["../../src/print/units.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAA;AAG9C;;;GAGG;AACH,MAAM,WAAW,UAAU;IACzB,6DAA6D;IAC7D,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,MAAM,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAAA;CAC/B;AA2CD;;;;;;;;;;GAUG;AACH,wBAAgB,UAAU,CACxB,MAAM,EAAE,KAAK,CAAC,OAAO,CAAC,EACtB,KAAK,EAAE,WAAW,GAAG,SAAS,EAC9B,MAAM,EAAE,MAAM,GACb,UAAU,CA2CZ"}

package/dist/lens/print/values.d.ts

@@ -0,0 +1,28 @@
+import type { Encoding, FieldFormat, Frame, Panel, PanelKind, Semantics } from '../contract';
+import type { PrintSection } from '../runtime/print';
+/** Panel kinds ChartHost can draw on its own, without a dashboard provider. */
+export declare const chartKinds: Set<PanelKind>;
+/**
+ * Panel kinds whose printed form is a formula rather than a chart with an
+ * evidence table: the structure — operators, indent, direction — is the
+ * reading, and a two-column table of the same numbers is not a substitute.
+ */
+export declare const formulaKinds: Set<PanelKind>;
+export type ChartKind = 'pie' | 'donut' | 'radial' | 'bar' | 'hbar' | 'line' | 'area';
+export declare function numeric(value: unknown): number | undefined;
+export declare function text(value: unknown): string;
+export declare function indexOf(frame: Frame, field: string | undefined): number;
+export declare function formatsForEncoding(panel: Panel, encoding: Encoding): Record<string, FieldFormat>;
+export declare function viewFor(semantics: Semantics, preferred: PanelKind): PanelKind;
+/**
+ * The panel a section prints as: the authored panel for a root section, and the
+ * drill level's own view, encoding and formats below it.
+ */
+export declare function sectionPanel(section: PrintSection): Panel;
+/**
+ * Row-identical frames print once. Drill levels frequently restate their
+ * parent's rows, and two perspectives over the same cut resolve to the same
+ * numbers; a printed audit gains nothing from the repetition.
+ */
+export declare function frameSignature(frame: Frame | undefined): string | undefined;
+//# sourceMappingURL=values.d.ts.map

package/dist/lens/print/values.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"values.d.ts","sourceRoot":"","sources":["../../src/print/values.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,WAAW,EAAE,KAAK,EAAE,KAAK,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,aAAa,CAAA;AAE5F,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAA;AAEpD,+EAA+E;AAC/E,eAAO,MAAM,UAAU,gBAAgF,CAAA;AAEvG;;;;GAIG;AACH,eAAO,MAAM,YAAY,gBAAiF,CAAA;AAE1G,MAAM,MAAM,SAAS,GAAG,KAAK,GAAG,OAAO,GAAG,QAAQ,GAAG,KAAK,GAAG,MAAM,GAAG,MAAM,GAAG,MAAM,CAAA;AAErF,wBAAgB,OAAO,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,GAAG,SAAS,CAO1D;AAED,wBAAgB,IAAI,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAK3C;AAED,wBAAgB,OAAO,CAAC,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM,GAAG,SAAS,GAAG,MAAM,CAEvE;AAED,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,KAAK,EAAE,QAAQ,EAAE,QAAQ,GAAG,MAAM,CAAC,MAAM,EAAE,WAAW,CAAC,CAOhG;AAED,wBAAgB,OAAO,CAAC,SAAS,EAAE,SAAS,EAAE,SAAS,EAAE,SAAS,GAAG,SAAS,CAO7E;AAED;;;GAGG;AACH,wBAAgB,YAAY,CAAC,OAAO,EAAE,YAAY,GAAG,KAAK,CAiBzD;AAED;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,KAAK,GAAG,SAAS,GAAG,MAAM,GAAG,SAAS,CAG3E"}

package/dist/lens/print-CwcB0fug.js

@@ -0,0 +1,216 @@
+import { w as B, j as G, v as Q, k as V, l as z, m as W, p as X, n as Y, q as Z } from "./index-C45DAO6w.js";
+function p(i) {
+  return Object.values(i.frames)[0];
+}
+function D(i, m, a, k) {
+  return JSON.stringify([i.snapshotId, m.id, a, (k == null ? void 0 : k.id) ?? ""]);
+}
+function tt(i) {
+  return i.urlSource ? i.urlSource.kind === "field" : i.params.some((m) => m.source.kind === "field") || Object.values(i.payload).some((m) => m.kind === "field");
+}
+function et(i, m, a) {
+  var u, P;
+  const k = [], L = (o, I, v) => {
+    (o == null ? void 0 : o.kind) === "open_drawer" && k.push({ action: o, label: I, ...v ? { row: v } : {} });
+  }, y = (o, I) => {
+    !o || o.kind !== "open_drawer" || a && tt(o) || L(o, I, a == null ? void 0 : a.rows[0]);
+  };
+  for (const o of i.actions) y(o, i.title);
+  for (const o of i.columns ?? []) y(o.action, o.label);
+  for (const o of ((u = i.metricFlow) == null ? void 0 : u.stages) ?? []) y(o.action, o.label);
+  for (const o of ((P = i.metricHierarchy) == null ? void 0 : P.rows) ?? []) y(o.action, o.label);
+  i.metricRelationship && (y(i.metricRelationship.source.action, i.metricRelationship.source.label), y(i.metricRelationship.target.action, i.metricRelationship.target.label));
+  for (const o of m.children) {
+    if (!o.action || o.action.kind !== "open_drawer") continue;
+    const I = a == null ? void 0 : a.rows.find((v) => {
+      var j;
+      const T = ((j = m.encoding) == null ? void 0 : j.id) ?? i.encoding.id, N = T ? a.columns.findIndex(({ name: x }) => x === T) : -1;
+      return N >= 0 && String(v[N]) === o.key;
+    });
+    L(o.action, o.label, I);
+  }
+  return k;
+}
+async function nt(i, m, a = 2e3, k, L = new URL(
+  typeof globalThis.location > "u" ? "http://localhost/" : globalThis.location.href
+), y) {
+  var U, H;
+  const u = [], P = [];
+  let o = !1;
+  const I = /* @__PURE__ */ new Set(), v = /* @__PURE__ */ new Map(), T = /* @__PURE__ */ new Set(), N = /* @__PURE__ */ new Set(), j = /* @__PURE__ */ new Map(), x = [], _ = (s) => {
+    var l, e;
+    return JSON.stringify([
+      s.meta.dashboardId,
+      ((l = s.drawer) == null ? void 0 : l.title) ?? "",
+      ((e = s.header) == null ? void 0 : e.title) ?? ""
+    ]);
+  };
+  N.add(_(i));
+  const F = () => y != null && y.aborted ? (o = !0, !0) : !1, A = (s, l, e, r) => {
+    if (!m || F()) return Promise.resolve(void 0);
+    const d = JSON.stringify([s.snapshotId, e, (r == null ? void 0 : r.id) ?? ""]), t = j.get(d);
+    if (t) return t;
+    const h = m({
+      snapshotId: s.snapshotId,
+      path: Z(s, e),
+      ...r ? { perspective: r.id } : {}
+    }, s).then((R) => {
+      var n;
+      return (n = R.page) != null && n.hasNext && T.add(d), p(R);
+    }).catch((R) => {
+      const n = R instanceof Error ? R.message : "query request failed";
+      P.push(`${s.meta.title} › ${l.label}: ${n}`);
+    });
+    return j.set(d, h), h;
+  }, K = async (s, l, e, r, d) => {
+    if (F()) return;
+    if (e > 12) {
+      P.push(`${s.meta.title}: nested detail depth exceeds 12 levels`);
+      return;
+    }
+    let t = B(s);
+    const h = (n, f, c, $, g) => {
+      if (k)
+        for (const q of et(n, f, c)) {
+          if (F()) break;
+          const w = G(q.action, {
+            fields: q.row && c ? V(c, q.row) : {},
+            variables: Q(L),
+            location: L
+          });
+          if (!w) continue;
+          const O = r ?? n.id, b = v.get(w);
+          if (b) {
+            b.includes(O) || b.push(O);
+            continue;
+          }
+          v.set(w, [O]), x.push({ href: w, candidate: q, breadcrumb: $, depth: g, owner: O });
+        }
+    }, R = async (n, f, c, $, g, q) => {
+      if (F()) return;
+      if (u.length >= a)
+        throw new Error(`print report exceeds ${a} sections`);
+      const w = z(t, f);
+      if (!w) return;
+      const O = D(t, n, f, c);
+      if (I.has(O)) return;
+      if (I.add(O), W(t, w)) {
+        const E = X(t, w);
+        await Promise.all(E.map((J) => {
+          const S = t.drill.edges[J.root];
+          if (!(!S || S.frame && t.frames[S.frame]))
+            return A(t, S, S.path, J);
+        }));
+        for (const J of E) {
+          if (F()) break;
+          const S = t.drill.edges[J.root];
+          S && await R(n, S.path, J, [...$, J.label], g, !1);
+        }
+        return;
+      }
+      let b = w.frame ? t.frames[w.frame] : void 0;
+      b || (b = await A(t, w, f, c)), b != null && b.children && (t = Y(t, f, b));
+      const C = z(t, f) ?? w, M = C.label.trim() || n.title;
+      u.push({
+        id: `${n.id}:${u.length}`,
+        document: t,
+        panel: n,
+        level: C,
+        frame: b,
+        path: [...f],
+        breadcrumb: [...l, ...$, M],
+        perspective: c,
+        depth: e + g,
+        root: q && e === 0,
+        // Only the drawer's own top level is the reading's explanation. Its
+        // drill levels are detail like any other and belong in the appendix —
+        // a KPI tile cannot hold sixty quarters of history.
+        ...r && g === 0 ? { owner: r } : {},
+        ...d && g === 0 ? { origin: d } : {},
+        ...T.has(JSON.stringify([t.snapshotId, f, (c == null ? void 0 : c.id) ?? ""])) ? { hasMore: !0 } : {}
+      }), h(
+        n,
+        C,
+        b,
+        [...l, ...$, M],
+        e + g + 1
+      );
+      for (const E of C.children) {
+        if (F()) break;
+        E.target && await R(
+          n,
+          [...f, E.key],
+          c,
+          [...$, M, E.label],
+          g + 1,
+          !1
+        );
+      }
+    };
+    for (const n of t.panels) {
+      if (F()) break;
+      if (u.length >= a)
+        throw new Error(`print report exceeds ${a} sections`);
+      if (!n.drillRoot) {
+        const c = t.frames[n.frame], $ = {
+          path: [],
+          label: n.title,
+          children: [],
+          perspectives: [],
+          ...c ? { frame: n.frame } : {}
+        }, g = [...l, n.title];
+        u.push({
+          id: `${n.id}:${u.length}`,
+          document: t,
+          panel: n,
+          level: $,
+          frame: c,
+          path: [],
+          breadcrumb: g,
+          depth: e,
+          root: e === 0,
+          ...r ? { owner: r } : {},
+          ...d ? { origin: d } : {}
+        }), h(n, $, c, g, e + 1);
+        continue;
+      }
+      const f = t.drill.edges[n.drillRoot];
+      f && await R(n, f.path, void 0, [], 0, !0);
+    }
+  };
+  for (await K(i, [], 0); x.length > 0 && !F(); ) {
+    const s = x.splice(0, 4), l = await Promise.all(s.map(async (e) => {
+      try {
+        return { entry: e, document: await k(e.href) };
+      } catch (r) {
+        const d = r instanceof Error ? r.message : "document request failed";
+        return P.push(`${e.candidate.label}: ${d}`), { entry: e, document: void 0 };
+      }
+    }));
+    for (const { entry: e, document: r } of l) {
+      if (!r || F()) continue;
+      const d = _(r);
+      if (N.has(d)) continue;
+      N.add(d);
+      const t = ((U = r.drawer) == null ? void 0 : U.title) || ((H = r.header) == null ? void 0 : H.title) || r.meta.title, h = e.candidate.label && e.candidate.label !== e.breadcrumb.at(-1) ? [...e.breadcrumb, e.candidate.label] : e.breadcrumb;
+      await K(
+        r,
+        t && t !== h.at(-1) ? [...h, t] : h,
+        e.depth,
+        e.owner,
+        e.href
+      );
+    }
+  }
+  for (const [s, l] of v) {
+    if (l.length < 2) continue;
+    const [e, ...r] = l, d = u.filter((t) => t.origin === s && t.owner === e);
+    for (const t of r)
+      for (const h of d)
+        u.push({ ...h, id: `${h.id}:${t}`, owner: t });
+  }
+  return { document: i, sections: u, warnings: P, truncated: o };
+}
+export {
+  nt as buildPrintReport
+};

package/dist/lens/runtime/clipboard.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Put text on the clipboard, from wherever the runtime is embedded.
+ *
+ * Three paths, in order: the async clipboard API; the legacy selection copy for
+ * an insecure context or a rejected permission; and silence. Silence is a real
+ * outcome and not a failure to report — every value this copies is also on
+ * screen to read, and a thrown error out of a click handler would take the
+ * dashboard down for a convenience.
+ */
+export declare function copyText(text: string): Promise<void>;
+//# sourceMappingURL=clipboard.d.ts.map

package/dist/lens/runtime/clipboard.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"clipboard.d.ts","sourceRoot":"","sources":["../../src/runtime/clipboard.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,wBAAsB,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAuB1D"}

package/dist/lens/runtime/document.d.ts

@@ -0,0 +1,9 @@
+import { type DashboardDocument } from '../contract';
+export interface DocumentRequestOptions {
+    csrf?: string;
+    signal?: AbortSignal;
+    fetcher?: typeof fetch;
+    prefetch?: boolean;
+}
+export declare function fetchDocument(src: string, options?: DocumentRequestOptions): Promise<DashboardDocument>;
+//# sourceMappingURL=document.d.ts.map

package/dist/lens/runtime/document.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"document.d.ts","sourceRoot":"","sources":["../../src/runtime/document.ts"],"names":[],"mappings":"AAAA,OAAO,EAAiB,KAAK,iBAAiB,EAAE,MAAM,aAAa,CAAA;AAEnE,MAAM,WAAW,sBAAsB;IACrC,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,MAAM,CAAC,EAAE,WAAW,CAAA;IACpB,OAAO,CAAC,EAAE,OAAO,KAAK,CAAA;IACtB,QAAQ,CAAC,EAAE,OAAO,CAAA;CACnB;AAED,wBAAsB,aAAa,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,GAAE,sBAA2B,GAAG,OAAO,CAAC,iBAAiB,CAAC,CAWjH"}

package/dist/lens/runtime/drawer.d.ts

@@ -0,0 +1,21 @@
+import { type ReactNode } from 'react';
+interface LensDrawerProps {
+    children: ReactNode;
+    closeLabel: string;
+    /**
+     * The drawer can stack on top of an expanded panel, which is itself a
+     * body-level portal. So the drawer carries the theme of the dashboard root it
+     * came from, mirroring PanelOverlay, or every `--lens-*` custom property on
+     * the portaled subtree resolves to its fallback.
+     */
+    dark?: boolean;
+    /** Fallback eyebrow used until the document supplies its own drawer header. */
+    eyebrow: string;
+    label: string;
+    onClose: () => void;
+    restoreFocus?: HTMLElement;
+    theme?: string;
+}
+export declare function LensDrawer({ children, closeLabel, dark, eyebrow, label, onClose, restoreFocus, theme }: LensDrawerProps): import("react/jsx-runtime").JSX.Element;
+export {};
+//# sourceMappingURL=drawer.d.ts.map

package/dist/lens/runtime/drawer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"drawer.d.ts","sourceRoot":"","sources":["../../src/runtime/drawer.tsx"],"names":[],"mappings":"AACA,OAAO,EAAU,KAAK,SAAS,EAAE,MAAM,OAAO,CAAA;AAI9C,UAAU,eAAe;IACvB,QAAQ,EAAE,SAAS,CAAA;IACnB,UAAU,EAAE,MAAM,CAAA;IAClB;;;;;OAKG;IACH,IAAI,CAAC,EAAE,OAAO,CAAA;IACd,+EAA+E;IAC/E,OAAO,EAAE,MAAM,CAAA;IACf,KAAK,EAAE,MAAM,CAAA;IACb,OAAO,EAAE,MAAM,IAAI,CAAA;IACnB,YAAY,CAAC,EAAE,WAAW,CAAA;IAC1B,KAAK,CAAC,EAAE,MAAM,CAAA;CACf;AAED,wBAAgB,UAAU,CAAC,EAAE,QAAQ,EAAE,UAAU,EAAE,IAAY,EAAE,OAAO,EAAE,KAAK,EAAE,OAAO,EAAE,YAAY,EAAE,KAAK,EAAE,EAAE,eAAe,2CAuD/H"}

package/dist/lens/runtime/drill.d.ts

@@ -0,0 +1,54 @@
+import type { DashboardDocument, Frame, Level, NodePath, Panel, Perspective } from '../contract';
+import type { NavigationView } from './navigation';
+export declare function sameNodePath(left: NodePath, right: NodePath): boolean;
+interface ResolvedDrillPath {
+    level: Level;
+    queryPath: NodePath;
+}
+/**
+ * Resolves a navigation path to the level it addresses. A path is an owning
+ * level's canonical path followed by zero or more child keys, each a concrete
+ * selection (a point, or the "other" bucket) whose edge leads to the next
+ * level. Levels reached through a point are parameterised by it — the same
+ * node aggregates 2025 or 2024 depending on which slice was entered — so the
+ * selection has to survive in the path instead of collapsing onto the target
+ * node's canonical ancestry.
+ *
+ * `queryPath` is the same walk in the wire shape the snapshot query endpoint
+ * parses: each selection interleaved with the node it selects into
+ * (`[…, root, "2026", detail, "direct", detail-2]`).
+ */
+export declare function resolveDrillPath(document: DashboardDocument, path: NodePath): ResolvedDrillPath | undefined;
+export declare function levelForPath(document: DashboardDocument, path: NodePath): Level | undefined;
+/**
+ * The wire path for a navigation path: selections interleaved with the nodes
+ * they select into. An unresolvable path passes through unchanged so the
+ * server, not the client, owns the rejection.
+ */
+export declare function queryPathForNavigation(document: DashboardDocument, path: NodePath): NodePath;
+/**
+ * A fork in the drill path: a node that carries no data of its own because its
+ * perspectives (which branch off it) own it. Panels must not draw anything at
+ * such a node until a perspective is chosen — the parent's numbers under the
+ * child's title read as fact and are wrong.
+ */
+export declare function isPerspectiveFork(document: DashboardDocument, level: Level): boolean;
+/**
+ * The perspectives a user can stand on at a drill position. A level that IS a
+ * perspective's root offers its branch's whole sibling set — the same choice
+ * the overlay offered on the segment that led here — even when the document
+ * recorded only the level's own perspective on it (the builder attaches one
+ * ref per perspective node). Any other level offers exactly what it declares,
+ * so deeper nodes inside a perspective never advertise a switch that would
+ * silently jump them back to a sibling's root.
+ */
+export declare function perspectivesForPosition(document: DashboardDocument, level: Level | undefined): Array<Perspective>;
+export declare function pathResolves(document: DashboardDocument, path: NodePath, perspectiveId?: string): boolean;
+export declare function panelForNavigation(document: DashboardDocument, view: NavigationView): Panel | undefined;
+export declare function rootNavigation(document: DashboardDocument, panelId?: string): NavigationView;
+export declare function replayNavigation(document: DashboardDocument, view: NavigationView): NavigationView | undefined;
+export declare function dynamicParentPath(document: DashboardDocument, path: NodePath): NodePath | undefined;
+export declare function withFrameChildren(document: DashboardDocument, path: NodePath, frame: Frame): DashboardDocument;
+export declare function withInlineFrameChildren(document: DashboardDocument): DashboardDocument;
+export {};
+//# sourceMappingURL=drill.d.ts.map