| /* |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| */ |
| |
| import {each, isArray, isObject, isTypedArray, defaults} from 'zrender/src/core/util'; |
| import compatStyle from './helper/compatStyle'; |
| import {normalizeToArray} from '../util/model'; |
| import { Dictionary } from 'zrender/src/core/types'; |
| import { ECUnitOption } from '../util/types'; |
| import type { BarSeriesOption } from '../chart/bar/BarSeries'; |
| import type { PieSeriesOption } from '../chart/pie/PieSeries'; |
| import { deprecateLog, deprecateReplaceLog } from '../util/log'; |
| |
| function get(opt: Dictionary<any>, path: string): any { |
| const pathArr = path.split(','); |
| let obj = opt; |
| for (let i = 0; i < pathArr.length; i++) { |
| obj = obj && obj[pathArr[i]]; |
| if (obj == null) { |
| break; |
| } |
| } |
| return obj; |
| } |
| |
| function set(opt: Dictionary<any>, path: string, val: any, overwrite?: boolean) { |
| const pathArr = path.split(','); |
| let obj = opt; |
| let key; |
| let i = 0; |
| for (; i < pathArr.length - 1; i++) { |
| key = pathArr[i]; |
| if (obj[key] == null) { |
| obj[key] = {}; |
| } |
| obj = obj[key]; |
| } |
| if (overwrite || obj[pathArr[i]] == null) { |
| obj[pathArr[i]] = val; |
| } |
| } |
| |
| function compatLayoutProperties(option: Dictionary<any>) { |
| option && each(LAYOUT_PROPERTIES, function (prop) { |
| if (prop[0] in option && !(prop[1] in option)) { |
| option[prop[1]] = option[prop[0]]; |
| } |
| }); |
| } |
| |
| const LAYOUT_PROPERTIES = [ |
| ['x', 'left'], ['y', 'top'], ['x2', 'right'], ['y2', 'bottom'] |
| ]; |
| |
| const COMPATITABLE_COMPONENTS = [ |
| 'grid', 'geo', 'parallel', 'legend', 'toolbox', 'title', 'visualMap', 'dataZoom', 'timeline' |
| ]; |
| |
| const BAR_ITEM_STYLE_MAP = [ |
| ['borderRadius', 'barBorderRadius'], |
| ['borderColor', 'barBorderColor'], |
| ['borderWidth', 'barBorderWidth'] |
| ]; |
| |
| function compatBarItemStyle(option: Dictionary<any>) { |
| const itemStyle = option && option.itemStyle; |
| if (itemStyle) { |
| for (let i = 0; i < BAR_ITEM_STYLE_MAP.length; i++) { |
| const oldName = BAR_ITEM_STYLE_MAP[i][1]; |
| const newName = BAR_ITEM_STYLE_MAP[i][0]; |
| if (itemStyle[oldName] != null) { |
| itemStyle[newName] = itemStyle[oldName]; |
| if (__DEV__) { |
| deprecateReplaceLog(oldName, newName); |
| } |
| } |
| } |
| } |
| } |
| |
| function compatPieLabel(option: Dictionary<any>) { |
| if (!option) { |
| return; |
| } |
| if (option.alignTo === 'edge' && option.margin != null && option.edgeDistance == null) { |
| if (__DEV__) { |
| deprecateReplaceLog('label.margin', 'label.edgeDistance', 'pie'); |
| } |
| option.edgeDistance = option.margin; |
| } |
| } |
| |
| function compatSunburstState(option: Dictionary<any>) { |
| if (!option) { |
| return; |
| } |
| if (option.downplay && !option.blur) { |
| option.blur = option.downplay; |
| if (__DEV__) { |
| deprecateReplaceLog('downplay', 'blur', 'sunburst'); |
| } |
| } |
| } |
| |
| function compatGraphFocus(option: Dictionary<any>) { |
| if (!option) { |
| return; |
| } |
| if (option.focusNodeAdjacency != null) { |
| option.emphasis = option.emphasis || {}; |
| if (option.emphasis.focus == null) { |
| if (__DEV__) { |
| deprecateReplaceLog('focusNodeAdjacency', 'emphasis: { focus: \'adjacency\'}', 'graph/sankey'); |
| } |
| option.emphasis.focus = 'adjacency'; |
| } |
| } |
| } |
| |
| function traverseTree(data: any[], cb: Function) { |
| if (data) { |
| for (let i = 0; i < data.length; i++) { |
| cb(data[i]); |
| data[i] && traverseTree(data[i].children, cb); |
| } |
| } |
| } |
| |
| export default function globalBackwardCompat(option: ECUnitOption, isTheme?: boolean) { |
| compatStyle(option, isTheme); |
| |
| // Make sure series array for model initialization. |
| option.series = normalizeToArray(option.series); |
| |
| each(option.series, function (seriesOpt: any) { |
| if (!isObject(seriesOpt)) { |
| return; |
| } |
| |
| const seriesType = seriesOpt.type; |
| |
| if (seriesType === 'line') { |
| if (seriesOpt.clipOverflow != null) { |
| seriesOpt.clip = seriesOpt.clipOverflow; |
| if (__DEV__) { |
| deprecateReplaceLog('clipOverflow', 'clip', 'line'); |
| } |
| } |
| } |
| else if (seriesType === 'pie' || seriesType === 'gauge') { |
| if (seriesOpt.clockWise != null) { |
| seriesOpt.clockwise = seriesOpt.clockWise; |
| if (__DEV__) { |
| deprecateReplaceLog('clockWise', 'clockwise'); |
| } |
| } |
| compatPieLabel((seriesOpt as PieSeriesOption).label); |
| const data = seriesOpt.data; |
| if (data && !isTypedArray(data)) { |
| for (let i = 0; i < data.length; i++) { |
| compatPieLabel(data[i]); |
| } |
| } |
| |
| if (seriesOpt.hoverOffset != null) { |
| seriesOpt.emphasis = seriesOpt.emphasis || {}; |
| if (seriesOpt.emphasis.scaleSize = null) { |
| if (__DEV__) { |
| deprecateReplaceLog('hoverOffset', 'emphasis.scaleSize'); |
| } |
| seriesOpt.emphasis.scaleSize = seriesOpt.hoverOffset; |
| } |
| } |
| } |
| else if (seriesType === 'gauge') { |
| const pointerColor = get(seriesOpt, 'pointer.color'); |
| pointerColor != null |
| && set(seriesOpt, 'itemStyle.color', pointerColor); |
| } |
| else if (seriesType === 'bar') { |
| compatBarItemStyle(seriesOpt); |
| compatBarItemStyle((seriesOpt as BarSeriesOption).backgroundStyle); |
| compatBarItemStyle(seriesOpt.emphasis); |
| const data = seriesOpt.data; |
| if (data && !isTypedArray(data)) { |
| for (let i = 0; i < data.length; i++) { |
| if (typeof data[i] === 'object') { |
| compatBarItemStyle(data[i]); |
| compatBarItemStyle(data[i] && data[i].emphasis); |
| } |
| } |
| } |
| } |
| else if (seriesType === 'sunburst') { |
| const highlightPolicy = seriesOpt.highlightPolicy; |
| if (highlightPolicy) { |
| seriesOpt.emphasis = seriesOpt.emphasis || {}; |
| if (!seriesOpt.emphasis.focus) { |
| seriesOpt.emphasis.focus = highlightPolicy; |
| if (__DEV__) { |
| deprecateReplaceLog('highlightPolicy', 'emphasis.focus', 'sunburst'); |
| } |
| } |
| } |
| |
| compatSunburstState(seriesOpt); |
| |
| traverseTree(seriesOpt.data, compatSunburstState); |
| } |
| else if (seriesType === 'graph' || seriesType === 'sankey') { |
| compatGraphFocus(seriesOpt); |
| // TODO nodes, edges? |
| } |
| else if (seriesType === 'map') { |
| if (seriesOpt.mapType && !seriesOpt.map) { |
| if (__DEV__) { |
| deprecateReplaceLog('mapType', 'map', 'map'); |
| } |
| seriesOpt.map = seriesOpt.mapType; |
| } |
| if (seriesOpt.mapLocation) { |
| if (__DEV__) { |
| deprecateLog('`mapLocation` is not used anymore.'); |
| } |
| defaults(seriesOpt, seriesOpt.mapLocation); |
| } |
| } |
| |
| if (seriesOpt.hoverAnimation != null) { |
| seriesOpt.emphasis = seriesOpt.emphasis || {}; |
| if (seriesOpt.emphasis && seriesOpt.emphasis.scale == null) { |
| if (__DEV__) { |
| deprecateReplaceLog('hoverAnimation', 'emphasis.scale'); |
| } |
| seriesOpt.emphasis.scale = seriesOpt.hoverAnimation; |
| } |
| } |
| |
| compatLayoutProperties(seriesOpt); |
| }); |
| |
| // dataRange has changed to visualMap |
| if (option.dataRange) { |
| option.visualMap = option.dataRange; |
| } |
| |
| each(COMPATITABLE_COMPONENTS, function (componentName) { |
| let options = option[componentName]; |
| if (options) { |
| if (!isArray(options)) { |
| options = [options]; |
| } |
| each(options, function (option) { |
| compatLayoutProperties(option); |
| }); |
| } |
| }); |
| } |