@visactor/vchart 0.0.1-alpha.0

package/esm/series/base/base-series.js

@@ -0,0 +1,565 @@
+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 { ChartEvent } from "../../constant/event";
+
+import { DEFAULT_DATA_KEY, DEFAULT_DATA_SERIES_FIELD, DEFAULT_SERIES_STYLE_NAME, PREFIX, STACK_FIELD_END, STACK_FIELD_END_PERCENT, STACK_FIELD_START, STACK_FIELD_START_PERCENT } from "../../constant/index";
+
+import { DataView } from "@visactor/vdataset";
+
+import { MarkTypeEnum } from "../../mark/interface";
+
+import { BaseModel } from "../../model/base-model";
+
+import { dataViewFromDataView } from "../../data/initialize";
+
+import { isNil, isValid, isBoolean, isString, merge, isFunction, isArray, mergeFields, getFieldAlias } from "../../util";
+
+import { Group } from "./group";
+
+import { addChartSpaceProperty } from "../../data/transforms/add-property";
+
+import { Trigger } from "../../interaction/trigger";
+
+import { registerDataSetInstanceTransform } from "../../data/register";
+
+import { OrdinalScale } from "@visactor/vscale";
+
+import { BaseSeriesTooltipHelper } from "./tooltip-helper";
+
+import { dimensionStatistics } from "../../data/transforms/dimension-statistics";
+
+import { invalidTravel } from "../../data/transforms/invalid-travel";
+
+import { getDataScheme } from "../../theme/color-scheme/util";
+
+import { SeriesData } from "./series-data";
+
+import { addDataKey, initKeyMap } from "../../data/transforms/data-key";
+
+import { array } from "@visactor/vutils";
+
+export class BaseSeries extends BaseModel {
+    getTrigger() {
+        return this._trigger;
+    }
+    getRegion() {
+        return this._region;
+    }
+    getRootMark() {
+        return this._rootMark;
+    }
+    getMarkMap() {
+        return this._markMap;
+    }
+    getRawData() {
+        return this._rawData;
+    }
+    getRawDataStatistics() {
+        return this._rawDataStatistics;
+    }
+    getViewDataFilter() {
+        return this._viewDataFilter;
+    }
+    getViewData() {
+        var _a;
+        return null === (_a = this._data) || void 0 === _a ? void 0 : _a.getDataView();
+    }
+    getViewDataProductId() {
+        var _a;
+        return null === (_a = this._data) || void 0 === _a ? void 0 : _a.getProductId();
+    }
+    getViewDataStatistics() {
+        return this._viewDataStatistics;
+    }
+    getViewStackData() {
+        return this._viewStackData;
+    }
+    getSeriesField() {
+        return this._seriesField;
+    }
+    setSeriesField(field) {
+        isValid(field) && (this._seriesField = field, this.getMarksInType([ MarkTypeEnum.line, MarkTypeEnum.area ]).forEach((m => {
+            m.setFacet(this._seriesField);
+        })));
+    }
+    getGroups() {
+        return this._groups;
+    }
+    getStack() {
+        return this._stack;
+    }
+    getPercent() {
+        return this._percent;
+    }
+    getStackOffsetSilhouette() {
+        return this._stackOffsetSilhouette;
+    }
+    get tooltipHelper() {
+        return this._tooltipHelper;
+    }
+    getInvalidType() {
+        return this._invalidType;
+    }
+    setInvalidType(t) {
+        var _a;
+        this._invalidType = t, null === (_a = this.getViewData()) || void 0 === _a || _a.reRunAllTransform();
+    }
+    constructor(spec, options) {
+        var _a;
+        super(spec, Object.assign({}, options)), this.type = "series", this.layoutType = "absolute", 
+        this.modelType = "series", this.name = void 0, this.coordinate = "none", this._region = null, 
+        this._rootMark = null, this._seriesMark = null, this._markMap = {}, this._viewDataMap = new Map, 
+        this._viewDataFilter = null, this._data = null, this._stack = !1, this._percent = !1, 
+        this._stackOffsetSilhouette = !1, this._region = options.region, this._dataSet = options.dataSet, 
+        (null === (_a = this._spec) || void 0 === _a ? void 0 : _a.name) && (this.name = this._spec.name);
+    }
+    created() {
+        super.created(), this._buildMarkAttributeContext(), this.initData(), this.initGroups(), 
+        this.initStatisticalData(), this.event.emit(ChartEvent.afterInitData, {
+            model: this
+        }), this.initTrigger(), this.initTooltip(), this.initRootMark(), this.initMark(), 
+        this._initExtensionMark(), this.initMarkStyle(), this.initMarkState(), !1 !== this._spec.animation && isValid(this._region.animate) && this.initAnimation(), 
+        this.afterInitMark(), this.initEvent(), this.event.emit(ChartEvent.afterInitEvent, {
+            model: this
+        });
+    }
+    _buildMarkAttributeContext() {
+        this._markAttributeContext = {
+            globalScale: (key, value) => {
+                var _a;
+                return null === (_a = this._option.globalScale.getScale(key)) || void 0 === _a ? void 0 : _a.scale(value);
+            },
+            seriesColor: seriesValue => {
+                var _a;
+                return isNil(seriesValue) && (seriesValue = this.getSeriesKeys()[0]), null === (_a = this._option.globalScale.getScale("color")) || void 0 === _a ? void 0 : _a.scale(seriesValue);
+            }
+        };
+    }
+    setAttrFromSpec() {
+        var _a;
+        super.setAttrFromSpec(), this.setSeriesField(this._spec.seriesField), isBoolean(this._spec.stack) && (this._stack = this._spec.stack), 
+        isBoolean(this._spec.percent) && (this._percent = this._spec.percent, this._stack = this._spec.stack || this._spec.percent), 
+        isBoolean(this._spec.stackOffsetSilhouette) && (this._stackOffsetSilhouette = this._spec.stackOffsetSilhouette, 
+        this._stack = this._spec.stack || this._spec.stackOffsetSilhouette), isValid(this._spec.invalidType) && (this._invalidType = this._spec.invalidType), 
+        null === (_a = this._tooltipHelper) || void 0 === _a || _a.updateTooltipSpec(this._spec.tooltip);
+    }
+    initData() {
+        var _a;
+        if (this._rawData = this._spec.data, this._addDataIndexAndKey(), this._rawData) {
+            this._viewDataFilter = dataViewFromDataView(this._rawData, this._dataSet, {
+                name: `${PREFIX}_series_${this.id}_viewDataFilter`
+            });
+            const viewData = dataViewFromDataView(this._viewDataFilter, this._dataSet, {
+                name: `${PREFIX}_series_${this.id}_viewData`
+            });
+            this._data = new SeriesData(this._option, viewData), this._viewDataFilter.target.removeListener("change", viewData.reRunAllTransform);
+        }
+        "link" !== this._invalidType && "zero" !== this._invalidType || (registerDataSetInstanceTransform(this._option.dataSet, "invalidTravel", invalidTravel), 
+        null === (_a = this.getViewData()) || void 0 === _a || _a.transform({
+            type: "invalidTravel",
+            options: {
+                config: () => ({
+                    invalidType: this._invalidType,
+                    checkField: this.getStackValueField()
+                })
+            }
+        }, !1));
+    }
+    initGroups() {
+        const groupFields = this.getGroupFields();
+        groupFields && groupFields.length && (this._groups = new Group(groupFields), this._data && this._groups.initData(this._data.getDataView(), this._dataSet));
+    }
+    initStatisticalData() {
+        this._rawData && this._statisticRawData(), this._data && this._statisticViewData();
+    }
+    _statisticRawData() {
+        const rawDataName = `${PREFIX}_series_${this.id}_rawDataStatic`;
+        this._rawDataStatistics = this.createStatisticalData(rawDataName, this._rawData, this._option.globalScale.getStatisticalFields), 
+        this._rawData.target.removeListener("change", this._rawDataStatistics.reRunAllTransform), 
+        this._rawDataStatistics.reRunAllTransform();
+    }
+    _statisticViewData() {
+        const viewDataName = `${PREFIX}_series_${this.id}_viewDataStatic`;
+        this._viewDataStatistics = this.createStatisticalData(viewDataName, this._data.getDataView()), 
+        this._data.getDataView().target.removeListener("change", this._viewDataStatistics.reRunAllTransform), 
+        (this._stack || this._stackValue) && this.createdStackData();
+    }
+    createStatisticalData(dataName, rawData, staticFields) {
+        registerDataSetInstanceTransform(this._dataSet, "dimensionStatistics", dimensionStatistics);
+        const data = new DataView(this._dataSet, {
+            name: dataName
+        });
+        return data.parse([ rawData ], {
+            type: "dataview"
+        }), data.transform({
+            type: "dimensionStatistics",
+            options: {
+                operations: [ "max", "min", "values" ],
+                fields: () => {
+                    var _a;
+                    const fields = mergeFields(this.getStatisticFields(), null !== (_a = null == staticFields ? void 0 : staticFields(rawData.name)) && void 0 !== _a ? _a : []);
+                    return this._seriesField && mergeFields(fields, [ {
+                        key: this._seriesField,
+                        operations: [ "values" ]
+                    } ]), fields;
+                },
+                target: "latest"
+            }
+        }, !1), data;
+    }
+    createdStackData() {
+        var _a, _b;
+        const dataName = null !== (_b = null === (_a = this._rawData) || void 0 === _a ? void 0 : _a.name) && void 0 !== _b ? _b : `${PREFIX}_series_${this.id}_viewStackData`;
+        this._viewStackData = new DataView(this._dataSet), this._viewStackData.parse([ this.getViewDataFilter() ], {
+            type: "dataview"
+        }), this._viewStackData.name = dataName, this._viewStackData.transform({
+            type: "stackSplit",
+            options: {
+                fields: this.getStackGroupFields()
+            }
+        }, !1);
+    }
+    generateDefaultDataKey(dataKey, datum, index, context) {
+        if (isNil(dataKey)) {
+            const {keyMap: keyMap} = context, seriesDataKey = this._getSeriesDataKey(datum);
+            return void 0 === keyMap.get(seriesDataKey) ? keyMap.set(seriesDataKey, 0) : keyMap.set(seriesDataKey, keyMap.get(seriesDataKey) + 1), 
+            `${seriesDataKey}_${keyMap.get(seriesDataKey)}`;
+        }
+        if (isString(dataKey)) return datum[dataKey];
+        if (isArray(dataKey) && dataKey.every((d => isString(d)))) return dataKey.map((k => datum[k])).join("-");
+        if (isFunction(dataKey)) return dataKey(datum, index);
+        throw new Error(`invalid dataKey: ${dataKey}`);
+    }
+    _addDataIndexAndKey() {
+        var _a;
+        (null === (_a = this._rawData) || void 0 === _a ? void 0 : _a.dataSet) && (registerDataSetInstanceTransform(this._rawData.dataSet, "addChartSpaceProperty", addChartSpaceProperty), 
+        this._rawData.transform({
+            type: "addChartSpaceProperty",
+            options: {
+                beforeCall: initKeyMap,
+                call: addDataKey.bind(this)
+            }
+        }, !1));
+    }
+    updateRawData(d) {
+        this._rawData && this._rawData.updateRawData(d);
+    }
+    rawDataUpdate(d) {
+        var _a;
+        this.event.emit(ChartEvent.rawDataUpdate, {
+            model: this
+        }), null === (_a = this._rawDataStatistics) || void 0 === _a || _a.reRunAllTransform();
+    }
+    rawDataStatisticsUpdate(d) {
+        this.event.emit(ChartEvent.rawDataStatisticsUpdate, {
+            model: this
+        });
+    }
+    viewDataFilterOver(d) {
+        this.event.emit(ChartEvent.viewDataFilterOver, {
+            model: this
+        });
+    }
+    viewDataUpdate(d) {
+        this.event.emit(ChartEvent.viewDataUpdate, {
+            model: this
+        }), this._data.updateData(), this._viewDataStatistics.reRunAllTransform();
+    }
+    viewDataStatisticsUpdate(d) {
+        this.event.emit(ChartEvent.viewDataStatisticsUpdate, {
+            model: this
+        });
+    }
+    getDatumPositionValues(datum, fields) {
+        return !datum || isNil(fields) ? [] : isString(fields) ? [ datum[fields] ] : fields.map((f => datum[f]));
+    }
+    initRootMark() {
+        var _a, _b;
+        this._rootMark = this._createMark(MarkTypeEnum.group, `seriesGroup_${this.type}_${this.id}`, {
+            parent: null === (_b = (_a = this._region).getGroupMark) || void 0 === _b ? void 0 : _b.call(_a),
+            dataView: !1,
+            support3d: this._spec.support3d
+        }), this._rootMark.setZIndex(this.layoutZIndex);
+    }
+    _initExtensionMark() {
+        var _a;
+        this._spec.extensionMark && (null === (_a = this._spec.extensionMark) || void 0 === _a || _a.forEach(((m, i) => {
+            this._createExtensionMark(m, null, `${PREFIX}_series_${this.id}_extensionMark`, i);
+        })));
+    }
+    _createExtensionMark(spec, parentMark, namePrefix, index) {
+        var _a;
+        const mark = this._createMark(spec.type, `${PREFIX}_${index}`, {
+            markSpec: spec,
+            parent: parentMark,
+            dataView: !1
+        });
+        if (mark) if ("group" === spec.type) namePrefix = `${namePrefix}_${index}`, null === (_a = spec.children) || void 0 === _a || _a.forEach(((s, i) => {
+            this._createExtensionMark(s, mark, namePrefix, i);
+        })); else if (!(parentMark || isNil(spec.dataId) && isNil(spec.dataIndex))) {
+            const dataView = this._option.getSeriesData(spec.id, spec.dataIndex);
+            dataView === this._rawData ? mark.setDataView(this.getViewData(), this.getViewDataProductId()) : mark.setDataView(dataView);
+        }
+    }
+    getStackData() {
+        var _a;
+        return null === (_a = this._viewStackData) || void 0 === _a ? void 0 : _a.latestData;
+    }
+    initTrigger() {
+        const triggerSpec = {
+            hover: this._spec.hover,
+            select: this._spec.select
+        }, triggerOptions = Object.assign(Object.assign({}, this._option), {
+            model: this,
+            interaction: this._region.interaction
+        });
+        this._trigger = new Trigger(triggerSpec, triggerOptions);
+    }
+    initAnimation() {}
+    initMarkState() {
+        this.initSeriesStyleState();
+    }
+    initSeriesStyleState() {
+        var _a;
+        const seriesStyle = this._spec.seriesStyle;
+        if (!seriesStyle || !seriesStyle.length) return;
+        const groupBy = null !== (_a = this._seriesField) && void 0 !== _a ? _a : DEFAULT_DATA_SERIES_FIELD;
+        this.getMarksWithoutRoot().forEach((mark => {
+            const filterMap = {}, attrMap = {}, markStyle = {};
+            seriesStyle.forEach((item => {
+                var _a;
+                const style = null === (_a = item[mark.name]) || void 0 === _a ? void 0 : _a.style;
+                style && (filterMap[item.name] = !0, markStyle[item.name] = markStyle[item.name] || {}, 
+                Object.keys(style).forEach((key => {
+                    attrMap[key] = !0, markStyle[item.name][key] = style[key];
+                })));
+            })), mark.state.addStateInfo({
+                stateValue: DEFAULT_SERIES_STYLE_NAME,
+                level: -1,
+                filter: datum => Array.isArray(datum) ? 0 !== datum.length && !0 === filterMap[datum[0][groupBy]] : !0 === filterMap[datum[groupBy]]
+            });
+            const style = {};
+            Object.keys(attrMap).forEach((key => {
+                style[key] = datum => {
+                    var _a, _b;
+                    let style;
+                    if (Array.isArray(datum)) {
+                        if (0 === datum.length) return;
+                        style = null === (_a = markStyle[datum[0][groupBy]]) || void 0 === _a ? void 0 : _a[key];
+                    }
+                    return style = null === (_b = markStyle[datum[groupBy]]) || void 0 === _b ? void 0 : _b[key], 
+                    style || mark.getAttribute(key, datum);
+                };
+            })), this.setMarkStyle(mark, style, DEFAULT_SERIES_STYLE_NAME);
+        }));
+    }
+    afterInitMark() {
+        var _a;
+        this.event.emit(ChartEvent.afterInitMark, {
+            model: this
+        }), null === (_a = this._rawDataStatistics) || void 0 === _a || _a.reRunAllTransform(), 
+        this.setSeriesField(this._spec.seriesField);
+    }
+    getMarks() {
+        return Object.values(this._markMap);
+    }
+    getMarksWithoutRoot() {
+        return Object.values(this._markMap).filter((m => !m.name.includes("seriesGroup")));
+    }
+    getMarksInType(type) {
+        const typeList = array(type);
+        return this.getMarks().filter((m => typeList.includes(m.type)));
+    }
+    getMarkInName(name) {
+        return this.getMarks().find((m => m.name === name));
+    }
+    getMarkInId(markId) {
+        return this.getMarks().find((m => m.id === markId));
+    }
+    initEvent() {
+        var _a, _b, _c, _d, _e;
+        this._trigger.init(), null === (_a = this._rawData) || void 0 === _a || _a.target.addListener("change", this.rawDataUpdate.bind(this)), 
+        null === (_c = null === (_b = this._data) || void 0 === _b ? void 0 : _b.getDataView()) || void 0 === _c || _c.target.addListener("change", this.viewDataUpdate.bind(this)), 
+        null === (_d = this._viewDataStatistics) || void 0 === _d || _d.target.addListener("change", this.viewDataStatisticsUpdate.bind(this)), 
+        null === (_e = this._rawDataStatistics) || void 0 === _e || _e.target.addListener("change", this.rawDataStatisticsUpdate.bind(this));
+    }
+    releaseEvent() {
+        super.releaseEvent(), this._trigger.release();
+    }
+    initTooltip() {
+        this._tooltipHelper = new BaseSeriesTooltipHelper(this);
+    }
+    updateSpec(spec) {
+        const result = super.updateSpec(spec);
+        spec.type !== this.type && (result.reMake = !0);
+        const {invalidType: invalidType} = this._originalSpec;
+        return spec.invalidType !== invalidType && (result.change = !0, result.reRender = !0), 
+        result;
+    }
+    reInit() {
+        super.reInit(), this.initMarkStyle(), this.getMarksWithoutRoot().forEach((mark => {
+            this.initMarkStyleWithSpec(mark, this._spec[mark.name]);
+        }));
+    }
+    onEvaluateEnd(ctx) {
+        this._data.updateData();
+    }
+    onRender(ctx) {}
+    release() {
+        var _a;
+        super.release(), this._markMap = {}, this._viewDataMap.clear(), null === (_a = this._data) || void 0 === _a || _a.release(), 
+        this._dataSet = this._data = this._rawData = this._rawDataStatistics = this._spec = this._region = this._viewDataStatistics = this._viewStackData = null;
+    }
+    onLayoutEnd(ctx) {
+        const region = this.getRegion();
+        this.setLayoutRect(region.getLayoutRect()), this.setLayoutStartPosition(region.getLayoutStartPoint()), 
+        super.onLayoutEnd(ctx);
+    }
+    getSeriesKeys() {
+        var _a, _b, _c;
+        return this._seriesField ? null !== (_c = null === (_b = null === (_a = this._rawDataStatistics) || void 0 === _a ? void 0 : _a.latestData[this._seriesField]) || void 0 === _b ? void 0 : _b.values) && void 0 !== _c ? _c : [] : this.name ? [ this.name ] : this.userId ? [ `${this.userId}` ] : [ `${this.type}_${this.id}` ];
+    }
+    getSeriesStyle(datum) {
+        return attribute => {
+            var _a, _b;
+            return null !== (_b = null === (_a = this._seriesMark) || void 0 === _a ? void 0 : _a.getAttribute(attribute, datum)) && void 0 !== _b ? _b : null;
+        };
+    }
+    getSeriesInfoList() {
+        const seriesKeys = this.getSeriesKeys(), defaultShapeType = this.getDefaultShapeType();
+        return seriesKeys.map((key => {
+            var _a;
+            return {
+                key: key,
+                style: this.getSeriesStyle({
+                    [null !== (_a = this._seriesField) && void 0 !== _a ? _a : DEFAULT_DATA_SERIES_FIELD]: key
+                }),
+                shapeType: defaultShapeType
+            };
+        }));
+    }
+    getDefaultColorScale() {
+        var _a, _b, _c, _d;
+        return null === (_d = (_c = (new OrdinalScale).domain(this._seriesField ? null === (_b = null === (_a = this._viewDataStatistics) || void 0 === _a ? void 0 : _a.latestData[this._seriesField]) || void 0 === _b ? void 0 : _b.values : [])).range) || void 0 === _d ? void 0 : _d.call(_c, getDataScheme(this._option.getTheme().colorScheme, this.type));
+    }
+    getColorAttribute() {
+        var _a, _b;
+        return {
+            scale: null !== (_a = this._option.globalScale.getScale("color")) && void 0 !== _a ? _a : this.getDefaultColorScale(),
+            field: null !== (_b = this._seriesField) && void 0 !== _b ? _b : DEFAULT_DATA_SERIES_FIELD
+        };
+    }
+    getDimensionField() {
+        return [];
+    }
+    getMeasureField() {
+        return [];
+    }
+    onMarkPositionUpdate() {
+        this.onMarkTreePositionUpdate(this.getMarksWithoutRoot());
+    }
+    onMarkTreePositionUpdate(marks) {}
+    setCurrentTheme(theme, noRender) {
+        return __awaiter(this, void 0, void 0, (function*() {
+            const modifyConfig = () => (this._initTheme(theme), this.reInit(), {
+                change: !0,
+                reMake: !1
+            });
+            noRender ? modifyConfig() : yield this._option.globalInstance.updateCustomConfigAndRerender(modifyConfig);
+        }));
+    }
+    _initTheme(theme) {
+        var _a;
+        const globalTheme = this._option.getTheme();
+        theme ? super._initTheme(theme) : super._initTheme(null !== (_a = globalTheme.series[this.type]) && void 0 !== _a ? _a : {});
+        const chartSpec = this.getChart().getSpec();
+        this._spec = merge({}, this._theme, this._getDefaultSpecFromChart(chartSpec), this._originalSpec);
+    }
+    _getDefaultSpecFromChart(chartSpec) {
+        return {};
+    }
+    _createMark(type, name, option = {}) {
+        var _a, _b, _c, _d, _e;
+        const {key: key, groupKey: groupKey, skipBeforeLayouted: skipBeforeLayouted, themeSpec: themeSpec = {}, markSpec: markSpec, dataView: dataView, dataProductId: dataProductId, parent: parent, isSeriesMark: isSeriesMark, dataStatistics: dataStatistics, depend: depend, label: label, progressive: progressive, support3d: support3d} = option, m = super._createMark(type, name, {
+            key: null != key ? key : this._getDataIdKey(),
+            support3d: support3d,
+            dataStatistics: null != dataStatistics ? dataStatistics : this._rawDataStatistics,
+            attributeContext: this._markAttributeContext
+        });
+        if (isValid(m)) {
+            this._markMap[name] = m, isSeriesMark && (this._seriesMark = m), isNil(parent) ? null === (_a = this._rootMark) || void 0 === _a || _a.addMark(m) : !1 !== parent && parent.addMark(m), 
+            isNil(dataView) ? (m.setDataView(this.getViewData(), this.getViewDataProductId()), 
+            m.setSkipBeforeLayouted(!0)) : !1 !== dataView && m.setDataView(dataView, dataProductId), 
+            isBoolean(skipBeforeLayouted) && m.setSkipBeforeLayouted(skipBeforeLayouted), isValid(depend) && m.setDepend(...array(depend)), 
+            isValid(label) && m.setLabelSpec(label);
+            const spec = this.getSpec() || {};
+            [ MarkTypeEnum.area, MarkTypeEnum.line, MarkTypeEnum.group ].includes(m.type) ? m.setMorph(!1) : (m.setMorph(!1 !== (null === (_b = spec.morph) || void 0 === _b ? void 0 : _b.enable)), 
+            m.setMorphKey((null === (_c = spec.morph) || void 0 === _c ? void 0 : _c.morphKey) || `${this._specIndex}`), 
+            m.setMorphElementKey(null !== (_e = null === (_d = spec.morph) || void 0 === _d ? void 0 : _d.morphElementKey) && void 0 !== _e ? _e : option.defaultMorphElementKey)), 
+            isNil(progressive) || m.setProgressiveConfig(progressive), isNil(groupKey) || m.setGroupKey(groupKey), 
+            this.initMarkStyleWithSpec(m, merge({}, themeSpec, markSpec || spec[m.name]));
+        }
+        return m;
+    }
+    _getDataIdKey() {
+        var _a;
+        return null !== (_a = super._getDataIdKey()) && void 0 !== _a ? _a : DEFAULT_DATA_KEY;
+    }
+    _getSeriesDataKey(datum) {
+        let key = "";
+        if (!datum) return key;
+        return key = this.getDimensionField().map((field => datum[field])).join("_"), this.getSeriesField() && (key += `_${datum[this.getSeriesField()]}`), 
+        key;
+    }
+    addViewDataFilter(option) {
+        this._viewDataFilter.transform(option, !1);
+    }
+    reFilterViewData() {
+        var _a;
+        null === (_a = this._viewDataFilter) || void 0 === _a || _a.reRunAllTransform();
+    }
+    reTransformViewData() {
+        var _a, _b;
+        null === (_b = null === (_a = this._data) || void 0 === _a ? void 0 : _a.getDataView()) || void 0 === _b || _b.reRunAllTransform();
+    }
+    fillData() {
+        var _a;
+        null === (_a = this.getRawData()) || void 0 === _a || _a.reRunAllTransform();
+    }
+    compile() {
+        this.compileSignal(), this.compileData();
+    }
+    getDefaultShapeType() {
+        return "circle";
+    }
+    getFieldAlias(field) {
+        var _a;
+        return field !== STACK_FIELD_END && field !== STACK_FIELD_END_PERCENT && field !== STACK_FIELD_START && field !== STACK_FIELD_START_PERCENT || (field = this.getStackValueField()), 
+        null !== (_a = getFieldAlias(this.getRawData(), field)) && void 0 !== _a ? _a : field;
+    }
+}
+//# sourceMappingURL=base-series.js.map