@aintela/bi 0.2.0

package/dist/ChartContext-C_f_6khG.js

@@ -0,0 +1,14 @@
+var C = Object.defineProperty;
+var o = (t, e) => C(t, "name", { value: e, configurable: !0 });
+import { jsx as a } from "react/jsx-runtime";
+import r from "react";
+const n = r.createContext(null), c = /* @__PURE__ */ o(({ value: t, children: e }) => /* @__PURE__ */ a(n.Provider, { value: t, children: e }), "ChartContextProvider");
+function i() {
+  return r.useContext(n);
+}
+o(i, "useChartContext");
+export {
+  c as C,
+  i as u
+};
+//# sourceMappingURL=ChartContext-C_f_6khG.js.map

package/dist/ChartContext-C_f_6khG.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ChartContext-C_f_6khG.js","sources":["../src/grid/ChartContext.tsx"],"sourcesContent":["import React from 'react';\n\n/**\n * Tells a card whether the enclosing `GridCard` is drawn \"Naked\" (no header,\n * so the card should render its own title) or \"Boxed\". Lives in its own module\n * so cards can read it without importing the grid (react-grid-layout) bundle.\n */\nexport interface ChartContextState {\n    naked: boolean;\n}\n\nconst ChartContext = React.createContext<ChartContextState | null>(null);\n\nexport const ChartContextProvider: React.FC<{ value: ChartContextState; children: React.ReactNode }> = ({ value, children }) => (\n    <ChartContext.Provider value={value}>{children}</ChartContext.Provider>\n);\n\nexport function useChartContext(): ChartContextState | null {\n    return React.useContext(ChartContext);\n}\n"],"names":["ChartContext","React","ChartContextProvider","__name","value","children","jsx","useChartContext"],"mappings":";;;;AAWA,MAAMA,IAAeC,EAAM,cAAwC,IAAI,GAE1DC,IAA0F,gBAAAC,EAAA,CAAC,EAAE,OAAAC,GAAO,UAAAC,EAAA,MAC7G,gBAAAC,EAACN,EAAa,UAAb,EAAsB,OAAAI,GAAe,UAAAC,EAAA,CAAS,GADoD;AAIhG,SAASE,IAA4C;AACxD,SAAON,EAAM,WAAWD,CAAY;AACxC;AAFgBG,EAAAI,GAAA;"}

package/dist/DashboardParametersContext-Clv--79U.js

@@ -0,0 +1,39 @@
+var P = Object.defineProperty;
+var e = (r, s) => P(r, "name", { value: s, configurable: !0 });
+import { jsx as h } from "react/jsx-runtime";
+import { createContext as p, useState as b, useRef as x, useEffect as D, useContext as C } from "react";
+const c = p(void 0);
+function I({ values: r, children: s }) {
+  const [o, n] = b(r.parameters), t = JSON.stringify(r.parameters), d = x(t);
+  D(() => {
+    d.current !== t && (d.current = t, n(r.parameters));
+  }, [t, r.parameters]);
+  const f = {
+    dashboardId: r.dashboardId,
+    parameters: o,
+    refreshTick: r.refreshTick ?? 0,
+    datasetOverride: r.datasetOverride,
+    setParameter: /* @__PURE__ */ e((a, m) => {
+      n((i) => {
+        if (m === void 0) {
+          const { [a]: O, ...u } = i;
+          return u;
+        }
+        return { ...i, [a]: m };
+      });
+    }, "setParameter"),
+    getParameter: /* @__PURE__ */ e((a) => o[a], "getParameter")
+  };
+  return /* @__PURE__ */ h(c.Provider, { value: f, children: s });
+}
+e(I, "DashboardParametersProvider");
+function K() {
+  return C(c);
+}
+e(K, "useDashboardParameters");
+export {
+  c as D,
+  I as a,
+  K as u
+};
+//# sourceMappingURL=DashboardParametersContext-Clv--79U.js.map

package/dist/DashboardParametersContext-Clv--79U.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"DashboardParametersContext-Clv--79U.js","sources":["../src/hooks/DashboardParametersContext.tsx"],"sourcesContent":["import React, { createContext, useContext, useEffect, useRef, useState } from 'react';\nimport type { ReactNode } from 'react';\n\nexport interface ParametersStateSlim {\n    dashboardId: string;\n    parameters: Record<string, string | string[]>;\n    /**\n     * Monotonic counter the host bumps to force every active\n     * `useDashboardData` consumer to re-fetch with `noCache`. Defaults to 0;\n     * the hook treats the first observed value as the baseline (mounting is\n     * never a force-refresh).\n     */\n    refreshTick?: number;\n    /**\n     * Admin-only runtime override for the dataset on a parameterised\n     * dashboard. Shipped in every data-fetch POST body; the server validates\n     * and silently drops it for non-admin callers.\n     */\n    datasetOverride?: string;\n}\n\nexport interface ParametersState {\n    dashboardId: string;\n    parameters: Record<string, string | string[]>;\n    setParameter: (key: string, value: string | string[] | undefined) => void;\n    getParameter: (key: string) => string | string[] | undefined;\n    refreshTick: number;\n    datasetOverride?: string;\n}\n\nexport const DashboardParametersContext = createContext<ParametersState | undefined>(undefined);\n\nexport function DashboardParametersProvider({ values, children }: { values: ParametersStateSlim; children: ReactNode }) {\n    const [stateParameters, setStateParameters] = useState<Record<string, string | string[]>>(values.parameters);\n\n    // Sync local state when `values.parameters` changes from outside (URL,\n    // host swapping dashboards, draft hydration). Compared structurally so a\n    // host producing a fresh object every render does not re-sync.\n    const valuesParametersKey = JSON.stringify(values.parameters);\n    const lastKeyRef = useRef(valuesParametersKey);\n    useEffect(() => {\n        if (lastKeyRef.current === valuesParametersKey) return;\n        lastKeyRef.current = valuesParametersKey;\n        setStateParameters(values.parameters);\n    }, [valuesParametersKey, values.parameters]);\n\n    const state: ParametersState = {\n        dashboardId: values.dashboardId,\n        parameters: stateParameters,\n        refreshTick: values.refreshTick ?? 0,\n        datasetOverride: values.datasetOverride,\n        setParameter: (key, value) => {\n            setStateParameters((prev) => {\n                if (value === undefined) {\n                    const { [key]: _removed, ...rest } = prev;\n                    return rest;\n                }\n                return { ...prev, [key]: value };\n            });\n        },\n        getParameter: (key) => stateParameters[key],\n    };\n\n    return <DashboardParametersContext.Provider value={state}>{children}</DashboardParametersContext.Provider>;\n}\n\nexport function useDashboardParameters(): ParametersState | undefined {\n    return useContext(DashboardParametersContext);\n}\n"],"names":["DashboardParametersContext","createContext","DashboardParametersProvider","values","children","stateParameters","setStateParameters","useState","valuesParametersKey","lastKeyRef","useRef","useEffect","state","__name","key","value","prev","_removed","rest","useDashboardParameters","useContext"],"mappings":";;;;AA8BO,MAAMA,IAA6BC,EAA2C,MAAS;AAEvF,SAASC,EAA4B,EAAE,QAAAC,GAAQ,UAAAC,KAAkE;AACpH,QAAM,CAACC,GAAiBC,CAAkB,IAAIC,EAA4CJ,EAAO,UAAU,GAKrGK,IAAsB,KAAK,UAAUL,EAAO,UAAU,GACtDM,IAAaC,EAAOF,CAAmB;AAC7C,EAAAG,EAAU,MAAM;AACZ,IAAIF,EAAW,YAAYD,MAC3BC,EAAW,UAAUD,GACrBF,EAAmBH,EAAO,UAAU;AAAA,EACxC,GAAG,CAACK,GAAqBL,EAAO,UAAU,CAAC;AAE3C,QAAMS,IAAyB;AAAA,IAC3B,aAAaT,EAAO;AAAA,IACpB,YAAYE;AAAA,IACZ,aAAaF,EAAO,eAAe;AAAA,IACnC,iBAAiBA,EAAO;AAAA,IACxB,cAAc,gBAAAU,EAAA,CAACC,GAAKC,MAAU;AAC1B,MAAAT,EAAmB,CAACU,MAAS;AACzB,YAAID,MAAU,QAAW;AACrB,gBAAM,EAAE,CAACD,CAAG,GAAGG,GAAU,GAAGC,MAASF;AACrC,iBAAOE;AAAA,QACX;AACA,eAAO,EAAE,GAAGF,GAAM,CAACF,CAAG,GAAGC,EAAA;AAAA,MAC7B,CAAC;AAAA,IACL,GARc;AAAA,IASd,cAAc,gBAAAF,EAAA,CAACC,MAAQT,EAAgBS,CAAG,GAA5B;AAAA,EAA4B;AAG9C,2BAAQd,EAA2B,UAA3B,EAAoC,OAAOY,GAAQ,UAAAR,GAAS;AACxE;AAhCgBS,EAAAX,GAAA;AAkCT,SAASiB,IAAsD;AAClE,SAAOC,EAAWpB,CAA0B;AAChD;AAFgBa,EAAAM,GAAA;"}

package/dist/cards/ChartCard.d.ts

@@ -0,0 +1,62 @@
+import { default as React } from 'react';
+import { DataResult } from '../data/dataUtils';
+export interface ChartSeries {
+    dataKey: string;
+    name?: string;
+    color?: string;
+    type?: 'line' | 'bar' | 'area';
+}
+export type ChartType = 'line' | 'bar' | 'barH' | 'barV' | 'donut' | 'pie' | 'scatter' | 'area' | 'stackedArea' | 'stackedBar' | 'combo';
+type DomainValue = number | 'auto' | 'dataMin' | 'dataMax';
+export interface AxisConfig {
+    hide?: boolean;
+    label?: string;
+    tickAngle?: number;
+    tickCount?: number;
+    interval?: number | 'preserveStart' | 'preserveEnd' | 'preserveStartEnd';
+    tickSize?: number;
+    tickLine?: boolean;
+    axisLine?: boolean;
+    domain?: [DomainValue, DomainValue];
+    unit?: string;
+    reversed?: boolean;
+    fontSize?: number;
+    color?: string;
+    width?: number;
+    height?: number;
+    scale?: 'auto' | 'linear' | 'pow' | 'sqrt' | 'log' | 'time' | 'band' | 'point';
+}
+export interface ChartCardProps<TModel extends Record<string, any> = Record<string, any>> {
+    data?: DataResult<TModel> | null;
+    type: ChartType;
+    xAxis?: string;
+    series: ChartSeries[];
+    title?: string;
+    height?: number;
+    stacked?: boolean;
+    showLegend?: boolean;
+    showGrid?: boolean;
+    showTooltip?: boolean;
+    formatXAxis?: (value: unknown) => string;
+    formatYAxis?: (value: number) => string;
+    xAxisConfig?: AxisConfig;
+    yAxisConfig?: AxisConfig;
+    loading?: boolean;
+    /** Max visible slices for pie/donut charts. Smaller slices are grouped into "Others". Default 4. */
+    maxSlices?: number;
+    /** Overrides the palette from chartDefaults / the theme when set. */
+    palette?: string[];
+    /** Background colour of the chart container (a theme token string is fine). */
+    backgroundColor?: string;
+    /** Colour of the grid lines; defaults to a translucent `text.primary`. */
+    gridColor?: string;
+}
+/**
+ * Modulates the alpha of `baseColor` by `index/total`, returning a colour in
+ * `[minAlpha, maxAlpha]`. Used to render mono-shaded bars / slices where every
+ * mark shares one hue but varies in intensity. Built on MUI's `alpha()`, so it
+ * accepts hex, functional and keyword CSS colours alike.
+ */
+export declare function chartShade(baseColor: string, index: number, total: number, minAlpha?: number, maxAlpha?: number): string;
+export declare function ChartCard<TModel extends Record<string, any> = Record<string, any>>({ data, type, xAxis, series, title, height, stacked, showLegend, showGrid, showTooltip, formatXAxis, formatYAxis, xAxisConfig, yAxisConfig, loading, maxSlices, palette: paletteOverride, backgroundColor, gridColor: gridColorOverride, }: ChartCardProps<TModel>): React.JSX.Element;
+export default ChartCard;

package/dist/cards/DataTableCard.d.ts

@@ -0,0 +1,55 @@
+import { default as React } from 'react';
+import { GridCellClassNamePropType, GridCellParams, GridColumnHeaderParams, GridRowClassNameParams, GridRowHeightParams, GridRowHeightReturnValue, GridValidRowModel } from '@mui/x-data-grid-pro';
+import { DataResult } from '../data/dataUtils';
+import { LazyDataResult } from '../hooks/useDashboardLazyData';
+export type ColumnFormats = 'compact' | 'number' | 'currency' | 'check' | 'percent' | 'date';
+export interface DataTableColumn<TModel extends GridValidRowModel = any, T = any> {
+    field: string;
+    label: string;
+    align?: 'left' | 'center' | 'right';
+    width?: number;
+    minWidth?: number;
+    format?: ColumnFormats | ((value: unknown) => string);
+    sortable?: boolean;
+    filterable?: boolean;
+    headerClassName?: string;
+    cellClassName?: string | GridCellClassNamePropType<TModel, T>;
+    renderHeader?: (params: GridColumnHeaderParams<TModel, T>) => React.ReactNode;
+    renderCell?: (params: GridCellParams<TModel, T, string>) => React.ReactNode;
+    /** `'singleSelect'` renders a dropdown filter (with {@link valueOptions}). */
+    type?: 'singleSelect';
+    valueOptions?: ReadonlyArray<unknown>;
+    /** `true` → restrict the singleSelect filter to `isAnyOf` (multi-select). */
+    multiSelectDropdown?: boolean;
+}
+export interface DataTableCardProps<TModel extends Record<string, any> = Record<string, any>> {
+    /** Local mode — full rowset already in memory (`useDashboardData(...).toDataResult(schema)`). */
+    data?: DataResult<TModel> | null;
+    /** Server mode (mutually exclusive with `data`) — `useDashboardLazyData(viewId, schema)`. */
+    lazyData?: LazyDataResult<TModel>;
+    /** Column schema (`defineSchema(...)`). Loosely typed on purpose: an untyped `DataResult` + a typed schema is the common LLM pattern. */
+    schema?: {
+        build(): DataTableColumn<any>[];
+    };
+    title?: string;
+    pageSize?: number;
+    dense?: boolean;
+    striped?: boolean;
+    /** Override for the even-row stripe (defaults to `theme.palette.action.hover`). */
+    stripedColorEven?: string;
+    stripedColorOdd?: string;
+    maxHeight?: number | string;
+    /** Header background (defaults to a translucent `primary.main`). */
+    headerColor?: string;
+    loading?: boolean;
+    autoFitHeaders?: boolean;
+    getRowHeight?: (params: GridRowHeightParams) => GridRowHeightReturnValue;
+    getRowClassName?: (params: GridRowClassNameParams<TModel & GridValidRowModel>) => string;
+    /** Default pinned columns at first render (`{ left?: string[]; right?: string[] }`). */
+    initialPinnedColumns?: {
+        left?: string[];
+        right?: string[];
+    };
+}
+export declare function DataTableCard<TModel extends Record<string, any>>({ data, lazyData, schema, getRowClassName, title, striped, stripedColorEven, stripedColorOdd, getRowHeight, headerColor, pageSize, dense, loading, autoFitHeaders, initialPinnedColumns, }: DataTableCardProps<TModel>): React.JSX.Element;
+export default DataTableCard;

package/dist/cards/GaugeCard.d.ts

@@ -0,0 +1,20 @@
+import { default as React } from 'react';
+export interface GaugeThreshold {
+    /** Upper bound of the band as a ratio in `[0, 1]`. */
+    value: number;
+    color: string;
+}
+export interface GaugeCardProps {
+    value: number;
+    min?: number;
+    max?: number;
+    label?: string;
+    prefix?: string;
+    suffix?: string;
+    /** Bands from low to high. Defaults to error / warning / success at 33 % / 66 % / 100 %. */
+    thresholds?: GaugeThreshold[];
+    formatValue?: (value: number) => string;
+    loading?: boolean;
+}
+export declare function GaugeCard({ value, min, max, label, prefix, suffix, thresholds, formatValue, loading }: GaugeCardProps): React.JSX.Element;
+export default GaugeCard;

package/dist/cards/GaugeGroup.d.ts

@@ -0,0 +1,12 @@
+import { default as React } from 'react';
+import { GaugeCardProps } from './GaugeCard';
+export interface GaugeGroupProps {
+    title?: string;
+    materialIcon?: string;
+    footNote?: string;
+    partial?: boolean;
+    loading?: boolean;
+    gauges: React.ReactElement<GaugeCardProps>[];
+}
+export declare const GaugeGroup: React.FC<GaugeGroupProps>;
+export default GaugeGroup;

package/dist/cards/MapBubbles.d.ts

@@ -0,0 +1,35 @@
+import { default as React } from 'react';
+export interface MapBubble {
+    lat: number;
+    lng: number;
+    value: number;
+    label?: string;
+}
+export interface MapBubblesProps {
+    data?: {
+        rows: MapBubble[];
+    };
+    title?: string;
+    height?: number;
+    minBubbleSize?: number;
+    maxBubbleSize?: number;
+    /** Bubble colour; defaults to the first BI series colour. */
+    color?: string;
+    formatValue?: (value: number) => string;
+    loading?: boolean;
+    /** Zoom multiplier (1 = whole world). Overrides auto-fit zoom when set. */
+    defaultZoom?: number;
+    /** Map center as [longitude, latitude]. Overrides auto-fit center when set. */
+    center?: [number, number];
+    /** When true (default), automatically centers and zooms to fit all bubbles. */
+    autoFit?: boolean;
+    /**
+     * Geography topology URL(s). The first layer is the base (filled); further
+     * layers render as boundary overlays. Defaults to the nearest
+     * `GeoLayersProvider`, else the world base layer (`worldGeoLayers`).
+     * Pass `brazilGeoLayers` for the legacy world + Brazil-states pair.
+     */
+    geoUrl?: string | readonly string[];
+}
+export declare function MapBubblesCard({ data, title, height, minBubbleSize, maxBubbleSize, color, formatValue, loading, defaultZoom, center: centerProp, autoFit, geoUrl, }: MapBubblesProps): React.JSX.Element;
+export default MapBubblesCard;

package/dist/cards/MapConnections.d.ts

@@ -0,0 +1,28 @@
+import { default as React } from 'react';
+export interface MapConnection {
+    fromLat: number;
+    fromLng: number;
+    toLat: number;
+    toLng: number;
+    value?: number;
+    label?: string;
+}
+export interface MapConnectionsProps {
+    data?: {
+        rows: MapConnection[];
+    };
+    title?: string;
+    height?: number;
+    /** Arc colour; defaults to the second BI series colour. */
+    color?: string;
+    showEndpoints?: boolean;
+    formatValue?: (value: number) => string;
+    loading?: boolean;
+    defaultZoom?: number;
+    center?: [number, number];
+    autoFit?: boolean;
+    /** See `MapBubblesProps.geoUrl`. */
+    geoUrl?: string | readonly string[];
+}
+export declare function MapConnectionsCard({ data, title, height, color, showEndpoints, formatValue, loading, defaultZoom, center: centerProp, autoFit, geoUrl, }: MapConnectionsProps): React.JSX.Element;
+export default MapConnectionsCard;

package/dist/cards/MetricCard.d.ts

@@ -0,0 +1,15 @@
+import { default as React } from 'react';
+export interface MetricCardProps {
+    currentValue: number;
+    previousValue?: number;
+    prefix?: string;
+    suffix?: string;
+    differenceStyle?: 'percentage' | 'value' | 'absolute';
+    description?: string;
+    icon?: React.ReactNode;
+    label?: string;
+    formatValue?: (value: number) => string;
+    loading?: boolean;
+}
+export declare function MetricCard({ currentValue, previousValue, prefix, suffix, differenceStyle, description, icon, label, formatValue, loading, }: MetricCardProps): React.JSX.Element;
+export default MetricCard;

package/dist/cards/MetricGroupCard.d.ts

@@ -0,0 +1,10 @@
+import { default as React } from 'react';
+import { MetricCardProps } from './MetricCard';
+export interface MetricGroupCardProps {
+    title?: string;
+    metrics: MetricCardProps[];
+    columns?: 2 | 3 | 4;
+    loading?: boolean;
+}
+export declare function MetricGroupCard({ title, metrics, columns, loading }: MetricGroupCardProps): React.JSX.Element;
+export default MetricGroupCard;

package/dist/cards/TreeMapCard.d.ts

@@ -0,0 +1,15 @@
+import { default as React } from 'react';
+import { DataResult } from '../data/dataUtils';
+export interface TreeMapCardProps<TModel extends Record<string, any> = Record<string, any>> {
+    data?: DataResult<TModel> | null;
+    nameKey: keyof TModel & string;
+    valueKey: keyof TModel & string;
+    title?: string;
+    height?: number;
+    formatValue?: (value: number) => string;
+    loading?: boolean;
+    /** Overrides `theme.palette.bi.series`. */
+    palette?: readonly string[];
+}
+export declare function TreeMapCard<TModel extends Record<string, any> = Record<string, any>>({ data, nameKey, valueKey, title, height, formatValue, loading, palette: paletteOverride, }: TreeMapCardProps<TModel>): React.JSX.Element;
+export default TreeMapCard;

package/dist/cards/geoLayers.d.ts

@@ -0,0 +1,23 @@
+/** World countries (world-atlas, ~110 m). */
+export declare const GEO_URL_WORLD = "https://cdn.jsdelivr.net/npm/world-atlas@2/countries-110m.json";
+/** IBGE — Brazilian states at maximum quality (~1 MB). */
+export declare const GEO_URL_BRAZIL_STATES = "https://servicodados.ibge.gov.br/api/v3/malhas/paises/BR?formato=application/vnd.geo+json&qualidade=maxima&intrarregiao=UF";
+/** IBGE — Brazilian municipalities at minimum quality (~3.5 MB). Use sparingly. */
+export declare const GEO_URL_BRAZIL_MUNICIPALITIES = "https://servicodados.ibge.gov.br/api/v3/malhas/paises/BR?formato=application/vnd.geo+json&qualidade=minima&intrarregiao=municipio";
+/**
+ * The layer set the legacy app used everywhere: world countries as the base
+ * fill + Brazilian state boundaries as an overlay. Exported as a *named*
+ * default a host opts into (`<GeoLayersProvider layers={brazilGeoLayers}>`
+ * or `geoUrl={brazilGeoLayers}`); the cards' built-in default is the world
+ * base alone.
+ */
+export declare const brazilGeoLayers: readonly string[];
+/** Cards' built-in default when neither a prop nor a provider sets layers. */
+export declare const worldGeoLayers: readonly string[];
+/** Sets the geography layer URLs for every map card in a subtree. */
+export declare const GeoLayersProvider: import('react').Provider<readonly string[] | null>;
+/**
+ * Resolves the layers for a map card: explicit prop → nearest provider →
+ * {@link worldGeoLayers}.
+ */
+export declare function useGeoLayers(override?: string | readonly string[]): readonly string[];

package/dist/cards/index.d.ts

@@ -0,0 +1,24 @@
+export { MetricCard } from './MetricCard';
+export type { MetricCardProps } from './MetricCard';
+export { MetricGroupCard } from './MetricGroupCard';
+export type { MetricGroupCardProps } from './MetricGroupCard';
+export { GaugeCard } from './GaugeCard';
+export type { GaugeCardProps, GaugeThreshold } from './GaugeCard';
+export { GaugeGroup } from './GaugeGroup';
+export type { GaugeGroupProps } from './GaugeGroup';
+export { DataTableCard } from './DataTableCard';
+export type { DataTableCardProps, DataTableColumn, ColumnFormats } from './DataTableCard';
+export { ChartCard, chartShade } from './ChartCard';
+export type { ChartCardProps, ChartSeries, ChartType, AxisConfig } from './ChartCard';
+export { TreeMapCard } from './TreeMapCard';
+export type { TreeMapCardProps } from './TreeMapCard';
+export { MapBubblesCard } from './MapBubbles';
+export type { MapBubblesProps, MapBubble } from './MapBubbles';
+export { MapConnectionsCard } from './MapConnections';
+export type { MapConnectionsProps, MapConnection } from './MapConnections';
+export { GEO_URL_WORLD, GEO_URL_BRAZIL_STATES, GEO_URL_BRAZIL_MUNICIPALITIES, brazilGeoLayers, worldGeoLayers, GeoLayersProvider, useGeoLayers, } from './geoLayers';
+export { computeMapViewport, BASE_SCALE } from './mapUtils';
+export type { MapViewport } from './mapUtils';
+export { CONTINENT_PATHS, MAP_VIEWBOX, latLngToXY } from './worldMapPath';
+export { useContainerRectangle } from './useContainerRectangle';
+export { warnIfMuiXLicenseMissing } from './licenseGuard';

package/dist/cards/licenseGuard.d.ts

@@ -0,0 +1,9 @@
+/**
+ * `DataTableCard` renders MUI X DataGrid **Pro**, whose licence key must be set
+ * by the HOST before first render (`LicenseInfo.setLicenseKey(...)` at boot —
+ * this package never ships a key). Without one the grid draws a watermark and
+ * logs a licence error; this guard makes the cause obvious once per session.
+ */
+export declare function warnIfMuiXLicenseMissing(): void;
+/** Test seam. */
+export declare function resetMuiXLicenseWarning(): void;

package/dist/cards/mapUtils.d.ts

@@ -0,0 +1,23 @@
+export declare const BASE_SCALE = 150;
+export interface MapViewport {
+    center: [number, number];
+    zoom: number;
+}
+/**
+ * Computes the projection center and zoom multiplier to best fit a set of
+ * coordinates.
+ *
+ * Priority:
+ *  1. Both `center` and `defaultZoom` provided → use them directly.
+ *  2. `autoFit` enabled (default) → derive center/zoom from coordinates.
+ *  3. `defaultZoom` only → derive center from data, apply the given zoom.
+ *  4. `center` only → use it, derive zoom from data.
+ */
+export declare function computeMapViewport(coords: {
+    lat: number;
+    lng: number;
+}[], opts?: {
+    autoFit?: boolean;
+    defaultZoom?: number;
+    center?: [number, number];
+}): MapViewport;

package/dist/cards/useContainerRectangle.d.ts

@@ -0,0 +1,9 @@
+import { default as React } from 'react';
+/**
+ * Width/height of a container element, kept fresh with a ResizeObserver.
+ * Local copy of the chat library's hook of the same name (a runtime import of
+ * `@aintela/chat` would drag the whole chat barrel into every card).
+ */
+export declare function useContainerRectangle(ref: React.RefObject<HTMLElement | null>, initialWidth?: number, initialHeight?: number, 
+/** Re-attach the observer when this changes (the element may mount after the first render). */
+remeasureKey?: unknown): [number, number];

package/dist/cards/worldMapPath.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Simplified equirectangular world map for dashboard visualizations.
+ * Coordinates: viewBox 0 0 1000 500, where x = (lng+180)/360*1000, y = (90-lat)/180*500.
+ */
+export declare const CONTINENT_PATHS: string[];
+export declare const MAP_VIEWBOX = "0 0 1000 500";
+export declare function latLngToXY(lat: number, lng: number): [number, number];

package/dist/cards.d.ts

@@ -0,0 +1,2 @@
+export * from './cards/index'
+export {}

package/dist/cards.js

@@ -0,0 +1,28 @@
+import { B as e, C as r, a as o, D as C, G as L, b as d, c as i, d as t, e as G, f as n, M, g as _, h as p, i as u, j as T, T as E, k as I, l as c, m as A, n as l, u as R, o as S, w as g, p as B } from "./index-wtSLspPh.js";
+export {
+  e as BASE_SCALE,
+  r as CONTINENT_PATHS,
+  o as ChartCard,
+  C as DataTableCard,
+  L as GEO_URL_BRAZIL_MUNICIPALITIES,
+  d as GEO_URL_BRAZIL_STATES,
+  i as GEO_URL_WORLD,
+  t as GaugeCard,
+  G as GaugeGroup,
+  n as GeoLayersProvider,
+  M as MAP_VIEWBOX,
+  _ as MapBubblesCard,
+  p as MapConnectionsCard,
+  u as MetricCard,
+  T as MetricGroupCard,
+  E as TreeMapCard,
+  I as brazilGeoLayers,
+  c as chartShade,
+  A as computeMapViewport,
+  l as latLngToXY,
+  R as useContainerRectangle,
+  S as useGeoLayers,
+  g as warnIfMuiXLicenseMissing,
+  B as worldGeoLayers
+};
+//# sourceMappingURL=cards.js.map

package/dist/cards.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cards.js","sources":[],"sourcesContent":[],"names":[],"mappings":";"}

package/dist/client/BiClient.d.ts

@@ -0,0 +1,160 @@
+/**
+ * The one seam between this package and a server. Every hook, viewer and
+ * inline component reaches the network through a `BiClient`; nothing in the
+ * package reads `process.env`, `import.meta.env` or a hard-coded host.
+ *
+ * `createBiClient({ baseUrl })` gives you the default REST layout the legacy
+ * .NET WSServer exposes (`/Query/...`, `/Dashboard/...`, `/SubAgent/...`,
+ * `/open/...`). Every route is a function on `routes`, so a host whose server
+ * lays the endpoints out differently (the AIA `aia-bi` API, an AgentsServer
+ * artifact route) overrides just the routes it changes.
+ */
+export type BiFetch = (input: string, init?: RequestInit) => Promise<Response>;
+export interface ArtifactUrlScope {
+    /** Chat session that produced the artifact (the default scope). */
+    sessionId?: string;
+    /** When set, takes priority over `sessionId` — the artifact belongs to a saved dashboard. */
+    dashboardId?: string;
+}
+export interface QueryExecutionBody {
+    parameters?: Record<string, unknown>;
+    /** Admin-only runtime dataset override (parameterised dashboards). */
+    datasetOverride?: string;
+}
+export interface PagedQueryBody extends QueryExecutionBody {
+    page: number;
+    pageSize: number;
+    sort: Array<{
+        field: string;
+        dir: 'asc' | 'desc';
+    }>;
+    filter: Array<{
+        field: string;
+        op: string;
+        value: unknown;
+    }>;
+}
+export interface ExportQueryBody extends QueryExecutionBody {
+    sort: Array<{
+        field: string;
+        dir: 'asc' | 'desc';
+    }>;
+    filter: Array<{
+        field: string;
+        op: string;
+        value: unknown;
+    }>;
+}
+export interface BiRoutes {
+    /** POST — run a registered query (by hash) for a dashboard. */
+    query(dashboardId: string, queryHash: string, opts: {
+        noCache?: boolean;
+    }): string;
+    /** POST — one page of a server-side view. */
+    queryPage(dashboardId: string, viewId: string): string;
+    /** POST — distinct values of one column of a view (filter dropdowns). */
+    queryDistinct(dashboardId: string, viewId: string, field: string): string;
+    /** POST — full-rowset export of a view. */
+    queryExport(dashboardId: string, viewId: string, format: 'csv' | 'xlsx'): string;
+    /** GET — the option rows behind an auto-complete filter. */
+    filterOptions(dashboardId: string, filterId: string): string;
+    /** GET — a dashboard document (draft). */
+    dashboard(dashboardId: string): string;
+    /** GET — sub-agent status while a dashboard is being generated. */
+    subAgentStatus(sessionId: string, subAgentId: string): string;
+    /** GET — the compiled CJS dashboard bundle. */
+    dashboardBundle(sessionId: string, scriptFileName: string): string;
+    /** URL of an image artifact (matplotlib PNG) for `<img src>`. */
+    artifact(src: string, scope: ArtifactUrlScope): string;
+    /** URL of an HTML artifact for `<iframe src>`. */
+    htmlArtifact(src: string, scope: ArtifactUrlScope): string;
+    /** GET — every dashboard the caller can see (lean list). */
+    dashboardList(): string;
+    /** GET — the draft whose `originalSessionId` is `sessionId` (404 when none). */
+    dashboardBySession(sessionId: string): string;
+    /** POST — create or update a dashboard document (`{ ...metadata, draft: {...} }`). */
+    dashboardUpsert(): string;
+    /** POST — overwrite one dashboard (move to folder, rename, …). */
+    dashboardUpdate(dashboardId: string): string;
+    /** DELETE — remove a dashboard. */
+    dashboardDelete(dashboardId: string): string;
+    /** POST — one of the verb routes: share / unshare / pin / unpin / publishAsDefault / unpublishAsDefault. */
+    dashboardAction(dashboardId: string, action: DashboardActionName): string;
+    /** GET (list) / POST (create) — dashboard folders. */
+    folders(): string;
+    /** GET / PATCH / DELETE — one folder. */
+    folder(folderId: string): string;
+    /** POST — share / unshare a folder (cascades to its dashboards). */
+    folderAction(folderId: string, action: FolderActionName): string;
+    /** GET — folders with their dashboards plus the root-level dashboards. */
+    folderHierarchy(): string;
+}
+export type DashboardActionName = 'share' | 'unshare' | 'pin' | 'unpin' | 'publishAsDefault' | 'unpublishAsDefault';
+export type FolderActionName = 'share' | 'unshare';
+export interface BiClientOptions {
+    /** Server origin, e.g. `https://bi.example.com`. No trailing slash needed. */
+    baseUrl: string;
+    /** `fetch` implementation (defaults to `globalThis.fetch`); inject for tests or a custom transport. */
+    fetch?: BiFetch;
+    /** Returns the `Authorization` header value (`Bearer …`) or `undefined` for none. May be async. */
+    getAuthHeader?: () => string | undefined | Promise<string | undefined>;
+    /** Extra headers on every request. */
+    headers?: Record<string, string>;
+    /** Route overrides — any subset of {@link BiRoutes}. */
+    routes?: Partial<BiRoutes>;
+    /**
+     * Legacy image URLs carried a `?t=<now>` cache-buster because the proxy
+     * served mutable files. Off by default; a host fronting a mutable store
+     * can turn it back on.
+     */
+    cacheBustArtifacts?: boolean;
+}
+export interface BiClient {
+    readonly baseUrl: string;
+    readonly routes: BiRoutes;
+    /** Low-level request: prefixes `baseUrl` on relative paths and adds auth + default headers. */
+    request(path: string, init?: RequestInit): Promise<Response>;
+    /** Same as `request`, but throws a descriptive `Error` on a non-2xx status. */
+    requestOk(path: string, init?: RequestInit): Promise<Response>;
+    runQuery<T = unknown>(dashboardId: string, queryHash: string, body: QueryExecutionBody, opts?: {
+        noCache?: boolean;
+        signal?: AbortSignal;
+    }): Promise<T>;
+    getQueryPage<T = unknown>(dashboardId: string, viewId: string, body: PagedQueryBody): Promise<T>;
+    getDistinctValues(dashboardId: string, viewId: string, field: string, body: QueryExecutionBody): Promise<{
+        values: Array<string | null>;
+        truncated?: boolean;
+    } | null>;
+    exportQuery(dashboardId: string, viewId: string, format: 'csv' | 'xlsx', body: ExportQueryBody): Promise<Blob>;
+    getFilterOptions<T = unknown>(dashboardId: string, filterId: string): Promise<T | null>;
+    getDashboard<T = unknown>(dashboardId: string): Promise<T>;
+    getSubAgentStatus<T = unknown>(sessionId: string, subAgentId: string): Promise<T | null>;
+    fetchDashboardBundle(sessionId: string, scriptFileName: string): Promise<string>;
+    artifactUrl(src: string, scope?: ArtifactUrlScope): string;
+    iframeUrl(src: string, scope?: ArtifactUrlScope): string;
+    listDashboards<T = unknown>(): Promise<T[]>;
+    /** `null` when no dashboard is bound to the session. */
+    getDashboardBySession<T = unknown>(sessionId: string): Promise<T | null>;
+    /** POST the upsert payload; resolves to the server's document (raw, un-flattened). */
+    upsertDashboard<T = unknown>(payload: unknown): Promise<T>;
+    updateDashboard(dashboardId: string, dashboard: unknown): Promise<void>;
+    /** `false` when the server answered 404. */
+    deleteDashboard(dashboardId: string): Promise<boolean>;
+    dashboardAction(dashboardId: string, action: DashboardActionName): Promise<void>;
+    listFolders<T = unknown>(): Promise<T[]>;
+    getFolder<T = unknown>(folderId: string): Promise<T>;
+    createFolder<T = unknown>(name: string, description?: string): Promise<T>;
+    updateFolder<T = unknown>(folderId: string, patch: unknown): Promise<T>;
+    deleteFolder(folderId: string): Promise<boolean>;
+    folderAction(folderId: string, action: FolderActionName): Promise<void>;
+    getDashboardHierarchy<T = unknown>(): Promise<T>;
+}
+/** The legacy WSServer / Express layout. Override per route through `BiClientOptions.routes`. */
+export declare function defaultBiRoutes(baseUrl: string, cacheBust: boolean): BiRoutes;
+/**
+ * ISO-8601 date strings → `Date` on JSON parse (the .NET server serialises
+ * `DateTime` as ISO). Same shape as the chat library's `dateReviver`, kept
+ * local so this subpath has no runtime dependency on it.
+ */
+export declare function biDateReviver(_key: string, value: unknown): unknown;
+export declare function createBiClient(options: BiClientOptions): BiClient;