You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
354 lines
13 KiB
354 lines
13 KiB
|
|
/*
|
|
* 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.
|
|
*/
|
|
|
|
|
|
/**
|
|
* AUTO-GENERATED FILE. DO NOT MODIFY.
|
|
*/
|
|
|
|
/*
|
|
* 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 { makeInner, getDataItemValue, queryReferringComponents, SINGLE_REFERRING } from '../../util/model.js';
|
|
import { createHashMap, each, isArray, isString, isObject, isTypedArray } from 'zrender/lib/core/util.js';
|
|
import { SOURCE_FORMAT_ORIGINAL, SOURCE_FORMAT_ARRAY_ROWS, SOURCE_FORMAT_OBJECT_ROWS, SERIES_LAYOUT_BY_ROW, SOURCE_FORMAT_KEYED_COLUMNS } from '../../util/types.js';
|
|
// The result of `guessOrdinal`.
|
|
export var BE_ORDINAL = {
|
|
Must: 1,
|
|
Might: 2,
|
|
Not: 3 // Other cases
|
|
};
|
|
|
|
var innerGlobalModel = makeInner();
|
|
/**
|
|
* MUST be called before mergeOption of all series.
|
|
*/
|
|
export function resetSourceDefaulter(ecModel) {
|
|
// `datasetMap` is used to make default encode.
|
|
innerGlobalModel(ecModel).datasetMap = createHashMap();
|
|
}
|
|
/**
|
|
* [The strategy of the arrengment of data dimensions for dataset]:
|
|
* "value way": all axes are non-category axes. So series one by one take
|
|
* several (the number is coordSysDims.length) dimensions from dataset.
|
|
* The result of data arrengment of data dimensions like:
|
|
* | ser0_x | ser0_y | ser1_x | ser1_y | ser2_x | ser2_y |
|
|
* "category way": at least one axis is category axis. So the the first data
|
|
* dimension is always mapped to the first category axis and shared by
|
|
* all of the series. The other data dimensions are taken by series like
|
|
* "value way" does.
|
|
* The result of data arrengment of data dimensions like:
|
|
* | ser_shared_x | ser0_y | ser1_y | ser2_y |
|
|
*
|
|
* @return encode Never be `null/undefined`.
|
|
*/
|
|
export function makeSeriesEncodeForAxisCoordSys(coordDimensions, seriesModel, source) {
|
|
var encode = {};
|
|
var datasetModel = querySeriesUpstreamDatasetModel(seriesModel);
|
|
// Currently only make default when using dataset, util more reqirements occur.
|
|
if (!datasetModel || !coordDimensions) {
|
|
return encode;
|
|
}
|
|
var encodeItemName = [];
|
|
var encodeSeriesName = [];
|
|
var ecModel = seriesModel.ecModel;
|
|
var datasetMap = innerGlobalModel(ecModel).datasetMap;
|
|
var key = datasetModel.uid + '_' + source.seriesLayoutBy;
|
|
var baseCategoryDimIndex;
|
|
var categoryWayValueDimStart;
|
|
coordDimensions = coordDimensions.slice();
|
|
each(coordDimensions, function (coordDimInfoLoose, coordDimIdx) {
|
|
var coordDimInfo = isObject(coordDimInfoLoose) ? coordDimInfoLoose : coordDimensions[coordDimIdx] = {
|
|
name: coordDimInfoLoose
|
|
};
|
|
if (coordDimInfo.type === 'ordinal' && baseCategoryDimIndex == null) {
|
|
baseCategoryDimIndex = coordDimIdx;
|
|
categoryWayValueDimStart = getDataDimCountOnCoordDim(coordDimInfo);
|
|
}
|
|
encode[coordDimInfo.name] = [];
|
|
});
|
|
var datasetRecord = datasetMap.get(key) || datasetMap.set(key, {
|
|
categoryWayDim: categoryWayValueDimStart,
|
|
valueWayDim: 0
|
|
});
|
|
// TODO
|
|
// Auto detect first time axis and do arrangement.
|
|
each(coordDimensions, function (coordDimInfo, coordDimIdx) {
|
|
var coordDimName = coordDimInfo.name;
|
|
var count = getDataDimCountOnCoordDim(coordDimInfo);
|
|
// In value way.
|
|
if (baseCategoryDimIndex == null) {
|
|
var start = datasetRecord.valueWayDim;
|
|
pushDim(encode[coordDimName], start, count);
|
|
pushDim(encodeSeriesName, start, count);
|
|
datasetRecord.valueWayDim += count;
|
|
// ??? TODO give a better default series name rule?
|
|
// especially when encode x y specified.
|
|
// consider: when multiple series share one dimension
|
|
// category axis, series name should better use
|
|
// the other dimension name. On the other hand, use
|
|
// both dimensions name.
|
|
}
|
|
// In category way, the first category axis.
|
|
else if (baseCategoryDimIndex === coordDimIdx) {
|
|
pushDim(encode[coordDimName], 0, count);
|
|
pushDim(encodeItemName, 0, count);
|
|
}
|
|
// In category way, the other axis.
|
|
else {
|
|
var start = datasetRecord.categoryWayDim;
|
|
pushDim(encode[coordDimName], start, count);
|
|
pushDim(encodeSeriesName, start, count);
|
|
datasetRecord.categoryWayDim += count;
|
|
}
|
|
});
|
|
function pushDim(dimIdxArr, idxFrom, idxCount) {
|
|
for (var i = 0; i < idxCount; i++) {
|
|
dimIdxArr.push(idxFrom + i);
|
|
}
|
|
}
|
|
function getDataDimCountOnCoordDim(coordDimInfo) {
|
|
var dimsDef = coordDimInfo.dimsDef;
|
|
return dimsDef ? dimsDef.length : 1;
|
|
}
|
|
encodeItemName.length && (encode.itemName = encodeItemName);
|
|
encodeSeriesName.length && (encode.seriesName = encodeSeriesName);
|
|
return encode;
|
|
}
|
|
/**
|
|
* Work for data like [{name: ..., value: ...}, ...].
|
|
*
|
|
* @return encode Never be `null/undefined`.
|
|
*/
|
|
export function makeSeriesEncodeForNameBased(seriesModel, source, dimCount) {
|
|
var encode = {};
|
|
var datasetModel = querySeriesUpstreamDatasetModel(seriesModel);
|
|
// Currently only make default when using dataset, util more reqirements occur.
|
|
if (!datasetModel) {
|
|
return encode;
|
|
}
|
|
var sourceFormat = source.sourceFormat;
|
|
var dimensionsDefine = source.dimensionsDefine;
|
|
var potentialNameDimIndex;
|
|
if (sourceFormat === SOURCE_FORMAT_OBJECT_ROWS || sourceFormat === SOURCE_FORMAT_KEYED_COLUMNS) {
|
|
each(dimensionsDefine, function (dim, idx) {
|
|
if ((isObject(dim) ? dim.name : dim) === 'name') {
|
|
potentialNameDimIndex = idx;
|
|
}
|
|
});
|
|
}
|
|
var idxResult = function () {
|
|
var idxRes0 = {};
|
|
var idxRes1 = {};
|
|
var guessRecords = [];
|
|
// 5 is an experience value.
|
|
for (var i = 0, len = Math.min(5, dimCount); i < len; i++) {
|
|
var guessResult = doGuessOrdinal(source.data, sourceFormat, source.seriesLayoutBy, dimensionsDefine, source.startIndex, i);
|
|
guessRecords.push(guessResult);
|
|
var isPureNumber = guessResult === BE_ORDINAL.Not;
|
|
// [Strategy of idxRes0]: find the first BE_ORDINAL.Not as the value dim,
|
|
// and then find a name dim with the priority:
|
|
// "BE_ORDINAL.Might|BE_ORDINAL.Must" > "other dim" > "the value dim itself".
|
|
if (isPureNumber && idxRes0.v == null && i !== potentialNameDimIndex) {
|
|
idxRes0.v = i;
|
|
}
|
|
if (idxRes0.n == null || idxRes0.n === idxRes0.v || !isPureNumber && guessRecords[idxRes0.n] === BE_ORDINAL.Not) {
|
|
idxRes0.n = i;
|
|
}
|
|
if (fulfilled(idxRes0) && guessRecords[idxRes0.n] !== BE_ORDINAL.Not) {
|
|
return idxRes0;
|
|
}
|
|
// [Strategy of idxRes1]: if idxRes0 not satisfied (that is, no BE_ORDINAL.Not),
|
|
// find the first BE_ORDINAL.Might as the value dim,
|
|
// and then find a name dim with the priority:
|
|
// "other dim" > "the value dim itself".
|
|
// That is for backward compat: number-like (e.g., `'3'`, `'55'`) can be
|
|
// treated as number.
|
|
if (!isPureNumber) {
|
|
if (guessResult === BE_ORDINAL.Might && idxRes1.v == null && i !== potentialNameDimIndex) {
|
|
idxRes1.v = i;
|
|
}
|
|
if (idxRes1.n == null || idxRes1.n === idxRes1.v) {
|
|
idxRes1.n = i;
|
|
}
|
|
}
|
|
}
|
|
function fulfilled(idxResult) {
|
|
return idxResult.v != null && idxResult.n != null;
|
|
}
|
|
return fulfilled(idxRes0) ? idxRes0 : fulfilled(idxRes1) ? idxRes1 : null;
|
|
}();
|
|
if (idxResult) {
|
|
encode.value = [idxResult.v];
|
|
// `potentialNameDimIndex` has highest priority.
|
|
var nameDimIndex = potentialNameDimIndex != null ? potentialNameDimIndex : idxResult.n;
|
|
// By default, label uses itemName in charts.
|
|
// So we don't set encodeLabel here.
|
|
encode.itemName = [nameDimIndex];
|
|
encode.seriesName = [nameDimIndex];
|
|
}
|
|
return encode;
|
|
}
|
|
/**
|
|
* @return If return null/undefined, indicate that should not use datasetModel.
|
|
*/
|
|
export function querySeriesUpstreamDatasetModel(seriesModel) {
|
|
// Caution: consider the scenario:
|
|
// A dataset is declared and a series is not expected to use the dataset,
|
|
// and at the beginning `setOption({series: { noData })` (just prepare other
|
|
// option but no data), then `setOption({series: {data: [...]}); In this case,
|
|
// the user should set an empty array to avoid that dataset is used by default.
|
|
var thisData = seriesModel.get('data', true);
|
|
if (!thisData) {
|
|
return queryReferringComponents(seriesModel.ecModel, 'dataset', {
|
|
index: seriesModel.get('datasetIndex', true),
|
|
id: seriesModel.get('datasetId', true)
|
|
}, SINGLE_REFERRING).models[0];
|
|
}
|
|
}
|
|
/**
|
|
* @return Always return an array event empty.
|
|
*/
|
|
export function queryDatasetUpstreamDatasetModels(datasetModel) {
|
|
// Only these attributes declared, we by default reference to `datasetIndex: 0`.
|
|
// Otherwise, no reference.
|
|
if (!datasetModel.get('transform', true) && !datasetModel.get('fromTransformResult', true)) {
|
|
return [];
|
|
}
|
|
return queryReferringComponents(datasetModel.ecModel, 'dataset', {
|
|
index: datasetModel.get('fromDatasetIndex', true),
|
|
id: datasetModel.get('fromDatasetId', true)
|
|
}, SINGLE_REFERRING).models;
|
|
}
|
|
/**
|
|
* The rule should not be complex, otherwise user might not
|
|
* be able to known where the data is wrong.
|
|
* The code is ugly, but how to make it neat?
|
|
*/
|
|
export function guessOrdinal(source, dimIndex) {
|
|
return doGuessOrdinal(source.data, source.sourceFormat, source.seriesLayoutBy, source.dimensionsDefine, source.startIndex, dimIndex);
|
|
}
|
|
// dimIndex may be overflow source data.
|
|
// return {BE_ORDINAL}
|
|
function doGuessOrdinal(data, sourceFormat, seriesLayoutBy, dimensionsDefine, startIndex, dimIndex) {
|
|
var result;
|
|
// Experience value.
|
|
var maxLoop = 5;
|
|
if (isTypedArray(data)) {
|
|
return BE_ORDINAL.Not;
|
|
}
|
|
// When sourceType is 'objectRows' or 'keyedColumns', dimensionsDefine
|
|
// always exists in source.
|
|
var dimName;
|
|
var dimType;
|
|
if (dimensionsDefine) {
|
|
var dimDefItem = dimensionsDefine[dimIndex];
|
|
if (isObject(dimDefItem)) {
|
|
dimName = dimDefItem.name;
|
|
dimType = dimDefItem.type;
|
|
} else if (isString(dimDefItem)) {
|
|
dimName = dimDefItem;
|
|
}
|
|
}
|
|
if (dimType != null) {
|
|
return dimType === 'ordinal' ? BE_ORDINAL.Must : BE_ORDINAL.Not;
|
|
}
|
|
if (sourceFormat === SOURCE_FORMAT_ARRAY_ROWS) {
|
|
var dataArrayRows = data;
|
|
if (seriesLayoutBy === SERIES_LAYOUT_BY_ROW) {
|
|
var sample = dataArrayRows[dimIndex];
|
|
for (var i = 0; i < (sample || []).length && i < maxLoop; i++) {
|
|
if ((result = detectValue(sample[startIndex + i])) != null) {
|
|
return result;
|
|
}
|
|
}
|
|
} else {
|
|
for (var i = 0; i < dataArrayRows.length && i < maxLoop; i++) {
|
|
var row = dataArrayRows[startIndex + i];
|
|
if (row && (result = detectValue(row[dimIndex])) != null) {
|
|
return result;
|
|
}
|
|
}
|
|
}
|
|
} else if (sourceFormat === SOURCE_FORMAT_OBJECT_ROWS) {
|
|
var dataObjectRows = data;
|
|
if (!dimName) {
|
|
return BE_ORDINAL.Not;
|
|
}
|
|
for (var i = 0; i < dataObjectRows.length && i < maxLoop; i++) {
|
|
var item = dataObjectRows[i];
|
|
if (item && (result = detectValue(item[dimName])) != null) {
|
|
return result;
|
|
}
|
|
}
|
|
} else if (sourceFormat === SOURCE_FORMAT_KEYED_COLUMNS) {
|
|
var dataKeyedColumns = data;
|
|
if (!dimName) {
|
|
return BE_ORDINAL.Not;
|
|
}
|
|
var sample = dataKeyedColumns[dimName];
|
|
if (!sample || isTypedArray(sample)) {
|
|
return BE_ORDINAL.Not;
|
|
}
|
|
for (var i = 0; i < sample.length && i < maxLoop; i++) {
|
|
if ((result = detectValue(sample[i])) != null) {
|
|
return result;
|
|
}
|
|
}
|
|
} else if (sourceFormat === SOURCE_FORMAT_ORIGINAL) {
|
|
var dataOriginal = data;
|
|
for (var i = 0; i < dataOriginal.length && i < maxLoop; i++) {
|
|
var item = dataOriginal[i];
|
|
var val = getDataItemValue(item);
|
|
if (!isArray(val)) {
|
|
return BE_ORDINAL.Not;
|
|
}
|
|
if ((result = detectValue(val[dimIndex])) != null) {
|
|
return result;
|
|
}
|
|
}
|
|
}
|
|
function detectValue(val) {
|
|
var beStr = isString(val);
|
|
// Consider usage convenience, '1', '2' will be treated as "number".
|
|
// `Number('')` (or any whitespace) is `0`.
|
|
if (val != null && Number.isFinite(Number(val)) && val !== '') {
|
|
return beStr ? BE_ORDINAL.Might : BE_ORDINAL.Not;
|
|
} else if (beStr && val !== '-') {
|
|
return BE_ORDINAL.Must;
|
|
}
|
|
}
|
|
return BE_ORDINAL.Not;
|
|
} |