drizzle-cube 0.10.1 → 0.11.1

package/dist/adapters/utils.cjs

@@ -1 +1 @@
-Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require("./utils-CvC1czqb.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-a2p2B6x8.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-CN_bxSiq.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-BaxFceDq.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/client/charts/chartConfigHelpers.d.ts

@@ -21,6 +21,11 @@ export declare function requiresMeasure({ measureCount }: ChartAvailabilityConte
 export declare const targetDisplayOption: DisplayOptionConfig;
 /** Connect-nulls toggle for line/area charts. */
 export declare const connectNullsDisplayOption: DisplayOptionConfig;
+/**
+ * Gap-filling control for time-series charts (issue #1368). `auto` follows the
+ * query, then the cube time dimension's `fillMissingDates`, then fills.
+ */
+export declare const fillMissingDatesDisplayOption: DisplayOptionConfig;
 /** Left Y-axis numeric format control (dual-axis charts). */
 export declare const leftYAxisFormatDisplayOption: DisplayOptionConfig;
 /** Right Y-axis numeric format control (dual-axis charts). */

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

@@ -31,6 +31,8 @@ export interface BreakdownItem {
     isTimeDimension: boolean;
     /** Enable period comparison for time dimensions (compares current filter period vs prior period) */
     enableComparison?: boolean;
+    /** Whether to fill missing buckets for this time dimension. */
+    fillMissingDates?: boolean;
 }
 /** Validation status for query building */
 export type ValidationStatus = 'idle' | 'validating' | 'valid' | 'invalid';
@@ -54,6 +56,8 @@ export interface AnalysisBuilderState {
     order?: Record<string, 'asc' | 'desc'>;
     /** Row limit for the query (sent to server) */
     limit?: number;
+    /** Value for filled time buckets; `null` leaves a gap. Unset fills with 0. */
+    fillMissingDatesValue?: number | null;
     validationStatus: ValidationStatus;
     validationError: string | null;
 }

package/dist/cjs/client/components/AnalysisBuilder/utils/queryUtils.d.ts

@@ -9,8 +9,13 @@ export declare function buildCubeQuery(metrics: MetricItem[], breakdowns: Breakd
  * Record-grain charts list rows rather than aggregates — see
  * `ChartTypeConfig.recordGrain`. Without this, editing a records-table
  * portlet in the builder silently rebuilds its query as a grouped one.
+ *
+ * The server rejects period comparison and `fillMissingDates: true` on an
+ * ungrouped query, so it leaves both out and keeps the date filter. The
+ * breakdowns keep both settings for when the chart switches back. An
+ * explicit `fillMissingDates: false` stays, since the server accepts it.
  */
-ungrouped?: boolean): CubeQuery;
+ungrouped?: boolean, fillMissingDatesValue?: number | null): CubeQuery;
 /**
  * Check if a query has any content
  */

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

@@ -1,5 +1,5 @@
 import { useCubeLoadQuery, useFunnelQuery, useFlowQuery, useRetentionQuery } from '../../hooks/queries/index.js';
-import { CubeQuery, MultiQueryConfig, ServerFunnelQuery } from '../../types.js';
+import { ChartDisplayConfig, CubeQuery, MultiQueryConfig, ServerFunnelQuery } from '../../types.js';
 import { FlowChartData, ServerFlowQuery } from '../../types/flow.js';
 import { RetentionChartData, ServerRetentionQuery } from '../../types/retention.js';
 interface RefreshOptions {
@@ -18,6 +18,8 @@ export interface UsePortletQueryResultsParams {
     shouldSkipQuery: boolean;
     eagerLoad: boolean;
     isVisible: boolean;
+    /** Chart display config — its `fillMissingDates` drives client-side gap filling */
+    displayConfig?: ChartDisplayConfig;
 }
 export interface PortletQueryResults {
     resultSet: ReturnType<typeof useCubeLoadQuery>['resultSet'];

package/dist/cjs/client/hooks/queries/useCubeLoadQuery.d.ts

@@ -1,5 +1,6 @@
 import { CubeQuery, CubeResultSet } from '../../types.js';
 import { QueryWarning } from '../../shared/types.js';
+import { ChartGapFillOptions } from '../../utils/gapFilling.js';
 /**
  * Create a stable query key from a CubeQuery
  * The key includes all query parameters to ensure proper caching
@@ -31,6 +32,12 @@ export interface UseCubeLoadQueryOptions {
      * @default true
      */
     keepPreviousData?: boolean;
+    /**
+     * Fill missing time buckets for a chart (Cube.js-style, client-side). The
+     * server returns observed rows only; when set, the returned result set's rows
+     * are gap-filled per `ChartGapFillOptions`. Omit for raw rows.
+     */
+    gapFill?: ChartGapFillOptions;
 }
 /** Options for the refetch function */
 export interface RefetchOptions {

package/dist/cjs/client/hooks/queries/useMultiCubeLoadQuery.d.ts

@@ -1,4 +1,5 @@
 import { MultiQueryConfig, CubeResultSet } from '../../types.js';
+import { ChartGapFillOptions } from '../../utils/gapFilling.js';
 /**
  * Create a stable query key for multi-query
  */
@@ -29,6 +30,12 @@ export interface UseMultiCubeLoadQueryOptions {
      * @default true
      */
     keepPreviousData?: boolean;
+    /**
+     * Fill missing time buckets for a chart (Cube.js-style, client-side). When
+     * set, each query's rows are gap-filled per `ChartGapFillOptions` before
+     * merging. Omit for raw rows.
+     */
+    gapFill?: ChartGapFillOptions;
 }
 export interface UseMultiCubeLoadQueryResult {
     /** Merged data from all queries */

package/dist/cjs/client/hooks/useAnalysisQuery.d.ts

@@ -1,5 +1,5 @@
 import { DebugDataEntry } from './queries/index.js';
-import { CubeQuery, MultiQueryConfig, FunnelBindingKey, QueryMergeStrategy, AnalysisType } from '../types.js';
+import { CubeQuery, MultiQueryConfig, FunnelBindingKey, QueryMergeStrategy, AnalysisType, ChartDisplayConfig } from '../types.js';
 import { ExecutionStatus } from '../components/AnalysisBuilder/types.js';
 import { ServerFunnelQuery } from '../types/funnel.js';
 import { ServerFlowQuery, FlowChartData } from '../types/flow.js';
@@ -56,6 +56,11 @@ export interface UseAnalysisQueryOptions {
         errors: string[];
         warnings: string[];
     } | null;
+    /**
+     * The chart's gap-filling setting (`displayConfig.fillMissingDates`). Results
+     * are gap-filled client-side per this setting, the query and the cube.
+     */
+    fillMissingDates?: ChartDisplayConfig['fillMissingDates'];
 }
 export interface UseAnalysisQueryResult {
     /** Query execution status */

package/dist/cjs/client/index.d.ts

@@ -71,6 +71,8 @@ export type { DashboardExportFile, DashboardImportResult, DashboardImportError,
 export type { DashboardImportExportState, PendingDashboardImport, FailedDashboardImport, } from './hooks/dashboard/useDashboardImportExport.js';
 export { compressAndEncode, decodeAndDecompress, generateShareUrl, parseShareUrl, isShareableSize } from './utils/shareUtils.js';
 export { isMultiQueryData, mergeQueryResults, mergeResultsConcat, mergeResultsByKey, getCombinedFields, getQueryLabels, getQueryIndices, generateQueryLabel, validateMergeKey } from './utils/multiQueryUtils.js';
+export { fillChartRows, withChartGapFilling } from './utils/gapFilling.js';
+export type { ChartGapFillOptions } from './utils/gapFilling.js';
 export { validateFunnelConfig, validateBindingKeyExists, validateStepQueries, validateBindingKeyForSteps, isMinimumFunnelConfigValid, getAvailableBindingKeyDimensions, getBindingKeyLabel, } from './utils/funnelValidation.js';
 export { getBindingKeyField, getCubeNameFromQuery, formatDuration, transformServerFunnelResult, buildServerFunnelQuery, isFunnelData, buildFunnelConfigFromQueries, } from './utils/funnelExecution.js';
 export { getThemeVariable, setThemeVariable, applyTheme, resetTheme, getTheme, setTheme, isDarkMode, watchThemeChanges, THEME_PRESETS } from './theme/index.js';

package/dist/cjs/client/types.d.ts

@@ -19,6 +19,8 @@ export interface CubeMetaDimension {
     type: string;
     /** Supported granularities for time dimensions (for time-based drill-down) */
     granularities?: TimeGranularity[];
+    /** The cube time dimension's gap-filling default, when it declares one */
+    fillMissingDates?: boolean;
 }
 export interface CubeMetaField {
     name: string;
@@ -146,6 +148,7 @@ export interface ChartDisplayConfig {
     stacked?: boolean;
     stackType?: 'none' | 'normal' | 'percent';
     connectNulls?: boolean;
+    fillMissingDates?: boolean | 'auto';
     showSummary?: boolean;
     showPoints?: boolean;
     showAllXLabels?: boolean;
@@ -400,6 +403,8 @@ export interface CubeQuery {
     limit?: number;
     offset?: number;
     segments?: string[];
+    /** Value for filled time buckets; `null` leaves a gap. Unset fills with 0. */
+    fillMissingDatesValue?: number | null;
     /** When true, returns raw row-level data without GROUP BY or aggregation */
     ungrouped?: boolean;
     /**

package/dist/cjs/client/utils/gapFilling.d.ts

@@ -0,0 +1,52 @@
+import { CubeResultSet } from '../types.js';
+/** A chart's gap-filling preference. */
+export interface ChartGapFillOptions {
+    /** `true`/`false` force filling on/off; `'auto'` or unset defers to the query and cube. */
+    fillMissingDates?: boolean | 'auto';
+}
+/** A time dimension of the query a result came from. */
+export interface ChartGapFillTimeDimension {
+    dimension: string;
+    granularity?: string;
+    dateRange?: string | string[];
+    fillMissingDates?: boolean;
+    compareDateRange?: readonly unknown[];
+}
+/** The parts of a query chart gap filling reads. */
+export interface ChartGapFillQuery {
+    measures?: readonly string[];
+    dimensions?: readonly string[];
+    timeDimensions?: readonly ChartGapFillTimeDimension[];
+    filters?: readonly ChartGapFillFilter[];
+    fillMissingDatesValue?: number | null;
+    ungrouped?: boolean;
+}
+interface ChartGapFillFilter {
+    member?: string;
+    operator?: string;
+    values?: readonly unknown[];
+    dateRange?: string | string[];
+    and?: readonly ChartGapFillFilter[];
+    or?: readonly ChartGapFillFilter[];
+}
+interface TimeDimensionAnnotation {
+    fillMissingDates?: boolean;
+}
+/**
+ * Fill missing time buckets in result rows for a chart.
+ *
+ * Comparison (`compareDateRange`) dimensions are left alone — the server fills
+ * each period already and the rows carry period metadata. Ungrouped queries are
+ * never filled.
+ */
+export declare function fillChartRows(rows: Record<string, unknown>[], query: ChartGapFillQuery, annotation: {
+    timeDimensions?: Record<string, TimeDimensionAnnotation>;
+} | undefined, options?: ChartGapFillOptions): Record<string, unknown>[];
+/**
+ * Wrap a result set so its rows are gap-filled for a chart. The underlying
+ * result set (and the query cache holding it) stays raw, so changing the chart
+ * setting never refetches. Returns the result set unchanged when it does not
+ * carry the query it came from.
+ */
+export declare function withChartGapFilling(resultSet: CubeResultSet, options?: ChartGapFillOptions): CubeResultSet;
+export {};

package/dist/cjs/client/utils/index.d.ts

@@ -6,6 +6,7 @@ export * from './periodUtils.js';
 export * from './pivotUtils.js';
 export * from './syntaxHighlighting.js';
 export * from './comparisonUtils.js';
+export * from './gapFilling.js';
 export { captureThumbnail, isThumbnailCaptureAvailable } from './thumbnail.js';
 export { exportPortletToXlsx, isExportAvailable } from './exportXlsx.js';
 export { createDashboardExport, serializeDashboardExport, parseDashboardExport, readDashboardExportFile, downloadDashboardExport, dashboardExportFilename, normalizeDashboardConfigForExport, } from './dashboardExport.js';

package/dist/cjs/server/ai/query-schema.d.ts

@@ -76,7 +76,7 @@ export declare const QUERY_PARAMS_SCHEMA: {
                 };
                 readonly fillMissingDates: {
                     readonly type: "boolean";
-                    readonly description: "Fill gaps in time series with fillMissingDatesValue (default: true). Requires granularity + dateRange.";
+                    readonly description: "Fill gaps in time series with fillMissingDatesValue. Default: off (observed rows only) unless the cube time dimension enables it. Requires granularity + dateRange.";
                 };
                 readonly compareDateRange: {
                     readonly type: "array";

package/dist/cjs/server/execution/result-post-processor.d.ts

@@ -1,4 +1,4 @@
-import { SemanticQuery } from '../types/index.js';
+import { Cube, SemanticQuery } from '../types/index.js';
 import { DatabaseAdapter } from '../adapters/base-adapter.js';
 /**
  * Normalise time-dimension values in result rows and apply gap filling.
@@ -6,5 +6,7 @@ import { DatabaseAdapter } from '../adapters/base-adapter.js';
  * @param data Raw rows from the database executor
  * @param query The semantic query (for timeDimensions + measures)
  * @param databaseAdapter Adapter used to convert engine-specific date results
+ * @param cubes Cube definitions, for each time dimension's `fillMissingDates`
+ * @param fillByDefault Gap-fill time dimensions neither the query nor the cube configures
  */
-export declare function postProcessResultRows(data: unknown, query: SemanticQuery, databaseAdapter: DatabaseAdapter): Record<string, unknown>[];
+export declare function postProcessResultRows(data: unknown, query: SemanticQuery, databaseAdapter: DatabaseAdapter, cubes?: Map<string, Cube>, fillByDefault?: boolean): Record<string, unknown>[];

package/dist/cjs/server/executor.d.ts

@@ -93,6 +93,8 @@ export declare class QueryExecutor {
      * @param cacheKey - When provided (and a cache provider is configured), the
      *   fresh result is written to the cache. Pass `undefined` to skip caching
      *   (e.g. comparison period sub-queries cache at the comparison level).
+     * @param fillByDefault - Gap-fill time dimensions that neither the query nor
+     *   the cube configures. Only comparison period sub-queries pass `true`.
      */
     private executeStandardQuery;
     /**

package/dist/cjs/server/gap-filler.d.ts

@@ -1,48 +1,13 @@
+import { Cube } from './types/cube.js';
 import { SemanticQuery } from './types/query.js';
-import { TimeGranularity } from './types/core.js';
+export { generateTimeBuckets, fillTimeSeriesGaps, parseDateRange, MAX_GAP_FILL_BUCKETS, type GapFillerConfig } from '../shared/gap-filler.js';
 /**
- * Maximum number of time buckets gap filling will generate. Beyond this, gap
- * filling is skipped entirely (data is returned unmodified) to avoid both
- * runaway memory use and silent truncation of real rows.
- */
-export declare const MAX_GAP_FILL_BUCKETS = 10000;
-export interface GapFillerConfig {
-    /** The time dimension key (e.g., 'Sales.date') */
-    timeDimensionKey: string;
-    /** Time granularity for bucket generation */
-    granularity: TimeGranularity;
-    /** Date range [start, end] */
-    dateRange: [Date, Date];
-    /** Value to fill for missing measures (default: 0) */
-    fillValue: number | null;
-    /** List of measure keys in the data */
-    measures: string[];
-    /** List of dimension keys in the data (excluding time dimensions) */
-    dimensions: string[];
-}
-/**
- * Generate all time buckets for a given date range and granularity
- */
-export declare function generateTimeBuckets(startDate: Date, endDate: Date, granularity: TimeGranularity): Date[];
-/**
- * Fill time series gaps in query result data
+ * Apply server-side gap filling to query result rows.
  *
- * @param data - Original query result data
- * @param config - Gap filling configuration
- * @returns Data with gaps filled
- */
-export declare function fillTimeSeriesGaps(data: Record<string, unknown>[], config: GapFillerConfig): Record<string, unknown>[];
-/**
- * Parse date range from query time dimension
- * Handles both array format ['2024-01-01', '2024-01-31'] and string format
- */
-export declare function parseDateRange(dateRange: string | string[] | undefined): [Date, Date] | null;
-/**
- * Apply gap filling to query result data based on query configuration
+ * Precedence per time dimension: the query's `fillMissingDates`, then the cube
+ * dimension's, then `fillByDefault`. Ungrouped queries are never filled.
  *
- * @param data - Original query result data
- * @param query - The semantic query
- * @param measures - List of measure names in the result
- * @returns Data with gaps filled (if applicable)
+ * @param fillByDefault - Fill when neither the query nor the cube says. Only
+ *   comparison-period sub-queries pass `true`, to keep periods aligned.
  */
-export declare function applyGapFilling(data: Record<string, unknown>[], query: SemanticQuery, measures: string[]): Record<string, unknown>[];
+export declare function applyServerGapFilling(data: Record<string, unknown>[], query: SemanticQuery, cubes?: Map<string, Cube>, fillByDefault?: boolean): Record<string, unknown>[];

package/dist/cjs/server/types/core.d.ts

@@ -165,6 +165,8 @@ export interface TimeDimensionAnnotation {
     shortTitle: string;
     type: string;
     granularity?: TimeGranularity;
+    /** The cube time dimension's `fillMissingDates`, when it declares one */
+    fillMissingDates?: boolean;
 }
 /**
  * Type enums and constants

package/dist/cjs/server/types/cube.d.ts

@@ -191,6 +191,18 @@ export interface Dimension {
      * @example ['year', 'quarter', 'month', 'day'] for a custom subset
      */
     granularities?: TimeGranularity[];
+    /**
+     * Whether missing time buckets are filled for this time dimension when a
+     * query or chart does not say. Only applies when type is 'time'.
+     *
+     * - Server: a query that omits `fillMissingDates` is filled only when this is
+     *   `true`. Unset means observed rows only (the Cube.js default).
+     * - Charts: fill gaps by default, like Cube.js. Set `false` where a missing
+     *   bucket means "no data" rather than zero, e.g. daily snapshot tables.
+     *
+     * A query's or chart's own `fillMissingDates` always wins.
+     */
+    fillMissingDates?: boolean;
 }
 /**
  * Measure definition

package/dist/cjs/server/types/metadata.d.ts

@@ -77,6 +77,11 @@ export interface DimensionMetadata {
      * Used for time-based drill-down (year -> quarter -> month -> week -> day)
      */
     granularities?: TimeGranularity[];
+    /**
+     * The time dimension's `fillMissingDates` default, when the cube declares one.
+     * Charts use it to decide whether to fill missing buckets.
+     */
+    fillMissingDates?: boolean;
 }
 /**
  * Hierarchy metadata for structured drill-down paths

package/dist/cjs/server/types/query.d.ts

@@ -135,7 +135,8 @@ export interface TimeDimension {
     /**
      * Fill missing dates in time series with the fill value.
      * Requires both granularity and dateRange to be set.
-     * Default: true (enabled)
+     * Default: the cube time dimension's `fillMissingDates`, else false — the
+     * server returns observed rows only and charts fill gaps client-side.
      */
     fillMissingDates?: boolean;
     /**

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

@@ -21,6 +21,11 @@ export declare function requiresMeasure({ measureCount }: ChartAvailabilityConte
 export declare const targetDisplayOption: DisplayOptionConfig;
 /** Connect-nulls toggle for line/area charts. */
 export declare const connectNullsDisplayOption: DisplayOptionConfig;
+/**
+ * Gap-filling control for time-series charts (issue #1368). `auto` follows the
+ * query, then the cube time dimension's `fillMissingDates`, then fills.
+ */
+export declare const fillMissingDatesDisplayOption: DisplayOptionConfig;
 /** Left Y-axis numeric format control (dual-axis charts). */
 export declare const leftYAxisFormatDisplayOption: DisplayOptionConfig;
 /** Right Y-axis numeric format control (dual-axis charts). */

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-zSjYEy0r.js";
-import { d as l, l as u, s as d, u as f } from "./chunks/chart-activity-grid-Bbc58UJD.js";
-import { t as p } from "./chunks/chart-funnel-CuOSCsbt.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-Bz9yHkW1.js";
-import { t as x } from "./chunks/chart-area-9uCXIvMN.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-Cxd0cdAl.js";
+import { d as l, l as u, s as d, u as f } from "./chunks/chart-activity-grid-Ly_-2B-f.js";
+import { t as p } from "./chunks/chart-funnel-71Kn4eeF.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-DoLQqFXg.js";
+import { t as x } from "./chunks/chart-area-D3l-71Wy.js";
 import { i as S } from "./chunks/utils-CToHkuhU.js";
-import { t as C } from "./chunks/chart-bar-C5a1T9Ce.js";
-import { t as w } from "./chunks/chart-line-CjW9Yo03.js";
-import { t as T } from "./chunks/chart-pie-BTb5nKd7.js";
-import { t as E } from "./chunks/chart-scatter-Bdj95OeV.js";
-import { t as D } from "./chunks/chart-radar-8384sPlX.js";
-import { t as O } from "./chunks/chart-radial-bar-CuBmmOTU.js";
-import { t as k } from "./chunks/chart-tree-map-CtJADX87.js";
+import { t as C } from "./chunks/chart-bar-BaTyQOqs.js";
+import { t as w } from "./chunks/chart-line-BNqjUowg.js";
+import { t as T } from "./chunks/chart-pie-D8r9HCZ4.js";
+import { t as E } from "./chunks/chart-scatter-CH82md0L.js";
+import { t as D } from "./chunks/chart-radar-R4PuCIWp.js";
+import { t as O } from "./chunks/chart-radial-bar-hmrSFa6O.js";
+import { t as k } from "./chunks/chart-tree-map-CmysE4bF.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 };