@object-ui/plugin-report 6.2.3 → 7.1.0

package/dist/packages/plugin-report/src/MatrixRenderer.d.ts

@@ -1,51 +0,0 @@
-import { ActionRunner } from '../../core/src';
-import { SpecReport, DataSource } from '../../types/src';
-import { DrillOpenIn, DrillView } from './drill';
-/**
- * MatrixRenderer
- *
- * Renders a spec `Report` of type `'matrix'` as a 2D pivot table.
- *
- * - Drives data via {@link useReportData}, which returns a {@link PivotMatrix}
- *   when `report.groupingsAcross` is non-empty.
- * - Headers: row headers down the left, column headers across the top.
- *   Multi-level groupings are shown as concatenated path segments.
- * - Body cells display one row per column-definition (e.g. `amount sum`).
- *   When `report.columns` has more than one entry, each cell shows the
- *   values stacked vertically with their labels.
- * - Totals: row total column on the right, column total row at the bottom,
- *   and grand-total in the bottom-right corner.
- * - Drill-down: clicking a body cell fires `onCellClick` with both the row
- *   key and column key; if an `actionRunner` is supplied, it also dispatches
- *   a {@link buildDrillAction} carrying both keys merged.
- *
- * We intentionally don't use ObjectGrid here — its tree model is single-axis
- * and bolting a 2D matrix onto grid header groups would be heavier than a
- * direct table. The pivot dataset is already small (rows × cols are
- * dimensions, not raw records).
- */
-import * as React from 'react';
-export interface MatrixCellClickArgs {
-    rowKey: Record<string, unknown>;
-    colKey: Record<string, unknown>;
-    /** Pre-merged key combining row + col — convenient for drill construction. */
-    combinedKey: Record<string, unknown>;
-    /** Pre-aggregated values for the clicked cell (may be undefined for empty cells). */
-    values?: Record<string, unknown>;
-}
-export interface MatrixRendererProps {
-    report: SpecReport;
-    dataSource?: DataSource;
-    rows?: Array<Record<string, unknown>>;
-    runtimeFilter?: Record<string, unknown>;
-    /** Imperative drill callback. */
-    onCellClick?: (args: MatrixCellClickArgs) => void;
-    /** Declarative drill: dispatch a `type: 'drill'` action when a cell is clicked. */
-    actionRunner?: ActionRunner;
-    drillView?: DrillView;
-    drillOpenIn?: DrillOpenIn;
-    className?: string;
-    /** Render text for an empty cell. Defaults to "—". */
-    emptyCellText?: string;
-}
-export declare const MatrixRenderer: React.FC<MatrixRendererProps>;

package/dist/packages/plugin-report/src/MatrixRenderer.stories.d.ts

@@ -1,24 +0,0 @@
-import { StoryObj } from '@storybook/react';
-/**
- * MatrixRenderer stories — region × quarter pivot for M2 demo.
- *
- * Showcases:
- *  - `groupingsAcross` rendering as columns
- *  - `dateGranularity: 'quarter'` bucketing on close_date
- *  - Server-side aggregation path: stories supply a mock `dataSource.aggregate`
- *    that returns pre-bucketed rows so the hook skips client aggregation,
- *    mirroring what objectql's engine fallback now does end-to-end.
- *  - Cell click → drill action with combined (region, quarter) filter.
- */
-import * as React from 'react';
-declare const meta: {
-    title: string;
-    component: React.FC<import('./MatrixRenderer').MatrixRendererProps>;
-    parameters: {
-        layout: string;
-    };
-    tags: string[];
-};
-export default meta;
-type Story = StoryObj<typeof meta>;
-export declare const RegionByQuarterServerAggregated: Story;

package/dist/packages/plugin-report/src/ReportBuilder.d.ts

@@ -1,10 +0,0 @@
-import { default as React } from 'react';
-import { ReportBuilderSchema } from '../../types/src';
-export interface ReportBuilderProps {
-    schema: ReportBuilderSchema;
-}
-/**
- * ReportBuilder - Interactive report builder component
- * Allows users to configure report fields, filters, grouping, sections, and export settings
- */
-export declare const ReportBuilder: React.FC<ReportBuilderProps>;

package/dist/packages/plugin-report/src/ReportConfigPanel.d.ts

@@ -1,24 +0,0 @@
-import { AvailableField } from './editorTypes';
-export type { AvailableField } from './editorTypes';
-export { specFilterToUIGroup, uiGroupToSpecFilter, SpecFilterAdapter, } from './specFilterAdapter';
-export type { SpecFilterParseResult } from './specFilterAdapter';
-export { ColumnsEditor, normalizeColumns } from './ColumnsEditor';
-export { GroupingsBuilder } from './GroupingsBuilder';
-export { ChartConfig } from './ChartConfig';
-export interface ReportConfigPanelProps {
-    open: boolean;
-    onClose: () => void;
-    config: Record<string, any> | null;
-    onSave: (config: Record<string, any>) => void;
-    onFieldChange?: (key: string, value: any, draft: Record<string, any>) => void;
-    availableFields?: AvailableField[];
-    /**
-     * Optional resolver that returns the field list for a given object name.
-     * Used by `JoinedBlocksEditor` so blocks with an `objectName` override
-     * pick their fields from the right object schema instead of the container's.
-     * If omitted, blocks fall back to `availableFields`.
-     */
-    getFieldsForObject?: (objectName: string | undefined) => AvailableField[] | undefined;
-}
-export declare function ReportConfigPanel({ open, onClose, config, onSave, onFieldChange, availableFields, getFieldsForObject, }: ReportConfigPanelProps): import("react/jsx-runtime").JSX.Element | null;
-export default ReportConfigPanel;

package/dist/packages/plugin-report/src/ReportRenderer.d.ts

@@ -1,44 +0,0 @@
-import { ActionRunner } from '../../core/src';
-import { SpecReport, DataSource } from '../../types/src';
-import { LegacyReportRendererProps } from './LegacyReportRenderer';
-import { DrillOpenIn, DrillView } from './drill';
-/**
- * ReportRenderer
- *
- * Thin dispatcher that routes a report schema to the correct renderer based
- * on whether it is a spec-native `SpecReport` (preferred) or a legacy
- * presentation-layer schema (`data`/`columns`/`chart`).
- *
- * Dispatch table:
- * | report.type            | Renderer                          |
- * |------------------------|-----------------------------------|
- * | tabular | summary      | <SpecReportGrid>                  |
- * | matrix                 | placeholder (M2)                  |
- * | joined                 | placeholder (M3)                  |
- * | (legacy / no type)     | <LegacyReportRenderer>            |
- *
- * Host apps can:
- * - Pass a `SpecReport` plus a `dataSource` to drive a live, drillable report.
- * - Pass a legacy `{ data, columns, chart }` schema for backwards compatibility.
- */
-import * as React from 'react';
-export type ReportRendererSchema = SpecReport | LegacyReportRendererProps['schema'];
-export interface ReportRendererProps {
-    /** Either a spec-native `SpecReport` or a legacy presentation schema. */
-    schema: ReportRendererSchema;
-    /** Required for spec reports unless `rows` is provided. */
-    dataSource?: DataSource | Record<string, unknown>;
-    /** Pre-fetched rows (skips data fetch). */
-    rows?: Array<Record<string, unknown>>;
-    /** Runtime filter merged on top of `report.filter`. */
-    runtimeFilter?: Record<string, unknown>;
-    /** Action runner used to dispatch `drill` actions on row click. */
-    actionRunner?: ActionRunner;
-    /** Default view for drill targets. */
-    drillView?: DrillView;
-    /** Where the drill target should open. */
-    drillOpenIn?: DrillOpenIn;
-    /** Optional class for the outer container. */
-    className?: string;
-}
-export declare const ReportRenderer: React.FC<ReportRendererProps>;

package/dist/packages/plugin-report/src/ScheduleConfig.d.ts

@@ -1,7 +0,0 @@
-import { default as React } from 'react';
-import { ReportSchedule } from '../../types/src';
-export interface ScheduleConfigProps {
-    schedule?: ReportSchedule;
-    onChange?: (schedule: ReportSchedule) => void;
-}
-export declare const ScheduleConfig: React.FC<ScheduleConfigProps>;

package/dist/packages/plugin-report/src/SpecReportGrid.d.ts

@@ -1,49 +0,0 @@
-import { SpecReport, DataSource } from '../../types/src';
-import { ActionRunner } from '../../core/src';
-import { DrillOpenIn, DrillView } from './drill';
-/**
- * SpecReportGrid
- *
- * Bridge between the spec `Report` (definition) and `ObjectGrid` (renderer).
- *
- * - Drives data fetch via {@link useReportData}.
- * - For `tabular` reports, renders a flat grid with columns mapped from `report.columns`.
- * - For `summary` reports, applies `report.groupingsDown` as ObjectGrid grouping and
- *   passes per-group aggregations so collapsible group headers show subtotals.
- * - `matrix` reports fall through to a "not supported" notice (handled by M2).
- *
- * The grand total is rendered as a footer-style row above the grid; per-column
- * `summary` on the grid handles classic SQL `GRAND TOTAL` semantics.
- */
-import * as React from 'react';
-export interface SpecReportGridProps {
-    report: SpecReport;
-    /** Optional DataSource adapter. When omitted, `rows` must be supplied. */
-    dataSource?: DataSource;
-    /** Optional pre-fetched rows (skips dataSource.find). */
-    rows?: Record<string, unknown>[];
-    /** Optional runtime filter merged with report.filter via `$and`. */
-    runtimeFilter?: Record<string, unknown>;
-    /** Drill-down callback. Receives the group key for the clicked row. */
-    onDrillDown?: (groupKey: Record<string, unknown>, rawRows: Record<string, unknown>[]) => void;
-    /**
-     * Optional `ActionRunner` used to dispatch a `type: 'drill'` action on row
-     * click. When set, the grid builds the drill action via {@link buildDrillAction}
-     * and runs it through the engine — the host must register a `drill` handler
-     * (see {@link registerDrillHandler}) for the navigation to take effect.
-     * `onDrillDown` still fires (after dispatch) so consumers can observe.
-     */
-    actionRunner?: ActionRunner;
-    /** Drill view override (default `'list'`). */
-    drillView?: DrillView;
-    /** Drill open-in override (default `'current'`). */
-    drillOpenIn?: DrillOpenIn;
-    className?: string;
-}
-/**
- * Render a spec `Report` as an `ObjectGrid` (Summary/Tabular only).
- *
- * For `matrix`/`joined` types this returns a placeholder; M2/M3 will
- * provide dedicated renderers.
- */
-export declare const SpecReportGrid: React.FC<SpecReportGridProps>;

package/dist/packages/plugin-report/src/SpecReportGrid.stories.d.ts

@@ -1,31 +0,0 @@
-import { StoryObj } from '@storybook/react';
-/**
- * SpecReportGrid stories — CRM-flavoured demos for M1.
- *
- * - Sales funnel by stage (summary report, sum amount, count opportunities)
- * - Sales funnel by owner → stage (multi-level grouping)
- * - Pipeline by region × quarter (matrix placeholder — M2 will render this)
- *
- * Stories supply rows inline so they work without a backend; the drill action
- * is wired to a console-logging ActionRunner so clicks demonstrate the
- * declarative drill protocol.
- */
-import * as React from 'react';
-declare const meta: {
-    title: string;
-    component: React.FC<import('./SpecReportGrid').SpecReportGridProps>;
-    parameters: {
-        layout: string;
-    };
-    tags: string[];
-};
-export default meta;
-type Story = StoryObj<typeof meta>;
-/** Funnel by stage — classic CRM "summary by status" view. */
-export declare const FunnelByStage: Story;
-/** Two-level funnel: owner → stage. Click a row to dispatch a drill action. */
-export declare const FunnelByOwnerAndStage: Story;
-/** Tabular detail report — flat opportunity list with totals. */
-export declare const TabularOpportunityList: Story;
-/** Matrix report placeholder — region × quarter pivot will land in M2. */
-export declare const MatrixRegionByQuarter: Story;

package/dist/packages/plugin-report/src/buildChartData.d.ts

@@ -1,38 +0,0 @@
-import { ReportRow } from './hooks/useReportData';
-import { SpecReport, SpecReportColumn } from '../../types/src';
-export interface ChartAdapterLabelResolvers {
-    /** Resolve a friendly label for a measure column. Used for the chart's y-axis legend. */
-    resolveColumnLabel?: (col: SpecReportColumn) => string | undefined;
-    /** Resolve a friendly label for an implicit `count` measure given the yAxis field. */
-    resolveCountLabel?: (yField: string) => string | undefined;
-    /** Resolve a friendly display label for an x-axis bucket value (e.g. translate picklist values). */
-    resolveAxisValue?: (field: string, rawValue: unknown) => string | undefined;
-}
-export interface ChartAdapterInput {
-    report: SpecReport;
-    rows: ReportRow[];
-    labels?: ChartAdapterLabelResolvers;
-}
-export interface ChartAdapterOutput {
-    /** `{ data, xAxisKey, series, chartType }` ready for `<SchemaRenderer type="chart">`. */
-    schema: ChartSchema | null;
-    /** Human-readable diagnostic when we can't build a chart (missing xAxis, etc.). */
-    diagnostic?: string;
-}
-type ChartType = 'bar' | 'column' | 'horizontal-bar' | 'line' | 'area' | 'pie' | 'donut' | 'funnel' | 'radar' | 'scatter';
-export interface ChartSchema {
-    type: 'chart';
-    chartType: ChartType;
-    data: Array<Record<string, unknown>>;
-    xAxisKey: string;
-    series: Array<{
-        dataKey: string;
-        label?: string;
-    }>;
-    title?: string;
-    showLegend?: boolean;
-    showDataLabels?: boolean;
-    className?: string;
-}
-export declare function buildChartData({ report, rows, labels }: ChartAdapterInput): ChartAdapterOutput;
-export {};

package/dist/packages/plugin-report/src/drill.d.ts

@@ -1,63 +0,0 @@
-import { ActionDef, ActionHandler, ActionRunner } from '../../core/src';
-import { SpecReport } from '../../types/src';
-/** Open-target for a drill. */
-export type DrillOpenIn = 'current' | 'modal' | 'new-tab';
-/** Drill target — either a list filtered down to the group, or a specific record. */
-export type DrillView = 'list' | 'detail' | (string & {});
-/** Serializable shape of a `type: 'drill'` action. */
-export interface DrillActionDef extends ActionDef {
-    type: 'drill';
-    objectName: string;
-    filter?: Record<string, unknown>;
-    view?: DrillView;
-    recordId?: string | number;
-    openIn?: DrillOpenIn;
-}
-/** Resolved navigation target produced by a drill handler. */
-export interface DrillNavigateTarget {
-    objectName: string;
-    filter?: Record<string, unknown>;
-    view?: DrillView;
-    recordId?: string | number;
-    openIn?: DrillOpenIn;
-}
-/** Options passed when creating a drill handler. */
-export interface DrillHandlerOptions {
-    /**
-     * Host-supplied navigation callback. The handler invokes this with a
-     * fully-resolved target so the host can decide whether to push to
-     * router, open a modal, or open a new tab.
-     */
-    navigate: (target: DrillNavigateTarget) => void | Promise<void>;
-}
-/**
- * Compose a `drill` action from a spec report + group key.
- *
- * Filter precedence (later overrides earlier where keys conflict):
- *   1. `report.filter` (definition-time)
- *   2. `runtimeFilter` (URL / user selection)
- *   3. `groupKey` (the row/cell the user actually clicked)
- *
- * All three are combined via `$and` so backend filter engines see the
- * full intersection.
- */
-export declare function buildDrillAction(report: SpecReport, groupKey: Record<string, unknown>, options?: {
-    runtimeFilter?: Record<string, unknown>;
-    view?: DrillView;
-    recordId?: string | number;
-    openIn?: DrillOpenIn;
-}): DrillActionDef;
-/** Type guard for drill actions. */
-export declare function isDrillAction(action: ActionDef | undefined | null): action is DrillActionDef;
-/**
- * Build an `ActionHandler` for the `drill` action type.
- *
- * Register it on an `ActionRunner` (or `ActionEngine`'s runner) via
- * `runner.registerHandler('drill', createDrillHandler({ navigate }))`.
- */
-export declare function createDrillHandler(opts: DrillHandlerOptions): ActionHandler;
-/**
- * Register the drill handler on an `ActionRunner` instance. Returns an
- * unregister function for cleanup (useful in React effects).
- */
-export declare function registerDrillHandler(runner: ActionRunner, opts: DrillHandlerOptions): () => void;

package/dist/packages/plugin-report/src/editorTypes.d.ts

@@ -1,20 +0,0 @@
-/**
- * ObjectUI
- * Copyright (c) 2024-present ObjectStack Inc.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- */
-export type AvailableField = {
-    value: string;
-    label: string;
-    type?: string;
-    options?: Array<{
-        value: string;
-        label: string;
-    }>;
-};
-export type Translator = (key: string, defaultValue?: string, options?: any) => string;
-export declare const DATE_TYPES: Set<string>;
-export declare const NUMERIC_TYPES: Set<string>;
-export declare const NONE: "";

package/dist/packages/plugin-report/src/hooks/useReportData.d.ts

@@ -1,131 +0,0 @@
-import { SpecReport, SpecReportColumn, SpecReportGrouping, SpecReportDateGranularity } from '../../../types/src';
-export interface ReportRow {
-    /** Group key path, e.g. `{ region: 'East', quarter: '2024-Q1' }`. Empty `{}` for the grand-total row. */
-    groupKey: Record<string, unknown>;
-    /** Display labels for the key path, in `[down..., across...]` order. */
-    groupPath: string[];
-    /** Aggregated values, keyed as `${field}__${aggregate}` (or just `${field}` for passthrough columns). */
-    values: Record<string, unknown>;
-    /** Number of underlying raw rows in this group. */
-    count: number;
-    /** Child rows for nested groupings. Undefined at the leaf level. */
-    children?: ReportRow[];
-}
-export interface UseReportDataResult {
-    rows: ReportRow[];
-    rawRows: Record<string, unknown>[];
-    totals: Record<string, unknown>;
-    /** Pivoted matrix shape — populated when `report.groupingsAcross` is non-empty. */
-    pivot: PivotMatrix | null;
-    loading: boolean;
-    error: Error | null;
-    refetch: () => Promise<void>;
-    drillDown: (groupKey: Record<string, unknown>) => Record<string, unknown>[];
-}
-/**
- * 2D pivot output. `rowHeaders` × `colHeaders` form the matrix; `cells[rowId][colId]`
- * holds the per-cell aggregated values keyed by `columnKey()`. Totals are
- * pre-computed so the renderer doesn't need to re-aggregate.
- */
-export interface PivotHeader {
-    /** Group key path, e.g. `{ region: 'EMEA' }` (row) or `{ closeQuarter: '2024-Q1' }` (col). */
-    key: Record<string, unknown>;
-    /** Display labels in nesting order. */
-    path: string[];
-    /** Stable id derived from `path` — use as React key + lookup key into `cells`. */
-    id: string;
-}
-export interface PivotMatrix {
-    rowHeaders: PivotHeader[];
-    colHeaders: PivotHeader[];
-    /** `cells[rowId][colId] = { 'amount__sum': 1200, ... }`. Missing cells are absent (renderer fills with 0/—). */
-    cells: Record<string, Record<string, Record<string, unknown>>>;
-    /** Row totals across all columns, keyed by `rowId`. */
-    rowTotals: Record<string, Record<string, unknown>>;
-    /** Column totals across all rows, keyed by `colId`. */
-    colTotals: Record<string, Record<string, unknown>>;
-    /** Grand total across the entire matrix. */
-    grandTotal: Record<string, unknown>;
-    columns: readonly SpecReportColumn[];
-    downGroupings: readonly SpecReportGrouping[];
-    acrossGroupings: readonly SpecReportGrouping[];
-}
-export interface UseReportDataOptions {
-    /**
-     * Adapter exposing `find(resource, params)` and optionally `aggregate(resource, query)`.
-     * - When `.aggregate` is present, the hook prefers it for reports with date
-     *   bucketing or pure aggregations — the server then runs DATE_TRUNC + GROUP
-     *   BY natively and returns one row per bucket.
-     * - When only `.find` is present, the hook falls back to raw rows + client
-     *   bucketing (see `bucketDate` / `groupingValue`).
-     * If the hook stays idle, no fetch happens.
-     */
-    dataSource?: {
-        find?: (resource: string, params?: Record<string, unknown>) => Promise<unknown>;
-        aggregate?: (resource: string, query: Record<string, unknown>) => Promise<unknown>;
-    };
-    /** Filter merged on top of `report.filter` via `$and` (e.g., URL params, user selections). */
-    runtimeFilter?: Record<string, unknown>;
-    /** Optional `$top` cap for the raw fetch. Defaults to 5000. */
-    maxRows?: number;
-    /** When `false`, skips fetching. Defaults to `true`. */
-    enabled?: boolean;
-    /** Pre-fetched rows. When provided, bypasses `dataSource` entirely. */
-    rows?: Record<string, unknown>[];
-    /**
-     * When true (default), prefer `dataSource.aggregate()` for reports that
-     * carry date granularity or any aggregating column. Set false to force the
-     * client-side path (useful for tests / debugging).
-     */
-    preferServerAggregation?: boolean;
-}
-/** Stable key for a column's aggregated output: `field__aggregate` (or just `field`). */
-export declare function columnKey(col: SpecReportColumn): string;
-/** Format a Date into a string bucket according to a date granularity. */
-export declare function bucketDate(value: unknown, granularity: SpecReportDateGranularity): string | null;
-/** Extract the group value for a single grouping, applying dateGranularity if set. */
-export declare function groupingValue(row: Record<string, unknown>, grouping: SpecReportGrouping): string;
-/**
- * Compute aggregates for an array of rows against a list of columns.
- * `unique` returns the count of distinct non-null values; `count` includes nulls.
- */
-export declare function aggregateRows(rows: Record<string, unknown>[], columns: readonly SpecReportColumn[]): Record<string, unknown>;
-/**
- * Recursive grouping. Each grouping level produces a nested `ReportRow[]`.
- * The final leaf level still aggregates over the bucket so callers always have
- * `values` available without re-walking children.
- */
-export declare function groupAndAggregate(rows: Record<string, unknown>[], groupings: readonly SpecReportGrouping[], columns: readonly SpecReportColumn[], parentKey?: Record<string, unknown>, parentPath?: string[]): ReportRow[];
-/**
- * Build a 2D pivot matrix from raw rows. Rows are bucketed by every
- * `downGroupings` field path; columns by every `acrossGroupings` field path.
- * Each cell is then aggregated independently with the report's columns.
- *
- * - When either dimension is empty, the matrix degenerates: a single header
- *   with empty path is emitted so the renderer can still display a 1×N or
- *   N×1 strip without special-casing.
- * - Header ordering honours each grouping's `sort` ('asc' default, 'desc' opt-in).
- * - `limit` on the *head* grouping of each dimension is respected (matches
- *   `groupAndAggregate`); deeper limits are ignored to preserve totals.
- */
-export declare function pivotRows(rows: Record<string, unknown>[], columns: readonly SpecReportColumn[], downGroupings: readonly SpecReportGrouping[], acrossGroupings: readonly SpecReportGrouping[]): PivotMatrix;
-/** Combine two FilterCondition objects via `$and`, dropping empty ones. */
-export declare function mergeFilters(a: Record<string, unknown> | undefined, b: Record<string, unknown> | undefined): Record<string, unknown> | undefined;
-/** Collect all fields referenced by groupings + columns + sort + filter (for $select). */
-export declare function collectFields(report: SpecReport): string[];
-/**
- * Build a `QueryAST`-style payload for `dataSource.aggregate()`. Groupings
- * with `dateGranularity` are emitted as structured objects so spec-aware
- * backends can do server-side DATE_TRUNC; backends that don't recognise the
- * field gracefully treat them as the bare field name (the engine's
- * in-memory fallback handles the rest).
- *
- * Returns `null` when the report has no groupings *and* no aggregating
- * columns — in that case there's no work for `aggregate()` to do and the
- * hook should stick with `find()`.
- */
-export declare function buildAggregateQuery(report: SpecReport, runtimeFilter: Record<string, unknown> | undefined, maxRows: number): Record<string, unknown> | null;
-/**
- * Run a spec `Report` and return its rows, totals, and a drill-down helper.
- */
-export declare function useReportData(report: SpecReport | undefined, options?: UseReportDataOptions): UseReportDataResult;

package/dist/packages/plugin-report/src/index.d.ts

@@ -1,26 +0,0 @@
-import { ReportRenderer } from './ReportRenderer';
-import { LegacyReportRenderer } from './LegacyReportRenderer';
-import { ReportViewer } from './ReportViewer';
-import { ReportBuilder } from './ReportBuilder';
-import { ReportConfigPanel } from './ReportConfigPanel';
-import { SpecReportGrid } from './SpecReportGrid';
-import { MatrixRenderer } from './MatrixRenderer';
-import { JoinedReportRenderer } from './JoinedReportRenderer';
-export { ReportRenderer, LegacyReportRenderer, ReportViewer, ReportBuilder, ReportConfigPanel, SpecReportGrid, MatrixRenderer, JoinedReportRenderer };
-export type { ReportRendererProps, ReportRendererSchema } from './ReportRenderer';
-export type { LegacyReportRendererProps } from './LegacyReportRenderer';
-export type { SpecReportGridProps } from './SpecReportGrid';
-export type { MatrixRendererProps, MatrixCellClickArgs } from './MatrixRenderer';
-export type { JoinedReportRendererProps } from './JoinedReportRenderer';
-export { buildDrillAction, createDrillHandler, registerDrillHandler, isDrillAction, } from './drill';
-export type { DrillActionDef, DrillHandlerOptions, DrillNavigateTarget, DrillOpenIn, DrillView, } from './drill';
-export type { AvailableField } from './ReportConfigPanel';
-export { JoinedBlocksEditor, validateJoinedBlocks } from './JoinedBlocksEditor';
-export type { JoinedBlocksEditorProps } from './JoinedBlocksEditor';
-export { formatValue } from './formatValue';
-export { exportReport, exportAsCSV, exportAsJSON, exportAsHTML, exportAsPDF, exportAsExcel } from './ReportExportEngine';
-export { ScheduleConfig } from './ScheduleConfig';
-export { exportWithLiveData, exportExcelWithFormulas, createScheduleTrigger, } from './LiveReportExporter';
-export type { LiveExportOptions, LiveExportResult, ExcelColumnConfig, ScheduleTriggerCallback, } from './LiveReportExporter';
-export { useReportData, columnKey, bucketDate, groupingValue, aggregateRows, groupAndAggregate, pivotRows, buildAggregateQuery, mergeFilters, collectFields, } from './hooks/useReportData';
-export type { ReportRow, PivotHeader, PivotMatrix, UseReportDataResult, UseReportDataOptions, } from './hooks/useReportData';

package/dist/packages/plugin-report/src/specFilterAdapter.d.ts

@@ -1,38 +0,0 @@
-import { AvailableField, Translator } from './editorTypes';
-type UICondition = {
-    id: string;
-    field: string;
-    operator: string;
-    value: any;
-};
-type UIGroup = {
-    id: string;
-    logic: 'and' | 'or';
-    conditions: UICondition[];
-};
-export interface SpecFilterParseResult {
-    group: UIGroup;
-    /** When true the spec filter could not be fully represented in the UI. */
-    complex: boolean;
-}
-/**
- * Convert a spec `FilterCondition` into a UI `FilterGroup`.
- * Falsy / non-object input yields an empty AND group.
- * Nested `$and` / `$or`, `$not`, or any unrecognized shape sets `complex: true`.
- */
-export declare function specFilterToUIGroup(spec: unknown): SpecFilterParseResult;
-/**
- * Convert a UI `FilterGroup` back into a spec `FilterCondition`.
- * - Empty group → `undefined` (drop the key).
- * - Single condition (equals + simple value) → `{field: value}` shorthand.
- * - Single condition (other operator)        → `{field: {$op: value}}`.
- * - Multiple conditions → `{$and: [...]}` or `{$or: [...]}`.
- */
-export declare function uiGroupToSpecFilter(group: UIGroup | undefined): any;
-export declare function SpecFilterAdapter({ availableFields, value, onChange, t, }: {
-    availableFields: AvailableField[];
-    value: any;
-    onChange: (v: any) => void;
-    t: Translator;
-}): import("react/jsx-runtime").JSX.Element;
-export {};