@matthieumordrel/chart-studio 0.2.3 → 0.2.5

package/dist/core/infer-columns.mjs

@@ -1,3 +1,4 @@
+import { resolveChartSchemaDefinition } from "./schema-builder.mjs";
 //#region src/core/infer-columns.ts
 const MAX_SAMPLE_COUNT = 50;
 const DATE_KEY_PATTERN = /(date|time|timestamp|created|updated|start|end|deadline|due|scheduled|posted|published|at)$/i;
@@ -463,7 +464,8 @@ function sortResolvedColumns(columns) {
 * Resolve chart columns directly from raw data and an optional explicit schema.
 */
 function inferColumnsFromData(data, schema) {
-	const rawColumnSchema = getRawColumnSchemaMap(schema);
+	const resolvedSchema = resolveChartSchemaDefinition(schema);
+	const rawColumnSchema = getRawColumnSchemaMap(resolvedSchema);
 	const fields = collectFieldKeys(data, rawColumnSchema);
 	const rawFieldIds = new Set(fields);
 	const resolvedColumns = [];
@@ -473,7 +475,7 @@ function inferColumnsFromData(data, schema) {
 		const column = buildRawColumn(typedField, samples, rawColumnSchema?.[typedField]);
 		if (column) resolvedColumns.push(column);
 	}
-	for (const [key, columnSchema] of getDerivedColumnSchemas(schema, rawFieldIds)) resolvedColumns.push(buildDerivedColumn(key, columnSchema));
+	for (const [key, columnSchema] of getDerivedColumnSchemas(resolvedSchema, rawFieldIds)) resolvedColumns.push(buildDerivedColumn(key, columnSchema));
 	if (resolvedColumns.length === 0) warn("No inferable or explicit chart columns were found. Provide non-empty data or schema.columns.");
 	return finalizeResolvedColumns(sortResolvedColumns(resolvedColumns));
 }

package/dist/core/metric-utils.mjs

@@ -109,13 +109,21 @@ function restrictAvailableMetrics(metrics, config) {
 */
 function resolveMetric(metric, columns, availableMetrics, configuredDefaultMetric) {
 	if (availableMetrics && availableMetrics.length > 0) {
-		const selectedMetric = availableMetrics.find((candidate) => isSameMetric(candidate, metric));
-		if (selectedMetric) return selectedMetric;
-		return (configuredDefaultMetric ? availableMetrics.find((candidate) => isSameMetric(candidate, configuredDefaultMetric)) : void 0) ?? availableMetrics[0];
+		if (metric !== null) {
+			const selectedMetric = availableMetrics.find((candidate) => isSameMetric(candidate, metric));
+			if (selectedMetric) return selectedMetric;
+		}
+		const defaultMetric = configuredDefaultMetric ? availableMetrics.find((candidate) => isSameMetric(candidate, configuredDefaultMetric)) : void 0;
+		if (defaultMetric) return defaultMetric;
+		if (metric === null) {
+			const countMetric = availableMetrics.find((candidate) => candidate.kind === "count");
+			if (countMetric) return countMetric;
+		}
+		return availableMetrics[0];
 	}
-	if (!isAggregateMetric(metric)) return DEFAULT_METRIC;
+	if (metric === null || !isAggregateMetric(metric)) return DEFAULT_METRIC;
 	if (!columns.find((candidate) => candidate.type === "number" && candidate.id === metric.columnId)) return DEFAULT_METRIC;
 	return metric;
 }
 //#endregion
-export { DEFAULT_METRIC, buildAvailableMetrics, getMetricLabel, isAggregateMetric, isSameMetric, resolveMetric, restrictAvailableMetrics };
+export { DEFAULT_METRIC, buildAvailableMetrics, getMetricLabel, isAggregateMetric, isSameMetric, normalizeMetricAllowances, resolveMetric, restrictAvailableMetrics };

package/dist/core/pipeline-data-points.mjs

@@ -157,7 +157,10 @@ function buildTimeBuckets(items, xColumn, groupByColumn, groups, metric, metricC
 				xKey: key
 			};
 			const groupMap = accumulator.get(key);
-			for (const group of groups) point[group] = aggregate(groupMap.get(group) ?? [], metric.kind === "aggregate" ? metric.aggregate : "count", metric.kind === "aggregate" ? metric.includeZeros ?? true : true);
+			for (const group of groups) {
+				const values = groupMap.get(group) ?? [];
+				point[group] = values.length === 0 ? null : aggregate(values, metric.kind === "aggregate" ? metric.aggregate : "count", metric.kind === "aggregate" ? metric.includeZeros ?? true : true);
+			}
 			return point;
 		}),
 		groups

package/dist/core/schema-builder.mjs

@@ -0,0 +1,335 @@
+import { isSameMetric, normalizeMetricAllowances } from "./metric-utils.mjs";
+//#region src/core/schema-builder.ts
+const SELECTABLE_CONTROL_CONFIG = Symbol("chart-schema-selectable-control-config");
+const METRIC_CONTROL_CONFIG = Symbol("chart-schema-metric-config");
+const COLUMN_HELPER = {
+	field(id, options = {}) {
+		return {
+			kind: "raw",
+			id,
+			column: options
+		};
+	},
+	date(id, options = {}) {
+		return {
+			kind: "raw",
+			id,
+			column: {
+				type: "date",
+				...options
+			}
+		};
+	},
+	category(id, options = {}) {
+		return {
+			kind: "raw",
+			id,
+			column: {
+				type: "category",
+				...options
+			}
+		};
+	},
+	number(id, options = {}) {
+		return {
+			kind: "raw",
+			id,
+			column: {
+				type: "number",
+				...options
+			}
+		};
+	},
+	boolean(id, options = {}) {
+		return {
+			kind: "raw",
+			id,
+			column: {
+				type: "boolean",
+				...options
+			}
+		};
+	},
+	exclude(id) {
+		return {
+			kind: "exclude",
+			id,
+			column: false
+		};
+	},
+	derived: {
+		date(id, options) {
+			return {
+				kind: "derived",
+				id,
+				column: {
+					kind: "derived",
+					type: "date",
+					...options
+				}
+			};
+		},
+		category(id, options) {
+			return {
+				kind: "derived",
+				id,
+				column: {
+					kind: "derived",
+					type: "category",
+					...options
+				}
+			};
+		},
+		boolean(id, options) {
+			return {
+				kind: "derived",
+				id,
+				column: {
+					kind: "derived",
+					type: "boolean",
+					...options
+				}
+			};
+		},
+		number(id, options) {
+			return {
+				kind: "derived",
+				id,
+				column: {
+					kind: "derived",
+					type: "number",
+					...options
+				}
+			};
+		}
+	}
+};
+function uniqueValues(values) {
+	if (!values || values.length === 0) return;
+	return [...new Set(values)];
+}
+function sanitizeSelectableControlConfig(config, supportsDefault) {
+	const allowed = uniqueValues(config.allowed);
+	let hidden = uniqueValues(config.hidden);
+	if (allowed && hidden) {
+		const allowedSet = new Set(allowed);
+		hidden = hidden.filter((option) => allowedSet.has(option));
+	}
+	let nextDefault = supportsDefault ? config.default : void 0;
+	if (nextDefault !== void 0) {
+		if (allowed && !allowed.includes(nextDefault)) nextDefault = void 0;
+		if (nextDefault !== void 0 && hidden?.includes(nextDefault)) nextDefault = void 0;
+	}
+	const nextConfig = {};
+	if (allowed && allowed.length > 0) nextConfig.allowed = allowed;
+	if (hidden && hidden.length > 0) nextConfig.hidden = hidden;
+	if (nextDefault !== void 0) nextConfig.default = nextDefault;
+	return nextConfig;
+}
+function createSelectableControlBuilder(config = {}, supportsDefault) {
+	const nextConfig = sanitizeSelectableControlConfig(config, supportsDefault);
+	return {
+		allowed(...options) {
+			return createSelectableControlBuilder({
+				...nextConfig,
+				allowed: options
+			}, supportsDefault);
+		},
+		hidden(...options) {
+			return createSelectableControlBuilder({
+				...nextConfig,
+				hidden: [...nextConfig.hidden ?? [], ...options]
+			}, supportsDefault);
+		},
+		default(option) {
+			return createSelectableControlBuilder({
+				...nextConfig,
+				default: option
+			}, supportsDefault);
+		},
+		[SELECTABLE_CONTROL_CONFIG]: nextConfig
+	};
+}
+function uniqueMetrics(metrics) {
+	if (!metrics || metrics.length === 0) return;
+	const unique = [];
+	for (const metric of metrics) if (!unique.some((candidate) => isSameMetric(candidate, metric))) unique.push(metric);
+	return unique;
+}
+function sanitizeMetricConfig(config) {
+	const allowed = config.allowed && config.allowed.length > 0 ? [...config.allowed] : void 0;
+	let hidden = uniqueMetrics(config.hidden);
+	const expandedAllowed = normalizeMetricAllowances(allowed);
+	if (expandedAllowed && hidden) hidden = hidden.filter((metric) => expandedAllowed.some((allowedMetric) => isSameMetric(allowedMetric, metric)));
+	let nextDefault = config.default;
+	if (nextDefault) {
+		const defaultMetric = nextDefault;
+		if (expandedAllowed && !expandedAllowed.some((metric) => isSameMetric(metric, defaultMetric))) nextDefault = void 0;
+		if (nextDefault) {
+			const visibleDefault = nextDefault;
+			if (hidden?.some((metric) => isSameMetric(metric, visibleDefault))) nextDefault = void 0;
+		}
+	}
+	const nextConfig = {};
+	if (allowed && allowed.length > 0) nextConfig.allowed = allowed;
+	if (hidden && hidden.length > 0) nextConfig.hidden = hidden;
+	if (nextDefault) nextConfig.default = nextDefault;
+	return nextConfig;
+}
+function createMetricBuilder(config = {}) {
+	const nextConfig = sanitizeMetricConfig(config);
+	return {
+		count() {
+			return createMetricBuilder({
+				...nextConfig,
+				allowed: [...nextConfig.allowed ?? [], { kind: "count" }]
+			});
+		},
+		aggregate(columnId, firstAggregate, ...restAggregates) {
+			const aggregates = [firstAggregate, ...restAggregates];
+			const selection = restAggregates.length === 0 ? firstAggregate : aggregates;
+			return createMetricBuilder({
+				...nextConfig,
+				allowed: [...nextConfig.allowed ?? [], {
+					kind: "aggregate",
+					columnId,
+					aggregate: selection
+				}]
+			});
+		},
+		hideCount() {
+			return createMetricBuilder({
+				...nextConfig,
+				hidden: [...nextConfig.hidden ?? [], { kind: "count" }]
+			});
+		},
+		hideAggregate(columnId, firstAggregate, ...restAggregates) {
+			const aggregates = [firstAggregate, ...restAggregates];
+			return createMetricBuilder({
+				...nextConfig,
+				hidden: [...nextConfig.hidden ?? [], ...aggregates.map((aggregate) => ({
+					kind: "aggregate",
+					columnId,
+					aggregate
+				}))]
+			});
+		},
+		defaultCount() {
+			return createMetricBuilder({
+				...nextConfig,
+				default: { kind: "count" }
+			});
+		},
+		defaultAggregate(columnId, aggregate) {
+			return createMetricBuilder({
+				...nextConfig,
+				default: {
+					kind: "aggregate",
+					columnId,
+					aggregate
+				}
+			});
+		},
+		[METRIC_CONTROL_CONFIG]: nextConfig
+	};
+}
+function getSelectableControlConfig(builder) {
+	return builder[SELECTABLE_CONTROL_CONFIG];
+}
+function getMetricBuilderConfig(builder) {
+	return builder[METRIC_CONTROL_CONFIG];
+}
+function buildColumnsMap(entries) {
+	const columns = {};
+	for (const entry of entries) {
+		if (entry.id in columns) throw new Error(`Duplicate chart schema column id: "${entry.id}"`);
+		columns[entry.id] = entry.column;
+	}
+	return columns;
+}
+function assertColumnEntries(entries) {
+	if (!Array.isArray(entries)) throw new TypeError("defineChartSchema().columns(...) must return an array of column entries.");
+}
+function resolveChartSchemaDefinition(schema) {
+	if (!schema) return;
+	if (typeof schema === "object" && "build" in schema && typeof schema.build === "function") return schema.build();
+	return schema;
+}
+function createChartSchemaBuilder(state = {}) {
+	let cachedSchema;
+	return {
+		columns(defineColumns) {
+			const entries = defineColumns(COLUMN_HELPER);
+			assertColumnEntries(entries);
+			return createChartSchemaBuilder({
+				...state,
+				columns: buildColumnsMap(entries)
+			});
+		},
+		xAxis(defineXAxis) {
+			const builder = defineXAxis(createSelectableControlBuilder({}, true));
+			return createChartSchemaBuilder({
+				...state,
+				xAxis: getSelectableControlConfig(builder)
+			});
+		},
+		groupBy(defineGroupBy) {
+			const builder = defineGroupBy(createSelectableControlBuilder({}, true));
+			return createChartSchemaBuilder({
+				...state,
+				groupBy: getSelectableControlConfig(builder)
+			});
+		},
+		filters(defineFilters) {
+			const builder = defineFilters(createSelectableControlBuilder({}, false));
+			return createChartSchemaBuilder({
+				...state,
+				filters: getSelectableControlConfig(builder)
+			});
+		},
+		metric(defineMetric) {
+			const builder = defineMetric(createMetricBuilder());
+			return createChartSchemaBuilder({
+				...state,
+				metric: getMetricBuilderConfig(builder)
+			});
+		},
+		chartType(defineChartType) {
+			const builder = defineChartType(createSelectableControlBuilder({}, true));
+			return createChartSchemaBuilder({
+				...state,
+				chartType: getSelectableControlConfig(builder)
+			});
+		},
+		timeBucket(defineTimeBucket) {
+			const builder = defineTimeBucket(createSelectableControlBuilder({}, true));
+			return createChartSchemaBuilder({
+				...state,
+				timeBucket: getSelectableControlConfig(builder)
+			});
+		},
+		connectNulls(value) {
+			return createChartSchemaBuilder({
+				...state,
+				connectNulls: value
+			});
+		},
+		build() {
+			if (cachedSchema) return cachedSchema;
+			cachedSchema = {
+				...state.columns !== void 0 ? { columns: state.columns } : {},
+				...state.xAxis !== void 0 ? { xAxis: state.xAxis } : {},
+				...state.groupBy !== void 0 ? { groupBy: state.groupBy } : {},
+				...state.filters !== void 0 ? { filters: state.filters } : {},
+				...state.metric !== void 0 ? { metric: state.metric } : {},
+				...state.chartType !== void 0 ? { chartType: state.chartType } : {},
+				...state.timeBucket !== void 0 ? { timeBucket: state.timeBucket } : {},
+				...state.connectNulls !== void 0 ? { connectNulls: state.connectNulls } : {},
+				__chartSchemaBrand: "chart-schema-definition"
+			};
+			return cachedSchema;
+		}
+	};
+}
+//#endregion
+export { createChartSchemaBuilder, resolveChartSchemaDefinition };