@macroui/echarts-vue 1.0.0

package/dist/index.js

@@ -0,0 +1,741 @@
+import { a as isPlainObject, c as parseOnEvent, i as isOn, l as warn$1, n as useRuntime, o as isSameSet, r as isBrowser, s as isValidArrayIndex } from "./runtime-CcSlBnVC.js";
+import { Teleport, computed, defineComponent, h, inject, nextTick, onBeforeUnmount, onMounted, onScopeDispose, onUnmounted, onUpdated, shallowReactive, shallowRef, toRefs, toValue, watch, watchEffect } from "vue";
+import { init, throttle } from "echarts/core";
+//#region src/composables/api.ts
+const METHOD_NAMES = [
+	"getWidth",
+	"getHeight",
+	"getDom",
+	"getOption",
+	"resize",
+	"dispatchAction",
+	"convertToPixel",
+	"convertFromPixel",
+	"containPixel",
+	"getDataURL",
+	"getConnectedDataURL",
+	"appendData",
+	"clear",
+	"isDisposed",
+	"dispose"
+];
+function usePublicAPI(chart) {
+	function makePublicMethod(name) {
+		const fn = function(...args) {
+			if (!chart.value) throw new Error("ECharts is not initialized yet.");
+			return Reflect.apply(chart.value[name], chart.value, args);
+		};
+		return fn;
+	}
+	return METHOD_NAMES.reduce((acc, name) => {
+		acc[name] = makePublicMethod(name);
+		return acc;
+	}, {});
+}
+//#endregion
+//#region src/composables/autoresize.ts
+function useAutoresize(chart, autoresize, root) {
+	watch([
+		root,
+		chart,
+		autoresize
+	], ([root, chart, autoresize], _, onCleanup) => {
+		let ro = null;
+		if (root && chart && autoresize) {
+			const { offsetWidth, offsetHeight } = root;
+			const { throttle: wait = 100, onResize } = autoresize === true ? {} : autoresize;
+			let initialResizeTriggered = false;
+			const callback = () => {
+				chart.resize();
+				onResize?.();
+			};
+			const resizeCallback = wait ? throttle(callback, wait) : callback;
+			ro = new ResizeObserver(() => {
+				if (!initialResizeTriggered) {
+					initialResizeTriggered = true;
+					if (root.offsetWidth === offsetWidth && root.offsetHeight === offsetHeight) return;
+				}
+				if (root.offsetWidth === 0 || root.offsetHeight === 0) return;
+				resizeCallback();
+			});
+			ro.observe(root);
+		}
+		onCleanup(() => {
+			if (ro) {
+				ro.disconnect();
+				ro = null;
+			}
+		});
+	});
+}
+const autoresizeProps = { autoresize: [Boolean, Object] };
+//#endregion
+//#region src/composables/loading.ts
+const LOADING_OPTIONS_KEY = Symbol();
+function useLoading(chart, loading, loadingOptions) {
+	const defaultLoadingOptions = inject(LOADING_OPTIONS_KEY, {});
+	const realLoadingOptions = computed(() => ({
+		...toValue(defaultLoadingOptions),
+		...loadingOptions.value ?? {}
+	}));
+	watchEffect(() => {
+		const instance = chart.value;
+		if (!instance) return;
+		if (loading.value) instance.showLoading(realLoadingOptions.value);
+		else instance.hideLoading();
+	});
+}
+const loadingProps = {
+	loading: Boolean,
+	loadingOptions: Object
+};
+//#endregion
+//#region src/composables/slot.ts
+const SLOT_OPTION_PATHS = {
+	tooltip: ["tooltip", "formatter"],
+	dataView: [
+		"toolbox",
+		"feature",
+		"dataView",
+		"optionToContent"
+	]
+};
+const SLOT_PREFIXES = ["tooltip", "dataView"];
+function isValidSlotName(key) {
+	return SLOT_PREFIXES.some((slotPrefix) => key === slotPrefix || key.startsWith(slotPrefix + "-"));
+}
+function ensureChild(parent, seg, nextSeg) {
+	const next = readSegment(parent, seg);
+	if (Array.isArray(next)) {
+		const cloned = [...next];
+		writeSegment(parent, seg, cloned);
+		return cloned;
+	}
+	if (isPlainObject(next)) {
+		const cloned = { ...next };
+		writeSegment(parent, seg, cloned);
+		return cloned;
+	}
+	if (next === void 0) {
+		const created = nextSeg && isValidArrayIndex(nextSeg) ? [] : {};
+		writeSegment(parent, seg, created);
+		return created;
+	}
+}
+function readSegment(parent, seg) {
+	if (Array.isArray(parent)) return parent[Number(seg)];
+	return parent[seg];
+}
+function writeSegment(parent, seg, value) {
+	if (Array.isArray(parent)) {
+		parent[Number(seg)] = value;
+		return;
+	}
+	parent[seg] = value;
+}
+function useSlotOption(slots, onSlotsChange) {
+	const detachedRoot = isBrowser() ? document.createElement("div") : void 0;
+	const containers = shallowReactive({});
+	const initialized = shallowReactive({});
+	const params = shallowReactive({});
+	const isMounted = shallowRef(false);
+	const warnedInvalidSlots = /* @__PURE__ */ new Set();
+	const collectSlotNames = (warnInvalid) => {
+		const result = [];
+		for (const key of Object.keys(slots)) {
+			if (key === "graphic") continue;
+			if (isValidSlotName(key)) result.push(key);
+			else if (warnInvalid && !warnedInvalidSlots.has(key)) {
+				warn$1(`Invalid slot name: ${key}`);
+				warnedInvalidSlots.add(key);
+			}
+		}
+		return result;
+	};
+	let slotNames = collectSlotNames(false);
+	const render = () => {
+		const names = collectSlotNames(false);
+		if (names.length === 0 || !isMounted.value || !detachedRoot) return;
+		return h(Teleport, { to: detachedRoot }, names.map((slotName) => {
+			const slot = slots[slotName];
+			const slotContent = initialized[slotName] ? slot?.(params[slotName]) : void 0;
+			return h("div", {
+				key: slotName,
+				ref: (el) => {
+					if (el instanceof HTMLElement) containers[slotName] = el;
+				},
+				style: { display: "contents" }
+			}, slotContent);
+		}));
+	};
+	function patchOption(src) {
+		const root = { ...src };
+		const names = collectSlotNames(true);
+		for (const key of names) {
+			const prefix = key.startsWith("tooltip") ? "tooltip" : "dataView";
+			const rest = key.slice(prefix.length);
+			const parts = rest ? rest.slice(1).split("-") : [];
+			const tail = SLOT_OPTION_PATHS[prefix];
+			const path = [...parts, ...tail];
+			let current = root;
+			for (let i = 0; i < path.length - 1; i++) {
+				current = ensureChild(current, path[i], path[i + 1]);
+				if (!current) break;
+			}
+			if (!current) continue;
+			const leaf = path[path.length - 1];
+			const formatter = (payload) => {
+				initialized[key] = true;
+				params[key] = payload;
+				return containers[key];
+			};
+			writeSegment(current, leaf, formatter);
+		}
+		return root;
+	}
+	onUpdated(() => {
+		const nextSlotNames = collectSlotNames(false);
+		if (!isSameSet(nextSlotNames, slotNames)) {
+			const nextSlotNameSet = new Set(nextSlotNames);
+			for (const key of slotNames) if (!nextSlotNameSet.has(key)) {
+				delete params[key];
+				delete initialized[key];
+				delete containers[key];
+			}
+			slotNames = nextSlotNames;
+			onSlotsChange();
+		}
+	});
+	onMounted(() => {
+		isMounted.value = true;
+	});
+	onUnmounted(() => {
+		detachedRoot?.remove();
+	});
+	return {
+		render,
+		patchOption
+	};
+}
+//#endregion
+//#region src/wc.ts
+let registered = null;
+const TAG_NAME = "x-macroui-echarts";
+function register() {
+	if (registered != null) return registered;
+	const registry = globalThis.customElements;
+	if (!isBrowser() || !registry?.get) {
+		registered = false;
+		return registered;
+	}
+	if (!registry.get("x-macroui-echarts")) try {
+		class ECElement extends HTMLElement {
+			__dispose = null;
+			disconnectedCallback() {
+				if (this.__dispose) {
+					this.__dispose();
+					this.__dispose = null;
+				}
+			}
+		}
+		registry.define(TAG_NAME, ECElement);
+	} catch {
+		registered = false;
+		return registered;
+	}
+	registered = true;
+	return registered;
+}
+//#endregion
+//#region src/core/events.ts
+function getEmitter(instance, zr) {
+	return zr ? instance.getZr() : instance;
+}
+function resolveHandlers(value) {
+	if (typeof value === "function") return [value];
+	if (!Array.isArray(value)) return [];
+	const handlers = [];
+	for (const item of value) if (typeof item === "function") handlers.push(item);
+	return handlers;
+}
+function createBoundHandler(emitter, event, value, once) {
+	const handlers = resolveHandlers(value);
+	if (handlers.length === 0) return;
+	const invoke = (...args) => {
+		for (const handler of handlers) handler(...args);
+	};
+	if (!once) return invoke;
+	let called = false;
+	const onceHandler = (...args) => {
+		if (called) return;
+		called = true;
+		invoke(...args);
+		emitter.off(event, onceHandler);
+	};
+	return onceHandler;
+}
+function toNativeEventKey(event, once) {
+	if (!event.startsWith("native:")) return null;
+	const nativeEvent = event.slice(7);
+	if (!nativeEvent) return null;
+	return `on${nativeEvent.charAt(0).toUpperCase()}${nativeEvent.slice(1)}${once ? "Once" : ""}`;
+}
+function useReactiveChartListeners(chart, attrs) {
+	const bindings = /* @__PURE__ */ new Map();
+	let activeInstance;
+	function clearBindings() {
+		for (const binding of bindings.values()) binding.emitter.off(binding.event, binding.handler);
+		bindings.clear();
+	}
+	watchEffect(() => {
+		const instance = chart.value;
+		if (!instance) {
+			clearBindings();
+			activeInstance = void 0;
+			return;
+		}
+		if (activeInstance && activeInstance !== instance) clearBindings();
+		activeInstance = instance;
+		const seen = /* @__PURE__ */ new Set();
+		for (const key in attrs) {
+			const parsed = parseOnEvent(key);
+			if (!parsed || parsed.event.startsWith("native:")) continue;
+			const zr = parsed.event.startsWith("zr:");
+			const event = zr ? parsed.event.slice(3) : parsed.event;
+			const source = attrs[key];
+			const emitter = getEmitter(instance, zr);
+			const existing = bindings.get(key);
+			if (existing && existing.source === source && existing.event === event && existing.once === parsed.once) {
+				seen.add(key);
+				continue;
+			}
+			if (existing) {
+				existing.emitter.off(existing.event, existing.handler);
+				bindings.delete(key);
+			}
+			const handler = createBoundHandler(emitter, event, source, parsed.once);
+			if (!handler) continue;
+			emitter.on(event, handler);
+			bindings.set(key, {
+				emitter,
+				event,
+				source,
+				once: parsed.once,
+				handler
+			});
+			seen.add(key);
+		}
+		for (const [key, binding] of bindings) {
+			if (seen.has(key)) continue;
+			binding.emitter.off(binding.event, binding.handler);
+			bindings.delete(key);
+		}
+	});
+	onScopeDispose(clearBindings);
+}
+function useReactiveEventAttrs(attrs) {
+	return {
+		nonEventAttrs: computed(() => {
+			const result = {};
+			for (const key in attrs) {
+				if (isOn(key)) continue;
+				result[key] = attrs[key];
+			}
+			return result;
+		}),
+		nativeListeners: computed(() => {
+			const result = {};
+			for (const key in attrs) {
+				const parsed = parseOnEvent(key);
+				if (!parsed) continue;
+				const nativeKey = toNativeEventKey(parsed.event, parsed.once);
+				if (!nativeKey) continue;
+				result[nativeKey] = attrs[key];
+			}
+			return result;
+		})
+	};
+}
+//#endregion
+//#region src/update.ts
+/**
+* Read an item's `id` as a string.
+* Only accept string or number. Other types are ignored to surface inconsistent data early.
+*/
+function readId(item) {
+	if (!isPlainObject(item)) return;
+	const raw = item.id;
+	if (typeof raw === "string") return raw;
+	if (typeof raw === "number" && Number.isFinite(raw)) return String(raw);
+}
+function summarizeArray(items) {
+	const ids = /* @__PURE__ */ new Set();
+	let noIdCount = 0;
+	for (let i = 0; i < items.length; i++) {
+		const id = readId(items[i]);
+		if (id === void 0) {
+			noIdCount++;
+			continue;
+		}
+		ids.add(id);
+	}
+	return {
+		idsSorted: ids.size > 0 ? Array.from(ids).sort() : [],
+		noIdCount
+	};
+}
+/**
+* Build a minimal signature from a full ECharts option.
+* Only top-level keys are inspected.
+*/
+function buildSignature(option) {
+	const opt = option;
+	const optionsLength = Array.isArray(opt.options) ? opt.options.length : 0;
+	const mediaLength = Array.isArray(opt.media) ? opt.media.length : 0;
+	const arrays = Object.create(null);
+	const objects = [];
+	const scalars = [];
+	for (const key of Object.keys(opt)) {
+		if (key === "options" || key === "media") continue;
+		const value = opt[key];
+		if (Array.isArray(value)) {
+			arrays[key] = summarizeArray(value);
+			continue;
+		}
+		if (isPlainObject(value)) {
+			objects.push(key);
+			continue;
+		}
+		if (value !== void 0) scalars.push(key);
+	}
+	if (objects.length > 1) objects.sort();
+	if (scalars.length > 1) scalars.sort();
+	return {
+		optionsLength,
+		mediaLength,
+		arrays,
+		objects,
+		scalars
+	};
+}
+function diffKeys(prevKeys, nextKeys) {
+	if (prevKeys.length === 0) return [];
+	if (nextKeys.length === 0) return prevKeys.slice();
+	const nextSet = new Set(nextKeys);
+	const missing = [];
+	for (let i = 0; i < prevKeys.length; i++) {
+		const key = prevKeys[i];
+		if (!nextSet.has(key)) missing.push(key);
+	}
+	return missing;
+}
+function hasMissingIds(prevIds, nextIds) {
+	if (prevIds.length === 0) return false;
+	if (nextIds.length === 0) return true;
+	const nextSet = new Set(nextIds);
+	for (let i = 0; i < prevIds.length; i++) if (!nextSet.has(prevIds[i])) return true;
+	return false;
+}
+function shouldForceNotMerge(prev, next) {
+	if (next.optionsLength < prev.optionsLength) return true;
+	if (next.mediaLength < prev.mediaLength) return true;
+	return diffKeys(prev.scalars, next.scalars).length > 0;
+}
+function collectObjectOverrides(prev, next) {
+	const overrides = /* @__PURE__ */ new Map();
+	const missingObjects = diffKeys(prev.objects, next.objects);
+	for (let i = 0; i < missingObjects.length; i++) {
+		const key = missingObjects[i];
+		const movedToArray = next.arrays[key] !== void 0;
+		const movedToScalar = next.scalars.includes(key);
+		if (!movedToArray && !movedToScalar) overrides.set(key, null);
+	}
+	return overrides;
+}
+function collectArrayChanges(prev, next, overrides) {
+	const replaceMerge = /* @__PURE__ */ new Set();
+	for (const key of Object.keys(prev.arrays)) {
+		const prevArray = prev.arrays[key];
+		if (!prevArray) continue;
+		const nextArray = next.arrays[key];
+		if (!nextArray) {
+			if (prevArray.idsSorted.length > 0 || prevArray.noIdCount > 0) {
+				overrides.set(key, []);
+				replaceMerge.add(key);
+			}
+			continue;
+		}
+		if (hasMissingIds(prevArray.idsSorted, nextArray.idsSorted)) {
+			replaceMerge.add(key);
+			continue;
+		}
+		if (nextArray.noIdCount < prevArray.noIdCount) replaceMerge.add(key);
+	}
+	return replaceMerge;
+}
+function applyOverrides(option, next, overrides) {
+	if (overrides.size === 0) return {
+		option,
+		signature: next
+	};
+	const normalizedOption = { ...option };
+	overrides.forEach((value, key) => {
+		normalizedOption[key] = value;
+	});
+	return {
+		option: normalizedOption,
+		signature: buildSignature(normalizedOption)
+	};
+}
+/**
+* Produce an update plan plus a normalized option that encodes common deletions.
+* Falls back to `notMerge: true` when the change looks complex.
+*/
+function planUpdate(prev, option) {
+	const next = buildSignature(option);
+	if (!prev) return {
+		option,
+		signature: next,
+		plan: { notMerge: false }
+	};
+	if (shouldForceNotMerge(prev, next)) return {
+		option,
+		signature: next,
+		plan: { notMerge: true }
+	};
+	const overrides = collectObjectOverrides(prev, next);
+	const replaceMergeSet = collectArrayChanges(prev, next, overrides);
+	const normalized = applyOverrides(option, next, overrides);
+	const replaceMerge = replaceMergeSet.size > 0 ? Array.from(replaceMergeSet).sort() : void 0;
+	return {
+		option: normalized.option,
+		signature: normalized.signature,
+		plan: replaceMerge ? {
+			notMerge: false,
+			replaceMerge
+		} : { notMerge: false }
+	};
+}
+//#endregion
+//#region src/style.css?raw
+var style_default = "x-macroui-echarts{display:block;width:100%;height:100%;min-width:0;}\nx-macroui-echarts>.echarts-host{display:block;width:100%;height:100%;min-width:0;}\nx-macroui-echarts>.echarts-host>:first-child,x-macroui-echarts>.echarts-host>:first-child>canvas{border-radius:inherit;}\n";
+//#endregion
+//#region src/style.ts
+if (isBrowser()) if (Array.isArray(document.adoptedStyleSheets) && "replaceSync" in CSSStyleSheet.prototype) {
+	const sheet = new CSSStyleSheet();
+	sheet.replaceSync(style_default);
+	document.adoptedStyleSheets = [...document.adoptedStyleSheets, sheet];
+} else {
+	const styleEl = document.createElement("style");
+	styleEl.textContent = style_default;
+	document.head.appendChild(styleEl);
+}
+//#endregion
+//#region src/ECharts.ts
+const wcRegistered = register();
+const THEME_KEY = Symbol();
+const INIT_OPTIONS_KEY = Symbol();
+const UPDATE_OPTIONS_KEY = Symbol();
+//#endregion
+//#region src/index.ts
+var src_default = defineComponent({
+	name: "Echarts",
+	inheritAttrs: false,
+	props: {
+		option: Object,
+		theme: { type: [Object, String] },
+		initOptions: Object,
+		updateOptions: Object,
+		group: String,
+		manualUpdate: Boolean,
+		...autoresizeProps,
+		...loadingProps
+	},
+	emits: {},
+	slots: Object,
+	setup(props, { attrs, expose, slots }) {
+		const attrsMap = attrs;
+		const root = shallowRef();
+		const chartHost = shallowRef();
+		const chart = shallowRef();
+		const isReady = shallowRef(false);
+		const defaultTheme = inject(THEME_KEY, null);
+		const defaultInitOptions = inject(INIT_OPTIONS_KEY, null);
+		const defaultUpdateOptions = inject(UPDATE_OPTIONS_KEY, null);
+		const { autoresize, manualUpdate, loading, loadingOptions } = toRefs(props);
+		const realTheme = computed(() => props.theme || toValue(defaultTheme));
+		const realInitOptions = computed(() => props.initOptions || toValue(defaultInitOptions) || void 0);
+		const realUpdateOptions = computed(() => props.updateOptions || toValue(defaultUpdateOptions));
+		const { nonEventAttrs, nativeListeners } = useReactiveEventAttrs(attrsMap);
+		const { render: renderSlot, patchOption } = useSlotOption(slots, requestUpdate);
+		const { patchOption: patchGraphicOption, render: renderGraphic } = useRuntime({
+			chart,
+			slots,
+			manualUpdate,
+			requestUpdate
+		}) ?? {};
+		let lastSignature;
+		function withGraphicReplaceMerge(updateOptions) {
+			if (!slots.graphic || !patchGraphicOption) return updateOptions;
+			const replaceMerge = [...updateOptions?.replaceMerge ?? [], "graphic"];
+			return {
+				...updateOptions,
+				replaceMerge: [...new Set(replaceMerge)]
+			};
+		}
+		function applyOption(instance, option, override, manual = false) {
+			const slotted = patchOption(option);
+			const patched = patchGraphicOption ? patchGraphicOption(slotted) : slotted;
+			if (manual) {
+				instance.setOption(patched, withGraphicReplaceMerge(override) ?? {});
+				lastSignature = void 0;
+				return;
+			}
+			if (override) {
+				const planned = planUpdate(lastSignature, patched);
+				instance.setOption(patched, withGraphicReplaceMerge(override));
+				lastSignature = planned.signature;
+				return;
+			}
+			if (realUpdateOptions.value) {
+				instance.setOption(patched, withGraphicReplaceMerge(realUpdateOptions.value));
+				lastSignature = void 0;
+				return;
+			}
+			const planned = planUpdate(lastSignature, patched);
+			const updateOptions = { notMerge: planned.plan.notMerge };
+			const replacements = (planned.plan.replaceMerge ?? []).filter((key) => key != null);
+			if (replacements.length > 0) updateOptions.replaceMerge = [...new Set(replacements)];
+			instance.setOption(planned.option, withGraphicReplaceMerge(updateOptions));
+			lastSignature = planned.signature;
+		}
+		function requestUpdate(updateOptions) {
+			const instance = chart.value;
+			const option = props.option;
+			if (!instance || !option || manualUpdate.value) return false;
+			applyOption(instance, option, updateOptions);
+			return true;
+		}
+		if (slots.graphic && !patchGraphicOption) warn$1("Detected `#graphic` slot but no extension is registered. Import from `@macroui/echarts-vue/graphic` to enable it.");
+		useReactiveChartListeners(chart, attrsMap);
+		function cleanup() {
+			const instance = chart.value;
+			if (instance) {
+				instance.dispose();
+				chart.value = void 0;
+			}
+			isReady.value = false;
+			lastSignature = void 0;
+		}
+		function init$1() {
+			isReady.value = false;
+			const host = chartHost.value;
+			const instance = chart.value = init(host, realTheme.value, realInitOptions.value);
+			if (props.group) instance.group = props.group;
+			function resize() {
+				if (!instance.isDisposed()) instance.resize();
+			}
+			function commit() {
+				const option = props.option;
+				if (!option) return;
+				if (manualUpdate.value) {
+					applyOption(instance, option, void 0, true);
+					return;
+				}
+				applyOption(instance, option);
+			}
+			if (autoresize.value) {
+				nextTick(() => {
+					resize();
+					commit();
+					isReady.value = true;
+				});
+				return;
+			}
+			commit();
+			isReady.value = true;
+		}
+		const setOption = (option, notMerge, lazyUpdate) => {
+			if (!props.manualUpdate) {
+				warn$1("`setOption` is only available when `manual-update` is `true`.");
+				return;
+			}
+			const updateOptions = typeof notMerge === "boolean" ? {
+				notMerge,
+				lazyUpdate
+			} : notMerge;
+			const instance = chart.value;
+			if (!instance) return;
+			applyOption(instance, option, updateOptions ?? void 0, true);
+		};
+		watch(() => props.option, (option) => {
+			if (!option) {
+				lastSignature = void 0;
+				return;
+			}
+			if (manualUpdate.value) {
+				warn$1("`option` prop changes are ignored when `manual-update` is `true`.");
+				return;
+			}
+			const instance = chart.value;
+			if (!instance) return;
+			applyOption(instance, option);
+		}, { deep: true });
+		watch([manualUpdate, realInitOptions], () => {
+			cleanup();
+			init$1();
+		}, { deep: true });
+		watch(realTheme, (theme) => {
+			const instance = chart.value;
+			if (instance) {
+				instance.setTheme(theme || {});
+				if (props.option && !manualUpdate.value) applyOption(instance, props.option);
+			}
+		}, { deep: true });
+		watchEffect(() => {
+			const instance = chart.value;
+			if (props.group && instance) instance.group = props.group;
+		});
+		const publicApi = usePublicAPI(chart);
+		useLoading(chart, loading, loadingOptions);
+		useAutoresize(chart, autoresize, root);
+		onMounted(init$1);
+		onBeforeUnmount(() => {
+			if (wcRegistered && root.value) {
+				root.value.__dispose = cleanup;
+				return;
+			}
+			cleanup();
+		});
+		expose({
+			setOption,
+			root,
+			chart,
+			...publicApi
+		});
+		return (() => {
+			const children = [h("div", {
+				ref: chartHost,
+				class: "echarts-host"
+			})];
+			if (isReady.value) {
+				const teleported = renderSlot();
+				if (teleported) children.push(teleported);
+			}
+			if (renderGraphic) {
+				const graphic = renderGraphic();
+				if (graphic) children.push(graphic);
+			}
+			return h(TAG_NAME, {
+				...nonEventAttrs.value,
+				...nativeListeners.value,
+				ref: root,
+				class: ["echarts", nonEventAttrs.value.class]
+			}, children);
+		});
+	}
+});
+//#endregion
+export { INIT_OPTIONS_KEY, LOADING_OPTIONS_KEY, THEME_KEY, UPDATE_OPTIONS_KEY, src_default as default };
+
+//# sourceMappingURL=index.js.map