@visactor/vchart 0.0.1-alpha.0

package/esm/chart/base-chart.js

@@ -0,0 +1,621 @@
+var __awaiter = this && this.__awaiter || function(thisArg, _arguments, P, generator) {
+    return new (P || (P = Promise))((function(resolve, reject) {
+        function fulfilled(value) {
+            try {
+                step(generator.next(value));
+            } catch (e) {
+                reject(e);
+            }
+        }
+        function rejected(value) {
+            try {
+                step(generator.throw(value));
+            } catch (e) {
+                reject(e);
+            }
+        }
+        function step(result) {
+            var value;
+            result.done ? resolve(result.value) : (value = result.value, value instanceof P ? value : new P((function(resolve) {
+                resolve(value);
+            }))).then(fulfilled, rejected);
+        }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    }));
+};
+
+import { GlobalScale } from "../scale/global-scale";
+
+import { Factory } from "../core/factory";
+
+import { Event } from "../event/event";
+
+import { isArray, isValid, createID, calcPadding, normalizeLayoutPaddingSpec, array, isTrueBrowser, isString, getActualColor } from "../util";
+
+import { Stack } from "./stack";
+
+import { BaseModel } from "../model/base-model";
+
+import { BaseMark } from "../mark/base/base-mark";
+
+import { DEFAULT_CHART_WIDTH, DEFAULT_CHART_HEIGHT } from "../constant/base";
+
+import { dataToDataView } from "../data/initialize";
+
+import { has, isFunction, isEmpty, getContainerSize } from "@visactor/vutils";
+
+import { getDataScheme } from "../theme/color-scheme/util";
+
+import { CompilableBase } from "../compile/compilable-base";
+
+import { STATE_VALUE_ENUM } from "../compile/mark/interface";
+
+import { ChartEvent, VGRAMMAR_HOOK_EVENT } from "../constant";
+
+export class BaseChart extends CompilableBase {
+    getSpec() {
+        return this._spec;
+    }
+    setSpec(s) {
+        this.transformSpec(s), this._spec = s;
+    }
+    getLayoutRect() {
+        return this._layoutRect;
+    }
+    getViewRect() {
+        return this._viewRect;
+    }
+    getLayoutTag() {
+        return this._layoutTag;
+    }
+    setLayoutTag(tag, morphConfig) {
+        var _a;
+        return this._layoutTag = tag, (null === (_a = this.getCompiler()) || void 0 === _a ? void 0 : _a.getVGrammarView()) && (this.getCompiler().getVGrammarView().updateLayoutTag(), 
+        tag && this.getCompiler().reRenderAsync(morphConfig)), this._layoutTag;
+    }
+    constructor(spec, option) {
+        var _a, _b;
+        super(option), this.type = "chart", this.id = createID(), this._regions = [], this._series = [], 
+        this._components = [], this._layoutRect = {
+            x: 0,
+            y: 0,
+            width: DEFAULT_CHART_WIDTH,
+            height: DEFAULT_CHART_HEIGHT
+        }, this._viewRect = {
+            width: DEFAULT_CHART_WIDTH,
+            height: DEFAULT_CHART_HEIGHT
+        }, this._viewBox = {
+            x1: 0,
+            y1: 0,
+            x2: DEFAULT_CHART_WIDTH,
+            y2: DEFAULT_CHART_HEIGHT
+        }, this._idMap = new Map, this._layoutTag = !0, this.state = {
+            layoutUpdateRank: 1
+        }, this.padding = {
+            top: 0,
+            left: 0,
+            right: 0,
+            bottom: 0
+        }, this.getAllSeries = () => {
+            var _a;
+            return null !== (_a = this._series) && void 0 !== _a ? _a : [];
+        }, this.getRegionsInIndex = index => index && 0 !== index.length ? this._regions.filter(((_r, i) => index.includes(i))) : [ this._regions[0] ], 
+        this.getAllRegions = () => this._regions, this.getRegionsInIds = ids => ids ? this._regions.filter((r => ids.includes(r.id))) : [], 
+        this.getRegionsInQuerier = region => region ? this._regions.filter(((r, index) => array(region).some((regionFilter => isValid(regionFilter.regionId) && regionFilter.regionId === r.userId || regionFilter.regionIndex === index)))) : this._regions, 
+        this.getRegionsInUserId = userId => {
+            if (userId) return this._regions.find((r => r.userId === userId));
+        }, this.getRegionsInUserIdOrIndex = (user_ids, index) => this.getAllRegions().filter((r => (null == user_ids ? void 0 : user_ids.length) ? r.userId && user_ids.includes(r.userId) : !(null == index ? void 0 : index.length) || index.includes(r.getSpecIndex()))), 
+        this.getComponents = () => this._components, this.getSeriesInIndex = index => index && 0 !== index.length ? this._series.filter(((_r, i) => index.includes(i))) : [ this._series[0] ], 
+        this.getSeriesInIds = ids => ids ? this._series.filter((r => ids.includes(r.id))) : [], 
+        this.getSeriesInUserId = userId => {
+            if (userId) return this._series.find((r => r.userId === userId));
+        }, this.getSeriesInUserIdOrIndex = (user_ids, index) => this.getAllSeries().filter((s => (null == user_ids ? void 0 : user_ids.length) ? s.userId && user_ids.includes(s.userId) : !(null == index ? void 0 : index.length) || index.includes(s.getSpecIndex()))), 
+        this.getComponentByIndex = (key, index) => {
+            const components = this._components.filter((c => c.specKey === key));
+            if (components && 0 !== components.length) return components[index];
+        }, this.getComponentsByKey = key => this._components.filter((c => c.specKey === key)), 
+        this.getComponentByUserId = userId => {
+            const component = this._components.find((s => s.userId === userId));
+            if (component) return component;
+        }, this._theme = option.getTheme(), this._paddingSpec = normalizeLayoutPaddingSpec(null !== (_a = spec.padding) && void 0 !== _a ? _a : null === (_b = this._theme) || void 0 === _b ? void 0 : _b.padding), 
+        this._event = new Event(option.eventDispatcher, option.mode), this._dataSet = option.dataSet, 
+        this._modelOption = Object.assign(Object.assign({}, option), {
+            mode: this._option.mode,
+            map: this._idMap,
+            getChartLayoutRect: () => this._layoutRect,
+            getChartViewRect: () => this._viewRect,
+            getChart: () => this,
+            globalScale: this._globalScale
+        }), this._stack = new Stack(this), this._spec = spec;
+    }
+    created() {
+        this.transformSpec(this._spec), this.createGlobalScale(), this.createLayout(), this.createRegion(this._spec.region), 
+        this.createSeries(this._spec.series), this.createComponent(this._spec);
+    }
+    transformSpec(spec) {
+        spec.region && 0 !== spec.region.length || (spec.region = [ {} ]), has(spec, "tooltip") || (spec.tooltip = {});
+    }
+    init(options = {}) {
+        this.initRegion(), this.initSeries(), this.initGlobalScale(), this.initComponent(), 
+        this.initEvent(), this._stack.init(), this._series.forEach((s => {
+            var _a;
+            return null === (_a = s.getRawData()) || void 0 === _a ? void 0 : _a.markRunning();
+        })), this._series.forEach((s => s.fillData()));
+    }
+    onResize(width, height) {
+        const canvasRect = {
+            width: width,
+            height: height
+        };
+        this._canvasRect = canvasRect, this._updateLayoutRect(this._option.viewBox), this.setLayoutTag(!0);
+    }
+    updateViewBox(viewBox) {
+        this._updateLayoutRect(viewBox), this.setLayoutTag(!0);
+    }
+    createRegion(regionSpec) {
+        regionSpec && regionSpec.forEach(((s, i) => {
+            const region = Factory.createRegion("region", s, Object.assign(Object.assign({}, this._modelOption), {
+                specIndex: i,
+                specKey: "region"
+            }));
+            region && (region.created(), this._regions.push(region));
+        }));
+    }
+    initRegion() {
+        this._regions.forEach((r => r.init({})));
+    }
+    createSeries(seriesSpec) {
+        seriesSpec.forEach(((spec, index) => {
+            let region;
+            if (spec.data ? spec.data = dataToDataView(spec.data, this._dataSet, this._spec.data) : spec.data = this.getSeriesData(spec.dataId, spec.dataIndex), 
+            !1 === this._option.animation && (spec.animation = !1), isValid(spec.regionId) ? region = this.getRegionsInUserId(spec.regionId) : isValid(spec.regionIndex) && (region = this.getRegionsInIndex([ spec.regionIndex ])[0]), 
+            region || (region = this._regions[0]), !region) return;
+            const series = Factory.createSeries(spec.type, spec, Object.assign(Object.assign({}, this._modelOption), {
+                region: region,
+                specIndex: index,
+                specKey: "series",
+                getTheme: () => this._theme,
+                globalScale: this._globalScale,
+                getSeriesData: this.getSeriesData.bind(this)
+            }));
+            series && (series.created(), this._series.push(series), region.addSeries(series));
+        }));
+    }
+    initSeries() {
+        this._series.forEach((s => s.init({})));
+    }
+    getSeriesById(id) {
+        return this._series.find((x => x.id === id));
+    }
+    createComponent(spec) {
+        Factory.getComponents().forEach((C => {
+            const cmp = C.createComponent(spec, Object.assign(Object.assign({}, this._modelOption), {
+                getAllRegions: this.getAllRegions,
+                getRegionsInIndex: this.getRegionsInIndex,
+                getRegionsInIds: this.getRegionsInIds,
+                getRegionsInUserIdOrIndex: this.getRegionsInUserIdOrIndex,
+                getTheme: () => this._theme,
+                getAllSeries: this.getAllSeries,
+                getSeriesInIndex: this.getSeriesInIndex,
+                getSeriesInIds: this.getSeriesInIds,
+                getSeriesInUserIdOrIndex: this.getSeriesInUserIdOrIndex,
+                getAllComponents: this.getComponents,
+                getComponentByIndex: this.getComponentByIndex,
+                getComponentByUserId: this.getComponentByUserId,
+                getComponentsByKey: this.getComponentsByKey
+            }));
+            cmp && array(cmp).forEach((c => {
+                c.created(), this._components.push(c);
+            }));
+        }));
+    }
+    initComponent() {
+        this._components.forEach((c => c.init({
+            dataSet: this._dataSet
+        })));
+    }
+    getAllComponents() {
+        return this._components;
+    }
+    getAllModels() {
+        return [].concat(this.getAllSeries(), this.getAllComponents(), this.getAllRegions());
+    }
+    createLayout() {
+        this._updateLayoutRect(this._option.viewBox), this._initLayoutFunc();
+    }
+    setLayout(layout) {
+        this._option.layout = layout, this._initLayoutFunc();
+    }
+    _initLayoutFunc() {
+        var _a, _b;
+        if (this._layoutFunc = this._option.layout, !this._layoutFunc) {
+            const layout = new (Factory.getLayout(null !== (_b = null === (_a = this._spec.layout) || void 0 === _a ? void 0 : _a.type) && void 0 !== _b ? _b : "base"))(this._spec.layout);
+            this._layoutFunc = layout.layoutItems.bind(layout);
+        }
+    }
+    layout(params) {
+        var _a, _b, _c, _d;
+        if (null === (_b = null === (_a = this._option.performanceHook) || void 0 === _a ? void 0 : _a.beforeLayoutWithSceneGraph) || void 0 === _b || _b.call(_a), 
+        this.getLayoutTag()) {
+            this._event.emit(ChartEvent.layoutStart, {
+                chart: this
+            }), this.onLayoutStart(params);
+            const elements = this.getLayoutElements();
+            this._layoutFunc(this, elements, this._layoutRect, this._viewBox), this.setLayoutTag(!1), 
+            this.onLayoutEnd(params), this._event.emit(ChartEvent.layoutEnd, {
+                chart: this
+            });
+        }
+        null === (_d = null === (_c = this._option.performanceHook) || void 0 === _c ? void 0 : _c.afterLayoutWithSceneGraph) || void 0 === _d || _d.call(_c);
+    }
+    onLayoutStart(option) {
+        this.getLayoutElements().forEach((element => element.onLayoutStart(this._layoutRect, this._viewRect, option)));
+    }
+    onLayoutEnd(option) {
+        this.getLayoutElements().forEach((element => element.onLayoutEnd(option)));
+    }
+    onEvaluateEnd(option) {
+        this.getLayoutElements().forEach((element => element.onEvaluateEnd(option)));
+    }
+    getLayoutElements() {
+        return [ ...this._components, ...this._regions, ...this._series ];
+    }
+    getModelById(id) {
+        const model = this._idMap.get(id);
+        if (model && model instanceof BaseModel) return model;
+    }
+    getModelByUserId(userId) {
+        const series = this._series.find((s => s.userId === userId));
+        if (series) return series;
+        const region = this._regions.find((s => s.userId === userId));
+        if (region) return region;
+        const component = this._components.find((s => s.userId === userId));
+        return component || void 0;
+    }
+    getAllMarks() {
+        return Array.from(this._idMap.values()).filter((item => item && item instanceof BaseMark));
+    }
+    getMarkById(id) {
+        const mark = this._idMap.get(id);
+        if (mark && mark instanceof BaseMark) return mark;
+    }
+    updateParseData(id, data, options) {
+        const dv = this._dataSet.getDataView(id);
+        dv && dv.updateRawData(data);
+    }
+    updateData(id, data, options) {
+        const dv = this._dataSet.getDataView(id);
+        dv && dv.parseNewData(data), this.getAllModels().forEach((model => model.onDataUpdate()));
+    }
+    onRender(option) {}
+    getCanvasRect() {
+        if (this._canvasRect) return this._canvasRect;
+        const {width: userWidth, height: userHeight} = this._spec;
+        if (isValid(userWidth) && isValid(userHeight)) this._canvasRect = {
+            width: userWidth,
+            height: userHeight
+        }; else {
+            let width = DEFAULT_CHART_WIDTH, height = DEFAULT_CHART_HEIGHT;
+            const container = this._option.container, canvas = this._option.canvas;
+            if (container) {
+                const {width: containerWidth, height: containerHeight} = getContainerSize(this._option.container, DEFAULT_CHART_WIDTH, DEFAULT_CHART_HEIGHT);
+                width = containerWidth, height = containerHeight;
+            } else if (canvas && isTrueBrowser(this._option.mode)) {
+                let canvasNode;
+                canvasNode = isString(canvas) ? null === document || void 0 === document ? void 0 : document.getElementById(canvas) : canvas;
+                const {width: containerWidth, height: containerHeight} = getContainerSize(canvasNode, DEFAULT_CHART_WIDTH, DEFAULT_CHART_HEIGHT);
+                width = containerWidth, height = containerHeight;
+            }
+            width = null != userWidth ? userWidth : width, height = null != userHeight ? userHeight : height, 
+            this._canvasRect = {
+                width: width,
+                height: height
+            };
+        }
+        return this._canvasRect;
+    }
+    getSeriesData(id, index) {
+        if (!this._spec.data) throw new Error("no data in spec!");
+        if ("string" == typeof id) {
+            const metchData = this._spec.data.filter((data => data.name === id));
+            if (metchData[0]) return metchData[0];
+            throw new Error(`no data matches dataId ${id}!`);
+        }
+        if ("number" == typeof index) {
+            if (this._spec.data[index]) return this._spec.data[index];
+            throw new Error(`no data matches dataIndex ${index}!`);
+        }
+        return this._spec.data[0];
+    }
+    createGlobalScale() {
+        var _a, _b, _c;
+        const scales = null !== (_a = this._spec.scales) && void 0 !== _a ? _a : [];
+        let colorScaleSpec = scales.find((s => "color" === s.id));
+        if (!colorScaleSpec && (colorScaleSpec = {
+            type: "ordinal",
+            id: "color",
+            domain: null,
+            range: null
+        }, scales.push(colorScaleSpec), this._spec.color)) {
+            const colorSpec = this._spec.color;
+            isArray(colorSpec) ? colorScaleSpec.range = colorSpec.map((color => {
+                var _a;
+                return getActualColor(color, null === (_a = this._theme) || void 0 === _a ? void 0 : _a.colorScheme);
+            })) : (colorScaleSpec.type = colorSpec.type, colorSpec.domain && (colorScaleSpec.domain = colorSpec.domain), 
+            colorScaleSpec.range = colorSpec.range);
+        }
+        (null === (_b = colorScaleSpec.range) || void 0 === _b ? void 0 : _b.length) || (colorScaleSpec.range = getDataScheme(null === (_c = this._theme) || void 0 === _c ? void 0 : _c.colorScheme), 
+        colorScaleSpec.rangeTheme = !0), this._globalScale = new GlobalScale(scales, this), 
+        this._modelOption.globalScale = this._globalScale;
+    }
+    initGlobalScale() {
+        const domainSet = new Set;
+        this._series.forEach((s => {
+            const keys = s.getSeriesKeys();
+            keys && keys.forEach((k => domainSet.add(k)));
+        }));
+        const domain = Array.from(domainSet);
+        this._globalScale.updateScaleDomain(domain);
+    }
+    updateGlobalScaleTheme() {
+        var _a;
+        const colorSpec = this._globalScale.getScaleSpec("color");
+        colorSpec.rangeTheme && (colorSpec.range = getDataScheme(null === (_a = this._theme) || void 0 === _a ? void 0 : _a.colorScheme), 
+        this._globalScale.getScale("color").range(colorSpec.range));
+    }
+    updateSpec(spec, morphConfig) {
+        const result = {
+            change: !1,
+            reMake: !1,
+            reRender: !1,
+            reSize: !1,
+            reCompile: !1
+        };
+        if (this.setLayoutTag(!0, morphConfig), spec.type !== this.type) return result.reMake = !0, 
+        result;
+        this.transformSpec(spec);
+        const currentKeys = Object.keys(this._spec), nextKeys = Object.keys(spec);
+        return JSON.stringify(currentKeys) !== JSON.stringify(nextKeys) ? (result.reMake = !0, 
+        result) : (this._spec = spec, this.updateDataSpec(result), result.reMake ? result : (this.updateRegionSpec(result), 
+        result.reMake ? result : (this.updateComponentSpec(result), result.reMake || this.updateSeriesSpec(result), 
+        result)));
+    }
+    updateDataSpec(result) {
+        this._spec.data && array(this._spec.data).forEach((d => {
+            const dataView = this._dataSet.getDataView(d.id);
+            dataView && (d.values ? dataView.updateRawData(d.values) : d.latestData || dataView.updateRawData([]));
+        }));
+    }
+    updateRegionSpec(result) {
+        var _a;
+        (null === (_a = this._spec) || void 0 === _a ? void 0 : _a.region) && (this._spec.region.length === this._regions.length ? this._regions.forEach((r => {
+            this._mergeUpdateResult(result, r.updateSpec(this._spec.region[r.getSpecIndex()])), 
+            r.reInit();
+        })) : result.reMake = !0);
+    }
+    updateComponentSpec(result) {
+        const componentCache = {};
+        this._components.forEach((c => {
+            var _a;
+            const cmpSpec = null !== (_a = this._spec[c.specKey]) && void 0 !== _a ? _a : {};
+            isArray(cmpSpec) ? (componentCache[c.specKey] = componentCache[c.specKey] || {
+                specCount: cmpSpec.length,
+                componentCount: 0
+            }, componentCache[c.specKey].componentCount++, this._mergeUpdateResult(result, c.updateSpec(cmpSpec[c.getSpecIndex()]))) : this._mergeUpdateResult(result, c.updateSpec(cmpSpec)), 
+            c.reInit();
+        }));
+        for (const key in componentCache) if (Object.prototype.hasOwnProperty.call(componentCache, key)) {
+            const element = componentCache[key];
+            element.componentCount !== element.specCount && (result.reMake = !0);
+        }
+    }
+    updateSeriesSpec(result) {
+        this._spec.series.length === this._series.length ? this._series.forEach((s => {
+            this._mergeUpdateResult(result, s.updateSpec(this._spec.series[s.getSpecIndex()])), 
+            s.reInit();
+        })) : result.reMake = !0;
+    }
+    getCanvas() {
+        var _a, _b;
+        return null !== (_b = null === (_a = this.getCompiler()) || void 0 === _a ? void 0 : _a.getCanvas()) && void 0 !== _b ? _b : null;
+    }
+    isValidSeries(seriesType) {
+        return !0;
+    }
+    _getDefaultSeriesSpec(spec) {
+        var _a;
+        return {
+            data: null === (_a = spec.data) || void 0 === _a ? void 0 : _a[0],
+            dataKey: spec.dataKey,
+            hover: spec.hover,
+            select: spec.select,
+            label: spec.label,
+            seriesStyle: spec.seriesStyle,
+            animation: spec.animation,
+            animationAppear: spec.animationAppear,
+            animationDisappear: spec.animationDisappear,
+            animationEnter: spec.animationEnter,
+            animationUpdate: spec.animationUpdate,
+            animationExit: spec.animationExit,
+            animationNormal: spec.animationNormal,
+            extensionMark: spec.extensionMark
+        };
+    }
+    _mergeUpdateResult(resultA, resultB) {
+        resultA.change = resultA.change || resultB.change, resultA.reCompile = resultA.reCompile || resultB.reCompile, 
+        resultA.reMake = resultA.reMake || resultB.reMake, resultA.reRender = resultA.reRender || resultB.reRender, 
+        resultA.reSize = resultA.reSize || resultB.reSize;
+    }
+    _updateLayoutRect(viewBox) {
+        let viewRect = this.getCanvasRect();
+        if (viewBox) {
+            this._viewBox = viewBox;
+            const {x1: x1 = 0, y1: y1 = 0, x2: x2, y2: y2} = viewBox;
+            viewRect = {
+                width: x2 - x1,
+                height: y2 - y1
+            };
+        } else this._viewBox = {
+            x1: 0,
+            y1: 0,
+            x2: viewRect.width,
+            y2: viewRect.height
+        };
+        this._viewRect = viewRect, this.padding = calcPadding(this._paddingSpec, viewRect, viewRect), 
+        this._layoutRect.width = viewRect.width - this.padding.left - this.padding.right, 
+        this._layoutRect.height = viewRect.height - this.padding.top - this.padding.bottom, 
+        this._layoutRect.x = this.padding.left, this._layoutRect.y = this.padding.top;
+    }
+    getCurrentTheme() {
+        return this._theme;
+    }
+    setCurrentTheme(theme) {
+        this._theme = theme, this.setLayoutTag(!0), this.transformSpec(this._spec), this.updateGlobalScaleTheme(), 
+        this.setRegionTheme(), this.setComponentTheme(theme), this.setSeriesTheme(theme);
+    }
+    setRegionTheme() {
+        this._regions.forEach((r => {
+            r.reInit();
+        }));
+    }
+    setComponentTheme(theme) {
+        this._components.forEach((c => {
+            c.setCurrentTheme(theme.series[c.type], !0);
+        }));
+    }
+    setSeriesTheme(theme) {
+        this._series.forEach((s => __awaiter(this, void 0, void 0, (function*() {
+            yield s.setCurrentTheme(theme.series[s.type], !0);
+        }))));
+    }
+    compile() {
+        this.compileLayout(), this.compileRegions(), this.compileSeries(), this.compileComponents();
+    }
+    compileLayout() {
+        const {width: width, height: height} = this.getCanvasRect();
+        this.getCompiler().setSize(width, height);
+    }
+    compileRegions() {
+        var _a, _b, _c, _d;
+        null === (_b = null === (_a = this._option.performanceHook) || void 0 === _a ? void 0 : _a.beforeRegionCompile) || void 0 === _b || _b.call(_a), 
+        this.getAllRegions().forEach((r => {
+            r.compile();
+        })), null === (_d = null === (_c = this._option.performanceHook) || void 0 === _c ? void 0 : _c.afterRegionCompile) || void 0 === _d || _d.call(_c);
+    }
+    compileSeries() {
+        var _a, _b, _c, _d;
+        null === (_b = null === (_a = this._option.performanceHook) || void 0 === _a ? void 0 : _a.beforeSeriesCompile) || void 0 === _b || _b.call(_a), 
+        this.getAllSeries().forEach((s => {
+            s.compile();
+        })), null === (_d = null === (_c = this._option.performanceHook) || void 0 === _c ? void 0 : _c.afterSeriesCompile) || void 0 === _d || _d.call(_c);
+    }
+    compileComponents() {
+        var _a, _b, _c, _d;
+        null === (_b = null === (_a = this._option.performanceHook) || void 0 === _a ? void 0 : _a.beforeComponentCompile) || void 0 === _b || _b.call(_a), 
+        this.getAllComponents().forEach((c => {
+            c.compile();
+        })), null === (_d = null === (_c = this._option.performanceHook) || void 0 === _c ? void 0 : _c.afterComponentCompile) || void 0 === _d || _d.call(_c);
+    }
+    release() {
+        super.release(), [ ...this._components, ...this._regions, ...this._series ].forEach((m => {
+            m.release();
+        })), this._components = this._regions = this._series = [], this._spec = {}, this._dataSet = this._globalScale = this._layoutFunc = null, 
+        this._layoutTag = !1, this._idMap.clear();
+    }
+    onLayout(srView) {
+        const root = srView.rootMark;
+        this.checkUpdate(root, null, null), this.layout({
+            group: root,
+            srView: srView
+        });
+    }
+    checkUpdate(mark, model, sceneRoot) {
+        var _a, _b;
+        if ((null === (_a = mark.context) || void 0 === _a ? void 0 : _a.model) && (sceneRoot = mark, 
+        model = mark.context.model), model && mark.isUpdated) return null === (_b = model.bindSceneNode) || void 0 === _b || _b.call(model, sceneRoot.elements[0]), 
+        void model.setAttributeTag(!0);
+        "group" === mark.markType && mark.children.forEach((child => {
+            this.checkUpdate(child, model, sceneRoot);
+        }));
+    }
+    updateState(state, filter) {
+        const seriesArr = this.getAllSeries();
+        for (const key in state) {
+            if (isEmpty(state[key])) continue;
+            const stateSpec = state[key];
+            let stateInfo = {
+                stateValue: key
+            };
+            stateInfo = isFunction(stateSpec.filter) ? Object.assign({
+                filter: stateSpec.filter
+            }, stateInfo) : Object.assign(Object.assign({}, stateSpec.filter), stateInfo), stateSpec.level && (stateInfo.level = stateSpec.level), 
+            seriesArr.forEach((series => {
+                series.getMarks().forEach((m => {
+                    m.stateStyle[key] && (filter && !filter(series, m, key) || (m.state.changeStateInfo(stateInfo), 
+                    m.updateMarkState(key)));
+                }));
+            }));
+        }
+    }
+    setSelected(datum, filter, region) {
+        this._setStateInDatum(STATE_VALUE_ENUM.STATE_SELECTED, !0, datum, filter, region);
+    }
+    setHovered(datum, filter, region) {
+        this._setStateInDatum(STATE_VALUE_ENUM.STATE_HOVER, !0, datum, filter, region);
+    }
+    initEvent() {
+        [ ChartEvent.dataZoomChange, ChartEvent.scrollBarChange ].forEach((event => {
+            this._event.on(event, (({value: value}) => {
+                if (!value.filterData) return;
+                this._disableMarkAnimation([ "exit", "update" ]);
+                const enableMarkAnimate = () => {
+                    this._enableMarkAnimation([ "exit", "update" ]), this._event.off(VGRAMMAR_HOOK_EVENT.AFTER_MARK_RENDER_END, enableMarkAnimate);
+                };
+                this._event.on(VGRAMMAR_HOOK_EVENT.AFTER_MARK_RENDER_END, enableMarkAnimate);
+            }));
+        }));
+    }
+    _enableMarkAnimation(states) {
+        this.getAllMarks().forEach((mark => {
+            const product = mark.getProduct();
+            product && product.animate && product.animate.enableAnimationState(states);
+        }));
+    }
+    _disableMarkAnimation(states) {
+        this.getAllMarks().forEach((mark => {
+            const product = mark.getProduct();
+            product && product.animate && product.animate.disableAnimationState(states);
+        }));
+    }
+    _setStateInDatum(stateKey, checkReverse, datum, filter, region) {
+        const keys = (datum = datum ? array(datum) : null) ? Object.keys(datum[0]) : null;
+        this.getRegionsInQuerier(region).forEach((r => {
+            datum ? (r.getSeries().forEach((s => {
+                s.getMarks().forEach((m => {
+                    if (m.getProduct() && (!filter || isFunction(filter) && filter(s, m))) {
+                        const isCollect = m.getProduct().isCollectionMark(), elements = m.getProduct().elements;
+                        let pickElements = elements;
+                        if (isCollect) pickElements = elements.filter((e => {
+                            const elDatum = e.getDatum();
+                            datum.every(((d, index) => keys.every((k => d[k] == elDatum[index][k]))));
+                        })); else if (datum.length > 1) {
+                            const datumTemp = [ ...datum ];
+                            pickElements = elements.filter((e => {
+                                if (0 === datumTemp.length) return !1;
+                                const elDatum = e.getDatum(), index = datumTemp.findIndex((d => keys.every((k => d[k] == elDatum[k]))));
+                                return index >= 0 && (datumTemp.splice(index, 1), !0);
+                            }));
+                        } else {
+                            const el = elements.find((e => keys.every((k => datum[0][k] == e.getDatum()[k]))));
+                            el && (pickElements = [ el ]);
+                        }
+                        pickElements.forEach((element => {
+                            r.interaction.addEventElement(stateKey, element);
+                        }));
+                    }
+                }));
+            })), checkReverse && r.interaction.reverseEventElement(stateKey)) : r.interaction.clearEventElement(stateKey, !0);
+        }));
+    }
+}
+//# sourceMappingURL=base-chart.js.map