drizzle-cube 0.9.0 → 0.9.2

package/dist/adapters/utils.cjs

@@ -1 +1 @@
-Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require("./utils-DXWQUJbD.cjs");exports.buildTransformedQuery=e.t,exports.calculateQueryComplexity=e.n,exports.formatCubeResponse=e.r,exports.formatErrorResponse=e.i,exports.formatMetaResponse=e.a,exports.formatSqlResponse=e.o,exports.formatSqlString=e.x,exports.generateRequestId=e.s,exports.getDatabaseType=e.c,exports.handleBatchRequest=e.l,exports.handleDiscover=e.p,exports.handleDryRun=e.u,exports.handleLoad=e.m,exports.handleSuggest=e.d,exports.handleValidate=e.f,exports.normalizeQueryFields=e.h;
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require("./utils-BkdzL4m9.cjs");exports.buildTransformedQuery=e.t,exports.calculateQueryComplexity=e.n,exports.formatCubeResponse=e.r,exports.formatErrorResponse=e.i,exports.formatMetaResponse=e.a,exports.formatSqlResponse=e.o,exports.formatSqlString=e.x,exports.generateRequestId=e.s,exports.getDatabaseType=e.c,exports.handleBatchRequest=e.l,exports.handleDiscover=e.p,exports.handleDryRun=e.u,exports.handleLoad=e.m,exports.handleSuggest=e.d,exports.handleValidate=e.f,exports.normalizeQueryFields=e.h;

package/dist/adapters/utils.js

@@ -1,2 +1,2 @@
-import { a as e, c as t, d as n, f as r, h as i, i as a, l as o, m as s, n as c, o as l, p as u, r as d, s as f, t as p, u as m, x as h } from "./utils-C_RKaP0n.js";
+import { a as e, c as t, d as n, f as r, h as i, i as a, l as o, m as s, n as c, o as l, p as u, r as d, s as f, t as p, u as m, x as h } from "./utils-BY3FDOmN.js";
 export { p as buildTransformedQuery, c as calculateQueryComplexity, d as formatCubeResponse, a as formatErrorResponse, e as formatMetaResponse, l as formatSqlResponse, h as formatSqlString, f as generateRequestId, t as getDatabaseType, o as handleBatchRequest, u as handleDiscover, m as handleDryRun, s as handleLoad, n as handleSuggest, r as handleValidate, i as normalizeQueryFields };

package/dist/cjs/adapters/mcp-app-html.d.ts

@@ -0,0 +1,25 @@
+/**
+ * The bundled MCP App HTML — public subpath `drizzle-cube/mcp-app-html`.
+ *
+ * This is the ~2 MB single-file MCP App (React + charts, inlined by
+ * `vite-plugin-singlefile` → `src/mcp-app/generated-html.ts`). It is only ever
+ * needed when `mcp.app` is enabled and a client lists or reads the
+ * `ui://drizzle-cube/visualization.html` resource, so the MCP transport loads it
+ * with a dynamic `import()` at that moment rather than at adapter import time.
+ *
+ * **Invariant:** nothing reachable from the adapter entries (`hono`, `express`,
+ * `fastify`, `nextjs`, `core`, `utils`) may import this module — or
+ * `../mcp-app/generated-html.js` — statically. A static import drags the blob
+ * into every consumer's server bundle even with `mcp.enabled: false`
+ * (`tests/adapters/mcp-app-html-lazy.test.ts` guards this). The one deliberate
+ * static importer is `mcp-tools.ts` (`drizzle-cube/mcp`), whose `resources`
+ * array is synchronous public API.
+ *
+ * In the published build the transport's `import()` targets the bare specifier
+ * `drizzle-cube/mcp-app-html` (see `vite.config.adapters.ts`), so bundlers that
+ * count every emitted module against a size budget (e.g. wrangler for
+ * Cloudflare Workers) can alias it to a stub exporting `mcpAppHtml = ''` when the
+ * MCP App is not used.
+ */
+/** The bundled MCP App as a single HTML document. Empty string if not yet built. */
+export declare const mcpAppHtml: string;

package/dist/cjs/adapters/mcp-transport.d.ts

@@ -5,8 +5,25 @@ export type { McpAppConfig };
 export { type MCPPrompt };
 export declare const MCP_APP_RESOURCE_URI = "ui://drizzle-cube/visualization.html";
 export declare const MCP_APP_MIME_TYPE = "text/html;profile=mcp-app";
-/** Get the bundled MCP App HTML, optionally with locale config injected. Returns empty string if not yet built. */
-export declare function getMcpAppHtml(config?: McpAppConfig): string;
+/**
+ * Inject the MCP App locale config into an MCP App HTML document. Pure: the
+ * HTML is passed in, so callers decide how (and whether) to load the blob.
+ * Returns `html` unchanged when it is empty (not yet built) or no config is given.
+ */
+export declare function injectMcpAppConfig(html: string, config?: McpAppConfig): string;
+/**
+ * Get the bundled MCP App HTML, optionally with locale config injected.
+ * Returns an empty string if the app is not yet built.
+ *
+ * The ~2 MB HTML blob is loaded with a dynamic `import()` on first use, never at
+ * module load: it is only wanted when `mcp.app` is on and a client actually
+ * lists/reads the visualization resource. Every adapter imports this module, so
+ * a static import here would put the blob in every consumer's server bundle
+ * even with `mcp.enabled: false`. In the published build the specifier is
+ * rewritten to `drizzle-cube/mcp-app-html`, which consumers may alias to a stub
+ * — see `mcp-app-html.ts`.
+ */
+export declare function getMcpAppHtml(config?: McpAppConfig): Promise<string>;
 export type JsonRpcId = string | number | null | undefined;
 export interface JsonRpcRequest {
     jsonrpc: '2.0';

package/dist/cjs/client/charts/chartConfigs.d.ts

@@ -45,8 +45,35 @@ export interface DisplayOptionConfig {
         value: any;
         label: string;
     }>;
+    /**
+     * Which tab the option belongs on. Defaults to `display`.
+     *
+     * The Chart tab exists to answer "what feeds this chart", which for most
+     * types is the axis drop zones. A content-first chart has no zones, and its
+     * equivalent input is a display option — markdown's `content` being the case
+     * in point, which is its whole substance and wants the room. Marking it
+     * `chart` moves it there rather than leaving the tab empty and the editor
+     * squeezed into a sidebar.
+     */
+    placement?: 'chart' | 'display';
     /** Help text shown below the input */
     description?: string;
+    /** Visible rows for a string option's textarea. Defaults to 8. */
+    rows?: number;
+    /**
+     * Render a string option with syntax highlighting rather than as a plain
+     * textarea. Only `markdownTemplate` exists, colouring `{{ }}` expressions,
+     * `{% %}` tags and markdown headings.
+     */
+    syntax?: 'markdownTemplate';
+    /**
+     * External reference for options whose full syntax cannot fit in help text.
+     * Rendered as a link after the description, so the panel can stay short
+     * instead of restating a whole template language badly.
+     */
+    docsUrl?: string;
+    /** Label for the `docsUrl` link — a translation key, like `label`. */
+    docsLabel?: string;
     /** Minimum value for number inputs */
     min?: number;
     /** Maximum value for number inputs */
@@ -54,6 +81,13 @@ export interface DisplayOptionConfig {
     /** Step value for number inputs */
     step?: number;
 }
+/**
+ * Split display options by which tab renders them.
+ *
+ * Shared by the Chart and Display panels so the two cannot disagree and leave
+ * an option shown twice or not at all.
+ */
+export declare function optionsForPlacement(options: DisplayOptionConfig[] | undefined, placement: 'chart' | 'display'): DisplayOptionConfig[];
 /**
  * Whether a chart type can be rendered with the current query shape.
  * Each chart's .config.ts declares its own `isAvailable` to keep requirements

package/dist/cjs/client/components/AnalysisBuilder/AnalysisChartConfigPanel.d.ts

@@ -1,4 +1,4 @@
-import { ChartType, ChartAxisConfig } from '../../types.js';
+import { ChartType, ChartAxisConfig, ChartDisplayConfig, ColorPalette } from '../../types.js';
 import { MetricItem, BreakdownItem } from './types.js';
 import { ChartAvailabilityMap } from '../../shared/chartDefaults.js';
 import { MetaResponse } from '../../shared/types.js';
@@ -13,6 +13,14 @@ interface AnalysisChartConfigPanelProps {
     chartAvailability?: ChartAvailabilityMap;
     onChartTypeChange: (type: ChartType) => void;
     onChartConfigChange: (config: ChartAxisConfig) => void;
+    /**
+     * Display config, for the options a chart asks to render here rather than on
+     * the Display tab — see `placement` on `DisplayOptionConfig`. Optional, since
+     * not every mount of this panel owns the display config.
+     */
+    displayConfig?: ChartDisplayConfig;
+    colorPalette?: ColorPalette;
+    onDisplayConfigChange?: (config: ChartDisplayConfig) => void;
 }
-export default function AnalysisChartConfigPanel({ chartType, chartConfig, metrics, breakdowns, schema, chartAvailability, onChartTypeChange, onChartConfigChange }: AnalysisChartConfigPanelProps): import("react").JSX.Element;
+export default function AnalysisChartConfigPanel({ chartType, chartConfig, metrics, breakdowns, schema, chartAvailability, onChartTypeChange, onChartConfigChange, displayConfig, colorPalette, onDisplayConfigChange }: AnalysisChartConfigPanelProps): import("react").JSX.Element;
 export {};

package/dist/cjs/client/components/AnalysisBuilder/TemplateEditor.d.ts

@@ -0,0 +1,17 @@
+/**
+ * A textarea with syntax highlighting, for the markdown template field.
+ *
+ * A textarea cannot style its own contents, so the text is drawn twice: a
+ * coloured layer underneath, and the real textarea on top with transparent text
+ * and a visible caret. The two only stay aligned if they share every metric
+ * that affects layout — font, size, line height, padding, border, wrapping —
+ * so those live in one constant rather than on each element.
+ */
+interface TemplateEditorProps {
+    value: string;
+    onChange: (value: string) => void;
+    placeholder?: string;
+    rows?: number;
+}
+export default function TemplateEditor({ value, onChange, placeholder, rows }: TemplateEditorProps): import("react").JSX.Element;
+export {};

package/dist/cjs/client/components/AnalysisBuilder/templateSyntax.d.ts

@@ -0,0 +1,26 @@
+/**
+ * A deliberately small tokenizer for the markdown template editor.
+ *
+ * highlight.js, which the debug panels use, has no Knap language and would need
+ * a whole grammar loaded to colour a template. The editor needs far less than a
+ * grammar: it has to tell prose from template code, and within template code
+ * tell a keyword from a variable, a filter, a literal and punctuation. That is
+ * a short list, so it is done directly and costs nothing to load.
+ *
+ * This colours text; it does not understand it. Diagnostics come from Knap's
+ * own parser via `findUnknownReferences`.
+ */
+export type TemplateTokenKind = 'text' | 'heading' | 'delimiter' | 'keyword' | 'identifier' | 'filter' | 'string' | 'number' | 'operator';
+export interface TemplateToken {
+    text: string;
+    kind: TemplateTokenKind;
+}
+/**
+ * Split template source into coloured runs.
+ *
+ * Every character of the input appears in exactly one token, in order, so the
+ * rendered layer lines up with the textarea character for character. An
+ * unterminated `{{` stays plain text rather than swallowing the rest of the
+ * document, which keeps the colouring stable while someone is mid-keystroke.
+ */
+export declare function tokenizeTemplate(source: string): TemplateToken[];

package/dist/cjs/client/components/analyticsPortlet/parsePortletQuery.d.ts

@@ -8,6 +8,18 @@ export interface ParsedPortletQuery {
     serverFlowQuery: ServerFlowQuery | null;
     serverRetentionQuery: ServerRetentionQuery | null;
 }
+/**
+ * Whether a portlet's query string asks for anything the engine could run.
+ *
+ * A chart type marked `skipQuery` does not *require* a query, but it may still
+ * carry one — a markdown portlet with a query renders its content as a data
+ * template. This decides which of the two it is.
+ *
+ * Everything unrunnable reads as "no query": an empty string, `{}` (what the
+ * agent writes for a text portlet), unparseable JSON, or a query whose members
+ * are all empty. The alternate formats count as runnable in their own right.
+ */
+export declare function hasRunnableQuery(query: string): boolean;
 export interface ParsePortletQueryParams {
     query: string;
     shouldSkipQuery: boolean;

package/dist/cjs/client/components/analyticsPortlet/portletRenderState.d.ts

@@ -6,6 +6,13 @@ export interface PortletRenderStateParams {
     hasChartConfig: boolean;
     hasMandatoryFields: boolean;
     shouldSkipQuery: boolean;
+    /**
+     * Whether the chart has something to show even with no rows — true for the
+     * content-first types, meaning those whose config sets `skipQuery`. A
+     * markdown narrative whose whole job is to say "no incidents this week" must
+     * survive an empty result rather than being replaced by the no-data view.
+     */
+    rendersWithoutData: boolean;
     eagerLoad: boolean;
     isVisible: boolean;
     isLoading: boolean;

package/dist/cjs/client/components/charts/MarkdownChart.d.ts

@@ -1,4 +1,4 @@
 import { default as React } from 'react';
 import { ChartProps } from '../../types.js';
-declare const MarkdownChart: React.MemoExoticComponent<({ displayConfig, height, colorPalette }: ChartProps) => React.JSX.Element | null>;
+declare const MarkdownChart: React.MemoExoticComponent<({ data, displayConfig, queryObject, height, colorPalette }: ChartProps) => React.JSX.Element | null>;
 export default MarkdownChart;

package/dist/cjs/client/components/charts/MarkdownChart.helpers.d.ts

@@ -0,0 +1,156 @@
+import { CSSProperties } from 'react';
+import { CubeQuery } from '../../types.js';
+import { MarkdownTemplateDiagnostic } from './markdownTemplate.js';
+/** Body text size class for a fontSize setting. */
+export declare function bodySizeClass(fontSize: string): string;
+/** Text alignment class for an alignment setting. */
+export declare function alignmentClass(alignment: string): string;
+/**
+ * markdown-to-jsx options for the chart's themed elements.
+ *
+ * The `sanitizer` is markdown-to-jsx's own, named rather than left implicit:
+ * template output can carry warehouse values into link and image destinations,
+ * so the protocol policy should be visible in our code.
+ */
+export declare function buildMarkdownOptions(accentColor: string, fontSize: string): {
+    sanitizer: (value: string) => string | null;
+    overrides: {
+        h1: {
+            props: {
+                className: string;
+                style: {
+                    color: string;
+                };
+            };
+        };
+        h2: {
+            props: {
+                className: string;
+                style: {
+                    color: string;
+                };
+            };
+        };
+        h3: {
+            props: {
+                className: string;
+                style: {
+                    color: string;
+                };
+            };
+        };
+        p: {
+            props: {
+                className: string;
+            };
+        };
+        strong: {
+            props: {
+                className: string;
+            };
+        };
+        em: {
+            props: {
+                className: string;
+            };
+        };
+        a: {
+            props: {
+                className: string;
+                target: string;
+                rel: string;
+                style: {
+                    color: string;
+                };
+            };
+        };
+        code: {
+            props: {
+                className: string;
+            };
+        };
+        pre: {
+            props: {
+                className: string;
+            };
+        };
+        ul: {
+            props: {
+                className: string;
+            };
+        };
+        ol: {
+            props: {
+                className: string;
+            };
+        };
+        li: {
+            props: {
+                className: string;
+            };
+        };
+        blockquote: {
+            props: {
+                className: string;
+            };
+        };
+        hr: {
+            props: {
+                className: string;
+                style: {
+                    height: string;
+                    backgroundColor: string;
+                    opacity: number;
+                };
+            };
+        };
+        table: {
+            props: {
+                className: string;
+            };
+        };
+        thead: {
+            props: {
+                className: string;
+            };
+        };
+        th: {
+            props: {
+                className: string;
+            };
+        };
+        td: {
+            props: {
+                className: string;
+            };
+        };
+        tr: {
+            props: {
+                className: string;
+            };
+        };
+    };
+};
+/** The accent stripe, on whichever side the config names. */
+export declare function buildAccentBorderStyle(accentBorder: string, accentColor: string, transparentBackground: boolean): CSSProperties;
+/** The palette colour at `index`, or the chart default. */
+export declare function resolveAccentColor(colors: string[] | undefined, index: number): string;
+/** Rows arrive as `unknown[]`; only plain objects can become template variables. */
+export declare function toTemplateRows(data: unknown): Record<string, unknown>[];
+export interface MarkdownTemplateState {
+    /** Whether the content is a template rather than literal markdown. */
+    isTemplate: boolean;
+    /** The rendered body, or null before the first async render lands. */
+    output: string | null;
+    errors: MarkdownTemplateDiagnostic[];
+    /** References that resolved to nothing, reported alongside the output. */
+    warnings: MarkdownTemplateDiagnostic[];
+}
+/**
+ * Render the chart's content as a Knap template when a query is attached.
+ *
+ * A real query is what distinguishes the two modes, and it has to be the
+ * members rather than the object: several callers pass `{}` for "no query", and
+ * treating that as a template would silently reinterpret every text block.
+ */
+export declare function useMarkdownTemplate(content: string, data: unknown, queryObject: CubeQuery | undefined): MarkdownTemplateState;

package/dist/cjs/client/components/charts/markdownTemplate.d.ts

@@ -0,0 +1,92 @@
+/**
+ * Knap template support for the markdown chart.
+ *
+ * A markdown portlet with a query renders its content as a Knap template rather
+ * than as literal markdown, so a dashboard can carry a written summary that is
+ * computed from live data instead of typed by hand.
+ *
+ * Knap resolves `a.b` as nested member access, so a cube-qualified result key
+ * such as `Employees.avgSalary` is unreachable from a `for` loop or from the
+ * `map` / `where` filters — those see a missing `Employees` object and yield
+ * nothing. Every row is therefore offered three ways:
+ *
+ *   rows      aliased keys (`employees_avg_salary`) — loops and arithmetic
+ *   labelled  human field labels as keys — `{{ labelled | table }}` headers
+ *   data      the raw dotted keys — `{{ data[0]["Employees.avgSalary"] }}`
+ *
+ * `first` and `last` exist because Knap's filters stringify on assignment:
+ * `{% set top = rows | sort:"x" %}` makes `top` a string, so a template cannot
+ * sort and then index. The query's own ordering has to be surfaced directly.
+ */
+/** One result field, in the three namings a template can address it by. */
+export interface MarkdownTemplateField {
+    /** The raw cube-qualified key, e.g. `Employees.avgSalary`. */
+    key: string;
+    /** The template-safe alias, e.g. `employees_avg_salary`. */
+    alias: string;
+    /** The human-readable label, e.g. `Avg Salary`. */
+    label: string;
+}
+/** The variables a markdown template is rendered against. */
+export interface MarkdownTemplateContext {
+    rows: Record<string, unknown>[];
+    labelled: Record<string, unknown>[];
+    data: Record<string, unknown>[];
+    rowCount: number;
+    first: Record<string, unknown> | null;
+    last: Record<string, unknown> | null;
+    fields: MarkdownTemplateField[];
+}
+/** A rendered template, or the diagnostics explaining why it did not render. */
+export interface MarkdownTemplateResult {
+    output: string;
+    errors: MarkdownTemplateDiagnostic[];
+    /**
+     * References the template makes that resolve to nothing. Knap renders an
+     * unknown name as an empty string, so a misspelt field produces a blank
+     * heading rather than any complaint — the failure is invisible at exactly the
+     * moment the author needs to see it.
+     */
+    warnings: MarkdownTemplateDiagnostic[];
+}
+export interface MarkdownTemplateDiagnostic {
+    message: string;
+    line: number;
+    column: number;
+}
+/**
+ * Derive the template alias for a cube-qualified field key.
+ *
+ * `Employees.avgSalary` becomes `employees_avg_salary`. A key that would start
+ * with a digit is prefixed, since Knap identifiers cannot.
+ */
+export declare function aliasForField(key: string): string;
+/**
+ * Build the template variables for a set of result rows.
+ *
+ * @param rows - raw result rows, as `resultSet.rawData()` returns them
+ * @param getFieldLabel - resolves a field key to its human label; pass the
+ *   value of `useCubeFieldLabel()` so labels match the rest of the app
+ */
+export declare function buildTemplateContext(rows: Record<string, unknown>[], getFieldLabel?: (key: string) => string): MarkdownTemplateContext;
+/**
+ * Find references that will silently render as nothing.
+ *
+ * Two mistakes account for nearly all of them: naming a variable the context
+ * does not provide, and reading a field off a row under a name that is not its
+ * alias. Both look identical in the output — a blank space where a value should
+ * be — so they are reported with the names that would have worked.
+ */
+export declare function findUnknownReferences(template: string, context: MarkdownTemplateContext): MarkdownTemplateDiagnostic[];
+/**
+ * Check a template for syntax errors and unknown filters without rendering it.
+ * Synchronous, so an editor can show diagnostics as the author types.
+ */
+export declare function validateTemplate(template: string): MarkdownTemplateDiagnostic[];
+/**
+ * Render a markdown template against result rows.
+ *
+ * Never throws. A broken template reports its diagnostics so the portlet can
+ * show them in place, rather than taking the dashboard down with it.
+ */
+export declare function renderMarkdownTemplate(template: string, context: MarkdownTemplateContext): Promise<MarkdownTemplateResult>;

package/dist/client/charts/chartConfigs.d.ts

@@ -45,8 +45,35 @@ export interface DisplayOptionConfig {
         value: any;
         label: string;
     }>;
+    /**
+     * Which tab the option belongs on. Defaults to `display`.
+     *
+     * The Chart tab exists to answer "what feeds this chart", which for most
+     * types is the axis drop zones. A content-first chart has no zones, and its
+     * equivalent input is a display option — markdown's `content` being the case
+     * in point, which is its whole substance and wants the room. Marking it
+     * `chart` moves it there rather than leaving the tab empty and the editor
+     * squeezed into a sidebar.
+     */
+    placement?: 'chart' | 'display';
     /** Help text shown below the input */
     description?: string;
+    /** Visible rows for a string option's textarea. Defaults to 8. */
+    rows?: number;
+    /**
+     * Render a string option with syntax highlighting rather than as a plain
+     * textarea. Only `markdownTemplate` exists, colouring `{{ }}` expressions,
+     * `{% %}` tags and markdown headings.
+     */
+    syntax?: 'markdownTemplate';
+    /**
+     * External reference for options whose full syntax cannot fit in help text.
+     * Rendered as a link after the description, so the panel can stay short
+     * instead of restating a whole template language badly.
+     */
+    docsUrl?: string;
+    /** Label for the `docsUrl` link — a translation key, like `label`. */
+    docsLabel?: string;
     /** Minimum value for number inputs */
     min?: number;
     /** Maximum value for number inputs */
@@ -54,6 +81,13 @@ export interface DisplayOptionConfig {
     /** Step value for number inputs */
     step?: number;
 }
+/**
+ * Split display options by which tab renders them.
+ *
+ * Shared by the Chart and Display panels so the two cannot disagree and leave
+ * an option shown twice or not at all.
+ */
+export declare function optionsForPlacement(options: DisplayOptionConfig[] | undefined, placement: 'chart' | 'display'): DisplayOptionConfig[];
 /**
  * Whether a chart type can be rendered with the current query shape.
  * Each chart's .config.ts declares its own `isAvailable` to keep requirements

package/dist/client/charts.js

@@ -1,14 +1,14 @@
-import { dt as e, ft as t, gt as n, ht as r, lt as i, mt as a, pt as o, t as s, ut as c } from "./chunks/chart-data-table-CCvvgeG_.js";
-import { d as l, l as u, s as d, u as f } from "./chunks/chart-activity-grid-UZIp9_2E.js";
-import { t as p } from "./chunks/chart-funnel-D2vGQhaz.js";
-import { a as m, i as h, n as g, o as _, r as v, s as y, t as b } from "./chunks/charts-loader-OHpTBq8c.js";
-import { t as x } from "./chunks/chart-area-CEBcvCcn.js";
+import { dt as e, ft as t, gt as n, ht as r, lt as i, mt as a, pt as o, t as s, ut as c } from "./chunks/chart-data-table-Dfup1JpL.js";
+import { d as l, l as u, s as d, u as f } from "./chunks/chart-activity-grid-aIyjUpbJ.js";
+import { t as p } from "./chunks/chart-funnel-DqBD-oth.js";
+import { a as m, i as h, n as g, o as _, r as v, s as y, t as b } from "./chunks/charts-loader-B_ye_C5_.js";
+import { t as x } from "./chunks/chart-area-DCCvp06H.js";
 import { i as S } from "./chunks/utils-CToHkuhU.js";
-import { t as C } from "./chunks/chart-bar-DGh7cpU-.js";
-import { t as w } from "./chunks/chart-line-C4r44HWi.js";
-import { t as T } from "./chunks/chart-pie-BHrPxga2.js";
-import { t as E } from "./chunks/chart-scatter-BHttSxcc.js";
-import { t as D } from "./chunks/chart-radar-I9sOFbG5.js";
-import { t as O } from "./chunks/chart-radial-bar-DeDMMf9P.js";
-import { t as k } from "./chunks/chart-tree-map-CdSwr_zI.js";
+import { t as C } from "./chunks/chart-bar-C8xQ15Aa.js";
+import { t as w } from "./chunks/chart-line-rl9q-vom.js";
+import { t as T } from "./chunks/chart-pie-W4Mk0WFB.js";
+import { t as E } from "./chunks/chart-scatter-BHp1yLvR.js";
+import { t as D } from "./chunks/chart-radar-BXkMOUVC.js";
+import { t as O } from "./chunks/chart-radial-bar-CSw1hCK2.js";
+import { t as k } from "./chunks/chart-tree-map-YBAOj00L.js";
 export { d as CHART_COLORS, u as CHART_MARGINS, s as DataTable, p as FunnelChart, b as LazyChart, f as NEGATIVE_COLOR, l as POSITIVE_COLOR, x as RechartsAreaChart, C as RechartsBarChart, w as RechartsLineChart, T as RechartsPieChart, D as RechartsRadarChart, O as RechartsRadialBarChart, E as RechartsScatterChart, k as RechartsTreeMapChart, i as clearChartConfigCache, S as formatChartData, g as getAvailableChartTypes, c as getChartConfigAsync, e as getChartConfigSync, v as getUnavailableChartTypes, t as isChartConfigLoaded, h as isChartTypeAvailable, m as isValidChartType, o as loadAllChartConfigs, _ as preloadChart, a as preloadChartConfig, r as preloadChartConfigs, y as preloadCharts, n as useChartConfig };