@c2n/chart 0.0.7

package/dist/echarts-chart-base-LogCQN10.js

@@ -0,0 +1,228 @@
+import { t as ChartBase } from "./chart-base-C4-1TyKq.js";
+import { i as __decorate } from "./chart-series-BnpHO3lm.js";
+import { property } from "lit/decorators.js";
+//#region src/engines/echarts-loader.ts
+var LOADERS = {
+	pie: () => import("echarts/charts").then((m) => [m.PieChart]),
+	gauge: () => import("echarts/charts").then((m) => [m.GaugeChart]),
+	scatter: () => import("echarts/charts").then((m) => [m.ScatterChart]),
+	heatmap: () => import("echarts/charts").then((m) => [m.HeatmapChart]),
+	candlestick: () => import("echarts/charts").then((m) => [m.CandlestickChart]),
+	bar: () => import("echarts/charts").then((m) => [m.BarChart]),
+	line: () => import("echarts/charts").then((m) => [m.LineChart]),
+	grid: () => import("echarts/components").then((m) => [m.GridComponent]),
+	legend: () => import("echarts/components").then((m) => [m.LegendComponent]),
+	tooltip: () => import("echarts/components").then((m) => [m.TooltipComponent]),
+	visualMap: () => import("echarts/components").then((m) => [m.VisualMapComponent]),
+	dataZoom: () => import("echarts/components").then((m) => [m.DataZoomComponent])
+};
+var corePending;
+/** Registrations already applied, so a second chart of the same type registers nothing. */
+var registered = /* @__PURE__ */ new Set();
+/** Registrations in flight, so two charts mounting together do not both load the same chunk. */
+var inflight = /* @__PURE__ */ new Map();
+/**
+* Loads `echarts/core`, registers `features` and the chosen renderer, and returns the core namespace.
+* Registration is idempotent and deduped, so calling this per element is cheap after the first.
+*/
+async function loadECharts(features, renderer) {
+	if (!corePending) corePending = import("echarts/core");
+	const core = await corePending;
+	const keys = [...features, `renderer:${renderer}`];
+	await Promise.all(keys.map((key) => {
+		if (registered.has(key)) return void 0;
+		let task = inflight.get(key);
+		if (!task) {
+			task = (key.startsWith("renderer:") ? import("echarts/renderers").then((m) => [renderer === "svg" ? m.SVGRenderer : m.CanvasRenderer]) : LOADERS[key]()).then((modules) => {
+				core.use(modules);
+				registered.add(key);
+			}).finally(() => inflight.delete(key));
+			inflight.set(key, task);
+		}
+		return task;
+	}));
+	return core;
+}
+//#endregion
+//#region src/engines/echarts-adapter.ts
+async function createEchartsAdapter(features, renderer) {
+	const echarts = await loadECharts(features, renderer);
+	let instance;
+	let events;
+	let hidden = /* @__PURE__ */ new Set();
+	/** Merges the projected data into whatever series the last option build produced. */
+	const withData = (options, data) => ({
+		...options,
+		series: (options.series ?? []).map((series, index) => ({
+			...series,
+			data: data[index] ?? []
+		}))
+	});
+	const adapter = {
+		engine: "echarts",
+		async create(host, options, data, handlers) {
+			events = handlers;
+			instance = echarts.init(host, void 0, {
+				renderer,
+				useDirtyRect: true
+			});
+			instance.setOption(withData(options, data), { notMerge: true });
+			instance.on("click", (params) => {
+				const point = params;
+				events?.click({
+					index: point.dataIndex ?? 0,
+					seriesIndex: point.seriesIndex ?? 0
+				});
+			});
+			instance.on("mouseover", (params) => {
+				const point = params;
+				events?.hover({
+					index: point.dataIndex ?? 0,
+					seriesIndex: point.seriesIndex ?? 0,
+					px: point.event?.offsetX ?? 0,
+					py: point.event?.offsetY ?? 0
+				});
+			});
+			instance.on("mouseout", () => events?.hover(null));
+			instance.on("dataZoom", () => {
+				const zoom = (instance?.getOption())?.dataZoom?.[0];
+				if (zoom?.startValue !== void 0 && zoom.endValue !== void 0) events?.rangeChange({
+					min: zoom.startValue,
+					max: zoom.endValue
+				});
+			});
+		},
+		/** Series data only: ECharts merges it without re-evaluating axes, colours or layout. */
+		setData(data) {
+			instance?.setOption({ series: data.map((series) => ({ data: series })) }, {
+				notMerge: false,
+				lazyUpdate: true,
+				silent: true
+			});
+		},
+		/**
+		* `replace` is required when the series set shrinks — a merge would leave the removed series on screen
+		* forever. A merge otherwise keeps the current data and zoom, which is what a theme change wants.
+		*/
+		setOptions(options, mode) {
+			instance?.setOption(options, {
+				notMerge: mode === "replace",
+				lazyUpdate: true
+			});
+			if (mode === "replace") for (const index of hidden) adapter.setSeriesVisibility(index, false);
+		},
+		/**
+		* Goes through the legend action, which is why `LegendComponent` is registered even though the
+		* built-in legend is hidden — it is the only public way to toggle a series.
+		*/
+		setSeriesVisibility(index, visible) {
+			const next = new Set(hidden);
+			if (visible) next.delete(index);
+			else next.add(index);
+			hidden = next;
+			const name = (instance?.getOption())?.series?.[index]?.name;
+			if (!name) return;
+			instance?.dispatchAction({
+				type: visible ? "legendSelect" : "legendUnSelect",
+				name
+			});
+		},
+		/** The same action: ECharts' legend selects by name, and a pie's names are its slices, not its series. */
+		setDatumVisibility(name, visible) {
+			instance?.dispatchAction({
+				type: visible ? "legendSelect" : "legendUnSelect",
+				name
+			});
+		},
+		resize(width, height) {
+			if (width > 0 && height > 0) instance?.resize({
+				width,
+				height
+			});
+		},
+		/** ECharts leaks its global resize and event handlers without an explicit dispose. */
+		destroy() {
+			instance?.dispose();
+			instance = void 0;
+			events = void 0;
+		}
+	};
+	return adapter;
+}
+//#endregion
+//#region src/echarts-chart-base.ts
+/**
+* The ECharts half of the hierarchy. A concrete chart declares the engine modules it needs and how one
+* series is configured; everything else — theme, text styles, the disabled built-in tooltip and legend —
+* is settled here.
+*
+* Defines no tag and is never registered.
+*/
+var EchartsChartBase = class extends ChartBase {
+	constructor(..._args) {
+		super(..._args);
+		this.engineName = "echarts";
+		this.renderer = "canvas";
+	}
+	/** Grid and axes for a cartesian chart. The pie and gauge charts override this to contribute neither. */
+	coordinateSystem(context) {
+		const { theme } = context;
+		const axisLine = { lineStyle: { color: theme.gridColor } };
+		const axisLabel = {
+			color: theme.axisColor,
+			fontSize: theme.fontSize
+		};
+		return {
+			grid: {
+				left: 48,
+				right: 16,
+				top: 16,
+				bottom: 32,
+				containLabel: false
+			},
+			xAxis: {
+				type: this.xType === "time" ? "time" : this.xType === "category" ? "category" : "value",
+				axisLine,
+				axisLabel,
+				data: context.labels
+			},
+			yAxis: {
+				type: "value",
+				axisLine,
+				axisLabel,
+				splitLine: { lineStyle: { color: theme.gridColor } }
+			}
+		};
+	}
+	createAdapter() {
+		return createEchartsAdapter([...this.features, "legend"], this.renderer);
+	}
+	projectData(frame, context) {
+		return this.frameBuilder.echartsView(frame, this.dataShape(context));
+	}
+	/** Cartesian charts want `[x, y]` pairs; the labelled ones want `{ name, value }`. */
+	dataShape(_context) {
+		return "pairs";
+	}
+	buildOptions(context) {
+		const { theme, series } = context;
+		return {
+			animation: this.animation === "auto",
+			color: theme.palette,
+			textStyle: {
+				fontFamily: theme.fontFamily === "inherit" ? void 0 : theme.fontFamily,
+				fontSize: theme.fontSize,
+				color: theme.color
+			},
+			legend: { show: false },
+			...this.coordinateSystem(context),
+			series: series.map((item, index) => ({
+				name: item.label ?? item.field,
+				...this.seriesOption(index, context)
+			}))
+		};
+	}
+};
+__decorate([property({ type: String })], EchartsChartBase.prototype, "renderer", void 0);
+//#endregion
+export { EchartsChartBase as t };

package/dist/echarts-chart-base.js

@@ -0,0 +1,2 @@
+import { t as EchartsChartBase } from "./echarts-chart-base-LogCQN10.js";
+export { EchartsChartBase };

package/dist/line-chart.js

@@ -0,0 +1,31 @@
+import { i as __decorate } from "./chart-series-BnpHO3lm.js";
+import { t as UplotChartBase } from "./uplot-chart-base-BWr0zJE2.js";
+import { n as linePaths } from "./uplot-paths-ChKohvIX.js";
+import { property } from "lit/decorators.js";
+import { customElement } from "@c2n/core/element-helper.js";
+//#region src/line-chart.ts
+var LineChart = class LineChart extends UplotChartBase {
+	constructor(..._args) {
+		super(..._args);
+		this.curve = "linear";
+		this.points = "auto";
+	}
+	seriesStyle(series, index, context) {
+		const { theme } = context;
+		return {
+			stroke: this.colorOf(series, index, theme),
+			width: series.lineWidth ?? theme.lineWidth,
+			paths: linePaths(this.curve),
+			spanGaps: series.spanGaps ?? false,
+			points: {
+				show: this.points === "none" ? false : this.points === "always" ? true : void 0,
+				size: theme.pointRadius * 2
+			}
+		};
+	}
+};
+__decorate([property({ type: String })], LineChart.prototype, "curve", void 0);
+__decorate([property({ type: String })], LineChart.prototype, "points", void 0);
+LineChart = __decorate([customElement("c2-line-chart")], LineChart);
+//#endregion
+export { LineChart };

package/dist/pie-chart.js

@@ -0,0 +1,100 @@
+import { i as __decorate } from "./chart-series-BnpHO3lm.js";
+import { t as EchartsChartBase } from "./echarts-chart-base-LogCQN10.js";
+import { property, state } from "lit/decorators.js";
+import { customElement } from "@c2n/core/element-helper.js";
+//#region src/pie-chart.ts
+var PieChart = class PieChart extends EchartsChartBase {
+	constructor() {
+		super();
+		this.features = ["pie"];
+		this.innerRadius = 0;
+		this.outerRadius = .75;
+		this.startAngle = 90;
+		this.labels = "none";
+		this.sort = "none";
+		this.hiddenSlices = /* @__PURE__ */ new Set();
+		this.tooltip = "item";
+		this.legend = "end";
+	}
+	/** A pie has no grid and no axes at all: contributing them would draw an empty cartesian frame. */
+	coordinateSystem() {
+		return {};
+	}
+	/**
+	* A pie's legend is its slices, not its series: there is only ever one series, so the inherited legend
+	* would render a single entry ("Revenue") above a four-slice donut.
+	*/
+	legendItems() {
+		const labels = this.frame?.labels;
+		if (!labels || labels.length === 0) return super.legendItems();
+		const series = this.resolvedSeries[0] ?? { field: "" };
+		const theme = this.themeController.theme;
+		return labels.map((label, index) => ({
+			label,
+			color: theme.palette[index % theme.palette.length],
+			visible: !this.hiddenSlices.has(label),
+			toggle: () => this.setSliceVisible(label, this.hiddenSlices.has(label)),
+			series,
+			index
+		}));
+	}
+	/** Shows or hides one slice, as the legend does. ECharts selects by name, which is the slice's label. */
+	setSliceVisible(label, visible) {
+		const next = new Set(this.hiddenSlices);
+		if (visible) next.delete(label);
+		else next.add(label);
+		this.hiddenSlices = next;
+		this.adapter?.setDatumVisibility?.(label, visible);
+	}
+	dataShape() {
+		return "named";
+	}
+	seriesOption(_index, context) {
+		const { theme } = context;
+		return {
+			type: "pie",
+			radius: [`${this.innerRadius * 100}%`, `${this.outerRadius * 100}%`],
+			startAngle: this.startAngle,
+			label: {
+				show: this.labels !== "none",
+				position: this.labels === "inside" ? "inside" : "outside",
+				color: this.labels === "inside" ? theme.surface : theme.color,
+				fontSize: theme.fontSize
+			},
+			labelLine: { show: this.labels === "outside" },
+			itemStyle: sliceBorder(this, theme.surface),
+			sort: this.sort === "none" ? void 0 : this.sort === "asc" ? "ascending" : "descending"
+		};
+	}
+};
+__decorate([property({
+	type: Number,
+	attribute: "inner-radius"
+})], PieChart.prototype, "innerRadius", void 0);
+__decorate([property({
+	type: Number,
+	attribute: "outer-radius"
+})], PieChart.prototype, "outerRadius", void 0);
+__decorate([property({
+	type: Number,
+	attribute: "start-angle"
+})], PieChart.prototype, "startAngle", void 0);
+__decorate([property({ type: String })], PieChart.prototype, "labels", void 0);
+__decorate([property({ type: String })], PieChart.prototype, "sort", void 0);
+__decorate([state()], PieChart.prototype, "hiddenSlices", void 0);
+PieChart = __decorate([customElement("c2-pie-chart")], PieChart);
+/** Reads `--c2-chart__slice--border` off the host as ECharts' `{ borderColor, borderWidth }`. */
+function sliceBorder(host, fallbackColor) {
+	const value = getComputedStyle(host).getPropertyValue("--c2-chart__slice--border").trim();
+	if (!value || value === "none") return {
+		borderColor: "transparent",
+		borderWidth: 0
+	};
+	const width = parseFloat(value);
+	return {
+		borderColor: value.replace(/^\s*[\d.]+[a-z%]*\s*/i, "").replace(/^(solid|dashed|dotted|double|groove|ridge|inset|outset)\s*/i, "") || fallbackColor,
+		borderWidth: Number.isFinite(width) ? width : 2
+	};
+}
+//#endregion
+export { PieChart };

package/dist/sparkline.js

@@ -0,0 +1,79 @@
+import { n as chart_default } from "./chart-base-C4-1TyKq.js";
+import { i as __decorate } from "./chart-series-BnpHO3lm.js";
+import { t as UplotChartBase } from "./uplot-chart-base-BWr0zJE2.js";
+import { n as linePaths, r as withAlpha } from "./uplot-paths-ChKohvIX.js";
+import { property } from "lit/decorators.js";
+import { customElement } from "@c2n/core/element-helper.js";
+import { css, unsafeCSS } from "lit";
+//#region src/sparkline.ts
+var Sparkline = class Sparkline extends UplotChartBase {
+	static {
+		this.styles = [unsafeCSS(chart_default), css`
+      :host {
+        /* Redefined, not merely defaulted: the base sets these variables, so a fallback would never apply.
+           An author rule on the element still wins, because it beats :host. */
+        --c2-chart--width: 120px;
+        --c2-chart--height: 32px;
+        --c2-chart--padding: 0;
+        display: inline-flex;
+        border: none;
+        background: none;
+      }
+    `];
+	}
+	constructor() {
+		super();
+		this.type = "line";
+		this.tone = "neutral";
+		this.axes = "none";
+		this.grid = "none";
+		this.cursor = "none";
+		this.legend = "none";
+		this.tooltip = "none";
+	}
+	seriesStyle(series, index, context) {
+		const color = this.resolveTone(series, index, context);
+		return {
+			stroke: color,
+			width: series.lineWidth ?? context.theme.lineWidth,
+			paths: linePaths("smooth"),
+			points: { show: false },
+			...this.type === "area" ? { fill: withAlpha(color, .18) } : {}
+		};
+	}
+	/**
+	* Strips every remaining pixel of chrome, so the line fills the whole box.
+	*
+	* The axes are left alone on purpose: `this.axes = 'none'` already builds them with `show: false`, which
+	* is what makes uPlot skip both the axis element and its gutter. Handing it `axes: []` would do the
+	* opposite — uPlot fills a short array back up to two axes with its own defaults, which are *visible* —
+	* and a 120x32 sparkline would spend 52px of its width on a y axis it never asked for.
+	*/
+	decorateOptions(options, _context) {
+		return {
+			...options,
+			padding: [
+				2,
+				2,
+				2,
+				2
+			]
+		};
+	}
+	resolveTone(series, index, context) {
+		if (this.tone === "neutral") return this.colorOf(series, index, context.theme);
+		if (this.tone === "positive") return context.theme.positive;
+		if (this.tone === "negative") return context.theme.negative;
+		const column = this.frame?.columns[index];
+		if (!column || !this.frame || this.frame.length < 2) return this.colorOf(series, index, context.theme);
+		const first = Number(column[0]);
+		const last = Number(column[this.frame.length - 1]);
+		if (!Number.isFinite(first) || !Number.isFinite(last) || first === last) return this.colorOf(series, index, context.theme);
+		return last > first ? context.theme.positive : context.theme.negative;
+	}
+};
+__decorate([property({ type: String })], Sparkline.prototype, "type", void 0);
+__decorate([property({ type: String })], Sparkline.prototype, "tone", void 0);
+Sparkline = __decorate([customElement("c2-sparkline")], Sparkline);
+//#endregion
+export { Sparkline };

package/dist/uplot-chart-base-BWr0zJE2.js

@@ -0,0 +1,253 @@
+import { t as ChartBase } from "./chart-base-C4-1TyKq.js";
+import { i as __decorate } from "./chart-series-BnpHO3lm.js";
+import { property } from "lit/decorators.js";
+//#region src/engines/uplot-loader.ts
+var pending;
+var loaded;
+/**
+* Loads uPlot once per page. Ten sparklines mounting at the same time share one request and one module
+* evaluation, because every caller awaits the same promise.
+*/
+function loadUplot() {
+	if (!pending) pending = import("uplot").then((module) => {
+		loaded = module.default;
+		return loaded;
+	});
+	return pending;
+}
+/**
+* The module, for callers that cannot await it — the path builders, which are read while an option object
+* is being built. `undefined` until the load resolves; every chart builds its options from inside an
+* adapter that already awaited {@link loadUplot}, so by then this is set.
+*/
+function loadedUplot() {
+	return loaded;
+}
+//#endregion
+//#region src/engines/uplot-adapter.ts
+async function createUplotAdapter() {
+	const UPlot = await loadUplot();
+	let instance;
+	let container;
+	let events;
+	let data = [[]];
+	/** Set while we are rebuilding, so the scale hook does not report our own restore as a user zoom. */
+	let restoring = false;
+	/** Adds our hooks to whatever the element built, without the element knowing uPlot's hook shape. */
+	const withHooks = (options) => ({
+		...options,
+		hooks: {
+			...options.hooks,
+			setCursor: [(self) => {
+				const index = self.cursor.idx;
+				if (index === null || index === void 0) {
+					events?.hover(null);
+					return;
+				}
+				events?.hover({
+					index,
+					seriesIndex: Math.max(1, self.cursor.idxs?.findIndex((value) => value !== null && value !== void 0) ?? 1) - 1,
+					px: self.cursor.left ?? 0,
+					py: self.cursor.top ?? 0
+				});
+			}],
+			setSelect: [(self) => {
+				if (self.select.width <= 0) return;
+				const min = self.posToVal(self.select.left, "x");
+				const max = self.posToVal(self.select.left + self.select.width, "x");
+				events?.rangeChange({
+					min,
+					max
+				});
+			}],
+			setScale: [(self, key) => {
+				if (restoring || key !== "x") return;
+				const { min, max } = self.scales.x;
+				if (min !== void 0 && max !== void 0) events?.rangeChange({
+					min,
+					max
+				});
+			}]
+		}
+	});
+	const build = (options, next) => {
+		if (!container) return;
+		instance = new UPlot(withHooks(options), next, container);
+	};
+	return {
+		engine: "uplot",
+		async create(host, options, initial, handlers) {
+			container = host;
+			events = handlers;
+			data = initial;
+			build(options, initial);
+		},
+		/** The hot path, and the reason uPlot is here: a redraw and nothing else. */
+		setData(next) {
+			data = next;
+			instance?.setData(next, true);
+		},
+		/** Destroy and rebuild, preserving the x window. See the file header for why there is no alternative. */
+		setOptions(options, _mode) {
+			if (!instance || !container) return;
+			const { min, max } = instance.scales.x;
+			instance.destroy();
+			build(options, data);
+			if (min !== void 0 && max !== void 0 && instance) {
+				restoring = true;
+				instance.setScale("x", {
+					min,
+					max
+				});
+				restoring = false;
+			}
+		},
+		setSeriesVisibility(index, visible) {
+			instance?.setSeries(index + 1, { show: visible });
+		},
+		resize(width, height) {
+			if (width > 0 && height > 0) instance?.setSize({
+				width,
+				height
+			});
+		},
+		destroy() {
+			instance?.destroy();
+			instance = void 0;
+			container = void 0;
+			events = void 0;
+		}
+	};
+}
+//#endregion
+//#region src/uplot-chart-base.ts
+var DAY = 864e5;
+var YEAR = 365 * DAY;
+/** uPlot scale key for the secondary y axis, which `c2-chart-series[axis=right]` draws against. */
+var RIGHT_SCALE = "y2";
+/**
+* The uPlot half of the hierarchy: the cartesian presentation shared by the line, area, bar and sparkline
+* charts, and the option object built from it. A concrete chart supplies only {@link seriesStyle}, which
+* is what makes a new uPlot chart type roughly ten lines.
+*
+* Defines no tag and is never registered.
+*
+* @cssproperty {color} [--c2-chart__axis-line--color=#e4e4e7] - Colour of the axis rules uPlot draws at the plot edges.
+*/
+var UplotChartBase = class extends ChartBase {
+	constructor(..._args) {
+		super(..._args);
+		this.engineName = "uplot";
+		this.grid = "y";
+		this.axes = "both";
+		this.zoom = false;
+		this.cursor = "x";
+	}
+	/** Last chance to adjust the finished option object; the sparkline strips its chrome here. */
+	decorateOptions(options, _context) {
+		return options;
+	}
+	createAdapter() {
+		return createUplotAdapter();
+	}
+	projectData(frame) {
+		return this.frameBuilder.uplotView(frame);
+	}
+	buildOptions(context) {
+		const { theme, series, width, height } = context;
+		const showX = this.axes === "both" || this.axes === "x";
+		const showY = this.axes === "both" || this.axes === "y";
+		const hasRight = series.some((item) => item.axis === "right");
+		const axis = (show, isX, scale) => ({
+			...scale ? {
+				scale,
+				side: 1
+			} : {},
+			show,
+			stroke: theme.axisColor,
+			font: `${theme.fontSize}px ${theme.fontFamily === "inherit" ? "system-ui, sans-serif" : theme.fontFamily}`,
+			ticks: {
+				show,
+				stroke: theme.gridColor,
+				width: 1
+			},
+			grid: scale === RIGHT_SCALE ? { show: false } : {
+				show: isX ? this.grid === "x" || this.grid === "both" : this.grid === "y" || this.grid === "both",
+				stroke: theme.gridColor,
+				width: 1
+			},
+			values: isX ? (_self, splits) => splits.map((value) => this.formatAxisX(value)) : (_self, splits) => splits.map((value) => this.formatValue(value))
+		});
+		const options = {
+			width: Math.max(1, Math.floor(width)),
+			height: Math.max(1, Math.floor(height)),
+			legend: { show: false },
+			cursor: this.cursor === "none" ? { show: false } : {
+				show: true,
+				x: true,
+				y: false,
+				drag: {
+					x: this.zoom,
+					y: false,
+					setScale: this.zoom
+				}
+			},
+			scales: {
+				x: { time: false },
+				y: { range: this.yRange() },
+				...hasRight ? { [RIGHT_SCALE]: { range: this.yRange() } } : {}
+			},
+			axes: [
+				axis(showX, true),
+				axis(showY, false),
+				...hasRight ? [axis(showY, false, RIGHT_SCALE)] : []
+			],
+			series: [{}, ...series.map((item, index) => ({
+				label: item.label ?? item.field,
+				show: !context.hidden.has(index),
+				scale: item.axis === "right" ? RIGHT_SCALE : void 0,
+				...this.seriesStyle(item, index, context)
+			}))]
+		};
+		return this.decorateOptions(options, context);
+	}
+	/** A fixed y range when either bound is set, otherwise uPlot's own auto-ranging. */
+	yRange() {
+		if (this.yMin === void 0 && this.yMax === void 0) return void 0;
+		return [this.yMin ?? null, this.yMax ?? null];
+	}
+	/**
+	* Axis tick labels are terser than the tooltip's. The unit comes from the span the chart covers, because a
+	* fixed date format repeats itself once the engine picks sub-day increments: an hour of samples would label
+	* every tick "Jan 1".
+	*/
+	formatAxisX(value) {
+		if (this.xType !== "time") return this.formatValue(value);
+		const span = this.xSpan();
+		const options = span > 0 && span < DAY ? {
+			hour: "numeric",
+			minute: "2-digit"
+		} : span < YEAR ? {
+			month: "short",
+			day: "numeric"
+		} : {
+			month: "short",
+			year: "numeric"
+		};
+		return new Intl.DateTimeFormat(this.locale, options).format(new Date(value));
+	}
+};
+__decorate([property({ type: String })], UplotChartBase.prototype, "grid", void 0);
+__decorate([property({ type: String })], UplotChartBase.prototype, "axes", void 0);
+__decorate([property({
+	type: Number,
+	attribute: "y-min"
+})], UplotChartBase.prototype, "yMin", void 0);
+__decorate([property({
+	type: Number,
+	attribute: "y-max"
+})], UplotChartBase.prototype, "yMax", void 0);
+__decorate([property({ type: Boolean })], UplotChartBase.prototype, "zoom", void 0);
+__decorate([property({ type: String })], UplotChartBase.prototype, "cursor", void 0);
+//#endregion
+export { loadedUplot as n, UplotChartBase as t };

package/dist/uplot-chart-base.js

@@ -0,0 +1,2 @@
+import { t as UplotChartBase } from "./uplot-chart-base-BWr0zJE2.js";
+export { UplotChartBase };