drizzle-cube 0.4.40 → 0.4.41

package/dist/cli/index.cjs

@@ -0,0 +1,439 @@
+#!/usr/bin/env node
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+//#endregion
+let node_util = require("node:util");
+let node_fs = require("node:fs");
+node_fs = __toESM(node_fs);
+let node_path = require("node:path");
+node_path = __toESM(node_path);
+//#region src/cli/commands/charts.ts
+/**
+* Charts CLI commands
+*
+* Provides scaffolding for custom chart plugins.
+*/
+var BUILT_IN_CHARTS = {
+	bar: "Bar chart — compare values across categories",
+	line: "Line chart — show trends over time",
+	area: "Area chart — line chart with filled areas",
+	pie: "Pie chart — show proportions of a whole",
+	scatter: "Scatter chart — show relationships between two measures",
+	bubble: "Bubble chart — scatter with size dimension",
+	radar: "Radar chart — multi-axis comparison",
+	radialBar: "Radial bar chart — circular bar chart",
+	treemap: "Treemap — hierarchical data as nested rectangles",
+	table: "Data table — sortable tabular display",
+	activityGrid: "Activity grid — GitHub-style contribution calendar",
+	kpiNumber: "KPI number — single metric display",
+	kpiDelta: "KPI delta — metric with change indicator",
+	kpiText: "KPI text — text-based metric",
+	funnel: "Funnel chart — conversion funnel visualization",
+	sankey: "Sankey diagram — flow visualization",
+	sunburst: "Sunburst chart — hierarchical pie chart",
+	heatmap: "Heatmap — color-coded matrix",
+	boxPlot: "Box plot — statistical distribution",
+	waterfall: "Waterfall chart — cumulative values",
+	candlestick: "Candlestick chart — financial OHLC data",
+	gauge: "Gauge — meter-style value display",
+	measureProfile: "Measure profile — detailed measure analysis"
+};
+/**
+* drizzle-cube charts list
+*/
+function chartsList() {
+	console.log("\nAvailable built-in chart types:\n");
+	const maxLen = Math.max(...Object.keys(BUILT_IN_CHARTS).map((k) => k.length));
+	for (const [type, desc] of Object.entries(BUILT_IN_CHARTS)) console.log(`  ${type.padEnd(maxLen + 2)} ${desc}`);
+	console.log(`\nUse --from <type> with 'charts init' to copy a built-in as starting point.`);
+	console.log(`Example: npx drizzle-cube charts init --from bar\n`);
+}
+/**
+* drizzle-cube charts init
+*/
+function chartsInit() {
+	const { values } = (0, node_util.parseArgs)({
+		options: {
+			from: {
+				type: "string",
+				short: "f"
+			},
+			output: {
+				type: "string",
+				short: "o",
+				default: "./src/charts"
+			},
+			name: {
+				type: "string",
+				short: "n"
+			}
+		},
+		strict: false
+	});
+	const outputDir = values.output;
+	const fromBuiltIn = values.from;
+	const customName = values.name;
+	if (fromBuiltIn) {
+		if (!BUILT_IN_CHARTS[fromBuiltIn]) {
+			console.error(`\nUnknown chart type: "${fromBuiltIn}"`);
+			console.error(`Run 'npx drizzle-cube charts list' to see available types.\n`);
+			process.exit(1);
+		}
+		scaffoldFromBuiltIn(fromBuiltIn, outputDir, customName);
+	} else scaffoldExample(outputDir, customName);
+}
+function scaffoldExample(outputDir, customName) {
+	const name = customName || "MyCustomChart";
+	const chartType = camelCase(name);
+	ensureDir(outputDir);
+	const componentPath = node_path.default.join(outputDir, `${name}.tsx`);
+	writeIfNotExists(componentPath, generateExampleComponent(name));
+	const configPath = node_path.default.join(outputDir, `${name}.config.ts`);
+	writeIfNotExists(configPath, generateExampleConfig(name, chartType));
+	const indexPath = node_path.default.join(outputDir, "index.ts");
+	writeIfNotExists(indexPath, generateRegistrationExample(name, chartType));
+	console.log(`
+Chart plugin scaffolded in ${outputDir}/
+
+Files created:
+  ${componentPath}        — Chart component
+  ${configPath}   — Chart configuration (drop zones, display options)
+  ${indexPath}             — Registration example
+
+Next steps:
+  1. Edit ${name}.tsx to implement your chart rendering
+  2. Configure drop zones in ${name}.config.ts
+  3. Register in your app:
+
+     import { customCharts } from '${outputDir}'
+
+     <CubeProvider customCharts={customCharts} ...>
+       <App />
+     </CubeProvider>
+`);
+}
+function scaffoldFromBuiltIn(chartType, outputDir, customName) {
+	const pascalType = chartType.charAt(0).toUpperCase() + chartType.slice(1);
+	const name = customName || `Custom${pascalType}Chart`;
+	const customType = camelCase(name);
+	const sourceDir = findPackageChartsDir();
+	if (!sourceDir) {
+		console.log(`
+Could not find drizzle-cube chart source files.
+Generating a template based on the ${chartType} chart instead.
+`);
+		scaffoldExample(outputDir, name);
+		return;
+	}
+	const fileName = {
+		bar: "BarChart",
+		line: "LineChart",
+		area: "AreaChart",
+		pie: "PieChart",
+		scatter: "ScatterChart",
+		bubble: "BubbleChart",
+		radar: "RadarChart",
+		radialBar: "RadialBarChart",
+		treemap: "TreeMapChart",
+		table: "DataTable",
+		activityGrid: "ActivityGridChart",
+		kpiNumber: "KpiNumber",
+		kpiDelta: "KpiDelta",
+		kpiText: "KpiText",
+		funnel: "FunnelChart",
+		sankey: "SankeyChart",
+		sunburst: "SunburstChart",
+		heatmap: "HeatMapChart",
+		boxPlot: "BoxPlotChart",
+		waterfall: "WaterfallChart",
+		candlestick: "CandlestickChart",
+		gauge: "GaugeChart",
+		measureProfile: "MeasureProfileChart"
+	}[chartType];
+	if (!fileName) {
+		console.error(`No file mapping for chart type: ${chartType}`);
+		scaffoldExample(outputDir, name);
+		return;
+	}
+	const componentSource = node_path.default.join(sourceDir, `${fileName}.tsx`);
+	const configSource = node_path.default.join(sourceDir, `${fileName}.config.ts`);
+	ensureDir(outputDir);
+	if (node_fs.default.existsSync(componentSource)) {
+		const rewritten = rewriteImports(node_fs.default.readFileSync(componentSource, "utf-8"));
+		writeIfNotExists(node_path.default.join(outputDir, `${name}.tsx`), rewritten);
+	}
+	if (node_fs.default.existsSync(configSource)) {
+		const rewritten = rewriteImports(node_fs.default.readFileSync(configSource, "utf-8"));
+		writeIfNotExists(node_path.default.join(outputDir, `${name}.config.ts`), rewritten);
+	}
+	writeIfNotExists(node_path.default.join(outputDir, "index.ts"), generateRegistrationFromBuiltIn(name, customType, chartType, fileName));
+	console.log(`
+Chart copied from built-in '${chartType}' to ${outputDir}/
+
+Files created:
+  ${node_path.default.join(outputDir, `${name}.tsx`)}        — Chart component (copied from ${fileName})
+  ${node_path.default.join(outputDir, `${name}.config.ts`)}   — Chart configuration
+  ${node_path.default.join(outputDir, "index.ts")}            — Registration example
+
+The chart is registered as type '${customType}' (not '${chartType}'), so
+the built-in is preserved. Change the type to '${chartType}' to override it.
+
+Next steps:
+  1. Customize the component and config
+  2. Register in your app:
+
+     import { customCharts } from '${outputDir}'
+
+     <CubeProvider customCharts={customCharts} ...>
+       <App />
+     </CubeProvider>
+`);
+}
+function generateExampleComponent(name) {
+	return `import React from 'react'
+import type { ChartProps } from 'drizzle-cube/client'
+
+/**
+ * ${name} — Custom chart component
+ *
+ * Receives the same ChartProps as all drizzle-cube charts:
+ * - data: raw query result rows
+ * - chartConfig: axis mapping (xAxis, yAxis, series fields)
+ * - displayConfig: visual options (colors, legend, etc.)
+ * - queryObject: the original CubeQuery
+ * - height: container height
+ * - colorPalette: theme color palette
+ * - onDataPointClick: drill-down handler
+ * - drillEnabled: whether drill-down is active
+ */
+const ${name} = React.memo(function ${name}({
+  data,
+  chartConfig,
+  displayConfig = {},
+  height = '100%',
+}: ChartProps) {
+  if (!data || data.length === 0) {
+    return (
+      <div
+        style={{
+          display: 'flex', alignItems: 'center', justifyContent: 'center',
+          height: typeof height === 'number' ? \`\${height}px\` : height,
+          color: '#888', fontSize: '14px',
+        }}
+      >
+        No data available
+      </div>
+    )
+  }
+
+  const xField = chartConfig?.xAxis?.[0]
+  const yField = chartConfig?.yAxis?.[0]
+
+  return (
+    <div style={{ height: typeof height === 'number' ? \`\${height}px\` : height, overflow: 'auto' }}>
+      {/* Replace this with your chart rendering logic */}
+      <table style={{ width: '100%', borderCollapse: 'collapse' }}>
+        <thead>
+          <tr>
+            {xField && <th style={{ textAlign: 'left', padding: '8px', borderBottom: '2px solid #eee' }}>{xField}</th>}
+            {yField && <th style={{ textAlign: 'right', padding: '8px', borderBottom: '2px solid #eee' }}>{yField}</th>}
+          </tr>
+        </thead>
+        <tbody>
+          {data.map((row, i) => (
+            <tr key={i}>
+              {xField && <td style={{ padding: '8px', borderBottom: '1px solid #eee' }}>{String(row[xField] ?? '')}</td>}
+              {yField && <td style={{ padding: '8px', borderBottom: '1px solid #eee', textAlign: 'right' }}>{String(row[yField] ?? '')}</td>}
+            </tr>
+          ))}
+        </tbody>
+      </table>
+    </div>
+  )
+})
+
+export default ${name}
+`;
+}
+function generateExampleConfig(name, chartType) {
+	return `import type { ChartTypeConfig } from 'drizzle-cube/client'
+
+/**
+ * Configuration for ${name}
+ *
+ * - label: Display name in the chart type picker
+ * - dropZones: Define which axes/fields the chart accepts
+ * - displayOptionsConfig: Define visual configuration options
+ */
+export const ${chartType}Config: ChartTypeConfig = {
+  label: '${name.replace(/([A-Z])/g, " $1").trim()}',
+  description: 'A custom chart type',
+  useCase: 'Use this chart when you need ...',
+
+  dropZones: [
+    {
+      key: 'xAxis',
+      label: 'X-Axis (Categories)',
+      mandatory: false,
+      acceptTypes: ['dimension', 'timeDimension'],
+      emptyText: 'Drop dimensions here',
+    },
+    {
+      key: 'yAxis',
+      label: 'Y-Axis (Values)',
+      mandatory: true,
+      acceptTypes: ['measure'],
+      emptyText: 'Drop measures here',
+    },
+  ],
+
+  displayOptionsConfig: [
+    {
+      key: 'showLegend',
+      label: 'Show Legend',
+      type: 'boolean',
+      defaultValue: true,
+    },
+  ],
+}
+`;
+}
+function generateRegistrationExample(name, chartType) {
+	return `import type { ChartDefinition } from 'drizzle-cube/client'
+import ${name} from './${name}'
+import { ${chartType}Config } from './${name}.config'
+
+/**
+ * Custom chart definitions to pass to CubeProvider.
+ *
+ * Usage:
+ *   import { customCharts } from './charts'
+ *
+ *   <CubeProvider customCharts={customCharts} ...>
+ *     <App />
+ *   </CubeProvider>
+ */
+export const customCharts: ChartDefinition[] = [
+  {
+    type: '${chartType}',
+    label: '${name.replace(/([A-Z])/g, " $1").trim()}',
+    config: ${chartType}Config,
+    component: ${name},
+  },
+]
+`;
+}
+function generateRegistrationFromBuiltIn(name, customType, _builtInType, fileName) {
+	const configExportName = fileName.charAt(0).toLowerCase() + fileName.slice(1) + "Config";
+	return `import type { ChartDefinition } from 'drizzle-cube/client'
+import ${name} from './${name}'
+import { ${configExportName} } from './${name}.config'
+
+/**
+ * Custom chart definitions to pass to CubeProvider.
+ *
+ * Usage:
+ *   import { customCharts } from './charts'
+ *
+ *   <CubeProvider customCharts={customCharts} ...>
+ *     <App />
+ *   </CubeProvider>
+ */
+export const customCharts: ChartDefinition[] = [
+  {
+    type: '${customType}',
+    label: ${configExportName}.label || '${name.replace(/([A-Z])/g, " $1").trim()}',
+    config: ${configExportName},
+    component: ${name},
+  },
+]
+`;
+}
+function camelCase(name) {
+	return name.charAt(0).toLowerCase() + name.slice(1);
+}
+function ensureDir(dir) {
+	if (!node_fs.default.existsSync(dir)) node_fs.default.mkdirSync(dir, { recursive: true });
+}
+function writeIfNotExists(filePath, content) {
+	if (node_fs.default.existsSync(filePath)) {
+		console.warn(`  Skipping ${filePath} (already exists)`);
+		return;
+	}
+	node_fs.default.writeFileSync(filePath, content, "utf-8");
+}
+/**
+* Try to find the chart component source directory from the installed package.
+*/
+function findPackageChartsDir() {
+	const candidates = [node_path.default.resolve(__dirname, "..", "..", "src", "client", "components", "charts"), node_path.default.resolve(__dirname, "..", "client", "components", "charts")];
+	for (const candidate of candidates) if (node_fs.default.existsSync(candidate)) return candidate;
+	try {
+		const pkgPath = require.resolve("drizzle-cube/package.json");
+		const pkgDir = node_path.default.dirname(pkgPath);
+		const chartsDir = node_path.default.join(pkgDir, "src", "client", "components", "charts");
+		if (node_fs.default.existsSync(chartsDir)) return chartsDir;
+	} catch {}
+	return null;
+}
+/**
+* Rewrite internal drizzle-cube imports to use the public package imports.
+*/
+function rewriteImports(content) {
+	return content.replace(/from\s+['"]\.\.\/\.\.\/charts\/chartConfigs['"]/g, "from 'drizzle-cube/client'").replace(/from\s+['"]\.\.\/\.\.\/charts\/[^'"]+['"]/g, "from 'drizzle-cube/client'").replace(/from\s+['"]\.\.\/\.\.\/types['"]/g, "from 'drizzle-cube/client'").replace(/from\s+['"]\.\.\/\.\.\/hooks\/[^'"]+['"]/g, "from 'drizzle-cube/client'").replace(/from\s+['"]\.\.\/\.\.\/icons['"]/g, "from 'drizzle-cube/client'").replace(/from\s+['"]\.\.\/\.\.\/icons\/[^'"]+['"]/g, "from 'drizzle-cube/client'").replace(/from\s+['"]\.\.\/\.\.\/utils\/[^'"]+['"]/g, "from 'drizzle-cube/client'").replace(/from\s+['"]\.\.\/\.\.\/shared\/[^'"]+['"]/g, "from 'drizzle-cube/client'").replace(/from\s+['"]\.\.\/\.\.\/providers\/[^'"]+['"]/g, "from 'drizzle-cube/client'").replace(/from\s+['"]\.\/([^'"]+)['"]/g, "from 'drizzle-cube/client'");
+}
+//#endregion
+//#region src/cli/index.ts
+/**
+* drizzle-cube CLI
+*
+* Usage:
+*   npx drizzle-cube charts init               # Scaffold an example custom chart
+*   npx drizzle-cube charts init --from bar     # Copy a built-in chart as starting point
+*   npx drizzle-cube charts init -o ./my-charts # Custom output directory
+*   npx drizzle-cube charts list                # List available built-in chart types
+*/
+var { positionals } = (0, node_util.parseArgs)({
+	allowPositionals: true,
+	strict: false
+});
+var [command, subcommand] = positionals;
+if (command === "charts") if (subcommand === "init") chartsInit();
+else if (subcommand === "list") chartsList();
+else console.log(`
+drizzle-cube charts
+
+Commands:
+  drizzle-cube charts init             Scaffold a custom chart
+  drizzle-cube charts init --from bar  Copy a built-in chart as starting point
+  drizzle-cube charts init -o <dir>    Set output directory (default: ./src/charts)
+  drizzle-cube charts list             List available built-in chart types
+`);
+else console.log(`
+drizzle-cube CLI
+
+Commands:
+  drizzle-cube charts   Chart plugin scaffolding tools
+
+Run 'drizzle-cube charts' for more info.
+`);
+//#endregion

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

@@ -1,7 +1,7 @@
-import { ReactNode } from 'react';
+import { ComponentType, ReactNode } from 'react';
 import { ChartType, ChartProps } from '../types';
 /**
- * Check if a chart type is supported
+ * Check if a chart type is supported (built-in or custom plugin)
  */
 export declare function isValidChartType(chartType: string): chartType is ChartType;
 export interface LazyChartProps extends ChartProps {
@@ -51,7 +51,7 @@ export declare function preloadChart(chartType: ChartType): void;
  */
 export declare function preloadCharts(chartTypes: ChartType[]): void;
 /**
- * Get all available chart types
+ * Get all available chart types (built-in + custom plugins)
  */
 export declare function getAvailableChartTypes(): ChartType[];
 /**
@@ -66,3 +66,18 @@ export declare function isChartTypeAvailable(chartType: ChartType): boolean;
  * Get list of chart types that failed to load due to missing dependencies.
  */
 export declare function getUnavailableChartTypes(): ChartType[];
+/**
+ * Register a custom chart component.
+ * Used by the chart plugin system.
+ */
+export declare function registerChartComponent(type: string, component?: ComponentType<ChartProps>, lazyComponent?: () => Promise<{
+    default: ComponentType<ChartProps>;
+}>, dependencies?: {
+    packageName: string;
+    installCommand: string;
+}): void;
+/**
+ * Unregister a custom chart component.
+ * Used by the chart plugin system.
+ */
+export declare function unregisterChartComponent(type: string): void;

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

@@ -1,5 +1,15 @@
-import { ChartConfigRegistry } from './chartConfigs';
+import { ChartTypeConfig, ChartConfigRegistry } from './chartConfigs';
 /**
  * Registry of all chart type configurations
  */
 export declare const chartConfigRegistry: ChartConfigRegistry;
+/**
+ * Register a custom chart config into the registry.
+ * Used by the chart plugin system.
+ */
+export declare function registerChartConfig(type: string, config: ChartTypeConfig): void;
+/**
+ * Unregister a chart config from the registry.
+ * Used by the chart plugin system.
+ */
+export declare function unregisterChartConfig(type: string): void;

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

@@ -0,0 +1,74 @@
+import { ComponentType } from 'react';
+import { ChartProps } from '../types';
+import { ChartTypeConfig } from './chartConfigs';
+import { IconProps } from '../icons/types';
+/**
+ * Complete definition for registering a custom chart type.
+ * Bundles component, config metadata, and optional icon.
+ */
+export interface ChartDefinition {
+    /** Unique chart type identifier (e.g., 'myGantt', 'customBar') */
+    type: string;
+    /** Display label for the chart type picker */
+    label: string;
+    /** Chart type configuration (drop zones, display options, validation) */
+    config: ChartTypeConfig;
+    /** The chart component (eager — loaded immediately) */
+    component?: ComponentType<ChartProps>;
+    /** Lazy-loaded chart component (for code splitting). Use instead of `component`. */
+    lazyComponent?: () => Promise<{
+        default: ComponentType<ChartProps>;
+    }>;
+    /** Optional icon component for the chart type picker */
+    icon?: ComponentType<IconProps>;
+    /** Optional dependency info — shows install instructions if the import fails */
+    dependencies?: {
+        packageName: string;
+        installCommand: string;
+    };
+}
+/**
+ * Central registry for custom chart plugins.
+ *
+ * Coordinates registration across the three internal registries
+ * (config, lazy config cache, chart loader) and provides a
+ * `useSyncExternalStore`-compatible subscription API for React reactivity.
+ */
+declare class ChartPluginRegistry {
+    private customCharts;
+    private builtInBackups;
+    private iconMap;
+    private version;
+    private listeners;
+    /**
+     * Register a custom chart definition.
+     * If `type` matches a built-in chart, the built-in is backed up and can be
+     * restored by calling `unregister()`.
+     */
+    register(definition: ChartDefinition): void;
+    /**
+     * Unregister a custom chart.
+     * If the chart type was a built-in override, the original built-in is restored.
+     */
+    unregister(type: string): void;
+    /** Get the custom icon for a chart type, if registered */
+    getIcon(type: string): ComponentType<IconProps> | undefined;
+    /** Get all registered custom chart type strings */
+    getCustomTypes(): string[];
+    /** Check if a chart type is a custom plugin (not built-in) */
+    isCustom(type: string): boolean;
+    /**
+     * Subscribe to registry changes.
+     * Compatible with React's `useSyncExternalStore`.
+     */
+    subscribe: (listener: () => void) => (() => void);
+    /**
+     * Get a snapshot of the registry version.
+     * Compatible with React's `useSyncExternalStore`.
+     */
+    getSnapshot: () => number;
+    private bump;
+}
+/** Singleton chart plugin registry */
+export declare const chartPluginRegistry: ChartPluginRegistry;
+export {};

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

@@ -88,3 +88,13 @@ export declare function loadAllChartConfigs(): Promise<ChartConfigRegistry>;
  * Useful for testing or when configs need to be reloaded.
  */
 export declare function clearChartConfigCache(): void;
+/**
+ * Register a custom chart config directly into the cache.
+ * Used by the chart plugin system.
+ */
+export declare function registerConfigToCache(type: string, config: ChartTypeConfig): void;
+/**
+ * Remove a custom chart config from the cache.
+ * Used by the chart plugin system.
+ */
+export declare function unregisterConfigFromCache(type: string): void;

package/dist/client/charts.js

@@ -1,15 +1,13 @@
-import { t as e } from "./chunks/chart-data-table-CW_qZDpt.js";
-import { t } from "./chunks/chart-funnel-C9JRW79j.js";
-import { a as n, i as r, n as i, o as a } from "./chunks/chart-activity-grid-wR2Twpo7.js";
-import { t as o } from "./chunks/chart-area-e9ysnatQ.js";
-import { a as s, i as c, n as l, o as u, r as d, s as f, t as p } from "./chunks/charts-loader-gZjOqZwG.js";
-import { a as m, c as h, i as g, n as _, o as v, r as y, s as b, t as x } from "./chunks/lazyChartConfigRegistry-BjhxDaSf.js";
-import { i as S } from "./chunks/utils-3FNmeZJR.js";
-import { t as C } from "./chunks/chart-line-CPhQRMZ7.js";
-import { t as w } from "./chunks/chart-bar-Bx4oKlqo.js";
-import { t as T } from "./chunks/chart-pie-DafSc9sE.js";
-import { t as E } from "./chunks/chart-scatter-J2JNi88S.js";
-import { t as D } from "./chunks/chart-radar-Dz9F5k-B.js";
-import { t as O } from "./chunks/chart-radial-bar-N3MNUL7o.js";
-import { t as k } from "./chunks/chart-tree-map-CbYjko2s.js";
-export { i as CHART_COLORS, r as CHART_MARGINS, e as DataTable, t as FunnelChart, p as LazyChart, n as NEGATIVE_COLOR, a as POSITIVE_COLOR, o as RechartsAreaChart, w as RechartsBarChart, C as RechartsLineChart, T as RechartsPieChart, D as RechartsRadarChart, O as RechartsRadialBarChart, E as RechartsScatterChart, k as RechartsTreeMapChart, x as clearChartConfigCache, S as formatChartData, l as getAvailableChartTypes, _ as getChartConfigAsync, y as getChartConfigSync, d as getUnavailableChartTypes, g as isChartConfigLoaded, c as isChartTypeAvailable, s as isValidChartType, m as loadAllChartConfigs, u as preloadChart, v as preloadChartConfig, b as preloadChartConfigs, f as preloadCharts, h as useChartConfig };
+import { C as e, D as t, E as n, S as r, T as i, _ as a, b as o, g as s, h as c, m as l, p as u, t as d, v as f, w as p, x as m, y as h } from "./chunks/chart-data-table-D4s27-U3.js";
+import { t as g } from "./chunks/chart-funnel-C9JRW79j.js";
+import { a as _, i as v, n as y, o as b } from "./chunks/chart-activity-grid-wR2Twpo7.js";
+import { t as x } from "./chunks/chart-area-e9ysnatQ.js";
+import { i as S } from "./chunks/utils-DMyRayr_.js";
+import { t as C } from "./chunks/chart-line-Bkl5WQAw.js";
+import { t as w } from "./chunks/chart-bar-DVzmau1G.js";
+import { t as T } from "./chunks/chart-pie-Do2YnCxl.js";
+import { t as E } from "./chunks/chart-scatter-YSHOUfXf.js";
+import { t as D } from "./chunks/chart-radar-C7gQkH70.js";
+import { t as O } from "./chunks/chart-radial-bar-DHqCck3x.js";
+import { t as k } from "./chunks/chart-tree-map-BlhcXK1F.js";
+export { y as CHART_COLORS, v as CHART_MARGINS, d as DataTable, g as FunnelChart, m as LazyChart, _ as NEGATIVE_COLOR, b as POSITIVE_COLOR, x as RechartsAreaChart, w as RechartsBarChart, C as RechartsLineChart, T as RechartsPieChart, D as RechartsRadarChart, O as RechartsRadialBarChart, E as RechartsScatterChart, k as RechartsTreeMapChart, u as clearChartConfigCache, S as formatChartData, r as getAvailableChartTypes, l as getChartConfigAsync, c as getChartConfigSync, e as getUnavailableChartTypes, s as isChartConfigLoaded, p as isChartTypeAvailable, i as isValidChartType, a as loadAllChartConfigs, n as preloadChart, f as preloadChartConfig, h as preloadChartConfigs, t as preloadCharts, o as useChartConfig };