angular-my-report 0.1.0 → 0.1.1

package/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+/// <amd-module name="angular-my-report" />
+export * from './public-api';

package/lib/engine/barcode.d.ts

@@ -0,0 +1,17 @@
+import type { BarcodeSymbology } from '../model/types';
+export interface BarcodeResult {
+    /** One char per module: '1' = bar, '0' = space. Empty when `error` is set. */
+    modules: string;
+    /** Human-readable text printed under the bars. */
+    text: string;
+    error?: string;
+}
+/**
+ * Code 128: code set B for text, switching to code set C for runs of 4+ digits (denser).
+ * Supports printable ASCII (32–126).
+ */
+export declare function encodeCode128(value: string): BarcodeResult;
+export declare function ean13CheckDigit(first12: string): number;
+/** EAN-13 from 12 digits (check digit added) or 13 digits (check digit verified). */
+export declare function encodeEan13(value: string): BarcodeResult;
+export declare function encodeBarcode(symbology: BarcodeSymbology, value: string): BarcodeResult;

package/lib/engine/chart.d.ts

@@ -0,0 +1,26 @@
+import type { ChartSpec } from '../model/types';
+import { type Row } from './expressions';
+/** Validated categorical palette (light surface), assigned in fixed order — never cycled. */
+export declare const SERIES_COLORS: string[];
+export declare const OTHER_COLOR = "#9a9a96";
+export declare const MAX_SERIES: number;
+export interface ChartData {
+    categories: string[];
+    series: {
+        name: string;
+        values: number[];
+        color: string;
+    }[];
+}
+/** Groups rows by category and aggregates each value field into a series. */
+export declare function chartData(spec: ChartSpec, rows: Row[]): ChartData;
+/** Pie slice colors: one fixed-order hue per category, "Other" in neutral gray. */
+export declare const sliceColor: (name: string, i: number) => string;
+/** "Nice" axis: rounded max and tick step for values in [min, max]. */
+export declare function niceScale(min: number, max: number, ticks?: number): {
+    min: number;
+    max: number;
+    step: number;
+};
+/** Short tick label: 1.2K, 3.4M. */
+export declare function compactNumber(n: number): string;

package/lib/engine/chartLayout.d.ts

@@ -0,0 +1,45 @@
+import type { ChartSpec } from '../model/types';
+import { type Row } from './expressions';
+/** SVG drawing primitives (coordinates in element pixels). */
+export type Prim = {
+    t: 'path';
+    d: string;
+    fill: string;
+    stroke?: string;
+    sw?: number;
+    opacity?: number;
+    title?: string;
+} | {
+    t: 'line';
+    x1: number;
+    y1: number;
+    x2: number;
+    y2: number;
+    stroke: string;
+    sw: number;
+} | {
+    t: 'poly';
+    points: string;
+    stroke: string;
+    sw: number;
+} | {
+    t: 'circle';
+    cx: number;
+    cy: number;
+    r: number;
+    fill: string;
+    stroke: string;
+    sw: number;
+    title?: string;
+} | {
+    t: 'text';
+    x: number;
+    y: number;
+    text: string;
+    anchor: 'start' | 'middle' | 'end';
+    size: number;
+    weight: number;
+    fill: string;
+};
+/** Lays out a chart into SVG primitives for a w×h box. */
+export declare function layoutChart(spec: ChartSpec, rows: Row[], w: number, h: number, fontSize: number, textColor: string): Prim[];

package/lib/engine/crosstab.d.ts

@@ -0,0 +1,22 @@
+import type { ReportElement } from '../model/types';
+import { type Row } from './expressions';
+import type { TableRenderData } from './table';
+export interface Pivot {
+    rowKeys: string[];
+    colKeys: string[];
+    /** cells[r][c] = aggregate, null when no rows fall in the cell. */
+    cells: (number | null)[][];
+    rowTotals: (number | null)[];
+    colTotals: (number | null)[];
+    grandTotal: number | null;
+}
+export declare function pivot(el: ReportElement, rows: Row[]): Pivot;
+/**
+ * Turns a cross table into an ordinary table element + data rows (cells pre-formatted), so the
+ * renderer can paginate it with the table code: header repeats, rows flow, totals form the footer.
+ */
+export declare function crosstabAsTable(el: ReportElement, rows: Row[]): {
+    table: ReportElement;
+    data: Row[];
+    render: TableRenderData;
+};

package/lib/engine/dataSources.d.ts

@@ -0,0 +1,35 @@
+import type { DataSourceDef } from '../model/types';
+import { type Row } from './expressions';
+export type FieldType = 'string' | 'number' | 'boolean' | 'date' | 'object';
+export interface FieldInfo {
+    name: string;
+    type: FieldType;
+}
+export interface LoadResult {
+    rows: Row[];
+    fields: FieldInfo[];
+    requestUrl: string;
+    /** Non-fatal note, e.g. the array path was not found and auto-detect was used. */
+    warning?: string;
+    /** The whole JSON document (first page for OData), readable in formulas as root.x. */
+    root?: unknown;
+}
+export declare function parseHeaders(text: string): Record<string, string>;
+export declare const hasSource: (ds: DataSourceDef) => boolean;
+export declare function buildODataUrl(ds: DataSourceDef): string;
+export declare function loadData(ds: DataSourceDef, signal?: AbortSignal): Promise<LoadResult>;
+/** Infers field names (flattening nested objects into dot paths) from a sample of rows. */
+export declare function inferFields(rows: Row[]): FieldInfo[];
+/** Lists entity sets from an OData service ($metadata XML, falling back to the JSON service document). */
+export declare function loadODataEntitySets(serviceUrl: string, headersText: string): Promise<string[]>;
+export interface DetectedSource {
+    dataSource: DataSourceDef;
+    /** Human-readable summary of what was detected. */
+    note: string;
+}
+/**
+ * Builds a data source from a pasted URL: fetches it once and decides between plain JSON and OData
+ * (OData responses carry @odata.context / odata.metadata / a "d" wrapper). An OData service root
+ * is resolved to its first entity set. Previous settings (array path, query options) are reset.
+ */
+export declare function detectDataSource(rawUrl: string, headers?: string): Promise<DetectedSource>;

package/lib/engine/expressions.d.ts

@@ -0,0 +1,46 @@
+import type { FormatSpec } from '../model/types';
+export type Row = Record<string, unknown>;
+export interface EvalContext {
+    row: Row | undefined;
+    /** Rows in the current scope (current group, or all rows for report bands). */
+    rows: Row[];
+    allRows: Row[];
+    pageRows: Row[];
+    rowNumber: number;
+    pageNumber: number;
+    totalPages: number;
+    reportName: string;
+    /** Report parameter values, by name. */
+    params?: Record<string, unknown>;
+    /** The whole loaded document (e.g. a receipt object whose items are the rows); read as root.x. */
+    root?: unknown;
+}
+export declare function getPath(obj: unknown, path: string): unknown;
+export declare const truthy: (v: unknown) => boolean;
+export declare const AGGREGATES: string[];
+/** Aggregates a field (or expression) over rows — used by charts and cross tables. */
+export declare function aggregate(fn: string, field: string, rows: Row[]): unknown;
+/** Evaluates one expression (the part inside `{}`). */
+export declare function evaluate(expr: string, ctx: EvalContext): unknown;
+/** Parse error message for an expression, or null when valid. */
+export declare function checkExpression(expr: string): string | null;
+/** First parse error among the `{…}` parts of a template, or null. */
+export declare function checkTemplate(template: string): string | null;
+/** yyyy yy MMM MM M dd d HH H mm ss */
+export declare function formatDatePattern(d: Date, pattern: string): string;
+export declare function formatValue(v: unknown, f: FormatSpec): string;
+/** Replaces every `{expr}` in the template with its formatted value. */
+export declare function renderTemplate(template: string, ctx: EvalContext, format: FormatSpec): string;
+export interface FunctionInfo {
+    name: string;
+    signature: string;
+    description: string;
+    group: 'Aggregate' | 'Logic' | 'Text' | 'Math' | 'Date' | 'Format';
+}
+export declare const FUNCTIONS: FunctionInfo[];
+export declare const SPECIAL_FIELDS: string[];
+/** Scalar values of a document as root.x paths (arrays skipped) — for the field list and autocomplete. */
+export declare function documentFields(root: unknown): {
+    name: string;
+    type: string;
+}[];

package/lib/engine/measure.d.ts

@@ -0,0 +1,7 @@
+import type { ReportElement } from '../model/types';
+/** Must match the line-height used by ElementBox when rendering text. */
+export declare const LINE_HEIGHT = 1.2;
+/** Whether the element grows vertically to fit its text (default: on for text and fields). */
+export declare const canGrow: (el: ReportElement) => boolean;
+/** Height (px) the element needs to show `text` fully at its current width, wrapping like the renderer. */
+export declare function measureTextHeight(text: string, el: ReportElement): number;

package/lib/engine/parameters.d.ts

@@ -0,0 +1,15 @@
+import type { DataSourceDef, ReportDefinition, ReportParameter } from '../model/types';
+import { type Row } from './expressions';
+export type ParamValues = Record<string, unknown>;
+/** Converts a raw (text) value to the parameter's type. */
+export declare function coerceParam(p: ReportParameter, raw: unknown): unknown;
+/** Default values for all parameters, overridden by `overrides` (e.g. from the page URL). */
+export declare function resolveParams(report: ReportDefinition, overrides?: Record<string, unknown>): ParamValues;
+export declare const paramChoices: (p: ReportParameter) => string[];
+/**
+ * Applies parameters to a data source: `{@Country}` in the URL (URL-encoded), OData options,
+ * headers and array path. Pasted JSON is left alone (it contains braces of its own).
+ */
+export declare function applyParamsToDataSource(ds: DataSourceDef, params: ParamValues): DataSourceDef;
+/** Rows that pass the report filter expression (all rows when there is none). */
+export declare function filterRows(report: ReportDefinition, rows: Row[], params: ParamValues): Row[];

package/lib/engine/qr.d.ts

@@ -0,0 +1,8 @@
+import type { QrSpec } from '../model/types';
+export interface QrResult {
+    /** size × size, true = dark module. */
+    modules: boolean[][];
+    size: number;
+    error?: string;
+}
+export declare function encodeQr(value: string, level: QrSpec['errorCorrection']): QrResult;

package/lib/engine/renderer.d.ts

@@ -0,0 +1,43 @@
+import type { Band, ReportDefinition, ReportElement } from '../model/types';
+import { type EvalContext, type Row } from './expressions';
+import { type ParamValues } from './parameters';
+type BandContext = Pick<EvalContext, 'row' | 'rows' | 'allRows' | 'rowNumber' | 'reportName' | 'params' | 'root'>;
+/** The slice of a table rendered inside one band instance (tables can span pages). */
+export interface PlacedTable {
+    rows: Row[];
+    rowHeights: number[];
+    /** Index of rows[0] within the full table (for striping and RowNumber). */
+    startIndex: number;
+    header: boolean;
+    headerHeight: number;
+    footer: boolean;
+    footerHeight: number;
+}
+export interface PlacedElement {
+    el: ReportElement;
+    top: number;
+    height: number;
+    table?: PlacedTable;
+}
+export interface PlacedBand {
+    band: Band;
+    top: number;
+    /** Actual height of this band instance (>= band.height when fields grew). */
+    height: number;
+    items: PlacedElement[];
+    ctx: BandContext;
+}
+export interface RenderedPage {
+    index: number;
+    bands: PlacedBand[];
+    rows: Row[];
+    /** Set for continuous (receipt) pages: the actual page height. */
+    height?: number;
+}
+/**
+ * Lays out bands onto pages. Text is evaluated later (needs TotalPages).
+ * `params` are the report parameter values (also used by the report filter).
+ */
+export declare function paginate(report: ReportDefinition, inputRows: Row[], params?: ParamValues, root?: unknown): RenderedPage[];
+export declare function contextFor(placed: PlacedBand, page: RenderedPage, totalPages: number): EvalContext;
+export {};

package/lib/engine/table.d.ts

@@ -0,0 +1,22 @@
+import type { ElementStyle, FormatSpec, ReportElement, TableColumn, TableSpec } from '../model/types';
+/** Already-evaluated cell strings for drawing a table (designer and preview). */
+export interface TableRenderData {
+    header: string[] | null;
+    headerHeight: number;
+    rows: {
+        cells: string[];
+        height: number;
+        index: number;
+    }[];
+    footer: string[] | null;
+    footerHeight: number;
+}
+export declare const hasGrid: (t: TableSpec) => boolean;
+/** Pixel width of each column (relative widths scaled to the table width). */
+export declare function columnWidths(el: ReportElement): number[];
+/** Style used for measuring/drawing one cell (1px grid line counts as a border). */
+export declare function tableCellStyle(el: ReportElement, header: boolean): ElementStyle;
+/** Height shown in the designer: header + one sample row + footer. */
+export declare function designTableHeight(t: TableSpec): number;
+export declare function defaultTableSpec(columns: TableColumn[]): TableSpec;
+export declare function createColumn(field: string, type?: string, format?: Partial<FormatSpec>): TableColumn;

package/lib/model/defaults.d.ts

@@ -0,0 +1,31 @@
+import type { Band, BandType, DataSourceDef, ElementKind, ElementStyle, FormatSpec, PageSettings, ReportDefinition, ReportElement } from './types';
+export declare const uid: (prefix?: string) => string;
+export declare const PAGE_SIZES: Record<string, {
+    width: number;
+    height: number;
+}>;
+export declare const BAND_LABELS: Record<BandType, string>;
+export declare const FOOTER_TYPES: BandType[];
+export declare const defaultStyle: () => ElementStyle;
+export declare const defaultFormat: () => FormatSpec;
+export declare function createElement(kind: ElementKind, x: number, y: number, overrides?: Partial<Omit<ReportElement, 'style' | 'format'>> & {
+    style?: Partial<ElementStyle>;
+    format?: Partial<FormatSpec>;
+}): ReportElement;
+/** A table with one column per field (up to 6), or two blank columns. */
+export declare function createTable(x: number, y: number, w: number, fields: {
+    name: string;
+    type?: string;
+}[]): ReportElement;
+export declare const createBand: (type: BandType, height: number, groupId?: string) => Band;
+export declare const emptyDataSource: () => DataSourceDef;
+export declare const defaultPage: () => PageSettings;
+export declare const contentWidth: (p: PageSettings) => number;
+export declare function newReport(): ReportDefinition;
+/** Bands in the order they are laid out on the page. */
+export declare function orderedBands(r: ReportDefinition): Band[];
+/** A ready-made report bound to the bundled sample JSON file. */
+export declare function sampleReport(): ReportDefinition;
+export declare const defaultWatermark: () => import("./types").Watermark;
+export declare const defaultBackground: () => import("./types").PageBackground;
+export declare const defaultFieldOptions: () => import("./types").FieldOptions;

package/lib/model/factories.d.ts

@@ -0,0 +1,31 @@
+import type { ReportDefinition, ReportElement } from './types';
+export interface FieldRef {
+    name: string;
+    type?: string;
+}
+export declare function createChart(x: number, y: number, w: number, fields: FieldRef[]): ReportElement;
+export declare function createBarcode(x: number, y: number, fields: FieldRef[]): ReportElement;
+export declare function createQr(x: number, y: number, fields: FieldRef[]): ReportElement;
+export declare function createCrosstab(x: number, y: number, w: number, fields: FieldRef[]): ReportElement;
+export interface BandedTableOptions {
+    fields: FieldRef[];
+    /** Band that receives the column titles. */
+    titleBand: 'pageHeader' | 'reportHeader' | 'groupHeader';
+    /** For titleBand 'groupHeader': which group. Defaults to the innermost. */
+    groupId?: string;
+    grid: boolean;
+    headerBackground: string;
+    headerColor: string;
+    /** Adds sum() of numeric columns to the Report Footer. */
+    totals: boolean;
+    rowHeight: number;
+    /** Clear the title band and Detail band first (otherwise the table is appended below). */
+    replace: boolean;
+}
+/** Adds the banded table to the report; returns the ids of the created elements. */
+export declare function addBandedTable(r: ReportDefinition, o: BandedTableOptions): string[];
+export declare const RECEIPT_WIDTHS: {
+    readonly 80: 302;
+    readonly 58: 219;
+};
+export declare function receiptReport(paper?: 80 | 58): ReportDefinition;

package/lib/model/types.d.ts

@@ -0,0 +1,244 @@
+export type BandType = 'reportHeader' | 'pageHeader' | 'groupHeader' | 'detail' | 'groupFooter' | 'pageFooter' | 'reportFooter';
+export type ElementKind = 'text' | 'field' | 'line' | 'rect' | 'image' | 'table' | 'chart' | 'barcode' | 'qrcode' | 'crosstab';
+export type HAlign = 'left' | 'center' | 'right';
+export type VAlign = 'top' | 'middle' | 'bottom';
+export interface ElementStyle {
+    fontFamily: string;
+    fontSize: number;
+    bold: boolean;
+    italic: boolean;
+    underline: boolean;
+    color: string;
+    background: string;
+    align: HAlign;
+    vAlign: VAlign;
+    borderWidth: number;
+    borderColor: string;
+    padding: number;
+}
+export type FormatKind = 'none' | 'number' | 'currency' | 'percent' | 'date' | 'datetime' | 'time';
+export interface FormatSpec {
+    kind: FormatKind;
+    decimals: number;
+    currency: string;
+}
+export interface ReportElement {
+    id: string;
+    kind: ElementKind;
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+    /** Template text. `{Field}`, `{sum(Amount)}`, `{PageNumber}`… For images: the URL (may contain {Field}). */
+    text: string;
+    format: FormatSpec;
+    style: ElementStyle;
+    /** Text/field grows taller to fit its content (pushing elements below down). Default true. */
+    canGrow?: boolean;
+    /** Only for kind 'table'. */
+    table?: TableSpec;
+    /** Only for kind 'chart'. */
+    chart?: ChartSpec;
+    /** Only for kind 'barcode' (the value is the `text` template). */
+    barcode?: BarcodeSpec;
+    /** Only for kind 'qrcode' (the value is the `text` template). */
+    qr?: QrSpec;
+    /** Only for kind 'crosstab'. */
+    crosstab?: CrossTabSpec;
+    /** Expression; the element is hidden when it evaluates to false, e.g. "Amount > 100". */
+    visibleWhen?: string;
+    /** Extra options for labels and fields. */
+    fieldOptions?: FieldOptions;
+    /** Lines and rectangles: stroke style. */
+    dash?: 'solid' | 'dashed' | 'dotted';
+    /** Images: how the picture fits its box. */
+    imageFit?: 'contain' | 'cover' | 'fill';
+}
+export interface FieldOptions {
+    /** Shown when the text evaluates to empty. */
+    nullText: string;
+    /** In repeating bands, leave the box empty when the value equals the previous row's (per page). */
+    hideDuplicates: boolean;
+    /** Conditional formatting: first matching rule wins. */
+    rules: StyleRule[];
+}
+export interface StyleRule {
+    /** Expression, e.g. "Amount > 1000". */
+    when: string;
+    color: string;
+    /** '' = unchanged */
+    background: string;
+    bold: boolean;
+}
+export interface TableColumn {
+    id: string;
+    header: string;
+    /** Cell template evaluated per row, e.g. "{Amount}". */
+    text: string;
+    /** Optional footer (totals) template, e.g. "{sum(Amount)}". */
+    footer: string;
+    /** Relative width; columns share the table width in proportion. */
+    width: number;
+    align: HAlign;
+    format: FormatSpec;
+}
+/**
+ * A table lists the rows in its band's scope: all rows in Report Header/Footer, the group's
+ * rows in Group Header/Footer, the current record in Detail. It flows across pages.
+ */
+export interface TableSpec {
+    columns: TableColumn[];
+    showHeader: boolean;
+    repeatHeader: boolean;
+    showFooter: boolean;
+    headerHeight: number;
+    rowHeight: number;
+    headerBackground: string;
+    headerColor: string;
+    /** Alternate-row background or 'transparent'. */
+    stripeBackground: string;
+    /** Grid line color or 'transparent'. */
+    gridColor: string;
+}
+export interface Band {
+    id: string;
+    type: BandType;
+    height: number;
+    visible: boolean;
+    groupId?: string;
+    elements: ReportElement[];
+}
+export interface Group {
+    id: string;
+    field: string;
+    direction: 'asc' | 'desc';
+}
+export interface SortSpec {
+    field: string;
+    direction: 'asc' | 'desc';
+}
+export interface PageSettings {
+    width: number;
+    height: number;
+    marginTop: number;
+    marginBottom: number;
+    marginLeft: number;
+    marginRight: number;
+    /** Receipt roll: one page as long as its content, no page breaks; the page footer follows the content. */
+    continuous?: boolean;
+}
+export type DataSourceType = 'json' | 'odata';
+export interface DataSourceDef {
+    type: DataSourceType;
+    /** JSON: file/API URL. OData: service root URL (or full entity-set URL). */
+    url: string;
+    /** JSON only: pasted JSON used instead of the URL when non-empty. */
+    inline: string;
+    /** JSON only: dot path to the array inside the response, e.g. "data.items". */
+    dataPath: string;
+    /** Extra request headers, one "Name: value" per line. */
+    headers: string;
+    entitySet: string;
+    select: string;
+    filter: string;
+    orderby: string;
+    expand: string;
+    top: number | null;
+    /** Safety cap when following OData nextLink paging. */
+    maxRows: number;
+}
+export interface ReportDefinition {
+    version: 1;
+    name: string;
+    page: PageSettings;
+    dataSource: DataSourceDef;
+    groups: Group[];
+    sort: SortSpec[];
+    bands: Band[];
+    /** Values the user supplies at run time; used as @Name in formulas and {@Name} in the data source. */
+    parameters?: ReportParameter[];
+    /** Expression applied to every data row; rows where it is false are left out, e.g. "Country == @Country". */
+    filter?: string;
+    watermark?: Watermark;
+    background?: PageBackground;
+}
+export type ParameterType = 'string' | 'number' | 'date' | 'boolean';
+export interface ReportParameter {
+    name: string;
+    label: string;
+    type: ParameterType;
+    defaultValue: string;
+    /** Comma-separated choices; empty = free input. */
+    options: string;
+}
+export interface Watermark {
+    enabled: boolean;
+    kind: 'text' | 'image';
+    text: string;
+    /** URL or data: URL. */
+    image: string;
+    /** 0–1 */
+    opacity: number;
+    /** Degrees, e.g. -45. */
+    angle: number;
+    fontSize: number;
+    color: string;
+    bold: boolean;
+    /** Image width as % of the page width. */
+    imageScale: number;
+    layer: 'behind' | 'front';
+    pages: 'all' | 'first';
+}
+export interface PageBackground {
+    enabled: boolean;
+    /** URL or data: URL. */
+    image: string;
+    fit: 'cover' | 'contain' | 'stretch' | 'center';
+    pages: 'all' | 'first';
+}
+export type AggregateKind = 'sum' | 'count' | 'avg' | 'min' | 'max';
+export type ChartType = 'bar' | 'hbar' | 'line' | 'area' | 'pie' | 'doughnut';
+/** A chart over the rows in its band's scope, grouped by a category field. */
+export interface ChartSpec {
+    type: ChartType;
+    title: string;
+    categoryField: string;
+    /** One series per value field (pie/doughnut use the first). */
+    valueFields: string[];
+    aggregate: AggregateKind;
+    sort: 'none' | 'category' | 'valueDesc' | 'valueAsc';
+    /** Extra categories fold into "Other". */
+    maxCategories: number;
+    showLegend: boolean;
+    showValues: boolean;
+    showGrid: boolean;
+    valueFormat: FormatSpec;
+}
+export type BarcodeSymbology = 'code128' | 'ean13';
+export interface BarcodeSpec {
+    symbology: BarcodeSymbology;
+    showText: boolean;
+    color: string;
+}
+export interface QrSpec {
+    errorCorrection: 'L' | 'M' | 'Q' | 'H';
+    color: string;
+}
+/** Pivot: one row per rowField value, one column per columnField value, cells = aggregate(valueField). */
+export interface CrossTabSpec {
+    rowField: string;
+    columnField: string;
+    valueField: string;
+    aggregate: AggregateKind;
+    cornerText: string;
+    showRowTotals: boolean;
+    showColumnTotals: boolean;
+    valueFormat: FormatSpec;
+    headerHeight: number;
+    rowHeight: number;
+    headerBackground: string;
+    headerColor: string;
+    stripeBackground: string;
+    gridColor: string;
+    repeatHeader: boolean;
+}

package/lib/ui/css.d.ts

@@ -0,0 +1,2 @@
+/** Builds an inline style string from a camelCase map; numbers get "px" unless unitless. */
+export declare function css(o: Record<string, string | number | undefined | null | false>): string;

package/lib/ui/designer/banded-table-dialog.component.d.ts

@@ -0,0 +1,27 @@
+import { type BandedTableOptions } from '../../model/factories';
+import * as i0 from "@angular/core";
+/**
+ * Header/Detail table wizard: titles go in a header band, one field per column in Detail.
+ * Everything it creates is ordinary labels/fields, editable afterwards.
+ */
+export declare class BandedTableDialogComponent {
+    private readonly store;
+    readonly closed: import("@angular/core").OutputEmitterRef<void>;
+    protected readonly fields: import("@angular/core").Signal<import("angular-my-report").FieldInfo[]>;
+    protected readonly hasGroups: import("@angular/core").Signal<boolean>;
+    protected readonly picked: import("@angular/core").WritableSignal<Record<string, boolean>>;
+    protected readonly selectedCount: import("@angular/core").Signal<number>;
+    protected titleBand: BandedTableOptions['titleBand'];
+    protected rowHeight: number;
+    protected headerBackground: string;
+    protected headerColor: string;
+    protected grid: boolean;
+    protected totals: boolean;
+    protected replace: boolean;
+    protected onBackdropDown(e: PointerEvent): void;
+    protected toggle(name: string, on: boolean): void;
+    protected all(on: boolean): void;
+    protected create(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BandedTableDialogComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BandedTableDialogComponent, "rpt-banded-table-dialog", never, {}, { "closed": "closed"; }, never, never, true, never>;
+}