@aintela/bi 0.2.0

package/dist/composer.js.map

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

package/dist/createBiTheme-TyUv_UHM.js

@@ -0,0 +1,93 @@
+var r = Object.defineProperty;
+var i = (e, t) => r(e, "name", { value: t, configurable: !0 });
+import { useTheme as o, createTheme as s } from "@mui/material/styles";
+const c = {
+  series: [
+    "#b8781f",
+    // amber
+    "#3f6fb5",
+    // blue
+    "#7a5ea8",
+    // violet
+    "#2f8f62",
+    // green
+    "#c65b5b",
+    // coral
+    "#1f8a8a",
+    // teal
+    "#8a6a4f",
+    // brown
+    "#5b6fc4"
+    // indigo
+  ],
+  positive: "#2e7d32",
+  negative: "#c62828",
+  neutral: "#6b6b6b"
+}, u = {
+  series: [
+    "#e0a458",
+    // amber (v2 accent)
+    "#7d9bd1",
+    // muted blue
+    "#9c8bb5",
+    // muted lavender
+    "#5eb88a",
+    // green
+    "#d97a7a",
+    // coral
+    "#4db6ac",
+    // teal
+    "#bcaaa4",
+    // warm grey
+    "#7986cb"
+    // indigo
+  ],
+  positive: "#5eb88a",
+  negative: "#d97a7a",
+  neutral: "#9e9e9e"
+};
+function a(e) {
+  const t = e.palette.mode === "dark" ? u : c, n = e.palette.bi;
+  return n ? {
+    series: n.series && n.series.length > 0 ? n.series : t.series,
+    positive: n.positive ?? t.positive,
+    negative: n.negative ?? t.negative,
+    neutral: n.neutral ?? t.neutral
+  } : t;
+}
+i(a, "resolveBiPalette");
+function f(e) {
+  const t = a(e);
+  return e.palette.bi === t ? e : s(e, { palette: { bi: t } });
+}
+i(f, "withBiPalette");
+function d(e) {
+  const t = e && b(e) ? e : s(e ?? {});
+  return f(t);
+}
+i(d, "createBiTheme");
+function b(e) {
+  var t;
+  return typeof e.spacing == "function" && typeof ((t = e.breakpoints) == null ? void 0 : t.up) == "function";
+}
+i(b, "isTheme");
+function g(e, t) {
+  const { series: n } = a(e);
+  return n[(t % n.length + n.length) % n.length];
+}
+i(g, "biSeriesColor");
+function v() {
+  const e = o();
+  return a(e);
+}
+i(v, "useBiPalette");
+export {
+  c as a,
+  u as b,
+  g as c,
+  d,
+  a as r,
+  v as u,
+  f as w
+};
+//# sourceMappingURL=createBiTheme-TyUv_UHM.js.map

package/dist/createBiTheme-TyUv_UHM.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"createBiTheme-TyUv_UHM.js","sources":["../src/theme/biPalette.ts","../src/theme/createBiTheme.ts"],"sourcesContent":["// ─────────────────────────────────────────────────────────────────────────────\n// THE ONLY FILE IN THIS PACKAGE THAT MAY CONTAIN A COLOUR LITERAL.\n//\n// Everything else reads colours from the MUI theme (`theme.palette.*`,\n// `alpha(...)`, `useBiPalette()`) or from the CSS custom properties that\n// <BiThemeBridge/> derives from it. The ESLint `no-restricted-syntax` rule,\n// stylelint and `tests/theme/colourLiterals.test.ts` all enforce that; this\n// file is their single allow-list entry.\n//\n// Hosts normally override these in their own `createTheme({ palette: { bi } })`.\n// The values here are only the defaults `withBiPalette()` falls back to when a\n// host did not set `palette.bi`, chosen per `palette.mode`.\n// ─────────────────────────────────────────────────────────────────────────────\n\n/** The BI-specific slice of the MUI palette. */\nexport interface BiPalette {\n    /** Categorical series colours, used in order by charts, pies, treemaps and map bubbles. */\n    series: string[];\n    /** \"Good\" trend / gauge band. */\n    positive: string;\n    /** \"Bad\" trend / gauge band. */\n    negative: string;\n    /** Flat trend / neutral band. */\n    neutral: string;\n}\n\ndeclare module '@mui/material/styles' {\n    interface Palette {\n        bi: BiPalette;\n    }\n    interface PaletteOptions {\n        bi?: Partial<BiPalette>;\n    }\n}\n\n/** Series set tuned for a light canvas (deeper, more saturated hues). */\nexport const biLightPalette: BiPalette = {\n    series: [\n        '#b8781f', // amber\n        '#3f6fb5', // blue\n        '#7a5ea8', // violet\n        '#2f8f62', // green\n        '#c65b5b', // coral\n        '#1f8a8a', // teal\n        '#8a6a4f', // brown\n        '#5b6fc4', // indigo\n    ],\n    positive: '#2e7d32',\n    negative: '#c62828',\n    neutral: '#6b6b6b',\n};\n\n/** Series set tuned for a dark canvas (the legacy Envision v2 chart palette, extended). */\nexport const biDarkPalette: BiPalette = {\n    series: [\n        '#e0a458', // amber (v2 accent)\n        '#7d9bd1', // muted blue\n        '#9c8bb5', // muted lavender\n        '#5eb88a', // green\n        '#d97a7a', // coral\n        '#4db6ac', // teal\n        '#bcaaa4', // warm grey\n        '#7986cb', // indigo\n    ],\n    positive: '#5eb88a',\n    negative: '#d97a7a',\n    neutral: '#9e9e9e',\n};\n","import { createTheme, useTheme } from '@mui/material/styles';\nimport type { Theme, ThemeOptions } from '@mui/material/styles';\nimport { biDarkPalette, biLightPalette, type BiPalette } from './biPalette';\n\n/**\n * Resolve the BI palette for a theme without mutating it: the host's\n * `palette.bi` wins field by field, the mode-appropriate default fills the\n * gaps. Safe to call on a theme that never heard of `palette.bi`.\n */\nexport function resolveBiPalette(theme: Theme): BiPalette {\n    const defaults = theme.palette.mode === 'dark' ? biDarkPalette : biLightPalette;\n    const own = (theme.palette as Partial<{ bi: Partial<BiPalette> }>).bi;\n    if (!own) return defaults;\n    return {\n        series: own.series && own.series.length > 0 ? own.series : defaults.series,\n        positive: own.positive ?? defaults.positive,\n        negative: own.negative ?? defaults.negative,\n        neutral: own.neutral ?? defaults.neutral,\n    };\n}\n\n/**\n * Returns a theme whose `palette.bi` is fully populated. When the host already\n * set every field this is the same theme instance; otherwise a new theme is\n * derived with `createTheme(theme, { palette: { bi } })` so every other\n * theme field is preserved.\n */\nexport function withBiPalette(theme: Theme): Theme {\n    const resolved = resolveBiPalette(theme);\n    const own = (theme.palette as Partial<{ bi: Partial<BiPalette> }>).bi;\n    if (own === resolved) return theme;\n    return createTheme(theme, { palette: { bi: resolved } });\n}\n\n/**\n * `createTheme` with the BI augmentation applied. Accepts either a finished\n * theme (`createBiTheme(myTheme)`) or plain `ThemeOptions`\n * (`createBiTheme({ palette: { mode: 'light' } })`).\n */\nexport function createBiTheme(base?: Theme | ThemeOptions): Theme {\n    const theme = base && isTheme(base) ? base : createTheme(base ?? {});\n    return withBiPalette(theme);\n}\n\nfunction isTheme(value: Theme | ThemeOptions): value is Theme {\n    return typeof (value as Theme).spacing === 'function' && typeof (value as Theme).breakpoints?.up === 'function';\n}\n\n/** i-th series colour of the theme's BI palette, wrapping around. */\nexport function biSeriesColor(theme: Theme, index: number): string {\n    const { series } = resolveBiPalette(theme);\n    return series[((index % series.length) + series.length) % series.length];\n}\n\n/** Hook form of {@link resolveBiPalette} — reads the ambient MUI theme. */\nexport function useBiPalette(): BiPalette {\n    const theme = useTheme();\n    return resolveBiPalette(theme);\n}\n"],"names":["biLightPalette","biDarkPalette","resolveBiPalette","theme","defaults","own","__name","withBiPalette","resolved","createTheme","createBiTheme","base","isTheme","value","_a","biSeriesColor","index","series","useBiPalette","useTheme"],"mappings":";;;AAoCO,MAAMA,IAA4B;AAAA,EACrC,QAAQ;AAAA,IACJ;AAAA;AAAA,IACA;AAAA;AAAA,IACA;AAAA;AAAA,IACA;AAAA;AAAA,IACA;AAAA;AAAA,IACA;AAAA;AAAA,IACA;AAAA;AAAA,IACA;AAAA;AAAA,EAAA;AAAA,EAEJ,UAAU;AAAA,EACV,UAAU;AAAA,EACV,SAAS;AACb,GAGaC,IAA2B;AAAA,EACpC,QAAQ;AAAA,IACJ;AAAA;AAAA,IACA;AAAA;AAAA,IACA;AAAA;AAAA,IACA;AAAA;AAAA,IACA;AAAA;AAAA,IACA;AAAA;AAAA,IACA;AAAA;AAAA,IACA;AAAA;AAAA,EAAA;AAAA,EAEJ,UAAU;AAAA,EACV,UAAU;AAAA,EACV,SAAS;AACb;AC1DO,SAASC,EAAiBC,GAAyB;AACtD,QAAMC,IAAWD,EAAM,QAAQ,SAAS,SAASF,IAAgBD,GAC3DK,IAAOF,EAAM,QAAgD;AACnE,SAAKE,IACE;AAAA,IACH,QAAQA,EAAI,UAAUA,EAAI,OAAO,SAAS,IAAIA,EAAI,SAASD,EAAS;AAAA,IACpE,UAAUC,EAAI,YAAYD,EAAS;AAAA,IACnC,UAAUC,EAAI,YAAYD,EAAS;AAAA,IACnC,SAASC,EAAI,WAAWD,EAAS;AAAA,EAAA,IALpBA;AAOrB;AAVgBE,EAAAJ,GAAA;AAkBT,SAASK,EAAcJ,GAAqB;AAC/C,QAAMK,IAAWN,EAAiBC,CAAK;AAEvC,SADaA,EAAM,QAAgD,OACvDK,IAAiBL,IACtBM,EAAYN,GAAO,EAAE,SAAS,EAAE,IAAIK,EAAA,GAAY;AAC3D;AALgBF,EAAAC,GAAA;AAYT,SAASG,EAAcC,GAAoC;AAC9D,QAAMR,IAAQQ,KAAQC,EAAQD,CAAI,IAAIA,IAAOF,EAAYE,KAAQ,EAAE;AACnE,SAAOJ,EAAcJ,CAAK;AAC9B;AAHgBG,EAAAI,GAAA;AAKhB,SAASE,EAAQC,GAA6C;;AAC1D,SAAO,OAAQA,EAAgB,WAAY,cAAc,SAAQC,IAAAD,EAAgB,gBAAhB,gBAAAC,EAA6B,OAAO;AACzG;AAFSR,EAAAM,GAAA;AAKF,SAASG,EAAcZ,GAAca,GAAuB;AAC/D,QAAM,EAAE,QAAAC,EAAA,IAAWf,EAAiBC,CAAK;AACzC,SAAOc,GAASD,IAAQC,EAAO,SAAUA,EAAO,UAAUA,EAAO,MAAM;AAC3E;AAHgBX,EAAAS,GAAA;AAMT,SAASG,IAA0B;AACtC,QAAMf,IAAQgB,EAAA;AACd,SAAOjB,EAAiBC,CAAK;AACjC;AAHgBG,EAAAY,GAAA;"}

package/dist/data/ChartCardDefaultsContext.d.ts

@@ -0,0 +1,43 @@
+import { default as React } from 'react';
+/**
+ * Chart defaults — a host (or a dashboard viewer) can override the series
+ * palette for a subtree and turn on "mono-shade per category" so single-series
+ * bar charts use shades of one hue instead of the categorical palette.
+ *
+ * `palette` is the per-dashboard override; when absent, charts read
+ * `theme.palette.bi.series` (see `useBiPalette`).
+ */
+export interface ChartCardDefaults {
+    /** Replaces `theme.palette.bi.series` for series and pie / donut slice colours. */
+    palette?: readonly string[];
+    /**
+     * When true, single-series bar charts colour each *category* (data row)
+     * with a different opacity of the base series colour.
+     */
+    monoShadePerCategory?: boolean;
+    /**
+     * When true, each ChartCard mounted under the provider gets a different
+     * primer colour from the palette in round-robin mount order.
+     */
+    rotateBasePerChart?: boolean;
+    /**
+     * Internal: provider-supplied counter used by ChartCard to claim a slot
+     * index on first mount. Use `ChartCardDefaultsProvider` rather than
+     * setting this directly.
+     */
+    allocateChartSlot?: () => number;
+}
+export declare const ChartCardDefaultsContext: React.Context<ChartCardDefaults>;
+export declare function useChartCardDefaults(): ChartCardDefaults;
+export interface ChartCardDefaultsProviderProps {
+    palette?: readonly string[];
+    monoShadePerCategory?: boolean;
+    rotateBasePerChart?: boolean;
+    children: React.ReactNode;
+}
+/**
+ * Wraps a subtree in a `ChartCardDefaultsContext`. Keeps a monotonically
+ * increasing counter across child ChartCard mounts so each captures a stable
+ * slot index on first render (not reset on parent re-renders).
+ */
+export declare const ChartCardDefaultsProvider: React.FC<ChartCardDefaultsProviderProps>;

package/dist/data/dataUtils.d.ts

@@ -0,0 +1,152 @@
+import { QueryResult } from './queryModel';
+import { DataTableColumn } from '../cards/DataTableCard';
+export type TypeMap = {
+    string: string;
+    number: number;
+    date: Date;
+    boolean: boolean;
+    'string[]': string[];
+    'number[]': number[];
+    'date[]': Date[];
+    'boolean[]': boolean[];
+};
+/**
+ * Name-only field type — the legacy / simple shape:
+ *   `id: 'string', amount: 'number'`
+ *
+ * Continues to be the canonical form for most columns; only
+ * dropdown-filtered columns need the richer {@link FieldDescriptor}
+ * object form.
+ */
+export type FieldTypeName = keyof TypeMap;
+/**
+ * Object-form field descriptor used to declare richer column
+ * metadata that the table needs at build time:
+ *
+ *  - `values: T[]`         — static dropdown filter (singleSelect)
+ *  - `values: 'distinct'`  — dynamic dropdown, values fetched
+ *                            from `/Query/.../distinct/{column}`
+ *  - `multiple: true`      — multi-select dropdown (server-side
+ *                            `isAnyOf` operator)
+ *
+ * Columns without dropdown semantics (numbers, free-text strings,
+ * dates) keep the simple {@link FieldTypeName} form.
+ */
+export interface FieldDescriptor<T extends FieldTypeName = FieldTypeName> {
+    /** Base data type the column carries. */
+    type: T;
+    /**
+     * If a literal array: those are the dropdown choices.
+     * If `'distinct'`: the lazy hook fetches the values from the
+     *   server on mount (cached per (view, params) on the server).
+     * Omitted: no dropdown — falls back to whatever the type's
+     *   default filter UI is.
+     */
+    values?: ReadonlyArray<TypeMap[T]> | 'distinct';
+    /**
+     * `true` enables a multi-select dropdown that emits the
+     * `isAnyOf` operator. Default is single-select (`is`).
+     */
+    multiple?: boolean;
+}
+/**
+ * Either form is accepted in {@link defineSchema}'s input shape.
+ * Existing callers passing plain strings keep working unchanged.
+ */
+export type FieldType = FieldTypeName | FieldDescriptor;
+/**
+ * Pulls the underlying TypeMap entry out of either form, so
+ * `InferModel<{ id: 'string'; status: { type: 'string'; values: ['A'] } }>`
+ * resolves to `{ id: string; status: string }`.
+ */
+type FieldTypeBase<F> = F extends FieldTypeName ? F : F extends FieldDescriptor<infer T> ? T : never;
+export type InferModel<S extends Record<string, FieldType>> = {
+    -readonly [K in keyof S]: TypeMap[FieldTypeBase<S[K]>];
+};
+/**
+ * Normalizes a field type entry to its base name. Used internally
+ * by the schema builders so the simple and object forms share one
+ * code path for column-type / formatter lookup.
+ */
+export declare function extractFieldTypeName(f: FieldType): FieldTypeName;
+/**
+ * Returns the descriptor associated with a field entry, if any.
+ * Simple-form entries (just a string) return `undefined`.
+ */
+export declare function extractFieldDescriptor(f: FieldType): FieldDescriptor | undefined;
+export type ColumnSchema<S extends Record<string, FieldType>> = {
+    [K in keyof S & string]: {
+        configure(config: Partial<Omit<DataTableColumn<InferModel<S>, TypeMap[FieldTypeBase<S[K]>]>, 'field'>>): ColumnSchema<S>;
+    };
+} & {
+    readonly definition: S;
+    build(): DataTableColumn<InferModel<S>>[];
+};
+export declare function defineSchema<const S extends Record<string, FieldType>>(schema: S): ColumnSchema<S>;
+export declare function toNumber(v: unknown): number;
+export declare function toDate(v: unknown): Date | string;
+export declare function toBoolean(v: unknown): boolean;
+export declare function toStr(v: unknown): string;
+export declare class DataResult<TModel extends Record<string, any>> {
+    rows: TModel[];
+    columns: (keyof TModel & string)[];
+    private schema;
+    private _columnSchema?;
+    length: () => number;
+    get columnSchema(): ColumnSchema<any>;
+    set columnSchema(value: ColumnSchema<any>);
+    constructor(data: QueryResult | null | undefined, schema: Record<string, FieldType>);
+    first(): TModel | null;
+    last(): TModel | null;
+    isEmpty(): boolean;
+    column<K extends keyof TModel & string>(key: K): TModel[K][];
+    sum(key: keyof TModel & string): number;
+    avg(key: keyof TModel & string): number;
+    min(key: keyof TModel & string): number;
+    max(key: keyof TModel & string): number;
+    groupBy<K extends keyof TModel & string>(key: K): Map<string, DataResult<TModel>>;
+    sortedBy(key: keyof TModel & string, order?: 'asc' | 'desc'): DataResult<TModel>;
+    distinct(key: string): DataResult<TModel>;
+    slice(start: number, end?: number): DataResult<TModel>;
+    take(count: number): DataResult<TModel>;
+    filter(predicate: (row: TModel) => boolean): DataResult<TModel>;
+    map<U extends Record<string, any>>(fn: (row: TModel, index: number) => U): DataResult<U>;
+    clone(rows: Record<string, any>[], newSchema?: Record<string, FieldType>): DataResult<TModel>;
+}
+type ArrayKeys<T> = {
+    [K in keyof T]: NonNullable<T[K]> extends any[] ? K : never;
+}[keyof T];
+type ArrayItem<T, K extends keyof T> = NonNullable<T[K]> extends (infer U)[] ? U & Record<string, any> : never;
+/** Wrap a plain array directly into a DataResult. */
+export declare function toDashResult<TItem extends Record<string, any>>(source: TItem[]): DataResult<TItem>;
+/** Wrap an object's array field into a DataResult, auto-detecting the first array property. */
+export declare function toDashResult<TInput extends Record<string, any>, K extends ArrayKeys<TInput> = ArrayKeys<TInput>>(source: TInput, arrayKey?: K): DataResult<ArrayItem<TInput, K>>;
+/** Wrap a plain array directly into a DataResult. */
+export declare function toDataResultFromList<TItem extends Record<string, any>>(source: TItem[]): DataResult<TItem>;
+/** Wrap an object's array field into a DataResult, auto-detecting the first array property. */
+export declare function toDataResultFromList<TInput extends Record<string, any>, K extends ArrayKeys<TInput> = ArrayKeys<TInput>>(source: TInput, arrayKey?: K): DataResult<ArrayItem<TInput, K>>;
+export declare function formatCompact(value: number, decimals?: number, addSuffix?: boolean, info?: any): string;
+export declare function formatNumber(value: number, options?: {
+    decimals?: number;
+    locale?: string;
+}): string;
+export declare function formatCurrency(value: number, options?: {
+    currency?: string;
+    locale?: string;
+}): string;
+export declare function formatPercent(value: number, options?: {
+    decimals?: number;
+    isRatio?: boolean;
+}): string;
+export declare function formatBoolean(value: boolean | number): string;
+export declare function formatDate(date: Date | null | undefined, format?: string): string;
+export declare function formatISODate(date: Date | null | undefined): string;
+export declare function truncateText(text: string, maxLength: number, suffix?: string): string;
+export declare function capitalize(text: string): string;
+export declare function toTitleCase(text: string): string;
+export declare function computeDomain(values: number[], padding?: number): [number, number];
+export declare function computeTicks(min: number, max: number, count?: number): number[];
+export declare function percentChange(previous: number, current: number): number | null;
+export declare function trendArrow(value: number): '↑' | '↓' | '→';
+export declare function trendColor(value: number, positiveIsGood?: boolean): 'success' | 'error' | 'default';
+export {};

package/dist/data/index.d.ts

@@ -0,0 +1,5 @@
+export * from './dataUtils';
+export type { QueryResult, QueryResultRow, ResultField, IRow, IGeneratedQueryResult, IGeneratedQueryResultRow } from './queryModel';
+export { ChartCardDefaultsContext, ChartCardDefaultsProvider, useChartCardDefaults } from './ChartCardDefaultsContext';
+export type { ChartCardDefaults, ChartCardDefaultsProviderProps } from './ChartCardDefaultsContext';
+export { useBiPalette, biSeriesColor, resolveBiPalette } from '../theme/createBiTheme';

package/dist/data/queryModel.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Wire shape of a query result as the server returns it: positional
+ * `values[]` per row aligned with `headers[]`. Shared by `DataResult`, the
+ * data hooks and the filter components.
+ */
+export interface ResultField {
+    v?: string | null;
+    vs?: string[] | null;
+}
+export interface QueryResultRow {
+    values: ResultField[];
+}
+export interface QueryResult {
+    headers: string[];
+    rows: QueryResultRow[];
+}
+/** A result row keyed by header name (the auto-complete filter's option shape). */
+export interface IRow {
+    [key: string]: string;
+}
+/** Legacy aliases kept for code compiled against the old `QueryModel.ts`. */
+export type IGeneratedQueryResultRow = QueryResultRow;
+export type IGeneratedQueryResult = QueryResult;

package/dist/data.d.ts

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

package/dist/data.js

@@ -0,0 +1,37 @@
+import { D as e, c as s, a as r, b as o, d as m, e as l, f as u, g as i, h as c, i as f, j as C, k as n, l as D, m as p, p as d, t as x, n as h, o as b, q as B, r as P, s as S, u as T, v, w as F, x as N } from "./dataUtils-CAUE5uZY.js";
+import { C as g, a as k, u as w } from "./ChartCardDefaultsContext-Cl5T25H0.js";
+import { c as j, r as q, u as z } from "./createBiTheme-TyUv_UHM.js";
+export {
+  g as ChartCardDefaultsContext,
+  k as ChartCardDefaultsProvider,
+  e as DataResult,
+  j as biSeriesColor,
+  s as capitalize,
+  r as computeDomain,
+  o as computeTicks,
+  m as defineSchema,
+  l as extractFieldDescriptor,
+  u as extractFieldTypeName,
+  i as formatBoolean,
+  c as formatCompact,
+  f as formatCurrency,
+  C as formatDate,
+  n as formatISODate,
+  D as formatNumber,
+  p as formatPercent,
+  d as percentChange,
+  q as resolveBiPalette,
+  x as toBoolean,
+  h as toDashResult,
+  b as toDataResultFromList,
+  B as toDate,
+  P as toNumber,
+  S as toStr,
+  T as toTitleCase,
+  v as trendArrow,
+  F as trendColor,
+  N as truncateText,
+  z as useBiPalette,
+  w as useChartCardDefaults
+};
+//# sourceMappingURL=data.js.map

package/dist/data.js.map

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