;
var markupFragment;
if (isObject(result)) {
if (result.type) {
markupFragment = result;
} else {
if ("development" !== "production") {
console.warn(
"The return type of `formatTooltip` is not supported: " +
makePrintable(result),
);
}
} // else {
// markupText = (result as TooltipFormatResultLegacyObject).html;
// markers = (result as TooltipFormatResultLegacyObject).markers;
// if (markersExisting) {
// markers = zrUtil.merge(markersExisting, markers);
// }
// }
} else {
markupText = result;
}
return {
text: markupText,
// markers: markers || markersExisting,
frag: markupFragment,
};
}
/**
* @param {Object} define
* @return See the return of `createTask`.
*/
function createTask(define) {
return new Task(define);
}
var Task =
/** @class */
(function () {
function Task(define) {
define = define || {};
this._reset = define.reset;
this._plan = define.plan;
this._count = define.count;
this._onDirty = define.onDirty;
this._dirty = true;
}
/**
* @param step Specified step.
* @param skip Skip customer perform call.
* @param modBy Sampling window size.
* @param modDataCount Sampling count.
* @return whether unfinished.
*/
Task.prototype.perform = function (performArgs) {
var upTask = this._upstream;
var skip = performArgs && performArgs.skip; // TODO some refactor.
// Pull data. Must pull data each time, because context.data
// may be updated by Series.setData.
if (this._dirty && upTask) {
var context = this.context;
context.data = context.outputData = upTask.context.outputData;
}
if (this.__pipeline) {
this.__pipeline.currentTask = this;
}
var planResult;
if (this._plan && !skip) {
planResult = this._plan(this.context);
} // Support sharding by mod, which changes the render sequence and makes the rendered graphic
// elements uniformed distributed when progress, especially when moving or zooming.
var lastModBy = normalizeModBy(this._modBy);
var lastModDataCount = this._modDataCount || 0;
var modBy = normalizeModBy(performArgs && performArgs.modBy);
var modDataCount = (performArgs && performArgs.modDataCount) || 0;
if (lastModBy !== modBy || lastModDataCount !== modDataCount) {
planResult = "reset";
}
function normalizeModBy(val) {
!(val >= 1) && (val = 1); // jshint ignore:line
return val;
}
var forceFirstProgress;
if (this._dirty || planResult === "reset") {
this._dirty = false;
forceFirstProgress = this._doReset(skip);
}
this._modBy = modBy;
this._modDataCount = modDataCount;
var step = performArgs && performArgs.step;
if (upTask) {
if ("development" !== "production") {
assert(upTask._outputDueEnd != null);
}
this._dueEnd = upTask._outputDueEnd;
} // DataTask or overallTask
else {
if ("development" !== "production") {
assert(!this._progress || this._count);
}
this._dueEnd = this._count ? this._count(this.context) : Infinity;
} // Note: Stubs, that its host overall task let it has progress, has progress.
// If no progress, pass index from upstream to downstream each time plan called.
if (this._progress) {
var start = this._dueIndex;
var end = Math.min(
step != null ? this._dueIndex + step : Infinity,
this._dueEnd,
);
if (!skip && (forceFirstProgress || start < end)) {
var progress = this._progress;
if (isArray(progress)) {
for (var i = 0; i < progress.length; i++) {
this._doProgress(progress[i], start, end, modBy, modDataCount);
}
} else {
this._doProgress(progress, start, end, modBy, modDataCount);
}
}
this._dueIndex = end; // If no `outputDueEnd`, assume that output data and
// input data is the same, so use `dueIndex` as `outputDueEnd`.
var outputDueEnd =
this._settedOutputEnd != null ? this._settedOutputEnd : end;
if ("development" !== "production") {
// ??? Can not rollback.
assert(outputDueEnd >= this._outputDueEnd);
}
this._outputDueEnd = outputDueEnd;
} else {
// (1) Some overall task has no progress.
// (2) Stubs, that its host overall task do not let it has progress, has no progress.
// This should always be performed so it can be passed to downstream.
this._dueIndex = this._outputDueEnd =
this._settedOutputEnd != null
? this._settedOutputEnd
: this._dueEnd;
}
return this.unfinished();
};
Task.prototype.dirty = function () {
this._dirty = true;
this._onDirty && this._onDirty(this.context);
};
Task.prototype._doProgress = function (
progress,
start,
end,
modBy,
modDataCount,
) {
iterator.reset(start, end, modBy, modDataCount);
this._callingProgress = progress;
this._callingProgress(
{
start: start,
end: end,
count: end - start,
next: iterator.next,
},
this.context,
);
};
Task.prototype._doReset = function (skip) {
this._dueIndex = this._outputDueEnd = this._dueEnd = 0;
this._settedOutputEnd = null;
var progress;
var forceFirstProgress;
if (!skip && this._reset) {
progress = this._reset(this.context);
if (progress && progress.progress) {
forceFirstProgress = progress.forceFirstProgress;
progress = progress.progress;
} // To simplify no progress checking, array must has item.
if (isArray(progress) && !progress.length) {
progress = null;
}
}
this._progress = progress;
this._modBy = this._modDataCount = null;
var downstream = this._downstream;
downstream && downstream.dirty();
return forceFirstProgress;
};
Task.prototype.unfinished = function () {
return this._progress && this._dueIndex < this._dueEnd;
};
/**
* @param downTask The downstream task.
* @return The downstream task.
*/
Task.prototype.pipe = function (downTask) {
if ("development" !== "production") {
assert(downTask && !downTask._disposed && downTask !== this);
} // If already downstream, do not dirty downTask.
if (this._downstream !== downTask || this._dirty) {
this._downstream = downTask;
downTask._upstream = this;
downTask.dirty();
}
};
Task.prototype.dispose = function () {
if (this._disposed) {
return;
}
this._upstream && (this._upstream._downstream = null);
this._downstream && (this._downstream._upstream = null);
this._dirty = false;
this._disposed = true;
};
Task.prototype.getUpstream = function () {
return this._upstream;
};
Task.prototype.getDownstream = function () {
return this._downstream;
};
Task.prototype.setOutputEnd = function (end) {
// This only happend in dataTask, dataZoom, map, currently.
// where dataZoom do not set end each time, but only set
// when reset. So we should record the setted end, in case
// that the stub of dataZoom perform again and earse the
// setted end by upstream.
this._outputDueEnd = this._settedOutputEnd = end;
};
return Task;
})();
var iterator = (function () {
var end;
var current;
var modBy;
var modDataCount;
var winCount;
var it = {
reset: function (s, e, sStep, sCount) {
current = s;
end = e;
modBy = sStep;
modDataCount = sCount;
winCount = Math.ceil(modDataCount / modBy);
it.next = modBy > 1 && modDataCount > 0 ? modNext : sequentialNext;
},
};
return it;
function sequentialNext() {
return current < end ? current++ : null;
}
function modNext() {
var dataIndex =
(current % winCount) * modBy + Math.ceil(current / winCount);
var result =
current >= end
? null
: dataIndex < modDataCount
? dataIndex // If modDataCount is smaller than data.count() (consider `appendData` case),
: // Use normal linear rendering mode.
current;
current++;
return result;
}
})(); ///////////////////////////////////////////////////////////
// For stream debug (Should be commented out after used!)
// @usage: printTask(this, 'begin');
// @usage: printTask(this, null, {someExtraProp});
// @usage: Use `__idxInPipeline` as conditional breakpiont.
//
// window.printTask = function (task: any, prefix: string, extra: { [key: string]: unknown }): void {
// window.ecTaskUID == null && (window.ecTaskUID = 0);
// task.uidDebug == null && (task.uidDebug = `task_${window.ecTaskUID++}`);
// task.agent && task.agent.uidDebug == null && (task.agent.uidDebug = `task_${window.ecTaskUID++}`);
// let props = [];
// if (task.__pipeline) {
// let val = `${task.__idxInPipeline}/${task.__pipeline.tail.__idxInPipeline} ${task.agent ? '(stub)' : ''}`;
// props.push({text: '__idxInPipeline/total', value: val});
// } else {
// let stubCount = 0;
// task.agentStubMap.each(() => stubCount++);
// props.push({text: 'idx', value: `overall (stubs: ${stubCount})`});
// }
// props.push({text: 'uid', value: task.uidDebug});
// if (task.__pipeline) {
// props.push({text: 'pipelineId', value: task.__pipeline.id});
// task.agent && props.push(
// {text: 'stubFor', value: task.agent.uidDebug}
// );
// }
// props.push(
// {text: 'dirty', value: task._dirty},
// {text: 'dueIndex', value: task._dueIndex},
// {text: 'dueEnd', value: task._dueEnd},
// {text: 'outputDueEnd', value: task._outputDueEnd}
// );
// if (extra) {
// Object.keys(extra).forEach(key => {
// props.push({text: key, value: extra[key]});
// });
// }
// let args = ['color: blue'];
// let msg = `%c[${prefix || 'T'}] %c` + props.map(item => (
// args.push('color: green', 'color: red'),
// `${item.text}: %c${item.value}`
// )).join('%c, ');
// console.log.apply(console, [msg].concat(args));
// // console.log(this);
// };
// window.printPipeline = function (task: any, prefix: string) {
// const pipeline = task.__pipeline;
// let currTask = pipeline.head;
// while (currTask) {
// window.printTask(currTask, prefix);
// currTask = currTask._downstream;
// }
// };
// window.showChain = function (chainHeadTask) {
// var chain = [];
// var task = chainHeadTask;
// while (task) {
// chain.push({
// task: task,
// up: task._upstream,
// down: task._downstream,
// idxInPipeline: task.__idxInPipeline
// });
// task = task._downstream;
// }
// return chain;
// };
// window.findTaskInChain = function (task, chainHeadTask) {
// let chain = window.showChain(chainHeadTask);
// let result = [];
// for (let i = 0; i < chain.length; i++) {
// let chainItem = chain[i];
// if (chainItem.task === task) {
// result.push(i);
// }
// }
// return result;
// };
// window.printChainAEachInChainB = function (chainHeadTaskA, chainHeadTaskB) {
// let chainA = window.showChain(chainHeadTaskA);
// for (let i = 0; i < chainA.length; i++) {
// console.log('chainAIdx:', i, 'inChainB:', window.findTaskInChain(chainA[i].task, chainHeadTaskB));
// }
// };
/**
* Convert raw the value in to inner value in List.
*
* [Performance sensitive]
*
* [Caution]: this is the key logic of user value parser.
* For backward compatibiliy, do not modify it until have to!
*/
function parseDataValue(
value, // For high performance, do not omit the second param.
opt,
) {
// Performance sensitive.
var dimType = opt && opt.type;
if (dimType === "ordinal") {
// If given value is a category string
return value;
}
if (
dimType === "time" && // spead up when using timestamp
!isNumber(value) &&
value != null &&
value !== "-"
) {
value = +parseDate(value);
} // dimType defaults 'number'.
// If dimType is not ordinal and value is null or undefined or NaN or '-',
// parse to NaN.
// number-like string (like ' 123 ') can be converted to a number.
// where null/undefined or other string will be converted to NaN.
return value == null || value === ""
? NaN // If string (like '-'), using '+' parse to NaN
: // If object, also parse to NaN
+value;
}
var valueParserMap = createHashMap({
number: function (val) {
// Do not use `numericToNumber` here. We have by defualt `numericToNumber`.
// Here the number parser can have loose rule:
// enable to cut suffix: "120px" => 120, "14%" => 14.
return parseFloat(val);
},
time: function (val) {
// return timestamp.
return +parseDate(val);
},
trim: function (val) {
return isString(val) ? trim(val) : val;
},
});
function getRawValueParser(type) {
return valueParserMap.get(type);
}
var ORDER_COMPARISON_OP_MAP = {
lt: function (lval, rval) {
return lval < rval;
},
lte: function (lval, rval) {
return lval <= rval;
},
gt: function (lval, rval) {
return lval > rval;
},
gte: function (lval, rval) {
return lval >= rval;
},
};
var FilterOrderComparator =
/** @class */
(function () {
function FilterOrderComparator(op, rval) {
if (!isNumber(rval)) {
var errMsg = "";
if ("development" !== "production") {
errMsg =
'rvalue of "<", ">", "<=", ">=" can only be number in filter.';
}
throwError(errMsg);
}
this._opFn = ORDER_COMPARISON_OP_MAP[op];
this._rvalFloat = numericToNumber(rval);
} // Performance sensitive.
FilterOrderComparator.prototype.evaluate = function (lval) {
// Most cases is 'number', and typeof maybe 10 times faseter than parseFloat.
return isNumber(lval)
? this._opFn(lval, this._rvalFloat)
: this._opFn(numericToNumber(lval), this._rvalFloat);
};
return FilterOrderComparator;
})();
var SortOrderComparator =
/** @class */
(function () {
/**
* @param order by defualt: 'asc'
* @param incomparable by defualt: Always on the tail.
* That is, if 'asc' => 'max', if 'desc' => 'min'
* See the definition of "incomparable" in [SORT_COMPARISON_RULE]
*/
function SortOrderComparator(order, incomparable) {
var isDesc = order === "desc";
this._resultLT = isDesc ? 1 : -1;
if (incomparable == null) {
incomparable = isDesc ? "min" : "max";
}
this._incomparable = incomparable === "min" ? -Infinity : Infinity;
} // See [SORT_COMPARISON_RULE].
// Performance sensitive.
SortOrderComparator.prototype.evaluate = function (lval, rval) {
// Most cases is 'number', and typeof maybe 10 times faseter than parseFloat.
var lvalFloat = isNumber(lval) ? lval : numericToNumber(lval);
var rvalFloat = isNumber(rval) ? rval : numericToNumber(rval);
var lvalNotNumeric = isNaN(lvalFloat);
var rvalNotNumeric = isNaN(rvalFloat);
if (lvalNotNumeric) {
lvalFloat = this._incomparable;
}
if (rvalNotNumeric) {
rvalFloat = this._incomparable;
}
if (lvalNotNumeric && rvalNotNumeric) {
var lvalIsStr = isString(lval);
var rvalIsStr = isString(rval);
if (lvalIsStr) {
lvalFloat = rvalIsStr ? lval : 0;
}
if (rvalIsStr) {
rvalFloat = lvalIsStr ? rval : 0;
}
}
return lvalFloat < rvalFloat
? this._resultLT
: lvalFloat > rvalFloat
? -this._resultLT
: 0;
};
return SortOrderComparator;
})();
var FilterEqualityComparator =
/** @class */
(function () {
function FilterEqualityComparator(isEq, rval) {
this._rval = rval;
this._isEQ = isEq;
this._rvalTypeof = typeof rval;
this._rvalFloat = numericToNumber(rval);
} // Performance sensitive.
FilterEqualityComparator.prototype.evaluate = function (lval) {
var eqResult = lval === this._rval;
if (!eqResult) {
var lvalTypeof = typeof lval;
if (
lvalTypeof !== this._rvalTypeof &&
(lvalTypeof === "number" || this._rvalTypeof === "number")
) {
eqResult = numericToNumber(lval) === this._rvalFloat;
}
}
return this._isEQ ? eqResult : !eqResult;
};
return FilterEqualityComparator;
})();
/**
* [FILTER_COMPARISON_RULE]
* `lt`|`lte`|`gt`|`gte`:
* + rval must be a number. And lval will be converted to number (`numericToNumber`) to compare.
* `eq`:
* + If same type, compare with `===`.
* + If there is one number, convert to number (`numericToNumber`) to compare.
* + Else return `false`.
* `ne`:
* + Not `eq`.
*
*
* [SORT_COMPARISON_RULE]
* All the values are grouped into three categories:
* + "numeric" (number and numeric string)
* + "non-numeric-string" (string that excluding numeric string)
* + "others"
* "numeric" vs "numeric": values are ordered by number order.
* "non-numeric-string" vs "non-numeric-string": values are ordered by ES spec (#sec-abstract-relational-comparison).
* "others" vs "others": do not change order (always return 0).
* "numeric" vs "non-numeric-string": "non-numeric-string" is treated as "incomparable".
* "number" vs "others": "others" is treated as "incomparable".
* "non-numeric-string" vs "others": "others" is treated as "incomparable".
* "incomparable" will be seen as -Infinity or Infinity (depends on the settings).
* MEMO:
* non-numeric string sort make sence when need to put the items with the same tag together.
* But if we support string sort, we still need to avoid the misleading like `'2' > '12'`,
* So we treat "numeric-string" sorted by number order rather than string comparison.
*
*
* [CHECK_LIST_OF_THE_RULE_DESIGN]
* + Do not support string comparison until required. And also need to
* void the misleading of "2" > "12".
* + Should avoid the misleading case:
* `" 22 " gte "22"` is `true` but `" 22 " eq "22"` is `false`.
* + JS bad case should be avoided: null <= 0, [] <= 0, ' ' <= 0, ...
* + Only "numeric" can be converted to comparable number, otherwise converted to NaN.
* See `util/number.ts#numericToNumber`.
*
* @return If `op` is not `RelationalOperator`, return null;
*/
function createFilterComparator(op, rval) {
return op === "eq" || op === "ne"
? new FilterEqualityComparator(op === "eq", rval)
: hasOwn(ORDER_COMPARISON_OP_MAP, op)
? new FilterOrderComparator(op, rval)
: null;
}
/**
* TODO: disable writable.
* This structure will be exposed to users.
*/
var ExternalSource =
/** @class */
(function () {
function ExternalSource() {}
ExternalSource.prototype.getRawData = function () {
// Only built-in transform available.
throw new Error("not supported");
};
ExternalSource.prototype.getRawDataItem = function (dataIndex) {
// Only built-in transform available.
throw new Error("not supported");
};
ExternalSource.prototype.cloneRawData = function () {
return;
};
/**
* @return If dimension not found, return null/undefined.
*/
ExternalSource.prototype.getDimensionInfo = function (dim) {
return;
};
/**
* dimensions defined if and only if either:
* (a) dataset.dimensions are declared.
* (b) dataset data include dimensions definitions in data (detected or via specified `sourceHeader`).
* If dimensions are defined, `dimensionInfoAll` is corresponding to
* the defined dimensions.
* Otherwise, `dimensionInfoAll` is determined by data columns.
* @return Always return an array (even empty array).
*/
ExternalSource.prototype.cloneAllDimensionInfo = function () {
return;
};
ExternalSource.prototype.count = function () {
return;
};
/**
* Only support by dimension index.
* No need to support by dimension name in transform function,
* becuase transform function is not case-specific, no need to use name literally.
*/
ExternalSource.prototype.retrieveValue = function (dataIndex, dimIndex) {
return;
};
ExternalSource.prototype.retrieveValueFromItem = function (
dataItem,
dimIndex,
) {
return;
};
ExternalSource.prototype.convertValue = function (rawVal, dimInfo) {
return parseDataValue(rawVal, dimInfo);
};
return ExternalSource;
})();
function createExternalSource(internalSource, externalTransform) {
var extSource = new ExternalSource();
var data = internalSource.data;
var sourceFormat = (extSource.sourceFormat = internalSource.sourceFormat);
var sourceHeaderCount = internalSource.startIndex;
var errMsg = "";
if (internalSource.seriesLayoutBy !== SERIES_LAYOUT_BY_COLUMN) {
// For the logic simplicity in transformer, only 'culumn' is
// supported in data transform. Otherwise, the `dimensionsDefine`
// might be detected by 'row', which probably confuses users.
if ("development" !== "production") {
errMsg =
'`seriesLayoutBy` of upstream dataset can only be "column" in data transform.';
}
throwError(errMsg);
} // [MEMO]
// Create a new dimensions structure for exposing.
// Do not expose all dimension info to users directly.
// Becuase the dimension is probably auto detected from data and not might reliable.
// Should not lead the transformers to think that is relialbe and return it.
// See [DIMENSION_INHERIT_RULE] in `sourceManager.ts`.
var dimensions = [];
var dimsByName = {};
var dimsDef = internalSource.dimensionsDefine;
if (dimsDef) {
each(dimsDef, function (dimDef, idx) {
var name = dimDef.name;
var dimDefExt = {
index: idx,
name: name,
displayName: dimDef.displayName,
};
dimensions.push(dimDefExt); // Users probably not sepcify dimension name. For simplicity, data transform
// do not generate dimension name.
if (name != null) {
// Dimension name should not be duplicated.
// For simplicity, data transform forbid name duplication, do not generate
// new name like module `completeDimensions.ts` did, but just tell users.
var errMsg_1 = "";
if (hasOwn(dimsByName, name)) {
if ("development" !== "production") {
errMsg_1 = 'dimension name "' + name + '" duplicated.';
}
throwError(errMsg_1);
}
dimsByName[name] = dimDefExt;
}
});
} // If dimension definitions are not defined and can not be detected.
// e.g., pure data `[[11, 22], ...]`.
else {
for (var i = 0; i < internalSource.dimensionsDetectedCount || 0; i++) {
// Do not generete name or anything others. The consequence process in
// `transform` or `series` probably have there own name generation strategry.
dimensions.push({
index: i,
});
}
} // Implement public methods:
var rawItemGetter = getRawSourceItemGetter(
sourceFormat,
SERIES_LAYOUT_BY_COLUMN,
);
if (externalTransform.__isBuiltIn) {
extSource.getRawDataItem = function (dataIndex) {
return rawItemGetter(data, sourceHeaderCount, dimensions, dataIndex);
};
extSource.getRawData = bind(getRawData, null, internalSource);
}
extSource.cloneRawData = bind(cloneRawData, null, internalSource);
var rawCounter = getRawSourceDataCounter(
sourceFormat,
SERIES_LAYOUT_BY_COLUMN,
);
extSource.count = bind(
rawCounter,
null,
data,
sourceHeaderCount,
dimensions,
);
var rawValueGetter = getRawSourceValueGetter(sourceFormat);
extSource.retrieveValue = function (dataIndex, dimIndex) {
var rawItem = rawItemGetter(
data,
sourceHeaderCount,
dimensions,
dataIndex,
);
return retrieveValueFromItem(rawItem, dimIndex);
};
var retrieveValueFromItem = (extSource.retrieveValueFromItem = function (
dataItem,
dimIndex,
) {
if (dataItem == null) {
return;
}
var dimDef = dimensions[dimIndex]; // When `dimIndex` is `null`, `rawValueGetter` return the whole item.
if (dimDef) {
return rawValueGetter(dataItem, dimIndex, dimDef.name);
}
});
extSource.getDimensionInfo = bind(
getDimensionInfo,
null,
dimensions,
dimsByName,
);
extSource.cloneAllDimensionInfo = bind(
cloneAllDimensionInfo,
null,
dimensions,
);
return extSource;
}
function getRawData(upstream) {
var sourceFormat = upstream.sourceFormat;
if (!isSupportedSourceFormat(sourceFormat)) {
var errMsg = "";
if ("development" !== "production") {
errMsg =
"`getRawData` is not supported in source format " + sourceFormat;
}
throwError(errMsg);
}
return upstream.data;
}
function cloneRawData(upstream) {
var sourceFormat = upstream.sourceFormat;
var data = upstream.data;
if (!isSupportedSourceFormat(sourceFormat)) {
var errMsg = "";
if ("development" !== "production") {
errMsg =
"`cloneRawData` is not supported in source format " + sourceFormat;
}
throwError(errMsg);
}
if (sourceFormat === SOURCE_FORMAT_ARRAY_ROWS) {
var result = [];
for (var i = 0, len = data.length; i < len; i++) {
// Not strictly clone for performance
result.push(data[i].slice());
}
return result;
} else if (sourceFormat === SOURCE_FORMAT_OBJECT_ROWS) {
var result = [];
for (var i = 0, len = data.length; i < len; i++) {
// Not strictly clone for performance
result.push(extend({}, data[i]));
}
return result;
}
}
function getDimensionInfo(dimensions, dimsByName, dim) {
if (dim == null) {
return;
} // Keep the same logic as `List::getDimension` did.
if (
isNumber(dim) || // If being a number-like string but not being defined a dimension name.
(!isNaN(dim) && !hasOwn(dimsByName, dim))
) {
return dimensions[dim];
} else if (hasOwn(dimsByName, dim)) {
return dimsByName[dim];
}
}
function cloneAllDimensionInfo(dimensions) {
return clone(dimensions);
}
var externalTransformMap = createHashMap();
function registerExternalTransform(externalTransform) {
externalTransform = clone(externalTransform);
var type = externalTransform.type;
var errMsg = "";
if (!type) {
if ("development" !== "production") {
errMsg = "Must have a `type` when `registerTransform`.";
}
throwError(errMsg);
}
var typeParsed = type.split(":");
if (typeParsed.length !== 2) {
if ("development" !== "production") {
errMsg = 'Name must include namespace like "ns:regression".';
}
throwError(errMsg);
} // Namespace 'echarts:xxx' is official namespace, where the transforms should
// be called directly via 'xxx' rather than 'echarts:xxx'.
var isBuiltIn = false;
if (typeParsed[0] === "echarts") {
type = typeParsed[1];
isBuiltIn = true;
}
externalTransform.__isBuiltIn = isBuiltIn;
externalTransformMap.set(type, externalTransform);
}
function applyDataTransform(rawTransOption, sourceList, infoForPrint) {
var pipedTransOption = normalizeToArray(rawTransOption);
var pipeLen = pipedTransOption.length;
var errMsg = "";
if (!pipeLen) {
if ("development" !== "production") {
errMsg =
"If `transform` declared, it should at least contain one transform.";
}
throwError(errMsg);
}
for (var i = 0, len = pipeLen; i < len; i++) {
var transOption = pipedTransOption[i];
sourceList = applySingleDataTransform(
transOption,
sourceList,
infoForPrint,
pipeLen === 1 ? null : i,
); // piped transform only support single input, except the fist one.
// piped transform only support single output, except the last one.
if (i !== len - 1) {
sourceList.length = Math.max(sourceList.length, 1);
}
}
return sourceList;
}
function applySingleDataTransform(
transOption,
upSourceList,
infoForPrint, // If `pipeIndex` is null/undefined, no piped transform.
pipeIndex,
) {
var errMsg = "";
if (!upSourceList.length) {
if ("development" !== "production") {
errMsg = "Must have at least one upstream dataset.";
}
throwError(errMsg);
}
if (!isObject(transOption)) {
if ("development" !== "production") {
errMsg =
"transform declaration must be an object rather than " +
typeof transOption +
".";
}
throwError(errMsg);
}
var transType = transOption.type;
var externalTransform = externalTransformMap.get(transType);
if (!externalTransform) {
if ("development" !== "production") {
errMsg = 'Can not find transform on type "' + transType + '".';
}
throwError(errMsg);
} // Prepare source
var extUpSourceList = map(upSourceList, function (upSource) {
return createExternalSource(upSource, externalTransform);
});
var resultList = normalizeToArray(
externalTransform.transform({
upstream: extUpSourceList[0],
upstreamList: extUpSourceList,
config: clone(transOption.config),
}),
);
if ("development" !== "production") {
if (transOption.print) {
var printStrArr = map(resultList, function (extSource) {
var pipeIndexStr =
pipeIndex != null ? " === pipe index: " + pipeIndex : "";
return [
"=== dataset index: " +
infoForPrint.datasetIndex +
pipeIndexStr +
" ===",
"- transform result data:",
makePrintable(extSource.data),
"- transform result dimensions:",
makePrintable(extSource.dimensions),
].join("\n");
}).join("\n");
log(printStrArr);
}
}
return map(resultList, function (result, resultIndex) {
var errMsg = "";
if (!isObject(result)) {
if ("development" !== "production") {
errMsg = "A transform should not return some empty results.";
}
throwError(errMsg);
}
if (!result.data) {
if ("development" !== "production") {
errMsg = "Transform result data should be not be null or undefined";
}
throwError(errMsg);
}
var sourceFormat = detectSourceFormat(result.data);
if (!isSupportedSourceFormat(sourceFormat)) {
if ("development" !== "production") {
errMsg = "Transform result data should be array rows or object rows.";
}
throwError(errMsg);
}
var resultMetaRawOption;
var firstUpSource = upSourceList[0];
/**
* Intuitively, the end users known the content of the original `dataset.source`,
* calucating the transform result in mind.
* Suppose the original `dataset.source` is:
* ```js
* [
* ['product', '2012', '2013', '2014', '2015'],
* ['AAA', 41.1, 30.4, 65.1, 53.3],
* ['BBB', 86.5, 92.1, 85.7, 83.1],
* ['CCC', 24.1, 67.2, 79.5, 86.4]
* ]
* ```
* The dimension info have to be detected from the source data.
* Some of the transformers (like filter, sort) will follow the dimension info
* of upstream, while others use new dimensions (like aggregate).
* Transformer can output a field `dimensions` to define the its own output dimensions.
* We also allow transformers to ignore the output `dimensions` field, and
* inherit the upstream dimensions definition. It can reduce the burden of handling
* dimensions in transformers.
*
* See also [DIMENSION_INHERIT_RULE] in `sourceManager.ts`.
*/
if (
firstUpSource &&
resultIndex === 0 && // If transformer returns `dimensions`, it means that the transformer has different
// dimensions definitions. We do not inherit anything from upstream.
!result.dimensions
) {
var startIndex = firstUpSource.startIndex; // We copy the header of upstream to the result becuase:
// (1) The returned data always does not contain header line and can not be used
// as dimension-detection. In this case we can not use "detected dimensions" of
// upstream directly, because it might be detected based on different `seriesLayoutBy`.
// (2) We should support that the series read the upstream source in `seriesLayoutBy: 'row'`.
// So the original detected header should be add to the result, otherwise they can not be read.
if (startIndex) {
result.data = firstUpSource.data
.slice(0, startIndex)
.concat(result.data);
}
resultMetaRawOption = {
seriesLayoutBy: SERIES_LAYOUT_BY_COLUMN,
sourceHeader: startIndex,
dimensions: firstUpSource.metaRawOption.dimensions,
};
} else {
resultMetaRawOption = {
seriesLayoutBy: SERIES_LAYOUT_BY_COLUMN,
sourceHeader: 0,
dimensions: result.dimensions,
};
}
return createSource(result.data, resultMetaRawOption, null);
});
}
function isSupportedSourceFormat(sourceFormat) {
return (
sourceFormat === SOURCE_FORMAT_ARRAY_ROWS ||
sourceFormat === SOURCE_FORMAT_OBJECT_ROWS
);
}
var UNDEFINED = "undefined";
/* global Float64Array, Int32Array, Uint32Array, Uint16Array */
// Caution: MUST not use `new CtorUint32Array(arr, 0, len)`, because the Ctor of array is
// different from the Ctor of typed array.
var CtorUint32Array = typeof Uint32Array === UNDEFINED ? Array : Uint32Array;
var CtorUint16Array = typeof Uint16Array === UNDEFINED ? Array : Uint16Array;
var CtorInt32Array = typeof Int32Array === UNDEFINED ? Array : Int32Array;
var CtorFloat64Array =
typeof Float64Array === UNDEFINED ? Array : Float64Array;
/**
* Multi dimensional data store
*/
var dataCtors = {
float: CtorFloat64Array,
int: CtorInt32Array,
// Ordinal data type can be string or int
ordinal: Array,
number: Array,
time: CtorFloat64Array,
};
var defaultDimValueGetters;
function getIndicesCtor(rawCount) {
// The possible max value in this._indicies is always this._rawCount despite of filtering.
return rawCount > 65535 ? CtorUint32Array : CtorUint16Array;
}
function getInitialExtent() {
return [Infinity, -Infinity];
}
function cloneChunk(originalChunk) {
var Ctor = originalChunk.constructor; // Only shallow clone is enough when Array.
return Ctor === Array ? originalChunk.slice() : new Ctor(originalChunk);
}
function prepareStore(store, dimIdx, dimType, end, append) {
var DataCtor = dataCtors[dimType || "float"];
if (append) {
var oldStore = store[dimIdx];
var oldLen = oldStore && oldStore.length;
if (!(oldLen === end)) {
var newStore = new DataCtor(end); // The cost of the copy is probably inconsiderable
// within the initial chunkSize.
for (var j = 0; j < oldLen; j++) {
newStore[j] = oldStore[j];
}
store[dimIdx] = newStore;
}
} else {
store[dimIdx] = new DataCtor(end);
}
}
/**
* Basically, DataStore API keep immutable.
*/
var DataStore =
/** @class */
(function () {
function DataStore() {
this._chunks = []; // It will not be calculated util needed.
this._rawExtent = [];
this._extent = [];
this._count = 0;
this._rawCount = 0;
this._calcDimNameToIdx = createHashMap();
}
/**
* Initialize from data
*/
DataStore.prototype.initData = function (
provider,
inputDimensions,
dimValueGetter,
) {
if ("development" !== "production") {
assert(
isFunction(provider.getItem) && isFunction(provider.count),
"Inavlid data provider.",
);
}
this._provider = provider; // Clear
this._chunks = [];
this._indices = null;
this.getRawIndex = this._getRawIdxIdentity;
var source = provider.getSource();
var defaultGetter = (this.defaultDimValueGetter =
defaultDimValueGetters[source.sourceFormat]); // Default dim value getter
this._dimValueGetter = dimValueGetter || defaultGetter; // Reset raw extent.
this._rawExtent = [];
var willRetrieveDataByName = shouldRetrieveDataByName(source);
this._dimensions = map(inputDimensions, function (dim) {
if ("development" !== "production") {
if (willRetrieveDataByName) {
assert(dim.property != null);
}
}
return {
// Only pick these two props. Not leak other properties like orderMeta.
type: dim.type,
property: dim.property,
};
});
this._initDataFromProvider(0, provider.count());
};
DataStore.prototype.getProvider = function () {
return this._provider;
};
/**
* Caution: even when a `source` instance owned by a series, the created data store
* may still be shared by different sereis (the source hash does not use all `source`
* props, see `sourceManager`). In this case, the `source` props that are not used in
* hash (like `source.dimensionDefine`) probably only belongs to a certain series and
* thus should not be fetch here.
*/
DataStore.prototype.getSource = function () {
return this._provider.getSource();
};
/**
* @caution Only used in dataStack.
*/
DataStore.prototype.ensureCalculationDimension = function (
dimName,
type,
) {
var calcDimNameToIdx = this._calcDimNameToIdx;
var dimensions = this._dimensions;
var calcDimIdx = calcDimNameToIdx.get(dimName);
if (calcDimIdx != null) {
if (dimensions[calcDimIdx].type === type) {
return calcDimIdx;
}
} else {
calcDimIdx = dimensions.length;
}
dimensions[calcDimIdx] = {
type: type,
};
calcDimNameToIdx.set(dimName, calcDimIdx);
this._chunks[calcDimIdx] = new dataCtors[type || "float"](
this._rawCount,
);
this._rawExtent[calcDimIdx] = getInitialExtent();
return calcDimIdx;
};
DataStore.prototype.collectOrdinalMeta = function (dimIdx, ordinalMeta) {
var chunk = this._chunks[dimIdx];
var dim = this._dimensions[dimIdx];
var rawExtents = this._rawExtent;
var offset = dim.ordinalOffset || 0;
var len = chunk.length;
if (offset === 0) {
// We need to reset the rawExtent if collect is from start.
// Because this dimension may be guessed as number and calcuating a wrong extent.
rawExtents[dimIdx] = getInitialExtent();
}
var dimRawExtent = rawExtents[dimIdx]; // Parse from previous data offset. len may be changed after appendData
for (var i = offset; i < len; i++) {
var val = (chunk[i] = ordinalMeta.parseAndCollect(chunk[i]));
if (!isNaN(val)) {
dimRawExtent[0] = Math.min(val, dimRawExtent[0]);
dimRawExtent[1] = Math.max(val, dimRawExtent[1]);
}
}
dim.ordinalMeta = ordinalMeta;
dim.ordinalOffset = len;
dim.type = "ordinal"; // Force to be ordinal
};
DataStore.prototype.getOrdinalMeta = function (dimIdx) {
var dimInfo = this._dimensions[dimIdx];
var ordinalMeta = dimInfo.ordinalMeta;
return ordinalMeta;
};
DataStore.prototype.getDimensionProperty = function (dimIndex) {
var item = this._dimensions[dimIndex];
return item && item.property;
};
/**
* Caution: Can be only called on raw data (before `this._indices` created).
*/
DataStore.prototype.appendData = function (data) {
if ("development" !== "production") {
assert(!this._indices, "appendData can only be called on raw data.");
}
var provider = this._provider;
var start = this.count();
provider.appendData(data);
var end = provider.count();
if (!provider.persistent) {
end += start;
}
if (start < end) {
this._initDataFromProvider(start, end, true);
}
return [start, end];
};
DataStore.prototype.appendValues = function (values, minFillLen) {
var chunks = this._chunks;
var dimensions = this._dimensions;
var dimLen = dimensions.length;
var rawExtent = this._rawExtent;
var start = this.count();
var end = start + Math.max(values.length, minFillLen || 0);
for (var i = 0; i < dimLen; i++) {
var dim = dimensions[i];
prepareStore(chunks, i, dim.type, end, true);
}
var emptyDataItem = [];
for (var idx = start; idx < end; idx++) {
var sourceIdx = idx - start; // Store the data by dimensions
for (var dimIdx = 0; dimIdx < dimLen; dimIdx++) {
var dim = dimensions[dimIdx];
var val = defaultDimValueGetters.arrayRows.call(
this,
values[sourceIdx] || emptyDataItem,
dim.property,
sourceIdx,
dimIdx,
);
chunks[dimIdx][idx] = val;
var dimRawExtent = rawExtent[dimIdx];
val < dimRawExtent[0] && (dimRawExtent[0] = val);
val > dimRawExtent[1] && (dimRawExtent[1] = val);
}
}
this._rawCount = this._count = end;
return {
start: start,
end: end,
};
};
DataStore.prototype._initDataFromProvider = function (
start,
end,
append,
) {
var provider = this._provider;
var chunks = this._chunks;
var dimensions = this._dimensions;
var dimLen = dimensions.length;
var rawExtent = this._rawExtent;
var dimNames = map(dimensions, function (dim) {
return dim.property;
});
for (var i = 0; i < dimLen; i++) {
var dim = dimensions[i];
if (!rawExtent[i]) {
rawExtent[i] = getInitialExtent();
}
prepareStore(chunks, i, dim.type, end, append);
}
if (provider.fillStorage) {
provider.fillStorage(start, end, chunks, rawExtent);
} else {
var dataItem = [];
for (var idx = start; idx < end; idx++) {
// NOTICE: Try not to write things into dataItem
dataItem = provider.getItem(idx, dataItem); // Each data item is value
// [1, 2]
// 2
// Bar chart, line chart which uses category axis
// only gives the 'y' value. 'x' value is the indices of category
// Use a tempValue to normalize the value to be a (x, y) value
// Store the data by dimensions
for (var dimIdx = 0; dimIdx < dimLen; dimIdx++) {
var dimStorage = chunks[dimIdx]; // PENDING NULL is empty or zero
var val = this._dimValueGetter(
dataItem,
dimNames[dimIdx],
idx,
dimIdx,
);
dimStorage[idx] = val;
var dimRawExtent = rawExtent[dimIdx];
val < dimRawExtent[0] && (dimRawExtent[0] = val);
val > dimRawExtent[1] && (dimRawExtent[1] = val);
}
}
}
if (!provider.persistent && provider.clean) {
// Clean unused data if data source is typed array.
provider.clean();
}
this._rawCount = this._count = end; // Reset data extent
this._extent = [];
};
DataStore.prototype.count = function () {
return this._count;
};
/**
* Get value. Return NaN if idx is out of range.
*/
DataStore.prototype.get = function (dim, idx) {
if (!(idx >= 0 && idx < this._count)) {
return NaN;
}
var dimStore = this._chunks[dim];
return dimStore ? dimStore[this.getRawIndex(idx)] : NaN;
};
DataStore.prototype.getValues = function (dimensions, idx) {
var values = [];
var dimArr = [];
if (idx == null) {
idx = dimensions; // TODO get all from store?
dimensions = []; // All dimensions
for (var i = 0; i < this._dimensions.length; i++) {
dimArr.push(i);
}
} else {
dimArr = dimensions;
}
for (var i = 0, len = dimArr.length; i < len; i++) {
values.push(this.get(dimArr[i], idx));
}
return values;
};
/**
* @param dim concrete dim
*/
DataStore.prototype.getByRawIndex = function (dim, rawIdx) {
if (!(rawIdx >= 0 && rawIdx < this._rawCount)) {
return NaN;
}
var dimStore = this._chunks[dim];
return dimStore ? dimStore[rawIdx] : NaN;
};
/**
* Get sum of data in one dimension
*/
DataStore.prototype.getSum = function (dim) {
var dimData = this._chunks[dim];
var sum = 0;
if (dimData) {
for (var i = 0, len = this.count(); i < len; i++) {
var value = this.get(dim, i);
if (!isNaN(value)) {
sum += value;
}
}
}
return sum;
};
/**
* Get median of data in one dimension
*/
DataStore.prototype.getMedian = function (dim) {
var dimDataArray = []; // map all data of one dimension
this.each([dim], function (val) {
if (!isNaN(val)) {
dimDataArray.push(val);
}
}); // TODO
// Use quick select?
var sortedDimDataArray = dimDataArray.sort(function (a, b) {
return a - b;
});
var len = this.count(); // calculate median
return len === 0
? 0
: len % 2 === 1
? sortedDimDataArray[(len - 1) / 2]
: (sortedDimDataArray[len / 2] + sortedDimDataArray[len / 2 - 1]) / 2;
};
/**
* Retreive the index with given raw data index
*/
DataStore.prototype.indexOfRawIndex = function (rawIndex) {
if (rawIndex >= this._rawCount || rawIndex < 0) {
return -1;
}
if (!this._indices) {
return rawIndex;
} // Indices are ascending
var indices = this._indices; // If rawIndex === dataIndex
var rawDataIndex = indices[rawIndex];
if (
rawDataIndex != null &&
rawDataIndex < this._count &&
rawDataIndex === rawIndex
) {
return rawIndex;
}
var left = 0;
var right = this._count - 1;
while (left <= right) {
var mid = ((left + right) / 2) | 0;
if (indices[mid] < rawIndex) {
left = mid + 1;
} else if (indices[mid] > rawIndex) {
right = mid - 1;
} else {
return mid;
}
}
return -1;
};
/**
* Retreive the index of nearest value
* @param dim
* @param value
* @param [maxDistance=Infinity]
* @return If and only if multiple indices has
* the same value, they are put to the result.
*/
DataStore.prototype.indicesOfNearest = function (
dim,
value,
maxDistance,
) {
var chunks = this._chunks;
var dimData = chunks[dim];
var nearestIndices = [];
if (!dimData) {
return nearestIndices;
}
if (maxDistance == null) {
maxDistance = Infinity;
}
var minDist = Infinity;
var minDiff = -1;
var nearestIndicesLen = 0; // Check the test case of `test/ut/spec/data/SeriesData.js`.
for (var i = 0, len = this.count(); i < len; i++) {
var dataIndex = this.getRawIndex(i);
var diff = value - dimData[dataIndex];
var dist = Math.abs(diff);
if (dist <= maxDistance) {
// When the `value` is at the middle of `this.get(dim, i)` and `this.get(dim, i+1)`,
// we'd better not push both of them to `nearestIndices`, otherwise it is easy to
// get more than one item in `nearestIndices` (more specifically, in `tooltip`).
// So we chose the one that `diff >= 0` in this csae.
// But if `this.get(dim, i)` and `this.get(dim, j)` get the same value, both of them
// should be push to `nearestIndices`.
if (
dist < minDist ||
(dist === minDist && diff >= 0 && minDiff < 0)
) {
minDist = dist;
minDiff = diff;
nearestIndicesLen = 0;
}
if (diff === minDiff) {
nearestIndices[nearestIndicesLen++] = i;
}
}
}
nearestIndices.length = nearestIndicesLen;
return nearestIndices;
};
DataStore.prototype.getIndices = function () {
var newIndices;
var indices = this._indices;
if (indices) {
var Ctor = indices.constructor;
var thisCount = this._count; // `new Array(a, b, c)` is different from `new Uint32Array(a, b, c)`.
if (Ctor === Array) {
newIndices = new Ctor(thisCount);
for (var i = 0; i < thisCount; i++) {
newIndices[i] = indices[i];
}
} else {
newIndices = new Ctor(indices.buffer, 0, thisCount);
}
} else {
var Ctor = getIndicesCtor(this._rawCount);
newIndices = new Ctor(this.count());
for (var i = 0; i < newIndices.length; i++) {
newIndices[i] = i;
}
}
return newIndices;
};
/**
* Data filter.
*/
DataStore.prototype.filter = function (dims, cb) {
if (!this._count) {
return this;
}
var newStore = this.clone();
var count = newStore.count();
var Ctor = getIndicesCtor(newStore._rawCount);
var newIndices = new Ctor(count);
var value = [];
var dimSize = dims.length;
var offset = 0;
var dim0 = dims[0];
var chunks = newStore._chunks;
for (var i = 0; i < count; i++) {
var keep = void 0;
var rawIdx = newStore.getRawIndex(i); // Simple optimization
if (dimSize === 0) {
keep = cb(i);
} else if (dimSize === 1) {
var val = chunks[dim0][rawIdx];
keep = cb(val, i);
} else {
var k = 0;
for (; k < dimSize; k++) {
value[k] = chunks[dims[k]][rawIdx];
}
value[k] = i;
keep = cb.apply(null, value);
}
if (keep) {
newIndices[offset++] = rawIdx;
}
} // Set indices after filtered.
if (offset < count) {
newStore._indices = newIndices;
}
newStore._count = offset; // Reset data extent
newStore._extent = [];
newStore._updateGetRawIdx();
return newStore;
};
/**
* Select data in range. (For optimization of filter)
* (Manually inline code, support 5 million data filtering in data zoom.)
*/
DataStore.prototype.selectRange = function (range) {
var newStore = this.clone();
var len = newStore._count;
if (!len) {
return this;
}
var dims = keys(range);
var dimSize = dims.length;
if (!dimSize) {
return this;
}
var originalCount = newStore.count();
var Ctor = getIndicesCtor(newStore._rawCount);
var newIndices = new Ctor(originalCount);
var offset = 0;
var dim0 = dims[0];
var min = range[dim0][0];
var max = range[dim0][1];
var storeArr = newStore._chunks;
var quickFinished = false;
if (!newStore._indices) {
// Extreme optimization for common case. About 2x faster in chrome.
var idx = 0;
if (dimSize === 1) {
var dimStorage = storeArr[dims[0]];
for (var i = 0; i < len; i++) {
var val = dimStorage[i]; // NaN will not be filtered. Consider the case, in line chart, empty
// value indicates the line should be broken. But for the case like
// scatter plot, a data item with empty value will not be rendered,
// but the axis extent may be effected if some other dim of the data
// item has value. Fortunately it is not a significant negative effect.
if ((val >= min && val <= max) || isNaN(val)) {
newIndices[offset++] = idx;
}
idx++;
}
quickFinished = true;
} else if (dimSize === 2) {
var dimStorage = storeArr[dims[0]];
var dimStorage2 = storeArr[dims[1]];
var min2 = range[dims[1]][0];
var max2 = range[dims[1]][1];
for (var i = 0; i < len; i++) {
var val = dimStorage[i];
var val2 = dimStorage2[i]; // Do not filter NaN, see comment above.
if (
((val >= min && val <= max) || isNaN(val)) &&
((val2 >= min2 && val2 <= max2) || isNaN(val2))
) {
newIndices[offset++] = idx;
}
idx++;
}
quickFinished = true;
}
}
if (!quickFinished) {
if (dimSize === 1) {
for (var i = 0; i < originalCount; i++) {
var rawIndex = newStore.getRawIndex(i);
var val = storeArr[dims[0]][rawIndex]; // Do not filter NaN, see comment above.
if ((val >= min && val <= max) || isNaN(val)) {
newIndices[offset++] = rawIndex;
}
}
} else {
for (var i = 0; i < originalCount; i++) {
var keep = true;
var rawIndex = newStore.getRawIndex(i);
for (var k = 0; k < dimSize; k++) {
var dimk = dims[k];
var val = storeArr[dimk][rawIndex]; // Do not filter NaN, see comment above.
if (val < range[dimk][0] || val > range[dimk][1]) {
keep = false;
}
}
if (keep) {
newIndices[offset++] = newStore.getRawIndex(i);
}
}
}
} // Set indices after filtered.
if (offset < originalCount) {
newStore._indices = newIndices;
}
newStore._count = offset; // Reset data extent
newStore._extent = [];
newStore._updateGetRawIdx();
return newStore;
}; // /**
// * Data mapping to a plain array
// */
// mapArray(dims: DimensionIndex[], cb: MapArrayCb): any[] {
// const result: any[] = [];
// this.each(dims, function () {
// result.push(cb && (cb as MapArrayCb).apply(null, arguments));
// });
// return result;
// }
/**
* Data mapping to a new List with given dimensions
*/
DataStore.prototype.map = function (dims, cb) {
// TODO only clone picked chunks.
var target = this.clone(dims);
this._updateDims(target, dims, cb);
return target;
};
/**
* @caution Danger!! Only used in dataStack.
*/
DataStore.prototype.modify = function (dims, cb) {
this._updateDims(this, dims, cb);
};
DataStore.prototype._updateDims = function (target, dims, cb) {
var targetChunks = target._chunks;
var tmpRetValue = [];
var dimSize = dims.length;
var dataCount = target.count();
var values = [];
var rawExtent = target._rawExtent;
for (var i = 0; i < dims.length; i++) {
rawExtent[dims[i]] = getInitialExtent();
}
for (var dataIndex = 0; dataIndex < dataCount; dataIndex++) {
var rawIndex = target.getRawIndex(dataIndex);
for (var k = 0; k < dimSize; k++) {
values[k] = targetChunks[dims[k]][rawIndex];
}
values[dimSize] = dataIndex;
var retValue = cb && cb.apply(null, values);
if (retValue != null) {
// a number or string (in oridinal dimension)?
if (typeof retValue !== "object") {
tmpRetValue[0] = retValue;
retValue = tmpRetValue;
}
for (var i = 0; i < retValue.length; i++) {
var dim = dims[i];
var val = retValue[i];
var rawExtentOnDim = rawExtent[dim];
var dimStore = targetChunks[dim];
if (dimStore) {
dimStore[rawIndex] = val;
}
if (val < rawExtentOnDim[0]) {
rawExtentOnDim[0] = val;
}
if (val > rawExtentOnDim[1]) {
rawExtentOnDim[1] = val;
}
}
}
}
};
/**
* Large data down sampling using largest-triangle-three-buckets
* @param {string} valueDimension
* @param {number} targetCount
*/
DataStore.prototype.lttbDownSample = function (valueDimension, rate) {
var target = this.clone([valueDimension], true);
var targetStorage = target._chunks;
var dimStore = targetStorage[valueDimension];
var len = this.count();
var sampledIndex = 0;
var frameSize = Math.floor(1 / rate);
var currentRawIndex = this.getRawIndex(0);
var maxArea;
var area;
var nextRawIndex;
var newIndices = new (getIndicesCtor(this._rawCount))(
Math.min((Math.ceil(len / frameSize) + 2) * 2, len),
); // First frame use the first data.
newIndices[sampledIndex++] = currentRawIndex;
for (var i = 1; i < len - 1; i += frameSize) {
var nextFrameStart = Math.min(i + frameSize, len - 1);
var nextFrameEnd = Math.min(i + frameSize * 2, len);
var avgX = (nextFrameEnd + nextFrameStart) / 2;
var avgY = 0;
for (var idx = nextFrameStart; idx < nextFrameEnd; idx++) {
var rawIndex = this.getRawIndex(idx);
var y = dimStore[rawIndex];
if (isNaN(y)) {
continue;
}
avgY += y;
}
avgY /= nextFrameEnd - nextFrameStart;
var frameStart = i;
var frameEnd = Math.min(i + frameSize, len);
var pointAX = i - 1;
var pointAY = dimStore[currentRawIndex];
maxArea = -1;
nextRawIndex = frameStart;
var firstNaNIndex = -1;
var countNaN = 0; // Find a point from current frame that construct a triangel with largest area with previous selected point
// And the average of next frame.
for (var idx = frameStart; idx < frameEnd; idx++) {
var rawIndex = this.getRawIndex(idx);
var y = dimStore[rawIndex];
if (isNaN(y)) {
countNaN++;
if (firstNaNIndex < 0) {
firstNaNIndex = rawIndex;
}
continue;
} // Calculate triangle area over three buckets
area = Math.abs(
(pointAX - avgX) * (y - pointAY) -
(pointAX - idx) * (avgY - pointAY),
);
if (area > maxArea) {
maxArea = area;
nextRawIndex = rawIndex; // Next a is this b
}
}
if (countNaN > 0 && countNaN < frameEnd - frameStart) {
// Append first NaN point in every bucket.
// It is necessary to ensure the correct order of indices.
newIndices[sampledIndex++] = Math.min(firstNaNIndex, nextRawIndex);
nextRawIndex = Math.max(firstNaNIndex, nextRawIndex);
}
newIndices[sampledIndex++] = nextRawIndex;
currentRawIndex = nextRawIndex; // This a is the next a (chosen b)
} // First frame use the last data.
newIndices[sampledIndex++] = this.getRawIndex(len - 1);
target._count = sampledIndex;
target._indices = newIndices;
target.getRawIndex = this._getRawIdx;
return target;
};
/**
* Large data down sampling on given dimension
* @param sampleIndex Sample index for name and id
*/
DataStore.prototype.downSample = function (
dimension,
rate,
sampleValue,
sampleIndex,
) {
var target = this.clone([dimension], true);
var targetStorage = target._chunks;
var frameValues = [];
var frameSize = Math.floor(1 / rate);
var dimStore = targetStorage[dimension];
var len = this.count();
var rawExtentOnDim = (target._rawExtent[dimension] =
getInitialExtent());
var newIndices = new (getIndicesCtor(this._rawCount))(
Math.ceil(len / frameSize),
);
var offset = 0;
for (var i = 0; i < len; i += frameSize) {
// Last frame
if (frameSize > len - i) {
frameSize = len - i;
frameValues.length = frameSize;
}
for (var k = 0; k < frameSize; k++) {
var dataIdx = this.getRawIndex(i + k);
frameValues[k] = dimStore[dataIdx];
}
var value = sampleValue(frameValues);
var sampleFrameIdx = this.getRawIndex(
Math.min(i + sampleIndex(frameValues, value) || 0, len - 1),
); // Only write value on the filtered data
dimStore[sampleFrameIdx] = value;
if (value < rawExtentOnDim[0]) {
rawExtentOnDim[0] = value;
}
if (value > rawExtentOnDim[1]) {
rawExtentOnDim[1] = value;
}
newIndices[offset++] = sampleFrameIdx;
}
target._count = offset;
target._indices = newIndices;
target._updateGetRawIdx();
return target;
};
/**
* Data iteration
* @param ctx default this
* @example
* list.each('x', function (x, idx) {});
* list.each(['x', 'y'], function (x, y, idx) {});
* list.each(function (idx) {})
*/
DataStore.prototype.each = function (dims, cb) {
if (!this._count) {
return;
}
var dimSize = dims.length;
var chunks = this._chunks;
for (var i = 0, len = this.count(); i < len; i++) {
var rawIdx = this.getRawIndex(i); // Simple optimization
switch (dimSize) {
case 0:
cb(i);
break;
case 1:
cb(chunks[dims[0]][rawIdx], i);
break;
case 2:
cb(chunks[dims[0]][rawIdx], chunks[dims[1]][rawIdx], i);
break;
default:
var k = 0;
var value = [];
for (; k < dimSize; k++) {
value[k] = chunks[dims[k]][rawIdx];
} // Index
value[k] = i;
cb.apply(null, value);
}
}
};
/**
* Get extent of data in one dimension
*/
DataStore.prototype.getDataExtent = function (dim) {
// Make sure use concrete dim as cache name.
var dimData = this._chunks[dim];
var initialExtent = getInitialExtent();
if (!dimData) {
return initialExtent;
} // Make more strict checkings to ensure hitting cache.
var currEnd = this.count(); // Consider the most cases when using data zoom, `getDataExtent`
// happened before filtering. We cache raw extent, which is not
// necessary to be cleared and recalculated when restore data.
var useRaw = !this._indices;
var dimExtent;
if (useRaw) {
return this._rawExtent[dim].slice();
}
dimExtent = this._extent[dim];
if (dimExtent) {
return dimExtent.slice();
}
dimExtent = initialExtent;
var min = dimExtent[0];
var max = dimExtent[1];
for (var i = 0; i < currEnd; i++) {
var rawIdx = this.getRawIndex(i);
var value = dimData[rawIdx];
value < min && (min = value);
value > max && (max = value);
}
dimExtent = [min, max];
this._extent[dim] = dimExtent;
return dimExtent;
};
/**
* Get raw data item
*/
DataStore.prototype.getRawDataItem = function (idx) {
var rawIdx = this.getRawIndex(idx);
if (!this._provider.persistent) {
var val = [];
var chunks = this._chunks;
for (var i = 0; i < chunks.length; i++) {
val.push(chunks[i][rawIdx]);
}
return val;
} else {
return this._provider.getItem(rawIdx);
}
};
/**
* Clone shallow.
*
* @param clonedDims Determine which dims to clone. Will share the data if not specified.
*/
DataStore.prototype.clone = function (clonedDims, ignoreIndices) {
var target = new DataStore();
var chunks = this._chunks;
var clonedDimsMap =
clonedDims &&
reduce(
clonedDims,
function (obj, dimIdx) {
obj[dimIdx] = true;
return obj;
},
{},
);
if (clonedDimsMap) {
for (var i = 0; i < chunks.length; i++) {
// Not clone if dim is not picked.
target._chunks[i] = !clonedDimsMap[i]
? chunks[i]
: cloneChunk(chunks[i]);
}
} else {
target._chunks = chunks;
}
this._copyCommonProps(target);
if (!ignoreIndices) {
target._indices = this._cloneIndices();
}
target._updateGetRawIdx();
return target;
};
DataStore.prototype._copyCommonProps = function (target) {
target._count = this._count;
target._rawCount = this._rawCount;
target._provider = this._provider;
target._dimensions = this._dimensions;
target._extent = clone(this._extent);
target._rawExtent = clone(this._rawExtent);
};
DataStore.prototype._cloneIndices = function () {
if (this._indices) {
var Ctor = this._indices.constructor;
var indices = void 0;
if (Ctor === Array) {
var thisCount = this._indices.length;
indices = new Ctor(thisCount);
for (var i = 0; i < thisCount; i++) {
indices[i] = this._indices[i];
}
} else {
indices = new Ctor(this._indices);
}
return indices;
}
return null;
};
DataStore.prototype._getRawIdxIdentity = function (idx) {
return idx;
};
DataStore.prototype._getRawIdx = function (idx) {
if (idx < this._count && idx >= 0) {
return this._indices[idx];
}
return -1;
};
DataStore.prototype._updateGetRawIdx = function () {
this.getRawIndex = this._indices
? this._getRawIdx
: this._getRawIdxIdentity;
};
DataStore.internalField = (function () {
function getDimValueSimply(dataItem, property, dataIndex, dimIndex) {
return parseDataValue(dataItem[dimIndex], this._dimensions[dimIndex]);
}
defaultDimValueGetters = {
arrayRows: getDimValueSimply,
objectRows: function (dataItem, property, dataIndex, dimIndex) {
return parseDataValue(
dataItem[property],
this._dimensions[dimIndex],
);
},
keyedColumns: getDimValueSimply,
original: function (dataItem, property, dataIndex, dimIndex) {
// Performance sensitive, do not use modelUtil.getDataItemValue.
// If dataItem is an plain object with no value field, the let `value`
// will be assigned with the object, but it will be tread correctly
// in the `convertValue`.
var value =
dataItem && (dataItem.value == null ? dataItem : dataItem.value);
return parseDataValue(
value instanceof Array
? value[dimIndex] // If value is a single number or something else not array.
: value,
this._dimensions[dimIndex],
);
},
typedArray: function (dataItem, property, dataIndex, dimIndex) {
return dataItem[dimIndex];
},
};
})();
return DataStore;
})();
/**
* [REQUIREMENT_MEMO]:
* (0) `metaRawOption` means `dimensions`/`sourceHeader`/`seriesLayoutBy` in raw option.
* (1) Keep support the feature: `metaRawOption` can be specified both on `series` and
* `root-dataset`. Them on `series` has higher priority.
* (2) Do not support to set `metaRawOption` on a `non-root-dataset`, because it might
* confuse users: whether those props indicate how to visit the upstream source or visit
* the transform result source, and some transforms has nothing to do with these props,
* and some transforms might have multiple upstream.
* (3) Transforms should specify `metaRawOption` in each output, just like they can be
* declared in `root-dataset`.
* (4) At present only support visit source in `SERIES_LAYOUT_BY_COLUMN` in transforms.
* That is for reducing complexity in transfroms.
* PENDING: Whether to provide transposition transform?
*
* [IMPLEMENTAION_MEMO]:
* "sourceVisitConfig" are calculated from `metaRawOption` and `data`.
* They will not be calculated until `source` is about to be visited (to prevent from
* duplicate calcuation). `source` is visited only in series and input to transforms.
*
* [DIMENSION_INHERIT_RULE]:
* By default the dimensions are inherited from ancestors, unless a transform return
* a new dimensions definition.
* Consider the case:
* ```js
* dataset: [{
* source: [ ['Product', 'Sales', 'Prise'], ['Cookies', 321, 44.21], ...]
* }, {
* transform: { type: 'filter', ... }
* }]
* dataset: [{
* dimension: ['Product', 'Sales', 'Prise'],
* source: [ ['Cookies', 321, 44.21], ...]
* }, {
* transform: { type: 'filter', ... }
* }]
* ```
* The two types of option should have the same behavior after transform.
*
*
* [SCENARIO]:
* (1) Provide source data directly:
* ```js
* series: {
* encode: {...},
* dimensions: [...]
* seriesLayoutBy: 'row',
* data: [[...]]
* }
* ```
* (2) Series refer to dataset.
* ```js
* series: [{
* encode: {...}
* // Ignore datasetIndex means `datasetIndex: 0`
* // and the dimensions defination in dataset is used
* }, {
* encode: {...},
* seriesLayoutBy: 'column',
* datasetIndex: 1
* }]
* ```
* (3) dataset transform
* ```js
* dataset: [{
* source: [...]
* }, {
* source: [...]
* }, {
* // By default from 0.
* transform: { type: 'filter', config: {...} }
* }, {
* // Piped.
* transform: [
* { type: 'filter', config: {...} },
* { type: 'sort', config: {...} }
* ]
* }, {
* id: 'regressionData',
* fromDatasetIndex: 1,
* // Third-party transform
* transform: { type: 'ecStat:regression', config: {...} }
* }, {
* // retrieve the extra result.
* id: 'regressionFormula',
* fromDatasetId: 'regressionData',
* fromTransformResult: 1
* }]
* ```
*/
var SourceManager =
/** @class */
(function () {
function SourceManager(sourceHost) {
// Cached source. Do not repeat calculating if not dirty.
this._sourceList = [];
this._storeList = []; // version sign of each upstream source manager.
this._upstreamSignList = [];
this._versionSignBase = 0;
this._dirty = true;
this._sourceHost = sourceHost;
}
/**
* Mark dirty.
*/
SourceManager.prototype.dirty = function () {
this._setLocalSource([], []);
this._storeList = [];
this._dirty = true;
};
SourceManager.prototype._setLocalSource = function (
sourceList,
upstreamSignList,
) {
this._sourceList = sourceList;
this._upstreamSignList = upstreamSignList;
this._versionSignBase++;
if (this._versionSignBase > 9e10) {
this._versionSignBase = 0;
}
};
/**
* For detecting whether the upstream source is dirty, so that
* the local cached source (in `_sourceList`) should be discarded.
*/
SourceManager.prototype._getVersionSign = function () {
return this._sourceHost.uid + "_" + this._versionSignBase;
};
/**
* Always return a source instance. Otherwise throw error.
*/
SourceManager.prototype.prepareSource = function () {
// For the case that call `setOption` multiple time but no data changed,
// cache the result source to prevent from repeating transform.
if (this._isDirty()) {
this._createSource();
this._dirty = false;
}
};
SourceManager.prototype._createSource = function () {
this._setLocalSource([], []);
var sourceHost = this._sourceHost;
var upSourceMgrList = this._getUpstreamSourceManagers();
var hasUpstream = !!upSourceMgrList.length;
var resultSourceList;
var upstreamSignList;
if (isSeries(sourceHost)) {
var seriesModel = sourceHost;
var data = void 0;
var sourceFormat = void 0;
var upSource = void 0; // Has upstream dataset
if (hasUpstream) {
var upSourceMgr = upSourceMgrList[0];
upSourceMgr.prepareSource();
upSource = upSourceMgr.getSource();
data = upSource.data;
sourceFormat = upSource.sourceFormat;
upstreamSignList = [upSourceMgr._getVersionSign()];
} // Series data is from own.
else {
data = seriesModel.get("data", true);
sourceFormat = isTypedArray(data)
? SOURCE_FORMAT_TYPED_ARRAY
: SOURCE_FORMAT_ORIGINAL;
upstreamSignList = [];
} // See [REQUIREMENT_MEMO], merge settings on series and parent dataset if it is root.
var newMetaRawOption = this._getSourceMetaRawOption() || {};
var upMetaRawOption = (upSource && upSource.metaRawOption) || {};
var seriesLayoutBy =
retrieve2(
newMetaRawOption.seriesLayoutBy,
upMetaRawOption.seriesLayoutBy,
) || null;
var sourceHeader = retrieve2(
newMetaRawOption.sourceHeader,
upMetaRawOption.sourceHeader,
); // Note here we should not use `upSource.dimensionsDefine`. Consider the case:
// `upSource.dimensionsDefine` is detected by `seriesLayoutBy: 'column'`,
// but series need `seriesLayoutBy: 'row'`.
var dimensions = retrieve2(
newMetaRawOption.dimensions,
upMetaRawOption.dimensions,
); // We share source with dataset as much as possible
// to avoid extra memroy cost of high dimensional data.
var needsCreateSource =
seriesLayoutBy !== upMetaRawOption.seriesLayoutBy ||
!!sourceHeader !== !!upMetaRawOption.sourceHeader ||
dimensions;
resultSourceList = needsCreateSource
? [
createSource(
data,
{
seriesLayoutBy: seriesLayoutBy,
sourceHeader: sourceHeader,
dimensions: dimensions,
},
sourceFormat,
),
]
: [];
} else {
var datasetModel = sourceHost; // Has upstream dataset.
if (hasUpstream) {
var result = this._applyTransform(upSourceMgrList);
resultSourceList = result.sourceList;
upstreamSignList = result.upstreamSignList;
} // Is root dataset.
else {
var sourceData = datasetModel.get("source", true);
resultSourceList = [
createSource(sourceData, this._getSourceMetaRawOption(), null),
];
upstreamSignList = [];
}
}
if ("development" !== "production") {
assert(resultSourceList && upstreamSignList);
}
this._setLocalSource(resultSourceList, upstreamSignList);
};
SourceManager.prototype._applyTransform = function (upMgrList) {
var datasetModel = this._sourceHost;
var transformOption = datasetModel.get("transform", true);
var fromTransformResult = datasetModel.get("fromTransformResult", true);
if ("development" !== "production") {
assert(fromTransformResult != null || transformOption != null);
}
if (fromTransformResult != null) {
var errMsg = "";
if (upMgrList.length !== 1) {
if ("development" !== "production") {
errMsg =
"When using `fromTransformResult`, there should be only one upstream dataset";
}
doThrow(errMsg);
}
}
var sourceList;
var upSourceList = [];
var upstreamSignList = [];
each(upMgrList, function (upMgr) {
upMgr.prepareSource();
var upSource = upMgr.getSource(fromTransformResult || 0);
var errMsg = "";
if (fromTransformResult != null && !upSource) {
if ("development" !== "production") {
errMsg =
"Can not retrieve result by `fromTransformResult`: " +
fromTransformResult;
}
doThrow(errMsg);
}
upSourceList.push(upSource);
upstreamSignList.push(upMgr._getVersionSign());
});
if (transformOption) {
sourceList = applyDataTransform(transformOption, upSourceList, {
datasetIndex: datasetModel.componentIndex,
});
} else if (fromTransformResult != null) {
sourceList = [cloneSourceShallow(upSourceList[0])];
}
return {
sourceList: sourceList,
upstreamSignList: upstreamSignList,
};
};
SourceManager.prototype._isDirty = function () {
if (this._dirty) {
return true;
} // All sourceList is from the some upsteam.
var upSourceMgrList = this._getUpstreamSourceManagers();
for (var i = 0; i < upSourceMgrList.length; i++) {
var upSrcMgr = upSourceMgrList[i];
if (
// Consider the case that there is ancestor diry, call it recursively.
// The performance is probably not an issue because usually the chain is not long.
upSrcMgr._isDirty() ||
this._upstreamSignList[i] !== upSrcMgr._getVersionSign()
) {
return true;
}
}
};
/**
* @param sourceIndex By defualt 0, means "main source".
* Most cases there is only one source.
*/
SourceManager.prototype.getSource = function (sourceIndex) {
sourceIndex = sourceIndex || 0;
var source = this._sourceList[sourceIndex];
if (!source) {
// Series may share source instance with dataset.
var upSourceMgrList = this._getUpstreamSourceManagers();
return (
upSourceMgrList[0] && upSourceMgrList[0].getSource(sourceIndex)
);
}
return source;
};
/**
*
* Get a data store which can be shared across series.
* Only available for series.
*
* @param seriesDimRequest Dimensions that are generated in series.
* Should have been sorted by `storeDimIndex` asc.
*/
SourceManager.prototype.getSharedDataStore = function (seriesDimRequest) {
if ("development" !== "production") {
assert(
isSeries(this._sourceHost),
"Can only call getDataStore on series source manager.",
);
}
var schema = seriesDimRequest.makeStoreSchema();
return this._innerGetDataStore(
schema.dimensions,
seriesDimRequest.source,
schema.hash,
);
};
SourceManager.prototype._innerGetDataStore = function (
storeDims,
seriesSource,
sourceReadKey,
) {
// TODO Can use other sourceIndex?
var sourceIndex = 0;
var storeList = this._storeList;
var cachedStoreMap = storeList[sourceIndex];
if (!cachedStoreMap) {
cachedStoreMap = storeList[sourceIndex] = {};
}
var cachedStore = cachedStoreMap[sourceReadKey];
if (!cachedStore) {
var upSourceMgr = this._getUpstreamSourceManagers()[0];
if (isSeries(this._sourceHost) && upSourceMgr) {
cachedStore = upSourceMgr._innerGetDataStore(
storeDims,
seriesSource,
sourceReadKey,
);
} else {
cachedStore = new DataStore(); // Always create store from source of series.
cachedStore.initData(
new DefaultDataProvider(seriesSource, storeDims.length),
storeDims,
);
}
cachedStoreMap[sourceReadKey] = cachedStore;
}
return cachedStore;
};
/**
* PEDING: Is it fast enough?
* If no upstream, return empty array.
*/
SourceManager.prototype._getUpstreamSourceManagers = function () {
// Always get the relationship from the raw option.
// Do not cache the link of the dependency graph, so that
// no need to update them when change happen.
var sourceHost = this._sourceHost;
if (isSeries(sourceHost)) {
var datasetModel = querySeriesUpstreamDatasetModel(sourceHost);
return !datasetModel ? [] : [datasetModel.getSourceManager()];
} else {
return map(
queryDatasetUpstreamDatasetModels(sourceHost),
function (datasetModel) {
return datasetModel.getSourceManager();
},
);
}
};
SourceManager.prototype._getSourceMetaRawOption = function () {
var sourceHost = this._sourceHost;
var seriesLayoutBy;
var sourceHeader;
var dimensions;
if (isSeries(sourceHost)) {
seriesLayoutBy = sourceHost.get("seriesLayoutBy", true);
sourceHeader = sourceHost.get("sourceHeader", true);
dimensions = sourceHost.get("dimensions", true);
} // See [REQUIREMENT_MEMO], `non-root-dataset` do not support them.
else if (!this._getUpstreamSourceManagers().length) {
var model = sourceHost;
seriesLayoutBy = model.get("seriesLayoutBy", true);
sourceHeader = model.get("sourceHeader", true);
dimensions = model.get("dimensions", true);
}
return {
seriesLayoutBy: seriesLayoutBy,
sourceHeader: sourceHeader,
dimensions: dimensions,
};
};
return SourceManager;
})();
// disable the transform merge, but do not disable transfrom clone from rawOption.
function disableTransformOptionMerge(datasetModel) {
var transformOption = datasetModel.option.transform;
transformOption && setAsPrimitive(datasetModel.option.transform);
}
function isSeries(sourceHost) {
// Avoid circular dependency with Series.ts
return sourceHost.mainType === "series";
}
function doThrow(errMsg) {
throw new Error(errMsg);
}
var TOOLTIP_LINE_HEIGHT_CSS = "line-height:1"; // TODO: more textStyle option
function getTooltipTextStyle(textStyle, renderMode) {
var nameFontColor = textStyle.color || "#6e7079";
var nameFontSize = textStyle.fontSize || 12;
var nameFontWeight = textStyle.fontWeight || "400";
var valueFontColor = textStyle.color || "#464646";
var valueFontSize = textStyle.fontSize || 14;
var valueFontWeight = textStyle.fontWeight || "900";
if (renderMode === "html") {
// `textStyle` is probably from user input, should be encoded to reduce security risk.
return {
// eslint-disable-next-line max-len
nameStyle:
"font-size:" +
encodeHTML(nameFontSize + "") +
"px;color:" +
encodeHTML(nameFontColor) +
";font-weight:" +
encodeHTML(nameFontWeight + ""),
// eslint-disable-next-line max-len
valueStyle:
"font-size:" +
encodeHTML(valueFontSize + "") +
"px;color:" +
encodeHTML(valueFontColor) +
";font-weight:" +
encodeHTML(valueFontWeight + ""),
};
} else {
return {
nameStyle: {
fontSize: nameFontSize,
fill: nameFontColor,
fontWeight: nameFontWeight,
},
valueStyle: {
fontSize: valueFontSize,
fill: valueFontColor,
fontWeight: valueFontWeight,
},
};
}
} // See `TooltipMarkupLayoutIntent['innerGapLevel']`.
// (value from UI design)
var HTML_GAPS = [0, 10, 20, 30];
var RICH_TEXT_GAPS = ["", "\n", "\n\n", "\n\n\n"]; // eslint-disable-next-line max-len
function createTooltipMarkup(type, option) {
option.type = type;
return option;
}
function isSectionFragment(frag) {
return frag.type === "section";
}
function getBuilder(frag) {
return isSectionFragment(frag) ? buildSection : buildNameValue;
}
function getBlockGapLevel(frag) {
if (isSectionFragment(frag)) {
var gapLevel_1 = 0;
var subBlockLen = frag.blocks.length;
var hasInnerGap_1 =
subBlockLen > 1 || (subBlockLen > 0 && !frag.noHeader);
each(frag.blocks, function (subBlock) {
var subGapLevel = getBlockGapLevel(subBlock); // If the some of the sub-blocks have some gaps (like 10px) inside, this block
// should use a larger gap (like 20px) to distinguish those sub-blocks.
if (subGapLevel >= gapLevel_1) {
gapLevel_1 =
subGapLevel +
+(
hasInnerGap_1 && // 0 always can not be readable gap level.
(!subGapLevel || // If no header, always keep the sub gap level. Otherwise
// look weird in case `multipleSeries`.
(isSectionFragment(subBlock) && !subBlock.noHeader))
);
}
});
return gapLevel_1;
}
return 0;
}
function buildSection(ctx, fragment, topMarginForOuterGap, toolTipTextStyle) {
var noHeader = fragment.noHeader;
var gaps = getGap(getBlockGapLevel(fragment));
var subMarkupTextList = [];
var subBlocks = fragment.blocks || [];
assert(!subBlocks || isArray(subBlocks));
subBlocks = subBlocks || [];
var orderMode = ctx.orderMode;
if (fragment.sortBlocks && orderMode) {
subBlocks = subBlocks.slice();
var orderMap = {
valueAsc: "asc",
valueDesc: "desc",
};
if (hasOwn(orderMap, orderMode)) {
var comparator_1 = new SortOrderComparator(orderMap[orderMode], null);
subBlocks.sort(function (a, b) {
return comparator_1.evaluate(a.sortParam, b.sortParam);
});
} // FIXME 'seriesDesc' necessary?
else if (orderMode === "seriesDesc") {
subBlocks.reverse();
}
}
each(subBlocks, function (subBlock, idx) {
var valueFormatter = fragment.valueFormatter;
var subMarkupText = getBuilder(subBlock)(
// Inherit valueFormatter
valueFormatter
? extend(extend({}, ctx), {
valueFormatter: valueFormatter,
})
: ctx,
subBlock,
idx > 0 ? gaps.html : 0,
toolTipTextStyle,
);
subMarkupText != null && subMarkupTextList.push(subMarkupText);
});
var subMarkupText =
ctx.renderMode === "richText"
? subMarkupTextList.join(gaps.richText)
: wrapBlockHTML(
subMarkupTextList.join(""),
noHeader ? topMarginForOuterGap : gaps.html,
);
if (noHeader) {
return subMarkupText;
}
var displayableHeader = makeValueReadable(
fragment.header,
"ordinal",
ctx.useUTC,
);
var nameStyle = getTooltipTextStyle(
toolTipTextStyle,
ctx.renderMode,
).nameStyle;
if (ctx.renderMode === "richText") {
return (
wrapInlineNameRichText(ctx, displayableHeader, nameStyle) +
gaps.richText +
subMarkupText
);
} else {
return wrapBlockHTML(
'' +
encodeHTML(displayableHeader) +
"
" +
subMarkupText,
topMarginForOuterGap,
);
}
}
function buildNameValue(
ctx,
fragment,
topMarginForOuterGap,
toolTipTextStyle,
) {
var renderMode = ctx.renderMode;
var noName = fragment.noName;
var noValue = fragment.noValue;
var noMarker = !fragment.markerType;
var name = fragment.name;
var useUTC = ctx.useUTC;
var valueFormatter =
fragment.valueFormatter ||
ctx.valueFormatter ||
function (value) {
value = isArray(value) ? value : [value];
return map(value, function (val, idx) {
return makeValueReadable(
val,
isArray(valueTypeOption) ? valueTypeOption[idx] : valueTypeOption,
useUTC,
);
});
};
if (noName && noValue) {
return;
}
var markerStr = noMarker
? ""
: ctx.markupStyleCreator.makeTooltipMarker(
fragment.markerType,
fragment.markerColor || "#333",
renderMode,
);
var readableName = noName ? "" : makeValueReadable(name, "ordinal", useUTC);
var valueTypeOption = fragment.valueType;
var readableValueList = noValue ? [] : valueFormatter(fragment.value);
var valueAlignRight = !noMarker || !noName; // It little weird if only value next to marker but far from marker.
var valueCloseToMarker = !noMarker && noName;
var _a = getTooltipTextStyle(toolTipTextStyle, renderMode),
nameStyle = _a.nameStyle,
valueStyle = _a.valueStyle;
return renderMode === "richText"
? (noMarker ? "" : markerStr) +
(noName ? "" : wrapInlineNameRichText(ctx, readableName, nameStyle)) + // Value has commas inside, so use ' ' as delimiter for multiple values.
(noValue
? ""
: wrapInlineValueRichText(
ctx,
readableValueList,
valueAlignRight,
valueCloseToMarker,
valueStyle,
))
: wrapBlockHTML(
(noMarker ? "" : markerStr) +
(noName
? ""
: wrapInlineNameHTML(readableName, !noMarker, nameStyle)) +
(noValue
? ""
: wrapInlineValueHTML(
readableValueList,
valueAlignRight,
valueCloseToMarker,
valueStyle,
)),
topMarginForOuterGap,
);
}
/**
* @return markupText. null/undefined means no content.
*/
function buildTooltipMarkup(
fragment,
markupStyleCreator,
renderMode,
orderMode,
useUTC,
toolTipTextStyle,
) {
if (!fragment) {
return;
}
var builder = getBuilder(fragment);
var ctx = {
useUTC: useUTC,
renderMode: renderMode,
orderMode: orderMode,
markupStyleCreator: markupStyleCreator,
valueFormatter: fragment.valueFormatter,
};
return builder(ctx, fragment, 0, toolTipTextStyle);
}
function getGap(gapLevel) {
return {
html: HTML_GAPS[gapLevel],
richText: RICH_TEXT_GAPS[gapLevel],
};
}
function wrapBlockHTML(encodedContent, topGap) {
var clearfix = '';
var marginCSS = "margin: " + topGap + "px 0 0";
return (
'' +
encodedContent +
clearfix +
"
"
);
}
function wrapInlineNameHTML(name, leftHasMarker, style) {
var marginCss = leftHasMarker ? "margin-left:2px" : "";
return (
'' +
encodeHTML(name) +
""
);
}
function wrapInlineValueHTML(
valueList,
alignRight,
valueCloseToMarker,
style,
) {
// Do not too close to marker, considering there are multiple values separated by spaces.
var paddingStr = valueCloseToMarker ? "10px" : "20px";
var alignCSS = alignRight ? "float:right;margin-left:" + paddingStr : "";
valueList = isArray(valueList) ? valueList : [valueList];
return (
'' + // Value has commas inside, so use ' ' as delimiter for multiple values.
map(valueList, function (value) {
return encodeHTML(value);
}).join(" ") +
""
);
}
function wrapInlineNameRichText(ctx, name, style) {
return ctx.markupStyleCreator.wrapRichTextStyle(name, style);
}
function wrapInlineValueRichText(
ctx,
values,
alignRight,
valueCloseToMarker,
style,
) {
var styles = [style];
var paddingLeft = valueCloseToMarker ? 10 : 20;
alignRight &&
styles.push({
padding: [0, 0, 0, paddingLeft],
align: "right",
}); // Value has commas inside, so use ' ' as delimiter for multiple values.
return ctx.markupStyleCreator.wrapRichTextStyle(
isArray(values) ? values.join(" ") : values,
styles,
);
}
function retrieveVisualColorForTooltipMarker(series, dataIndex) {
var style = series.getData().getItemVisual(dataIndex, "style");
var color = style[series.visualDrawType];
return convertToColorString(color);
}
function getPaddingFromTooltipModel(model, renderMode) {
var padding = model.get("padding");
return padding != null
? padding // We give slightly different to look pretty.
: renderMode === "richText"
? [8, 10]
: 10;
}
/**
* The major feature is generate styles for `renderMode: 'richText'`.
* But it also serves `renderMode: 'html'` to provide
* "renderMode-independent" API.
*/
var TooltipMarkupStyleCreator =
/** @class */
(function () {
function TooltipMarkupStyleCreator() {
this.richTextStyles = {}; // Notice that "generate a style name" usuall happens repeatly when mouse moving and
// displaying a tooltip. So we put the `_nextStyleNameId` as a member of each creator
// rather than static shared by all creators (which will cause it increase to fast).
this._nextStyleNameId = getRandomIdBase();
}
TooltipMarkupStyleCreator.prototype._generateStyleName = function () {
return "__EC_aUTo_" + this._nextStyleNameId++;
};
TooltipMarkupStyleCreator.prototype.makeTooltipMarker = function (
markerType,
colorStr,
renderMode,
) {
var markerId =
renderMode === "richText" ? this._generateStyleName() : null;
var marker = getTooltipMarker({
color: colorStr,
type: markerType,
renderMode: renderMode,
markerId: markerId,
});
if (isString(marker)) {
return marker;
} else {
if ("development" !== "production") {
assert(markerId);
}
this.richTextStyles[markerId] = marker.style;
return marker.content;
}
};
/**
* @usage
* ```ts
* const styledText = markupStyleCreator.wrapRichTextStyle([
* // The styles will be auto merged.
* {
* fontSize: 12,
* color: 'blue'
* },
* {
* padding: 20
* }
* ]);
* ```
*/
TooltipMarkupStyleCreator.prototype.wrapRichTextStyle = function (
text,
styles,
) {
var finalStl = {};
if (isArray(styles)) {
each(styles, function (stl) {
return extend(finalStl, stl);
});
} else {
extend(finalStl, styles);
}
var styleName = this._generateStyleName();
this.richTextStyles[styleName] = finalStl;
return "{" + styleName + "|" + text + "}";
};
return TooltipMarkupStyleCreator;
})();
function defaultSeriesFormatTooltip(opt) {
var series = opt.series;
var dataIndex = opt.dataIndex;
var multipleSeries = opt.multipleSeries;
var data = series.getData();
var tooltipDims = data.mapDimensionsAll("defaultedTooltip");
var tooltipDimLen = tooltipDims.length;
var value = series.getRawValue(dataIndex);
var isValueArr = isArray(value);
var markerColor = retrieveVisualColorForTooltipMarker(series, dataIndex); // Complicated rule for pretty tooltip.
var inlineValue;
var inlineValueType;
var subBlocks;
var sortParam;
if (tooltipDimLen > 1 || (isValueArr && !tooltipDimLen)) {
var formatArrResult = formatTooltipArrayValue(
value,
series,
dataIndex,
tooltipDims,
markerColor,
);
inlineValue = formatArrResult.inlineValues;
inlineValueType = formatArrResult.inlineValueTypes;
subBlocks = formatArrResult.blocks; // Only support tooltip sort by the first inline value. It's enough in most cases.
sortParam = formatArrResult.inlineValues[0];
} else if (tooltipDimLen) {
var dimInfo = data.getDimensionInfo(tooltipDims[0]);
sortParam = inlineValue = retrieveRawValue(
data,
dataIndex,
tooltipDims[0],
);
inlineValueType = dimInfo.type;
} else {
sortParam = inlineValue = isValueArr ? value[0] : value;
} // Do not show generated series name. It might not be readable.
var seriesNameSpecified = isNameSpecified(series);
var seriesName = (seriesNameSpecified && series.name) || "";
var itemName = data.getName(dataIndex);
var inlineName = multipleSeries ? seriesName : itemName;
return createTooltipMarkup("section", {
header: seriesName,
// When series name not specified, do not show a header line with only '-'.
// This case alway happen in tooltip.trigger: 'item'.
noHeader: multipleSeries || !seriesNameSpecified,
sortParam: sortParam,
blocks: [
createTooltipMarkup("nameValue", {
markerType: "item",
markerColor: markerColor,
// Do not mix display seriesName and itemName in one tooltip,
// which might confuses users.
name: inlineName,
// name dimension might be auto assigned, where the name might
// be not readable. So we check trim here.
noName: !trim(inlineName),
value: inlineValue,
valueType: inlineValueType,
}),
].concat(subBlocks || []),
});
}
function formatTooltipArrayValue(
value,
series,
dataIndex,
tooltipDims,
colorStr,
) {
// check: category-no-encode-has-axis-data in dataset.html
var data = series.getData();
var isValueMultipleLine = reduce(
value,
function (isValueMultipleLine, val, idx) {
var dimItem = data.getDimensionInfo(idx);
return (isValueMultipleLine =
isValueMultipleLine ||
(dimItem &&
dimItem.tooltip !== false &&
dimItem.displayName != null));
},
false,
);
var inlineValues = [];
var inlineValueTypes = [];
var blocks = [];
tooltipDims.length
? each(tooltipDims, function (dim) {
setEachItem(retrieveRawValue(data, dataIndex, dim), dim);
}) // By default, all dims is used on tooltip.
: each(value, setEachItem);
function setEachItem(val, dim) {
var dimInfo = data.getDimensionInfo(dim); // If `dimInfo.tooltip` is not set, show tooltip.
if (!dimInfo || dimInfo.otherDims.tooltip === false) {
return;
}
if (isValueMultipleLine) {
blocks.push(
createTooltipMarkup("nameValue", {
markerType: "subItem",
markerColor: colorStr,
name: dimInfo.displayName,
value: val,
valueType: dimInfo.type,
}),
);
} else {
inlineValues.push(val);
inlineValueTypes.push(dimInfo.type);
}
}
return {
inlineValues: inlineValues,
inlineValueTypes: inlineValueTypes,
blocks: blocks,
};
}
var inner$1 = makeInner();
function getSelectionKey(data, dataIndex) {
return data.getName(dataIndex) || data.getId(dataIndex);
}
var SERIES_UNIVERSAL_TRANSITION_PROP = "__universalTransitionEnabled";
var SeriesModel =
/** @class */
(function (_super) {
__extends(SeriesModel, _super);
function SeriesModel() {
// [Caution]: Becuase this class or desecendants can be used as `XXX.extend(subProto)`,
// the class members must not be initialized in constructor or declaration place.
// Otherwise there is bad case:
// class A {xxx = 1;}
// enableClassExtend(A);
// class B extends A {}
// var C = B.extend({xxx: 5});
// var c = new C();
// console.log(c.xxx); // expect 5 but always 1.
var _this = (_super !== null && _super.apply(this, arguments)) || this; // ---------------------------------------
// Props about data selection
// ---------------------------------------
_this._selectedDataIndicesMap = {};
return _this;
}
SeriesModel.prototype.init = function (option, parentModel, ecModel) {
this.seriesIndex = this.componentIndex;
this.dataTask = createTask({
count: dataTaskCount,
reset: dataTaskReset,
});
this.dataTask.context = {
model: this,
};
this.mergeDefaultAndTheme(option, ecModel);
var sourceManager = (inner$1(this).sourceManager = new SourceManager(
this,
));
sourceManager.prepareSource();
var data = this.getInitialData(option, ecModel);
wrapData(data, this);
this.dataTask.context.data = data;
if ("development" !== "production") {
assert(data, "getInitialData returned invalid data.");
}
inner$1(this).dataBeforeProcessed = data; // If we reverse the order (make data firstly, and then make
// dataBeforeProcessed by cloneShallow), cloneShallow will
// cause data.graph.data !== data when using
// module:echarts/data/Graph or module:echarts/data/Tree.
// See module:echarts/data/helper/linkSeriesData
// Theoretically, it is unreasonable to call `seriesModel.getData()` in the model
// init or merge stage, because the data can be restored. So we do not `restoreData`
// and `setData` here, which forbids calling `seriesModel.getData()` in this stage.
// Call `seriesModel.getRawData()` instead.
// this.restoreData();
autoSeriesName(this);
this._initSelectedMapFromData(data);
};
/**
* Util for merge default and theme to option
*/
SeriesModel.prototype.mergeDefaultAndTheme = function (option, ecModel) {
var layoutMode = fetchLayoutMode(this);
var inputPositionParams = layoutMode ? getLayoutParams(option) : {}; // Backward compat: using subType on theme.
// But if name duplicate between series subType
// (for example: parallel) add component mainType,
// add suffix 'Series'.
var themeSubType = this.subType;
if (ComponentModel.hasClass(themeSubType)) {
themeSubType += "Series";
}
merge(option, ecModel.getTheme().get(this.subType));
merge(option, this.getDefaultOption()); // Default label emphasis `show`
defaultEmphasis(option, "label", ["show"]);
this.fillDataTextStyle(option.data);
if (layoutMode) {
mergeLayoutParam(option, inputPositionParams, layoutMode);
}
};
SeriesModel.prototype.mergeOption = function (newSeriesOption, ecModel) {
// this.settingTask.dirty();
newSeriesOption = merge(this.option, newSeriesOption, true);
this.fillDataTextStyle(newSeriesOption.data);
var layoutMode = fetchLayoutMode(this);
if (layoutMode) {
mergeLayoutParam(this.option, newSeriesOption, layoutMode);
}
var sourceManager = inner$1(this).sourceManager;
sourceManager.dirty();
sourceManager.prepareSource();
var data = this.getInitialData(newSeriesOption, ecModel);
wrapData(data, this);
this.dataTask.dirty();
this.dataTask.context.data = data;
inner$1(this).dataBeforeProcessed = data;
autoSeriesName(this);
this._initSelectedMapFromData(data);
};
SeriesModel.prototype.fillDataTextStyle = function (data) {
// Default data label emphasis `show`
// FIXME Tree structure data ?
// FIXME Performance ?
if (data && !isTypedArray(data)) {
var props = ["show"];
for (var i = 0; i < data.length; i++) {
if (data[i] && data[i].label) {
defaultEmphasis(data[i], "label", props);
}
}
}
};
/**
* Init a data structure from data related option in series
* Must be overriden.
*/
SeriesModel.prototype.getInitialData = function (option, ecModel) {
return;
};
/**
* Append data to list
*/
SeriesModel.prototype.appendData = function (params) {
// FIXME ???
// (1) If data from dataset, forbidden append.
// (2) support append data of dataset.
var data = this.getRawData();
data.appendData(params.data);
};
/**
* Consider some method like `filter`, `map` need make new data,
* We should make sure that `seriesModel.getData()` get correct
* data in the stream procedure. So we fetch data from upstream
* each time `task.perform` called.
*/
SeriesModel.prototype.getData = function (dataType) {
var task = getCurrentTask(this);
if (task) {
var data = task.context.data;
return dataType == null ? data : data.getLinkedData(dataType);
} else {
// When series is not alive (that may happen when click toolbox
// restore or setOption with not merge mode), series data may
// be still need to judge animation or something when graphic
// elements want to know whether fade out.
return inner$1(this).data;
}
};
SeriesModel.prototype.getAllData = function () {
var mainData = this.getData();
return mainData && mainData.getLinkedDataAll
? mainData.getLinkedDataAll()
: [
{
data: mainData,
},
];
};
SeriesModel.prototype.setData = function (data) {
var task = getCurrentTask(this);
if (task) {
var context = task.context; // Consider case: filter, data sample.
// FIXME:TS never used, so comment it
// if (context.data !== data && task.modifyOutputEnd) {
// task.setOutputEnd(data.count());
// }
context.outputData = data; // Caution: setData should update context.data,
// Because getData may be called multiply in a
// single stage and expect to get the data just
// set. (For example, AxisProxy, x y both call
// getData and setDate sequentially).
// So the context.data should be fetched from
// upstream each time when a stage starts to be
// performed.
if (task !== this.dataTask) {
context.data = data;
}
}
inner$1(this).data = data;
};
SeriesModel.prototype.getEncode = function () {
var encode = this.get("encode", true);
if (encode) {
return createHashMap(encode);
}
};
SeriesModel.prototype.getSourceManager = function () {
return inner$1(this).sourceManager;
};
SeriesModel.prototype.getSource = function () {
return this.getSourceManager().getSource();
};
/**
* Get data before processed
*/
SeriesModel.prototype.getRawData = function () {
return inner$1(this).dataBeforeProcessed;
};
SeriesModel.prototype.getColorBy = function () {
var colorBy = this.get("colorBy");
return colorBy || "series";
};
SeriesModel.prototype.isColorBySeries = function () {
return this.getColorBy() === "series";
};
/**
* Get base axis if has coordinate system and has axis.
* By default use coordSys.getBaseAxis();
* Can be overrided for some chart.
* @return {type} description
*/
SeriesModel.prototype.getBaseAxis = function () {
var coordSys = this.coordinateSystem; // @ts-ignore
return coordSys && coordSys.getBaseAxis && coordSys.getBaseAxis();
};
/**
* Default tooltip formatter
*
* @param dataIndex
* @param multipleSeries
* @param dataType
* @param renderMode valid values: 'html'(by default) and 'richText'.
* 'html' is used for rendering tooltip in extra DOM form, and the result
* string is used as DOM HTML content.
* 'richText' is used for rendering tooltip in rich text form, for those where
* DOM operation is not supported.
* @return formatted tooltip with `html` and `markers`
* Notice: The override method can also return string
*/
SeriesModel.prototype.formatTooltip = function (
dataIndex,
multipleSeries,
dataType,
) {
return defaultSeriesFormatTooltip({
series: this,
dataIndex: dataIndex,
multipleSeries: multipleSeries,
});
};
SeriesModel.prototype.isAnimationEnabled = function () {
var ecModel = this.ecModel; // Disable animation if using echarts in node but not give ssr flag.
// In ssr mode, renderToString will generate svg with css animation.
if (env.node && !(ecModel && ecModel.ssr)) {
return false;
}
var animationEnabled = this.getShallow("animation");
if (animationEnabled) {
if (this.getData().count() > this.getShallow("animationThreshold")) {
animationEnabled = false;
}
}
return !!animationEnabled;
};
SeriesModel.prototype.restoreData = function () {
this.dataTask.dirty();
};
SeriesModel.prototype.getColorFromPalette = function (
name,
scope,
requestColorNum,
) {
var ecModel = this.ecModel; // PENDING
var color = PaletteMixin.prototype.getColorFromPalette.call(
this,
name,
scope,
requestColorNum,
);
if (!color) {
color = ecModel.getColorFromPalette(name, scope, requestColorNum);
}
return color;
};
/**
* Use `data.mapDimensionsAll(coordDim)` instead.
* @deprecated
*/
SeriesModel.prototype.coordDimToDataDim = function (coordDim) {
return this.getRawData().mapDimensionsAll(coordDim);
};
/**
* Get progressive rendering count each step
*/
SeriesModel.prototype.getProgressive = function () {
return this.get("progressive");
};
/**
* Get progressive rendering count each step
*/
SeriesModel.prototype.getProgressiveThreshold = function () {
return this.get("progressiveThreshold");
}; // PENGING If selectedMode is null ?
SeriesModel.prototype.select = function (innerDataIndices, dataType) {
this._innerSelect(this.getData(dataType), innerDataIndices);
};
SeriesModel.prototype.unselect = function (innerDataIndices, dataType) {
var selectedMap = this.option.selectedMap;
if (!selectedMap) {
return;
}
var selectedMode = this.option.selectedMode;
var data = this.getData(dataType);
if (selectedMode === "series" || selectedMap === "all") {
this.option.selectedMap = {};
this._selectedDataIndicesMap = {};
return;
}
for (var i = 0; i < innerDataIndices.length; i++) {
var dataIndex = innerDataIndices[i];
var nameOrId = getSelectionKey(data, dataIndex);
selectedMap[nameOrId] = false;
this._selectedDataIndicesMap[nameOrId] = -1;
}
};
SeriesModel.prototype.toggleSelect = function (
innerDataIndices,
dataType,
) {
var tmpArr = [];
for (var i = 0; i < innerDataIndices.length; i++) {
tmpArr[0] = innerDataIndices[i];
this.isSelected(innerDataIndices[i], dataType)
? this.unselect(tmpArr, dataType)
: this.select(tmpArr, dataType);
}
};
SeriesModel.prototype.getSelectedDataIndices = function () {
if (this.option.selectedMap === "all") {
return [].slice.call(this.getData().getIndices());
}
var selectedDataIndicesMap = this._selectedDataIndicesMap;
var nameOrIds = keys(selectedDataIndicesMap);
var dataIndices = [];
for (var i = 0; i < nameOrIds.length; i++) {
var dataIndex = selectedDataIndicesMap[nameOrIds[i]];
if (dataIndex >= 0) {
dataIndices.push(dataIndex);
}
}
return dataIndices;
};
SeriesModel.prototype.isSelected = function (dataIndex, dataType) {
var selectedMap = this.option.selectedMap;
if (!selectedMap) {
return false;
}
var data = this.getData(dataType);
return (
(selectedMap === "all" ||
selectedMap[getSelectionKey(data, dataIndex)]) &&
!data.getItemModel(dataIndex).get(["select", "disabled"])
);
};
SeriesModel.prototype.isUniversalTransitionEnabled = function () {
if (this[SERIES_UNIVERSAL_TRANSITION_PROP]) {
return true;
}
var universalTransitionOpt = this.option.universalTransition; // Quick reject
if (!universalTransitionOpt) {
return false;
}
if (universalTransitionOpt === true) {
return true;
} // Can be simply 'universalTransition: true'
return universalTransitionOpt && universalTransitionOpt.enabled;
};
SeriesModel.prototype._innerSelect = function (data, innerDataIndices) {
var _a, _b;
var option = this.option;
var selectedMode = option.selectedMode;
var len = innerDataIndices.length;
if (!selectedMode || !len) {
return;
}
if (selectedMode === "series") {
option.selectedMap = "all";
} else if (selectedMode === "multiple") {
if (!isObject(option.selectedMap)) {
option.selectedMap = {};
}
var selectedMap = option.selectedMap;
for (var i = 0; i < len; i++) {
var dataIndex = innerDataIndices[i]; // TODO diffrent types of data share same object.
var nameOrId = getSelectionKey(data, dataIndex);
selectedMap[nameOrId] = true;
this._selectedDataIndicesMap[nameOrId] =
data.getRawIndex(dataIndex);
}
} else if (selectedMode === "single" || selectedMode === true) {
var lastDataIndex = innerDataIndices[len - 1];
var nameOrId = getSelectionKey(data, lastDataIndex);
option.selectedMap = ((_a = {}), (_a[nameOrId] = true), _a);
this._selectedDataIndicesMap =
((_b = {}), (_b[nameOrId] = data.getRawIndex(lastDataIndex)), _b);
}
};
SeriesModel.prototype._initSelectedMapFromData = function (data) {
// Ignore select info in data if selectedMap exists.
// NOTE It's only for legacy usage. edge data is not supported.
if (this.option.selectedMap) {
return;
}
var dataIndices = [];
if (data.hasItemOption) {
data.each(function (idx) {
var rawItem = data.getRawDataItem(idx);
if (rawItem && rawItem.selected) {
dataIndices.push(idx);
}
});
}
if (dataIndices.length > 0) {
this._innerSelect(data, dataIndices);
}
}; // /**
// * @see {module:echarts/stream/Scheduler}
// */
// abstract pipeTask: null
SeriesModel.registerClass = function (clz) {
return ComponentModel.registerClass(clz);
};
SeriesModel.protoInitialize = (function () {
var proto = SeriesModel.prototype;
proto.type = "series.__base__";
proto.seriesIndex = 0;
proto.ignoreStyleOnData = false;
proto.hasSymbolVisual = false;
proto.defaultSymbol = "circle"; // Make sure the values can be accessed!
proto.visualStyleAccessPath = "itemStyle";
proto.visualDrawType = "fill";
})();
return SeriesModel;
})(ComponentModel);
mixin(SeriesModel, DataFormatMixin);
mixin(SeriesModel, PaletteMixin);
mountExtend(SeriesModel, ComponentModel);
/**
* MUST be called after `prepareSource` called
* Here we need to make auto series, especially for auto legend. But we
* do not modify series.name in option to avoid side effects.
*/
function autoSeriesName(seriesModel) {
// User specified name has higher priority, otherwise it may cause
// series can not be queried unexpectedly.
var name = seriesModel.name;
if (!isNameSpecified(seriesModel)) {
seriesModel.name = getSeriesAutoName(seriesModel) || name;
}
}
function getSeriesAutoName(seriesModel) {
var data = seriesModel.getRawData();
var dataDims = data.mapDimensionsAll("seriesName");
var nameArr = [];
each(dataDims, function (dataDim) {
var dimInfo = data.getDimensionInfo(dataDim);
dimInfo.displayName && nameArr.push(dimInfo.displayName);
});
return nameArr.join(" ");
}
function dataTaskCount(context) {
return context.model.getRawData().count();
}
function dataTaskReset(context) {
var seriesModel = context.model;
seriesModel.setData(seriesModel.getRawData().cloneShallow());
return dataTaskProgress;
}
function dataTaskProgress(param, context) {
// Avoid repead cloneShallow when data just created in reset.
if (context.outputData && param.end > context.outputData.count()) {
context.model.getRawData().cloneShallow(context.outputData);
}
} // TODO refactor
function wrapData(data, seriesModel) {
each(
concatArray(data.CHANGABLE_METHODS, data.DOWNSAMPLE_METHODS),
function (methodName) {
data.wrapMethod(methodName, curry(onDataChange, seriesModel));
},
);
}
function onDataChange(seriesModel, newList) {
var task = getCurrentTask(seriesModel);
if (task) {
// Consider case: filter, selectRange
task.setOutputEnd((newList || this).count());
}
return newList;
}
function getCurrentTask(seriesModel) {
var scheduler = (seriesModel.ecModel || {}).scheduler;
var pipeline = scheduler && scheduler.getPipeline(seriesModel.uid);
if (pipeline) {
// When pipline finished, the currrentTask keep the last
// task (renderTask).
var task = pipeline.currentTask;
if (task) {
var agentStubMap = task.agentStubMap;
if (agentStubMap) {
task = agentStubMap.get(seriesModel.uid);
}
}
return task;
}
}
var ComponentView =
/** @class */
(function () {
function ComponentView() {
this.group = new Group();
this.uid = getUID("viewComponent");
}
ComponentView.prototype.init = function (ecModel, api) {};
ComponentView.prototype.render = function (
model,
ecModel,
api,
payload,
) {};
ComponentView.prototype.dispose = function (ecModel, api) {};
ComponentView.prototype.updateView = function (
model,
ecModel,
api,
payload,
) {
// Do nothing;
};
ComponentView.prototype.updateLayout = function (
model,
ecModel,
api,
payload,
) {
// Do nothing;
};
ComponentView.prototype.updateVisual = function (
model,
ecModel,
api,
payload,
) {
// Do nothing;
};
/**
* Hook for toggle blur target series.
* Can be used in marker for blur or leave blur the markers
*/
ComponentView.prototype.toggleBlurSeries = function (
seriesModels,
isBlur,
ecModel,
) {
// Do nothing;
};
/**
* Traverse the new rendered elements.
*
* It will traverse the new added element in progressive rendering.
* And traverse all in normal rendering.
*/
ComponentView.prototype.eachRendered = function (cb) {
var group = this.group;
if (group) {
group.traverse(cb);
}
};
return ComponentView;
})();
enableClassExtend(ComponentView);
enableClassManagement(ComponentView);
/**
* @return {string} If large mode changed, return string 'reset';
*/
function createRenderPlanner() {
var inner = makeInner();
return function (seriesModel) {
var fields = inner(seriesModel);
var pipelineContext = seriesModel.pipelineContext;
var originalLarge = !!fields.large;
var originalProgressive = !!fields.progressiveRender; // FIXME: if the planner works on a filtered series, `pipelineContext` does not
// exists. See #11611 . Probably we need to modify this structure, see the comment
// on `performRawSeries` in `Schedular.js`.
var large = (fields.large = !!(pipelineContext && pipelineContext.large));
var progressive = (fields.progressiveRender = !!(
pipelineContext && pipelineContext.progressiveRender
));
return (
!!(originalLarge !== large || originalProgressive !== progressive) &&
"reset"
);
};
}
var inner$2 = makeInner();
var renderPlanner = createRenderPlanner();
var ChartView =
/** @class */
(function () {
function ChartView() {
this.group = new Group();
this.uid = getUID("viewChart");
this.renderTask = createTask({
plan: renderTaskPlan,
reset: renderTaskReset,
});
this.renderTask.context = {
view: this,
};
}
ChartView.prototype.init = function (ecModel, api) {};
ChartView.prototype.render = function (
seriesModel,
ecModel,
api,
payload,
) {
if ("development" !== "production") {
throw new Error("render method must been implemented");
}
};
/**
* Highlight series or specified data item.
*/
ChartView.prototype.highlight = function (
seriesModel,
ecModel,
api,
payload,
) {
var data = seriesModel.getData(payload && payload.dataType);
if (!data) {
if ("development" !== "production") {
error("Unknown dataType " + payload.dataType);
}
return;
}
toggleHighlight(data, payload, "emphasis");
};
/**
* Downplay series or specified data item.
*/
ChartView.prototype.downplay = function (
seriesModel,
ecModel,
api,
payload,
) {
var data = seriesModel.getData(payload && payload.dataType);
if (!data) {
if ("development" !== "production") {
error("Unknown dataType " + payload.dataType);
}
return;
}
toggleHighlight(data, payload, "normal");
};
/**
* Remove self.
*/
ChartView.prototype.remove = function (ecModel, api) {
this.group.removeAll();
};
/**
* Dispose self.
*/
ChartView.prototype.dispose = function (ecModel, api) {};
ChartView.prototype.updateView = function (
seriesModel,
ecModel,
api,
payload,
) {
this.render(seriesModel, ecModel, api, payload);
}; // FIXME never used?
ChartView.prototype.updateLayout = function (
seriesModel,
ecModel,
api,
payload,
) {
this.render(seriesModel, ecModel, api, payload);
}; // FIXME never used?
ChartView.prototype.updateVisual = function (
seriesModel,
ecModel,
api,
payload,
) {
this.render(seriesModel, ecModel, api, payload);
};
/**
* Traverse the new rendered elements.
*
* It will traverse the new added element in progressive rendering.
* And traverse all in normal rendering.
*/
ChartView.prototype.eachRendered = function (cb) {
traverseElements(this.group, cb);
};
ChartView.markUpdateMethod = function (payload, methodName) {
inner$2(payload).updateMethod = methodName;
};
ChartView.protoInitialize = (function () {
var proto = ChartView.prototype;
proto.type = "chart";
})();
return ChartView;
})();
/**
* Set state of single element
*/
function elSetState(el, state, highlightDigit) {
if (el && isHighDownDispatcher(el)) {
(state === "emphasis" ? enterEmphasis : leaveEmphasis)(
el,
highlightDigit,
);
}
}
function toggleHighlight(data, payload, state) {
var dataIndex = queryDataIndex(data, payload);
var highlightDigit =
payload && payload.highlightKey != null
? getHighlightDigit(payload.highlightKey)
: null;
if (dataIndex != null) {
each(normalizeToArray(dataIndex), function (dataIdx) {
elSetState(data.getItemGraphicEl(dataIdx), state, highlightDigit);
});
} else {
data.eachItemGraphicEl(function (el) {
elSetState(el, state, highlightDigit);
});
}
}
enableClassExtend(ChartView, ["dispose"]);
enableClassManagement(ChartView);
function renderTaskPlan(context) {
return renderPlanner(context.model);
}
function renderTaskReset(context) {
var seriesModel = context.model;
var ecModel = context.ecModel;
var api = context.api;
var payload = context.payload; // FIXME: remove updateView updateVisual
var progressiveRender = seriesModel.pipelineContext.progressiveRender;
var view = context.view;
var updateMethod = payload && inner$2(payload).updateMethod;
var methodName = progressiveRender
? "incrementalPrepareRender"
: updateMethod && view[updateMethod]
? updateMethod // `appendData` is also supported when data amount
: // is less than progressive threshold.
"render";
if (methodName !== "render") {
view[methodName](seriesModel, ecModel, api, payload);
}
return progressMethodMap[methodName];
}
var progressMethodMap = {
incrementalPrepareRender: {
progress: function (params, context) {
context.view.incrementalRender(
params,
context.model,
context.ecModel,
context.api,
context.payload,
);
},
},
render: {
// Put view.render in `progress` to support appendData. But in this case
// view.render should not be called in reset, otherwise it will be called
// twise. Use `forceFirstProgress` to make sure that view.render is called
// in any cases.
forceFirstProgress: true,
progress: function (params, context) {
context.view.render(
context.model,
context.ecModel,
context.api,
context.payload,
);
},
},
};
/*
* 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.
*/
var ORIGIN_METHOD = "\0__throttleOriginMethod";
var RATE = "\0__throttleRate";
var THROTTLE_TYPE = "\0__throttleType";
/**
* @public
* @param {(Function)} fn
* @param {number} [delay=0] Unit: ms.
* @param {boolean} [debounce=false]
* true: If call interval less than `delay`, only the last call works.
* false: If call interval less than `delay, call works on fixed rate.
* @return {(Function)} throttled fn.
*/
function throttle(fn, delay, debounce) {
var currCall;
var lastCall = 0;
var lastExec = 0;
var timer = null;
var diff;
var scope;
var args;
var debounceNextCall;
delay = delay || 0;
function exec() {
lastExec = new Date().getTime();
timer = null;
fn.apply(scope, args || []);
}
var cb = function () {
var cbArgs = [];
for (var _i = 0; _i < arguments.length; _i++) {
cbArgs[_i] = arguments[_i];
}
currCall = new Date().getTime();
scope = this;
args = cbArgs;
var thisDelay = debounceNextCall || delay;
var thisDebounce = debounceNextCall || debounce;
debounceNextCall = null;
diff = currCall - (thisDebounce ? lastCall : lastExec) - thisDelay;
clearTimeout(timer); // Here we should make sure that: the `exec` SHOULD NOT be called later
// than a new call of `cb`, that is, preserving the command order. Consider
// calculating "scale rate" when roaming as an example. When a call of `cb`
// happens, either the `exec` is called dierectly, or the call is delayed.
// But the delayed call should never be later than next call of `cb`. Under
// this assurance, we can simply update view state each time `dispatchAction`
// triggered by user roaming, but not need to add extra code to avoid the
// state being "rolled-back".
if (thisDebounce) {
timer = setTimeout(exec, thisDelay);
} else {
if (diff >= 0) {
exec();
} else {
timer = setTimeout(exec, -diff);
}
}
lastCall = currCall;
};
/**
* Clear throttle.
* @public
*/
cb.clear = function () {
if (timer) {
clearTimeout(timer);
timer = null;
}
};
/**
* Enable debounce once.
*/
cb.debounceNextCall = function (debounceDelay) {
debounceNextCall = debounceDelay;
};
return cb;
}
/**
* Create throttle method or update throttle rate.
*
* @example
* ComponentView.prototype.render = function () {
* ...
* throttle.createOrUpdate(
* this,
* '_dispatchAction',
* this.model.get('throttle'),
* 'fixRate'
* );
* };
* ComponentView.prototype.remove = function () {
* throttle.clear(this, '_dispatchAction');
* };
* ComponentView.prototype.dispose = function () {
* throttle.clear(this, '_dispatchAction');
* };
*
*/
function createOrUpdate(obj, fnAttr, rate, throttleType) {
var fn = obj[fnAttr];
if (!fn) {
return;
}
var originFn = fn[ORIGIN_METHOD] || fn;
var lastThrottleType = fn[THROTTLE_TYPE];
var lastRate = fn[RATE];
if (lastRate !== rate || lastThrottleType !== throttleType) {
if (rate == null || !throttleType) {
return (obj[fnAttr] = originFn);
}
fn = obj[fnAttr] = throttle(originFn, rate, throttleType === "debounce");
fn[ORIGIN_METHOD] = originFn;
fn[THROTTLE_TYPE] = throttleType;
fn[RATE] = rate;
}
return fn;
}
/**
* Clear throttle. Example see throttle.createOrUpdate.
*/
function clear(obj, fnAttr) {
var fn = obj[fnAttr];
if (fn && fn[ORIGIN_METHOD]) {
// Clear throttle
fn.clear && fn.clear();
obj[fnAttr] = fn[ORIGIN_METHOD];
}
}
var inner$3 = makeInner();
var defaultStyleMappers = {
itemStyle: makeStyleMapper(ITEM_STYLE_KEY_MAP, true),
lineStyle: makeStyleMapper(LINE_STYLE_KEY_MAP, true),
};
var defaultColorKey = {
lineStyle: "stroke",
itemStyle: "fill",
};
function getStyleMapper(seriesModel, stylePath) {
var styleMapper =
seriesModel.visualStyleMapper || defaultStyleMappers[stylePath];
if (!styleMapper) {
console.warn("Unkown style type '" + stylePath + "'.");
return defaultStyleMappers.itemStyle;
}
return styleMapper;
}
function getDefaultColorKey(seriesModel, stylePath) {
// return defaultColorKey[stylePath] ||
var colorKey = seriesModel.visualDrawType || defaultColorKey[stylePath];
if (!colorKey) {
console.warn("Unkown style type '" + stylePath + "'.");
return "fill";
}
return colorKey;
}
var seriesStyleTask = {
createOnAllSeries: true,
performRawSeries: true,
reset: function (seriesModel, ecModel) {
var data = seriesModel.getData();
var stylePath = seriesModel.visualStyleAccessPath || "itemStyle"; // Set in itemStyle
var styleModel = seriesModel.getModel(stylePath);
var getStyle = getStyleMapper(seriesModel, stylePath);
var globalStyle = getStyle(styleModel);
var decalOption = styleModel.getShallow("decal");
if (decalOption) {
data.setVisual("decal", decalOption);
decalOption.dirty = true;
} // TODO
var colorKey = getDefaultColorKey(seriesModel, stylePath);
var color = globalStyle[colorKey]; // TODO style callback
var colorCallback = isFunction(color) ? color : null;
var hasAutoColor =
globalStyle.fill === "auto" || globalStyle.stroke === "auto"; // Get from color palette by default.
if (!globalStyle[colorKey] || colorCallback || hasAutoColor) {
// Note: if some series has color specified (e.g., by itemStyle.color), we DO NOT
// make it effect palette. Bacause some scenarios users need to make some series
// transparent or as background, which should better not effect the palette.
var colorPalette = seriesModel.getColorFromPalette(
// TODO series count changed.
seriesModel.name,
null,
ecModel.getSeriesCount(),
);
if (!globalStyle[colorKey]) {
globalStyle[colorKey] = colorPalette;
data.setVisual("colorFromPalette", true);
}
globalStyle.fill =
globalStyle.fill === "auto" || isFunction(globalStyle.fill)
? colorPalette
: globalStyle.fill;
globalStyle.stroke =
globalStyle.stroke === "auto" || isFunction(globalStyle.stroke)
? colorPalette
: globalStyle.stroke;
}
data.setVisual("style", globalStyle);
data.setVisual("drawType", colorKey); // Only visible series has each data be visual encoded
if (!ecModel.isSeriesFiltered(seriesModel) && colorCallback) {
data.setVisual("colorFromPalette", false);
return {
dataEach: function (data, idx) {
var dataParams = seriesModel.getDataParams(idx);
var itemStyle = extend({}, globalStyle);
itemStyle[colorKey] = colorCallback(dataParams);
data.setItemVisual(idx, "style", itemStyle);
},
};
}
},
};
var sharedModel = new Model();
var dataStyleTask = {
createOnAllSeries: true,
performRawSeries: true,
reset: function (seriesModel, ecModel) {
if (
seriesModel.ignoreStyleOnData ||
ecModel.isSeriesFiltered(seriesModel)
) {
return;
}
var data = seriesModel.getData();
var stylePath = seriesModel.visualStyleAccessPath || "itemStyle"; // Set in itemStyle
var getStyle = getStyleMapper(seriesModel, stylePath);
var colorKey = data.getVisual("drawType");
return {
dataEach: data.hasItemOption
? function (data, idx) {
// Not use getItemModel for performance considuration
var rawItem = data.getRawDataItem(idx);
if (rawItem && rawItem[stylePath]) {
sharedModel.option = rawItem[stylePath];
var style = getStyle(sharedModel);
var existsStyle = data.ensureUniqueItemVisual(idx, "style");
extend(existsStyle, style);
if (sharedModel.option.decal) {
data.setItemVisual(idx, "decal", sharedModel.option.decal);
sharedModel.option.decal.dirty = true;
}
if (colorKey in style) {
data.setItemVisual(idx, "colorFromPalette", false);
}
}
}
: null,
};
},
}; // Pick color from palette for the data which has not been set with color yet.
// Note: do not support stream rendering. No such cases yet.
var dataColorPaletteTask = {
performRawSeries: true,
overallReset: function (ecModel) {
// Each type of series use one scope.
// Pie and funnel are using diferrent scopes
var paletteScopeGroupByType = createHashMap();
ecModel.eachSeries(function (seriesModel) {
var colorBy = seriesModel.getColorBy();
if (seriesModel.isColorBySeries()) {
return;
}
var key = seriesModel.type + "-" + colorBy;
var colorScope = paletteScopeGroupByType.get(key);
if (!colorScope) {
colorScope = {};
paletteScopeGroupByType.set(key, colorScope);
}
inner$3(seriesModel).scope = colorScope;
});
ecModel.eachSeries(function (seriesModel) {
if (
seriesModel.isColorBySeries() ||
ecModel.isSeriesFiltered(seriesModel)
) {
return;
}
var dataAll = seriesModel.getRawData();
var idxMap = {};
var data = seriesModel.getData();
var colorScope = inner$3(seriesModel).scope;
var stylePath = seriesModel.visualStyleAccessPath || "itemStyle";
var colorKey = getDefaultColorKey(seriesModel, stylePath);
data.each(function (idx) {
var rawIdx = data.getRawIndex(idx);
idxMap[rawIdx] = idx;
}); // Iterate on data before filtered. To make sure color from palette can be
// Consistent when toggling legend.
dataAll.each(function (rawIdx) {
var idx = idxMap[rawIdx];
var fromPalette = data.getItemVisual(idx, "colorFromPalette"); // Get color from palette for each data only when the color is inherited from series color, which is
// also picked from color palette. So following situation is not in the case:
// 1. series.itemStyle.color is set
// 2. color is encoded by visualMap
if (fromPalette) {
var itemStyle = data.ensureUniqueItemVisual(idx, "style");
var name_1 = dataAll.getName(rawIdx) || rawIdx + "";
var dataCount = dataAll.count();
itemStyle[colorKey] = seriesModel.getColorFromPalette(
name_1,
colorScope,
dataCount,
);
}
});
});
},
};
var PI$3 = Math.PI;
/**
* @param {module:echarts/ExtensionAPI} api
* @param {Object} [opts]
* @param {string} [opts.text]
* @param {string} [opts.color]
* @param {string} [opts.textColor]
* @return {module:zrender/Element}
*/
function defaultLoading(api, opts) {
opts = opts || {};
defaults(opts, {
text: "loading",
textColor: "#000",
fontSize: 12,
fontWeight: "normal",
fontStyle: "normal",
fontFamily: "sans-serif",
maskColor: "rgba(255, 255, 255, 0.8)",
showSpinner: true,
color: "#5470c6",
spinnerRadius: 10,
lineWidth: 5,
zlevel: 0,
});
var group = new Group();
var mask = new Rect({
style: {
fill: opts.maskColor,
},
zlevel: opts.zlevel,
z: 10000,
});
group.add(mask);
var textContent = new ZRText({
style: {
text: opts.text,
fill: opts.textColor,
fontSize: opts.fontSize,
fontWeight: opts.fontWeight,
fontStyle: opts.fontStyle,
fontFamily: opts.fontFamily,
},
zlevel: opts.zlevel,
z: 10001,
});
var labelRect = new Rect({
style: {
fill: "none",
},
textContent: textContent,
textConfig: {
position: "right",
distance: 10,
},
zlevel: opts.zlevel,
z: 10001,
});
group.add(labelRect);
var arc;
if (opts.showSpinner) {
arc = new Arc({
shape: {
startAngle: -PI$3 / 2,
endAngle: -PI$3 / 2 + 0.1,
r: opts.spinnerRadius,
},
style: {
stroke: opts.color,
lineCap: "round",
lineWidth: opts.lineWidth,
},
zlevel: opts.zlevel,
z: 10001,
});
arc
.animateShape(true)
.when(1000, {
endAngle: (PI$3 * 3) / 2,
})
.start("circularInOut");
arc
.animateShape(true)
.when(1000, {
startAngle: (PI$3 * 3) / 2,
})
.delay(300)
.start("circularInOut");
group.add(arc);
} // Inject resize
group.resize = function () {
var textWidth = textContent.getBoundingRect().width;
var r = opts.showSpinner ? opts.spinnerRadius : 0; // cx = (containerWidth - arcDiameter - textDistance - textWidth) / 2
// textDistance needs to be calculated when both animation and text exist
var cx =
(api.getWidth() -
r * 2 -
(opts.showSpinner && textWidth ? 10 : 0) -
textWidth) /
2 -
(opts.showSpinner && textWidth ? 0 : 5 + textWidth / 2) + // only show the text
(opts.showSpinner ? 0 : textWidth / 2) + // only show the spinner
(textWidth ? 0 : r);
var cy = api.getHeight() / 2;
opts.showSpinner &&
arc.setShape({
cx: cx,
cy: cy,
});
labelRect.setShape({
x: cx - r,
y: cy - r,
width: r * 2,
height: r * 2,
});
mask.setShape({
x: 0,
y: 0,
width: api.getWidth(),
height: api.getHeight(),
});
};
group.resize();
return group;
}
var Scheduler =
/** @class */
(function () {
function Scheduler(
ecInstance,
api,
dataProcessorHandlers,
visualHandlers,
) {
// key: handlerUID
this._stageTaskMap = createHashMap();
this.ecInstance = ecInstance;
this.api = api; // Fix current processors in case that in some rear cases that
// processors might be registered after echarts instance created.
// Register processors incrementally for a echarts instance is
// not supported by this stream architecture.
dataProcessorHandlers = this._dataProcessorHandlers =
dataProcessorHandlers.slice();
visualHandlers = this._visualHandlers = visualHandlers.slice();
this._allHandlers = dataProcessorHandlers.concat(visualHandlers);
}
Scheduler.prototype.restoreData = function (ecModel, payload) {
// TODO: Only restore needed series and components, but not all components.
// Currently `restoreData` of all of the series and component will be called.
// But some independent components like `title`, `legend`, `graphic`, `toolbox`,
// `tooltip`, `axisPointer`, etc, do not need series refresh when `setOption`,
// and some components like coordinate system, axes, dataZoom, visualMap only
// need their target series refresh.
// (1) If we are implementing this feature some day, we should consider these cases:
// if a data processor depends on a component (e.g., dataZoomProcessor depends
// on the settings of `dataZoom`), it should be re-performed if the component
// is modified by `setOption`.
// (2) If a processor depends on sevral series, speicified by its `getTargetSeries`,
// it should be re-performed when the result array of `getTargetSeries` changed.
// We use `dependencies` to cover these issues.
// (3) How to update target series when coordinate system related components modified.
// TODO: simply the dirty mechanism? Check whether only the case here can set tasks dirty,
// and this case all of the tasks will be set as dirty.
ecModel.restoreData(payload); // Theoretically an overall task not only depends on each of its target series, but also
// depends on all of the series.
// The overall task is not in pipeline, and `ecModel.restoreData` only set pipeline tasks
// dirty. If `getTargetSeries` of an overall task returns nothing, we should also ensure
// that the overall task is set as dirty and to be performed, otherwise it probably cause
// state chaos. So we have to set dirty of all of the overall tasks manually, otherwise it
// probably cause state chaos (consider `dataZoomProcessor`).
this._stageTaskMap.each(function (taskRecord) {
var overallTask = taskRecord.overallTask;
overallTask && overallTask.dirty();
});
}; // If seriesModel provided, incremental threshold is check by series data.
Scheduler.prototype.getPerformArgs = function (task, isBlock) {
// For overall task
if (!task.__pipeline) {
return;
}
var pipeline = this._pipelineMap.get(task.__pipeline.id);
var pCtx = pipeline.context;
var incremental =
!isBlock &&
pipeline.progressiveEnabled &&
(!pCtx || pCtx.progressiveRender) &&
task.__idxInPipeline > pipeline.blockIndex;
var step = incremental ? pipeline.step : null;
var modDataCount = pCtx && pCtx.modDataCount;
var modBy =
modDataCount != null ? Math.ceil(modDataCount / step) : null;
return {
step: step,
modBy: modBy,
modDataCount: modDataCount,
};
};
Scheduler.prototype.getPipeline = function (pipelineId) {
return this._pipelineMap.get(pipelineId);
};
/**
* Current, progressive rendering starts from visual and layout.
* Always detect render mode in the same stage, avoiding that incorrect
* detection caused by data filtering.
* Caution:
* `updateStreamModes` use `seriesModel.getData()`.
*/
Scheduler.prototype.updateStreamModes = function (seriesModel, view) {
var pipeline = this._pipelineMap.get(seriesModel.uid);
var data = seriesModel.getData();
var dataLen = data.count(); // `progressiveRender` means that can render progressively in each
// animation frame. Note that some types of series do not provide
// `view.incrementalPrepareRender` but support `chart.appendData`. We
// use the term `incremental` but not `progressive` to describe the
// case that `chart.appendData`.
var progressiveRender =
pipeline.progressiveEnabled &&
view.incrementalPrepareRender &&
dataLen >= pipeline.threshold;
var large =
seriesModel.get("large") &&
dataLen >= seriesModel.get("largeThreshold"); // TODO: modDataCount should not updated if `appendData`, otherwise cause whole repaint.
// see `test/candlestick-large3.html`
var modDataCount =
seriesModel.get("progressiveChunkMode") === "mod" ? dataLen : null;
seriesModel.pipelineContext = pipeline.context = {
progressiveRender: progressiveRender,
modDataCount: modDataCount,
large: large,
};
};
Scheduler.prototype.restorePipelines = function (ecModel) {
var scheduler = this;
var pipelineMap = (scheduler._pipelineMap = createHashMap());
ecModel.eachSeries(function (seriesModel) {
var progressive = seriesModel.getProgressive();
var pipelineId = seriesModel.uid;
pipelineMap.set(pipelineId, {
id: pipelineId,
head: null,
tail: null,
threshold: seriesModel.getProgressiveThreshold(),
progressiveEnabled:
progressive &&
!(
seriesModel.preventIncremental &&
seriesModel.preventIncremental()
),
blockIndex: -1,
step: Math.round(progressive || 700),
count: 0,
});
scheduler._pipe(seriesModel, seriesModel.dataTask);
});
};
Scheduler.prototype.prepareStageTasks = function () {
var stageTaskMap = this._stageTaskMap;
var ecModel = this.api.getModel();
var api = this.api;
each(
this._allHandlers,
function (handler) {
var record =
stageTaskMap.get(handler.uid) ||
stageTaskMap.set(handler.uid, {});
var errMsg = "";
if ("development" !== "production") {
// Currently do not need to support to sepecify them both.
errMsg = '"reset" and "overallReset" must not be both specified.';
}
assert(!(handler.reset && handler.overallReset), errMsg);
handler.reset &&
this._createSeriesStageTask(handler, record, ecModel, api);
handler.overallReset &&
this._createOverallStageTask(handler, record, ecModel, api);
},
this,
);
};
Scheduler.prototype.prepareView = function (view, model, ecModel, api) {
var renderTask = view.renderTask;
var context = renderTask.context;
context.model = model;
context.ecModel = ecModel;
context.api = api;
renderTask.__block = !view.incrementalPrepareRender;
this._pipe(model, renderTask);
};
Scheduler.prototype.performDataProcessorTasks = function (
ecModel,
payload,
) {
// If we do not use `block` here, it should be considered when to update modes.
this._performStageTasks(this._dataProcessorHandlers, ecModel, payload, {
block: true,
});
};
Scheduler.prototype.performVisualTasks = function (
ecModel,
payload,
opt,
) {
this._performStageTasks(this._visualHandlers, ecModel, payload, opt);
};
Scheduler.prototype._performStageTasks = function (
stageHandlers,
ecModel,
payload,
opt,
) {
opt = opt || {};
var unfinished = false;
var scheduler = this;
each(stageHandlers, function (stageHandler, idx) {
if (opt.visualType && opt.visualType !== stageHandler.visualType) {
return;
}
var stageHandlerRecord = scheduler._stageTaskMap.get(
stageHandler.uid,
);
var seriesTaskMap = stageHandlerRecord.seriesTaskMap;
var overallTask = stageHandlerRecord.overallTask;
if (overallTask) {
var overallNeedDirty_1;
var agentStubMap = overallTask.agentStubMap;
agentStubMap.each(function (stub) {
if (needSetDirty(opt, stub)) {
stub.dirty();
overallNeedDirty_1 = true;
}
});
overallNeedDirty_1 && overallTask.dirty();
scheduler.updatePayload(overallTask, payload);
var performArgs_1 = scheduler.getPerformArgs(
overallTask,
opt.block,
); // Execute stubs firstly, which may set the overall task dirty,
// then execute the overall task. And stub will call seriesModel.setData,
// which ensures that in the overallTask seriesModel.getData() will not
// return incorrect data.
agentStubMap.each(function (stub) {
stub.perform(performArgs_1);
});
if (overallTask.perform(performArgs_1)) {
unfinished = true;
}
} else if (seriesTaskMap) {
seriesTaskMap.each(function (task, pipelineId) {
if (needSetDirty(opt, task)) {
task.dirty();
}
var performArgs = scheduler.getPerformArgs(task, opt.block); // FIXME
// if intending to decalare `performRawSeries` in handlers, only
// stream-independent (specifically, data item independent) operations can be
// performed. Because is a series is filtered, most of the tasks will not
// be performed. A stream-dependent operation probably cause wrong biz logic.
// Perhaps we should not provide a separate callback for this case instead
// of providing the config `performRawSeries`. The stream-dependent operaions
// and stream-independent operations should better not be mixed.
performArgs.skip =
!stageHandler.performRawSeries &&
ecModel.isSeriesFiltered(task.context.model);
scheduler.updatePayload(task, payload);
if (task.perform(performArgs)) {
unfinished = true;
}
});
}
});
function needSetDirty(opt, task) {
return (
opt.setDirty &&
(!opt.dirtyMap || opt.dirtyMap.get(task.__pipeline.id))
);
}
this.unfinished = unfinished || this.unfinished;
};
Scheduler.prototype.performSeriesTasks = function (ecModel) {
var unfinished;
ecModel.eachSeries(function (seriesModel) {
// Progress to the end for dataInit and dataRestore.
unfinished = seriesModel.dataTask.perform() || unfinished;
});
this.unfinished = unfinished || this.unfinished;
};
Scheduler.prototype.plan = function () {
// Travel pipelines, check block.
this._pipelineMap.each(function (pipeline) {
var task = pipeline.tail;
do {
if (task.__block) {
pipeline.blockIndex = task.__idxInPipeline;
break;
}
task = task.getUpstream();
} while (task);
});
};
Scheduler.prototype.updatePayload = function (task, payload) {
payload !== "remain" && (task.context.payload = payload);
};
Scheduler.prototype._createSeriesStageTask = function (
stageHandler,
stageHandlerRecord,
ecModel,
api,
) {
var scheduler = this;
var oldSeriesTaskMap = stageHandlerRecord.seriesTaskMap; // The count of stages are totally about only several dozen, so
// do not need to reuse the map.
var newSeriesTaskMap = (stageHandlerRecord.seriesTaskMap =
createHashMap());
var seriesType = stageHandler.seriesType;
var getTargetSeries = stageHandler.getTargetSeries; // If a stageHandler should cover all series, `createOnAllSeries` should be declared mandatorily,
// to avoid some typo or abuse. Otherwise if an extension do not specify a `seriesType`,
// it works but it may cause other irrelevant charts blocked.
if (stageHandler.createOnAllSeries) {
ecModel.eachRawSeries(create);
} else if (seriesType) {
ecModel.eachRawSeriesByType(seriesType, create);
} else if (getTargetSeries) {
getTargetSeries(ecModel, api).each(create);
}
function create(seriesModel) {
var pipelineId = seriesModel.uid; // Init tasks for each seriesModel only once.
// Reuse original task instance.
var task = newSeriesTaskMap.set(
pipelineId,
(oldSeriesTaskMap && oldSeriesTaskMap.get(pipelineId)) ||
createTask({
plan: seriesTaskPlan,
reset: seriesTaskReset,
count: seriesTaskCount,
}),
);
task.context = {
model: seriesModel,
ecModel: ecModel,
api: api,
// PENDING: `useClearVisual` not used?
useClearVisual: stageHandler.isVisual && !stageHandler.isLayout,
plan: stageHandler.plan,
reset: stageHandler.reset,
scheduler: scheduler,
};
scheduler._pipe(seriesModel, task);
}
};
Scheduler.prototype._createOverallStageTask = function (
stageHandler,
stageHandlerRecord,
ecModel,
api,
) {
var scheduler = this;
var overallTask = (stageHandlerRecord.overallTask =
stageHandlerRecord.overallTask || // For overall task, the function only be called on reset stage.
createTask({
reset: overallTaskReset,
}));
overallTask.context = {
ecModel: ecModel,
api: api,
overallReset: stageHandler.overallReset,
scheduler: scheduler,
};
var oldAgentStubMap = overallTask.agentStubMap; // The count of stages are totally about only several dozen, so
// do not need to reuse the map.
var newAgentStubMap = (overallTask.agentStubMap = createHashMap());
var seriesType = stageHandler.seriesType;
var getTargetSeries = stageHandler.getTargetSeries;
var overallProgress = true;
var shouldOverallTaskDirty = false; // FIXME:TS never used, so comment it
// let modifyOutputEnd = stageHandler.modifyOutputEnd;
// An overall task with seriesType detected or has `getTargetSeries`, we add
// stub in each pipelines, it will set the overall task dirty when the pipeline
// progress. Moreover, to avoid call the overall task each frame (too frequent),
// we set the pipeline block.
var errMsg = "";
if ("development" !== "production") {
errMsg =
'"createOnAllSeries" do not supported for "overallReset", ' +
"becuase it will block all streams.";
}
assert(!stageHandler.createOnAllSeries, errMsg);
if (seriesType) {
ecModel.eachRawSeriesByType(seriesType, createStub);
} else if (getTargetSeries) {
getTargetSeries(ecModel, api).each(createStub);
} // Otherwise, (usually it is legancy case), the overall task will only be
// executed when upstream dirty. Otherwise the progressive rendering of all
// pipelines will be disabled unexpectedly. But it still needs stubs to receive
// dirty info from upsteam.
else {
overallProgress = false;
each(ecModel.getSeries(), createStub);
}
function createStub(seriesModel) {
var pipelineId = seriesModel.uid;
var stub = newAgentStubMap.set(
pipelineId,
(oldAgentStubMap && oldAgentStubMap.get(pipelineId)) || // When the result of `getTargetSeries` changed, the overallTask
// should be set as dirty and re-performed.
((shouldOverallTaskDirty = true),
createTask({
reset: stubReset,
onDirty: stubOnDirty,
})),
);
stub.context = {
model: seriesModel,
overallProgress: overallProgress, // FIXME:TS never used, so comment it
// modifyOutputEnd: modifyOutputEnd
};
stub.agent = overallTask;
stub.__block = overallProgress;
scheduler._pipe(seriesModel, stub);
}
if (shouldOverallTaskDirty) {
overallTask.dirty();
}
};
Scheduler.prototype._pipe = function (seriesModel, task) {
var pipelineId = seriesModel.uid;
var pipeline = this._pipelineMap.get(pipelineId);
!pipeline.head && (pipeline.head = task);
pipeline.tail && pipeline.tail.pipe(task);
pipeline.tail = task;
task.__idxInPipeline = pipeline.count++;
task.__pipeline = pipeline;
};
Scheduler.wrapStageHandler = function (stageHandler, visualType) {
if (isFunction(stageHandler)) {
stageHandler = {
overallReset: stageHandler,
seriesType: detectSeriseType(stageHandler),
};
}
stageHandler.uid = getUID("stageHandler");
visualType && (stageHandler.visualType = visualType);
return stageHandler;
};
return Scheduler;
})();
function overallTaskReset(context) {
context.overallReset(context.ecModel, context.api, context.payload);
}
function stubReset(context) {
return context.overallProgress && stubProgress;
}
function stubProgress() {
this.agent.dirty();
this.getDownstream().dirty();
}
function stubOnDirty() {
this.agent && this.agent.dirty();
}
function seriesTaskPlan(context) {
return context.plan
? context.plan(
context.model,
context.ecModel,
context.api,
context.payload,
)
: null;
}
function seriesTaskReset(context) {
if (context.useClearVisual) {
context.data.clearAllVisual();
}
var resetDefines = (context.resetDefines = normalizeToArray(
context.reset(
context.model,
context.ecModel,
context.api,
context.payload,
),
));
return resetDefines.length > 1
? map(resetDefines, function (v, idx) {
return makeSeriesTaskProgress(idx);
})
: singleSeriesTaskProgress;
}
var singleSeriesTaskProgress = makeSeriesTaskProgress(0);
function makeSeriesTaskProgress(resetDefineIdx) {
return function (params, context) {
var data = context.data;
var resetDefine = context.resetDefines[resetDefineIdx];
if (resetDefine && resetDefine.dataEach) {
for (var i = params.start; i < params.end; i++) {
resetDefine.dataEach(data, i);
}
} else if (resetDefine && resetDefine.progress) {
resetDefine.progress(params, data);
}
};
}
function seriesTaskCount(context) {
return context.data.count();
}
/**
* Only some legacy stage handlers (usually in echarts extensions) are pure function.
* To ensure that they can work normally, they should work in block mode, that is,
* they should not be started util the previous tasks finished. So they cause the
* progressive rendering disabled. We try to detect the series type, to narrow down
* the block range to only the series type they concern, but not all series.
*/
function detectSeriseType(legacyFunc) {
seriesType = null;
try {
// Assume there is no async when calling `eachSeriesByType`.
legacyFunc(ecModelMock, apiMock);
} catch (e) {}
return seriesType;
}
var ecModelMock = {};
var apiMock = {};
var seriesType;
mockMethods(ecModelMock, GlobalModel);
mockMethods(apiMock, ExtensionAPI);
ecModelMock.eachSeriesByType = ecModelMock.eachRawSeriesByType = function (
type,
) {
seriesType = type;
};
ecModelMock.eachComponent = function (cond) {
if (cond.mainType === "series" && cond.subType) {
seriesType = cond.subType;
}
};
function mockMethods(target, Clz) {
/* eslint-disable */
for (var name_1 in Clz.prototype) {
// Do not use hasOwnProperty
target[name_1] = noop;
}
/* eslint-enable */
}
/*
* 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.
*/
var colorAll = [
"#37A2DA",
"#32C5E9",
"#67E0E3",
"#9FE6B8",
"#FFDB5C",
"#ff9f7f",
"#fb7293",
"#E062AE",
"#E690D1",
"#e7bcf3",
"#9d96f5",
"#8378EA",
"#96BFFF",
];
var lightTheme = {
color: colorAll,
colorLayer: [
["#37A2DA", "#ffd85c", "#fd7b5f"],
["#37A2DA", "#67E0E3", "#FFDB5C", "#ff9f7f", "#E062AE", "#9d96f5"],
[
"#37A2DA",
"#32C5E9",
"#9FE6B8",
"#FFDB5C",
"#ff9f7f",
"#fb7293",
"#e7bcf3",
"#8378EA",
"#96BFFF",
],
colorAll,
],
};
/*
* 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.
*/
var contrastColor = "#B9B8CE";
var backgroundColor = "#100C2A";
var axisCommon = function () {
return {
axisLine: {
lineStyle: {
color: contrastColor,
},
},
splitLine: {
lineStyle: {
color: "#484753",
},
},
splitArea: {
areaStyle: {
color: ["rgba(255,255,255,0.02)", "rgba(255,255,255,0.05)"],
},
},
minorSplitLine: {
lineStyle: {
color: "#20203B",
},
},
};
};
var colorPalette = [
"#4992ff",
"#7cffb2",
"#fddd60",
"#ff6e76",
"#58d9f9",
"#05c091",
"#ff8a45",
"#8d48e3",
"#dd79ff",
];
var theme = {
darkMode: true,
color: colorPalette,
backgroundColor: backgroundColor,
axisPointer: {
lineStyle: {
color: "#817f91",
},
crossStyle: {
color: "#817f91",
},
label: {
// TODO Contrast of label backgorundColor
color: "#fff",
},
},
legend: {
textStyle: {
color: contrastColor,
},
},
textStyle: {
color: contrastColor,
},
title: {
textStyle: {
color: "#EEF1FA",
},
subtextStyle: {
color: "#B9B8CE",
},
},
toolbox: {
iconStyle: {
borderColor: contrastColor,
},
},
dataZoom: {
borderColor: "#71708A",
textStyle: {
color: contrastColor,
},
brushStyle: {
color: "rgba(135,163,206,0.3)",
},
handleStyle: {
color: "#353450",
borderColor: "#C5CBE3",
},
moveHandleStyle: {
color: "#B0B6C3",
opacity: 0.3,
},
fillerColor: "rgba(135,163,206,0.2)",
emphasis: {
handleStyle: {
borderColor: "#91B7F2",
color: "#4D587D",
},
moveHandleStyle: {
color: "#636D9A",
opacity: 0.7,
},
},
dataBackground: {
lineStyle: {
color: "#71708A",
width: 1,
},
areaStyle: {
color: "#71708A",
},
},
selectedDataBackground: {
lineStyle: {
color: "#87A3CE",
},
areaStyle: {
color: "#87A3CE",
},
},
},
visualMap: {
textStyle: {
color: contrastColor,
},
},
timeline: {
lineStyle: {
color: contrastColor,
},
label: {
color: contrastColor,
},
controlStyle: {
color: contrastColor,
borderColor: contrastColor,
},
},
calendar: {
itemStyle: {
color: backgroundColor,
},
dayLabel: {
color: contrastColor,
},
monthLabel: {
color: contrastColor,
},
yearLabel: {
color: contrastColor,
},
},
timeAxis: axisCommon(),
logAxis: axisCommon(),
valueAxis: axisCommon(),
categoryAxis: axisCommon(),
line: {
symbol: "circle",
},
graph: {
color: colorPalette,
},
gauge: {
title: {
color: contrastColor,
},
axisLine: {
lineStyle: {
color: [[1, "rgba(207,212,219,0.2)"]],
},
},
axisLabel: {
color: contrastColor,
},
detail: {
color: "#EEF1FA",
},
},
candlestick: {
itemStyle: {
color: "#f64e56",
color0: "#54ea92",
borderColor: "#f64e56",
borderColor0: "#54ea92", // borderColor: '#ca2824',
// borderColor0: '#09a443'
},
},
};
theme.categoryAxis.splitLine.show = false;
/**
* Usage of query:
* `chart.on('click', query, handler);`
* The `query` can be:
* + The component type query string, only `mainType` or `mainType.subType`,
* like: 'xAxis', 'series', 'xAxis.category' or 'series.line'.
* + The component query object, like:
* `{seriesIndex: 2}`, `{seriesName: 'xx'}`, `{seriesId: 'some'}`,
* `{xAxisIndex: 2}`, `{xAxisName: 'xx'}`, `{xAxisId: 'some'}`.
* + The data query object, like:
* `{dataIndex: 123}`, `{dataType: 'link'}`, `{name: 'some'}`.
* + The other query object (cmponent customized query), like:
* `{element: 'some'}` (only available in custom series).
*
* Caveat: If a prop in the `query` object is `null/undefined`, it is the
* same as there is no such prop in the `query` object.
*/
var ECEventProcessor =
/** @class */
(function () {
function ECEventProcessor() {}
ECEventProcessor.prototype.normalizeQuery = function (query) {
var cptQuery = {};
var dataQuery = {};
var otherQuery = {}; // `query` is `mainType` or `mainType.subType` of component.
if (isString(query)) {
var condCptType = parseClassType(query); // `.main` and `.sub` may be ''.
cptQuery.mainType = condCptType.main || null;
cptQuery.subType = condCptType.sub || null;
} // `query` is an object, convert to {mainType, index, name, id}.
else {
// `xxxIndex`, `xxxName`, `xxxId`, `name`, `dataIndex`, `dataType` is reserved,
// can not be used in `compomentModel.filterForExposedEvent`.
var suffixes_1 = ["Index", "Name", "Id"];
var dataKeys_1 = {
name: 1,
dataIndex: 1,
dataType: 1,
};
each(query, function (val, key) {
var reserved = false;
for (var i = 0; i < suffixes_1.length; i++) {
var propSuffix = suffixes_1[i];
var suffixPos = key.lastIndexOf(propSuffix);
if (
suffixPos > 0 &&
suffixPos === key.length - propSuffix.length
) {
var mainType = key.slice(0, suffixPos); // Consider `dataIndex`.
if (mainType !== "data") {
cptQuery.mainType = mainType;
cptQuery[propSuffix.toLowerCase()] = val;
reserved = true;
}
}
}
if (dataKeys_1.hasOwnProperty(key)) {
dataQuery[key] = val;
reserved = true;
}
if (!reserved) {
otherQuery[key] = val;
}
});
}
return {
cptQuery: cptQuery,
dataQuery: dataQuery,
otherQuery: otherQuery,
};
};
ECEventProcessor.prototype.filter = function (eventType, query) {
// They should be assigned before each trigger call.
var eventInfo = this.eventInfo;
if (!eventInfo) {
return true;
}
var targetEl = eventInfo.targetEl;
var packedEvent = eventInfo.packedEvent;
var model = eventInfo.model;
var view = eventInfo.view; // For event like 'globalout'.
if (!model || !view) {
return true;
}
var cptQuery = query.cptQuery;
var dataQuery = query.dataQuery;
return (
check(cptQuery, model, "mainType") &&
check(cptQuery, model, "subType") &&
check(cptQuery, model, "index", "componentIndex") &&
check(cptQuery, model, "name") &&
check(cptQuery, model, "id") &&
check(dataQuery, packedEvent, "name") &&
check(dataQuery, packedEvent, "dataIndex") &&
check(dataQuery, packedEvent, "dataType") &&
(!view.filterForExposedEvent ||
view.filterForExposedEvent(
eventType,
query.otherQuery,
targetEl,
packedEvent,
))
);
function check(query, host, prop, propOnHost) {
return (
query[prop] == null || host[propOnHost || prop] === query[prop]
);
}
};
ECEventProcessor.prototype.afterTrigger = function () {
// Make sure the eventInfo wont be used in next trigger.
this.eventInfo = null;
};
return ECEventProcessor;
})();
var SYMBOL_PROPS_WITH_CB = [
"symbol",
"symbolSize",
"symbolRotate",
"symbolOffset",
];
var SYMBOL_PROPS = SYMBOL_PROPS_WITH_CB.concat(["symbolKeepAspect"]); // Encoding visual for all series include which is filtered for legend drawing
var seriesSymbolTask = {
createOnAllSeries: true,
// For legend.
performRawSeries: true,
reset: function (seriesModel, ecModel) {
var data = seriesModel.getData();
if (seriesModel.legendIcon) {
data.setVisual("legendIcon", seriesModel.legendIcon);
}
if (!seriesModel.hasSymbolVisual) {
return;
}
var symbolOptions = {};
var symbolOptionsCb = {};
var hasCallback = false;
for (var i = 0; i < SYMBOL_PROPS_WITH_CB.length; i++) {
var symbolPropName = SYMBOL_PROPS_WITH_CB[i];
var val = seriesModel.get(symbolPropName);
if (isFunction(val)) {
hasCallback = true;
symbolOptionsCb[symbolPropName] = val;
} else {
symbolOptions[symbolPropName] = val;
}
}
symbolOptions.symbol = symbolOptions.symbol || seriesModel.defaultSymbol;
data.setVisual(
extend(
{
legendIcon: seriesModel.legendIcon || symbolOptions.symbol,
symbolKeepAspect: seriesModel.get("symbolKeepAspect"),
},
symbolOptions,
),
); // Only visible series has each data be visual encoded
if (ecModel.isSeriesFiltered(seriesModel)) {
return;
}
var symbolPropsCb = keys(symbolOptionsCb);
function dataEach(data, idx) {
var rawValue = seriesModel.getRawValue(idx);
var params = seriesModel.getDataParams(idx);
for (var i = 0; i < symbolPropsCb.length; i++) {
var symbolPropName = symbolPropsCb[i];
data.setItemVisual(
idx,
symbolPropName,
symbolOptionsCb[symbolPropName](rawValue, params),
);
}
}
return {
dataEach: hasCallback ? dataEach : null,
};
},
};
var dataSymbolTask = {
createOnAllSeries: true,
// For legend.
performRawSeries: true,
reset: function (seriesModel, ecModel) {
if (!seriesModel.hasSymbolVisual) {
return;
} // Only visible series has each data be visual encoded
if (ecModel.isSeriesFiltered(seriesModel)) {
return;
}
var data = seriesModel.getData();
function dataEach(data, idx) {
var itemModel = data.getItemModel(idx);
for (var i = 0; i < SYMBOL_PROPS.length; i++) {
var symbolPropName = SYMBOL_PROPS[i];
var val = itemModel.getShallow(symbolPropName, true);
if (val != null) {
data.setItemVisual(idx, symbolPropName, val);
}
}
}
return {
dataEach: data.hasItemOption ? dataEach : null,
};
},
};
/*
* 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.
*/
function getItemVisualFromData(data, dataIndex, key) {
switch (key) {
case "color":
var style = data.getItemVisual(dataIndex, "style");
return style[data.getVisual("drawType")];
case "opacity":
return data.getItemVisual(dataIndex, "style").opacity;
case "symbol":
case "symbolSize":
case "liftZ":
return data.getItemVisual(dataIndex, key);
default:
if ("development" !== "production") {
console.warn("Unknown visual type " + key);
}
}
}
function getVisualFromData(data, key) {
switch (key) {
case "color":
var style = data.getVisual("style");
return style[data.getVisual("drawType")];
case "opacity":
return data.getVisual("style").opacity;
case "symbol":
case "symbolSize":
case "liftZ":
return data.getVisual(key);
default:
if ("development" !== "production") {
console.warn("Unknown visual type " + key);
}
}
}
function setItemVisualFromData(data, dataIndex, key, value) {
switch (key) {
case "color":
// Make sure not sharing style object.
var style = data.ensureUniqueItemVisual(dataIndex, "style");
style[data.getVisual("drawType")] = value; // Mark the color has been changed, not from palette anymore
data.setItemVisual(dataIndex, "colorFromPalette", false);
break;
case "opacity":
data.ensureUniqueItemVisual(dataIndex, "style").opacity = value;
break;
case "symbol":
case "symbolSize":
case "liftZ":
data.setItemVisual(dataIndex, key, value);
break;
default:
if ("development" !== "production") {
console.warn("Unknown visual type " + key);
}
}
}
// Inlucdes: pieSelect, pieUnSelect, pieToggleSelect, mapSelect, mapUnSelect, mapToggleSelect
function createLegacyDataSelectAction(seriesType, ecRegisterAction) {
function getSeriesIndices(ecModel, payload) {
var seriesIndices = [];
ecModel.eachComponent(
{
mainType: "series",
subType: seriesType,
query: payload,
},
function (seriesModel) {
seriesIndices.push(seriesModel.seriesIndex);
},
);
return seriesIndices;
}
each(
[
[seriesType + "ToggleSelect", "toggleSelect"],
[seriesType + "Select", "select"],
[seriesType + "UnSelect", "unselect"],
],
function (eventsMap) {
ecRegisterAction(eventsMap[0], function (payload, ecModel, api) {
payload = extend({}, payload);
if ("development" !== "production") {
deprecateReplaceLog(payload.type, eventsMap[1]);
}
api.dispatchAction(
extend(payload, {
type: eventsMap[1],
seriesIndex: getSeriesIndices(ecModel, payload),
}),
);
});
},
);
}
function handleSeriesLegacySelectEvents(
type,
eventPostfix,
ecIns,
ecModel,
payload,
) {
var legacyEventName = type + eventPostfix;
if (!ecIns.isSilent(legacyEventName)) {
if ("development" !== "production") {
deprecateLog("event " + legacyEventName + " is deprecated.");
}
ecModel.eachComponent(
{
mainType: "series",
subType: "pie",
},
function (seriesModel) {
var seriesIndex = seriesModel.seriesIndex;
var selectedMap = seriesModel.option.selectedMap;
var selected = payload.selected;
for (var i = 0; i < selected.length; i++) {
if (selected[i].seriesIndex === seriesIndex) {
var data = seriesModel.getData();
var dataIndex = queryDataIndex(data, payload.fromActionPayload);
ecIns.trigger(legacyEventName, {
type: legacyEventName,
seriesId: seriesModel.id,
name: isArray(dataIndex)
? data.getName(dataIndex[0])
: data.getName(dataIndex),
selected: isString(selectedMap)
? selectedMap
: extend({}, selectedMap),
});
}
}
},
);
}
}
function handleLegacySelectEvents(messageCenter, ecIns, api) {
messageCenter.on("selectchanged", function (params) {
var ecModel = api.getModel();
if (params.isFromClick) {
handleSeriesLegacySelectEvents(
"map",
"selectchanged",
ecIns,
ecModel,
params,
);
handleSeriesLegacySelectEvents(
"pie",
"selectchanged",
ecIns,
ecModel,
params,
);
} else if (params.fromAction === "select") {
handleSeriesLegacySelectEvents(
"map",
"selected",
ecIns,
ecModel,
params,
);
handleSeriesLegacySelectEvents(
"pie",
"selected",
ecIns,
ecModel,
params,
);
} else if (params.fromAction === "unselect") {
handleSeriesLegacySelectEvents(
"map",
"unselected",
ecIns,
ecModel,
params,
);
handleSeriesLegacySelectEvents(
"pie",
"unselected",
ecIns,
ecModel,
params,
);
}
});
}
/*
* 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.
*/
function findEventDispatcher(target, det, returnFirstMatch) {
var found;
while (target) {
if (det(target)) {
found = target;
if (returnFirstMatch) {
break;
}
}
target = target.__hostTarget || target.parent;
}
return found;
}
var wmUniqueIndex = Math.round(Math.random() * 9);
var supportDefineProperty = typeof Object.defineProperty === "function";
var WeakMap = (function () {
function WeakMap() {
this._id = "__ec_inner_" + wmUniqueIndex++;
}
WeakMap.prototype.get = function (key) {
return this._guard(key)[this._id];
};
WeakMap.prototype.set = function (key, value) {
var target = this._guard(key);
if (supportDefineProperty) {
Object.defineProperty(target, this._id, {
value: value,
enumerable: false,
configurable: true,
});
} else {
target[this._id] = value;
}
return this;
};
WeakMap.prototype["delete"] = function (key) {
if (this.has(key)) {
delete this._guard(key)[this._id];
return true;
}
return false;
};
WeakMap.prototype.has = function (key) {
return !!this._guard(key)[this._id];
};
WeakMap.prototype._guard = function (key) {
if (key !== Object(key)) {
throw TypeError("Value of WeakMap is not a non-null object.");
}
return key;
};
return WeakMap;
})();
/**
* Triangle shape
* @inner
*/
var Triangle = Path.extend({
type: "triangle",
shape: {
cx: 0,
cy: 0,
width: 0,
height: 0,
},
buildPath: function (path, shape) {
var cx = shape.cx;
var cy = shape.cy;
var width = shape.width / 2;
var height = shape.height / 2;
path.moveTo(cx, cy - height);
path.lineTo(cx + width, cy + height);
path.lineTo(cx - width, cy + height);
path.closePath();
},
});
/**
* Diamond shape
* @inner
*/
var Diamond = Path.extend({
type: "diamond",
shape: {
cx: 0,
cy: 0,
width: 0,
height: 0,
},
buildPath: function (path, shape) {
var cx = shape.cx;
var cy = shape.cy;
var width = shape.width / 2;
var height = shape.height / 2;
path.moveTo(cx, cy - height);
path.lineTo(cx + width, cy);
path.lineTo(cx, cy + height);
path.lineTo(cx - width, cy);
path.closePath();
},
});
/**
* Pin shape
* @inner
*/
var Pin = Path.extend({
type: "pin",
shape: {
// x, y on the cusp
x: 0,
y: 0,
width: 0,
height: 0,
},
buildPath: function (path, shape) {
var x = shape.x;
var y = shape.y;
var w = (shape.width / 5) * 3; // Height must be larger than width
var h = Math.max(w, shape.height);
var r = w / 2; // Dist on y with tangent point and circle center
var dy = (r * r) / (h - r);
var cy = y - h + r + dy;
var angle = Math.asin(dy / r); // Dist on x with tangent point and circle center
var dx = Math.cos(angle) * r;
var tanX = Math.sin(angle);
var tanY = Math.cos(angle);
var cpLen = r * 0.6;
var cpLen2 = r * 0.7;
path.moveTo(x - dx, cy + dy);
path.arc(x, cy, r, Math.PI - angle, Math.PI * 2 + angle);
path.bezierCurveTo(
x + dx - tanX * cpLen,
cy + dy + tanY * cpLen,
x,
y - cpLen2,
x,
y,
);
path.bezierCurveTo(
x,
y - cpLen2,
x - dx + tanX * cpLen,
cy + dy + tanY * cpLen,
x - dx,
cy + dy,
);
path.closePath();
},
});
/**
* Arrow shape
* @inner
*/
var Arrow = Path.extend({
type: "arrow",
shape: {
x: 0,
y: 0,
width: 0,
height: 0,
},
buildPath: function (ctx, shape) {
var height = shape.height;
var width = shape.width;
var x = shape.x;
var y = shape.y;
var dx = (width / 3) * 2;
ctx.moveTo(x, y);
ctx.lineTo(x + dx, y + height);
ctx.lineTo(x, y + (height / 4) * 3);
ctx.lineTo(x - dx, y + height);
ctx.lineTo(x, y);
ctx.closePath();
},
});
/**
* Map of path contructors
*/
// TODO Use function to build symbol path.
var symbolCtors = {
line: Line,
rect: Rect,
roundRect: Rect,
square: Rect,
circle: Circle,
diamond: Diamond,
pin: Pin,
arrow: Arrow,
triangle: Triangle,
};
var symbolShapeMakers = {
line: function (x, y, w, h, shape) {
shape.x1 = x;
shape.y1 = y + h / 2;
shape.x2 = x + w;
shape.y2 = y + h / 2;
},
rect: function (x, y, w, h, shape) {
shape.x = x;
shape.y = y;
shape.width = w;
shape.height = h;
},
roundRect: function (x, y, w, h, shape) {
shape.x = x;
shape.y = y;
shape.width = w;
shape.height = h;
shape.r = Math.min(w, h) / 4;
},
square: function (x, y, w, h, shape) {
var size = Math.min(w, h);
shape.x = x;
shape.y = y;
shape.width = size;
shape.height = size;
},
circle: function (x, y, w, h, shape) {
// Put circle in the center of square
shape.cx = x + w / 2;
shape.cy = y + h / 2;
shape.r = Math.min(w, h) / 2;
},
diamond: function (x, y, w, h, shape) {
shape.cx = x + w / 2;
shape.cy = y + h / 2;
shape.width = w;
shape.height = h;
},
pin: function (x, y, w, h, shape) {
shape.x = x + w / 2;
shape.y = y + h / 2;
shape.width = w;
shape.height = h;
},
arrow: function (x, y, w, h, shape) {
shape.x = x + w / 2;
shape.y = y + h / 2;
shape.width = w;
shape.height = h;
},
triangle: function (x, y, w, h, shape) {
shape.cx = x + w / 2;
shape.cy = y + h / 2;
shape.width = w;
shape.height = h;
},
};
var symbolBuildProxies = {};
each(symbolCtors, function (Ctor, name) {
symbolBuildProxies[name] = new Ctor();
});
var SymbolClz = Path.extend({
type: "symbol",
shape: {
symbolType: "",
x: 0,
y: 0,
width: 0,
height: 0,
},
calculateTextPosition: function (out, config, rect) {
var res = calculateTextPosition(out, config, rect);
var shape = this.shape;
if (shape && shape.symbolType === "pin" && config.position === "inside") {
res.y = rect.y + rect.height * 0.4;
}
return res;
},
buildPath: function (ctx, shape, inBundle) {
var symbolType = shape.symbolType;
if (symbolType !== "none") {
var proxySymbol = symbolBuildProxies[symbolType];
if (!proxySymbol) {
// Default rect
symbolType = "rect";
proxySymbol = symbolBuildProxies[symbolType];
}
symbolShapeMakers[symbolType](
shape.x,
shape.y,
shape.width,
shape.height,
proxySymbol.shape,
);
proxySymbol.buildPath(ctx, proxySymbol.shape, inBundle);
}
},
}); // Provide setColor helper method to avoid determine if set the fill or stroke outside
function symbolPathSetColor(color, innerColor) {
if (this.type !== "image") {
var symbolStyle = this.style;
if (this.__isEmptyBrush) {
symbolStyle.stroke = color;
symbolStyle.fill = innerColor || "#fff"; // TODO Same width with lineStyle in LineView
symbolStyle.lineWidth = 2;
} else if (this.shape.symbolType === "line") {
symbolStyle.stroke = color;
} else {
symbolStyle.fill = color;
}
this.markRedraw();
}
}
/**
* Create a symbol element with given symbol configuration: shape, x, y, width, height, color
*/
function createSymbol(
symbolType,
x,
y,
w,
h,
color, // whether to keep the ratio of w/h,
keepAspect,
) {
// TODO Support image object, DynamicImage.
var isEmpty = symbolType.indexOf("empty") === 0;
if (isEmpty) {
symbolType = symbolType.substr(5, 1).toLowerCase() + symbolType.substr(6);
}
var symbolPath;
if (symbolType.indexOf("image://") === 0) {
symbolPath = makeImage(
symbolType.slice(8),
new BoundingRect(x, y, w, h),
keepAspect ? "center" : "cover",
);
} else if (symbolType.indexOf("path://") === 0) {
symbolPath = makePath(
symbolType.slice(7),
{},
new BoundingRect(x, y, w, h),
keepAspect ? "center" : "cover",
);
} else {
symbolPath = new SymbolClz({
shape: {
symbolType: symbolType,
x: x,
y: y,
width: w,
height: h,
},
});
}
symbolPath.__isEmptyBrush = isEmpty; // TODO Should deprecate setColor
symbolPath.setColor = symbolPathSetColor;
if (color) {
symbolPath.setColor(color);
}
return symbolPath;
}
function normalizeSymbolSize(symbolSize) {
if (!isArray(symbolSize)) {
symbolSize = [+symbolSize, +symbolSize];
}
return [symbolSize[0] || 0, symbolSize[1] || 0];
}
function normalizeSymbolOffset(symbolOffset, symbolSize) {
if (symbolOffset == null) {
return;
}
if (!isArray(symbolOffset)) {
symbolOffset = [symbolOffset, symbolOffset];
}
return [
parsePercent$1(symbolOffset[0], symbolSize[0]) || 0,
parsePercent$1(
retrieve2(symbolOffset[1], symbolOffset[0]),
symbolSize[1],
) || 0,
];
}
function createLinearGradient(ctx, obj, rect) {
var x = obj.x == null ? 0 : obj.x;
var x2 = obj.x2 == null ? 1 : obj.x2;
var y = obj.y == null ? 0 : obj.y;
var y2 = obj.y2 == null ? 0 : obj.y2;
if (!obj.global) {
x = x * rect.width + rect.x;
x2 = x2 * rect.width + rect.x;
y = y * rect.height + rect.y;
y2 = y2 * rect.height + rect.y;
}
x = isNaN(x) ? 0 : x;
x2 = isNaN(x2) ? 1 : x2;
y = isNaN(y) ? 0 : y;
y2 = isNaN(y2) ? 0 : y2;
var canvasGradient = ctx.createLinearGradient(x, y, x2, y2);
return canvasGradient;
}
function createRadialGradient(ctx, obj, rect) {
var width = rect.width;
var height = rect.height;
var min = Math.min(width, height);
var x = obj.x == null ? 0.5 : obj.x;
var y = obj.y == null ? 0.5 : obj.y;
var r = obj.r == null ? 0.5 : obj.r;
if (!obj.global) {
x = x * width + rect.x;
y = y * height + rect.y;
r = r * min;
}
var canvasGradient = ctx.createRadialGradient(x, y, 0, x, y, r);
return canvasGradient;
}
function getCanvasGradient(ctx, obj, rect) {
var canvasGradient =
obj.type === "radial"
? createRadialGradient(ctx, obj, rect)
: createLinearGradient(ctx, obj, rect);
var colorStops = obj.colorStops;
for (var i = 0; i < colorStops.length; i++) {
canvasGradient.addColorStop(colorStops[i].offset, colorStops[i].color);
}
return canvasGradient;
}
function isClipPathChanged(clipPaths, prevClipPaths) {
if (clipPaths === prevClipPaths || (!clipPaths && !prevClipPaths)) {
return false;
}
if (
!clipPaths ||
!prevClipPaths ||
clipPaths.length !== prevClipPaths.length
) {
return true;
}
for (var i = 0; i < clipPaths.length; i++) {
if (clipPaths[i] !== prevClipPaths[i]) {
return true;
}
}
return false;
}
function parseInt10(val) {
return parseInt(val, 10);
}
function getSize(root, whIdx, opts) {
var wh = ["width", "height"][whIdx];
var cwh = ["clientWidth", "clientHeight"][whIdx];
var plt = ["paddingLeft", "paddingTop"][whIdx];
var prb = ["paddingRight", "paddingBottom"][whIdx];
if (opts[wh] != null && opts[wh] !== "auto") {
return parseFloat(opts[wh]);
}
var stl = document.defaultView.getComputedStyle(root);
return (
((root[cwh] || parseInt10(stl[wh]) || parseInt10(root.style[wh])) -
(parseInt10(stl[plt]) || 0) -
(parseInt10(stl[prb]) || 0)) |
0
);
}
function normalizeLineDash(lineType, lineWidth) {
if (!lineType || lineType === "solid" || !(lineWidth > 0)) {
return null;
}
return lineType === "dashed"
? [4 * lineWidth, 2 * lineWidth]
: lineType === "dotted"
? [lineWidth]
: isNumber(lineType)
? [lineType]
: isArray(lineType)
? lineType
: null;
}
function getLineDash(el) {
var style = el.style;
var lineDash =
style.lineDash &&
style.lineWidth > 0 &&
normalizeLineDash(style.lineDash, style.lineWidth);
var lineDashOffset = style.lineDashOffset;
if (lineDash) {
var lineScale_1 =
style.strokeNoScale && el.getLineScale ? el.getLineScale() : 1;
if (lineScale_1 && lineScale_1 !== 1) {
lineDash = map(lineDash, function (rawVal) {
return rawVal / lineScale_1;
});
lineDashOffset /= lineScale_1;
}
}
return [lineDash, lineDashOffset];
}
var pathProxyForDraw = new PathProxy(true);
function styleHasStroke(style) {
var stroke = style.stroke;
return !(stroke == null || stroke === "none" || !(style.lineWidth > 0));
}
function isValidStrokeFillStyle(strokeOrFill) {
return typeof strokeOrFill === "string" && strokeOrFill !== "none";
}
function styleHasFill(style) {
var fill = style.fill;
return fill != null && fill !== "none";
}
function doFillPath(ctx, style) {
if (style.fillOpacity != null && style.fillOpacity !== 1) {
var originalGlobalAlpha = ctx.globalAlpha;
ctx.globalAlpha = style.fillOpacity * style.opacity;
ctx.fill();
ctx.globalAlpha = originalGlobalAlpha;
} else {
ctx.fill();
}
}
function doStrokePath(ctx, style) {
if (style.strokeOpacity != null && style.strokeOpacity !== 1) {
var originalGlobalAlpha = ctx.globalAlpha;
ctx.globalAlpha = style.strokeOpacity * style.opacity;
ctx.stroke();
ctx.globalAlpha = originalGlobalAlpha;
} else {
ctx.stroke();
}
}
function createCanvasPattern(ctx, pattern, el) {
var image = createOrUpdateImage(pattern.image, pattern.__image, el);
if (isImageReady(image)) {
var canvasPattern = ctx.createPattern(image, pattern.repeat || "repeat");
if (
typeof DOMMatrix === "function" &&
canvasPattern &&
canvasPattern.setTransform
) {
var matrix = new DOMMatrix();
matrix.translateSelf(pattern.x || 0, pattern.y || 0);
matrix.rotateSelf(0, 0, (pattern.rotation || 0) * RADIAN_TO_DEGREE);
matrix.scaleSelf(pattern.scaleX || 1, pattern.scaleY || 1);
canvasPattern.setTransform(matrix);
}
return canvasPattern;
}
}
function brushPath(ctx, el, style, inBatch) {
var _a;
var hasStroke = styleHasStroke(style);
var hasFill = styleHasFill(style);
var strokePercent = style.strokePercent;
var strokePart = strokePercent < 1;
var firstDraw = !el.path;
if ((!el.silent || strokePart) && firstDraw) {
el.createPathProxy();
}
var path = el.path || pathProxyForDraw;
var dirtyFlag = el.__dirty;
if (!inBatch) {
var fill = style.fill;
var stroke = style.stroke;
var hasFillGradient = hasFill && !!fill.colorStops;
var hasStrokeGradient = hasStroke && !!stroke.colorStops;
var hasFillPattern = hasFill && !!fill.image;
var hasStrokePattern = hasStroke && !!stroke.image;
var fillGradient = void 0;
var strokeGradient = void 0;
var fillPattern = void 0;
var strokePattern = void 0;
var rect = void 0;
if (hasFillGradient || hasStrokeGradient) {
rect = el.getBoundingRect();
}
if (hasFillGradient) {
fillGradient = dirtyFlag
? getCanvasGradient(ctx, fill, rect)
: el.__canvasFillGradient;
el.__canvasFillGradient = fillGradient;
}
if (hasStrokeGradient) {
strokeGradient = dirtyFlag
? getCanvasGradient(ctx, stroke, rect)
: el.__canvasStrokeGradient;
el.__canvasStrokeGradient = strokeGradient;
}
if (hasFillPattern) {
fillPattern =
dirtyFlag || !el.__canvasFillPattern
? createCanvasPattern(ctx, fill, el)
: el.__canvasFillPattern;
el.__canvasFillPattern = fillPattern;
}
if (hasStrokePattern) {
strokePattern =
dirtyFlag || !el.__canvasStrokePattern
? createCanvasPattern(ctx, stroke, el)
: el.__canvasStrokePattern;
el.__canvasStrokePattern = fillPattern;
}
if (hasFillGradient) {
ctx.fillStyle = fillGradient;
} else if (hasFillPattern) {
if (fillPattern) {
ctx.fillStyle = fillPattern;
} else {
hasFill = false;
}
}
if (hasStrokeGradient) {
ctx.strokeStyle = strokeGradient;
} else if (hasStrokePattern) {
if (strokePattern) {
ctx.strokeStyle = strokePattern;
} else {
hasStroke = false;
}
}
}
var scale = el.getGlobalScale();
path.setScale(scale[0], scale[1], el.segmentIgnoreThreshold);
var lineDash;
var lineDashOffset;
if (ctx.setLineDash && style.lineDash) {
(_a = getLineDash(el)), (lineDash = _a[0]), (lineDashOffset = _a[1]);
}
var needsRebuild = true;
if (firstDraw || dirtyFlag & SHAPE_CHANGED_BIT) {
path.setDPR(ctx.dpr);
if (strokePart) {
path.setContext(null);
} else {
path.setContext(ctx);
needsRebuild = false;
}
path.reset();
el.buildPath(path, el.shape, inBatch);
path.toStatic();
el.pathUpdated();
}
if (needsRebuild) {
path.rebuildPath(ctx, strokePart ? strokePercent : 1);
}
if (lineDash) {
ctx.setLineDash(lineDash);
ctx.lineDashOffset = lineDashOffset;
}
if (!inBatch) {
if (style.strokeFirst) {
if (hasStroke) {
doStrokePath(ctx, style);
}
if (hasFill) {
doFillPath(ctx, style);
}
} else {
if (hasFill) {
doFillPath(ctx, style);
}
if (hasStroke) {
doStrokePath(ctx, style);
}
}
}
if (lineDash) {
ctx.setLineDash([]);
}
}
function brushImage(ctx, el, style) {
var image = (el.__image = createOrUpdateImage(
style.image,
el.__image,
el,
el.onload,
));
if (!image || !isImageReady(image)) {
return;
}
var x = style.x || 0;
var y = style.y || 0;
var width = el.getWidth();
var height = el.getHeight();
var aspect = image.width / image.height;
if (width == null && height != null) {
width = height * aspect;
} else if (height == null && width != null) {
height = width / aspect;
} else if (width == null && height == null) {
width = image.width;
height = image.height;
}
if (style.sWidth && style.sHeight) {
var sx = style.sx || 0;
var sy = style.sy || 0;
ctx.drawImage(
image,
sx,
sy,
style.sWidth,
style.sHeight,
x,
y,
width,
height,
);
} else if (style.sx && style.sy) {
var sx = style.sx;
var sy = style.sy;
var sWidth = width - sx;
var sHeight = height - sy;
ctx.drawImage(image, sx, sy, sWidth, sHeight, x, y, width, height);
} else {
ctx.drawImage(image, x, y, width, height);
}
}
function brushText(ctx, el, style) {
var _a;
var text = style.text;
text != null && (text += "");
if (text) {
ctx.font = style.font || DEFAULT_FONT;
ctx.textAlign = style.textAlign;
ctx.textBaseline = style.textBaseline;
var lineDash = void 0;
var lineDashOffset = void 0;
if (ctx.setLineDash && style.lineDash) {
(_a = getLineDash(el)), (lineDash = _a[0]), (lineDashOffset = _a[1]);
}
if (lineDash) {
ctx.setLineDash(lineDash);
ctx.lineDashOffset = lineDashOffset;
}
if (style.strokeFirst) {
if (styleHasStroke(style)) {
ctx.strokeText(text, style.x, style.y);
}
if (styleHasFill(style)) {
ctx.fillText(text, style.x, style.y);
}
} else {
if (styleHasFill(style)) {
ctx.fillText(text, style.x, style.y);
}
if (styleHasStroke(style)) {
ctx.strokeText(text, style.x, style.y);
}
}
if (lineDash) {
ctx.setLineDash([]);
}
}
}
var SHADOW_NUMBER_PROPS = ["shadowBlur", "shadowOffsetX", "shadowOffsetY"];
var STROKE_PROPS = [
["lineCap", "butt"],
["lineJoin", "miter"],
["miterLimit", 10],
];
function bindCommonProps(ctx, style, prevStyle, forceSetAll, scope) {
var styleChanged = false;
if (!forceSetAll) {
prevStyle = prevStyle || {};
if (style === prevStyle) {
return false;
}
}
if (forceSetAll || style.opacity !== prevStyle.opacity) {
flushPathDrawn(ctx, scope);
styleChanged = true;
var opacity = Math.max(Math.min(style.opacity, 1), 0);
ctx.globalAlpha = isNaN(opacity) ? DEFAULT_COMMON_STYLE.opacity : opacity;
}
if (forceSetAll || style.blend !== prevStyle.blend) {
if (!styleChanged) {
flushPathDrawn(ctx, scope);
styleChanged = true;
}
ctx.globalCompositeOperation = style.blend || DEFAULT_COMMON_STYLE.blend;
}
for (var i = 0; i < SHADOW_NUMBER_PROPS.length; i++) {
var propName = SHADOW_NUMBER_PROPS[i];
if (forceSetAll || style[propName] !== prevStyle[propName]) {
if (!styleChanged) {
flushPathDrawn(ctx, scope);
styleChanged = true;
}
ctx[propName] = ctx.dpr * (style[propName] || 0);
}
}
if (forceSetAll || style.shadowColor !== prevStyle.shadowColor) {
if (!styleChanged) {
flushPathDrawn(ctx, scope);
styleChanged = true;
}
ctx.shadowColor = style.shadowColor || DEFAULT_COMMON_STYLE.shadowColor;
}
return styleChanged;
}
function bindPathAndTextCommonStyle(ctx, el, prevEl, forceSetAll, scope) {
var style = getStyle(el, scope.inHover);
var prevStyle = forceSetAll
? null
: (prevEl && getStyle(prevEl, scope.inHover)) || {};
if (style === prevStyle) {
return false;
}
var styleChanged = bindCommonProps(
ctx,
style,
prevStyle,
forceSetAll,
scope,
);
if (forceSetAll || style.fill !== prevStyle.fill) {
if (!styleChanged) {
flushPathDrawn(ctx, scope);
styleChanged = true;
}
isValidStrokeFillStyle(style.fill) && (ctx.fillStyle = style.fill);
}
if (forceSetAll || style.stroke !== prevStyle.stroke) {
if (!styleChanged) {
flushPathDrawn(ctx, scope);
styleChanged = true;
}
isValidStrokeFillStyle(style.stroke) && (ctx.strokeStyle = style.stroke);
}
if (forceSetAll || style.opacity !== prevStyle.opacity) {
if (!styleChanged) {
flushPathDrawn(ctx, scope);
styleChanged = true;
}
ctx.globalAlpha = style.opacity == null ? 1 : style.opacity;
}
if (el.hasStroke()) {
var lineWidth = style.lineWidth;
var newLineWidth =
lineWidth /
(style.strokeNoScale && el.getLineScale ? el.getLineScale() : 1);
if (ctx.lineWidth !== newLineWidth) {
if (!styleChanged) {
flushPathDrawn(ctx, scope);
styleChanged = true;
}
ctx.lineWidth = newLineWidth;
}
}
for (var i = 0; i < STROKE_PROPS.length; i++) {
var prop = STROKE_PROPS[i];
var propName = prop[0];
if (forceSetAll || style[propName] !== prevStyle[propName]) {
if (!styleChanged) {
flushPathDrawn(ctx, scope);
styleChanged = true;
}
ctx[propName] = style[propName] || prop[1];
}
}
return styleChanged;
}
function bindImageStyle(ctx, el, prevEl, forceSetAll, scope) {
return bindCommonProps(
ctx,
getStyle(el, scope.inHover),
prevEl && getStyle(prevEl, scope.inHover),
forceSetAll,
scope,
);
}
function setContextTransform(ctx, el) {
var m = el.transform;
var dpr = ctx.dpr || 1;
if (m) {
ctx.setTransform(
dpr * m[0],
dpr * m[1],
dpr * m[2],
dpr * m[3],
dpr * m[4],
dpr * m[5],
);
} else {
ctx.setTransform(dpr, 0, 0, dpr, 0, 0);
}
}
function updateClipStatus(clipPaths, ctx, scope) {
var allClipped = false;
for (var i = 0; i < clipPaths.length; i++) {
var clipPath = clipPaths[i];
allClipped = allClipped || clipPath.isZeroArea();
setContextTransform(ctx, clipPath);
ctx.beginPath();
clipPath.buildPath(ctx, clipPath.shape);
ctx.clip();
}
scope.allClipped = allClipped;
}
function isTransformChanged(m0, m1) {
if (m0 && m1) {
return (
m0[0] !== m1[0] ||
m0[1] !== m1[1] ||
m0[2] !== m1[2] ||
m0[3] !== m1[3] ||
m0[4] !== m1[4] ||
m0[5] !== m1[5]
);
} else if (!m0 && !m1) {
return false;
}
return true;
}
var DRAW_TYPE_PATH = 1;
var DRAW_TYPE_IMAGE = 2;
var DRAW_TYPE_TEXT = 3;
var DRAW_TYPE_INCREMENTAL = 4;
function canPathBatch(style) {
var hasFill = styleHasFill(style);
var hasStroke = styleHasStroke(style);
return !(
style.lineDash ||
!(+hasFill ^ +hasStroke) ||
(hasFill && typeof style.fill !== "string") ||
(hasStroke && typeof style.stroke !== "string") ||
style.strokePercent < 1 ||
style.strokeOpacity < 1 ||
style.fillOpacity < 1
);
}
function flushPathDrawn(ctx, scope) {
scope.batchFill && ctx.fill();
scope.batchStroke && ctx.stroke();
scope.batchFill = "";
scope.batchStroke = "";
}
function getStyle(el, inHover) {
return inHover ? el.__hoverStyle || el.style : el.style;
}
function brushSingle(ctx, el) {
brush(ctx, el, { inHover: false, viewWidth: 0, viewHeight: 0 }, true);
}
function brush(ctx, el, scope, isLast) {
var m = el.transform;
if (!el.shouldBePainted(scope.viewWidth, scope.viewHeight, false, false)) {
el.__dirty &= ~REDRAW_BIT;
el.__isRendered = false;
return;
}
var clipPaths = el.__clipPaths;
var prevElClipPaths = scope.prevElClipPaths;
var forceSetTransform = false;
var forceSetStyle = false;
if (!prevElClipPaths || isClipPathChanged(clipPaths, prevElClipPaths)) {
if (prevElClipPaths && prevElClipPaths.length) {
flushPathDrawn(ctx, scope);
ctx.restore();
forceSetStyle = forceSetTransform = true;
scope.prevElClipPaths = null;
scope.allClipped = false;
scope.prevEl = null;
}
if (clipPaths && clipPaths.length) {
flushPathDrawn(ctx, scope);
ctx.save();
updateClipStatus(clipPaths, ctx, scope);
forceSetTransform = true;
}
scope.prevElClipPaths = clipPaths;
}
if (scope.allClipped) {
el.__isRendered = false;
return;
}
el.beforeBrush && el.beforeBrush();
el.innerBeforeBrush();
var prevEl = scope.prevEl;
if (!prevEl) {
forceSetStyle = forceSetTransform = true;
}
var canBatchPath =
el instanceof Path && el.autoBatch && canPathBatch(el.style);
if (forceSetTransform || isTransformChanged(m, prevEl.transform)) {
flushPathDrawn(ctx, scope);
setContextTransform(ctx, el);
} else if (!canBatchPath) {
flushPathDrawn(ctx, scope);
}
var style = getStyle(el, scope.inHover);
if (el instanceof Path) {
if (scope.lastDrawType !== DRAW_TYPE_PATH) {
forceSetStyle = true;
scope.lastDrawType = DRAW_TYPE_PATH;
}
bindPathAndTextCommonStyle(ctx, el, prevEl, forceSetStyle, scope);
if (!canBatchPath || (!scope.batchFill && !scope.batchStroke)) {
ctx.beginPath();
}
brushPath(ctx, el, style, canBatchPath);
if (canBatchPath) {
scope.batchFill = style.fill || "";
scope.batchStroke = style.stroke || "";
}
} else {
if (el instanceof TSpan) {
if (scope.lastDrawType !== DRAW_TYPE_TEXT) {
forceSetStyle = true;
scope.lastDrawType = DRAW_TYPE_TEXT;
}
bindPathAndTextCommonStyle(ctx, el, prevEl, forceSetStyle, scope);
brushText(ctx, el, style);
} else if (el instanceof ZRImage) {
if (scope.lastDrawType !== DRAW_TYPE_IMAGE) {
forceSetStyle = true;
scope.lastDrawType = DRAW_TYPE_IMAGE;
}
bindImageStyle(ctx, el, prevEl, forceSetStyle, scope);
brushImage(ctx, el, style);
} else if (el.getTemporalDisplayables) {
if (scope.lastDrawType !== DRAW_TYPE_INCREMENTAL) {
forceSetStyle = true;
scope.lastDrawType = DRAW_TYPE_INCREMENTAL;
}
brushIncremental(ctx, el, scope);
}
}
if (canBatchPath && isLast) {
flushPathDrawn(ctx, scope);
}
el.innerAfterBrush();
el.afterBrush && el.afterBrush();
scope.prevEl = el;
el.__dirty = 0;
el.__isRendered = true;
}
function brushIncremental(ctx, el, scope) {
var displayables = el.getDisplayables();
var temporalDisplayables = el.getTemporalDisplayables();
ctx.save();
var innerScope = {
prevElClipPaths: null,
prevEl: null,
allClipped: false,
viewWidth: scope.viewWidth,
viewHeight: scope.viewHeight,
inHover: scope.inHover,
};
var i;
var len;
for (i = el.getCursor(), len = displayables.length; i < len; i++) {
var displayable = displayables[i];
displayable.beforeBrush && displayable.beforeBrush();
displayable.innerBeforeBrush();
brush(ctx, displayable, innerScope, i === len - 1);
displayable.innerAfterBrush();
displayable.afterBrush && displayable.afterBrush();
innerScope.prevEl = displayable;
}
for (var i_1 = 0, len_1 = temporalDisplayables.length; i_1 < len_1; i_1++) {
var displayable = temporalDisplayables[i_1];
displayable.beforeBrush && displayable.beforeBrush();
displayable.innerBeforeBrush();
brush(ctx, displayable, innerScope, i_1 === len_1 - 1);
displayable.innerAfterBrush();
displayable.afterBrush && displayable.afterBrush();
innerScope.prevEl = displayable;
}
el.clearTemporalDisplayables();
el.notClear = true;
ctx.restore();
}
var decalMap = new WeakMap();
var decalCache = new LRU(100);
var decalKeys = [
"symbol",
"symbolSize",
"symbolKeepAspect",
"color",
"backgroundColor",
"dashArrayX",
"dashArrayY",
"maxTileWidth",
"maxTileHeight",
];
/**
* Create or update pattern image from decal options
*
* @param {InnerDecalObject | 'none'} decalObject decal options, 'none' if no decal
* @return {Pattern} pattern with generated image, null if no decal
*/
function createOrUpdatePatternFromDecal(decalObject, api) {
if (decalObject === "none") {
return null;
}
var dpr = api.getDevicePixelRatio();
var zr = api.getZr();
var isSVG = zr.painter.type === "svg";
if (decalObject.dirty) {
decalMap["delete"](decalObject);
}
var oldPattern = decalMap.get(decalObject);
if (oldPattern) {
return oldPattern;
}
var decalOpt = defaults(decalObject, {
symbol: "rect",
symbolSize: 1,
symbolKeepAspect: true,
color: "rgba(0, 0, 0, 0.2)",
backgroundColor: null,
dashArrayX: 5,
dashArrayY: 5,
rotation: 0,
maxTileWidth: 512,
maxTileHeight: 512,
});
if (decalOpt.backgroundColor === "none") {
decalOpt.backgroundColor = null;
}
var pattern = {
repeat: "repeat",
};
setPatternnSource(pattern);
pattern.rotation = decalOpt.rotation;
pattern.scaleX = pattern.scaleY = isSVG ? 1 : 1 / dpr;
decalMap.set(decalObject, pattern);
decalObject.dirty = false;
return pattern;
function setPatternnSource(pattern) {
var keys = [dpr];
var isValidKey = true;
for (var i = 0; i < decalKeys.length; ++i) {
var value = decalOpt[decalKeys[i]];
if (
value != null &&
!isArray(value) &&
!isString(value) &&
!isNumber(value) &&
typeof value !== "boolean"
) {
isValidKey = false;
break;
}
keys.push(value);
}
var cacheKey;
if (isValidKey) {
cacheKey = keys.join(",") + (isSVG ? "-svg" : "");
var cache = decalCache.get(cacheKey);
if (cache) {
isSVG ? (pattern.svgElement = cache) : (pattern.image = cache);
}
}
var dashArrayX = normalizeDashArrayX(decalOpt.dashArrayX);
var dashArrayY = normalizeDashArrayY(decalOpt.dashArrayY);
var symbolArray = normalizeSymbolArray(decalOpt.symbol);
var lineBlockLengthsX = getLineBlockLengthX(dashArrayX);
var lineBlockLengthY = getLineBlockLengthY(dashArrayY);
var canvas = !isSVG && platformApi.createCanvas();
var svgRoot = isSVG && {
tag: "g",
attrs: {},
key: "dcl",
children: [],
};
var pSize = getPatternSize();
var ctx;
if (canvas) {
canvas.width = pSize.width * dpr;
canvas.height = pSize.height * dpr;
ctx = canvas.getContext("2d");
}
brushDecal();
if (isValidKey) {
decalCache.put(cacheKey, canvas || svgRoot);
}
pattern.image = canvas;
pattern.svgElement = svgRoot;
pattern.svgWidth = pSize.width;
pattern.svgHeight = pSize.height;
/**
* Get minumum length that can make a repeatable pattern.
*
* @return {Object} pattern width and height
*/
function getPatternSize() {
/**
* For example, if dash is [[3, 2], [2, 1]] for X, it looks like
* |--- --- --- --- --- ...
* |-- -- -- -- -- -- -- -- ...
* |--- --- --- --- --- ...
* |-- -- -- -- -- -- -- -- ...
* So the minumum length of X is 15,
* which is the least common multiple of `3 + 2` and `2 + 1`
* |--- --- --- |--- --- ...
* |-- -- -- -- -- |-- -- -- ...
*/
var width = 1;
for (var i = 0, xlen = lineBlockLengthsX.length; i < xlen; ++i) {
width = getLeastCommonMultiple(width, lineBlockLengthsX[i]);
}
var symbolRepeats = 1;
for (var i = 0, xlen = symbolArray.length; i < xlen; ++i) {
symbolRepeats = getLeastCommonMultiple(
symbolRepeats,
symbolArray[i].length,
);
}
width *= symbolRepeats;
var height =
lineBlockLengthY * lineBlockLengthsX.length * symbolArray.length;
if ("development" !== "production") {
var warn = function (attrName) {
/* eslint-disable-next-line */
console.warn(
"Calculated decal size is greater than " +
attrName +
" due to decal option settings so " +
attrName +
" is used for the decal size. Please consider changing the decal option to make a smaller decal or set " +
attrName +
" to be larger to avoid incontinuity.",
);
};
if (width > decalOpt.maxTileWidth) {
warn("maxTileWidth");
}
if (height > decalOpt.maxTileHeight) {
warn("maxTileHeight");
}
}
return {
width: Math.max(1, Math.min(width, decalOpt.maxTileWidth)),
height: Math.max(1, Math.min(height, decalOpt.maxTileHeight)),
};
}
function brushDecal() {
if (ctx) {
ctx.clearRect(0, 0, canvas.width, canvas.height);
if (decalOpt.backgroundColor) {
ctx.fillStyle = decalOpt.backgroundColor;
ctx.fillRect(0, 0, canvas.width, canvas.height);
}
}
var ySum = 0;
for (var i = 0; i < dashArrayY.length; ++i) {
ySum += dashArrayY[i];
}
if (ySum <= 0) {
// dashArrayY is 0, draw nothing
return;
}
var y = -lineBlockLengthY;
var yId = 0;
var yIdTotal = 0;
var xId0 = 0;
while (y < pSize.height) {
if (yId % 2 === 0) {
var symbolYId = (yIdTotal / 2) % symbolArray.length;
var x = 0;
var xId1 = 0;
var xId1Total = 0;
while (x < pSize.width * 2) {
var xSum = 0;
for (var i = 0; i < dashArrayX[xId0].length; ++i) {
xSum += dashArrayX[xId0][i];
}
if (xSum <= 0) {
// Skip empty line
break;
} // E.g., [15, 5, 20, 5] draws only for 15 and 20
if (xId1 % 2 === 0) {
var size = (1 - decalOpt.symbolSize) * 0.5;
var left = x + dashArrayX[xId0][xId1] * size;
var top_1 = y + dashArrayY[yId] * size;
var width = dashArrayX[xId0][xId1] * decalOpt.symbolSize;
var height = dashArrayY[yId] * decalOpt.symbolSize;
var symbolXId = (xId1Total / 2) % symbolArray[symbolYId].length;
brushSymbol(
left,
top_1,
width,
height,
symbolArray[symbolYId][symbolXId],
);
}
x += dashArrayX[xId0][xId1];
++xId1Total;
++xId1;
if (xId1 === dashArrayX[xId0].length) {
xId1 = 0;
}
}
++xId0;
if (xId0 === dashArrayX.length) {
xId0 = 0;
}
}
y += dashArrayY[yId];
++yIdTotal;
++yId;
if (yId === dashArrayY.length) {
yId = 0;
}
}
function brushSymbol(x, y, width, height, symbolType) {
var scale = isSVG ? 1 : dpr;
var symbol = createSymbol(
symbolType,
x * scale,
y * scale,
width * scale,
height * scale,
decalOpt.color,
decalOpt.symbolKeepAspect,
);
if (isSVG) {
var symbolVNode = zr.painter.renderOneToVNode(symbol);
if (symbolVNode) {
svgRoot.children.push(symbolVNode);
}
} else {
// Paint to canvas for all other renderers.
brushSingle(ctx, symbol);
}
}
}
}
}
/**
* Convert symbol array into normalized array
*
* @param {string | (string | string[])[]} symbol symbol input
* @return {string[][]} normolized symbol array
*/
function normalizeSymbolArray(symbol) {
if (!symbol || symbol.length === 0) {
return [["rect"]];
}
if (isString(symbol)) {
return [[symbol]];
}
var isAllString = true;
for (var i = 0; i < symbol.length; ++i) {
if (!isString(symbol[i])) {
isAllString = false;
break;
}
}
if (isAllString) {
return normalizeSymbolArray([symbol]);
}
var result = [];
for (var i = 0; i < symbol.length; ++i) {
if (isString(symbol[i])) {
result.push([symbol[i]]);
} else {
result.push(symbol[i]);
}
}
return result;
}
/**
* Convert dash input into dashArray
*
* @param {DecalDashArrayX} dash dash input
* @return {number[][]} normolized dash array
*/
function normalizeDashArrayX(dash) {
if (!dash || dash.length === 0) {
return [[0, 0]];
}
if (isNumber(dash)) {
var dashValue = Math.ceil(dash);
return [[dashValue, dashValue]];
}
/**
* [20, 5] should be normalized into [[20, 5]],
* while [20, [5, 10]] should be normalized into [[20, 20], [5, 10]]
*/
var isAllNumber = true;
for (var i = 0; i < dash.length; ++i) {
if (!isNumber(dash[i])) {
isAllNumber = false;
break;
}
}
if (isAllNumber) {
return normalizeDashArrayX([dash]);
}
var result = [];
for (var i = 0; i < dash.length; ++i) {
if (isNumber(dash[i])) {
var dashValue = Math.ceil(dash[i]);
result.push([dashValue, dashValue]);
} else {
var dashValue = map(dash[i], function (n) {
return Math.ceil(n);
});
if (dashValue.length % 2 === 1) {
// [4, 2, 1] means |---- - -- |---- - -- |
// so normalize it to be [4, 2, 1, 4, 2, 1]
result.push(dashValue.concat(dashValue));
} else {
result.push(dashValue);
}
}
}
return result;
}
/**
* Convert dash input into dashArray
*
* @param {DecalDashArrayY} dash dash input
* @return {number[]} normolized dash array
*/
function normalizeDashArrayY(dash) {
if (!dash || (typeof dash === "object" && dash.length === 0)) {
return [0, 0];
}
if (isNumber(dash)) {
var dashValue_1 = Math.ceil(dash);
return [dashValue_1, dashValue_1];
}
var dashValue = map(dash, function (n) {
return Math.ceil(n);
});
return dash.length % 2 ? dashValue.concat(dashValue) : dashValue;
}
/**
* Get block length of each line. A block is the length of dash line and space.
* For example, a line with [4, 1] has a dash line of 4 and a space of 1 after
* that, so the block length of this line is 5.
*
* @param {number[][]} dash dash arrary of X or Y
* @return {number[]} block length of each line
*/
function getLineBlockLengthX(dash) {
return map(dash, function (line) {
return getLineBlockLengthY(line);
});
}
function getLineBlockLengthY(dash) {
var blockLength = 0;
for (var i = 0; i < dash.length; ++i) {
blockLength += dash[i];
}
if (dash.length % 2 === 1) {
// [4, 2, 1] means |---- - -- |---- - -- |
// So total length is (4 + 2 + 1) * 2
return blockLength * 2;
}
return blockLength;
}
function decalVisual(ecModel, api) {
ecModel.eachRawSeries(function (seriesModel) {
if (ecModel.isSeriesFiltered(seriesModel)) {
return;
}
var data = seriesModel.getData();
if (data.hasItemVisual()) {
data.each(function (idx) {
var decal = data.getItemVisual(idx, "decal");
if (decal) {
var itemStyle = data.ensureUniqueItemVisual(idx, "style");
itemStyle.decal = createOrUpdatePatternFromDecal(decal, api);
}
});
}
var decal = data.getVisual("decal");
if (decal) {
var style = data.getVisual("style");
style.decal = createOrUpdatePatternFromDecal(decal, api);
}
});
}
var lifecycle = new Eventful();
// The implentations will be registered when installing the component.
// Avoid these code being bundled to the core module.
var implsStore = {}; // TODO Type
function registerImpl(name, impl) {
if ("development" !== "production") {
if (implsStore[name]) {
error("Already has an implementation of " + name + ".");
}
}
implsStore[name] = impl;
}
function getImpl(name) {
if ("development" !== "production") {
if (!implsStore[name]) {
error("Implementation of " + name + " doesn't exists.");
}
}
return implsStore[name];
}
var hasWindow = typeof window !== "undefined";
var version$1 = "5.3.2";
var dependencies = {
zrender: "5.3.1",
};
var TEST_FRAME_REMAIN_TIME = 1;
var PRIORITY_PROCESSOR_SERIES_FILTER = 800; // Some data processors depends on the stack result dimension (to calculate data extent).
// So data stack stage should be in front of data processing stage.
var PRIORITY_PROCESSOR_DATASTACK = 900; // "Data filter" will block the stream, so it should be
// put at the begining of data processing.
var PRIORITY_PROCESSOR_FILTER = 1000;
var PRIORITY_PROCESSOR_DEFAULT = 2000;
var PRIORITY_PROCESSOR_STATISTIC = 5000;
var PRIORITY_VISUAL_LAYOUT = 1000;
var PRIORITY_VISUAL_PROGRESSIVE_LAYOUT = 1100;
var PRIORITY_VISUAL_GLOBAL = 2000;
var PRIORITY_VISUAL_CHART = 3000;
var PRIORITY_VISUAL_COMPONENT = 4000; // Visual property in data. Greater than `PRIORITY_VISUAL_COMPONENT` to enable to
// overwrite the viusal result of component (like `visualMap`)
// using data item specific setting (like itemStyle.xxx on data item)
var PRIORITY_VISUAL_CHART_DATA_CUSTOM = 4500; // Greater than `PRIORITY_VISUAL_CHART_DATA_CUSTOM` to enable to layout based on
// visual result like `symbolSize`.
var PRIORITY_VISUAL_POST_CHART_LAYOUT = 4600;
var PRIORITY_VISUAL_BRUSH = 5000;
var PRIORITY_VISUAL_ARIA = 6000;
var PRIORITY_VISUAL_DECAL = 7000;
var PRIORITY = {
PROCESSOR: {
FILTER: PRIORITY_PROCESSOR_FILTER,
SERIES_FILTER: PRIORITY_PROCESSOR_SERIES_FILTER,
STATISTIC: PRIORITY_PROCESSOR_STATISTIC,
},
VISUAL: {
LAYOUT: PRIORITY_VISUAL_LAYOUT,
PROGRESSIVE_LAYOUT: PRIORITY_VISUAL_PROGRESSIVE_LAYOUT,
GLOBAL: PRIORITY_VISUAL_GLOBAL,
CHART: PRIORITY_VISUAL_CHART,
POST_CHART_LAYOUT: PRIORITY_VISUAL_POST_CHART_LAYOUT,
COMPONENT: PRIORITY_VISUAL_COMPONENT,
BRUSH: PRIORITY_VISUAL_BRUSH,
CHART_ITEM: PRIORITY_VISUAL_CHART_DATA_CUSTOM,
ARIA: PRIORITY_VISUAL_ARIA,
DECAL: PRIORITY_VISUAL_DECAL,
},
}; // Main process have three entries: `setOption`, `dispatchAction` and `resize`,
// where they must not be invoked nestedly, except the only case: invoke
// dispatchAction with updateMethod "none" in main process.
// This flag is used to carry out this rule.
// All events will be triggered out side main process (i.e. when !this[IN_MAIN_PROCESS]).
var IN_MAIN_PROCESS_KEY = "__flagInMainProcess";
var PENDING_UPDATE = "__pendingUpdate";
var STATUS_NEEDS_UPDATE_KEY = "__needsUpdateStatus";
var ACTION_REG = /^[a-zA-Z0-9_]+$/;
var CONNECT_STATUS_KEY = "__connectUpdateStatus";
var CONNECT_STATUS_PENDING = 0;
var CONNECT_STATUS_UPDATING = 1;
var CONNECT_STATUS_UPDATED = 2;
function createRegisterEventWithLowercaseECharts(method) {
return function () {
var args = [];
for (var _i = 0; _i < arguments.length; _i++) {
args[_i] = arguments[_i];
}
if (this.isDisposed()) {
disposedWarning(this.id);
return;
}
return toLowercaseNameAndCallEventful(this, method, args);
};
}
function createRegisterEventWithLowercaseMessageCenter(method) {
return function () {
var args = [];
for (var _i = 0; _i < arguments.length; _i++) {
args[_i] = arguments[_i];
}
return toLowercaseNameAndCallEventful(this, method, args);
};
}
function toLowercaseNameAndCallEventful(host, method, args) {
// `args[0]` is event name. Event name is all lowercase.
args[0] = args[0] && args[0].toLowerCase();
return Eventful.prototype[method].apply(host, args);
}
var MessageCenter =
/** @class */
(function (_super) {
__extends(MessageCenter, _super);
function MessageCenter() {
return (_super !== null && _super.apply(this, arguments)) || this;
}
return MessageCenter;
})(Eventful);
var messageCenterProto = MessageCenter.prototype;
messageCenterProto.on = createRegisterEventWithLowercaseMessageCenter("on");
messageCenterProto.off = createRegisterEventWithLowercaseMessageCenter("off"); // ---------------------------------------
// Internal method names for class ECharts
// ---------------------------------------
var prepare;
var prepareView;
var updateDirectly;
var updateMethods;
var doConvertPixel;
var updateStreamModes;
var doDispatchAction;
var flushPendingActions;
var triggerUpdatedEvent;
var bindRenderedEvent;
var bindMouseEvent;
var render;
var renderComponents;
var renderSeries;
var createExtensionAPI;
var enableConnect;
var markStatusToUpdate;
var applyChangedStates;
var ECharts =
/** @class */
(function (_super) {
__extends(ECharts, _super);
function ECharts(
dom, // Theme name or themeOption.
theme,
opts,
) {
var _this = _super.call(this, new ECEventProcessor()) || this;
_this._chartsViews = [];
_this._chartsMap = {};
_this._componentsViews = [];
_this._componentsMap = {}; // Can't dispatch action during rendering procedure
_this._pendingActions = [];
opts = opts || {}; // Get theme by name
if (isString(theme)) {
theme = themeStorage[theme];
}
_this._dom = dom;
var defaultRenderer = "canvas";
var defaultUseDirtyRect = false;
if ("development" !== "production") {
var root =
/* eslint-disable-next-line */
hasWindow ? window : global;
defaultRenderer =
root.__ECHARTS__DEFAULT__RENDERER__ || defaultRenderer;
var devUseDirtyRect = root.__ECHARTS__DEFAULT__USE_DIRTY_RECT__;
defaultUseDirtyRect =
devUseDirtyRect == null ? defaultUseDirtyRect : devUseDirtyRect;
}
var zr = (_this._zr = init(dom, {
renderer: opts.renderer || defaultRenderer,
devicePixelRatio: opts.devicePixelRatio,
width: opts.width,
height: opts.height,
ssr: opts.ssr,
useDirtyRect:
opts.useDirtyRect == null ? defaultUseDirtyRect : opts.useDirtyRect,
}));
_this._ssr = opts.ssr; // Expect 60 fps.
_this._throttledZrFlush = throttle(bind(zr.flush, zr), 17);
theme = clone(theme);
theme && globalBackwardCompat(theme, true);
_this._theme = theme;
_this._locale = createLocaleObject(opts.locale || SYSTEM_LANG);
_this._coordSysMgr = new CoordinateSystemManager();
var api = (_this._api = createExtensionAPI(_this)); // Sort on demand
function prioritySortFunc(a, b) {
return a.__prio - b.__prio;
}
sort(visualFuncs, prioritySortFunc);
sort(dataProcessorFuncs, prioritySortFunc);
_this._scheduler = new Scheduler(
_this,
api,
dataProcessorFuncs,
visualFuncs,
);
_this._messageCenter = new MessageCenter(); // Init mouse events
_this._initEvents(); // In case some people write `window.onresize = chart.resize`
_this.resize = bind(_this.resize, _this);
zr.animation.on("frame", _this._onframe, _this);
bindRenderedEvent(zr, _this);
bindMouseEvent(zr, _this); // ECharts instance can be used as value.
setAsPrimitive(_this);
return _this;
}
ECharts.prototype._onframe = function () {
if (this._disposed) {
return;
}
applyChangedStates(this);
var scheduler = this._scheduler; // Lazy update
if (this[PENDING_UPDATE]) {
var silent = this[PENDING_UPDATE].silent;
this[IN_MAIN_PROCESS_KEY] = true;
try {
prepare(this);
updateMethods.update.call(
this,
null,
this[PENDING_UPDATE].updateParams,
);
} catch (e) {
this[IN_MAIN_PROCESS_KEY] = false;
this[PENDING_UPDATE] = null;
throw e;
} // At present, in each frame, zrender performs:
// (1) animation step forward.
// (2) trigger('frame') (where this `_onframe` is called)
// (3) zrender flush (render).
// If we do nothing here, since we use `setToFinal: true`, the step (3) above
// will render the final state of the elements before the real animation started.
this._zr.flush();
this[IN_MAIN_PROCESS_KEY] = false;
this[PENDING_UPDATE] = null;
flushPendingActions.call(this, silent);
triggerUpdatedEvent.call(this, silent);
} // Avoid do both lazy update and progress in one frame.
else if (scheduler.unfinished) {
// Stream progress.
var remainTime = TEST_FRAME_REMAIN_TIME;
var ecModel = this._model;
var api = this._api;
scheduler.unfinished = false;
do {
var startTime = +new Date();
scheduler.performSeriesTasks(ecModel); // Currently dataProcessorFuncs do not check threshold.
scheduler.performDataProcessorTasks(ecModel);
updateStreamModes(this, ecModel); // Do not update coordinate system here. Because that coord system update in
// each frame is not a good user experience. So we follow the rule that
// the extent of the coordinate system is determin in the first frame (the
// frame is executed immedietely after task reset.
// this._coordSysMgr.update(ecModel, api);
// console.log('--- ec frame visual ---', remainTime);
scheduler.performVisualTasks(ecModel);
renderSeries(this, this._model, api, "remain", {});
remainTime -= +new Date() - startTime;
} while (remainTime > 0 && scheduler.unfinished); // Call flush explicitly for trigger finished event.
if (!scheduler.unfinished) {
this._zr.flush();
} // Else, zr flushing be ensue within the same frame,
// because zr flushing is after onframe event.
}
};
ECharts.prototype.getDom = function () {
return this._dom;
};
ECharts.prototype.getId = function () {
return this.id;
};
ECharts.prototype.getZr = function () {
return this._zr;
};
ECharts.prototype.isSSR = function () {
return this._ssr;
};
/* eslint-disable-next-line */
ECharts.prototype.setOption = function (option, notMerge, lazyUpdate) {
if (this[IN_MAIN_PROCESS_KEY]) {
if ("development" !== "production") {
error("`setOption` should not be called during main process.");
}
return;
}
if (this._disposed) {
disposedWarning(this.id);
return;
}
var silent;
var replaceMerge;
var transitionOpt;
if (isObject(notMerge)) {
lazyUpdate = notMerge.lazyUpdate;
silent = notMerge.silent;
replaceMerge = notMerge.replaceMerge;
transitionOpt = notMerge.transition;
notMerge = notMerge.notMerge;
}
this[IN_MAIN_PROCESS_KEY] = true;
if (!this._model || notMerge) {
var optionManager = new OptionManager(this._api);
var theme = this._theme;
var ecModel = (this._model = new GlobalModel());
ecModel.scheduler = this._scheduler;
ecModel.ssr = this._ssr;
ecModel.init(null, null, null, theme, this._locale, optionManager);
}
this._model.setOption(
option,
{
replaceMerge: replaceMerge,
},
optionPreprocessorFuncs,
);
var updateParams = {
seriesTransition: transitionOpt,
optionChanged: true,
};
if (lazyUpdate) {
this[PENDING_UPDATE] = {
silent: silent,
updateParams: updateParams,
};
this[IN_MAIN_PROCESS_KEY] = false; // `setOption(option, {lazyMode: true})` may be called when zrender has been slept.
// It should wake it up to make sure zrender start to render at the next frame.
this.getZr().wakeUp();
} else {
try {
prepare(this);
updateMethods.update.call(this, null, updateParams);
} catch (e) {
this[PENDING_UPDATE] = null;
this[IN_MAIN_PROCESS_KEY] = false;
throw e;
} // Ensure zr refresh sychronously, and then pixel in canvas can be
// fetched after `setOption`.
if (!this._ssr) {
// not use flush when using ssr mode.
this._zr.flush();
}
this[PENDING_UPDATE] = null;
this[IN_MAIN_PROCESS_KEY] = false;
flushPendingActions.call(this, silent);
triggerUpdatedEvent.call(this, silent);
}
};
/**
* @deprecated
*/
ECharts.prototype.setTheme = function () {
deprecateLog("ECharts#setTheme() is DEPRECATED in ECharts 3.0");
}; // We don't want developers to use getModel directly.
ECharts.prototype.getModel = function () {
return this._model;
};
ECharts.prototype.getOption = function () {
return this._model && this._model.getOption();
};
ECharts.prototype.getWidth = function () {
return this._zr.getWidth();
};
ECharts.prototype.getHeight = function () {
return this._zr.getHeight();
};
ECharts.prototype.getDevicePixelRatio = function () {
return (
this._zr.painter.dpr ||
/* eslint-disable-next-line */
(hasWindow && window.devicePixelRatio) ||
1
);
};
/**
* Get canvas which has all thing rendered
* @deprecated Use renderToCanvas instead.
*/
ECharts.prototype.getRenderedCanvas = function (opts) {
if ("development" !== "production") {
deprecateReplaceLog("getRenderedCanvas", "renderToCanvas");
}
return this.renderToCanvas(opts);
};
ECharts.prototype.renderToCanvas = function (opts) {
opts = opts || {};
var painter = this._zr.painter;
if ("development" !== "production") {
if (painter.type !== "canvas") {
throw new Error(
"renderToCanvas can only be used in the canvas renderer.",
);
}
}
return painter.getRenderedCanvas({
backgroundColor:
opts.backgroundColor || this._model.get("backgroundColor"),
pixelRatio: opts.pixelRatio || this.getDevicePixelRatio(),
});
};
ECharts.prototype.renderToSVGString = function (opts) {
opts = opts || {};
var painter = this._zr.painter;
if ("development" !== "production") {
if (painter.type !== "svg") {
throw new Error(
"renderToSVGString can only be used in the svg renderer.",
);
}
}
return painter.renderToString({
useViewBox: opts.useViewBox,
});
};
/**
* Get svg data url
*/
ECharts.prototype.getSvgDataURL = function () {
if (!env.svgSupported) {
return;
}
var zr = this._zr;
var list = zr.storage.getDisplayList(); // Stop animations
each(list, function (el) {
el.stopAnimation(null, true);
});
return zr.painter.toDataURL();
};
ECharts.prototype.getDataURL = function (opts) {
if (this._disposed) {
disposedWarning(this.id);
return;
}
opts = opts || {};
var excludeComponents = opts.excludeComponents;
var ecModel = this._model;
var excludesComponentViews = [];
var self = this;
each(excludeComponents, function (componentType) {
ecModel.eachComponent(
{
mainType: componentType,
},
function (component) {
var view = self._componentsMap[component.__viewId];
if (!view.group.ignore) {
excludesComponentViews.push(view);
view.group.ignore = true;
}
},
);
});
var url =
this._zr.painter.getType() === "svg"
? this.getSvgDataURL()
: this.renderToCanvas(opts).toDataURL(
"image/" + ((opts && opts.type) || "png"),
);
each(excludesComponentViews, function (view) {
view.group.ignore = false;
});
return url;
};
ECharts.prototype.getConnectedDataURL = function (opts) {
if (this._disposed) {
disposedWarning(this.id);
return;
}
var isSvg = opts.type === "svg";
var groupId = this.group;
var mathMin = Math.min;
var mathMax = Math.max;
var MAX_NUMBER = Infinity;
if (connectedGroups[groupId]) {
var left_1 = MAX_NUMBER;
var top_1 = MAX_NUMBER;
var right_1 = -MAX_NUMBER;
var bottom_1 = -MAX_NUMBER;
var canvasList_1 = [];
var dpr_1 = (opts && opts.pixelRatio) || this.getDevicePixelRatio();
each(instances$1, function (chart, id) {
if (chart.group === groupId) {
var canvas = isSvg
? chart.getZr().painter.getSvgDom().innerHTML
: chart.renderToCanvas(clone(opts));
var boundingRect = chart.getDom().getBoundingClientRect();
left_1 = mathMin(boundingRect.left, left_1);
top_1 = mathMin(boundingRect.top, top_1);
right_1 = mathMax(boundingRect.right, right_1);
bottom_1 = mathMax(boundingRect.bottom, bottom_1);
canvasList_1.push({
dom: canvas,
left: boundingRect.left,
top: boundingRect.top,
});
}
});
left_1 *= dpr_1;
top_1 *= dpr_1;
right_1 *= dpr_1;
bottom_1 *= dpr_1;
var width = right_1 - left_1;
var height = bottom_1 - top_1;
var targetCanvas = platformApi.createCanvas();
var zr_1 = init(targetCanvas, {
renderer: isSvg ? "svg" : "canvas",
});
zr_1.resize({
width: width,
height: height,
});
if (isSvg) {
var content_1 = "";
each(canvasList_1, function (item) {
var x = item.left - left_1;
var y = item.top - top_1;
content_1 +=
'' +
item.dom +
"";
});
zr_1.painter.getSvgRoot().innerHTML = content_1;
if (opts.connectedBackgroundColor) {
zr_1.painter.setBackgroundColor(opts.connectedBackgroundColor);
}
zr_1.refreshImmediately();
return zr_1.painter.toDataURL();
} else {
// Background between the charts
if (opts.connectedBackgroundColor) {
zr_1.add(
new Rect({
shape: {
x: 0,
y: 0,
width: width,
height: height,
},
style: {
fill: opts.connectedBackgroundColor,
},
}),
);
}
each(canvasList_1, function (item) {
var img = new ZRImage({
style: {
x: item.left * dpr_1 - left_1,
y: item.top * dpr_1 - top_1,
image: item.dom,
},
});
zr_1.add(img);
});
zr_1.refreshImmediately();
return targetCanvas.toDataURL(
"image/" + ((opts && opts.type) || "png"),
);
}
} else {
return this.getDataURL(opts);
}
};
ECharts.prototype.convertToPixel = function (finder, value) {
return doConvertPixel(this, "convertToPixel", finder, value);
};
ECharts.prototype.convertFromPixel = function (finder, value) {
return doConvertPixel(this, "convertFromPixel", finder, value);
};
/**
* Is the specified coordinate systems or components contain the given pixel point.
* @param {Array|number} value
* @return {boolean} result
*/
ECharts.prototype.containPixel = function (finder, value) {
if (this._disposed) {
disposedWarning(this.id);
return;
}
var ecModel = this._model;
var result;
var findResult = parseFinder(ecModel, finder);
each(
findResult,
function (models, key) {
key.indexOf("Models") >= 0 &&
each(
models,
function (model) {
var coordSys = model.coordinateSystem;
if (coordSys && coordSys.containPoint) {
result = result || !!coordSys.containPoint(value);
} else if (key === "seriesModels") {
var view = this._chartsMap[model.__viewId];
if (view && view.containPoint) {
result = result || view.containPoint(value, model);
} else {
if ("development" !== "production") {
console.warn(
key +
": " +
(view
? "The found component do not support containPoint."
: "No view mapping to the found component."),
);
}
}
} else {
if ("development" !== "production") {
console.warn(key + ": containPoint is not supported");
}
}
},
this,
);
},
this,
);
return !!result;
};
/**
* Get visual from series or data.
* @param finder
* If string, e.g., 'series', means {seriesIndex: 0}.
* If Object, could contain some of these properties below:
* {
* seriesIndex / seriesId / seriesName,
* dataIndex / dataIndexInside
* }
* If dataIndex is not specified, series visual will be fetched,
* but not data item visual.
* If all of seriesIndex, seriesId, seriesName are not specified,
* visual will be fetched from first series.
* @param visualType 'color', 'symbol', 'symbolSize'
*/
ECharts.prototype.getVisual = function (finder, visualType) {
var ecModel = this._model;
var parsedFinder = parseFinder(ecModel, finder, {
defaultMainType: "series",
});
var seriesModel = parsedFinder.seriesModel;
if ("development" !== "production") {
if (!seriesModel) {
console.warn("There is no specified seires model");
}
}
var data = seriesModel.getData();
var dataIndexInside = parsedFinder.hasOwnProperty("dataIndexInside")
? parsedFinder.dataIndexInside
: parsedFinder.hasOwnProperty("dataIndex")
? data.indexOfRawIndex(parsedFinder.dataIndex)
: null;
return dataIndexInside != null
? getItemVisualFromData(data, dataIndexInside, visualType)
: getVisualFromData(data, visualType);
};
/**
* Get view of corresponding component model
*/
ECharts.prototype.getViewOfComponentModel = function (componentModel) {
return this._componentsMap[componentModel.__viewId];
};
/**
* Get view of corresponding series model
*/
ECharts.prototype.getViewOfSeriesModel = function (seriesModel) {
return this._chartsMap[seriesModel.__viewId];
};
ECharts.prototype._initEvents = function () {
var _this = this;
each(MOUSE_EVENT_NAMES, function (eveName) {
var handler = function (e) {
var ecModel = _this.getModel();
var el = e.target;
var params;
var isGlobalOut = eveName === "globalout"; // no e.target when 'globalout'.
if (isGlobalOut) {
params = {};
} else {
el &&
findEventDispatcher(
el,
function (parent) {
var ecData = getECData(parent);
if (ecData && ecData.dataIndex != null) {
var dataModel =
ecData.dataModel ||
ecModel.getSeriesByIndex(ecData.seriesIndex);
params =
(dataModel &&
dataModel.getDataParams(
ecData.dataIndex,
ecData.dataType,
)) ||
{};
return true;
} // If element has custom eventData of components
else if (ecData.eventData) {
params = extend({}, ecData.eventData);
return true;
}
},
true,
);
} // Contract: if params prepared in mouse event,
// these properties must be specified:
// {
// componentType: string (component main type)
// componentIndex: number
// }
// Otherwise event query can not work.
if (params) {
var componentType = params.componentType;
var componentIndex = params.componentIndex; // Special handling for historic reason: when trigger by
// markLine/markPoint/markArea, the componentType is
// 'markLine'/'markPoint'/'markArea', but we should better
// enable them to be queried by seriesIndex, since their
// option is set in each series.
if (
componentType === "markLine" ||
componentType === "markPoint" ||
componentType === "markArea"
) {
componentType = "series";
componentIndex = params.seriesIndex;
}
var model =
componentType &&
componentIndex != null &&
ecModel.getComponent(componentType, componentIndex);
var view =
model &&
_this[
model.mainType === "series" ? "_chartsMap" : "_componentsMap"
][model.__viewId];
if ("development" !== "production") {
// `event.componentType` and `event[componentTpype + 'Index']` must not
// be missed, otherwise there is no way to distinguish source component.
// See `dataFormat.getDataParams`.
if (!isGlobalOut && !(model && view)) {
console.warn("model or view can not be found by params");
}
}
params.event = e;
params.type = eveName;
_this._$eventProcessor.eventInfo = {
targetEl: el,
packedEvent: params,
model: model,
view: view,
};
_this.trigger(eveName, params);
}
}; // Consider that some component (like tooltip, brush, ...)
// register zr event handler, but user event handler might
// do anything, such as call `setOption` or `dispatchAction`,
// which probably update any of the content and probably
// cause problem if it is called previous other inner handlers.
handler.zrEventfulCallAtLast = true;
_this._zr.on(eveName, handler, _this);
});
each(eventActionMap, function (actionType, eventType) {
_this._messageCenter.on(
eventType,
function (event) {
this.trigger(eventType, event);
},
_this,
);
}); // Extra events
// TODO register?
each(["selectchanged"], function (eventType) {
_this._messageCenter.on(
eventType,
function (event) {
this.trigger(eventType, event);
},
_this,
);
});
handleLegacySelectEvents(this._messageCenter, this, this._api);
};
ECharts.prototype.isDisposed = function () {
return this._disposed;
};
ECharts.prototype.clear = function () {
if (this._disposed) {
disposedWarning(this.id);
return;
}
this.setOption(
{
series: [],
},
true,
);
};
ECharts.prototype.dispose = function () {
if (this._disposed) {
disposedWarning(this.id);
return;
}
this._disposed = true;
var dom = this.getDom();
if (dom) {
setAttribute(this.getDom(), DOM_ATTRIBUTE_KEY, "");
}
var chart = this;
var api = chart._api;
var ecModel = chart._model;
each(chart._componentsViews, function (component) {
component.dispose(ecModel, api);
});
each(chart._chartsViews, function (chart) {
chart.dispose(ecModel, api);
}); // Dispose after all views disposed
chart._zr.dispose(); // Set properties to null.
// To reduce the memory cost in case the top code still holds this instance unexpectedly.
chart._dom =
chart._model =
chart._chartsMap =
chart._componentsMap =
chart._chartsViews =
chart._componentsViews =
chart._scheduler =
chart._api =
chart._zr =
chart._throttledZrFlush =
chart._theme =
chart._coordSysMgr =
chart._messageCenter =
null;
delete instances$1[chart.id];
};
/**
* Resize the chart
*/
ECharts.prototype.resize = function (opts) {
if (this[IN_MAIN_PROCESS_KEY]) {
if ("development" !== "production") {
error("`resize` should not be called during main process.");
}
return;
}
if (this._disposed) {
disposedWarning(this.id);
return;
}
this._zr.resize(opts);
var ecModel = this._model; // Resize loading effect
this._loadingFX && this._loadingFX.resize();
if (!ecModel) {
return;
}
var needPrepare = ecModel.resetOption("media");
var silent = opts && opts.silent; // There is some real cases that:
// chart.setOption(option, { lazyUpdate: true });
// chart.resize();
if (this[PENDING_UPDATE]) {
if (silent == null) {
silent = this[PENDING_UPDATE].silent;
}
needPrepare = true;
this[PENDING_UPDATE] = null;
}
this[IN_MAIN_PROCESS_KEY] = true;
try {
needPrepare && prepare(this);
updateMethods.update.call(this, {
type: "resize",
animation: extend(
{
// Disable animation
duration: 0,
},
opts && opts.animation,
),
});
} catch (e) {
this[IN_MAIN_PROCESS_KEY] = false;
throw e;
}
this[IN_MAIN_PROCESS_KEY] = false;
flushPendingActions.call(this, silent);
triggerUpdatedEvent.call(this, silent);
};
ECharts.prototype.showLoading = function (name, cfg) {
if (this._disposed) {
disposedWarning(this.id);
return;
}
if (isObject(name)) {
cfg = name;
name = "";
}
name = name || "default";
this.hideLoading();
if (!loadingEffects[name]) {
if ("development" !== "production") {
console.warn("Loading effects " + name + " not exists.");
}
return;
}
var el = loadingEffects[name](this._api, cfg);
var zr = this._zr;
this._loadingFX = el;
zr.add(el);
};
/**
* Hide loading effect
*/
ECharts.prototype.hideLoading = function () {
if (this._disposed) {
disposedWarning(this.id);
return;
}
this._loadingFX && this._zr.remove(this._loadingFX);
this._loadingFX = null;
};
ECharts.prototype.makeActionFromEvent = function (eventObj) {
var payload = extend({}, eventObj);
payload.type = eventActionMap[eventObj.type];
return payload;
};
/**
* @param opt If pass boolean, means opt.silent
* @param opt.silent Default `false`. Whether trigger events.
* @param opt.flush Default `undefined`.
* true: Flush immediately, and then pixel in canvas can be fetched
* immediately. Caution: it might affect performance.
* false: Not flush.
* undefined: Auto decide whether perform flush.
*/
ECharts.prototype.dispatchAction = function (payload, opt) {
if (this._disposed) {
disposedWarning(this.id);
return;
}
if (!isObject(opt)) {
opt = {
silent: !!opt,
};
}
if (!actions[payload.type]) {
return;
} // Avoid dispatch action before setOption. Especially in `connect`.
if (!this._model) {
return;
} // May dispatchAction in rendering procedure
if (this[IN_MAIN_PROCESS_KEY]) {
this._pendingActions.push(payload);
return;
}
var silent = opt.silent;
doDispatchAction.call(this, payload, silent);
var flush = opt.flush;
if (flush) {
this._zr.flush();
} else if (flush !== false && env.browser.weChat) {
// In WeChat embeded browser, `requestAnimationFrame` and `setInterval`
// hang when sliding page (on touch event), which cause that zr does not
// refresh util user interaction finished, which is not expected.
// But `dispatchAction` may be called too frequently when pan on touch
// screen, which impacts performance if do not throttle them.
this._throttledZrFlush();
}
flushPendingActions.call(this, silent);
triggerUpdatedEvent.call(this, silent);
};
ECharts.prototype.updateLabelLayout = function () {
lifecycle.trigger("series:layoutlabels", this._model, this._api, {
// Not adding series labels.
// TODO
updatedSeries: [],
});
};
ECharts.prototype.appendData = function (params) {
if (this._disposed) {
disposedWarning(this.id);
return;
}
var seriesIndex = params.seriesIndex;
var ecModel = this.getModel();
var seriesModel = ecModel.getSeriesByIndex(seriesIndex);
if ("development" !== "production") {
assert(params.data && seriesModel);
}
seriesModel.appendData(params); // Note: `appendData` does not support that update extent of coordinate
// system, util some scenario require that. In the expected usage of
// `appendData`, the initial extent of coordinate system should better
// be fixed by axis `min`/`max` setting or initial data, otherwise if
// the extent changed while `appendData`, the location of the painted
// graphic elements have to be changed, which make the usage of
// `appendData` meaningless.
this._scheduler.unfinished = true;
this.getZr().wakeUp();
}; // A work around for no `internal` modifier in ts yet but
// need to strictly hide private methods to JS users.
ECharts.internalField = (function () {
prepare = function (ecIns) {
var scheduler = ecIns._scheduler;
scheduler.restorePipelines(ecIns._model);
scheduler.prepareStageTasks();
prepareView(ecIns, true);
prepareView(ecIns, false);
scheduler.plan();
};
/**
* Prepare view instances of charts and components
*/
prepareView = function (ecIns, isComponent) {
var ecModel = ecIns._model;
var scheduler = ecIns._scheduler;
var viewList = isComponent
? ecIns._componentsViews
: ecIns._chartsViews;
var viewMap = isComponent ? ecIns._componentsMap : ecIns._chartsMap;
var zr = ecIns._zr;
var api = ecIns._api;
for (var i = 0; i < viewList.length; i++) {
viewList[i].__alive = false;
}
isComponent
? ecModel.eachComponent(function (componentType, model) {
componentType !== "series" && doPrepare(model);
})
: ecModel.eachSeries(doPrepare);
function doPrepare(model) {
// By defaut view will be reused if possible for the case that `setOption` with "notMerge"
// mode and need to enable transition animation. (Usually, when they have the same id, or
// especially no id but have the same type & name & index. See the `model.id` generation
// rule in `makeIdAndName` and `viewId` generation rule here).
// But in `replaceMerge` mode, this feature should be able to disabled when it is clear that
// the new model has nothing to do with the old model.
var requireNewView = model.__requireNewView; // This command should not work twice.
model.__requireNewView = false; // Consider: id same and type changed.
var viewId = "_ec_" + model.id + "_" + model.type;
var view = !requireNewView && viewMap[viewId];
if (!view) {
var classType = parseClassType(model.type);
var Clazz = isComponent
? ComponentView.getClass(classType.main, classType.sub) // FIXME:TS
: // (ChartView as ChartViewConstructor).getClass('series', classType.sub)
// For backward compat, still support a chart type declared as only subType
// like "liquidfill", but recommend "series.liquidfill"
// But need a base class to make a type series.
ChartView.getClass(classType.sub);
if ("development" !== "production") {
assert(Clazz, classType.sub + " does not exist.");
}
view = new Clazz();
view.init(ecModel, api);
viewMap[viewId] = view;
viewList.push(view);
zr.add(view.group);
}
model.__viewId = view.__id = viewId;
view.__alive = true;
view.__model = model;
view.group.__ecComponentInfo = {
mainType: model.mainType,
index: model.componentIndex,
};
!isComponent && scheduler.prepareView(view, model, ecModel, api);
}
for (var i = 0; i < viewList.length; ) {
var view = viewList[i];
if (!view.__alive) {
!isComponent && view.renderTask.dispose();
zr.remove(view.group);
view.dispose(ecModel, api);
viewList.splice(i, 1);
if (viewMap[view.__id] === view) {
delete viewMap[view.__id];
}
view.__id = view.group.__ecComponentInfo = null;
} else {
i++;
}
}
};
updateDirectly = function (ecIns, method, payload, mainType, subType) {
var ecModel = ecIns._model;
ecModel.setUpdatePayload(payload); // broadcast
if (!mainType) {
// FIXME
// Chart will not be update directly here, except set dirty.
// But there is no such scenario now.
each(
[].concat(ecIns._componentsViews).concat(ecIns._chartsViews),
callView,
);
return;
}
var query = {};
query[mainType + "Id"] = payload[mainType + "Id"];
query[mainType + "Index"] = payload[mainType + "Index"];
query[mainType + "Name"] = payload[mainType + "Name"];
var condition = {
mainType: mainType,
query: query,
};
subType && (condition.subType = subType); // subType may be '' by parseClassType;
var excludeSeriesId = payload.excludeSeriesId;
var excludeSeriesIdMap;
if (excludeSeriesId != null) {
excludeSeriesIdMap = createHashMap();
each(normalizeToArray(excludeSeriesId), function (id) {
var modelId = convertOptionIdName(id, null);
if (modelId != null) {
excludeSeriesIdMap.set(modelId, true);
}
});
} // If dispatchAction before setOption, do nothing.
ecModel &&
ecModel.eachComponent(
condition,
function (model) {
var isExcluded =
excludeSeriesIdMap &&
excludeSeriesIdMap.get(model.id) !== null;
if (isExcluded) {
return;
}
if (isHighDownPayload(payload)) {
if (model instanceof SeriesModel) {
if (
payload.type === HIGHLIGHT_ACTION_TYPE &&
!payload.notBlur &&
!model.get(["emphasis", "disabled"])
) {
blurSeriesFromHighlightPayload(
model,
payload,
ecIns._api,
);
}
} else {
var _a = findComponentHighDownDispatchers(
model.mainType,
model.componentIndex,
payload.name,
ecIns._api,
),
focusSelf = _a.focusSelf,
dispatchers = _a.dispatchers;
if (
payload.type === HIGHLIGHT_ACTION_TYPE &&
focusSelf &&
!payload.notBlur
) {
blurComponent(
model.mainType,
model.componentIndex,
ecIns._api,
);
} // PENDING:
// Whether to put this "enter emphasis" code in `ComponentView`,
// which will be the same as `ChartView` but might be not necessary
// and will be far from this logic.
if (dispatchers) {
each(dispatchers, function (dispatcher) {
payload.type === HIGHLIGHT_ACTION_TYPE
? enterEmphasis(dispatcher)
: leaveEmphasis(dispatcher);
});
}
}
} else if (isSelectChangePayload(payload)) {
// TODO geo
if (model instanceof SeriesModel) {
toggleSelectionFromPayload(model, payload, ecIns._api);
updateSeriesElementSelection(model);
markStatusToUpdate(ecIns);
}
}
},
ecIns,
);
ecModel &&
ecModel.eachComponent(
condition,
function (model) {
var isExcluded =
excludeSeriesIdMap &&
excludeSeriesIdMap.get(model.id) !== null;
if (isExcluded) {
return;
}
callView(
ecIns[
mainType === "series" ? "_chartsMap" : "_componentsMap"
][model.__viewId],
);
},
ecIns,
);
function callView(view) {
view &&
view.__alive &&
view[method] &&
view[method](view.__model, ecModel, ecIns._api, payload);
}
};
updateMethods = {
prepareAndUpdate: function (payload) {
prepare(this);
updateMethods.update.call(this, payload, {
// Needs to mark option changed if newOption is given.
// It's from MagicType.
// TODO If use a separate flag optionChanged in payload?
optionChanged: payload.newOption != null,
});
},
update: function (payload, updateParams) {
var ecModel = this._model;
var api = this._api;
var zr = this._zr;
var coordSysMgr = this._coordSysMgr;
var scheduler = this._scheduler; // update before setOption
if (!ecModel) {
return;
}
ecModel.setUpdatePayload(payload);
scheduler.restoreData(ecModel, payload);
scheduler.performSeriesTasks(ecModel); // TODO
// Save total ecModel here for undo/redo (after restoring data and before processing data).
// Undo (restoration of total ecModel) can be carried out in 'action' or outside API call.
// Create new coordinate system each update
// In LineView may save the old coordinate system and use it to get the orignal point
coordSysMgr.create(ecModel, api);
scheduler.performDataProcessorTasks(ecModel, payload); // Current stream render is not supported in data process. So we can update
// stream modes after data processing, where the filtered data is used to
// deteming whether use progressive rendering.
updateStreamModes(this, ecModel); // We update stream modes before coordinate system updated, then the modes info
// can be fetched when coord sys updating (consider the barGrid extent fix). But
// the drawback is the full coord info can not be fetched. Fortunately this full
// coord is not requied in stream mode updater currently.
coordSysMgr.update(ecModel, api);
clearColorPalette(ecModel);
scheduler.performVisualTasks(ecModel, payload);
render(this, ecModel, api, payload, updateParams); // Set background
var backgroundColor =
ecModel.get("backgroundColor") || "transparent";
var darkMode = ecModel.get("darkMode");
zr.setBackgroundColor(backgroundColor); // Force set dark mode.
if (darkMode != null && darkMode !== "auto") {
zr.setDarkMode(darkMode);
}
lifecycle.trigger("afterupdate", ecModel, api);
},
updateTransform: function (payload) {
var _this = this;
var ecModel = this._model;
var api = this._api; // update before setOption
if (!ecModel) {
return;
}
ecModel.setUpdatePayload(payload); // ChartView.markUpdateMethod(payload, 'updateTransform');
var componentDirtyList = [];
ecModel.eachComponent(function (componentType, componentModel) {
if (componentType === "series") {
return;
}
var componentView = _this.getViewOfComponentModel(componentModel);
if (componentView && componentView.__alive) {
if (componentView.updateTransform) {
var result = componentView.updateTransform(
componentModel,
ecModel,
api,
payload,
);
result &&
result.update &&
componentDirtyList.push(componentView);
} else {
componentDirtyList.push(componentView);
}
}
});
var seriesDirtyMap = createHashMap();
ecModel.eachSeries(function (seriesModel) {
var chartView = _this._chartsMap[seriesModel.__viewId];
if (chartView.updateTransform) {
var result = chartView.updateTransform(
seriesModel,
ecModel,
api,
payload,
);
result &&
result.update &&
seriesDirtyMap.set(seriesModel.uid, 1);
} else {
seriesDirtyMap.set(seriesModel.uid, 1);
}
});
clearColorPalette(ecModel); // Keep pipe to the exist pipeline because it depends on the render task of the full pipeline.
// this._scheduler.performVisualTasks(ecModel, payload, 'layout', true);
this._scheduler.performVisualTasks(ecModel, payload, {
setDirty: true,
dirtyMap: seriesDirtyMap,
}); // Currently, not call render of components. Geo render cost a lot.
// renderComponents(ecIns, ecModel, api, payload, componentDirtyList);
renderSeries(this, ecModel, api, payload, {}, seriesDirtyMap);
lifecycle.trigger("afterupdate", ecModel, api);
},
updateView: function (payload) {
var ecModel = this._model; // update before setOption
if (!ecModel) {
return;
}
ecModel.setUpdatePayload(payload);
ChartView.markUpdateMethod(payload, "updateView");
clearColorPalette(ecModel); // Keep pipe to the exist pipeline because it depends on the render task of the full pipeline.
this._scheduler.performVisualTasks(ecModel, payload, {
setDirty: true,
});
render(this, ecModel, this._api, payload, {});
lifecycle.trigger("afterupdate", ecModel, this._api);
},
updateVisual: function (payload) {
// updateMethods.update.call(this, payload);
var _this = this;
var ecModel = this._model; // update before setOption
if (!ecModel) {
return;
}
ecModel.setUpdatePayload(payload); // clear all visual
ecModel.eachSeries(function (seriesModel) {
seriesModel.getData().clearAllVisual();
}); // Perform visual
ChartView.markUpdateMethod(payload, "updateVisual");
clearColorPalette(ecModel); // Keep pipe to the exist pipeline because it depends on the render task of the full pipeline.
this._scheduler.performVisualTasks(ecModel, payload, {
visualType: "visual",
setDirty: true,
});
ecModel.eachComponent(function (componentType, componentModel) {
if (componentType !== "series") {
var componentView =
_this.getViewOfComponentModel(componentModel);
componentView &&
componentView.__alive &&
componentView.updateVisual(
componentModel,
ecModel,
_this._api,
payload,
);
}
});
ecModel.eachSeries(function (seriesModel) {
var chartView = _this._chartsMap[seriesModel.__viewId];
chartView.updateVisual(seriesModel, ecModel, _this._api, payload);
});
lifecycle.trigger("afterupdate", ecModel, this._api);
},
updateLayout: function (payload) {
updateMethods.update.call(this, payload);
},
};
doConvertPixel = function (ecIns, methodName, finder, value) {
if (ecIns._disposed) {
disposedWarning(ecIns.id);
return;
}
var ecModel = ecIns._model;
var coordSysList = ecIns._coordSysMgr.getCoordinateSystems();
var result;
var parsedFinder = parseFinder(ecModel, finder);
for (var i = 0; i < coordSysList.length; i++) {
var coordSys = coordSysList[i];
if (
coordSys[methodName] &&
(result = coordSys[methodName](ecModel, parsedFinder, value)) !=
null
) {
return result;
}
}
if ("development" !== "production") {
console.warn(
"No coordinate system that supports " +
methodName +
" found by the given finder.",
);
}
};
updateStreamModes = function (ecIns, ecModel) {
var chartsMap = ecIns._chartsMap;
var scheduler = ecIns._scheduler;
ecModel.eachSeries(function (seriesModel) {
scheduler.updateStreamModes(
seriesModel,
chartsMap[seriesModel.__viewId],
);
});
};
doDispatchAction = function (payload, silent) {
var _this = this;
var ecModel = this.getModel();
var payloadType = payload.type;
var escapeConnect = payload.escapeConnect;
var actionWrap = actions[payloadType];
var actionInfo = actionWrap.actionInfo;
var cptTypeTmp = (actionInfo.update || "update").split(":");
var updateMethod = cptTypeTmp.pop();
var cptType = cptTypeTmp[0] != null && parseClassType(cptTypeTmp[0]);
this[IN_MAIN_PROCESS_KEY] = true;
var payloads = [payload];
var batched = false; // Batch action
if (payload.batch) {
batched = true;
payloads = map(payload.batch, function (item) {
item = defaults(extend({}, item), payload);
item.batch = null;
return item;
});
}
var eventObjBatch = [];
var eventObj;
var isSelectChange = isSelectChangePayload(payload);
var isHighDown = isHighDownPayload(payload); // Only leave blur once if there are multiple batches.
if (isHighDown) {
allLeaveBlur(this._api);
}
each(payloads, function (batchItem) {
// Action can specify the event by return it.
eventObj = actionWrap.action(batchItem, _this._model, _this._api); // Emit event outside
eventObj = eventObj || extend({}, batchItem); // Convert type to eventType
eventObj.type = actionInfo.event || eventObj.type;
eventObjBatch.push(eventObj); // light update does not perform data process, layout and visual.
if (isHighDown) {
var _a = preParseFinder(payload),
queryOptionMap = _a.queryOptionMap,
mainTypeSpecified = _a.mainTypeSpecified;
var componentMainType = mainTypeSpecified
? queryOptionMap.keys()[0]
: "series";
updateDirectly(_this, updateMethod, batchItem, componentMainType);
markStatusToUpdate(_this);
} else if (isSelectChange) {
// At present `dispatchAction({ type: 'select', ... })` is not supported on components.
// geo still use 'geoselect'.
updateDirectly(_this, updateMethod, batchItem, "series");
markStatusToUpdate(_this);
} else if (cptType) {
updateDirectly(
_this,
updateMethod,
batchItem,
cptType.main,
cptType.sub,
);
}
});
if (
updateMethod !== "none" &&
!isHighDown &&
!isSelectChange &&
!cptType
) {
try {
// Still dirty
if (this[PENDING_UPDATE]) {
prepare(this);
updateMethods.update.call(this, payload);
this[PENDING_UPDATE] = null;
} else {
updateMethods[updateMethod].call(this, payload);
}
} catch (e) {
this[IN_MAIN_PROCESS_KEY] = false;
throw e;
}
} // Follow the rule of action batch
if (batched) {
eventObj = {
type: actionInfo.event || payloadType,
escapeConnect: escapeConnect,
batch: eventObjBatch,
};
} else {
eventObj = eventObjBatch[0];
}
this[IN_MAIN_PROCESS_KEY] = false;
if (!silent) {
var messageCenter = this._messageCenter;
messageCenter.trigger(eventObj.type, eventObj); // Extra triggered 'selectchanged' event
if (isSelectChange) {
var newObj = {
type: "selectchanged",
escapeConnect: escapeConnect,
selected: getAllSelectedIndices(ecModel),
isFromClick: payload.isFromClick || false,
fromAction: payload.type,
fromActionPayload: payload,
};
messageCenter.trigger(newObj.type, newObj);
}
}
};
flushPendingActions = function (silent) {
var pendingActions = this._pendingActions;
while (pendingActions.length) {
var payload = pendingActions.shift();
doDispatchAction.call(this, payload, silent);
}
};
triggerUpdatedEvent = function (silent) {
!silent && this.trigger("updated");
};
/**
* Event `rendered` is triggered when zr
* rendered. It is useful for realtime
* snapshot (reflect animation).
*
* Event `finished` is triggered when:
* (1) zrender rendering finished.
* (2) initial animation finished.
* (3) progressive rendering finished.
* (4) no pending action.
* (5) no delayed setOption needs to be processed.
*/
bindRenderedEvent = function (zr, ecIns) {
zr.on("rendered", function (params) {
ecIns.trigger("rendered", params); // The `finished` event should not be triggered repeatly,
// so it should only be triggered when rendering indeed happend
// in zrender. (Consider the case that dipatchAction is keep
// triggering when mouse move).
if (
// Although zr is dirty if initial animation is not finished
// and this checking is called on frame, we also check
// animation finished for robustness.
zr.animation.isFinished() &&
!ecIns[PENDING_UPDATE] &&
!ecIns._scheduler.unfinished &&
!ecIns._pendingActions.length
) {
ecIns.trigger("finished");
}
});
};
bindMouseEvent = function (zr, ecIns) {
zr.on("mouseover", function (e) {
var el = e.target;
var dispatcher = findEventDispatcher(el, isHighDownDispatcher);
if (dispatcher) {
handleGlobalMouseOverForHighDown(dispatcher, e, ecIns._api);
markStatusToUpdate(ecIns);
}
})
.on("mouseout", function (e) {
var el = e.target;
var dispatcher = findEventDispatcher(el, isHighDownDispatcher);
if (dispatcher) {
handleGlobalMouseOutForHighDown(dispatcher, e, ecIns._api);
markStatusToUpdate(ecIns);
}
})
.on("click", function (e) {
var el = e.target;
var dispatcher = findEventDispatcher(
el,
function (target) {
return getECData(target).dataIndex != null;
},
true,
);
if (dispatcher) {
var actionType = dispatcher.selected ? "unselect" : "select";
var ecData = getECData(dispatcher);
ecIns._api.dispatchAction({
type: actionType,
dataType: ecData.dataType,
dataIndexInside: ecData.dataIndex,
seriesIndex: ecData.seriesIndex,
isFromClick: true,
});
}
});
};
function clearColorPalette(ecModel) {
ecModel.clearColorPalette();
ecModel.eachSeries(function (seriesModel) {
seriesModel.clearColorPalette();
});
}
function allocateZlevels(ecModel) {
var componentZLevels = [];
var seriesZLevels = [];
var hasSeperateZLevel = false;
ecModel.eachComponent(function (componentType, componentModel) {
var zlevel = componentModel.get("zlevel") || 0;
var z = componentModel.get("z") || 0;
var zlevelKey = componentModel.getZLevelKey();
hasSeperateZLevel = hasSeperateZLevel || !!zlevelKey;
(componentType === "series"
? seriesZLevels
: componentZLevels
).push({
zlevel: zlevel,
z: z,
idx: componentModel.componentIndex,
type: componentType,
key: zlevelKey,
});
});
if (hasSeperateZLevel) {
// Series after component
var zLevels = componentZLevels.concat(seriesZLevels);
var lastSeriesZLevel_1;
var lastSeriesKey_1;
sort(zLevels, function (a, b) {
if (a.zlevel === b.zlevel) {
return a.z - b.z;
}
return a.zlevel - b.zlevel;
});
each(zLevels, function (item) {
var componentModel = ecModel.getComponent(item.type, item.idx);
var zlevel = item.zlevel;
var key = item.key;
if (lastSeriesZLevel_1 != null) {
zlevel = Math.max(lastSeriesZLevel_1, zlevel);
}
if (key) {
if (zlevel === lastSeriesZLevel_1 && key !== lastSeriesKey_1) {
zlevel++;
}
lastSeriesKey_1 = key;
} else if (lastSeriesKey_1) {
if (zlevel === lastSeriesZLevel_1) {
zlevel++;
}
lastSeriesKey_1 = "";
}
lastSeriesZLevel_1 = zlevel;
componentModel.setZLevel(zlevel);
});
}
}
render = function (ecIns, ecModel, api, payload, updateParams) {
allocateZlevels(ecModel);
renderComponents(ecIns, ecModel, api, payload, updateParams);
each(ecIns._chartsViews, function (chart) {
chart.__alive = false;
});
renderSeries(ecIns, ecModel, api, payload, updateParams); // Remove groups of unrendered charts
each(ecIns._chartsViews, function (chart) {
if (!chart.__alive) {
chart.remove(ecModel, api);
}
});
};
renderComponents = function (
ecIns,
ecModel,
api,
payload,
updateParams,
dirtyList,
) {
each(dirtyList || ecIns._componentsViews, function (componentView) {
var componentModel = componentView.__model;
clearStates(componentModel, componentView);
componentView.render(componentModel, ecModel, api, payload);
updateZ(componentModel, componentView);
updateStates(componentModel, componentView);
});
};
/**
* Render each chart and component
*/
renderSeries = function (
ecIns,
ecModel,
api,
payload,
updateParams,
dirtyMap,
) {
// Render all charts
var scheduler = ecIns._scheduler;
updateParams = extend(updateParams || {}, {
updatedSeries: ecModel.getSeries(),
}); // TODO progressive?
lifecycle.trigger("series:beforeupdate", ecModel, api, updateParams);
var unfinished = false;
ecModel.eachSeries(function (seriesModel) {
var chartView = ecIns._chartsMap[seriesModel.__viewId];
chartView.__alive = true;
var renderTask = chartView.renderTask;
scheduler.updatePayload(renderTask, payload); // TODO states on marker.
clearStates(seriesModel, chartView);
if (dirtyMap && dirtyMap.get(seriesModel.uid)) {
renderTask.dirty();
}
if (renderTask.perform(scheduler.getPerformArgs(renderTask))) {
unfinished = true;
}
chartView.group.silent = !!seriesModel.get("silent"); // Should not call markRedraw on group, because it will disable zrender
// increamental render (alway render from the __startIndex each frame)
// chartView.group.markRedraw();
updateBlend(seriesModel, chartView);
updateSeriesElementSelection(seriesModel);
});
scheduler.unfinished = unfinished || scheduler.unfinished;
lifecycle.trigger("series:layoutlabels", ecModel, api, updateParams); // transition after label is layouted.
lifecycle.trigger("series:transition", ecModel, api, updateParams);
ecModel.eachSeries(function (seriesModel) {
var chartView = ecIns._chartsMap[seriesModel.__viewId]; // Update Z after labels updated. Before applying states.
updateZ(seriesModel, chartView); // NOTE: Update states after label is updated.
// label should be in normal status when layouting.
updateStates(seriesModel, chartView);
}); // If use hover layer
updateHoverLayerStatus(ecIns, ecModel);
lifecycle.trigger("series:afterupdate", ecModel, api, updateParams);
};
markStatusToUpdate = function (ecIns) {
ecIns[STATUS_NEEDS_UPDATE_KEY] = true; // Wake up zrender if it's sleep. Let it update states in the next frame.
ecIns.getZr().wakeUp();
};
applyChangedStates = function (ecIns) {
if (!ecIns[STATUS_NEEDS_UPDATE_KEY]) {
return;
}
ecIns.getZr().storage.traverse(function (el) {
// Not applied on removed elements, it may still in fading.
if (isElementRemoved(el)) {
return;
}
applyElementStates(el);
});
ecIns[STATUS_NEEDS_UPDATE_KEY] = false;
};
function applyElementStates(el) {
var newStates = [];
var oldStates = el.currentStates; // Keep other states.
for (var i = 0; i < oldStates.length; i++) {
var stateName = oldStates[i];
if (
!(
stateName === "emphasis" ||
stateName === "blur" ||
stateName === "select"
)
) {
newStates.push(stateName);
}
} // Only use states when it's exists.
if (el.selected && el.states.select) {
newStates.push("select");
}
if (el.hoverState === HOVER_STATE_EMPHASIS && el.states.emphasis) {
newStates.push("emphasis");
} else if (el.hoverState === HOVER_STATE_BLUR && el.states.blur) {
newStates.push("blur");
}
el.useStates(newStates);
}
function updateHoverLayerStatus(ecIns, ecModel) {
var zr = ecIns._zr;
var storage = zr.storage;
var elCount = 0;
storage.traverse(function (el) {
if (!el.isGroup) {
elCount++;
}
});
if (
elCount > ecModel.get("hoverLayerThreshold") &&
!env.node &&
!env.worker
) {
ecModel.eachSeries(function (seriesModel) {
if (seriesModel.preventUsingHoverLayer) {
return;
}
var chartView = ecIns._chartsMap[seriesModel.__viewId];
if (chartView.__alive) {
chartView.eachRendered(function (el) {
if (el.states.emphasis) {
el.states.emphasis.hoverLayer = true;
}
});
}
});
}
}
/**
* Update chart and blend.
*/
function updateBlend(seriesModel, chartView) {
var blendMode = seriesModel.get("blendMode") || null;
chartView.eachRendered(function (el) {
// FIXME marker and other components
if (!el.isGroup) {
// DONT mark the element dirty. In case element is incremental and don't wan't to rerender.
el.style.blend = blendMode;
}
});
}
function updateZ(model, view) {
if (model.preventAutoZ) {
return;
}
var z = model.get("z") || 0;
var zlevel = model.get("zlevel") || 0; // Set z and zlevel
view.eachRendered(function (el) {
doUpdateZ(el, z, zlevel, -Infinity); // Don't traverse the children because it has been traversed in _updateZ.
return true;
});
}
function doUpdateZ(el, z, zlevel, maxZ2) {
// Group may also have textContent
var label = el.getTextContent();
var labelLine = el.getTextGuideLine();
var isGroup = el.isGroup;
if (isGroup) {
// set z & zlevel of children elements of Group
var children = el.childrenRef();
for (var i = 0; i < children.length; i++) {
maxZ2 = Math.max(doUpdateZ(children[i], z, zlevel, maxZ2), maxZ2);
}
} else {
// not Group
el.z = z;
el.zlevel = zlevel;
maxZ2 = Math.max(el.z2, maxZ2);
} // always set z and zlevel if label/labelLine exists
if (label) {
label.z = z;
label.zlevel = zlevel; // lift z2 of text content
// TODO if el.emphasis.z2 is spcefied, what about textContent.
isFinite(maxZ2) && (label.z2 = maxZ2 + 2);
}
if (labelLine) {
var textGuideLineConfig = el.textGuideLineConfig;
labelLine.z = z;
labelLine.zlevel = zlevel;
isFinite(maxZ2) &&
(labelLine.z2 =
maxZ2 +
(textGuideLineConfig && textGuideLineConfig.showAbove
? 1
: -1));
}
return maxZ2;
} // Clear states without animation.
// TODO States on component.
function clearStates(model, view) {
view.eachRendered(function (el) {
// Not applied on removed elements, it may still in fading.
if (isElementRemoved(el)) {
return;
}
var textContent = el.getTextContent();
var textGuide = el.getTextGuideLine();
if (el.stateTransition) {
el.stateTransition = null;
}
if (textContent && textContent.stateTransition) {
textContent.stateTransition = null;
}
if (textGuide && textGuide.stateTransition) {
textGuide.stateTransition = null;
} // TODO If el is incremental.
if (el.hasState()) {
el.prevStates = el.currentStates;
el.clearStates();
} else if (el.prevStates) {
el.prevStates = null;
}
});
}
function updateStates(model, view) {
var stateAnimationModel = model.getModel("stateAnimation");
var enableAnimation = model.isAnimationEnabled();
var duration = stateAnimationModel.get("duration");
var stateTransition =
duration > 0
? {
duration: duration,
delay: stateAnimationModel.get("delay"),
easing: stateAnimationModel.get("easing"), // additive: stateAnimationModel.get('additive')
}
: null;
view.eachRendered(function (el) {
if (el.states && el.states.emphasis) {
// Not applied on removed elements, it may still in fading.
if (isElementRemoved(el)) {
return;
}
if (el instanceof Path) {
savePathStates(el);
} // Only updated on changed element. In case element is incremental and don't wan't to rerender.
// TODO, a more proper way?
if (el.__dirty) {
var prevStates = el.prevStates; // Restore states without animation
if (prevStates) {
el.useStates(prevStates);
}
} // Update state transition and enable animation again.
if (enableAnimation) {
el.stateTransition = stateTransition;
var textContent = el.getTextContent();
var textGuide = el.getTextGuideLine(); // TODO Is it necessary to animate label?
if (textContent) {
textContent.stateTransition = stateTransition;
}
if (textGuide) {
textGuide.stateTransition = stateTransition;
}
} // The use higlighted and selected flag to toggle states.
if (el.__dirty) {
applyElementStates(el);
}
}
});
}
createExtensionAPI = function (ecIns) {
return new /** @class */
((function (_super) {
__extends(class_1, _super);
function class_1() {
return (_super !== null && _super.apply(this, arguments)) || this;
}
class_1.prototype.getCoordinateSystems = function () {
return ecIns._coordSysMgr.getCoordinateSystems();
};
class_1.prototype.getComponentByElement = function (el) {
while (el) {
var modelInfo = el.__ecComponentInfo;
if (modelInfo != null) {
return ecIns._model.getComponent(
modelInfo.mainType,
modelInfo.index,
);
}
el = el.parent;
}
};
class_1.prototype.enterEmphasis = function (el, highlightDigit) {
enterEmphasis(el, highlightDigit);
markStatusToUpdate(ecIns);
};
class_1.prototype.leaveEmphasis = function (el, highlightDigit) {
leaveEmphasis(el, highlightDigit);
markStatusToUpdate(ecIns);
};
class_1.prototype.enterBlur = function (el) {
enterBlur(el);
markStatusToUpdate(ecIns);
};
class_1.prototype.leaveBlur = function (el) {
leaveBlur(el);
markStatusToUpdate(ecIns);
};
class_1.prototype.enterSelect = function (el) {
enterSelect(el);
markStatusToUpdate(ecIns);
};
class_1.prototype.leaveSelect = function (el) {
leaveSelect(el);
markStatusToUpdate(ecIns);
};
class_1.prototype.getModel = function () {
return ecIns.getModel();
};
class_1.prototype.getViewOfComponentModel = function (
componentModel,
) {
return ecIns.getViewOfComponentModel(componentModel);
};
class_1.prototype.getViewOfSeriesModel = function (seriesModel) {
return ecIns.getViewOfSeriesModel(seriesModel);
};
return class_1;
})(ExtensionAPI))(ecIns);
};
enableConnect = function (chart) {
function updateConnectedChartsStatus(charts, status) {
for (var i = 0; i < charts.length; i++) {
var otherChart = charts[i];
otherChart[CONNECT_STATUS_KEY] = status;
}
}
each(eventActionMap, function (actionType, eventType) {
chart._messageCenter.on(eventType, function (event) {
if (
connectedGroups[chart.group] &&
chart[CONNECT_STATUS_KEY] !== CONNECT_STATUS_PENDING
) {
if (event && event.escapeConnect) {
return;
}
var action_1 = chart.makeActionFromEvent(event);
var otherCharts_1 = [];
each(instances$1, function (otherChart) {
if (
otherChart !== chart &&
otherChart.group === chart.group
) {
otherCharts_1.push(otherChart);
}
});
updateConnectedChartsStatus(
otherCharts_1,
CONNECT_STATUS_PENDING,
);
each(otherCharts_1, function (otherChart) {
if (
otherChart[CONNECT_STATUS_KEY] !== CONNECT_STATUS_UPDATING
) {
otherChart.dispatchAction(action_1);
}
});
updateConnectedChartsStatus(
otherCharts_1,
CONNECT_STATUS_UPDATED,
);
}
});
});
};
})();
return ECharts;
})(Eventful);
var echartsProto = ECharts.prototype;
echartsProto.on = createRegisterEventWithLowercaseECharts("on");
echartsProto.off = createRegisterEventWithLowercaseECharts("off");
/**
* @deprecated
*/
// @ts-ignore
echartsProto.one = function (eventName, cb, ctx) {
var self = this;
deprecateLog("ECharts#one is deprecated.");
function wrapped() {
var args2 = [];
for (var _i = 0; _i < arguments.length; _i++) {
args2[_i] = arguments[_i];
}
cb && cb.apply && cb.apply(this, args2); // @ts-ignore
self.off(eventName, wrapped);
}
this.on.call(this, eventName, wrapped, ctx);
};
var MOUSE_EVENT_NAMES = [
"click",
"dblclick",
"mouseover",
"mouseout",
"mousemove",
"mousedown",
"mouseup",
"globalout",
"contextmenu",
];
function disposedWarning(id) {
if ("development" !== "production") {
console.warn("Instance " + id + " has been disposed");
}
}
var actions = {};
/**
* Map eventType to actionType
*/
var eventActionMap = {};
var dataProcessorFuncs = [];
var optionPreprocessorFuncs = [];
var visualFuncs = [];
var themeStorage = {};
var loadingEffects = {};
var instances$1 = {};
var connectedGroups = {};
var idBase = +new Date() - 0;
var groupIdBase = +new Date() - 0;
var DOM_ATTRIBUTE_KEY = "_echarts_instance_";
/**
* @param opts.devicePixelRatio Use window.devicePixelRatio by default
* @param opts.renderer Can choose 'canvas' or 'svg' to render the chart.
* @param opts.width Use clientWidth of the input `dom` by default.
* Can be 'auto' (the same as null/undefined)
* @param opts.height Use clientHeight of the input `dom` by default.
* Can be 'auto' (the same as null/undefined)
* @param opts.locale Specify the locale.
* @param opts.useDirtyRect Enable dirty rectangle rendering or not.
*/
function init$1(dom, theme, opts) {
var isClient = !(opts && opts.ssr);
if (isClient) {
if ("development" !== "production") {
if (!dom) {
throw new Error("Initialize failed: invalid dom.");
}
}
var existInstance = getInstanceByDom(dom);
if (existInstance) {
if ("development" !== "production") {
console.warn(
"There is a chart instance already initialized on the dom.",
);
}
return existInstance;
}
if ("development" !== "production") {
if (
isDom(dom) &&
dom.nodeName.toUpperCase() !== "CANVAS" &&
((!dom.clientWidth && (!opts || opts.width == null)) ||
(!dom.clientHeight && (!opts || opts.height == null)))
) {
console.warn(
"Can't get DOM width or height. Please check " +
"dom.clientWidth and dom.clientHeight. They should not be 0." +
"For example, you may need to call this in the callback " +
"of window.onload.",
);
}
}
}
var chart = new ECharts(dom, theme, opts);
chart.id = "ec_" + idBase++;
instances$1[chart.id] = chart;
isClient && setAttribute(dom, DOM_ATTRIBUTE_KEY, chart.id);
enableConnect(chart);
lifecycle.trigger("afterinit", chart);
return chart;
}
/**
* @usage
* (A)
* ```js
* let chart1 = echarts.init(dom1);
* let chart2 = echarts.init(dom2);
* chart1.group = 'xxx';
* chart2.group = 'xxx';
* echarts.connect('xxx');
* ```
* (B)
* ```js
* let chart1 = echarts.init(dom1);
* let chart2 = echarts.init(dom2);
* echarts.connect('xxx', [chart1, chart2]);
* ```
*/
function connect(groupId) {
// Is array of charts
if (isArray(groupId)) {
var charts = groupId;
groupId = null; // If any chart has group
each(charts, function (chart) {
if (chart.group != null) {
groupId = chart.group;
}
});
groupId = groupId || "g_" + groupIdBase++;
each(charts, function (chart) {
chart.group = groupId;
});
}
connectedGroups[groupId] = true;
return groupId;
}
/**
* @deprecated
*/
function disConnect(groupId) {
connectedGroups[groupId] = false;
}
/**
* Alias and backword compat
*/
var disconnect = disConnect;
/**
* Dispose a chart instance
*/
function dispose$1(chart) {
if (isString(chart)) {
chart = instances$1[chart];
} else if (!(chart instanceof ECharts)) {
// Try to treat as dom
chart = getInstanceByDom(chart);
}
if (chart instanceof ECharts && !chart.isDisposed()) {
chart.dispose();
}
}
function getInstanceByDom(dom) {
return instances$1[getAttribute(dom, DOM_ATTRIBUTE_KEY)];
}
function getInstanceById(key) {
return instances$1[key];
}
/**
* Register theme
*/
function registerTheme(name, theme) {
themeStorage[name] = theme;
}
/**
* Register option preprocessor
*/
function registerPreprocessor(preprocessorFunc) {
if (indexOf(optionPreprocessorFuncs, preprocessorFunc) < 0) {
optionPreprocessorFuncs.push(preprocessorFunc);
}
}
function registerProcessor(priority, processor) {
normalizeRegister(
dataProcessorFuncs,
priority,
processor,
PRIORITY_PROCESSOR_DEFAULT,
);
}
/**
* Register postIniter
* @param {Function} postInitFunc
*/
function registerPostInit(postInitFunc) {
registerUpdateLifecycle("afterinit", postInitFunc);
}
/**
* Register postUpdater
* @param {Function} postUpdateFunc
*/
function registerPostUpdate(postUpdateFunc) {
registerUpdateLifecycle("afterupdate", postUpdateFunc);
}
function registerUpdateLifecycle(name, cb) {
lifecycle.on(name, cb);
}
function registerAction(actionInfo, eventName, action) {
if (isFunction(eventName)) {
action = eventName;
eventName = "";
}
var actionType = isObject(actionInfo)
? actionInfo.type
: [
actionInfo,
(actionInfo = {
event: eventName,
}),
][0]; // Event name is all lowercase
actionInfo.event = (actionInfo.event || actionType).toLowerCase();
eventName = actionInfo.event;
if (eventActionMap[eventName]) {
// Already registered.
return;
} // Validate action type and event name.
assert(ACTION_REG.test(actionType) && ACTION_REG.test(eventName));
if (!actions[actionType]) {
actions[actionType] = {
action: action,
actionInfo: actionInfo,
};
}
eventActionMap[eventName] = actionType;
}
function registerCoordinateSystem(type, coordSysCreator) {
CoordinateSystemManager.register(type, coordSysCreator);
}
/**
* Get dimensions of specified coordinate system.
* @param {string} type
* @return {Array.}
*/
function getCoordinateSystemDimensions(type) {
var coordSysCreator = CoordinateSystemManager.get(type);
if (coordSysCreator) {
return coordSysCreator.getDimensionsInfo
? coordSysCreator.getDimensionsInfo()
: coordSysCreator.dimensions.slice();
}
}
function registerLayout(priority, layoutTask) {
normalizeRegister(
visualFuncs,
priority,
layoutTask,
PRIORITY_VISUAL_LAYOUT,
"layout",
);
}
function registerVisual(priority, visualTask) {
normalizeRegister(
visualFuncs,
priority,
visualTask,
PRIORITY_VISUAL_CHART,
"visual",
);
}
var registeredTasks = [];
function normalizeRegister(
targetList,
priority,
fn,
defaultPriority,
visualType,
) {
if (isFunction(priority) || isObject(priority)) {
fn = priority;
priority = defaultPriority;
}
if ("development" !== "production") {
if (isNaN(priority) || priority == null) {
throw new Error("Illegal priority");
} // Check duplicate
each(targetList, function (wrap) {
assert(wrap.__raw !== fn);
});
} // Already registered
if (indexOf(registeredTasks, fn) >= 0) {
return;
}
registeredTasks.push(fn);
var stageHandler = Scheduler.wrapStageHandler(fn, visualType);
stageHandler.__prio = priority;
stageHandler.__raw = fn;
targetList.push(stageHandler);
}
function registerLoading(name, loadingFx) {
loadingEffects[name] = loadingFx;
}
/**
* ZRender need a canvas context to do measureText.
* But in node environment canvas may be created by node-canvas.
* So we need to specify how to create a canvas instead of using document.createElement('canvas')
*
*
* @deprecated use setPlatformAPI({ createCanvas }) instead.
*
* @example
* let Canvas = require('canvas');
* let echarts = require('echarts');
* echarts.setCanvasCreator(function () {
* // Small size is enough.
* return new Canvas(32, 32);
* });
*/
function setCanvasCreator(creator) {
if ("development" !== "production") {
deprecateLog(
"setCanvasCreator is deprecated. Use setPlatformAPI({ createCanvas }) instead.",
);
}
setPlatformAPI({
createCanvas: creator,
});
}
/**
* The parameters and usage: see `geoSourceManager.registerMap`.
* Compatible with previous `echarts.registerMap`.
*/
function registerMap(mapName, geoJson, specialAreas) {
var registerMap = getImpl("registerMap");
registerMap && registerMap(mapName, geoJson, specialAreas);
}
function getMap(mapName) {
var getMap = getImpl("getMap");
return getMap && getMap(mapName);
}
var registerTransform = registerExternalTransform;
/**
* Globa dispatchAction to a specified chart instance.
*/
// export function dispatchAction(payload: { chartId: string } & Payload, opt?: Parameters[1]) {
// if (!payload || !payload.chartId) {
// // Must have chartId to find chart
// return;
// }
// const chart = instances[payload.chartId];
// if (chart) {
// chart.dispatchAction(payload, opt);
// }
// }
// Buitlin global visual
registerVisual(PRIORITY_VISUAL_GLOBAL, seriesStyleTask);
registerVisual(PRIORITY_VISUAL_CHART_DATA_CUSTOM, dataStyleTask);
registerVisual(PRIORITY_VISUAL_CHART_DATA_CUSTOM, dataColorPaletteTask);
registerVisual(PRIORITY_VISUAL_GLOBAL, seriesSymbolTask);
registerVisual(PRIORITY_VISUAL_CHART_DATA_CUSTOM, dataSymbolTask);
registerVisual(PRIORITY_VISUAL_DECAL, decalVisual);
registerPreprocessor(globalBackwardCompat);
registerProcessor(PRIORITY_PROCESSOR_DATASTACK, dataStack);
registerLoading("default", defaultLoading); // Default actions
registerAction(
{
type: HIGHLIGHT_ACTION_TYPE,
event: HIGHLIGHT_ACTION_TYPE,
update: HIGHLIGHT_ACTION_TYPE,
},
noop,
);
registerAction(
{
type: DOWNPLAY_ACTION_TYPE,
event: DOWNPLAY_ACTION_TYPE,
update: DOWNPLAY_ACTION_TYPE,
},
noop,
);
registerAction(
{
type: SELECT_ACTION_TYPE,
event: SELECT_ACTION_TYPE,
update: SELECT_ACTION_TYPE,
},
noop,
);
registerAction(
{
type: UNSELECT_ACTION_TYPE,
event: UNSELECT_ACTION_TYPE,
update: UNSELECT_ACTION_TYPE,
},
noop,
);
registerAction(
{
type: TOGGLE_SELECT_ACTION_TYPE,
event: TOGGLE_SELECT_ACTION_TYPE,
update: TOGGLE_SELECT_ACTION_TYPE,
},
noop,
); // Default theme
registerTheme("light", lightTheme);
registerTheme("dark", theme); // For backward compatibility, where the namespace `dataTool` will
// be mounted on `echarts` is the extension `dataTool` is imported.
var dataTool = {};
var extensions = [];
var extensionRegisters = {
registerPreprocessor: registerPreprocessor,
registerProcessor: registerProcessor,
registerPostInit: registerPostInit,
registerPostUpdate: registerPostUpdate,
registerUpdateLifecycle: registerUpdateLifecycle,
registerAction: registerAction,
registerCoordinateSystem: registerCoordinateSystem,
registerLayout: registerLayout,
registerVisual: registerVisual,
registerTransform: registerTransform,
registerLoading: registerLoading,
registerMap: registerMap,
registerImpl: registerImpl,
PRIORITY: PRIORITY,
ComponentModel: ComponentModel,
ComponentView: ComponentView,
SeriesModel: SeriesModel,
ChartView: ChartView,
// TODO Use ComponentModel and SeriesModel instead of Constructor
registerComponentModel: function (ComponentModelClass) {
ComponentModel.registerClass(ComponentModelClass);
},
registerComponentView: function (ComponentViewClass) {
ComponentView.registerClass(ComponentViewClass);
},
registerSeriesModel: function (SeriesModelClass) {
SeriesModel.registerClass(SeriesModelClass);
},
registerChartView: function (ChartViewClass) {
ChartView.registerClass(ChartViewClass);
},
registerSubTypeDefaulter: function (componentType, defaulter) {
ComponentModel.registerSubTypeDefaulter(componentType, defaulter);
},
registerPainter: function (painterType, PainterCtor) {
registerPainter(painterType, PainterCtor);
},
};
function use(ext) {
if (isArray(ext)) {
// use([ChartLine, ChartBar]);
each(ext, function (singleExt) {
use(singleExt);
});
return;
}
if (indexOf(extensions, ext) >= 0) {
return;
}
extensions.push(ext);
if (isFunction(ext)) {
ext = {
install: ext,
};
}
ext.install(extensionRegisters);
}
/*
* 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.
*/
function dataIndexMapValueLength(valNumOrArrLengthMoreThan2) {
return valNumOrArrLengthMoreThan2 == null
? 0
: valNumOrArrLengthMoreThan2.length || 1;
}
function defaultKeyGetter(item) {
return item;
}
var DataDiffer =
/** @class */
(function () {
/**
* @param context Can be visited by this.context in callback.
*/
function DataDiffer(
oldArr,
newArr,
oldKeyGetter,
newKeyGetter,
context, // By default: 'oneToOne'.
diffMode,
) {
this._old = oldArr;
this._new = newArr;
this._oldKeyGetter = oldKeyGetter || defaultKeyGetter;
this._newKeyGetter = newKeyGetter || defaultKeyGetter; // Visible in callback via `this.context`;
this.context = context;
this._diffModeMultiple = diffMode === "multiple";
}
/**
* Callback function when add a data
*/
DataDiffer.prototype.add = function (func) {
this._add = func;
return this;
};
/**
* Callback function when update a data
*/
DataDiffer.prototype.update = function (func) {
this._update = func;
return this;
};
/**
* Callback function when update a data and only work in `cbMode: 'byKey'`.
*/
DataDiffer.prototype.updateManyToOne = function (func) {
this._updateManyToOne = func;
return this;
};
/**
* Callback function when update a data and only work in `cbMode: 'byKey'`.
*/
DataDiffer.prototype.updateOneToMany = function (func) {
this._updateOneToMany = func;
return this;
};
/**
* Callback function when update a data and only work in `cbMode: 'byKey'`.
*/
DataDiffer.prototype.updateManyToMany = function (func) {
this._updateManyToMany = func;
return this;
};
/**
* Callback function when remove a data
*/
DataDiffer.prototype.remove = function (func) {
this._remove = func;
return this;
};
DataDiffer.prototype.execute = function () {
this[
this._diffModeMultiple ? "_executeMultiple" : "_executeOneToOne"
]();
};
DataDiffer.prototype._executeOneToOne = function () {
var oldArr = this._old;
var newArr = this._new;
var newDataIndexMap = {};
var oldDataKeyArr = new Array(oldArr.length);
var newDataKeyArr = new Array(newArr.length);
this._initIndexMap(oldArr, null, oldDataKeyArr, "_oldKeyGetter");
this._initIndexMap(
newArr,
newDataIndexMap,
newDataKeyArr,
"_newKeyGetter",
);
for (var i = 0; i < oldArr.length; i++) {
var oldKey = oldDataKeyArr[i];
var newIdxMapVal = newDataIndexMap[oldKey];
var newIdxMapValLen = dataIndexMapValueLength(newIdxMapVal); // idx can never be empty array here. see 'set null' logic below.
if (newIdxMapValLen > 1) {
// Consider there is duplicate key (for example, use dataItem.name as key).
// We should make sure every item in newArr and oldArr can be visited.
var newIdx = newIdxMapVal.shift();
if (newIdxMapVal.length === 1) {
newDataIndexMap[oldKey] = newIdxMapVal[0];
}
this._update && this._update(newIdx, i);
} else if (newIdxMapValLen === 1) {
newDataIndexMap[oldKey] = null;
this._update && this._update(newIdxMapVal, i);
} else {
this._remove && this._remove(i);
}
}
this._performRestAdd(newDataKeyArr, newDataIndexMap);
};
/**
* For example, consider the case:
* oldData: [o0, o1, o2, o3, o4, o5, o6, o7],
* newData: [n0, n1, n2, n3, n4, n5, n6, n7, n8],
* Where:
* o0, o1, n0 has key 'a' (many to one)
* o5, n4, n5, n6 has key 'b' (one to many)
* o2, n1 has key 'c' (one to one)
* n2, n3 has key 'd' (add)
* o3, o4 has key 'e' (remove)
* o6, o7, n7, n8 has key 'f' (many to many, treated as add and remove)
* Then:
* (The order of the following directives are not ensured.)
* this._updateManyToOne(n0, [o0, o1]);
* this._updateOneToMany([n4, n5, n6], o5);
* this._update(n1, o2);
* this._remove(o3);
* this._remove(o4);
* this._remove(o6);
* this._remove(o7);
* this._add(n2);
* this._add(n3);
* this._add(n7);
* this._add(n8);
*/
DataDiffer.prototype._executeMultiple = function () {
var oldArr = this._old;
var newArr = this._new;
var oldDataIndexMap = {};
var newDataIndexMap = {};
var oldDataKeyArr = [];
var newDataKeyArr = [];
this._initIndexMap(
oldArr,
oldDataIndexMap,
oldDataKeyArr,
"_oldKeyGetter",
);
this._initIndexMap(
newArr,
newDataIndexMap,
newDataKeyArr,
"_newKeyGetter",
);
for (var i = 0; i < oldDataKeyArr.length; i++) {
var oldKey = oldDataKeyArr[i];
var oldIdxMapVal = oldDataIndexMap[oldKey];
var newIdxMapVal = newDataIndexMap[oldKey];
var oldIdxMapValLen = dataIndexMapValueLength(oldIdxMapVal);
var newIdxMapValLen = dataIndexMapValueLength(newIdxMapVal);
if (oldIdxMapValLen > 1 && newIdxMapValLen === 1) {
this._updateManyToOne &&
this._updateManyToOne(newIdxMapVal, oldIdxMapVal);
newDataIndexMap[oldKey] = null;
} else if (oldIdxMapValLen === 1 && newIdxMapValLen > 1) {
this._updateOneToMany &&
this._updateOneToMany(newIdxMapVal, oldIdxMapVal);
newDataIndexMap[oldKey] = null;
} else if (oldIdxMapValLen === 1 && newIdxMapValLen === 1) {
this._update && this._update(newIdxMapVal, oldIdxMapVal);
newDataIndexMap[oldKey] = null;
} else if (oldIdxMapValLen > 1 && newIdxMapValLen > 1) {
this._updateManyToMany &&
this._updateManyToMany(newIdxMapVal, oldIdxMapVal);
newDataIndexMap[oldKey] = null;
} else if (oldIdxMapValLen > 1) {
for (var i_1 = 0; i_1 < oldIdxMapValLen; i_1++) {
this._remove && this._remove(oldIdxMapVal[i_1]);
}
} else {
this._remove && this._remove(oldIdxMapVal);
}
}
this._performRestAdd(newDataKeyArr, newDataIndexMap);
};
DataDiffer.prototype._performRestAdd = function (
newDataKeyArr,
newDataIndexMap,
) {
for (var i = 0; i < newDataKeyArr.length; i++) {
var newKey = newDataKeyArr[i];
var newIdxMapVal = newDataIndexMap[newKey];
var idxMapValLen = dataIndexMapValueLength(newIdxMapVal);
if (idxMapValLen > 1) {
for (var j = 0; j < idxMapValLen; j++) {
this._add && this._add(newIdxMapVal[j]);
}
} else if (idxMapValLen === 1) {
this._add && this._add(newIdxMapVal);
} // Support both `newDataKeyArr` are duplication removed or not removed.
newDataIndexMap[newKey] = null;
}
};
DataDiffer.prototype._initIndexMap = function (
arr, // Can be null.
map, // In 'byKey', the output `keyArr` is duplication removed.
// In 'byIndex', the output `keyArr` is not duplication removed and
// its indices are accurately corresponding to `arr`.
keyArr,
keyGetterName,
) {
var cbModeMultiple = this._diffModeMultiple;
for (var i = 0; i < arr.length; i++) {
// Add prefix to avoid conflict with Object.prototype.
var key = "_ec_" + this[keyGetterName](arr[i], i);
if (!cbModeMultiple) {
keyArr[i] = key;
}
if (!map) {
continue;
}
var idxMapVal = map[key];
var idxMapValLen = dataIndexMapValueLength(idxMapVal);
if (idxMapValLen === 0) {
// Simple optimize: in most cases, one index has one key,
// do not need array.
map[key] = i;
if (cbModeMultiple) {
keyArr.push(key);
}
} else if (idxMapValLen === 1) {
map[key] = [idxMapVal, i];
} else {
idxMapVal.push(i);
}
}
};
return DataDiffer;
})();
var DimensionUserOuput =
/** @class */
(function () {
function DimensionUserOuput(encode, dimRequest) {
this._encode = encode;
this._schema = dimRequest;
}
DimensionUserOuput.prototype.get = function () {
return {
// Do not generate full dimension name until fist used.
fullDimensions: this._getFullDimensionNames(),
encode: this._encode,
};
};
/**
* Get all data store dimension names.
* Theoretically a series data store is defined both by series and used dataset (if any).
* If some dimensions are omitted for performance reason in `this.dimensions`,
* the dimension name may not be auto-generated if user does not specify a dimension name.
* In this case, the dimension name is `null`/`undefined`.
*/
DimensionUserOuput.prototype._getFullDimensionNames = function () {
if (!this._cachedDimNames) {
this._cachedDimNames = this._schema
? this._schema.makeOutputDimensionNames()
: [];
}
return this._cachedDimNames;
};
return DimensionUserOuput;
})();
function summarizeDimensions(data, schema) {
var summary = {};
var encode = (summary.encode = {});
var notExtraCoordDimMap = createHashMap();
var defaultedLabel = [];
var defaultedTooltip = [];
var userOutputEncode = {};
each(data.dimensions, function (dimName) {
var dimItem = data.getDimensionInfo(dimName);
var coordDim = dimItem.coordDim;
if (coordDim) {
if ("development" !== "production") {
assert(VISUAL_DIMENSIONS.get(coordDim) == null);
}
var coordDimIndex = dimItem.coordDimIndex;
getOrCreateEncodeArr(encode, coordDim)[coordDimIndex] = dimName;
if (!dimItem.isExtraCoord) {
notExtraCoordDimMap.set(coordDim, 1); // Use the last coord dim (and label friendly) as default label,
// because when dataset is used, it is hard to guess which dimension
// can be value dimension. If both show x, y on label is not look good,
// and conventionally y axis is focused more.
if (mayLabelDimType(dimItem.type)) {
defaultedLabel[0] = dimName;
} // User output encode do not contain generated coords.
// And it only has index. User can use index to retrieve value from the raw item array.
getOrCreateEncodeArr(userOutputEncode, coordDim)[coordDimIndex] =
data.getDimensionIndex(dimItem.name);
}
if (dimItem.defaultTooltip) {
defaultedTooltip.push(dimName);
}
}
VISUAL_DIMENSIONS.each(function (v, otherDim) {
var encodeArr = getOrCreateEncodeArr(encode, otherDim);
var dimIndex = dimItem.otherDims[otherDim];
if (dimIndex != null && dimIndex !== false) {
encodeArr[dimIndex] = dimItem.name;
}
});
});
var dataDimsOnCoord = [];
var encodeFirstDimNotExtra = {};
notExtraCoordDimMap.each(function (v, coordDim) {
var dimArr = encode[coordDim];
encodeFirstDimNotExtra[coordDim] = dimArr[0]; // Not necessary to remove duplicate, because a data
// dim canot on more than one coordDim.
dataDimsOnCoord = dataDimsOnCoord.concat(dimArr);
});
summary.dataDimsOnCoord = dataDimsOnCoord;
summary.dataDimIndicesOnCoord = map(dataDimsOnCoord, function (dimName) {
return data.getDimensionInfo(dimName).storeDimIndex;
});
summary.encodeFirstDimNotExtra = encodeFirstDimNotExtra;
var encodeLabel = encode.label; // FIXME `encode.label` is not recommanded, because formatter can not be set
// in this way. Use label.formatter instead. May be remove this approach someday.
if (encodeLabel && encodeLabel.length) {
defaultedLabel = encodeLabel.slice();
}
var encodeTooltip = encode.tooltip;
if (encodeTooltip && encodeTooltip.length) {
defaultedTooltip = encodeTooltip.slice();
} else if (!defaultedTooltip.length) {
defaultedTooltip = defaultedLabel.slice();
}
encode.defaultedLabel = defaultedLabel;
encode.defaultedTooltip = defaultedTooltip;
summary.userOutput = new DimensionUserOuput(userOutputEncode, schema);
return summary;
}
function getOrCreateEncodeArr(encode, dim) {
if (!encode.hasOwnProperty(dim)) {
encode[dim] = [];
}
return encode[dim];
} // FIXME:TS should be type `AxisType`
function getDimensionTypeByAxis(axisType) {
return axisType === "category"
? "ordinal"
: axisType === "time"
? "time"
: "float";
}
function mayLabelDimType(dimType) {
// In most cases, ordinal and time do not suitable for label.
// Ordinal info can be displayed on axis. Time is too long.
return !(dimType === "ordinal" || dimType === "time");
} // function findTheLastDimMayLabel(data) {
// // Get last value dim
// let dimensions = data.dimensions.slice();
// let valueType;
// let valueDim;
// while (dimensions.length && (
// valueDim = dimensions.pop(),
// valueType = data.getDimensionInfo(valueDim).type,
// valueType === 'ordinal' || valueType === 'time'
// )) {} // jshint ignore:line
// return valueDim;
// }
var SeriesDimensionDefine =
/** @class */
(function () {
/**
* @param opt All of the fields will be shallow copied.
*/
function SeriesDimensionDefine(opt) {
/**
* The format of `otherDims` is:
* ```js
* {
* tooltip?: number
* label?: number
* itemName?: number
* seriesName?: number
* }
* ```
*
* A `series.encode` can specified these fields:
* ```js
* encode: {
* // "3, 1, 5" is the index of data dimension.
* tooltip: [3, 1, 5],
* label: [0, 3],
* ...
* }
* ```
* `otherDims` is the parse result of the `series.encode` above, like:
* ```js
* // Suppose the index of this data dimension is `3`.
* this.otherDims = {
* // `3` is at the index `0` of the `encode.tooltip`
* tooltip: 0,
* // `3` is at the index `1` of the `encode.label`
* label: 1
* };
* ```
*
* This prop should never be `null`/`undefined` after initialized.
*/
this.otherDims = {};
if (opt != null) {
extend(this, opt);
}
}
return SeriesDimensionDefine;
})();
var inner$4 = makeInner();
var dimTypeShort = {
float: "f",
int: "i",
ordinal: "o",
number: "n",
time: "t",
};
/**
* Represents the dimension requirement of a series.
*
* NOTICE:
* When there are too many dimensions in dataset and many series, only the used dimensions
* (i.e., used by coord sys and declared in `series.encode`) are add to `dimensionDefineList`.
* But users may query data by other unused dimension names.
* In this case, users can only query data if and only if they have defined dimension names
* via ec option, so we provide `getDimensionIndexFromSource`, which only query them from
* `source` dimensions.
*/
var SeriesDataSchema =
/** @class */
(function () {
function SeriesDataSchema(opt) {
this.dimensions = opt.dimensions;
this._dimOmitted = opt.dimensionOmitted;
this.source = opt.source;
this._fullDimCount = opt.fullDimensionCount;
this._updateDimOmitted(opt.dimensionOmitted);
}
SeriesDataSchema.prototype.isDimensionOmitted = function () {
return this._dimOmitted;
};
SeriesDataSchema.prototype._updateDimOmitted = function (
dimensionOmitted,
) {
this._dimOmitted = dimensionOmitted;
if (!dimensionOmitted) {
return;
}
if (!this._dimNameMap) {
this._dimNameMap = ensureSourceDimNameMap(this.source);
}
};
/**
* @caution Can only be used when `dimensionOmitted: true`.
*
* Get index by user defined dimension name (i.e., not internal generate name).
* That is, get index from `dimensionsDefine`.
* If no `dimensionsDefine`, or no name get, return -1.
*/
SeriesDataSchema.prototype.getSourceDimensionIndex = function (dimName) {
return retrieve2(this._dimNameMap.get(dimName), -1);
};
/**
* @caution Can only be used when `dimensionOmitted: true`.
*
* Notice: may return `null`/`undefined` if user not specify dimension names.
*/
SeriesDataSchema.prototype.getSourceDimension = function (dimIndex) {
var dimensionsDefine = this.source.dimensionsDefine;
if (dimensionsDefine) {
return dimensionsDefine[dimIndex];
}
};
SeriesDataSchema.prototype.makeStoreSchema = function () {
var dimCount = this._fullDimCount;
var willRetrieveDataByName = shouldRetrieveDataByName(this.source);
var makeHashStrict = !shouldOmitUnusedDimensions(dimCount); // If source don't have dimensions or series don't omit unsed dimensions.
// Generate from seriesDimList directly
var dimHash = "";
var dims = [];
for (
var fullDimIdx = 0, seriesDimIdx = 0;
fullDimIdx < dimCount;
fullDimIdx++
) {
var property = void 0;
var type = void 0;
var ordinalMeta = void 0;
var seriesDimDef = this.dimensions[seriesDimIdx]; // The list has been sorted by `storeDimIndex` asc.
if (seriesDimDef && seriesDimDef.storeDimIndex === fullDimIdx) {
property = willRetrieveDataByName ? seriesDimDef.name : null;
type = seriesDimDef.type;
ordinalMeta = seriesDimDef.ordinalMeta;
seriesDimIdx++;
} else {
var sourceDimDef = this.getSourceDimension(fullDimIdx);
if (sourceDimDef) {
property = willRetrieveDataByName ? sourceDimDef.name : null;
type = sourceDimDef.type;
}
}
dims.push({
property: property,
type: type,
ordinalMeta: ordinalMeta,
}); // If retrieving data by index,
// use to determine whether data can be shared.
// (Becuase in this case there might be no dimension name defined in dataset, but indices always exists).
// (indices are always 0, 1, 2, ..., so we can ignore them to shorten the hash).
// Otherwise if retrieving data by property name (like `data: [{aa: 123, bb: 765}, ...]`),
// use in hash.
if (
willRetrieveDataByName &&
property != null && // For data stack, we have make sure each series has its own dim on this store.
// So we do not add property to hash to make sure they can share this store.
(!seriesDimDef || !seriesDimDef.isCalculationCoord)
) {
dimHash += makeHashStrict // Use escape character '`' in case that property name contains '$'.
? property.replace(/\`/g, "`1").replace(/\$/g, "`2") // For better performance, when there are large dimensions, tolerant this defects that hardly meet.
: property;
}
dimHash += "$";
dimHash += dimTypeShort[type] || "f";
if (ordinalMeta) {
dimHash += ordinalMeta.uid;
}
dimHash += "$";
} // Source from endpoint(usually series) will be read differently
// when seriesLayoutBy or startIndex(which is affected by sourceHeader) are different.
// So we use this three props as key.
var source = this.source;
var hash = [source.seriesLayoutBy, source.startIndex, dimHash].join(
"$$",
);
return {
dimensions: dims,
hash: hash,
};
};
SeriesDataSchema.prototype.makeOutputDimensionNames = function () {
var result = [];
for (
var fullDimIdx = 0, seriesDimIdx = 0;
fullDimIdx < this._fullDimCount;
fullDimIdx++
) {
var name_1 = void 0;
var seriesDimDef = this.dimensions[seriesDimIdx]; // The list has been sorted by `storeDimIndex` asc.
if (seriesDimDef && seriesDimDef.storeDimIndex === fullDimIdx) {
if (!seriesDimDef.isCalculationCoord) {
name_1 = seriesDimDef.name;
}
seriesDimIdx++;
} else {
var sourceDimDef = this.getSourceDimension(fullDimIdx);
if (sourceDimDef) {
name_1 = sourceDimDef.name;
}
}
result.push(name_1);
}
return result;
};
SeriesDataSchema.prototype.appendCalculationDimension = function (
dimDef,
) {
this.dimensions.push(dimDef);
dimDef.isCalculationCoord = true;
this._fullDimCount++; // If append dimension on a data store, consider the store
// might be shared by different series, series dimensions not
// really map to store dimensions.
this._updateDimOmitted(true);
};
return SeriesDataSchema;
})();
function isSeriesDataSchema(schema) {
return schema instanceof SeriesDataSchema;
}
function createDimNameMap(dimsDef) {
var dataDimNameMap = createHashMap();
for (var i = 0; i < (dimsDef || []).length; i++) {
var dimDefItemRaw = dimsDef[i];
var userDimName = isObject(dimDefItemRaw)
? dimDefItemRaw.name
: dimDefItemRaw;
if (userDimName != null && dataDimNameMap.get(userDimName) == null) {
dataDimNameMap.set(userDimName, i);
}
}
return dataDimNameMap;
}
function ensureSourceDimNameMap(source) {
var innerSource = inner$4(source);
return (
innerSource.dimNameMap ||
(innerSource.dimNameMap = createDimNameMap(source.dimensionsDefine))
);
}
function shouldOmitUnusedDimensions(dimCount) {
return dimCount > 30;
}
var isObject$2 = isObject;
var map$1 = map;
var CtorInt32Array$1 = typeof Int32Array === "undefined" ? Array : Int32Array; // Use prefix to avoid index to be the same as otherIdList[idx],
// which will cause weird udpate animation.
var ID_PREFIX = "e\0\0";
var INDEX_NOT_FOUND = -1; // type SeriesDimensionIndex = DimensionIndex;
var TRANSFERABLE_PROPERTIES = [
"hasItemOption",
"_nameList",
"_idList",
"_invertedIndicesMap",
"_dimSummary",
"userOutput",
"_rawData",
"_dimValueGetter",
"_nameDimIdx",
"_idDimIdx",
"_nameRepeatCount",
];
var CLONE_PROPERTIES = ["_approximateExtent"]; // -----------------------------
// Internal method declarations:
// -----------------------------
var prepareInvertedIndex;
var getId;
var getIdNameFromStore;
var normalizeDimensions;
var transferProperties;
var cloneListForMapAndSample;
var makeIdFromName;
var SeriesData =
/** @class */
(function () {
/**
* @param dimensionsInput.dimensions
* For example, ['someDimName', {name: 'someDimName', type: 'someDimType'}, ...].
* Dimensions should be concrete names like x, y, z, lng, lat, angle, radius
*/
function SeriesData(dimensionsInput, hostModel) {
this.type = "list";
this._dimOmitted = false;
this._nameList = [];
this._idList = []; // Models of data option is stored sparse for optimizing memory cost
// Never used yet (not used yet).
// private _optionModels: Model[] = [];
// Global visual properties after visual coding
this._visual = {}; // Globel layout properties.
this._layout = {}; // Item visual properties after visual coding
this._itemVisuals = []; // Item layout properties after layout
this._itemLayouts = []; // Graphic elemnents
this._graphicEls = []; // key: dim, value: extent
this._approximateExtent = {};
this._calculationInfo = {}; // Having detected that there is data item is non primitive type
// (in type `OptionDataItemObject`).
// Like `data: [ { value: xx, itemStyle: {...} }, ...]`
// At present it only happen in `SOURCE_FORMAT_ORIGINAL`.
this.hasItemOption = false; // Methods that create a new list based on this list should be listed here.
// Notice that those method should `RETURN` the new list.
this.TRANSFERABLE_METHODS = [
"cloneShallow",
"downSample",
"lttbDownSample",
"map",
]; // Methods that change indices of this list should be listed here.
this.CHANGABLE_METHODS = ["filterSelf", "selectRange"];
this.DOWNSAMPLE_METHODS = ["downSample", "lttbDownSample"];
var dimensions;
var assignStoreDimIdx = false;
if (isSeriesDataSchema(dimensionsInput)) {
dimensions = dimensionsInput.dimensions;
this._dimOmitted = dimensionsInput.isDimensionOmitted();
this._schema = dimensionsInput;
} else {
assignStoreDimIdx = true;
dimensions = dimensionsInput;
}
dimensions = dimensions || ["x", "y"];
var dimensionInfos = {};
var dimensionNames = [];
var invertedIndicesMap = {};
var needsHasOwn = false;
var emptyObj = {};
for (var i = 0; i < dimensions.length; i++) {
// Use the original dimensions[i], where other flag props may exists.
var dimInfoInput = dimensions[i];
var dimensionInfo = isString(dimInfoInput)
? new SeriesDimensionDefine({
name: dimInfoInput,
})
: !(dimInfoInput instanceof SeriesDimensionDefine)
? new SeriesDimensionDefine(dimInfoInput)
: dimInfoInput;
var dimensionName = dimensionInfo.name;
dimensionInfo.type = dimensionInfo.type || "float";
if (!dimensionInfo.coordDim) {
dimensionInfo.coordDim = dimensionName;
dimensionInfo.coordDimIndex = 0;
}
var otherDims = (dimensionInfo.otherDims =
dimensionInfo.otherDims || {});
dimensionNames.push(dimensionName);
dimensionInfos[dimensionName] = dimensionInfo;
if (emptyObj[dimensionName] != null) {
needsHasOwn = true;
}
if (dimensionInfo.createInvertedIndices) {
invertedIndicesMap[dimensionName] = [];
}
if (otherDims.itemName === 0) {
this._nameDimIdx = i;
}
if (otherDims.itemId === 0) {
this._idDimIdx = i;
}
if ("development" !== "production") {
assert(assignStoreDimIdx || dimensionInfo.storeDimIndex >= 0);
}
if (assignStoreDimIdx) {
dimensionInfo.storeDimIndex = i;
}
}
this.dimensions = dimensionNames;
this._dimInfos = dimensionInfos;
this._initGetDimensionInfo(needsHasOwn);
this.hostModel = hostModel;
this._invertedIndicesMap = invertedIndicesMap;
if (this._dimOmitted) {
var dimIdxToName_1 = (this._dimIdxToName = createHashMap());
each(dimensionNames, function (dimName) {
dimIdxToName_1.set(dimensionInfos[dimName].storeDimIndex, dimName);
});
}
}
/**
*
* Get concrete dimension name by dimension name or dimension index.
* If input a dimension name, do not validate whether the dimension name exits.
*
* @caution
* @param dim Must make sure the dimension is `SeriesDimensionLoose`.
* Because only those dimensions will have auto-generated dimension names if not
* have a user-specified name, and other dimensions will get a return of null/undefined.
*
* @notice Becuause of this reason, should better use `getDimensionIndex` instead, for examples:
* ```js
* const val = data.getStore().get(data.getDimensionIndex(dim), dataIdx);
* ```
*
* @return Concrete dim name.
*/
SeriesData.prototype.getDimension = function (dim) {
var dimIdx = this._recognizeDimIndex(dim);
if (dimIdx == null) {
return dim;
}
dimIdx = dim;
if (!this._dimOmitted) {
return this.dimensions[dimIdx];
} // Retrieve from series dimension definition becuase it probably contains
// generated dimension name (like 'x', 'y').
var dimName = this._dimIdxToName.get(dimIdx);
if (dimName != null) {
return dimName;
}
var sourceDimDef = this._schema.getSourceDimension(dimIdx);
if (sourceDimDef) {
return sourceDimDef.name;
}
};
/**
* Get dimension index in data store. Return -1 if not found.
* Can be used to index value from getRawValue.
*/
SeriesData.prototype.getDimensionIndex = function (dim) {
var dimIdx = this._recognizeDimIndex(dim);
if (dimIdx != null) {
return dimIdx;
}
if (dim == null) {
return -1;
}
var dimInfo = this._getDimInfo(dim);
return dimInfo
? dimInfo.storeDimIndex
: this._dimOmitted
? this._schema.getSourceDimensionIndex(dim)
: -1;
};
/**
* The meanings of the input parameter `dim`:
*
* + If dim is a number (e.g., `1`), it means the index of the dimension.
* For example, `getDimension(0)` will return 'x' or 'lng' or 'radius'.
* + If dim is a number-like string (e.g., `"1"`):
* + If there is the same concrete dim name defined in `series.dimensions` or `dataset.dimensions`,
* it means that concrete name.
* + If not, it will be converted to a number, which means the index of the dimension.
* (why? because of the backward compatbility. We have been tolerating number-like string in
* dimension setting, although now it seems that it is not a good idea.)
* For example, `visualMap[i].dimension: "1"` is the same meaning as `visualMap[i].dimension: 1`,
* if no dimension name is defined as `"1"`.
* + If dim is a not-number-like string, it means the concrete dim name.
* For example, it can be be default name `"x"`, `"y"`, `"z"`, `"lng"`, `"lat"`, `"angle"`, `"radius"`,
* or customized in `dimensions` property of option like `"age"`.
*
* @return recogonized `DimensionIndex`. Otherwise return null/undefined (means that dim is `DimensionName`).
*/
SeriesData.prototype._recognizeDimIndex = function (dim) {
if (
isNumber(dim) || // If being a number-like string but not being defined as a dimension name.
(dim != null &&
!isNaN(dim) &&
!this._getDimInfo(dim) &&
(!this._dimOmitted ||
this._schema.getSourceDimensionIndex(dim) < 0))
) {
return +dim;
}
};
SeriesData.prototype._getStoreDimIndex = function (dim) {
var dimIdx = this.getDimensionIndex(dim);
if ("development" !== "production") {
if (dimIdx == null) {
throw new Error("Unkown dimension " + dim);
}
}
return dimIdx;
};
/**
* Get type and calculation info of particular dimension
* @param dim
* Dimension can be concrete names like x, y, z, lng, lat, angle, radius
* Or a ordinal number. For example getDimensionInfo(0) will return 'x' or 'lng' or 'radius'
*/
SeriesData.prototype.getDimensionInfo = function (dim) {
// Do not clone, because there may be categories in dimInfo.
return this._getDimInfo(this.getDimension(dim));
};
SeriesData.prototype._initGetDimensionInfo = function (needsHasOwn) {
var dimensionInfos = this._dimInfos;
this._getDimInfo = needsHasOwn
? function (dimName) {
return dimensionInfos.hasOwnProperty(dimName)
? dimensionInfos[dimName]
: undefined;
}
: function (dimName) {
return dimensionInfos[dimName];
};
};
/**
* concrete dimension name list on coord.
*/
SeriesData.prototype.getDimensionsOnCoord = function () {
return this._dimSummary.dataDimsOnCoord.slice();
};
SeriesData.prototype.mapDimension = function (coordDim, idx) {
var dimensionsSummary = this._dimSummary;
if (idx == null) {
return dimensionsSummary.encodeFirstDimNotExtra[coordDim];
}
var dims = dimensionsSummary.encode[coordDim];
return dims ? dims[idx] : null;
};
SeriesData.prototype.mapDimensionsAll = function (coordDim) {
var dimensionsSummary = this._dimSummary;
var dims = dimensionsSummary.encode[coordDim];
return (dims || []).slice();
};
SeriesData.prototype.getStore = function () {
return this._store;
};
/**
* Initialize from data
* @param data source or data or data store.
* @param nameList The name of a datum is used on data diff and
* default label/tooltip.
* A name can be specified in encode.itemName,
* or dataItem.name (only for series option data),
* or provided in nameList from outside.
*/
SeriesData.prototype.initData = function (
data,
nameList,
dimValueGetter,
) {
var _this = this;
var store;
if (data instanceof DataStore) {
store = data;
}
if (!store) {
var dimensions = this.dimensions;
var provider =
isSourceInstance(data) || isArrayLike(data)
? new DefaultDataProvider(data, dimensions.length)
: data;
store = new DataStore();
var dimensionInfos = map$1(dimensions, function (dimName) {
return {
type: _this._dimInfos[dimName].type,
property: dimName,
};
});
store.initData(provider, dimensionInfos, dimValueGetter);
}
this._store = store; // Reset
this._nameList = (nameList || []).slice();
this._idList = [];
this._nameRepeatCount = {};
this._doInit(0, store.count()); // Cache summary info for fast visit. See "dimensionHelper".
// Needs to be initialized after store is prepared.
this._dimSummary = summarizeDimensions(this, this._schema);
this.userOutput = this._dimSummary.userOutput;
};
/**
* Caution: Can be only called on raw data (before `this._indices` created).
*/
SeriesData.prototype.appendData = function (data) {
var range = this._store.appendData(data);
this._doInit(range[0], range[1]);
};
/**
* Caution: Can be only called on raw data (before `this._indices` created).
* This method does not modify `rawData` (`dataProvider`), but only
* add values to store.
*
* The final count will be increased by `Math.max(values.length, names.length)`.
*
* @param values That is the SourceType: 'arrayRows', like
* [
* [12, 33, 44],
* [NaN, 43, 1],
* ['-', 'asdf', 0]
* ]
* Each item is exaclty cooresponding to a dimension.
*/
SeriesData.prototype.appendValues = function (values, names) {
var _a = this._store.appendValues(values, names.length),
start = _a.start,
end = _a.end;
var shouldMakeIdFromName = this._shouldMakeIdFromName();
this._updateOrdinalMeta();
if (names) {
for (var idx = start; idx < end; idx++) {
var sourceIdx = idx - start;
this._nameList[idx] = names[sourceIdx];
if (shouldMakeIdFromName) {
makeIdFromName(this, idx);
}
}
}
};
SeriesData.prototype._updateOrdinalMeta = function () {
var store = this._store;
var dimensions = this.dimensions;
for (var i = 0; i < dimensions.length; i++) {
var dimInfo = this._dimInfos[dimensions[i]];
if (dimInfo.ordinalMeta) {
store.collectOrdinalMeta(
dimInfo.storeDimIndex,
dimInfo.ordinalMeta,
);
}
}
};
SeriesData.prototype._shouldMakeIdFromName = function () {
var provider = this._store.getProvider();
return (
this._idDimIdx == null &&
provider.getSource().sourceFormat !== SOURCE_FORMAT_TYPED_ARRAY &&
!provider.fillStorage
);
};
SeriesData.prototype._doInit = function (start, end) {
if (start >= end) {
return;
}
var store = this._store;
var provider = store.getProvider();
this._updateOrdinalMeta();
var nameList = this._nameList;
var idList = this._idList;
var sourceFormat = provider.getSource().sourceFormat;
var isFormatOriginal = sourceFormat === SOURCE_FORMAT_ORIGINAL; // Each data item is value
// [1, 2]
// 2
// Bar chart, line chart which uses category axis
// only gives the 'y' value. 'x' value is the indices of category
// Use a tempValue to normalize the value to be a (x, y) value
// If dataItem is {name: ...} or {id: ...}, it has highest priority.
// This kind of ids and names are always stored `_nameList` and `_idList`.
if (isFormatOriginal && !provider.pure) {
var sharedDataItem = [];
for (var idx = start; idx < end; idx++) {
// NOTICE: Try not to write things into dataItem
var dataItem = provider.getItem(idx, sharedDataItem);
if (!this.hasItemOption && isDataItemOption(dataItem)) {
this.hasItemOption = true;
}
if (dataItem) {
var itemName = dataItem.name;
if (nameList[idx] == null && itemName != null) {
nameList[idx] = convertOptionIdName(itemName, null);
}
var itemId = dataItem.id;
if (idList[idx] == null && itemId != null) {
idList[idx] = convertOptionIdName(itemId, null);
}
}
}
}
if (this._shouldMakeIdFromName()) {
for (var idx = start; idx < end; idx++) {
makeIdFromName(this, idx);
}
}
prepareInvertedIndex(this);
};
/**
* PENDING: In fact currently this function is only used to short-circuit
* the calling of `scale.unionExtentFromData` when data have been filtered by modules
* like "dataZoom". `scale.unionExtentFromData` is used to calculate data extent for series on
* an axis, but if a "axis related data filter module" is used, the extent of the axis have
* been fixed and no need to calling `scale.unionExtentFromData` actually.
* But if we add "custom data filter" in future, which is not "axis related", this method may
* be still needed.
*
* Optimize for the scenario that data is filtered by a given extent.
* Consider that if data amount is more than hundreds of thousand,
* extent calculation will cost more than 10ms and the cache will
* be erased because of the filtering.
*/
SeriesData.prototype.getApproximateExtent = function (dim) {
return (
this._approximateExtent[dim] ||
this._store.getDataExtent(this._getStoreDimIndex(dim))
);
};
/**
* Calculate extent on a filtered data might be time consuming.
* Approximate extent is only used for: calculte extent of filtered data outside.
*/
SeriesData.prototype.setApproximateExtent = function (extent, dim) {
dim = this.getDimension(dim);
this._approximateExtent[dim] = extent.slice();
};
SeriesData.prototype.getCalculationInfo = function (key) {
return this._calculationInfo[key];
};
SeriesData.prototype.setCalculationInfo = function (key, value) {
isObject$2(key)
? extend(this._calculationInfo, key)
: (this._calculationInfo[key] = value);
};
/**
* @return Never be null/undefined. `number` will be converted to string. Becuase:
* In most cases, name is used in display, where returning a string is more convenient.
* In other cases, name is used in query (see `indexOfName`), where we can keep the
* rule that name `2` equals to name `'2'`.
*/
SeriesData.prototype.getName = function (idx) {
var rawIndex = this.getRawIndex(idx);
var name = this._nameList[rawIndex];
if (name == null && this._nameDimIdx != null) {
name = getIdNameFromStore(this, this._nameDimIdx, rawIndex);
}
if (name == null) {
name = "";
}
return name;
};
SeriesData.prototype._getCategory = function (dimIdx, idx) {
var ordinal = this._store.get(dimIdx, idx);
var ordinalMeta = this._store.getOrdinalMeta(dimIdx);
if (ordinalMeta) {
return ordinalMeta.categories[ordinal];
}
return ordinal;
};
/**
* @return Never null/undefined. `number` will be converted to string. Becuase:
* In all cases having encountered at present, id is used in making diff comparison, which
* are usually based on hash map. We can keep the rule that the internal id are always string
* (treat `2` is the same as `'2'`) to make the related logic simple.
*/
SeriesData.prototype.getId = function (idx) {
return getId(this, this.getRawIndex(idx));
};
SeriesData.prototype.count = function () {
return this._store.count();
};
/**
* Get value. Return NaN if idx is out of range.
*
* @notice Should better to use `data.getStore().get(dimIndex, dataIdx)` instead.
*/
SeriesData.prototype.get = function (dim, idx) {
var store = this._store;
var dimInfo = this._dimInfos[dim];
if (dimInfo) {
return store.get(dimInfo.storeDimIndex, idx);
}
};
/**
* @notice Should better to use `data.getStore().getByRawIndex(dimIndex, dataIdx)` instead.
*/
SeriesData.prototype.getByRawIndex = function (dim, rawIdx) {
var store = this._store;
var dimInfo = this._dimInfos[dim];
if (dimInfo) {
return store.getByRawIndex(dimInfo.storeDimIndex, rawIdx);
}
};
SeriesData.prototype.getIndices = function () {
return this._store.getIndices();
};
SeriesData.prototype.getDataExtent = function (dim) {
return this._store.getDataExtent(this._getStoreDimIndex(dim));
};
SeriesData.prototype.getSum = function (dim) {
return this._store.getSum(this._getStoreDimIndex(dim));
};
SeriesData.prototype.getMedian = function (dim) {
return this._store.getMedian(this._getStoreDimIndex(dim));
};
SeriesData.prototype.getValues = function (dimensions, idx) {
var _this = this;
var store = this._store;
return isArray(dimensions)
? store.getValues(
map$1(dimensions, function (dim) {
return _this._getStoreDimIndex(dim);
}),
idx,
)
: store.getValues(dimensions);
};
/**
* If value is NaN. Inlcuding '-'
* Only check the coord dimensions.
*/
SeriesData.prototype.hasValue = function (idx) {
var dataDimIndicesOnCoord = this._dimSummary.dataDimIndicesOnCoord;
for (var i = 0, len = dataDimIndicesOnCoord.length; i < len; i++) {
// Ordinal type originally can be string or number.
// But when an ordinal type is used on coord, it can
// not be string but only number. So we can also use isNaN.
if (isNaN(this._store.get(dataDimIndicesOnCoord[i], idx))) {
return false;
}
}
return true;
};
/**
* Retreive the index with given name
*/
SeriesData.prototype.indexOfName = function (name) {
for (var i = 0, len = this._store.count(); i < len; i++) {
if (this.getName(i) === name) {
return i;
}
}
return -1;
};
SeriesData.prototype.getRawIndex = function (idx) {
return this._store.getRawIndex(idx);
};
SeriesData.prototype.indexOfRawIndex = function (rawIndex) {
return this._store.indexOfRawIndex(rawIndex);
};
/**
* Only support the dimension which inverted index created.
* Do not support other cases until required.
* @param dim concrete dim
* @param value ordinal index
* @return rawIndex
*/
SeriesData.prototype.rawIndexOf = function (dim, value) {
var invertedIndices = dim && this._invertedIndicesMap[dim];
if ("development" !== "production") {
if (!invertedIndices) {
throw new Error("Do not supported yet");
}
}
var rawIndex = invertedIndices[value];
if (rawIndex == null || isNaN(rawIndex)) {
return INDEX_NOT_FOUND;
}
return rawIndex;
};
/**
* Retreive the index of nearest value
* @param dim
* @param value
* @param [maxDistance=Infinity]
* @return If and only if multiple indices has
* the same value, they are put to the result.
*/
SeriesData.prototype.indicesOfNearest = function (
dim,
value,
maxDistance,
) {
return this._store.indicesOfNearest(
this._getStoreDimIndex(dim),
value,
maxDistance,
);
};
SeriesData.prototype.each = function (dims, cb, ctx) {
if (isFunction(dims)) {
ctx = cb;
cb = dims;
dims = [];
} // ctxCompat just for compat echarts3
var fCtx = ctx || this;
var dimIndices = map$1(
normalizeDimensions(dims),
this._getStoreDimIndex,
this,
);
this._store.each(dimIndices, fCtx ? bind(cb, fCtx) : cb);
};
SeriesData.prototype.filterSelf = function (dims, cb, ctx) {
if (isFunction(dims)) {
ctx = cb;
cb = dims;
dims = [];
} // ctxCompat just for compat echarts3
var fCtx = ctx || this;
var dimIndices = map$1(
normalizeDimensions(dims),
this._getStoreDimIndex,
this,
);
this._store = this._store.filter(
dimIndices,
fCtx ? bind(cb, fCtx) : cb,
);
return this;
};
/**
* Select data in range. (For optimization of filter)
* (Manually inline code, support 5 million data filtering in data zoom.)
*/
SeriesData.prototype.selectRange = function (range) {
var _this = this;
var innerRange = {};
var dims = keys(range);
each(dims, function (dim) {
var dimIdx = _this._getStoreDimIndex(dim);
innerRange[dimIdx] = range[dim];
});
this._store = this._store.selectRange(innerRange);
return this;
};
/* eslint-enable max-len */
SeriesData.prototype.mapArray = function (dims, cb, ctx) {
if (isFunction(dims)) {
ctx = cb;
cb = dims;
dims = [];
} // ctxCompat just for compat echarts3
ctx = ctx || this;
var result = [];
this.each(
dims,
function () {
result.push(cb && cb.apply(this, arguments));
},
ctx,
);
return result;
};
SeriesData.prototype.map = function (dims, cb, ctx, ctxCompat) {
var fCtx = ctx || ctxCompat || this;
var dimIndices = map$1(
normalizeDimensions(dims),
this._getStoreDimIndex,
this,
);
var list = cloneListForMapAndSample(this);
list._store = this._store.map(dimIndices, fCtx ? bind(cb, fCtx) : cb);
return list;
};
SeriesData.prototype.modify = function (dims, cb, ctx, ctxCompat) {
var _this = this; // ctxCompat just for compat echarts3
var fCtx = ctx || ctxCompat || this;
if ("development" !== "production") {
each(normalizeDimensions(dims), function (dim) {
var dimInfo = _this.getDimensionInfo(dim);
if (!dimInfo.isCalculationCoord) {
console.error("Danger: only stack dimension can be modified");
}
});
}
var dimIndices = map$1(
normalizeDimensions(dims),
this._getStoreDimIndex,
this,
); // If do shallow clone here, if there are too many stacked series,
// it still cost lots of memory, becuase `_store.dimensions` are not shared.
// We should consider there probably be shallow clone happen in each sereis
// in consequent filter/map.
this._store.modify(dimIndices, fCtx ? bind(cb, fCtx) : cb);
};
/**
* Large data down sampling on given dimension
* @param sampleIndex Sample index for name and id
*/
SeriesData.prototype.downSample = function (
dimension,
rate,
sampleValue,
sampleIndex,
) {
var list = cloneListForMapAndSample(this);
list._store = this._store.downSample(
this._getStoreDimIndex(dimension),
rate,
sampleValue,
sampleIndex,
);
return list;
};
/**
* Large data down sampling using largest-triangle-three-buckets
* @param {string} valueDimension
* @param {number} targetCount
*/
SeriesData.prototype.lttbDownSample = function (valueDimension, rate) {
var list = cloneListForMapAndSample(this);
list._store = this._store.lttbDownSample(
this._getStoreDimIndex(valueDimension),
rate,
);
return list;
};
SeriesData.prototype.getRawDataItem = function (idx) {
return this._store.getRawDataItem(idx);
};
/**
* Get model of one data item.
*/
// TODO: Type of data item
SeriesData.prototype.getItemModel = function (idx) {
var hostModel = this.hostModel;
var dataItem = this.getRawDataItem(idx);
return new Model(dataItem, hostModel, hostModel && hostModel.ecModel);
};
/**
* Create a data differ
*/
SeriesData.prototype.diff = function (otherList) {
var thisList = this;
return new DataDiffer(
otherList ? otherList.getStore().getIndices() : [],
this.getStore().getIndices(),
function (idx) {
return getId(otherList, idx);
},
function (idx) {
return getId(thisList, idx);
},
);
};
/**
* Get visual property.
*/
SeriesData.prototype.getVisual = function (key) {
var visual = this._visual;
return visual && visual[key];
};
SeriesData.prototype.setVisual = function (kvObj, val) {
this._visual = this._visual || {};
if (isObject$2(kvObj)) {
extend(this._visual, kvObj);
} else {
this._visual[kvObj] = val;
}
};
/**
* Get visual property of single data item
*/
// eslint-disable-next-line
SeriesData.prototype.getItemVisual = function (idx, key) {
var itemVisual = this._itemVisuals[idx];
var val = itemVisual && itemVisual[key];
if (val == null) {
// Use global visual property
return this.getVisual(key);
}
return val;
};
/**
* If exists visual property of single data item
*/
SeriesData.prototype.hasItemVisual = function () {
return this._itemVisuals.length > 0;
};
/**
* Make sure itemVisual property is unique
*/
// TODO: use key to save visual to reduce memory.
SeriesData.prototype.ensureUniqueItemVisual = function (idx, key) {
var itemVisuals = this._itemVisuals;
var itemVisual = itemVisuals[idx];
if (!itemVisual) {
itemVisual = itemVisuals[idx] = {};
}
var val = itemVisual[key];
if (val == null) {
val = this.getVisual(key); // TODO Performance?
if (isArray(val)) {
val = val.slice();
} else if (isObject$2(val)) {
val = extend({}, val);
}
itemVisual[key] = val;
}
return val;
}; // eslint-disable-next-line
SeriesData.prototype.setItemVisual = function (idx, key, value) {
var itemVisual = this._itemVisuals[idx] || {};
this._itemVisuals[idx] = itemVisual;
if (isObject$2(key)) {
extend(itemVisual, key);
} else {
itemVisual[key] = value;
}
};
/**
* Clear itemVisuals and list visual.
*/
SeriesData.prototype.clearAllVisual = function () {
this._visual = {};
this._itemVisuals = [];
};
SeriesData.prototype.setLayout = function (key, val) {
isObject$2(key) ? extend(this._layout, key) : (this._layout[key] = val);
};
/**
* Get layout property.
*/
SeriesData.prototype.getLayout = function (key) {
return this._layout[key];
};
/**
* Get layout of single data item
*/
SeriesData.prototype.getItemLayout = function (idx) {
return this._itemLayouts[idx];
};
/**
* Set layout of single data item
*/
SeriesData.prototype.setItemLayout = function (idx, layout, merge) {
this._itemLayouts[idx] = merge
? extend(this._itemLayouts[idx] || {}, layout)
: layout;
};
/**
* Clear all layout of single data item
*/
SeriesData.prototype.clearItemLayouts = function () {
this._itemLayouts.length = 0;
};
/**
* Set graphic element relative to data. It can be set as null
*/
SeriesData.prototype.setItemGraphicEl = function (idx, el) {
var seriesIndex = this.hostModel && this.hostModel.seriesIndex;
setCommonECData(seriesIndex, this.dataType, idx, el);
this._graphicEls[idx] = el;
};
SeriesData.prototype.getItemGraphicEl = function (idx) {
return this._graphicEls[idx];
};
SeriesData.prototype.eachItemGraphicEl = function (cb, context) {
each(this._graphicEls, function (el, idx) {
if (el) {
cb && cb.call(context, el, idx);
}
});
};
/**
* Shallow clone a new list except visual and layout properties, and graph elements.
* New list only change the indices.
*/
SeriesData.prototype.cloneShallow = function (list) {
if (!list) {
list = new SeriesData(
this._schema
? this._schema
: map$1(this.dimensions, this._getDimInfo, this),
this.hostModel,
);
}
transferProperties(list, this);
list._store = this._store;
return list;
};
/**
* Wrap some method to add more feature
*/
SeriesData.prototype.wrapMethod = function (methodName, injectFunction) {
var originalMethod = this[methodName];
if (!isFunction(originalMethod)) {
return;
}
this.__wrappedMethods = this.__wrappedMethods || [];
this.__wrappedMethods.push(methodName);
this[methodName] = function () {
var res = originalMethod.apply(this, arguments);
return injectFunction.apply(this, [res].concat(slice(arguments)));
};
}; // ----------------------------------------------------------
// A work around for internal method visiting private member.
// ----------------------------------------------------------
SeriesData.internalField = (function () {
prepareInvertedIndex = function (data) {
var invertedIndicesMap = data._invertedIndicesMap;
each(invertedIndicesMap, function (invertedIndices, dim) {
var dimInfo = data._dimInfos[dim]; // Currently, only dimensions that has ordinalMeta can create inverted indices.
var ordinalMeta = dimInfo.ordinalMeta;
var store = data._store;
if (ordinalMeta) {
invertedIndices = invertedIndicesMap[dim] = new CtorInt32Array$1(
ordinalMeta.categories.length,
); // The default value of TypedArray is 0. To avoid miss
// mapping to 0, we should set it as INDEX_NOT_FOUND.
for (var i = 0; i < invertedIndices.length; i++) {
invertedIndices[i] = INDEX_NOT_FOUND;
}
for (var i = 0; i < store.count(); i++) {
// Only support the case that all values are distinct.
invertedIndices[store.get(dimInfo.storeDimIndex, i)] = i;
}
}
});
};
getIdNameFromStore = function (data, dimIdx, idx) {
return convertOptionIdName(data._getCategory(dimIdx, idx), null);
};
/**
* @see the comment of `List['getId']`.
*/
getId = function (data, rawIndex) {
var id = data._idList[rawIndex];
if (id == null && data._idDimIdx != null) {
id = getIdNameFromStore(data, data._idDimIdx, rawIndex);
}
if (id == null) {
id = ID_PREFIX + rawIndex;
}
return id;
};
normalizeDimensions = function (dimensions) {
if (!isArray(dimensions)) {
dimensions = dimensions != null ? [dimensions] : [];
}
return dimensions;
};
/**
* Data in excludeDimensions is copied, otherwise transfered.
*/
cloneListForMapAndSample = function (original) {
var list = new SeriesData(
original._schema
? original._schema
: map$1(original.dimensions, original._getDimInfo, original),
original.hostModel,
); // FIXME If needs stackedOn, value may already been stacked
transferProperties(list, original);
return list;
};
transferProperties = function (target, source) {
each(
TRANSFERABLE_PROPERTIES.concat(source.__wrappedMethods || []),
function (propName) {
if (source.hasOwnProperty(propName)) {
target[propName] = source[propName];
}
},
);
target.__wrappedMethods = source.__wrappedMethods;
each(CLONE_PROPERTIES, function (propName) {
target[propName] = clone(source[propName]);
});
target._calculationInfo = extend({}, source._calculationInfo);
};
makeIdFromName = function (data, idx) {
var nameList = data._nameList;
var idList = data._idList;
var nameDimIdx = data._nameDimIdx;
var idDimIdx = data._idDimIdx;
var name = nameList[idx];
var id = idList[idx];
if (name == null && nameDimIdx != null) {
nameList[idx] = name = getIdNameFromStore(data, nameDimIdx, idx);
}
if (id == null && idDimIdx != null) {
idList[idx] = id = getIdNameFromStore(data, idDimIdx, idx);
}
if (id == null && name != null) {
var nameRepeatCount = data._nameRepeatCount;
var nmCnt = (nameRepeatCount[name] =
(nameRepeatCount[name] || 0) + 1);
id = name;
if (nmCnt > 1) {
id += "__ec__" + nmCnt;
}
idList[idx] = id;
}
};
})();
return SeriesData;
})();
/**
* For outside usage compat (like echarts-gl are using it).
*/
function createDimensions(source, opt) {
return prepareSeriesDataSchema(source, opt).dimensions;
}
/**
* This method builds the relationship between:
* + "what the coord sys or series requires (see `coordDimensions`)",
* + "what the user defines (in `encode` and `dimensions`, see `opt.dimensionsDefine` and `opt.encodeDefine`)"
* + "what the data source provids (see `source`)".
*
* Some guess strategy will be adapted if user does not define something.
* If no 'value' dimension specified, the first no-named dimension will be
* named as 'value'.
*
* @return The results are always sorted by `storeDimIndex` asc.
*/
function prepareSeriesDataSchema(source, opt) {
// TODO: TYPE completeDimensions type
if (!isSourceInstance(source)) {
source = createSourceFromSeriesDataOption(source);
}
opt = opt || {};
var sysDims = opt.coordDimensions || [];
var dimsDef = opt.dimensionsDefine || source.dimensionsDefine || [];
var coordDimNameMap = createHashMap();
var resultList = [];
var dimCount = getDimCount(source, sysDims, dimsDef, opt.dimensionsCount); // Try to ignore unsed dimensions if sharing a high dimension datastore
// 30 is an experience value.
var omitUnusedDimensions =
opt.canOmitUnusedDimensions && shouldOmitUnusedDimensions(dimCount);
var isUsingSourceDimensionsDef = dimsDef === source.dimensionsDefine;
var dataDimNameMap = isUsingSourceDimensionsDef
? ensureSourceDimNameMap(source)
: createDimNameMap(dimsDef);
var encodeDef = opt.encodeDefine;
if (!encodeDef && opt.encodeDefaulter) {
encodeDef = opt.encodeDefaulter(source, dimCount);
}
var encodeDefMap = createHashMap(encodeDef);
var indicesMap = new CtorInt32Array(dimCount);
for (var i = 0; i < indicesMap.length; i++) {
indicesMap[i] = -1;
}
function getResultItem(dimIdx) {
var idx = indicesMap[dimIdx];
if (idx < 0) {
var dimDefItemRaw = dimsDef[dimIdx];
var dimDefItem = isObject(dimDefItemRaw)
? dimDefItemRaw
: {
name: dimDefItemRaw,
};
var resultItem = new SeriesDimensionDefine();
var userDimName = dimDefItem.name;
if (userDimName != null && dataDimNameMap.get(userDimName) != null) {
// Only if `series.dimensions` is defined in option
// displayName, will be set, and dimension will be diplayed vertically in
// tooltip by default.
resultItem.name = resultItem.displayName = userDimName;
}
dimDefItem.type != null && (resultItem.type = dimDefItem.type);
dimDefItem.displayName != null &&
(resultItem.displayName = dimDefItem.displayName);
var newIdx = resultList.length;
indicesMap[dimIdx] = newIdx;
resultItem.storeDimIndex = dimIdx;
resultList.push(resultItem);
return resultItem;
}
return resultList[idx];
}
if (!omitUnusedDimensions) {
for (var i = 0; i < dimCount; i++) {
getResultItem(i);
}
} // Set `coordDim` and `coordDimIndex` by `encodeDefMap` and normalize `encodeDefMap`.
encodeDefMap.each(function (dataDimsRaw, coordDim) {
var dataDims = normalizeToArray(dataDimsRaw).slice(); // Note: It is allowed that `dataDims.length` is `0`, e.g., options is
// `{encode: {x: -1, y: 1}}`. Should not filter anything in
// this case.
if (dataDims.length === 1 && !isString(dataDims[0]) && dataDims[0] < 0) {
encodeDefMap.set(coordDim, false);
return;
}
var validDataDims = encodeDefMap.set(coordDim, []);
each(dataDims, function (resultDimIdxOrName, idx) {
// The input resultDimIdx can be dim name or index.
var resultDimIdx = isString(resultDimIdxOrName)
? dataDimNameMap.get(resultDimIdxOrName)
: resultDimIdxOrName;
if (resultDimIdx != null && resultDimIdx < dimCount) {
validDataDims[idx] = resultDimIdx;
applyDim(getResultItem(resultDimIdx), coordDim, idx);
}
});
}); // Apply templetes and default order from `sysDims`.
var availDimIdx = 0;
each(sysDims, function (sysDimItemRaw) {
var coordDim;
var sysDimItemDimsDef;
var sysDimItemOtherDims;
var sysDimItem;
if (isString(sysDimItemRaw)) {
coordDim = sysDimItemRaw;
sysDimItem = {};
} else {
sysDimItem = sysDimItemRaw;
coordDim = sysDimItem.name;
var ordinalMeta = sysDimItem.ordinalMeta;
sysDimItem.ordinalMeta = null;
sysDimItem = extend({}, sysDimItem);
sysDimItem.ordinalMeta = ordinalMeta; // `coordDimIndex` should not be set directly.
sysDimItemDimsDef = sysDimItem.dimsDef;
sysDimItemOtherDims = sysDimItem.otherDims;
sysDimItem.name =
sysDimItem.coordDim =
sysDimItem.coordDimIndex =
sysDimItem.dimsDef =
sysDimItem.otherDims =
null;
}
var dataDims = encodeDefMap.get(coordDim); // negative resultDimIdx means no need to mapping.
if (dataDims === false) {
return;
}
dataDims = normalizeToArray(dataDims); // dimensions provides default dim sequences.
if (!dataDims.length) {
for (
var i = 0;
i < ((sysDimItemDimsDef && sysDimItemDimsDef.length) || 1);
i++
) {
while (
availDimIdx < dimCount &&
getResultItem(availDimIdx).coordDim != null
) {
availDimIdx++;
}
availDimIdx < dimCount && dataDims.push(availDimIdx++);
}
} // Apply templates.
each(dataDims, function (resultDimIdx, coordDimIndex) {
var resultItem = getResultItem(resultDimIdx); // Coordinate system has a higher priority on dim type than source.
if (isUsingSourceDimensionsDef && sysDimItem.type != null) {
resultItem.type = sysDimItem.type;
}
applyDim(defaults(resultItem, sysDimItem), coordDim, coordDimIndex);
if (resultItem.name == null && sysDimItemDimsDef) {
var sysDimItemDimsDefItem = sysDimItemDimsDef[coordDimIndex];
!isObject(sysDimItemDimsDefItem) &&
(sysDimItemDimsDefItem = {
name: sysDimItemDimsDefItem,
});
resultItem.name = resultItem.displayName = sysDimItemDimsDefItem.name;
resultItem.defaultTooltip = sysDimItemDimsDefItem.defaultTooltip;
} // FIXME refactor, currently only used in case: {otherDims: {tooltip: false}}
sysDimItemOtherDims &&
defaults(resultItem.otherDims, sysDimItemOtherDims);
});
});
function applyDim(resultItem, coordDim, coordDimIndex) {
if (VISUAL_DIMENSIONS.get(coordDim) != null) {
resultItem.otherDims[coordDim] = coordDimIndex;
} else {
resultItem.coordDim = coordDim;
resultItem.coordDimIndex = coordDimIndex;
coordDimNameMap.set(coordDim, true);
}
} // Make sure the first extra dim is 'value'.
var generateCoord = opt.generateCoord;
var generateCoordCount = opt.generateCoordCount;
var fromZero = generateCoordCount != null;
generateCoordCount = generateCoord ? generateCoordCount || 1 : 0;
var extra = generateCoord || "value";
function ifNoNameFillWithCoordName(resultItem) {
if (resultItem.name == null) {
// Duplication will be removed in the next step.
resultItem.name = resultItem.coordDim;
}
} // Set dim `name` and other `coordDim` and other props.
if (!omitUnusedDimensions) {
for (var resultDimIdx = 0; resultDimIdx < dimCount; resultDimIdx++) {
var resultItem = getResultItem(resultDimIdx);
var coordDim = resultItem.coordDim;
if (coordDim == null) {
// TODO no need to generate coordDim for isExtraCoord?
resultItem.coordDim = genCoordDimName(
extra,
coordDimNameMap,
fromZero,
);
resultItem.coordDimIndex = 0; // Series specified generateCoord is using out.
if (!generateCoord || generateCoordCount <= 0) {
resultItem.isExtraCoord = true;
}
generateCoordCount--;
}
ifNoNameFillWithCoordName(resultItem);
if (
resultItem.type == null &&
(guessOrdinal(source, resultDimIdx) === BE_ORDINAL.Must || // Consider the case:
// {
// dataset: {source: [
// ['2001', 123],
// ['2002', 456],
// ...
// ['The others', 987],
// ]},
// series: {type: 'pie'}
// }
// The first colum should better be treated as a "ordinal" although it
// might not able to be detected as an "ordinal" by `guessOrdinal`.
(resultItem.isExtraCoord &&
(resultItem.otherDims.itemName != null ||
resultItem.otherDims.seriesName != null)))
) {
resultItem.type = "ordinal";
}
}
} else {
each(resultList, function (resultItem) {
// PENDING: guessOrdinal or let user specify type: 'ordinal' manually?
ifNoNameFillWithCoordName(resultItem);
}); // Sort dimensions: there are some rule that use the last dim as label,
// and for some latter travel process easier.
resultList.sort(function (item0, item1) {
return item0.storeDimIndex - item1.storeDimIndex;
});
}
removeDuplication(resultList);
return new SeriesDataSchema({
source: source,
dimensions: resultList,
fullDimensionCount: dimCount,
dimensionOmitted: omitUnusedDimensions,
});
}
function removeDuplication(result) {
var duplicationMap = createHashMap();
for (var i = 0; i < result.length; i++) {
var dim = result[i];
var dimOriginalName = dim.name;
var count = duplicationMap.get(dimOriginalName) || 0;
if (count > 0) {
// Starts from 0.
dim.name = dimOriginalName + (count - 1);
}
count++;
duplicationMap.set(dimOriginalName, count);
}
} // ??? TODO
// Originally detect dimCount by data[0]. Should we
// optimize it to only by sysDims and dimensions and encode.
// So only necessary dims will be initialized.
// But
// (1) custom series should be considered. where other dims
// may be visited.
// (2) sometimes user need to calcualte bubble size or use visualMap
// on other dimensions besides coordSys needed.
// So, dims that is not used by system, should be shared in data store?
function getDimCount(source, sysDims, dimsDef, optDimCount) {
// Note that the result dimCount should not small than columns count
// of data, otherwise `dataDimNameMap` checking will be incorrect.
var dimCount = Math.max(
source.dimensionsDetectedCount || 1,
sysDims.length,
dimsDef.length,
optDimCount || 0,
);
each(sysDims, function (sysDimItem) {
var sysDimItemDimsDef;
if (isObject(sysDimItem) && (sysDimItemDimsDef = sysDimItem.dimsDef)) {
dimCount = Math.max(dimCount, sysDimItemDimsDef.length);
}
});
return dimCount;
}
function genCoordDimName(name, map, fromZero) {
var mapData = map.data;
if (fromZero || mapData.hasOwnProperty(name)) {
var i = 0;
while (mapData.hasOwnProperty(name + i)) {
i++;
}
name += i;
}
map.set(name, true);
return name;
}
/**
* @class
* For example:
* {
* coordSysName: 'cartesian2d',
* coordSysDims: ['x', 'y', ...],
* axisMap: HashMap({
* x: xAxisModel,
* y: yAxisModel
* }),
* categoryAxisMap: HashMap({
* x: xAxisModel,
* y: undefined
* }),
* // The index of the first category axis in `coordSysDims`.
* // `null/undefined` means no category axis exists.
* firstCategoryDimIndex: 1,
* // To replace user specified encode.
* }
*/
var CoordSysInfo =
/** @class */
(function () {
function CoordSysInfo(coordSysName) {
this.coordSysDims = [];
this.axisMap = createHashMap();
this.categoryAxisMap = createHashMap();
this.coordSysName = coordSysName;
}
return CoordSysInfo;
})();
function getCoordSysInfoBySeries(seriesModel) {
var coordSysName = seriesModel.get("coordinateSystem");
var result = new CoordSysInfo(coordSysName);
var fetch = fetchers[coordSysName];
if (fetch) {
fetch(seriesModel, result, result.axisMap, result.categoryAxisMap);
return result;
}
}
var fetchers = {
cartesian2d: function (seriesModel, result, axisMap, categoryAxisMap) {
var xAxisModel = seriesModel.getReferringComponents(
"xAxis",
SINGLE_REFERRING,
).models[0];
var yAxisModel = seriesModel.getReferringComponents(
"yAxis",
SINGLE_REFERRING,
).models[0];
if ("development" !== "production") {
if (!xAxisModel) {
throw new Error(
'xAxis "' +
retrieve(
seriesModel.get("xAxisIndex"),
seriesModel.get("xAxisId"),
0,
) +
'" not found',
);
}
if (!yAxisModel) {
throw new Error(
'yAxis "' +
retrieve(
seriesModel.get("xAxisIndex"),
seriesModel.get("yAxisId"),
0,
) +
'" not found',
);
}
}
result.coordSysDims = ["x", "y"];
axisMap.set("x", xAxisModel);
axisMap.set("y", yAxisModel);
if (isCategory(xAxisModel)) {
categoryAxisMap.set("x", xAxisModel);
result.firstCategoryDimIndex = 0;
}
if (isCategory(yAxisModel)) {
categoryAxisMap.set("y", yAxisModel);
result.firstCategoryDimIndex == null &&
(result.firstCategoryDimIndex = 1);
}
},
singleAxis: function (seriesModel, result, axisMap, categoryAxisMap) {
var singleAxisModel = seriesModel.getReferringComponents(
"singleAxis",
SINGLE_REFERRING,
).models[0];
if ("development" !== "production") {
if (!singleAxisModel) {
throw new Error("singleAxis should be specified.");
}
}
result.coordSysDims = ["single"];
axisMap.set("single", singleAxisModel);
if (isCategory(singleAxisModel)) {
categoryAxisMap.set("single", singleAxisModel);
result.firstCategoryDimIndex = 0;
}
},
polar: function (seriesModel, result, axisMap, categoryAxisMap) {
var polarModel = seriesModel.getReferringComponents(
"polar",
SINGLE_REFERRING,
).models[0];
var radiusAxisModel = polarModel.findAxisModel("radiusAxis");
var angleAxisModel = polarModel.findAxisModel("angleAxis");
if ("development" !== "production") {
if (!angleAxisModel) {
throw new Error("angleAxis option not found");
}
if (!radiusAxisModel) {
throw new Error("radiusAxis option not found");
}
}
result.coordSysDims = ["radius", "angle"];
axisMap.set("radius", radiusAxisModel);
axisMap.set("angle", angleAxisModel);
if (isCategory(radiusAxisModel)) {
categoryAxisMap.set("radius", radiusAxisModel);
result.firstCategoryDimIndex = 0;
}
if (isCategory(angleAxisModel)) {
categoryAxisMap.set("angle", angleAxisModel);
result.firstCategoryDimIndex == null &&
(result.firstCategoryDimIndex = 1);
}
},
geo: function (seriesModel, result, axisMap, categoryAxisMap) {
result.coordSysDims = ["lng", "lat"];
},
parallel: function (seriesModel, result, axisMap, categoryAxisMap) {
var ecModel = seriesModel.ecModel;
var parallelModel = ecModel.getComponent(
"parallel",
seriesModel.get("parallelIndex"),
);
var coordSysDims = (result.coordSysDims =
parallelModel.dimensions.slice());
each(parallelModel.parallelAxisIndex, function (axisIndex, index) {
var axisModel = ecModel.getComponent("parallelAxis", axisIndex);
var axisDim = coordSysDims[index];
axisMap.set(axisDim, axisModel);
if (isCategory(axisModel)) {
categoryAxisMap.set(axisDim, axisModel);
if (result.firstCategoryDimIndex == null) {
result.firstCategoryDimIndex = index;
}
}
});
},
};
function isCategory(axisModel) {
return axisModel.get("type") === "category";
}
/**
* Note that it is too complicated to support 3d stack by value
* (have to create two-dimension inverted index), so in 3d case
* we just support that stacked by index.
*
* @param seriesModel
* @param dimensionsInput The same as the input of .
* The input will be modified.
* @param opt
* @param opt.stackedCoordDimension Specify a coord dimension if needed.
* @param opt.byIndex=false
* @return calculationInfo
* {
* stackedDimension: string
* stackedByDimension: string
* isStackedByIndex: boolean
* stackedOverDimension: string
* stackResultDimension: string
* }
*/
function enableDataStack(seriesModel, dimensionsInput, opt) {
opt = opt || {};
var byIndex = opt.byIndex;
var stackedCoordDimension = opt.stackedCoordDimension;
var dimensionDefineList;
var schema;
var store;
if (isLegacyDimensionsInput(dimensionsInput)) {
dimensionDefineList = dimensionsInput;
} else {
schema = dimensionsInput.schema;
dimensionDefineList = schema.dimensions;
store = dimensionsInput.store;
} // Compatibal: when `stack` is set as '', do not stack.
var mayStack = !!(seriesModel && seriesModel.get("stack"));
var stackedByDimInfo;
var stackedDimInfo;
var stackResultDimension;
var stackedOverDimension;
each(dimensionDefineList, function (dimensionInfo, index) {
if (isString(dimensionInfo)) {
dimensionDefineList[index] = dimensionInfo = {
name: dimensionInfo,
};
}
if (mayStack && !dimensionInfo.isExtraCoord) {
// Find the first ordinal dimension as the stackedByDimInfo.
if (!byIndex && !stackedByDimInfo && dimensionInfo.ordinalMeta) {
stackedByDimInfo = dimensionInfo;
} // Find the first stackable dimension as the stackedDimInfo.
if (
!stackedDimInfo &&
dimensionInfo.type !== "ordinal" &&
dimensionInfo.type !== "time" &&
(!stackedCoordDimension ||
stackedCoordDimension === dimensionInfo.coordDim)
) {
stackedDimInfo = dimensionInfo;
}
}
});
if (stackedDimInfo && !byIndex && !stackedByDimInfo) {
// Compatible with previous design, value axis (time axis) only stack by index.
// It may make sense if the user provides elaborately constructed data.
byIndex = true;
} // Add stack dimension, they can be both calculated by coordinate system in `unionExtent`.
// That put stack logic in List is for using conveniently in echarts extensions, but it
// might not be a good way.
if (stackedDimInfo) {
// Use a weird name that not duplicated with other names.
// Also need to use seriesModel.id as postfix because different
// series may share same data store. The stack dimension needs to be distinguished.
stackResultDimension = "__\0ecstackresult_" + seriesModel.id;
stackedOverDimension = "__\0ecstackedover_" + seriesModel.id; // Create inverted index to fast query index by value.
if (stackedByDimInfo) {
stackedByDimInfo.createInvertedIndices = true;
}
var stackedDimCoordDim_1 = stackedDimInfo.coordDim;
var stackedDimType = stackedDimInfo.type;
var stackedDimCoordIndex_1 = 0;
each(dimensionDefineList, function (dimensionInfo) {
if (dimensionInfo.coordDim === stackedDimCoordDim_1) {
stackedDimCoordIndex_1++;
}
});
var stackedOverDimensionDefine = {
name: stackResultDimension,
coordDim: stackedDimCoordDim_1,
coordDimIndex: stackedDimCoordIndex_1,
type: stackedDimType,
isExtraCoord: true,
isCalculationCoord: true,
storeDimIndex: dimensionDefineList.length,
};
var stackResultDimensionDefine = {
name: stackedOverDimension,
// This dimension contains stack base (generally, 0), so do not set it as
// `stackedDimCoordDim` to avoid extent calculation, consider log scale.
coordDim: stackedOverDimension,
coordDimIndex: stackedDimCoordIndex_1 + 1,
type: stackedDimType,
isExtraCoord: true,
isCalculationCoord: true,
storeDimIndex: dimensionDefineList.length + 1,
};
if (schema) {
if (store) {
stackedOverDimensionDefine.storeDimIndex =
store.ensureCalculationDimension(
stackedOverDimension,
stackedDimType,
);
stackResultDimensionDefine.storeDimIndex =
store.ensureCalculationDimension(
stackResultDimension,
stackedDimType,
);
}
schema.appendCalculationDimension(stackedOverDimensionDefine);
schema.appendCalculationDimension(stackResultDimensionDefine);
} else {
dimensionDefineList.push(stackedOverDimensionDefine);
dimensionDefineList.push(stackResultDimensionDefine);
}
}
return {
stackedDimension: stackedDimInfo && stackedDimInfo.name,
stackedByDimension: stackedByDimInfo && stackedByDimInfo.name,
isStackedByIndex: byIndex,
stackedOverDimension: stackedOverDimension,
stackResultDimension: stackResultDimension,
};
}
function isLegacyDimensionsInput(dimensionsInput) {
return !isSeriesDataSchema(dimensionsInput.schema);
}
function isDimensionStacked(data, stackedDim) {
// Each single series only maps to one pair of axis. So we do not need to
// check stackByDim, whatever stacked by a dimension or stacked by index.
return (
!!stackedDim && stackedDim === data.getCalculationInfo("stackedDimension")
);
}
function getStackedDimension(data, targetDim) {
return isDimensionStacked(data, targetDim)
? data.getCalculationInfo("stackResultDimension")
: targetDim;
}
function getCoordSysDimDefs(seriesModel, coordSysInfo) {
var coordSysName = seriesModel.get("coordinateSystem");
var registeredCoordSys = CoordinateSystemManager.get(coordSysName);
var coordSysDimDefs;
if (coordSysInfo && coordSysInfo.coordSysDims) {
coordSysDimDefs = map(coordSysInfo.coordSysDims, function (dim) {
var dimInfo = {
name: dim,
};
var axisModel = coordSysInfo.axisMap.get(dim);
if (axisModel) {
var axisType = axisModel.get("type");
dimInfo.type = getDimensionTypeByAxis(axisType);
}
return dimInfo;
});
}
if (!coordSysDimDefs) {
// Get dimensions from registered coordinate system
coordSysDimDefs = (registeredCoordSys &&
(registeredCoordSys.getDimensionsInfo
? registeredCoordSys.getDimensionsInfo()
: registeredCoordSys.dimensions.slice())) || ["x", "y"];
}
return coordSysDimDefs;
}
function injectOrdinalMeta(dimInfoList, createInvertedIndices, coordSysInfo) {
var firstCategoryDimIndex;
var hasNameEncode;
coordSysInfo &&
each(dimInfoList, function (dimInfo, dimIndex) {
var coordDim = dimInfo.coordDim;
var categoryAxisModel = coordSysInfo.categoryAxisMap.get(coordDim);
if (categoryAxisModel) {
if (firstCategoryDimIndex == null) {
firstCategoryDimIndex = dimIndex;
}
dimInfo.ordinalMeta = categoryAxisModel.getOrdinalMeta();
if (createInvertedIndices) {
dimInfo.createInvertedIndices = true;
}
}
if (dimInfo.otherDims.itemName != null) {
hasNameEncode = true;
}
});
if (!hasNameEncode && firstCategoryDimIndex != null) {
dimInfoList[firstCategoryDimIndex].otherDims.itemName = 0;
}
return firstCategoryDimIndex;
}
/**
* Caution: there are side effects to `sourceManager` in this method.
* Should better only be called in `Series['getInitialData']`.
*/
function createSeriesData(sourceRaw, seriesModel, opt) {
opt = opt || {};
var sourceManager = seriesModel.getSourceManager();
var source;
var isOriginalSource = false;
if (sourceRaw) {
isOriginalSource = true;
source = createSourceFromSeriesDataOption(sourceRaw);
} else {
source = sourceManager.getSource(); // Is series.data. not dataset.
isOriginalSource = source.sourceFormat === SOURCE_FORMAT_ORIGINAL;
}
var coordSysInfo = getCoordSysInfoBySeries(seriesModel);
var coordSysDimDefs = getCoordSysDimDefs(seriesModel, coordSysInfo);
var useEncodeDefaulter = opt.useEncodeDefaulter;
var encodeDefaulter = isFunction(useEncodeDefaulter)
? useEncodeDefaulter
: useEncodeDefaulter
? curry(makeSeriesEncodeForAxisCoordSys, coordSysDimDefs, seriesModel)
: null;
var createDimensionOptions = {
coordDimensions: coordSysDimDefs,
generateCoord: opt.generateCoord,
encodeDefine: seriesModel.getEncode(),
encodeDefaulter: encodeDefaulter,
canOmitUnusedDimensions: !isOriginalSource,
};
var schema = prepareSeriesDataSchema(source, createDimensionOptions);
var firstCategoryDimIndex = injectOrdinalMeta(
schema.dimensions,
opt.createInvertedIndices,
coordSysInfo,
);
var store = !isOriginalSource
? sourceManager.getSharedDataStore(schema)
: null;
var stackCalculationInfo = enableDataStack(seriesModel, {
schema: schema,
store: store,
});
var data = new SeriesData(schema, seriesModel);
data.setCalculationInfo(stackCalculationInfo);
var dimValueGetter =
firstCategoryDimIndex != null && isNeedCompleteOrdinalData(source)
? function (itemOpt, dimName, dataIndex, dimIndex) {
// Use dataIndex as ordinal value in categoryAxis
return dimIndex === firstCategoryDimIndex
? dataIndex
: this.defaultDimValueGetter(
itemOpt,
dimName,
dataIndex,
dimIndex,
);
}
: null;
data.hasItemOption = false;
data.initData(
// Try to reuse the data store in sourceManager if using dataset.
isOriginalSource ? source : store,
null,
dimValueGetter,
);
return data;
}
function isNeedCompleteOrdinalData(source) {
if (source.sourceFormat === SOURCE_FORMAT_ORIGINAL) {
var sampleItem = firstDataNotNull(source.data || []);
return !isArray(getDataItemValue(sampleItem));
}
}
function firstDataNotNull(arr) {
var i = 0;
while (i < arr.length && arr[i] == null) {
i++;
}
return arr[i];
}
var Scale =
/** @class */
(function () {
function Scale(setting) {
this._setting = setting || {};
this._extent = [Infinity, -Infinity];
}
Scale.prototype.getSetting = function (name) {
return this._setting[name];
};
/**
* Set extent from data
*/
Scale.prototype.unionExtent = function (other) {
var extent = this._extent;
other[0] < extent[0] && (extent[0] = other[0]);
other[1] > extent[1] && (extent[1] = other[1]); // not setExtent because in log axis it may transformed to power
// this.setExtent(extent[0], extent[1]);
};
/**
* Set extent from data
*/
Scale.prototype.unionExtentFromData = function (data, dim) {
this.unionExtent(data.getApproximateExtent(dim));
};
/**
* Get extent
*
* Extent is always in increase order.
*/
Scale.prototype.getExtent = function () {
return this._extent.slice();
};
/**
* Set extent
*/
Scale.prototype.setExtent = function (start, end) {
var thisExtent = this._extent;
if (!isNaN(start)) {
thisExtent[0] = start;
}
if (!isNaN(end)) {
thisExtent[1] = end;
}
};
/**
* If value is in extent range
*/
Scale.prototype.isInExtentRange = function (value) {
return this._extent[0] <= value && this._extent[1] >= value;
};
/**
* When axis extent depends on data and no data exists,
* axis ticks should not be drawn, which is named 'blank'.
*/
Scale.prototype.isBlank = function () {
return this._isBlank;
};
/**
* When axis extent depends on data and no data exists,
* axis ticks should not be drawn, which is named 'blank'.
*/
Scale.prototype.setBlank = function (isBlank) {
this._isBlank = isBlank;
};
return Scale;
})();
enableClassManagement(Scale);
var uidBase = 0;
var OrdinalMeta =
/** @class */
(function () {
function OrdinalMeta(opt) {
this.categories = opt.categories || [];
this._needCollect = opt.needCollect;
this._deduplication = opt.deduplication;
this.uid = ++uidBase;
}
OrdinalMeta.createByAxisModel = function (axisModel) {
var option = axisModel.option;
var data = option.data;
var categories = data && map(data, getName);
return new OrdinalMeta({
categories: categories,
needCollect: !categories,
// deduplication is default in axis.
deduplication: option.dedplication !== false,
});
};
OrdinalMeta.prototype.getOrdinal = function (category) {
// @ts-ignore
return this._getOrCreateMap().get(category);
};
/**
* @return The ordinal. If not found, return NaN.
*/
OrdinalMeta.prototype.parseAndCollect = function (category) {
var index;
var needCollect = this._needCollect; // The value of category dim can be the index of the given category set.
// This feature is only supported when !needCollect, because we should
// consider a common case: a value is 2017, which is a number but is
// expected to be tread as a category. This case usually happen in dataset,
// where it happent to be no need of the index feature.
if (!isString(category) && !needCollect) {
return category;
} // Optimize for the scenario:
// category is ['2012-01-01', '2012-01-02', ...], where the input
// data has been ensured not duplicate and is large data.
// Notice, if a dataset dimension provide categroies, usually echarts
// should remove duplication except user tell echarts dont do that
// (set axis.deduplication = false), because echarts do not know whether
// the values in the category dimension has duplication (consider the
// parallel-aqi example)
if (needCollect && !this._deduplication) {
index = this.categories.length;
this.categories[index] = category;
return index;
}
var map = this._getOrCreateMap(); // @ts-ignore
index = map.get(category);
if (index == null) {
if (needCollect) {
index = this.categories.length;
this.categories[index] = category; // @ts-ignore
map.set(category, index);
} else {
index = NaN;
}
}
return index;
}; // Consider big data, do not create map until needed.
OrdinalMeta.prototype._getOrCreateMap = function () {
return this._map || (this._map = createHashMap(this.categories));
};
return OrdinalMeta;
})();
function getName(obj) {
if (isObject(obj) && obj.value != null) {
return obj.value;
} else {
return obj + "";
}
}
function isValueNice(val) {
var exp10 = Math.pow(10, quantityExponent(Math.abs(val)));
var f = Math.abs(val / exp10);
return f === 0 || f === 1 || f === 2 || f === 3 || f === 5;
}
function isIntervalOrLogScale(scale) {
return scale.type === "interval" || scale.type === "log";
}
/**
* @param extent Both extent[0] and extent[1] should be valid number.
* Should be extent[0] < extent[1].
* @param splitNumber splitNumber should be >= 1.
*/
function intervalScaleNiceTicks(
extent,
splitNumber,
minInterval,
maxInterval,
) {
var result = {};
var span = extent[1] - extent[0];
var interval = (result.interval = nice(span / splitNumber, true));
if (minInterval != null && interval < minInterval) {
interval = result.interval = minInterval;
}
if (maxInterval != null && interval > maxInterval) {
interval = result.interval = maxInterval;
} // Tow more digital for tick.
var precision = (result.intervalPrecision = getIntervalPrecision(interval)); // Niced extent inside original extent
var niceTickExtent = (result.niceTickExtent = [
round(Math.ceil(extent[0] / interval) * interval, precision),
round(Math.floor(extent[1] / interval) * interval, precision),
]);
fixExtent(niceTickExtent, extent);
return result;
}
function increaseInterval(interval) {
var exp10 = Math.pow(10, quantityExponent(interval)); // Increase interval
var f = interval / exp10;
if (!f) {
f = 1;
} else if (f === 2) {
f = 3;
} else if (f === 3) {
f = 5;
} else {
// f is 1 or 5
f *= 2;
}
return round(f * exp10);
}
/**
* @return interval precision
*/
function getIntervalPrecision(interval) {
// Tow more digital for tick.
return getPrecision(interval) + 2;
}
function clamp(niceTickExtent, idx, extent) {
niceTickExtent[idx] = Math.max(
Math.min(niceTickExtent[idx], extent[1]),
extent[0],
);
} // In some cases (e.g., splitNumber is 1), niceTickExtent may be out of extent.
function fixExtent(niceTickExtent, extent) {
!isFinite(niceTickExtent[0]) && (niceTickExtent[0] = extent[0]);
!isFinite(niceTickExtent[1]) && (niceTickExtent[1] = extent[1]);
clamp(niceTickExtent, 0, extent);
clamp(niceTickExtent, 1, extent);
if (niceTickExtent[0] > niceTickExtent[1]) {
niceTickExtent[0] = niceTickExtent[1];
}
}
function contain$1(val, extent) {
return val >= extent[0] && val <= extent[1];
}
function normalize$1(val, extent) {
if (extent[1] === extent[0]) {
return 0.5;
}
return (val - extent[0]) / (extent[1] - extent[0]);
}
function scale$2(val, extent) {
return val * (extent[1] - extent[0]) + extent[0];
}
var OrdinalScale =
/** @class */
(function (_super) {
__extends(OrdinalScale, _super);
function OrdinalScale(setting) {
var _this = _super.call(this, setting) || this;
_this.type = "ordinal";
var ordinalMeta = _this.getSetting("ordinalMeta"); // Caution: Should not use instanceof, consider ec-extensions using
// import approach to get OrdinalMeta class.
if (!ordinalMeta) {
ordinalMeta = new OrdinalMeta({});
}
if (isArray(ordinalMeta)) {
ordinalMeta = new OrdinalMeta({
categories: map(ordinalMeta, function (item) {
return isObject(item) ? item.value : item;
}),
});
}
_this._ordinalMeta = ordinalMeta;
_this._extent = _this.getSetting("extent") || [
0,
ordinalMeta.categories.length - 1,
];
return _this;
}
OrdinalScale.prototype.parse = function (val) {
// Caution: Math.round(null) will return `0` rather than `NaN`
if (val == null) {
return NaN;
}
return isString(val)
? this._ordinalMeta.getOrdinal(val) // val might be float.
: Math.round(val);
};
OrdinalScale.prototype.contain = function (rank) {
rank = this.parse(rank);
return (
contain$1(rank, this._extent) &&
this._ordinalMeta.categories[rank] != null
);
};
/**
* Normalize given rank or name to linear [0, 1]
* @param val raw ordinal number.
* @return normalized value in [0, 1].
*/
OrdinalScale.prototype.normalize = function (val) {
val = this._getTickNumber(this.parse(val));
return normalize$1(val, this._extent);
};
/**
* @param val normalized value in [0, 1].
* @return raw ordinal number.
*/
OrdinalScale.prototype.scale = function (val) {
val = Math.round(scale$2(val, this._extent));
return this.getRawOrdinalNumber(val);
};
OrdinalScale.prototype.getTicks = function () {
var ticks = [];
var extent = this._extent;
var rank = extent[0];
while (rank <= extent[1]) {
ticks.push({
value: rank,
});
rank++;
}
return ticks;
};
OrdinalScale.prototype.getMinorTicks = function (splitNumber) {
// Not support.
return;
};
/**
* @see `Ordinal['_ordinalNumbersByTick']`
*/
OrdinalScale.prototype.setSortInfo = function (info) {
if (info == null) {
this._ordinalNumbersByTick = this._ticksByOrdinalNumber = null;
return;
}
var infoOrdinalNumbers = info.ordinalNumbers;
var ordinalsByTick = (this._ordinalNumbersByTick = []);
var ticksByOrdinal = (this._ticksByOrdinalNumber = []); // Unnecessary support negative tick in `realtimeSort`.
var tickNum = 0;
var allCategoryLen = this._ordinalMeta.categories.length;
for (
var len = Math.min(allCategoryLen, infoOrdinalNumbers.length);
tickNum < len;
++tickNum
) {
var ordinalNumber = infoOrdinalNumbers[tickNum];
ordinalsByTick[tickNum] = ordinalNumber;
ticksByOrdinal[ordinalNumber] = tickNum;
} // Handle that `series.data` only covers part of the `axis.category.data`.
var unusedOrdinal = 0;
for (; tickNum < allCategoryLen; ++tickNum) {
while (ticksByOrdinal[unusedOrdinal] != null) {
unusedOrdinal++;
}
ordinalsByTick.push(unusedOrdinal);
ticksByOrdinal[unusedOrdinal] = tickNum;
}
};
OrdinalScale.prototype._getTickNumber = function (ordinal) {
var ticksByOrdinalNumber = this._ticksByOrdinalNumber; // also support ordinal out of range of `ordinalMeta.categories.length`,
// where ordinal numbers are used as tick value directly.
return ticksByOrdinalNumber &&
ordinal >= 0 &&
ordinal < ticksByOrdinalNumber.length
? ticksByOrdinalNumber[ordinal]
: ordinal;
};
/**
* @usage
* ```js
* const ordinalNumber = ordinalScale.getRawOrdinalNumber(tickVal);
*
* // case0
* const rawOrdinalValue = axisModel.getCategories()[ordinalNumber];
* // case1
* const rawOrdinalValue = this._ordinalMeta.categories[ordinalNumber];
* // case2
* const coord = axis.dataToCoord(ordinalNumber);
* ```
*
* @param {OrdinalNumber} tickNumber index of display
*/
OrdinalScale.prototype.getRawOrdinalNumber = function (tickNumber) {
var ordinalNumbersByTick = this._ordinalNumbersByTick; // tickNumber may be out of range, e.g., when axis max is larger than `ordinalMeta.categories.length`.,
// where ordinal numbers are used as tick value directly.
return ordinalNumbersByTick &&
tickNumber >= 0 &&
tickNumber < ordinalNumbersByTick.length
? ordinalNumbersByTick[tickNumber]
: tickNumber;
};
/**
* Get item on tick
*/
OrdinalScale.prototype.getLabel = function (tick) {
if (!this.isBlank()) {
var ordinalNumber = this.getRawOrdinalNumber(tick.value);
var cateogry = this._ordinalMeta.categories[ordinalNumber]; // Note that if no data, ordinalMeta.categories is an empty array.
// Return empty if it's not exist.
return cateogry == null ? "" : cateogry + "";
}
};
OrdinalScale.prototype.count = function () {
return this._extent[1] - this._extent[0] + 1;
};
OrdinalScale.prototype.unionExtentFromData = function (data, dim) {
this.unionExtent(data.getApproximateExtent(dim));
};
/**
* @override
* If value is in extent range
*/
OrdinalScale.prototype.isInExtentRange = function (value) {
value = this._getTickNumber(value);
return this._extent[0] <= value && this._extent[1] >= value;
};
OrdinalScale.prototype.getOrdinalMeta = function () {
return this._ordinalMeta;
};
OrdinalScale.prototype.calcNiceTicks = function () {};
OrdinalScale.prototype.calcNiceExtent = function () {};
OrdinalScale.type = "ordinal";
return OrdinalScale;
})(Scale);
Scale.registerClass(OrdinalScale);
var roundNumber = round;
var IntervalScale =
/** @class */
(function (_super) {
__extends(IntervalScale, _super);
function IntervalScale() {
var _this = (_super !== null && _super.apply(this, arguments)) || this;
_this.type = "interval"; // Step is calculated in adjustExtent.
_this._interval = 0;
_this._intervalPrecision = 2;
return _this;
}
IntervalScale.prototype.parse = function (val) {
return val;
};
IntervalScale.prototype.contain = function (val) {
return contain$1(val, this._extent);
};
IntervalScale.prototype.normalize = function (val) {
return normalize$1(val, this._extent);
};
IntervalScale.prototype.scale = function (val) {
return scale$2(val, this._extent);
};
IntervalScale.prototype.setExtent = function (start, end) {
var thisExtent = this._extent; // start,end may be a Number like '25',so...
if (!isNaN(start)) {
thisExtent[0] = parseFloat(start);
}
if (!isNaN(end)) {
thisExtent[1] = parseFloat(end);
}
};
IntervalScale.prototype.unionExtent = function (other) {
var extent = this._extent;
other[0] < extent[0] && (extent[0] = other[0]);
other[1] > extent[1] && (extent[1] = other[1]); // unionExtent may called by it's sub classes
this.setExtent(extent[0], extent[1]);
};
IntervalScale.prototype.getInterval = function () {
return this._interval;
};
IntervalScale.prototype.setInterval = function (interval) {
this._interval = interval; // Dropped auto calculated niceExtent and use user setted extent
// We assume user wan't to set both interval, min, max to get a better result
this._niceExtent = this._extent.slice();
this._intervalPrecision = getIntervalPrecision(interval);
};
/**
* @param expandToNicedExtent Whether expand the ticks to niced extent.
*/
IntervalScale.prototype.getTicks = function (expandToNicedExtent) {
var interval = this._interval;
var extent = this._extent;
var niceTickExtent = this._niceExtent;
var intervalPrecision = this._intervalPrecision;
var ticks = []; // If interval is 0, return [];
if (!interval) {
return ticks;
} // Consider this case: using dataZoom toolbox, zoom and zoom.
var safeLimit = 10000;
if (extent[0] < niceTickExtent[0]) {
if (expandToNicedExtent) {
ticks.push({
value: roundNumber(
niceTickExtent[0] - interval,
intervalPrecision,
),
});
} else {
ticks.push({
value: extent[0],
});
}
}
var tick = niceTickExtent[0];
while (tick <= niceTickExtent[1]) {
ticks.push({
value: tick,
}); // Avoid rounding error
tick = roundNumber(tick + interval, intervalPrecision);
if (tick === ticks[ticks.length - 1].value) {
// Consider out of safe float point, e.g.,
// -3711126.9907707 + 2e-10 === -3711126.9907707
break;
}
if (ticks.length > safeLimit) {
return [];
}
} // Consider this case: the last item of ticks is smaller
// than niceTickExtent[1] and niceTickExtent[1] === extent[1].
var lastNiceTick = ticks.length
? ticks[ticks.length - 1].value
: niceTickExtent[1];
if (extent[1] > lastNiceTick) {
if (expandToNicedExtent) {
ticks.push({
value: roundNumber(lastNiceTick + interval, intervalPrecision),
});
} else {
ticks.push({
value: extent[1],
});
}
}
return ticks;
};
IntervalScale.prototype.getMinorTicks = function (splitNumber) {
var ticks = this.getTicks(true);
var minorTicks = [];
var extent = this.getExtent();
for (var i = 1; i < ticks.length; i++) {
var nextTick = ticks[i];
var prevTick = ticks[i - 1];
var count = 0;
var minorTicksGroup = [];
var interval = nextTick.value - prevTick.value;
var minorInterval = interval / splitNumber;
while (count < splitNumber - 1) {
var minorTick = roundNumber(
prevTick.value + (count + 1) * minorInterval,
); // For the first and last interval. The count may be less than splitNumber.
if (minorTick > extent[0] && minorTick < extent[1]) {
minorTicksGroup.push(minorTick);
}
count++;
}
minorTicks.push(minorTicksGroup);
}
return minorTicks;
};
/**
* @param opt.precision If 'auto', use nice presision.
* @param opt.pad returns 1.50 but not 1.5 if precision is 2.
*/
IntervalScale.prototype.getLabel = function (data, opt) {
if (data == null) {
return "";
}
var precision = opt && opt.precision;
if (precision == null) {
precision = getPrecision(data.value) || 0;
} else if (precision === "auto") {
// Should be more precise then tick.
precision = this._intervalPrecision;
} // (1) If `precision` is set, 12.005 should be display as '12.00500'.
// (2) Use roundNumber (toFixed) to avoid scientific notation like '3.5e-7'.
var dataNum = roundNumber(data.value, precision, true);
return addCommas(dataNum);
};
/**
* @param splitNumber By default `5`.
*/
IntervalScale.prototype.calcNiceTicks = function (
splitNumber,
minInterval,
maxInterval,
) {
splitNumber = splitNumber || 5;
var extent = this._extent;
var span = extent[1] - extent[0];
if (!isFinite(span)) {
return;
} // User may set axis min 0 and data are all negative
// FIXME If it needs to reverse ?
if (span < 0) {
span = -span;
extent.reverse();
}
var result = intervalScaleNiceTicks(
extent,
splitNumber,
minInterval,
maxInterval,
);
this._intervalPrecision = result.intervalPrecision;
this._interval = result.interval;
this._niceExtent = result.niceTickExtent;
};
IntervalScale.prototype.calcNiceExtent = function (opt) {
var extent = this._extent; // If extent start and end are same, expand them
if (extent[0] === extent[1]) {
if (extent[0] !== 0) {
// Expand extent
var expandSize = extent[0]; // In the fowllowing case
// Axis has been fixed max 100
// Plus data are all 100 and axis extent are [100, 100].
// Extend to the both side will cause expanded max is larger than fixed max.
// So only expand to the smaller side.
if (!opt.fixMax) {
extent[1] += expandSize / 2;
extent[0] -= expandSize / 2;
} else {
extent[0] -= expandSize / 2;
}
} else {
extent[1] = 1;
}
}
var span = extent[1] - extent[0]; // If there are no data and extent are [Infinity, -Infinity]
if (!isFinite(span)) {
extent[0] = 0;
extent[1] = 1;
}
this.calcNiceTicks(opt.splitNumber, opt.minInterval, opt.maxInterval); // let extent = this._extent;
var interval = this._interval;
if (!opt.fixMin) {
extent[0] = roundNumber(Math.floor(extent[0] / interval) * interval);
}
if (!opt.fixMax) {
extent[1] = roundNumber(Math.ceil(extent[1] / interval) * interval);
}
};
IntervalScale.prototype.setNiceExtent = function (min, max) {
this._niceExtent = [min, max];
};
IntervalScale.type = "interval";
return IntervalScale;
})(Scale);
Scale.registerClass(IntervalScale);
/* global Float32Array */
var supportFloat32Array = typeof Float32Array !== "undefined";
var Float32ArrayCtor = !supportFloat32Array ? Array : Float32Array;
function createFloat32Array(arg) {
if (isArray(arg)) {
// Return self directly if don't support TypedArray.
return supportFloat32Array ? new Float32Array(arg) : arg;
} // Else is number
return new Float32ArrayCtor(arg);
}
var STACK_PREFIX = "__ec_stack_";
function getSeriesStackId(seriesModel) {
return seriesModel.get("stack") || STACK_PREFIX + seriesModel.seriesIndex;
}
function getAxisKey(axis) {
return axis.dim + axis.index;
}
/**
* @return {Object} {width, offset, offsetCenter} If axis.type is not 'category', return undefined.
*/
function getLayoutOnAxis(opt) {
var params = [];
var baseAxis = opt.axis;
var axisKey = "axis0";
if (baseAxis.type !== "category") {
return;
}
var bandWidth = baseAxis.getBandWidth();
for (var i = 0; i < opt.count || 0; i++) {
params.push(
defaults(
{
bandWidth: bandWidth,
axisKey: axisKey,
stackId: STACK_PREFIX + i,
},
opt,
),
);
}
var widthAndOffsets = doCalBarWidthAndOffset(params);
var result = [];
for (var i = 0; i < opt.count; i++) {
var item = widthAndOffsets[axisKey][STACK_PREFIX + i];
item.offsetCenter = item.offset + item.width / 2;
result.push(item);
}
return result;
}
function prepareLayoutBarSeries(seriesType, ecModel) {
var seriesModels = [];
ecModel.eachSeriesByType(seriesType, function (seriesModel) {
// Check series coordinate, do layout for cartesian2d only
if (isOnCartesian(seriesModel)) {
seriesModels.push(seriesModel);
}
});
return seriesModels;
}
/**
* Map from (baseAxis.dim + '_' + baseAxis.index) to min gap of two adjacent
* values.
* This works for time axes, value axes, and log axes.
* For a single time axis, return value is in the form like
* {'x_0': [1000000]}.
* The value of 1000000 is in milliseconds.
*/
function getValueAxesMinGaps(barSeries) {
/**
* Map from axis.index to values.
* For a single time axis, axisValues is in the form like
* {'x_0': [1495555200000, 1495641600000, 1495728000000]}.
* Items in axisValues[x], e.g. 1495555200000, are time values of all
* series.
*/
var axisValues = {};
each(barSeries, function (seriesModel) {
var cartesian = seriesModel.coordinateSystem;
var baseAxis = cartesian.getBaseAxis();
if (baseAxis.type !== "time" && baseAxis.type !== "value") {
return;
}
var data = seriesModel.getData();
var key = baseAxis.dim + "_" + baseAxis.index;
var dimIdx = data.getDimensionIndex(data.mapDimension(baseAxis.dim));
var store = data.getStore();
for (var i = 0, cnt = store.count(); i < cnt; ++i) {
var value = store.get(dimIdx, i);
if (!axisValues[key]) {
// No previous data for the axis
axisValues[key] = [value];
} else {
// No value in previous series
axisValues[key].push(value);
} // Ignore duplicated time values in the same axis
}
});
var axisMinGaps = {};
for (var key in axisValues) {
if (axisValues.hasOwnProperty(key)) {
var valuesInAxis = axisValues[key];
if (valuesInAxis) {
// Sort axis values into ascending order to calculate gaps
valuesInAxis.sort(function (a, b) {
return a - b;
});
var min = null;
for (var j = 1; j < valuesInAxis.length; ++j) {
var delta = valuesInAxis[j] - valuesInAxis[j - 1];
if (delta > 0) {
// Ignore 0 delta because they are of the same axis value
min = min === null ? delta : Math.min(min, delta);
}
} // Set to null if only have one data
axisMinGaps[key] = min;
}
}
}
return axisMinGaps;
}
function makeColumnLayout(barSeries) {
var axisMinGaps = getValueAxesMinGaps(barSeries);
var seriesInfoList = [];
each(barSeries, function (seriesModel) {
var cartesian = seriesModel.coordinateSystem;
var baseAxis = cartesian.getBaseAxis();
var axisExtent = baseAxis.getExtent();
var bandWidth;
if (baseAxis.type === "category") {
bandWidth = baseAxis.getBandWidth();
} else if (baseAxis.type === "value" || baseAxis.type === "time") {
var key = baseAxis.dim + "_" + baseAxis.index;
var minGap = axisMinGaps[key];
var extentSpan = Math.abs(axisExtent[1] - axisExtent[0]);
var scale = baseAxis.scale.getExtent();
var scaleSpan = Math.abs(scale[1] - scale[0]);
bandWidth = minGap ? (extentSpan / scaleSpan) * minGap : extentSpan; // When there is only one data value
} else {
var data = seriesModel.getData();
bandWidth = Math.abs(axisExtent[1] - axisExtent[0]) / data.count();
}
var barWidth = parsePercent$1(seriesModel.get("barWidth"), bandWidth);
var barMaxWidth = parsePercent$1(
seriesModel.get("barMaxWidth"),
bandWidth,
);
var barMinWidth = parsePercent$1(
// barMinWidth by default is 0.5 / 1 in cartesian. Because in value axis,
// the auto-calculated bar width might be less than 0.5 / 1.
seriesModel.get("barMinWidth") ||
(isInLargeMode(seriesModel) ? 0.5 : 1),
bandWidth,
);
var barGap = seriesModel.get("barGap");
var barCategoryGap = seriesModel.get("barCategoryGap");
seriesInfoList.push({
bandWidth: bandWidth,
barWidth: barWidth,
barMaxWidth: barMaxWidth,
barMinWidth: barMinWidth,
barGap: barGap,
barCategoryGap: barCategoryGap,
axisKey: getAxisKey(baseAxis),
stackId: getSeriesStackId(seriesModel),
});
});
return doCalBarWidthAndOffset(seriesInfoList);
}
function doCalBarWidthAndOffset(seriesInfoList) {
// Columns info on each category axis. Key is cartesian name
var columnsMap = {};
each(seriesInfoList, function (seriesInfo, idx) {
var axisKey = seriesInfo.axisKey;
var bandWidth = seriesInfo.bandWidth;
var columnsOnAxis = columnsMap[axisKey] || {
bandWidth: bandWidth,
remainedWidth: bandWidth,
autoWidthCount: 0,
categoryGap: null,
gap: "20%",
stacks: {},
};
var stacks = columnsOnAxis.stacks;
columnsMap[axisKey] = columnsOnAxis;
var stackId = seriesInfo.stackId;
if (!stacks[stackId]) {
columnsOnAxis.autoWidthCount++;
}
stacks[stackId] = stacks[stackId] || {
width: 0,
maxWidth: 0,
}; // Caution: In a single coordinate system, these barGrid attributes
// will be shared by series. Consider that they have default values,
// only the attributes set on the last series will work.
// Do not change this fact unless there will be a break change.
var barWidth = seriesInfo.barWidth;
if (barWidth && !stacks[stackId].width) {
// See #6312, do not restrict width.
stacks[stackId].width = barWidth;
barWidth = Math.min(columnsOnAxis.remainedWidth, barWidth);
columnsOnAxis.remainedWidth -= barWidth;
}
var barMaxWidth = seriesInfo.barMaxWidth;
barMaxWidth && (stacks[stackId].maxWidth = barMaxWidth);
var barMinWidth = seriesInfo.barMinWidth;
barMinWidth && (stacks[stackId].minWidth = barMinWidth);
var barGap = seriesInfo.barGap;
barGap != null && (columnsOnAxis.gap = barGap);
var barCategoryGap = seriesInfo.barCategoryGap;
barCategoryGap != null && (columnsOnAxis.categoryGap = barCategoryGap);
});
var result = {};
each(columnsMap, function (columnsOnAxis, coordSysName) {
result[coordSysName] = {};
var stacks = columnsOnAxis.stacks;
var bandWidth = columnsOnAxis.bandWidth;
var categoryGapPercent = columnsOnAxis.categoryGap;
if (categoryGapPercent == null) {
var columnCount = keys(stacks).length; // More columns in one group
// the spaces between group is smaller. Or the column will be too thin.
categoryGapPercent = Math.max(35 - columnCount * 4, 15) + "%";
}
var categoryGap = parsePercent$1(categoryGapPercent, bandWidth);
var barGapPercent = parsePercent$1(columnsOnAxis.gap, 1);
var remainedWidth = columnsOnAxis.remainedWidth;
var autoWidthCount = columnsOnAxis.autoWidthCount;
var autoWidth =
(remainedWidth - categoryGap) /
(autoWidthCount + (autoWidthCount - 1) * barGapPercent);
autoWidth = Math.max(autoWidth, 0); // Find if any auto calculated bar exceeded maxBarWidth
each(stacks, function (column) {
var maxWidth = column.maxWidth;
var minWidth = column.minWidth;
if (!column.width) {
var finalWidth = autoWidth;
if (maxWidth && maxWidth < finalWidth) {
finalWidth = Math.min(maxWidth, remainedWidth);
} // `minWidth` has higher priority. `minWidth` decide that wheter the
// bar is able to be visible. So `minWidth` should not be restricted
// by `maxWidth` or `remainedWidth` (which is from `bandWidth`). In
// the extreme cases for `value` axis, bars are allowed to overlap
// with each other if `minWidth` specified.
if (minWidth && minWidth > finalWidth) {
finalWidth = minWidth;
}
if (finalWidth !== autoWidth) {
column.width = finalWidth;
remainedWidth -= finalWidth + barGapPercent * finalWidth;
autoWidthCount--;
}
} else {
// `barMinWidth/barMaxWidth` has higher priority than `barWidth`, as
// CSS does. Becuase barWidth can be a percent value, where
// `barMaxWidth` can be used to restrict the final width.
var finalWidth = column.width;
if (maxWidth) {
finalWidth = Math.min(finalWidth, maxWidth);
} // `minWidth` has higher priority, as described above
if (minWidth) {
finalWidth = Math.max(finalWidth, minWidth);
}
column.width = finalWidth;
remainedWidth -= finalWidth + barGapPercent * finalWidth;
autoWidthCount--;
}
}); // Recalculate width again
autoWidth =
(remainedWidth - categoryGap) /
(autoWidthCount + (autoWidthCount - 1) * barGapPercent);
autoWidth = Math.max(autoWidth, 0);
var widthSum = 0;
var lastColumn;
each(stacks, function (column, idx) {
if (!column.width) {
column.width = autoWidth;
}
lastColumn = column;
widthSum += column.width * (1 + barGapPercent);
});
if (lastColumn) {
widthSum -= lastColumn.width * barGapPercent;
}
var offset = -widthSum / 2;
each(stacks, function (column, stackId) {
result[coordSysName][stackId] = result[coordSysName][stackId] || {
bandWidth: bandWidth,
offset: offset,
width: column.width,
};
offset += column.width * (1 + barGapPercent);
});
});
return result;
}
function retrieveColumnLayout(barWidthAndOffset, axis, seriesModel) {
if (barWidthAndOffset && axis) {
var result = barWidthAndOffset[getAxisKey(axis)];
if (result != null && seriesModel != null) {
return result[getSeriesStackId(seriesModel)];
}
return result;
}
}
function layout(seriesType, ecModel) {
var seriesModels = prepareLayoutBarSeries(seriesType, ecModel);
var barWidthAndOffset = makeColumnLayout(seriesModels);
each(seriesModels, function (seriesModel) {
var data = seriesModel.getData();
var cartesian = seriesModel.coordinateSystem;
var baseAxis = cartesian.getBaseAxis();
var stackId = getSeriesStackId(seriesModel);
var columnLayoutInfo = barWidthAndOffset[getAxisKey(baseAxis)][stackId];
var columnOffset = columnLayoutInfo.offset;
var columnWidth = columnLayoutInfo.width;
data.setLayout({
bandWidth: columnLayoutInfo.bandWidth,
offset: columnOffset,
size: columnWidth,
});
});
} // TODO: Do not support stack in large mode yet.
function createProgressiveLayout(seriesType) {
return {
seriesType: seriesType,
plan: createRenderPlanner(),
reset: function (seriesModel) {
if (!isOnCartesian(seriesModel)) {
return;
}
var data = seriesModel.getData();
var cartesian = seriesModel.coordinateSystem;
var baseAxis = cartesian.getBaseAxis();
var valueAxis = cartesian.getOtherAxis(baseAxis);
var valueDimIdx = data.getDimensionIndex(
data.mapDimension(valueAxis.dim),
);
var baseDimIdx = data.getDimensionIndex(
data.mapDimension(baseAxis.dim),
);
var drawBackground = seriesModel.get("showBackground", true);
var valueDim = data.mapDimension(valueAxis.dim);
var stackResultDim = data.getCalculationInfo("stackResultDimension");
var stacked =
isDimensionStacked(data, valueDim) &&
!!data.getCalculationInfo("stackedOnSeries");
var isValueAxisH = valueAxis.isHorizontal();
var valueAxisStart = getValueAxisStart(baseAxis, valueAxis);
var isLarge = isInLargeMode(seriesModel);
var barMinHeight = seriesModel.get("barMinHeight") || 0;
var stackedDimIdx =
stackResultDim && data.getDimensionIndex(stackResultDim); // Layout info.
var columnWidth = data.getLayout("size");
var columnOffset = data.getLayout("offset");
return {
progress: function (params, data) {
var count = params.count;
var largePoints = isLarge && createFloat32Array(count * 3);
var largeBackgroundPoints =
isLarge && drawBackground && createFloat32Array(count * 3);
var largeDataIndices = isLarge && createFloat32Array(count);
var coordLayout = cartesian.master.getRect();
var bgSize = isValueAxisH ? coordLayout.width : coordLayout.height;
var dataIndex;
var store = data.getStore();
var idxOffset = 0;
while ((dataIndex = params.next()) != null) {
var value = store.get(
stacked ? stackedDimIdx : valueDimIdx,
dataIndex,
);
var baseValue = store.get(baseDimIdx, dataIndex);
var baseCoord = valueAxisStart;
var startValue = void 0; // Because of the barMinHeight, we can not use the value in
// stackResultDimension directly.
if (stacked) {
startValue = +value - store.get(valueDimIdx, dataIndex);
}
var x = void 0;
var y = void 0;
var width = void 0;
var height = void 0;
if (isValueAxisH) {
var coord = cartesian.dataToPoint([value, baseValue]);
if (stacked) {
var startCoord = cartesian.dataToPoint([
startValue,
baseValue,
]);
baseCoord = startCoord[0];
}
x = baseCoord;
y = coord[1] + columnOffset;
width = coord[0] - baseCoord;
height = columnWidth;
if (Math.abs(width) < barMinHeight) {
width = (width < 0 ? -1 : 1) * barMinHeight;
}
} else {
var coord = cartesian.dataToPoint([baseValue, value]);
if (stacked) {
var startCoord = cartesian.dataToPoint([
baseValue,
startValue,
]);
baseCoord = startCoord[1];
}
x = coord[0] + columnOffset;
y = baseCoord;
width = columnWidth;
height = coord[1] - baseCoord;
if (Math.abs(height) < barMinHeight) {
// Include zero to has a positive bar
height = (height <= 0 ? -1 : 1) * barMinHeight;
}
}
if (!isLarge) {
data.setItemLayout(dataIndex, {
x: x,
y: y,
width: width,
height: height,
});
} else {
largePoints[idxOffset] = x;
largePoints[idxOffset + 1] = y;
largePoints[idxOffset + 2] = isValueAxisH ? width : height;
if (largeBackgroundPoints) {
largeBackgroundPoints[idxOffset] = isValueAxisH
? coordLayout.x
: x;
largeBackgroundPoints[idxOffset + 1] = isValueAxisH
? y
: coordLayout.y;
largeBackgroundPoints[idxOffset + 2] = bgSize;
}
largeDataIndices[dataIndex] = dataIndex;
}
idxOffset += 3;
}
if (isLarge) {
data.setLayout({
largePoints: largePoints,
largeDataIndices: largeDataIndices,
largeBackgroundPoints: largeBackgroundPoints,
valueAxisHorizontal: isValueAxisH,
});
}
},
};
},
};
}
function isOnCartesian(seriesModel) {
return (
seriesModel.coordinateSystem &&
seriesModel.coordinateSystem.type === "cartesian2d"
);
}
function isInLargeMode(seriesModel) {
return seriesModel.pipelineContext && seriesModel.pipelineContext.large;
} // See cases in `test/bar-start.html` and `#7412`, `#8747`.
function getValueAxisStart(baseAxis, valueAxis) {
return valueAxis.toGlobalCoord(
valueAxis.dataToCoord(valueAxis.type === "log" ? 1 : 0),
);
}
var bisect = function (a, x, lo, hi) {
while (lo < hi) {
var mid = (lo + hi) >>> 1;
if (a[mid][1] < x) {
lo = mid + 1;
} else {
hi = mid;
}
}
return lo;
};
var TimeScale =
/** @class */
(function (_super) {
__extends(TimeScale, _super);
function TimeScale(settings) {
var _this = _super.call(this, settings) || this;
_this.type = "time";
return _this;
}
/**
* Get label is mainly for other components like dataZoom, tooltip.
*/
TimeScale.prototype.getLabel = function (tick) {
var useUTC = this.getSetting("useUTC");
return format(
tick.value,
fullLeveledFormatter[
getDefaultFormatPrecisionOfInterval(
getPrimaryTimeUnit(this._minLevelUnit),
)
] || fullLeveledFormatter.second,
useUTC,
this.getSetting("locale"),
);
};
TimeScale.prototype.getFormattedLabel = function (
tick,
idx,
labelFormatter,
) {
var isUTC = this.getSetting("useUTC");
var lang = this.getSetting("locale");
return leveledFormat(tick, idx, labelFormatter, lang, isUTC);
};
/**
* @override
*/
TimeScale.prototype.getTicks = function () {
var interval = this._interval;
var extent = this._extent;
var ticks = []; // If interval is 0, return [];
if (!interval) {
return ticks;
}
ticks.push({
value: extent[0],
level: 0,
});
var useUTC = this.getSetting("useUTC");
var innerTicks = getIntervalTicks(
this._minLevelUnit,
this._approxInterval,
useUTC,
extent,
);
ticks = ticks.concat(innerTicks);
ticks.push({
value: extent[1],
level: 0,
});
return ticks;
};
TimeScale.prototype.calcNiceExtent = function (opt) {
var extent = this._extent; // If extent start and end are same, expand them
if (extent[0] === extent[1]) {
// Expand extent
extent[0] -= ONE_DAY;
extent[1] += ONE_DAY;
} // If there are no data and extent are [Infinity, -Infinity]
if (extent[1] === -Infinity && extent[0] === Infinity) {
var d = new Date();
extent[1] = +new Date(d.getFullYear(), d.getMonth(), d.getDate());
extent[0] = extent[1] - ONE_DAY;
}
this.calcNiceTicks(opt.splitNumber, opt.minInterval, opt.maxInterval);
};
TimeScale.prototype.calcNiceTicks = function (
approxTickNum,
minInterval,
maxInterval,
) {
approxTickNum = approxTickNum || 10;
var extent = this._extent;
var span = extent[1] - extent[0];
this._approxInterval = span / approxTickNum;
if (minInterval != null && this._approxInterval < minInterval) {
this._approxInterval = minInterval;
}
if (maxInterval != null && this._approxInterval > maxInterval) {
this._approxInterval = maxInterval;
}
var scaleIntervalsLen = scaleIntervals.length;
var idx = Math.min(
bisect(scaleIntervals, this._approxInterval, 0, scaleIntervalsLen),
scaleIntervalsLen - 1,
); // Interval that can be used to calculate ticks
this._interval = scaleIntervals[idx][1]; // Min level used when picking ticks from top down.
// We check one more level to avoid the ticks are to sparse in some case.
this._minLevelUnit = scaleIntervals[Math.max(idx - 1, 0)][0];
};
TimeScale.prototype.parse = function (val) {
// val might be float.
return isNumber(val) ? val : +parseDate(val);
};
TimeScale.prototype.contain = function (val) {
return contain$1(this.parse(val), this._extent);
};
TimeScale.prototype.normalize = function (val) {
return normalize$1(this.parse(val), this._extent);
};
TimeScale.prototype.scale = function (val) {
return scale$2(val, this._extent);
};
TimeScale.type = "time";
return TimeScale;
})(IntervalScale);
/**
* This implementation was originally copied from "d3.js"
*
* with some modifications made for this program.
* See the license statement at the head of this file.
*/
var scaleIntervals = [
// Format interval
["second", ONE_SECOND],
["minute", ONE_MINUTE],
["hour", ONE_HOUR],
["quarter-day", ONE_HOUR * 6],
["half-day", ONE_HOUR * 12],
["day", ONE_DAY * 1.2],
["half-week", ONE_DAY * 3.5],
["week", ONE_DAY * 7],
["month", ONE_DAY * 31],
["quarter", ONE_DAY * 95],
["half-year", ONE_YEAR / 2],
["year", ONE_YEAR], // 1Y
];
function isUnitValueSame(unit, valueA, valueB, isUTC) {
var dateA = parseDate(valueA);
var dateB = parseDate(valueB);
var isSame = function (unit) {
return (
getUnitValue(dateA, unit, isUTC) === getUnitValue(dateB, unit, isUTC)
);
};
var isSameYear = function () {
return isSame("year");
}; // const isSameHalfYear = () => isSameYear() && isSame('half-year');
// const isSameQuater = () => isSameYear() && isSame('quarter');
var isSameMonth = function () {
return isSameYear() && isSame("month");
};
var isSameDay = function () {
return isSameMonth() && isSame("day");
}; // const isSameHalfDay = () => isSameDay() && isSame('half-day');
var isSameHour = function () {
return isSameDay() && isSame("hour");
};
var isSameMinute = function () {
return isSameHour() && isSame("minute");
};
var isSameSecond = function () {
return isSameMinute() && isSame("second");
};
var isSameMilliSecond = function () {
return isSameSecond() && isSame("millisecond");
};
switch (unit) {
case "year":
return isSameYear();
case "month":
return isSameMonth();
case "day":
return isSameDay();
case "hour":
return isSameHour();
case "minute":
return isSameMinute();
case "second":
return isSameSecond();
case "millisecond":
return isSameMilliSecond();
}
} // const primaryUnitGetters = {
// year: fullYearGetterName(),
// month: monthGetterName(),
// day: dateGetterName(),
// hour: hoursGetterName(),
// minute: minutesGetterName(),
// second: secondsGetterName(),
// millisecond: millisecondsGetterName()
// };
// const primaryUnitUTCGetters = {
// year: fullYearGetterName(true),
// month: monthGetterName(true),
// day: dateGetterName(true),
// hour: hoursGetterName(true),
// minute: minutesGetterName(true),
// second: secondsGetterName(true),
// millisecond: millisecondsGetterName(true)
// };
// function moveTick(date: Date, unitName: TimeUnit, step: number, isUTC: boolean) {
// step = step || 1;
// switch (getPrimaryTimeUnit(unitName)) {
// case 'year':
// date[fullYearSetterName(isUTC)](date[fullYearGetterName(isUTC)]() + step);
// break;
// case 'month':
// date[monthSetterName(isUTC)](date[monthGetterName(isUTC)]() + step);
// break;
// case 'day':
// date[dateSetterName(isUTC)](date[dateGetterName(isUTC)]() + step);
// break;
// case 'hour':
// date[hoursSetterName(isUTC)](date[hoursGetterName(isUTC)]() + step);
// break;
// case 'minute':
// date[minutesSetterName(isUTC)](date[minutesGetterName(isUTC)]() + step);
// break;
// case 'second':
// date[secondsSetterName(isUTC)](date[secondsGetterName(isUTC)]() + step);
// break;
// case 'millisecond':
// date[millisecondsSetterName(isUTC)](date[millisecondsGetterName(isUTC)]() + step);
// break;
// }
// return date.getTime();
// }
// const DATE_INTERVALS = [[8, 7.5], [4, 3.5], [2, 1.5]];
// const MONTH_INTERVALS = [[6, 5.5], [3, 2.5], [2, 1.5]];
// const MINUTES_SECONDS_INTERVALS = [[30, 30], [20, 20], [15, 15], [10, 10], [5, 5], [2, 2]];
function getDateInterval(approxInterval, daysInMonth) {
approxInterval /= ONE_DAY;
return approxInterval > 16
? 16 // Math.floor(daysInMonth / 2) + 1 // In this case we only want one tick betwen two month.
: approxInterval > 7.5
? 7 // TODO week 7 or day 8?
: approxInterval > 3.5
? 4
: approxInterval > 1.5
? 2
: 1;
}
function getMonthInterval(approxInterval) {
var APPROX_ONE_MONTH = 30 * ONE_DAY;
approxInterval /= APPROX_ONE_MONTH;
return approxInterval > 6
? 6
: approxInterval > 3
? 3
: approxInterval > 2
? 2
: 1;
}
function getHourInterval(approxInterval) {
approxInterval /= ONE_HOUR;
return approxInterval > 12
? 12
: approxInterval > 6
? 6
: approxInterval > 3.5
? 4
: approxInterval > 2
? 2
: 1;
}
function getMinutesAndSecondsInterval(approxInterval, isMinutes) {
approxInterval /= isMinutes ? ONE_MINUTE : ONE_SECOND;
return approxInterval > 30
? 30
: approxInterval > 20
? 20
: approxInterval > 15
? 15
: approxInterval > 10
? 10
: approxInterval > 5
? 5
: approxInterval > 2
? 2
: 1;
}
function getMillisecondsInterval(approxInterval) {
return nice(approxInterval, true);
}
function getFirstTimestampOfUnit(date, unitName, isUTC) {
var outDate = new Date(date);
switch (getPrimaryTimeUnit(unitName)) {
case "year":
case "month":
outDate[monthSetterName(isUTC)](0);
case "day":
outDate[dateSetterName(isUTC)](1);
case "hour":
outDate[hoursSetterName(isUTC)](0);
case "minute":
outDate[minutesSetterName(isUTC)](0);
case "second":
outDate[secondsSetterName(isUTC)](0);
outDate[millisecondsSetterName(isUTC)](0);
}
return outDate.getTime();
}
function getIntervalTicks(bottomUnitName, approxInterval, isUTC, extent) {
var safeLimit = 10000;
var unitNames = timeUnits;
var iter = 0;
function addTicksInSpan(
interval,
minTimestamp,
maxTimestamp,
getMethodName,
setMethodName,
isDate,
out,
) {
var date = new Date(minTimestamp);
var dateTime = minTimestamp;
var d = date[getMethodName](); // if (isDate) {
// d -= 1; // Starts with 0; PENDING
// }
while (dateTime < maxTimestamp && dateTime <= extent[1]) {
out.push({
value: dateTime,
});
d += interval;
date[setMethodName](d);
dateTime = date.getTime();
} // This extra tick is for calcuating ticks of next level. Will not been added to the final result
out.push({
value: dateTime,
notAdd: true,
});
}
function addLevelTicks(unitName, lastLevelTicks, levelTicks) {
var newAddedTicks = [];
var isFirstLevel = !lastLevelTicks.length;
if (
isUnitValueSame(
getPrimaryTimeUnit(unitName),
extent[0],
extent[1],
isUTC,
)
) {
return;
}
if (isFirstLevel) {
lastLevelTicks = [
{
// TODO Optimize. Not include so may ticks.
value: getFirstTimestampOfUnit(
new Date(extent[0]),
unitName,
isUTC,
),
},
{
value: extent[1],
},
];
}
for (var i = 0; i < lastLevelTicks.length - 1; i++) {
var startTick = lastLevelTicks[i].value;
var endTick = lastLevelTicks[i + 1].value;
if (startTick === endTick) {
continue;
}
var interval = void 0;
var getterName = void 0;
var setterName = void 0;
var isDate = false;
switch (unitName) {
case "year":
interval = Math.max(1, Math.round(approxInterval / ONE_DAY / 365));
getterName = fullYearGetterName(isUTC);
setterName = fullYearSetterName(isUTC);
break;
case "half-year":
case "quarter":
case "month":
interval = getMonthInterval(approxInterval);
getterName = monthGetterName(isUTC);
setterName = monthSetterName(isUTC);
break;
case "week": // PENDING If week is added. Ignore day.
case "half-week":
case "day":
interval = getDateInterval(approxInterval); // Use 32 days and let interval been 16
getterName = dateGetterName(isUTC);
setterName = dateSetterName(isUTC);
isDate = true;
break;
case "half-day":
case "quarter-day":
case "hour":
interval = getHourInterval(approxInterval);
getterName = hoursGetterName(isUTC);
setterName = hoursSetterName(isUTC);
break;
case "minute":
interval = getMinutesAndSecondsInterval(approxInterval, true);
getterName = minutesGetterName(isUTC);
setterName = minutesSetterName(isUTC);
break;
case "second":
interval = getMinutesAndSecondsInterval(approxInterval, false);
getterName = secondsGetterName(isUTC);
setterName = secondsSetterName(isUTC);
break;
case "millisecond":
interval = getMillisecondsInterval(approxInterval);
getterName = millisecondsGetterName(isUTC);
setterName = millisecondsSetterName(isUTC);
break;
}
addTicksInSpan(
interval,
startTick,
endTick,
getterName,
setterName,
isDate,
newAddedTicks,
);
if (unitName === "year" && levelTicks.length > 1 && i === 0) {
// Add nearest years to the left extent.
levelTicks.unshift({
value: levelTicks[0].value - interval,
});
}
}
for (var i = 0; i < newAddedTicks.length; i++) {
levelTicks.push(newAddedTicks[i]);
} // newAddedTicks.length && console.log(unitName, newAddedTicks);
return newAddedTicks;
}
var levelsTicks = [];
var currentLevelTicks = [];
var tickCount = 0;
var lastLevelTickCount = 0;
for (var i = 0; i < unitNames.length && iter++ < safeLimit; ++i) {
var primaryTimeUnit = getPrimaryTimeUnit(unitNames[i]);
if (!isPrimaryTimeUnit(unitNames[i])) {
// TODO
continue;
}
addLevelTicks(
unitNames[i],
levelsTicks[levelsTicks.length - 1] || [],
currentLevelTicks,
);
var nextPrimaryTimeUnit = unitNames[i + 1]
? getPrimaryTimeUnit(unitNames[i + 1])
: null;
if (primaryTimeUnit !== nextPrimaryTimeUnit) {
if (currentLevelTicks.length) {
lastLevelTickCount = tickCount; // Remove the duplicate so the tick count can be precisely.
currentLevelTicks.sort(function (a, b) {
return a.value - b.value;
});
var levelTicksRemoveDuplicated = [];
for (var i_1 = 0; i_1 < currentLevelTicks.length; ++i_1) {
var tickValue = currentLevelTicks[i_1].value;
if (i_1 === 0 || currentLevelTicks[i_1 - 1].value !== tickValue) {
levelTicksRemoveDuplicated.push(currentLevelTicks[i_1]);
if (tickValue >= extent[0] && tickValue <= extent[1]) {
tickCount++;
}
}
}
var targetTickNum = (extent[1] - extent[0]) / approxInterval; // Added too much in this level and not too less in last level
if (
tickCount > targetTickNum * 1.5 &&
lastLevelTickCount > targetTickNum / 1.5
) {
break;
} // Only treat primary time unit as one level.
levelsTicks.push(levelTicksRemoveDuplicated);
if (tickCount > targetTickNum || bottomUnitName === unitNames[i]) {
break;
}
} // Reset if next unitName is primary
currentLevelTicks = [];
}
}
if ("development" !== "production") {
if (iter >= safeLimit) {
warn("Exceed safe limit.");
}
}
var levelsTicksInExtent = filter(
map(levelsTicks, function (levelTicks) {
return filter(levelTicks, function (tick) {
return (
tick.value >= extent[0] && tick.value <= extent[1] && !tick.notAdd
);
});
}),
function (levelTicks) {
return levelTicks.length > 0;
},
);
var ticks = [];
var maxLevel = levelsTicksInExtent.length - 1;
for (var i = 0; i < levelsTicksInExtent.length; ++i) {
var levelTicks = levelsTicksInExtent[i];
for (var k = 0; k < levelTicks.length; ++k) {
ticks.push({
value: levelTicks[k].value,
level: maxLevel - i,
});
}
}
ticks.sort(function (a, b) {
return a.value - b.value;
}); // Remove duplicates
var result = [];
for (var i = 0; i < ticks.length; ++i) {
if (i === 0 || ticks[i].value !== ticks[i - 1].value) {
result.push(ticks[i]);
}
}
return result;
}
Scale.registerClass(TimeScale);
var scaleProto = Scale.prototype; // FIXME:TS refactor: not good to call it directly with `this`?
var intervalScaleProto = IntervalScale.prototype;
var roundingErrorFix = round;
var mathFloor = Math.floor;
var mathCeil = Math.ceil;
var mathPow$1 = Math.pow;
var mathLog = Math.log;
var LogScale =
/** @class */
(function (_super) {
__extends(LogScale, _super);
function LogScale() {
var _this = (_super !== null && _super.apply(this, arguments)) || this;
_this.type = "log";
_this.base = 10;
_this._originalScale = new IntervalScale(); // FIXME:TS actually used by `IntervalScale`
_this._interval = 0;
return _this;
}
/**
* @param Whether expand the ticks to niced extent.
*/
LogScale.prototype.getTicks = function (expandToNicedExtent) {
var originalScale = this._originalScale;
var extent = this._extent;
var originalExtent = originalScale.getExtent();
var ticks = intervalScaleProto.getTicks.call(this, expandToNicedExtent);
return map(
ticks,
function (tick) {
var val = tick.value;
var powVal = round(mathPow$1(this.base, val)); // Fix #4158
powVal =
val === extent[0] && this._fixMin
? fixRoundingError(powVal, originalExtent[0])
: powVal;
powVal =
val === extent[1] && this._fixMax
? fixRoundingError(powVal, originalExtent[1])
: powVal;
return {
value: powVal,
};
},
this,
);
};
LogScale.prototype.setExtent = function (start, end) {
var base = this.base;
start = mathLog(start) / mathLog(base);
end = mathLog(end) / mathLog(base);
intervalScaleProto.setExtent.call(this, start, end);
};
/**
* @return {number} end
*/
LogScale.prototype.getExtent = function () {
var base = this.base;
var extent = scaleProto.getExtent.call(this);
extent[0] = mathPow$1(base, extent[0]);
extent[1] = mathPow$1(base, extent[1]); // Fix #4158
var originalScale = this._originalScale;
var originalExtent = originalScale.getExtent();
this._fixMin &&
(extent[0] = fixRoundingError(extent[0], originalExtent[0]));
this._fixMax &&
(extent[1] = fixRoundingError(extent[1], originalExtent[1]));
return extent;
};
LogScale.prototype.unionExtent = function (extent) {
this._originalScale.unionExtent(extent);
var base = this.base;
extent[0] = mathLog(extent[0]) / mathLog(base);
extent[1] = mathLog(extent[1]) / mathLog(base);
scaleProto.unionExtent.call(this, extent);
};
LogScale.prototype.unionExtentFromData = function (data, dim) {
// TODO
// filter value that <= 0
this.unionExtent(data.getApproximateExtent(dim));
};
/**
* Update interval and extent of intervals for nice ticks
* @param approxTickNum default 10 Given approx tick number
*/
LogScale.prototype.calcNiceTicks = function (approxTickNum) {
approxTickNum = approxTickNum || 10;
var extent = this._extent;
var span = extent[1] - extent[0];
if (span === Infinity || span <= 0) {
return;
}
var interval = quantity(span);
var err = (approxTickNum / span) * interval; // Filter ticks to get closer to the desired count.
if (err <= 0.5) {
interval *= 10;
} // Interval should be integer
while (
!isNaN(interval) &&
Math.abs(interval) < 1 &&
Math.abs(interval) > 0
) {
interval *= 10;
}
var niceExtent = [
round(mathCeil(extent[0] / interval) * interval),
round(mathFloor(extent[1] / interval) * interval),
];
this._interval = interval;
this._niceExtent = niceExtent;
};
LogScale.prototype.calcNiceExtent = function (opt) {
intervalScaleProto.calcNiceExtent.call(this, opt);
this._fixMin = opt.fixMin;
this._fixMax = opt.fixMax;
};
LogScale.prototype.parse = function (val) {
return val;
};
LogScale.prototype.contain = function (val) {
val = mathLog(val) / mathLog(this.base);
return contain$1(val, this._extent);
};
LogScale.prototype.normalize = function (val) {
val = mathLog(val) / mathLog(this.base);
return normalize$1(val, this._extent);
};
LogScale.prototype.scale = function (val) {
val = scale$2(val, this._extent);
return mathPow$1(this.base, val);
};
LogScale.type = "log";
return LogScale;
})(Scale);
var proto = LogScale.prototype;
proto.getMinorTicks = intervalScaleProto.getMinorTicks;
proto.getLabel = intervalScaleProto.getLabel;
function fixRoundingError(val, originalVal) {
return roundingErrorFix(val, getPrecision(originalVal));
}
Scale.registerClass(LogScale);
var ScaleRawExtentInfo =
/** @class */
(function () {
function ScaleRawExtentInfo(
scale,
model, // Usually: data extent from all series on this axis.
originalExtent,
) {
this._prepareParams(scale, model, originalExtent);
}
/**
* Parameters depending on ouside (like model, user callback)
* are prepared and fixed here.
*/
ScaleRawExtentInfo.prototype._prepareParams = function (
scale,
model, // Usually: data extent from all series on this axis.
dataExtent,
) {
if (dataExtent[1] < dataExtent[0]) {
dataExtent = [NaN, NaN];
}
this._dataMin = dataExtent[0];
this._dataMax = dataExtent[1];
var isOrdinal = (this._isOrdinal = scale.type === "ordinal");
this._needCrossZero =
scale.type === "interval" &&
model.getNeedCrossZero &&
model.getNeedCrossZero();
var modelMinRaw = (this._modelMinRaw = model.get("min", true));
if (isFunction(modelMinRaw)) {
// This callback alway provide users the full data extent (before data filtered).
this._modelMinNum = parseAxisModelMinMax(
scale,
modelMinRaw({
min: dataExtent[0],
max: dataExtent[1],
}),
);
} else if (modelMinRaw !== "dataMin") {
this._modelMinNum = parseAxisModelMinMax(scale, modelMinRaw);
}
var modelMaxRaw = (this._modelMaxRaw = model.get("max", true));
if (isFunction(modelMaxRaw)) {
// This callback alway provide users the full data extent (before data filtered).
this._modelMaxNum = parseAxisModelMinMax(
scale,
modelMaxRaw({
min: dataExtent[0],
max: dataExtent[1],
}),
);
} else if (modelMaxRaw !== "dataMax") {
this._modelMaxNum = parseAxisModelMinMax(scale, modelMaxRaw);
}
if (isOrdinal) {
// FIXME: there is a flaw here: if there is no "block" data processor like `dataZoom`,
// and progressive rendering is using, here the category result might just only contain
// the processed chunk rather than the entire result.
this._axisDataLen = model.getCategories().length;
} else {
var boundaryGap = model.get("boundaryGap");
var boundaryGapArr = isArray(boundaryGap)
? boundaryGap
: [boundaryGap || 0, boundaryGap || 0];
if (
typeof boundaryGapArr[0] === "boolean" ||
typeof boundaryGapArr[1] === "boolean"
) {
if ("development" !== "production") {
console.warn(
"Boolean type for boundaryGap is only " +
"allowed for ordinal axis. Please use string in " +
'percentage instead, e.g., "20%". Currently, ' +
"boundaryGap is set to be 0.",
);
}
this._boundaryGapInner = [0, 0];
} else {
this._boundaryGapInner = [
parsePercent(boundaryGapArr[0], 1),
parsePercent(boundaryGapArr[1], 1),
];
}
}
};
/**
* Calculate extent by prepared parameters.
* This method has no external dependency and can be called duplicatedly,
* getting the same result.
* If parameters changed, should call this method to recalcuate.
*/
ScaleRawExtentInfo.prototype.calculate = function () {
// Notice: When min/max is not set (that is, when there are null/undefined,
// which is the most common case), these cases should be ensured:
// (1) For 'ordinal', show all axis.data.
// (2) For others:
// + `boundaryGap` is applied (if min/max set, boundaryGap is
// disabled).
// + If `needCrossZero`, min/max should be zero, otherwise, min/max should
// be the result that originalExtent enlarged by boundaryGap.
// (3) If no data, it should be ensured that `scale.setBlank` is set.
var isOrdinal = this._isOrdinal;
var dataMin = this._dataMin;
var dataMax = this._dataMax;
var axisDataLen = this._axisDataLen;
var boundaryGapInner = this._boundaryGapInner;
var span = !isOrdinal ? dataMax - dataMin || Math.abs(dataMin) : null; // Currently if a `'value'` axis model min is specified as 'dataMin'/'dataMax',
// `boundaryGap` will not be used. It's the different from specifying as `null`/`undefined`.
var min = this._modelMinRaw === "dataMin" ? dataMin : this._modelMinNum;
var max = this._modelMaxRaw === "dataMax" ? dataMax : this._modelMaxNum; // If `_modelMinNum`/`_modelMaxNum` is `null`/`undefined`, should not be fixed.
var minFixed = min != null;
var maxFixed = max != null;
if (min == null) {
min = isOrdinal
? axisDataLen
? 0
: NaN
: dataMin - boundaryGapInner[0] * span;
}
if (max == null) {
max = isOrdinal
? axisDataLen
? axisDataLen - 1
: NaN
: dataMax + boundaryGapInner[1] * span;
}
(min == null || !isFinite(min)) && (min = NaN);
(max == null || !isFinite(max)) && (max = NaN);
var isBlank = eqNaN(min) || eqNaN(max) || (isOrdinal && !axisDataLen); // If data extent modified, need to recalculated to ensure cross zero.
if (this._needCrossZero) {
// Axis is over zero and min is not set
if (min > 0 && max > 0 && !minFixed) {
min = 0; // minFixed = true;
} // Axis is under zero and max is not set
if (min < 0 && max < 0 && !maxFixed) {
max = 0; // maxFixed = true;
} // PENDING:
// When `needCrossZero` and all data is positive/negative, should it be ensured
// that the results processed by boundaryGap are positive/negative?
// If so, here `minFixed`/`maxFixed` need to be set.
}
var determinedMin = this._determinedMin;
var determinedMax = this._determinedMax;
if (determinedMin != null) {
min = determinedMin;
minFixed = true;
}
if (determinedMax != null) {
max = determinedMax;
maxFixed = true;
} // Ensure min/max be finite number or NaN here. (not to be null/undefined)
// `NaN` means min/max axis is blank.
return {
min: min,
max: max,
minFixed: minFixed,
maxFixed: maxFixed,
isBlank: isBlank,
};
};
ScaleRawExtentInfo.prototype.modifyDataMinMax = function (
minMaxName,
val,
) {
if ("development" !== "production") {
assert(!this.frozen);
}
this[DATA_MIN_MAX_ATTR[minMaxName]] = val;
};
ScaleRawExtentInfo.prototype.setDeterminedMinMax = function (
minMaxName,
val,
) {
var attr = DETERMINED_MIN_MAX_ATTR[minMaxName];
if ("development" !== "production") {
assert(
!this.frozen && // Earse them usually means logic flaw.
this[attr] == null,
);
}
this[attr] = val;
};
ScaleRawExtentInfo.prototype.freeze = function () {
// @ts-ignore
this.frozen = true;
};
return ScaleRawExtentInfo;
})();
var DETERMINED_MIN_MAX_ATTR = {
min: "_determinedMin",
max: "_determinedMax",
};
var DATA_MIN_MAX_ATTR = {
min: "_dataMin",
max: "_dataMax",
};
/**
* Get scale min max and related info only depends on model settings.
* This method can be called after coordinate system created.
* For example, in data processing stage.
*
* Scale extent info probably be required multiple times during a workflow.
* For example:
* (1) `dataZoom` depends it to get the axis extent in "100%" state.
* (2) `processor/extentCalculator` depends it to make sure whether axis extent is specified.
* (3) `coordSys.update` use it to finally decide the scale extent.
* But the callback of `min`/`max` should not be called multiple times.
* The code below should not be implemented repeatedly either.
* So we cache the result in the scale instance, which will be recreated at the begining
* of the workflow (because `scale` instance will be recreated each round of the workflow).
*/
function ensureScaleRawExtentInfo(
scale,
model, // Usually: data extent from all series on this axis.
originalExtent,
) {
// Do not permit to recreate.
var rawExtentInfo = scale.rawExtentInfo;
if (rawExtentInfo) {
return rawExtentInfo;
}
rawExtentInfo = new ScaleRawExtentInfo(scale, model, originalExtent); // @ts-ignore
scale.rawExtentInfo = rawExtentInfo;
return rawExtentInfo;
}
function parseAxisModelMinMax(scale, minMax) {
return minMax == null ? null : eqNaN(minMax) ? NaN : scale.parse(minMax);
}
/**
* Get axis scale extent before niced.
* Item of returned array can only be number (including Infinity and NaN).
*
* Caution:
* Precondition of calling this method:
* The scale extent has been initialized using series data extent via
* `scale.setExtent` or `scale.unionExtentFromData`;
*/
function getScaleExtent(scale, model) {
var scaleType = scale.type;
var rawExtentResult = ensureScaleRawExtentInfo(
scale,
model,
scale.getExtent(),
).calculate();
scale.setBlank(rawExtentResult.isBlank);
var min = rawExtentResult.min;
var max = rawExtentResult.max; // If bars are placed on a base axis of type time or interval account for axis boundary overflow and current axis
// is base axis
// FIXME
// (1) Consider support value axis, where below zero and axis `onZero` should be handled properly.
// (2) Refactor the logic with `barGrid`. Is it not need to `makeBarWidthAndOffsetInfo` twice with different extent?
// Should not depend on series type `bar`?
// (3) Fix that might overlap when using dataZoom.
// (4) Consider other chart types using `barGrid`?
// See #6728, #4862, `test/bar-overflow-time-plot.html`
var ecModel = model.ecModel;
if (
ecModel &&
scaleType === "time"
/*|| scaleType === 'interval' */
) {
var barSeriesModels = prepareLayoutBarSeries("bar", ecModel);
var isBaseAxisAndHasBarSeries_1 = false;
each(barSeriesModels, function (seriesModel) {
isBaseAxisAndHasBarSeries_1 =
isBaseAxisAndHasBarSeries_1 ||
seriesModel.getBaseAxis() === model.axis;
});
if (isBaseAxisAndHasBarSeries_1) {
// Calculate placement of bars on axis. TODO should be decoupled
// with barLayout
var barWidthAndOffset = makeColumnLayout(barSeriesModels); // Adjust axis min and max to account for overflow
var adjustedScale = adjustScaleForOverflow(
min,
max,
model,
barWidthAndOffset,
);
min = adjustedScale.min;
max = adjustedScale.max;
}
}
return {
extent: [min, max],
// "fix" means "fixed", the value should not be
// changed in the subsequent steps.
fixMin: rawExtentResult.minFixed,
fixMax: rawExtentResult.maxFixed,
};
}
function adjustScaleForOverflow(
min,
max,
model, // Only support cartesian coord yet.
barWidthAndOffset,
) {
// Get Axis Length
var axisExtent = model.axis.getExtent();
var axisLength = axisExtent[1] - axisExtent[0]; // Get bars on current base axis and calculate min and max overflow
var barsOnCurrentAxis = retrieveColumnLayout(barWidthAndOffset, model.axis);
if (barsOnCurrentAxis === undefined) {
return {
min: min,
max: max,
};
}
var minOverflow = Infinity;
each(barsOnCurrentAxis, function (item) {
minOverflow = Math.min(item.offset, minOverflow);
});
var maxOverflow = -Infinity;
each(barsOnCurrentAxis, function (item) {
maxOverflow = Math.max(item.offset + item.width, maxOverflow);
});
minOverflow = Math.abs(minOverflow);
maxOverflow = Math.abs(maxOverflow);
var totalOverFlow = minOverflow + maxOverflow; // Calculate required buffer based on old range and overflow
var oldRange = max - min;
var oldRangePercentOfNew = 1 - (minOverflow + maxOverflow) / axisLength;
var overflowBuffer = oldRange / oldRangePercentOfNew - oldRange;
max += overflowBuffer * (maxOverflow / totalOverFlow);
min -= overflowBuffer * (minOverflow / totalOverFlow);
return {
min: min,
max: max,
};
} // Precondition of calling this method:
// The scale extent has been initailized using series data extent via
// `scale.setExtent` or `scale.unionExtentFromData`;
function niceScaleExtent(scale, inModel) {
var model = inModel;
var extentInfo = getScaleExtent(scale, model);
var extent = extentInfo.extent;
var splitNumber = model.get("splitNumber");
if (scale instanceof LogScale) {
scale.base = model.get("logBase");
}
var scaleType = scale.type;
var interval = model.get("interval");
var isIntervalOrTime = scaleType === "interval" || scaleType === "time";
scale.setExtent(extent[0], extent[1]);
scale.calcNiceExtent({
splitNumber: splitNumber,
fixMin: extentInfo.fixMin,
fixMax: extentInfo.fixMax,
minInterval: isIntervalOrTime ? model.get("minInterval") : null,
maxInterval: isIntervalOrTime ? model.get("maxInterval") : null,
}); // If some one specified the min, max. And the default calculated interval
// is not good enough. He can specify the interval. It is often appeared
// in angle axis with angle 0 - 360. Interval calculated in interval scale is hard
// to be 60.
// FIXME
if (interval != null) {
scale.setInterval && scale.setInterval(interval);
}
}
/**
* @param axisType Default retrieve from model.type
*/
function createScaleByModel(model, axisType) {
axisType = axisType || model.get("type");
if (axisType) {
switch (axisType) {
// Buildin scale
case "category":
return new OrdinalScale({
ordinalMeta: model.getOrdinalMeta
? model.getOrdinalMeta()
: model.getCategories(),
extent: [Infinity, -Infinity],
});
case "time":
return new TimeScale({
locale: model.ecModel.getLocaleModel(),
useUTC: model.ecModel.get("useUTC"),
});
default:
// case 'value'/'interval', 'log', or others.
return new (Scale.getClass(axisType) || IntervalScale)();
}
}
}
/**
* Check if the axis cross 0
*/
function ifAxisCrossZero(axis) {
var dataExtent = axis.scale.getExtent();
var min = dataExtent[0];
var max = dataExtent[1];
return !((min > 0 && max > 0) || (min < 0 && max < 0));
}
/**
* @param axis
* @return Label formatter function.
* param: {number} tickValue,
* param: {number} idx, the index in all ticks.
* If category axis, this param is not required.
* return: {string} label string.
*/
function makeLabelFormatter(axis) {
var labelFormatter = axis.getLabelModel().get("formatter");
var categoryTickStart =
axis.type === "category" ? axis.scale.getExtent()[0] : null;
if (axis.scale.type === "time") {
return (function (tpl) {
return function (tick, idx) {
return axis.scale.getFormattedLabel(tick, idx, tpl);
};
})(labelFormatter);
} else if (isString(labelFormatter)) {
return (function (tpl) {
return function (tick) {
// For category axis, get raw value; for numeric axis,
// get formatted label like '1,333,444'.
var label = axis.scale.getLabel(tick);
var text = tpl.replace("{value}", label != null ? label : "");
return text;
};
})(labelFormatter);
} else if (isFunction(labelFormatter)) {
return (function (cb) {
return function (tick, idx) {
// The original intention of `idx` is "the index of the tick in all ticks".
// But the previous implementation of category axis do not consider the
// `axisLabel.interval`, which cause that, for example, the `interval` is
// `1`, then the ticks "name5", "name7", "name9" are displayed, where the
// corresponding `idx` are `0`, `2`, `4`, but not `0`, `1`, `2`. So we keep
// the definition here for back compatibility.
if (categoryTickStart != null) {
idx = tick.value - categoryTickStart;
}
return cb(
getAxisRawValue(axis, tick),
idx,
tick.level != null
? {
level: tick.level,
}
: null,
);
};
})(labelFormatter);
} else {
return function (tick) {
return axis.scale.getLabel(tick);
};
}
}
function getAxisRawValue(axis, tick) {
// In category axis with data zoom, tick is not the original
// index of axis.data. So tick should not be exposed to user
// in category axis.
return axis.type === "category" ? axis.scale.getLabel(tick) : tick.value;
}
/**
* @param axis
* @return Be null/undefined if no labels.
*/
function estimateLabelUnionRect(axis) {
var axisModel = axis.model;
var scale = axis.scale;
if (!axisModel.get(["axisLabel", "show"]) || scale.isBlank()) {
return;
}
var realNumberScaleTicks;
var tickCount;
var categoryScaleExtent = scale.getExtent(); // Optimize for large category data, avoid call `getTicks()`.
if (scale instanceof OrdinalScale) {
tickCount = scale.count();
} else {
realNumberScaleTicks = scale.getTicks();
tickCount = realNumberScaleTicks.length;
}
var axisLabelModel = axis.getLabelModel();
var labelFormatter = makeLabelFormatter(axis);
var rect;
var step = 1; // Simple optimization for large amount of labels
if (tickCount > 40) {
step = Math.ceil(tickCount / 40);
}
for (var i = 0; i < tickCount; i += step) {
var tick = realNumberScaleTicks
? realNumberScaleTicks[i]
: {
value: categoryScaleExtent[0] + i,
};
var label = labelFormatter(tick, i);
var unrotatedSingleRect = axisLabelModel.getTextRect(label);
var singleRect = rotateTextRect(
unrotatedSingleRect,
axisLabelModel.get("rotate") || 0,
);
rect ? rect.union(singleRect) : (rect = singleRect);
}
return rect;
}
function rotateTextRect(textRect, rotate) {
var rotateRadians = (rotate * Math.PI) / 180;
var beforeWidth = textRect.width;
var beforeHeight = textRect.height;
var afterWidth =
beforeWidth * Math.abs(Math.cos(rotateRadians)) +
Math.abs(beforeHeight * Math.sin(rotateRadians));
var afterHeight =
beforeWidth * Math.abs(Math.sin(rotateRadians)) +
Math.abs(beforeHeight * Math.cos(rotateRadians));
var rotatedRect = new BoundingRect(
textRect.x,
textRect.y,
afterWidth,
afterHeight,
);
return rotatedRect;
}
/**
* @param model axisLabelModel or axisTickModel
* @return {number|String} Can be null|'auto'|number|function
*/
function getOptionCategoryInterval(model) {
var interval = model.get("interval");
return interval == null ? "auto" : interval;
}
/**
* Set `categoryInterval` as 0 implicitly indicates that
* show all labels reguardless of overlap.
* @param {Object} axis axisModel.axis
*/
function shouldShowAllLabels(axis) {
return (
axis.type === "category" &&
getOptionCategoryInterval(axis.getLabelModel()) === 0
);
}
function getDataDimensionsOnAxis(data, axisDim) {
// Remove duplicated dat dimensions caused by `getStackedDimension`.
var dataDimMap = {}; // Currently `mapDimensionsAll` will contain stack result dimension ('__\0ecstackresult').
// PENDING: is it reasonable? Do we need to remove the original dim from "coord dim" since
// there has been stacked result dim?
each(data.mapDimensionsAll(axisDim), function (dataDim) {
// For example, the extent of the original dimension
// is [0.1, 0.5], the extent of the `stackResultDimension`
// is [7, 9], the final extent should NOT include [0.1, 0.5],
// because there is no graphic corresponding to [0.1, 0.5].
// See the case in `test/area-stack.html` `main1`, where area line
// stack needs `yAxis` not start from 0.
dataDimMap[getStackedDimension(data, dataDim)] = true;
});
return keys(dataDimMap);
}
function unionAxisExtentFromData(dataExtent, data, axisDim) {
if (data) {
each(getDataDimensionsOnAxis(data, axisDim), function (dim) {
var seriesExtent = data.getApproximateExtent(dim);
seriesExtent[0] < dataExtent[0] && (dataExtent[0] = seriesExtent[0]);
seriesExtent[1] > dataExtent[1] && (dataExtent[1] = seriesExtent[1]);
});
}
}
/*
* 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.
*/
// eslint-disable-next-line @typescript-eslint/no-unused-vars
var AxisModelCommonMixin =
/** @class */
(function () {
function AxisModelCommonMixin() {}
AxisModelCommonMixin.prototype.getNeedCrossZero = function () {
var option = this.option;
return !option.scale;
};
/**
* Should be implemented by each axis model if necessary.
* @return coordinate system model
*/
AxisModelCommonMixin.prototype.getCoordSysModel = function () {
return;
};
return AxisModelCommonMixin;
})();
/**
* Create a muti dimension List structure from seriesModel.
*/
function createList(seriesModel) {
return createSeriesData(null, seriesModel);
} // export function createGraph(seriesModel) {
var dataStack$1 = {
isDimensionStacked: isDimensionStacked,
enableDataStack: enableDataStack,
getStackedDimension: getStackedDimension,
};
/**
* Create scale
* @param {Array.} dataExtent
* @param {Object|module:echarts/Model} option If `optoin.type`
* is secified, it can only be `'value'` currently.
*/
function createScale(dataExtent, option) {
var axisModel = option;
if (!(option instanceof Model)) {
axisModel = new Model(option); // FIXME
// Currently AxisModelCommonMixin has nothing to do with the
// the requirements of `axisHelper.createScaleByModel`. For
// example the method `getCategories` and `getOrdinalMeta`
// are required for `'category'` axis, and ecModel are required
// for `'time'` axis. But occationally echarts-gl happened
// to only use `'value'` axis.
// zrUtil.mixin(axisModel, AxisModelCommonMixin);
}
var scale = createScaleByModel(axisModel);
scale.setExtent(dataExtent[0], dataExtent[1]);
niceScaleExtent(scale, axisModel);
return scale;
}
/**
* Mixin common methods to axis model,
*
* Inlcude methods
* `getFormattedLabels() => Array.`
* `getCategories() => Array.`
* `getMin(origin: boolean) => number`
* `getMax(origin: boolean) => number`
* `getNeedCrossZero() => boolean`
*/
function mixinAxisModelCommonMethods(Model) {
mixin(Model, AxisModelCommonMixin);
}
function createTextStyle$1(textStyleModel, opts) {
opts = opts || {};
return createTextStyle(textStyleModel, null, null, opts.state !== "normal");
}
var helper = /*#__PURE__*/ Object.freeze({
__proto__: null,
createList: createList,
getLayoutRect: getLayoutRect,
dataStack: dataStack$1,
createScale: createScale,
mixinAxisModelCommonMethods: mixinAxisModelCommonMethods,
getECData: getECData,
createTextStyle: createTextStyle$1,
createDimensions: createDimensions,
createSymbol: createSymbol,
enableHoverEmphasis: enableHoverEmphasis,
});
var EPSILON$4 = 1e-8;
function isAroundEqual$1(a, b) {
return Math.abs(a - b) < EPSILON$4;
}
function contain$2(points, x, y) {
var w = 0;
var p = points[0];
if (!p) {
return false;
}
for (var i = 1; i < points.length; i++) {
var p2 = points[i];
w += windingLine(p[0], p[1], p2[0], p2[1], x, y);
p = p2;
}
var p0 = points[0];
if (!isAroundEqual$1(p[0], p0[0]) || !isAroundEqual$1(p[1], p0[1])) {
w += windingLine(p[0], p[1], p0[0], p0[1], x, y);
}
return w !== 0;
}
var TMP_TRANSFORM = [];
function transformPoints(points, transform) {
for (var p = 0; p < points.length; p++) {
applyTransform(points[p], points[p], transform);
}
}
function updateBBoxFromPoints(points, min$1, max$1, projection) {
for (var i = 0; i < points.length; i++) {
var p = points[i];
if (projection) {
// projection may return null point.
p = projection.project(p);
}
if (p && isFinite(p[0]) && isFinite(p[1])) {
min(min$1, min$1, p);
max(max$1, max$1, p);
}
}
}
function centroid(points) {
var signedArea = 0;
var cx = 0;
var cy = 0;
var len = points.length;
var x0 = points[len - 1][0];
var y0 = points[len - 1][1]; // Polygon should been closed.
for (var i = 0; i < len; i++) {
var x1 = points[i][0];
var y1 = points[i][1];
var a = x0 * y1 - x1 * y0;
signedArea += a;
cx += (x0 + x1) * a;
cy += (y0 + y1) * a;
x0 = x1;
y0 = y1;
}
return signedArea
? [cx / signedArea / 3, cy / signedArea / 3, signedArea]
: [points[0][0] || 0, points[0][1] || 0];
}
var Region =
/** @class */
(function () {
function Region(name) {
this.name = name;
}
Region.prototype.setCenter = function (center) {
this._center = center;
};
/**
* Get center point in data unit. That is,
* for GeoJSONRegion, the unit is lat/lng,
* for GeoSVGRegion, the unit is SVG local coord.
*/
Region.prototype.getCenter = function () {
var center = this._center;
if (!center) {
// In most cases there are no need to calculate this center.
// So calculate only when called.
center = this._center = this.calcCenter();
}
return center;
};
return Region;
})();
var GeoJSONPolygonGeometry =
/** @class */
(function () {
function GeoJSONPolygonGeometry(exterior, interiors) {
this.type = "polygon";
this.exterior = exterior;
this.interiors = interiors;
}
return GeoJSONPolygonGeometry;
})();
var GeoJSONLineStringGeometry =
/** @class */
(function () {
function GeoJSONLineStringGeometry(points) {
this.type = "linestring";
this.points = points;
}
return GeoJSONLineStringGeometry;
})();
var GeoJSONRegion =
/** @class */
(function (_super) {
__extends(GeoJSONRegion, _super);
function GeoJSONRegion(name, geometries, cp) {
var _this = _super.call(this, name) || this;
_this.type = "geoJSON";
_this.geometries = geometries;
_this._center = cp && [cp[0], cp[1]];
return _this;
}
GeoJSONRegion.prototype.calcCenter = function () {
var geometries = this.geometries;
var largestGeo;
var largestGeoSize = 0;
for (var i = 0; i < geometries.length; i++) {
var geo = geometries[i];
var exterior = geo.exterior; // Simple trick to use points count instead of polygon area as region size.
// Ignore linestring
var size = exterior && exterior.length;
if (size > largestGeoSize) {
largestGeo = geo;
largestGeoSize = size;
}
}
if (largestGeo) {
return centroid(largestGeo.exterior);
} // from bounding rect by default.
var rect = this.getBoundingRect();
return [rect.x + rect.width / 2, rect.y + rect.height / 2];
};
GeoJSONRegion.prototype.getBoundingRect = function (projection) {
var rect = this._rect; // Always recalculate if using projection.
if (rect && !projection) {
return rect;
}
var min = [Infinity, Infinity];
var max = [-Infinity, -Infinity];
var geometries = this.geometries;
each(geometries, function (geo) {
if (geo.type === "polygon") {
// Doesn't consider hole
updateBBoxFromPoints(geo.exterior, min, max, projection);
} else {
each(geo.points, function (points) {
updateBBoxFromPoints(points, min, max, projection);
});
}
}); // Normalie invalid bounding.
if (
!(
isFinite(min[0]) &&
isFinite(min[1]) &&
isFinite(max[0]) &&
isFinite(max[1])
)
) {
min[0] = min[1] = max[0] = max[1] = 0;
}
rect = new BoundingRect(
min[0],
min[1],
max[0] - min[0],
max[1] - min[1],
);
if (!projection) {
this._rect = rect;
}
return rect;
};
GeoJSONRegion.prototype.contain = function (coord) {
var rect = this.getBoundingRect();
var geometries = this.geometries;
if (!rect.contain(coord[0], coord[1])) {
return false;
}
loopGeo: for (var i = 0, len = geometries.length; i < len; i++) {
var geo = geometries[i]; // Only support polygon.
if (geo.type !== "polygon") {
continue;
}
var exterior = geo.exterior;
var interiors = geo.interiors;
if (contain$2(exterior, coord[0], coord[1])) {
// Not in the region if point is in the hole.
for (var k = 0; k < (interiors ? interiors.length : 0); k++) {
if (contain$2(interiors[k], coord[0], coord[1])) {
continue loopGeo;
}
}
return true;
}
}
return false;
};
/**
* Transform the raw coords to target bounding.
* @param x
* @param y
* @param width
* @param height
*/
GeoJSONRegion.prototype.transformTo = function (x, y, width, height) {
var rect = this.getBoundingRect();
var aspect = rect.width / rect.height;
if (!width) {
width = aspect * height;
} else if (!height) {
height = width / aspect;
}
var target = new BoundingRect(x, y, width, height);
var transform = rect.calculateTransform(target);
var geometries = this.geometries;
for (var i = 0; i < geometries.length; i++) {
var geo = geometries[i];
if (geo.type === "polygon") {
transformPoints(geo.exterior, transform);
each(geo.interiors, function (interior) {
transformPoints(interior, transform);
});
} else {
each(geo.points, function (points) {
transformPoints(points, transform);
});
}
}
rect = this._rect;
rect.copy(target); // Update center
this._center = [rect.x + rect.width / 2, rect.y + rect.height / 2];
};
GeoJSONRegion.prototype.cloneShallow = function (name) {
name == null && (name = this.name);
var newRegion = new GeoJSONRegion(name, this.geometries, this._center);
newRegion._rect = this._rect;
newRegion.transformTo = null; // Simply avoid to be called.
return newRegion;
};
return GeoJSONRegion;
})(Region);
var GeoSVGRegion =
/** @class */
(function (_super) {
__extends(GeoSVGRegion, _super);
function GeoSVGRegion(name, elOnlyForCalculate) {
var _this = _super.call(this, name) || this;
_this.type = "geoSVG";
_this._elOnlyForCalculate = elOnlyForCalculate;
return _this;
}
GeoSVGRegion.prototype.calcCenter = function () {
var el = this._elOnlyForCalculate;
var rect = el.getBoundingRect();
var center = [rect.x + rect.width / 2, rect.y + rect.height / 2];
var mat = identity(TMP_TRANSFORM);
var target = el;
while (target && !target.isGeoSVGGraphicRoot) {
mul$1(mat, target.getLocalTransform(), mat);
target = target.parent;
}
invert(mat, mat);
applyTransform(center, center, mat);
return center;
};
return GeoSVGRegion;
})(Region);
function decode(json) {
if (!json.UTF8Encoding) {
return json;
}
var jsonCompressed = json;
var encodeScale = jsonCompressed.UTF8Scale;
if (encodeScale == null) {
encodeScale = 1024;
}
var features = jsonCompressed.features;
each(features, function (feature) {
var geometry = feature.geometry;
var encodeOffsets = geometry.encodeOffsets;
var coordinates = geometry.coordinates; // Geometry may be appeded manually in the script after json loaded.
// In this case this geometry is usually not encoded.
if (!encodeOffsets) {
return;
}
switch (geometry.type) {
case "LineString":
geometry.coordinates = decodeRing(
coordinates,
encodeOffsets,
encodeScale,
);
break;
case "Polygon":
decodeRings(coordinates, encodeOffsets, encodeScale);
break;
case "MultiLineString":
decodeRings(coordinates, encodeOffsets, encodeScale);
break;
case "MultiPolygon":
each(coordinates, function (rings, idx) {
return decodeRings(rings, encodeOffsets[idx], encodeScale);
});
}
}); // Has been decoded
jsonCompressed.UTF8Encoding = false;
return jsonCompressed;
}
function decodeRings(rings, encodeOffsets, encodeScale) {
for (var c = 0; c < rings.length; c++) {
rings[c] = decodeRing(rings[c], encodeOffsets[c], encodeScale);
}
}
function decodeRing(coordinate, encodeOffsets, encodeScale) {
var result = [];
var prevX = encodeOffsets[0];
var prevY = encodeOffsets[1];
for (var i = 0; i < coordinate.length; i += 2) {
var x = coordinate.charCodeAt(i) - 64;
var y = coordinate.charCodeAt(i + 1) - 64; // ZigZag decoding
x = (x >> 1) ^ -(x & 1);
y = (y >> 1) ^ -(y & 1); // Delta deocding
x += prevX;
y += prevY;
prevX = x;
prevY = y; // Dequantize
result.push([x / encodeScale, y / encodeScale]);
}
return result;
}
function parseGeoJSON(geoJson, nameProperty) {
geoJson = decode(geoJson);
return map(
filter(geoJson.features, function (featureObj) {
// Output of mapshaper may have geometry null
return (
featureObj.geometry &&
featureObj.properties &&
featureObj.geometry.coordinates.length > 0
);
}),
function (featureObj) {
var properties = featureObj.properties;
var geo = featureObj.geometry;
var geometries = [];
switch (geo.type) {
case "Polygon":
var coordinates = geo.coordinates; // According to the GeoJSON specification.
// First must be exterior, and the rest are all interior(holes).
geometries.push(
new GeoJSONPolygonGeometry(coordinates[0], coordinates.slice(1)),
);
break;
case "MultiPolygon":
each(geo.coordinates, function (item) {
if (item[0]) {
geometries.push(
new GeoJSONPolygonGeometry(item[0], item.slice(1)),
);
}
});
break;
case "LineString":
geometries.push(new GeoJSONLineStringGeometry([geo.coordinates]));
break;
case "MultiLineString":
geometries.push(new GeoJSONLineStringGeometry(geo.coordinates));
}
var region = new GeoJSONRegion(
properties[nameProperty || "name"],
geometries,
properties.cp,
);
region.properties = properties;
return region;
},
);
}
var number = /*#__PURE__*/ Object.freeze({
__proto__: null,
linearMap: linearMap,
round: round,
asc: asc,
getPrecision: getPrecision,
getPrecisionSafe: getPrecisionSafe,
getPixelPrecision: getPixelPrecision,
getPercentWithPrecision: getPercentWithPrecision,
MAX_SAFE_INTEGER: MAX_SAFE_INTEGER,
remRadian: remRadian,
isRadianAroundZero: isRadianAroundZero,
parseDate: parseDate,
quantity: quantity,
quantityExponent: quantityExponent,
nice: nice,
quantile: quantile,
reformIntervals: reformIntervals,
isNumeric: isNumeric,
numericToNumber: numericToNumber,
});
var time = /*#__PURE__*/ Object.freeze({
__proto__: null,
parse: parseDate,
format: format,
});
var graphic$1 = /*#__PURE__*/ Object.freeze({
__proto__: null,
extendShape: extendShape,
extendPath: extendPath,
makePath: makePath,
makeImage: makeImage,
mergePath: mergePath$1,
resizePath: resizePath,
createIcon: createIcon,
updateProps: updateProps,
initProps: initProps,
getTransform: getTransform,
clipPointsByRect: clipPointsByRect,
clipRectByRect: clipRectByRect,
registerShape: registerShape,
getShapeClass: getShapeClass,
Group: Group,
Image: ZRImage,
Text: ZRText,
Circle: Circle,
Ellipse: Ellipse,
Sector: Sector,
Ring: Ring,
Polygon: Polygon,
Polyline: Polyline,
Rect: Rect,
Line: Line,
BezierCurve: BezierCurve,
Arc: Arc,
IncrementalDisplayable: IncrementalDisplayable,
CompoundPath: CompoundPath,
LinearGradient: LinearGradient,
RadialGradient: RadialGradient,
BoundingRect: BoundingRect,
});
var format$1 = /*#__PURE__*/ Object.freeze({
__proto__: null,
addCommas: addCommas,
toCamelCase: toCamelCase,
normalizeCssArray: normalizeCssArray$1,
encodeHTML: encodeHTML,
formatTpl: formatTpl,
getTooltipMarker: getTooltipMarker,
formatTime: formatTime,
capitalFirst: capitalFirst,
truncateText: truncateText,
getTextRect: getTextRect,
});
var util$1 = /*#__PURE__*/ Object.freeze({
__proto__: null,
map: map,
each: each,
indexOf: indexOf,
inherits: inherits,
reduce: reduce,
filter: filter,
bind: bind,
curry: curry,
isArray: isArray,
isString: isString,
isObject: isObject,
isFunction: isFunction,
extend: extend,
defaults: defaults,
clone: clone,
merge: merge,
});
var inner$5 = makeInner();
function createAxisLabels(axis) {
// Only ordinal scale support tick interval
return axis.type === "category"
? makeCategoryLabels(axis)
: makeRealNumberLabels(axis);
}
/**
* @param {module:echats/coord/Axis} axis
* @param {module:echarts/model/Model} tickModel For example, can be axisTick, splitLine, splitArea.
* @return {Object} {
* ticks: Array.
* tickCategoryInterval: number
* }
*/
function createAxisTicks(axis, tickModel) {
// Only ordinal scale support tick interval
return axis.type === "category"
? makeCategoryTicks(axis, tickModel)
: {
ticks: map(axis.scale.getTicks(), function (tick) {
return tick.value;
}),
};
}
function makeCategoryLabels(axis) {
var labelModel = axis.getLabelModel();
var result = makeCategoryLabelsActually(axis, labelModel);
return !labelModel.get("show") || axis.scale.isBlank()
? {
labels: [],
labelCategoryInterval: result.labelCategoryInterval,
}
: result;
}
function makeCategoryLabelsActually(axis, labelModel) {
var labelsCache = getListCache(axis, "labels");
var optionLabelInterval = getOptionCategoryInterval(labelModel);
var result = listCacheGet(labelsCache, optionLabelInterval);
if (result) {
return result;
}
var labels;
var numericLabelInterval;
if (isFunction(optionLabelInterval)) {
labels = makeLabelsByCustomizedCategoryInterval(
axis,
optionLabelInterval,
);
} else {
numericLabelInterval =
optionLabelInterval === "auto"
? makeAutoCategoryInterval(axis)
: optionLabelInterval;
labels = makeLabelsByNumericCategoryInterval(axis, numericLabelInterval);
} // Cache to avoid calling interval function repeatly.
return listCacheSet(labelsCache, optionLabelInterval, {
labels: labels,
labelCategoryInterval: numericLabelInterval,
});
}
function makeCategoryTicks(axis, tickModel) {
var ticksCache = getListCache(axis, "ticks");
var optionTickInterval = getOptionCategoryInterval(tickModel);
var result = listCacheGet(ticksCache, optionTickInterval);
if (result) {
return result;
}
var ticks;
var tickCategoryInterval; // Optimize for the case that large category data and no label displayed,
// we should not return all ticks.
if (!tickModel.get("show") || axis.scale.isBlank()) {
ticks = [];
}
if (isFunction(optionTickInterval)) {
ticks = makeLabelsByCustomizedCategoryInterval(
axis,
optionTickInterval,
true,
);
} // Always use label interval by default despite label show. Consider this
// scenario, Use multiple grid with the xAxis sync, and only one xAxis shows
// labels. `splitLine` and `axisTick` should be consistent in this case.
else if (optionTickInterval === "auto") {
var labelsResult = makeCategoryLabelsActually(axis, axis.getLabelModel());
tickCategoryInterval = labelsResult.labelCategoryInterval;
ticks = map(labelsResult.labels, function (labelItem) {
return labelItem.tickValue;
});
} else {
tickCategoryInterval = optionTickInterval;
ticks = makeLabelsByNumericCategoryInterval(
axis,
tickCategoryInterval,
true,
);
} // Cache to avoid calling interval function repeatly.
return listCacheSet(ticksCache, optionTickInterval, {
ticks: ticks,
tickCategoryInterval: tickCategoryInterval,
});
}
function makeRealNumberLabels(axis) {
var ticks = axis.scale.getTicks();
var labelFormatter = makeLabelFormatter(axis);
return {
labels: map(ticks, function (tick, idx) {
return {
level: tick.level,
formattedLabel: labelFormatter(tick, idx),
rawLabel: axis.scale.getLabel(tick),
tickValue: tick.value,
};
}),
};
}
function getListCache(axis, prop) {
// Because key can be funciton, and cache size always be small, we use array cache.
return inner$5(axis)[prop] || (inner$5(axis)[prop] = []);
}
function listCacheGet(cache, key) {
for (var i = 0; i < cache.length; i++) {
if (cache[i].key === key) {
return cache[i].value;
}
}
}
function listCacheSet(cache, key, value) {
cache.push({
key: key,
value: value,
});
return value;
}
function makeAutoCategoryInterval(axis) {
var result = inner$5(axis).autoInterval;
return result != null
? result
: (inner$5(axis).autoInterval = axis.calculateCategoryInterval());
}
/**
* Calculate interval for category axis ticks and labels.
* To get precise result, at least one of `getRotate` and `isHorizontal`
* should be implemented in axis.
*/
function calculateCategoryInterval(axis) {
var params = fetchAutoCategoryIntervalCalculationParams(axis);
var labelFormatter = makeLabelFormatter(axis);
var rotation = ((params.axisRotate - params.labelRotate) / 180) * Math.PI;
var ordinalScale = axis.scale;
var ordinalExtent = ordinalScale.getExtent(); // Providing this method is for optimization:
// avoid generating a long array by `getTicks`
// in large category data case.
var tickCount = ordinalScale.count();
if (ordinalExtent[1] - ordinalExtent[0] < 1) {
return 0;
}
var step = 1; // Simple optimization. Empirical value: tick count should less than 40.
if (tickCount > 40) {
step = Math.max(1, Math.floor(tickCount / 40));
}
var tickValue = ordinalExtent[0];
var unitSpan =
axis.dataToCoord(tickValue + 1) - axis.dataToCoord(tickValue);
var unitW = Math.abs(unitSpan * Math.cos(rotation));
var unitH = Math.abs(unitSpan * Math.sin(rotation));
var maxW = 0;
var maxH = 0; // Caution: Performance sensitive for large category data.
// Consider dataZoom, we should make appropriate step to avoid O(n) loop.
for (; tickValue <= ordinalExtent[1]; tickValue += step) {
var width = 0;
var height = 0; // Not precise, do not consider align and vertical align
// and each distance from axis line yet.
var rect = getBoundingRect(
labelFormatter({
value: tickValue,
}),
params.font,
"center",
"top",
); // Magic number
width = rect.width * 1.3;
height = rect.height * 1.3; // Min size, void long loop.
maxW = Math.max(maxW, width, 7);
maxH = Math.max(maxH, height, 7);
}
var dw = maxW / unitW;
var dh = maxH / unitH; // 0/0 is NaN, 1/0 is Infinity.
isNaN(dw) && (dw = Infinity);
isNaN(dh) && (dh = Infinity);
var interval = Math.max(0, Math.floor(Math.min(dw, dh)));
var cache = inner$5(axis.model);
var axisExtent = axis.getExtent();
var lastAutoInterval = cache.lastAutoInterval;
var lastTickCount = cache.lastTickCount; // Use cache to keep interval stable while moving zoom window,
// otherwise the calculated interval might jitter when the zoom
// window size is close to the interval-changing size.
// For example, if all of the axis labels are `a, b, c, d, e, f, g`.
// The jitter will cause that sometimes the displayed labels are
// `a, d, g` (interval: 2) sometimes `a, c, e`(interval: 1).
if (
lastAutoInterval != null &&
lastTickCount != null &&
Math.abs(lastAutoInterval - interval) <= 1 &&
Math.abs(lastTickCount - tickCount) <= 1 && // Always choose the bigger one, otherwise the critical
// point is not the same when zooming in or zooming out.
lastAutoInterval > interval && // If the axis change is caused by chart resize, the cache should not
// be used. Otherwise some hiden labels might not be shown again.
cache.axisExtent0 === axisExtent[0] &&
cache.axisExtent1 === axisExtent[1]
) {
interval = lastAutoInterval;
} // Only update cache if cache not used, otherwise the
// changing of interval is too insensitive.
else {
cache.lastTickCount = tickCount;
cache.lastAutoInterval = interval;
cache.axisExtent0 = axisExtent[0];
cache.axisExtent1 = axisExtent[1];
}
return interval;
}
function fetchAutoCategoryIntervalCalculationParams(axis) {
var labelModel = axis.getLabelModel();
return {
axisRotate: axis.getRotate
? axis.getRotate()
: axis.isHorizontal && !axis.isHorizontal()
? 90
: 0,
labelRotate: labelModel.get("rotate") || 0,
font: labelModel.getFont(),
};
}
function makeLabelsByNumericCategoryInterval(
axis,
categoryInterval,
onlyTick,
) {
var labelFormatter = makeLabelFormatter(axis);
var ordinalScale = axis.scale;
var ordinalExtent = ordinalScale.getExtent();
var labelModel = axis.getLabelModel();
var result = []; // TODO: axisType: ordinalTime, pick the tick from each month/day/year/...
var step = Math.max((categoryInterval || 0) + 1, 1);
var startTick = ordinalExtent[0];
var tickCount = ordinalScale.count(); // Calculate start tick based on zero if possible to keep label consistent
// while zooming and moving while interval > 0. Otherwise the selection
// of displayable ticks and symbols probably keep changing.
// 3 is empirical value.
if (startTick !== 0 && step > 1 && tickCount / step > 2) {
startTick = Math.round(Math.ceil(startTick / step) * step);
} // (1) Only add min max label here but leave overlap checking
// to render stage, which also ensure the returned list
// suitable for splitLine and splitArea rendering.
// (2) Scales except category always contain min max label so
// do not need to perform this process.
var showAllLabel = shouldShowAllLabels(axis);
var includeMinLabel = labelModel.get("showMinLabel") || showAllLabel;
var includeMaxLabel = labelModel.get("showMaxLabel") || showAllLabel;
if (includeMinLabel && startTick !== ordinalExtent[0]) {
addItem(ordinalExtent[0]);
} // Optimize: avoid generating large array by `ordinalScale.getTicks()`.
var tickValue = startTick;
for (; tickValue <= ordinalExtent[1]; tickValue += step) {
addItem(tickValue);
}
if (includeMaxLabel && tickValue - step !== ordinalExtent[1]) {
addItem(ordinalExtent[1]);
}
function addItem(tickValue) {
var tickObj = {
value: tickValue,
};
result.push(
onlyTick
? tickValue
: {
formattedLabel: labelFormatter(tickObj),
rawLabel: ordinalScale.getLabel(tickObj),
tickValue: tickValue,
},
);
}
return result;
}
function makeLabelsByCustomizedCategoryInterval(
axis,
categoryInterval,
onlyTick,
) {
var ordinalScale = axis.scale;
var labelFormatter = makeLabelFormatter(axis);
var result = [];
each(ordinalScale.getTicks(), function (tick) {
var rawLabel = ordinalScale.getLabel(tick);
var tickValue = tick.value;
if (categoryInterval(tick.value, rawLabel)) {
result.push(
onlyTick
? tickValue
: {
formattedLabel: labelFormatter(tick),
rawLabel: rawLabel,
tickValue: tickValue,
},
);
}
});
return result;
}
var NORMALIZED_EXTENT = [0, 1];
/**
* Base class of Axis.
*/
var Axis =
/** @class */
(function () {
function Axis(dim, scale, extent) {
this.onBand = false;
this.inverse = false;
this.dim = dim;
this.scale = scale;
this._extent = extent || [0, 0];
}
/**
* If axis extent contain given coord
*/
Axis.prototype.contain = function (coord) {
var extent = this._extent;
var min = Math.min(extent[0], extent[1]);
var max = Math.max(extent[0], extent[1]);
return coord >= min && coord <= max;
};
/**
* If axis extent contain given data
*/
Axis.prototype.containData = function (data) {
return this.scale.contain(data);
};
/**
* Get coord extent.
*/
Axis.prototype.getExtent = function () {
return this._extent.slice();
};
/**
* Get precision used for formatting
*/
Axis.prototype.getPixelPrecision = function (dataExtent) {
return getPixelPrecision(
dataExtent || this.scale.getExtent(),
this._extent,
);
};
/**
* Set coord extent
*/
Axis.prototype.setExtent = function (start, end) {
var extent = this._extent;
extent[0] = start;
extent[1] = end;
};
/**
* Convert data to coord. Data is the rank if it has an ordinal scale
*/
Axis.prototype.dataToCoord = function (data, clamp) {
var extent = this._extent;
var scale = this.scale;
data = scale.normalize(data);
if (this.onBand && scale.type === "ordinal") {
extent = extent.slice();
fixExtentWithBands(extent, scale.count());
}
return linearMap(data, NORMALIZED_EXTENT, extent, clamp);
};
/**
* Convert coord to data. Data is the rank if it has an ordinal scale
*/
Axis.prototype.coordToData = function (coord, clamp) {
var extent = this._extent;
var scale = this.scale;
if (this.onBand && scale.type === "ordinal") {
extent = extent.slice();
fixExtentWithBands(extent, scale.count());
}
var t = linearMap(coord, extent, NORMALIZED_EXTENT, clamp);
return this.scale.scale(t);
};
/**
* Convert pixel point to data in axis
*/
Axis.prototype.pointToData = function (point, clamp) {
// Should be implemented in derived class if necessary.
return;
};
/**
* Different from `zrUtil.map(axis.getTicks(), axis.dataToCoord, axis)`,
* `axis.getTicksCoords` considers `onBand`, which is used by
* `boundaryGap:true` of category axis and splitLine and splitArea.
* @param opt.tickModel default: axis.model.getModel('axisTick')
* @param opt.clamp If `true`, the first and the last
* tick must be at the axis end points. Otherwise, clip ticks
* that outside the axis extent.
*/
Axis.prototype.getTicksCoords = function (opt) {
opt = opt || {};
var tickModel = opt.tickModel || this.getTickModel();
var result = createAxisTicks(this, tickModel);
var ticks = result.ticks;
var ticksCoords = map(
ticks,
function (tickVal) {
return {
coord: this.dataToCoord(
this.scale.type === "ordinal"
? this.scale.getRawOrdinalNumber(tickVal)
: tickVal,
),
tickValue: tickVal,
};
},
this,
);
var alignWithLabel = tickModel.get("alignWithLabel");
fixOnBandTicksCoords(this, ticksCoords, alignWithLabel, opt.clamp);
return ticksCoords;
};
Axis.prototype.getMinorTicksCoords = function () {
if (this.scale.type === "ordinal") {
// Category axis doesn't support minor ticks
return [];
}
var minorTickModel = this.model.getModel("minorTick");
var splitNumber = minorTickModel.get("splitNumber"); // Protection.
if (!(splitNumber > 0 && splitNumber < 100)) {
splitNumber = 5;
}
var minorTicks = this.scale.getMinorTicks(splitNumber);
var minorTicksCoords = map(
minorTicks,
function (minorTicksGroup) {
return map(
minorTicksGroup,
function (minorTick) {
return {
coord: this.dataToCoord(minorTick),
tickValue: minorTick,
};
},
this,
);
},
this,
);
return minorTicksCoords;
};
Axis.prototype.getViewLabels = function () {
return createAxisLabels(this).labels;
};
Axis.prototype.getLabelModel = function () {
return this.model.getModel("axisLabel");
};
/**
* Notice here we only get the default tick model. For splitLine
* or splitArea, we should pass the splitLineModel or splitAreaModel
* manually when calling `getTicksCoords`.
* In GL, this method may be overrided to:
* `axisModel.getModel('axisTick', grid3DModel.getModel('axisTick'));`
*/
Axis.prototype.getTickModel = function () {
return this.model.getModel("axisTick");
};
/**
* Get width of band
*/
Axis.prototype.getBandWidth = function () {
var axisExtent = this._extent;
var dataExtent = this.scale.getExtent();
var len = dataExtent[1] - dataExtent[0] + (this.onBand ? 1 : 0); // Fix #2728, avoid NaN when only one data.
len === 0 && (len = 1);
var size = Math.abs(axisExtent[1] - axisExtent[0]);
return Math.abs(size) / len;
};
/**
* Only be called in category axis.
* Can be overrided, consider other axes like in 3D.
* @return Auto interval for cateogry axis tick and label
*/
Axis.prototype.calculateCategoryInterval = function () {
return calculateCategoryInterval(this);
};
return Axis;
})();
function fixExtentWithBands(extent, nTick) {
var size = extent[1] - extent[0];
var len = nTick;
var margin = size / len / 2;
extent[0] += margin;
extent[1] -= margin;
} // If axis has labels [1, 2, 3, 4]. Bands on the axis are
// |---1---|---2---|---3---|---4---|.
// So the displayed ticks and splitLine/splitArea should between
// each data item, otherwise cause misleading (e.g., split tow bars
// of a single data item when there are two bar series).
// Also consider if tickCategoryInterval > 0 and onBand, ticks and
// splitLine/spliteArea should layout appropriately corresponding
// to displayed labels. (So we should not use `getBandWidth` in this
// case).
function fixOnBandTicksCoords(axis, ticksCoords, alignWithLabel, clamp) {
var ticksLen = ticksCoords.length;
if (!axis.onBand || alignWithLabel || !ticksLen) {
return;
}
var axisExtent = axis.getExtent();
var last;
var diffSize;
if (ticksLen === 1) {
ticksCoords[0].coord = axisExtent[0];
last = ticksCoords[1] = {
coord: axisExtent[0],
};
} else {
var crossLen =
ticksCoords[ticksLen - 1].tickValue - ticksCoords[0].tickValue;
var shift_1 =
(ticksCoords[ticksLen - 1].coord - ticksCoords[0].coord) / crossLen;
each(ticksCoords, function (ticksItem) {
ticksItem.coord -= shift_1 / 2;
});
var dataExtent = axis.scale.getExtent();
diffSize = 1 + dataExtent[1] - ticksCoords[ticksLen - 1].tickValue;
last = {
coord: ticksCoords[ticksLen - 1].coord + shift_1 * diffSize,
};
ticksCoords.push(last);
}
var inverse = axisExtent[0] > axisExtent[1]; // Handling clamp.
if (littleThan(ticksCoords[0].coord, axisExtent[0])) {
clamp ? (ticksCoords[0].coord = axisExtent[0]) : ticksCoords.shift();
}
if (clamp && littleThan(axisExtent[0], ticksCoords[0].coord)) {
ticksCoords.unshift({
coord: axisExtent[0],
});
}
if (littleThan(axisExtent[1], last.coord)) {
clamp ? (last.coord = axisExtent[1]) : ticksCoords.pop();
}
if (clamp && littleThan(last.coord, axisExtent[1])) {
ticksCoords.push({
coord: axisExtent[1],
});
}
function littleThan(a, b) {
// Avoid rounding error cause calculated tick coord different with extent.
// It may cause an extra unecessary tick added.
a = round(a);
b = round(b);
return inverse ? a > b : a < b;
}
}
// Should use `ComponentModel.extend` or `class XXXX extend ComponentModel` to create class.
// Then use `registerComponentModel` in `install` parameter when `use` this extension. For example:
// class Bar3DModel extends ComponentModel {}
// export function install(registers) { regsiters.registerComponentModel(Bar3DModel); }
// echarts.use(install);
function extendComponentModel(proto) {
var Model = ComponentModel.extend(proto);
ComponentModel.registerClass(Model);
return Model;
}
function extendComponentView(proto) {
var View = ComponentView.extend(proto);
ComponentView.registerClass(View);
return View;
}
function extendSeriesModel(proto) {
var Model = SeriesModel.extend(proto);
SeriesModel.registerClass(Model);
return Model;
}
function extendChartView(proto) {
var View = ChartView.extend(proto);
ChartView.registerClass(View);
return View;
}
var PI2$6 = Math.PI * 2;
var CMD$3 = PathProxy.CMD;
var DEFAULT_SEARCH_SPACE = ["top", "right", "bottom", "left"];
function getCandidateAnchor(pos, distance, rect, outPt, outDir) {
var width = rect.width;
var height = rect.height;
switch (pos) {
case "top":
outPt.set(rect.x + width / 2, rect.y - distance);
outDir.set(0, -1);
break;
case "bottom":
outPt.set(rect.x + width / 2, rect.y + height + distance);
outDir.set(0, 1);
break;
case "left":
outPt.set(rect.x - distance, rect.y + height / 2);
outDir.set(-1, 0);
break;
case "right":
outPt.set(rect.x + width + distance, rect.y + height / 2);
outDir.set(1, 0);
break;
}
}
function projectPointToArc(
cx,
cy,
r,
startAngle,
endAngle,
anticlockwise,
x,
y,
out,
) {
x -= cx;
y -= cy;
var d = Math.sqrt(x * x + y * y);
x /= d;
y /= d; // Intersect point.
var ox = x * r + cx;
var oy = y * r + cy;
if (Math.abs(startAngle - endAngle) % PI2$6 < 1e-4) {
// Is a circle
out[0] = ox;
out[1] = oy;
return d - r;
}
if (anticlockwise) {
var tmp = startAngle;
startAngle = normalizeRadian(endAngle);
endAngle = normalizeRadian(tmp);
} else {
startAngle = normalizeRadian(startAngle);
endAngle = normalizeRadian(endAngle);
}
if (startAngle > endAngle) {
endAngle += PI2$6;
}
var angle = Math.atan2(y, x);
if (angle < 0) {
angle += PI2$6;
}
if (
(angle >= startAngle && angle <= endAngle) ||
(angle + PI2$6 >= startAngle && angle + PI2$6 <= endAngle)
) {
// Project point is on the arc.
out[0] = ox;
out[1] = oy;
return d - r;
}
var x1 = r * Math.cos(startAngle) + cx;
var y1 = r * Math.sin(startAngle) + cy;
var x2 = r * Math.cos(endAngle) + cx;
var y2 = r * Math.sin(endAngle) + cy;
var d1 = (x1 - x) * (x1 - x) + (y1 - y) * (y1 - y);
var d2 = (x2 - x) * (x2 - x) + (y2 - y) * (y2 - y);
if (d1 < d2) {
out[0] = x1;
out[1] = y1;
return Math.sqrt(d1);
} else {
out[0] = x2;
out[1] = y2;
return Math.sqrt(d2);
}
}
function projectPointToLine(x1, y1, x2, y2, x, y, out, limitToEnds) {
var dx = x - x1;
var dy = y - y1;
var dx1 = x2 - x1;
var dy1 = y2 - y1;
var lineLen = Math.sqrt(dx1 * dx1 + dy1 * dy1);
dx1 /= lineLen;
dy1 /= lineLen; // dot product
var projectedLen = dx * dx1 + dy * dy1;
var t = projectedLen / lineLen;
if (limitToEnds) {
t = Math.min(Math.max(t, 0), 1);
}
t *= lineLen;
var ox = (out[0] = x1 + t * dx1);
var oy = (out[1] = y1 + t * dy1);
return Math.sqrt((ox - x) * (ox - x) + (oy - y) * (oy - y));
}
function projectPointToRect(x1, y1, width, height, x, y, out) {
if (width < 0) {
x1 = x1 + width;
width = -width;
}
if (height < 0) {
y1 = y1 + height;
height = -height;
}
var x2 = x1 + width;
var y2 = y1 + height;
var ox = (out[0] = Math.min(Math.max(x, x1), x2));
var oy = (out[1] = Math.min(Math.max(y, y1), y2));
return Math.sqrt((ox - x) * (ox - x) + (oy - y) * (oy - y));
}
var tmpPt = [];
function nearestPointOnRect(pt, rect, out) {
var dist = projectPointToRect(
rect.x,
rect.y,
rect.width,
rect.height,
pt.x,
pt.y,
tmpPt,
);
out.set(tmpPt[0], tmpPt[1]);
return dist;
}
/**
* Calculate min distance corresponding point.
* This method won't evaluate if point is in the path.
*/
function nearestPointOnPath(pt, path, out) {
var xi = 0;
var yi = 0;
var x0 = 0;
var y0 = 0;
var x1;
var y1;
var minDist = Infinity;
var data = path.data;
var x = pt.x;
var y = pt.y;
for (var i = 0; i < data.length; ) {
var cmd = data[i++];
if (i === 1) {
xi = data[i];
yi = data[i + 1];
x0 = xi;
y0 = yi;
}
var d = minDist;
switch (cmd) {
case CMD$3.M:
// moveTo 命令重新创建一个新的 subpath, 并且更新新的起点
// 在 closePath 的时候使用
x0 = data[i++];
y0 = data[i++];
xi = x0;
yi = y0;
break;
case CMD$3.L:
d = projectPointToLine(
xi,
yi,
data[i],
data[i + 1],
x,
y,
tmpPt,
true,
);
xi = data[i++];
yi = data[i++];
break;
case CMD$3.C:
d = cubicProjectPoint(
xi,
yi,
data[i++],
data[i++],
data[i++],
data[i++],
data[i],
data[i + 1],
x,
y,
tmpPt,
);
xi = data[i++];
yi = data[i++];
break;
case CMD$3.Q:
d = quadraticProjectPoint(
xi,
yi,
data[i++],
data[i++],
data[i],
data[i + 1],
x,
y,
tmpPt,
);
xi = data[i++];
yi = data[i++];
break;
case CMD$3.A:
// TODO Arc 判断的开销比较大
var cx = data[i++];
var cy = data[i++];
var rx = data[i++];
var ry = data[i++];
var theta = data[i++];
var dTheta = data[i++]; // TODO Arc 旋转
i += 1;
var anticlockwise = !!(1 - data[i++]);
x1 = Math.cos(theta) * rx + cx;
y1 = Math.sin(theta) * ry + cy; // 不是直接使用 arc 命令
if (i <= 1) {
// 第一个命令起点还未定义
x0 = x1;
y0 = y1;
} // zr 使用scale来模拟椭圆, 这里也对x做一定的缩放
var _x = ((x - cx) * ry) / rx + cx;
d = projectPointToArc(
cx,
cy,
ry,
theta,
theta + dTheta,
anticlockwise,
_x,
y,
tmpPt,
);
xi = Math.cos(theta + dTheta) * rx + cx;
yi = Math.sin(theta + dTheta) * ry + cy;
break;
case CMD$3.R:
x0 = xi = data[i++];
y0 = yi = data[i++];
var width = data[i++];
var height = data[i++];
d = projectPointToRect(x0, y0, width, height, x, y, tmpPt);
break;
case CMD$3.Z:
d = projectPointToLine(xi, yi, x0, y0, x, y, tmpPt, true);
xi = x0;
yi = y0;
break;
}
if (d < minDist) {
minDist = d;
out.set(tmpPt[0], tmpPt[1]);
}
}
return minDist;
} // Temporal varible for intermediate usage.
var pt0 = new Point();
var pt1 = new Point();
var pt2 = new Point();
var dir = new Point();
var dir2 = new Point();
/**
* Calculate a proper guide line based on the label position and graphic element definition
* @param label
* @param labelRect
* @param target
* @param targetRect
*/
function updateLabelLinePoints(target, labelLineModel) {
if (!target) {
return;
}
var labelLine = target.getTextGuideLine();
var label = target.getTextContent(); // Needs to create text guide in each charts.
if (!(label && labelLine)) {
return;
}
var labelGuideConfig = target.textGuideLineConfig || {};
var points = [
[0, 0],
[0, 0],
[0, 0],
];
var searchSpace = labelGuideConfig.candidates || DEFAULT_SEARCH_SPACE;
var labelRect = label.getBoundingRect().clone();
labelRect.applyTransform(label.getComputedTransform());
var minDist = Infinity;
var anchorPoint = labelGuideConfig.anchor;
var targetTransform = target.getComputedTransform();
var targetInversedTransform =
targetTransform && invert([], targetTransform);
var len = labelLineModel.get("length2") || 0;
if (anchorPoint) {
pt2.copy(anchorPoint);
}
for (var i = 0; i < searchSpace.length; i++) {
var candidate = searchSpace[i];
getCandidateAnchor(candidate, 0, labelRect, pt0, dir);
Point.scaleAndAdd(pt1, pt0, dir, len); // Transform to target coord space.
pt1.transform(targetInversedTransform); // Note: getBoundingRect will ensure the `path` being created.
var boundingRect = target.getBoundingRect();
var dist = anchorPoint
? anchorPoint.distance(pt1)
: target instanceof Path
? nearestPointOnPath(pt1, target.path, pt2)
: nearestPointOnRect(pt1, boundingRect, pt2); // TODO pt2 is in the path
if (dist < minDist) {
minDist = dist; // Transform back to global space.
pt1.transform(targetTransform);
pt2.transform(targetTransform);
pt2.toArray(points[0]);
pt1.toArray(points[1]);
pt0.toArray(points[2]);
}
}
limitTurnAngle(points, labelLineModel.get("minTurnAngle"));
labelLine.setShape({
points: points,
});
} // Temporal variable for the limitTurnAngle function
var tmpArr = [];
var tmpProjPoint = new Point();
/**
* Reduce the line segment attached to the label to limit the turn angle between two segments.
* @param linePoints
* @param minTurnAngle Radian of minimum turn angle. 0 - 180
*/
function limitTurnAngle(linePoints, minTurnAngle) {
if (!(minTurnAngle <= 180 && minTurnAngle > 0)) {
return;
}
minTurnAngle = (minTurnAngle / 180) * Math.PI; // The line points can be
// /pt1----pt2 (label)
// /
// pt0/
pt0.fromArray(linePoints[0]);
pt1.fromArray(linePoints[1]);
pt2.fromArray(linePoints[2]);
Point.sub(dir, pt0, pt1);
Point.sub(dir2, pt2, pt1);
var len1 = dir.len();
var len2 = dir2.len();
if (len1 < 1e-3 || len2 < 1e-3) {
return;
}
dir.scale(1 / len1);
dir2.scale(1 / len2);
var angleCos = dir.dot(dir2);
var minTurnAngleCos = Math.cos(minTurnAngle);
if (minTurnAngleCos < angleCos) {
// Smaller than minTurnAngle
// Calculate project point of pt0 on pt1-pt2
var d = projectPointToLine(
pt1.x,
pt1.y,
pt2.x,
pt2.y,
pt0.x,
pt0.y,
tmpArr,
false,
);
tmpProjPoint.fromArray(tmpArr); // Calculate new projected length with limited minTurnAngle and get the new connect point
tmpProjPoint.scaleAndAdd(dir2, d / Math.tan(Math.PI - minTurnAngle)); // Limit the new calculated connect point between pt1 and pt2.
var t =
pt2.x !== pt1.x
? (tmpProjPoint.x - pt1.x) / (pt2.x - pt1.x)
: (tmpProjPoint.y - pt1.y) / (pt2.y - pt1.y);
if (isNaN(t)) {
return;
}
if (t < 0) {
Point.copy(tmpProjPoint, pt1);
} else if (t > 1) {
Point.copy(tmpProjPoint, pt2);
}
tmpProjPoint.toArray(linePoints[1]);
}
}
/**
* Limit the angle of line and the surface
* @param maxSurfaceAngle Radian of minimum turn angle. 0 - 180. 0 is same direction to normal. 180 is opposite
*/
function limitSurfaceAngle(linePoints, surfaceNormal, maxSurfaceAngle) {
if (!(maxSurfaceAngle <= 180 && maxSurfaceAngle > 0)) {
return;
}
maxSurfaceAngle = (maxSurfaceAngle / 180) * Math.PI;
pt0.fromArray(linePoints[0]);
pt1.fromArray(linePoints[1]);
pt2.fromArray(linePoints[2]);
Point.sub(dir, pt1, pt0);
Point.sub(dir2, pt2, pt1);
var len1 = dir.len();
var len2 = dir2.len();
if (len1 < 1e-3 || len2 < 1e-3) {
return;
}
dir.scale(1 / len1);
dir2.scale(1 / len2);
var angleCos = dir.dot(surfaceNormal);
var maxSurfaceAngleCos = Math.cos(maxSurfaceAngle);
if (angleCos < maxSurfaceAngleCos) {
// Calculate project point of pt0 on pt1-pt2
var d = projectPointToLine(
pt1.x,
pt1.y,
pt2.x,
pt2.y,
pt0.x,
pt0.y,
tmpArr,
false,
);
tmpProjPoint.fromArray(tmpArr);
var HALF_PI = Math.PI / 2;
var angle2 = Math.acos(dir2.dot(surfaceNormal));
var newAngle = HALF_PI + angle2 - maxSurfaceAngle;
if (newAngle >= HALF_PI) {
// parallel
Point.copy(tmpProjPoint, pt2);
} else {
// Calculate new projected length with limited minTurnAngle and get the new connect point
tmpProjPoint.scaleAndAdd(dir2, d / Math.tan(Math.PI / 2 - newAngle)); // Limit the new calculated connect point between pt1 and pt2.
var t =
pt2.x !== pt1.x
? (tmpProjPoint.x - pt1.x) / (pt2.x - pt1.x)
: (tmpProjPoint.y - pt1.y) / (pt2.y - pt1.y);
if (isNaN(t)) {
return;
}
if (t < 0) {
Point.copy(tmpProjPoint, pt1);
} else if (t > 1) {
Point.copy(tmpProjPoint, pt2);
}
}
tmpProjPoint.toArray(linePoints[1]);
}
}
function setLabelLineState(labelLine, ignore, stateName, stateModel) {
var isNormal = stateName === "normal";
var stateObj = isNormal ? labelLine : labelLine.ensureState(stateName); // Make sure display.
stateObj.ignore = ignore; // Set smooth
var smooth = stateModel.get("smooth");
if (smooth && smooth === true) {
smooth = 0.3;
}
stateObj.shape = stateObj.shape || {};
if (smooth > 0) {
stateObj.shape.smooth = smooth;
}
var styleObj = stateModel.getModel("lineStyle").getLineStyle();
isNormal ? labelLine.useStyle(styleObj) : (stateObj.style = styleObj);
}
function buildLabelLinePath(path, shape) {
var smooth = shape.smooth;
var points = shape.points;
if (!points) {
return;
}
path.moveTo(points[0][0], points[0][1]);
if (smooth > 0 && points.length >= 3) {
var len1 = dist(points[0], points[1]);
var len2 = dist(points[1], points[2]);
if (!len1 || !len2) {
path.lineTo(points[1][0], points[1][1]);
path.lineTo(points[2][0], points[2][1]);
return;
}
var moveLen = Math.min(len1, len2) * smooth;
var midPoint0 = lerp([], points[1], points[0], moveLen / len1);
var midPoint2 = lerp([], points[1], points[2], moveLen / len2);
var midPoint1 = lerp([], midPoint0, midPoint2, 0.5);
path.bezierCurveTo(
midPoint0[0],
midPoint0[1],
midPoint0[0],
midPoint0[1],
midPoint1[0],
midPoint1[1],
);
path.bezierCurveTo(
midPoint2[0],
midPoint2[1],
midPoint2[0],
midPoint2[1],
points[2][0],
points[2][1],
);
} else {
for (var i = 1; i < points.length; i++) {
path.lineTo(points[i][0], points[i][1]);
}
}
}
/**
* Create a label line if necessary and set it's style.
*/
function setLabelLineStyle(targetEl, statesModels, defaultStyle) {
var labelLine = targetEl.getTextGuideLine();
var label = targetEl.getTextContent();
if (!label) {
// Not show label line if there is no label.
if (labelLine) {
targetEl.removeTextGuideLine();
}
return;
}
var normalModel = statesModels.normal;
var showNormal = normalModel.get("show");
var labelIgnoreNormal = label.ignore;
for (var i = 0; i < DISPLAY_STATES.length; i++) {
var stateName = DISPLAY_STATES[i];
var stateModel = statesModels[stateName];
var isNormal = stateName === "normal";
if (stateModel) {
var stateShow = stateModel.get("show");
var isLabelIgnored = isNormal
? labelIgnoreNormal
: retrieve2(
label.states[stateName] && label.states[stateName].ignore,
labelIgnoreNormal,
);
if (
isLabelIgnored || // Not show when label is not shown in this state.
!retrieve2(stateShow, showNormal) // Use normal state by default if not set.
) {
var stateObj = isNormal
? labelLine
: labelLine && labelLine.states[stateName];
if (stateObj) {
stateObj.ignore = true;
}
continue;
} // Create labelLine if not exists
if (!labelLine) {
labelLine = new Polyline();
targetEl.setTextGuideLine(labelLine); // Reset state of normal because it's new created.
// NOTE: NORMAL should always been the first!
if (!isNormal && (labelIgnoreNormal || !showNormal)) {
setLabelLineState(labelLine, true, "normal", statesModels.normal);
} // Use same state proxy.
if (targetEl.stateProxy) {
labelLine.stateProxy = targetEl.stateProxy;
}
}
setLabelLineState(labelLine, false, stateName, stateModel);
}
}
if (labelLine) {
defaults(labelLine.style, defaultStyle); // Not fill.
labelLine.style.fill = null;
var showAbove = normalModel.get("showAbove");
var labelLineConfig = (targetEl.textGuideLineConfig =
targetEl.textGuideLineConfig || {});
labelLineConfig.showAbove = showAbove || false; // Custom the buildPath.
labelLine.buildPath = buildLabelLinePath;
}
}
function getLabelLineStatesModels(itemModel, labelLineName) {
labelLineName = labelLineName || "labelLine";
var statesModels = {
normal: itemModel.getModel(labelLineName),
};
for (var i = 0; i < SPECIAL_STATES.length; i++) {
var stateName = SPECIAL_STATES[i];
statesModels[stateName] = itemModel.getModel([stateName, labelLineName]);
}
return statesModels;
}
function prepareLayoutList(input) {
var list = [];
for (var i = 0; i < input.length; i++) {
var rawItem = input[i];
if (rawItem.defaultAttr.ignore) {
continue;
}
var label = rawItem.label;
var transform = label.getComputedTransform(); // NOTE: Get bounding rect after getComputedTransform, or label may not been updated by the host el.
var localRect = label.getBoundingRect();
var isAxisAligned =
!transform || (transform[1] < 1e-5 && transform[2] < 1e-5);
var minMargin = label.style.margin || 0;
var globalRect = localRect.clone();
globalRect.applyTransform(transform);
globalRect.x -= minMargin / 2;
globalRect.y -= minMargin / 2;
globalRect.width += minMargin;
globalRect.height += minMargin;
var obb = isAxisAligned
? new OrientedBoundingRect(localRect, transform)
: null;
list.push({
label: label,
labelLine: rawItem.labelLine,
rect: globalRect,
localRect: localRect,
obb: obb,
priority: rawItem.priority,
defaultAttr: rawItem.defaultAttr,
layoutOption: rawItem.computedLayoutOption,
axisAligned: isAxisAligned,
transform: transform,
});
}
return list;
}
function shiftLayout(list, xyDim, sizeDim, minBound, maxBound, balanceShift) {
var len = list.length;
if (len < 2) {
return;
}
list.sort(function (a, b) {
return a.rect[xyDim] - b.rect[xyDim];
});
var lastPos = 0;
var delta;
var adjusted = false;
var totalShifts = 0;
for (var i = 0; i < len; i++) {
var item = list[i];
var rect = item.rect;
delta = rect[xyDim] - lastPos;
if (delta < 0) {
// shiftForward(i, len, -delta);
rect[xyDim] -= delta;
item.label[xyDim] -= delta;
adjusted = true;
}
var shift = Math.max(-delta, 0);
totalShifts += shift;
lastPos = rect[xyDim] + rect[sizeDim];
}
if (totalShifts > 0 && balanceShift) {
// Shift back to make the distribution more equally.
shiftList(-totalShifts / len, 0, len);
} // TODO bleedMargin?
var first = list[0];
var last = list[len - 1];
var minGap;
var maxGap;
updateMinMaxGap(); // If ends exceed two bounds, squeeze at most 80%, then take the gap of two bounds.
minGap < 0 && squeezeGaps(-minGap, 0.8);
maxGap < 0 && squeezeGaps(maxGap, 0.8);
updateMinMaxGap();
takeBoundsGap(minGap, maxGap, 1);
takeBoundsGap(maxGap, minGap, -1); // Handle bailout when there is not enough space.
updateMinMaxGap();
if (minGap < 0) {
squeezeWhenBailout(-minGap);
}
if (maxGap < 0) {
squeezeWhenBailout(maxGap);
}
function updateMinMaxGap() {
minGap = first.rect[xyDim] - minBound;
maxGap = maxBound - last.rect[xyDim] - last.rect[sizeDim];
}
function takeBoundsGap(gapThisBound, gapOtherBound, moveDir) {
if (gapThisBound < 0) {
// Move from other gap if can.
var moveFromMaxGap = Math.min(gapOtherBound, -gapThisBound);
if (moveFromMaxGap > 0) {
shiftList(moveFromMaxGap * moveDir, 0, len);
var remained = moveFromMaxGap + gapThisBound;
if (remained < 0) {
squeezeGaps(-remained * moveDir, 1);
}
} else {
squeezeGaps(-gapThisBound * moveDir, 1);
}
}
}
function shiftList(delta, start, end) {
if (delta !== 0) {
adjusted = true;
}
for (var i = start; i < end; i++) {
var item = list[i];
var rect = item.rect;
rect[xyDim] += delta;
item.label[xyDim] += delta;
}
} // Squeeze gaps if the labels exceed margin.
function squeezeGaps(delta, maxSqeezePercent) {
var gaps = [];
var totalGaps = 0;
for (var i = 1; i < len; i++) {
var prevItemRect = list[i - 1].rect;
var gap = Math.max(
list[i].rect[xyDim] - prevItemRect[xyDim] - prevItemRect[sizeDim],
0,
);
gaps.push(gap);
totalGaps += gap;
}
if (!totalGaps) {
return;
}
var squeezePercent = Math.min(
Math.abs(delta) / totalGaps,
maxSqeezePercent,
);
if (delta > 0) {
for (var i = 0; i < len - 1; i++) {
// Distribute the shift delta to all gaps.
var movement = gaps[i] * squeezePercent; // Forward
shiftList(movement, 0, i + 1);
}
} else {
// Backward
for (var i = len - 1; i > 0; i--) {
// Distribute the shift delta to all gaps.
var movement = gaps[i - 1] * squeezePercent;
shiftList(-movement, i, len);
}
}
}
/**
* Squeeze to allow overlap if there is no more space available.
* Let other overlapping strategy like hideOverlap do the job instead of keep exceeding the bounds.
*/
function squeezeWhenBailout(delta) {
var dir = delta < 0 ? -1 : 1;
delta = Math.abs(delta);
var moveForEachLabel = Math.ceil(delta / (len - 1));
for (var i = 0; i < len - 1; i++) {
if (dir > 0) {
// Forward
shiftList(moveForEachLabel, 0, i + 1);
} else {
// Backward
shiftList(-moveForEachLabel, len - i - 1, len);
}
delta -= moveForEachLabel;
if (delta <= 0) {
return;
}
}
}
return adjusted;
}
/**
* Adjust labels on x direction to avoid overlap.
*/
function shiftLayoutOnX(
list,
leftBound,
rightBound, // If average the shifts on all labels and add them to 0
// TODO: Not sure if should enable it.
// Pros: The angle of lines will distribute more equally
// Cons: In some layout. It may not what user wanted. like in pie. the label of last sector is usually changed unexpectedly.
balanceShift,
) {
return shiftLayout(list, "x", "width", leftBound, rightBound, balanceShift);
}
/**
* Adjust labels on y direction to avoid overlap.
*/
function shiftLayoutOnY(
list,
topBound,
bottomBound, // If average the shifts on all labels and add them to 0
balanceShift,
) {
return shiftLayout(
list,
"y",
"height",
topBound,
bottomBound,
balanceShift,
);
}
function hideOverlap(labelList) {
var displayedLabels = []; // TODO, render overflow visible first, put in the displayedLabels.
labelList.sort(function (a, b) {
return b.priority - a.priority;
});
var globalRect = new BoundingRect(0, 0, 0, 0);
function hideEl(el) {
if (!el.ignore) {
// Show on emphasis.
var emphasisState = el.ensureState("emphasis");
if (emphasisState.ignore == null) {
emphasisState.ignore = false;
}
}
el.ignore = true;
}
for (var i = 0; i < labelList.length; i++) {
var labelItem = labelList[i];
var isAxisAligned = labelItem.axisAligned;
var localRect = labelItem.localRect;
var transform = labelItem.transform;
var label = labelItem.label;
var labelLine = labelItem.labelLine;
globalRect.copy(labelItem.rect); // Add a threshold because layout may be aligned precisely.
globalRect.width -= 0.1;
globalRect.height -= 0.1;
globalRect.x += 0.05;
globalRect.y += 0.05;
var obb = labelItem.obb;
var overlapped = false;
for (var j = 0; j < displayedLabels.length; j++) {
var existsTextCfg = displayedLabels[j]; // Fast rejection.
if (!globalRect.intersect(existsTextCfg.rect)) {
continue;
}
if (isAxisAligned && existsTextCfg.axisAligned) {
// Is overlapped
overlapped = true;
break;
}
if (!existsTextCfg.obb) {
// If self is not axis aligned. But other is.
existsTextCfg.obb = new OrientedBoundingRect(
existsTextCfg.localRect,
existsTextCfg.transform,
);
}
if (!obb) {
// If self is axis aligned. But other is not.
obb = new OrientedBoundingRect(localRect, transform);
}
if (obb.intersect(existsTextCfg.obb)) {
overlapped = true;
break;
}
} // TODO Callback to determine if this overlap should be handled?
if (overlapped) {
hideEl(label);
labelLine && hideEl(labelLine);
} else {
label.attr("ignore", labelItem.defaultAttr.ignore);
labelLine &&
labelLine.attr("ignore", labelItem.defaultAttr.labelGuideIgnore);
displayedLabels.push(labelItem);
}
}
}
function cloneArr(points) {
if (points) {
var newPoints = [];
for (var i = 0; i < points.length; i++) {
newPoints.push(points[i].slice());
}
return newPoints;
}
}
function prepareLayoutCallbackParams(labelItem, hostEl) {
var label = labelItem.label;
var labelLine = hostEl && hostEl.getTextGuideLine();
return {
dataIndex: labelItem.dataIndex,
dataType: labelItem.dataType,
seriesIndex: labelItem.seriesModel.seriesIndex,
text: labelItem.label.style.text,
rect: labelItem.hostRect,
labelRect: labelItem.rect,
// x: labelAttr.x,
// y: labelAttr.y,
align: label.style.align,
verticalAlign: label.style.verticalAlign,
labelLinePoints: cloneArr(labelLine && labelLine.shape.points),
};
}
var LABEL_OPTION_TO_STYLE_KEYS = [
"align",
"verticalAlign",
"width",
"height",
"fontSize",
];
var dummyTransformable = new Transformable();
var labelLayoutInnerStore = makeInner();
var labelLineAnimationStore = makeInner();
function extendWithKeys(target, source, keys) {
for (var i = 0; i < keys.length; i++) {
var key = keys[i];
if (source[key] != null) {
target[key] = source[key];
}
}
}
var LABEL_LAYOUT_PROPS = ["x", "y", "rotation"];
var LabelManager =
/** @class */
(function () {
function LabelManager() {
this._labelList = [];
this._chartViewList = [];
}
LabelManager.prototype.clearLabels = function () {
this._labelList = [];
this._chartViewList = [];
};
/**
* Add label to manager
*/
LabelManager.prototype._addLabel = function (
dataIndex,
dataType,
seriesModel,
label,
layoutOption,
) {
var labelStyle = label.style;
var hostEl = label.__hostTarget;
var textConfig = hostEl.textConfig || {}; // TODO: If label is in other state.
var labelTransform = label.getComputedTransform();
var labelRect = label.getBoundingRect().plain();
BoundingRect.applyTransform(labelRect, labelRect, labelTransform);
if (labelTransform) {
dummyTransformable.setLocalTransform(labelTransform);
} else {
// Identity transform.
dummyTransformable.x =
dummyTransformable.y =
dummyTransformable.rotation =
dummyTransformable.originX =
dummyTransformable.originY =
0;
dummyTransformable.scaleX = dummyTransformable.scaleY = 1;
}
var host = label.__hostTarget;
var hostRect;
if (host) {
hostRect = host.getBoundingRect().plain();
var transform = host.getComputedTransform();
BoundingRect.applyTransform(hostRect, hostRect, transform);
}
var labelGuide = hostRect && host.getTextGuideLine();
this._labelList.push({
label: label,
labelLine: labelGuide,
seriesModel: seriesModel,
dataIndex: dataIndex,
dataType: dataType,
layoutOption: layoutOption,
computedLayoutOption: null,
rect: labelRect,
hostRect: hostRect,
// Label with lower priority will be hidden when overlapped
// Use rect size as default priority
priority: hostRect ? hostRect.width * hostRect.height : 0,
// Save default label attributes.
// For restore if developers want get back to default value in callback.
defaultAttr: {
ignore: label.ignore,
labelGuideIgnore: labelGuide && labelGuide.ignore,
x: dummyTransformable.x,
y: dummyTransformable.y,
scaleX: dummyTransformable.scaleX,
scaleY: dummyTransformable.scaleY,
rotation: dummyTransformable.rotation,
style: {
x: labelStyle.x,
y: labelStyle.y,
align: labelStyle.align,
verticalAlign: labelStyle.verticalAlign,
width: labelStyle.width,
height: labelStyle.height,
fontSize: labelStyle.fontSize,
},
cursor: label.cursor,
attachedPos: textConfig.position,
attachedRot: textConfig.rotation,
},
});
};
LabelManager.prototype.addLabelsOfSeries = function (chartView) {
var _this = this;
this._chartViewList.push(chartView);
var seriesModel = chartView.__model;
var layoutOption = seriesModel.get("labelLayout");
/**
* Ignore layouting if it's not specified anything.
*/
if (!(isFunction(layoutOption) || keys(layoutOption).length)) {
return;
}
chartView.group.traverse(function (child) {
if (child.ignore) {
return true; // Stop traverse descendants.
} // Only support label being hosted on graphic elements.
var textEl = child.getTextContent();
var ecData = getECData(child); // Can only attach the text on the element with dataIndex
if (textEl && !textEl.disableLabelLayout) {
_this._addLabel(
ecData.dataIndex,
ecData.dataType,
seriesModel,
textEl,
layoutOption,
);
}
});
};
LabelManager.prototype.updateLayoutConfig = function (api) {
var width = api.getWidth();
var height = api.getHeight();
function createDragHandler(el, labelLineModel) {
return function () {
updateLabelLinePoints(el, labelLineModel);
};
}
for (var i = 0; i < this._labelList.length; i++) {
var labelItem = this._labelList[i];
var label = labelItem.label;
var hostEl = label.__hostTarget;
var defaultLabelAttr = labelItem.defaultAttr;
var layoutOption = void 0; // TODO A global layout option?
if (isFunction(labelItem.layoutOption)) {
layoutOption = labelItem.layoutOption(
prepareLayoutCallbackParams(labelItem, hostEl),
);
} else {
layoutOption = labelItem.layoutOption;
}
layoutOption = layoutOption || {};
labelItem.computedLayoutOption = layoutOption;
var degreeToRadian = Math.PI / 180; // TODO hostEl should always exists.
// Or label should not have parent because the x, y is all in global space.
if (hostEl) {
hostEl.setTextConfig({
// Force to set local false.
local: false,
// Ignore position and rotation config on the host el if x or y is changed.
position:
layoutOption.x != null || layoutOption.y != null
? null
: defaultLabelAttr.attachedPos,
// Ignore rotation config on the host el if rotation is changed.
rotation:
layoutOption.rotate != null
? layoutOption.rotate * degreeToRadian
: defaultLabelAttr.attachedRot,
offset: [layoutOption.dx || 0, layoutOption.dy || 0],
});
}
var needsUpdateLabelLine = false;
if (layoutOption.x != null) {
// TODO width of chart view.
label.x = parsePercent$1(layoutOption.x, width);
label.setStyle("x", 0); // Ignore movement in style. TODO: origin.
needsUpdateLabelLine = true;
} else {
label.x = defaultLabelAttr.x;
label.setStyle("x", defaultLabelAttr.style.x);
}
if (layoutOption.y != null) {
// TODO height of chart view.
label.y = parsePercent$1(layoutOption.y, height);
label.setStyle("y", 0); // Ignore movement in style.
needsUpdateLabelLine = true;
} else {
label.y = defaultLabelAttr.y;
label.setStyle("y", defaultLabelAttr.style.y);
}
if (layoutOption.labelLinePoints) {
var guideLine = hostEl.getTextGuideLine();
if (guideLine) {
guideLine.setShape({
points: layoutOption.labelLinePoints,
}); // Not update
needsUpdateLabelLine = false;
}
}
var labelLayoutStore = labelLayoutInnerStore(label);
labelLayoutStore.needsUpdateLabelLine = needsUpdateLabelLine;
label.rotation =
layoutOption.rotate != null
? layoutOption.rotate * degreeToRadian
: defaultLabelAttr.rotation;
label.scaleX = defaultLabelAttr.scaleX;
label.scaleY = defaultLabelAttr.scaleY;
for (var k = 0; k < LABEL_OPTION_TO_STYLE_KEYS.length; k++) {
var key = LABEL_OPTION_TO_STYLE_KEYS[k];
label.setStyle(
key,
layoutOption[key] != null
? layoutOption[key]
: defaultLabelAttr.style[key],
);
}
if (layoutOption.draggable) {
label.draggable = true;
label.cursor = "move";
if (hostEl) {
var hostModel = labelItem.seriesModel;
if (labelItem.dataIndex != null) {
var data = labelItem.seriesModel.getData(labelItem.dataType);
hostModel = data.getItemModel(labelItem.dataIndex);
}
label.on(
"drag",
createDragHandler(hostEl, hostModel.getModel("labelLine")),
);
}
} else {
// TODO Other drag functions?
label.off("drag");
label.cursor = defaultLabelAttr.cursor;
}
}
};
LabelManager.prototype.layout = function (api) {
var width = api.getWidth();
var height = api.getHeight();
var labelList = prepareLayoutList(this._labelList);
var labelsNeedsAdjustOnX = filter(labelList, function (item) {
return item.layoutOption.moveOverlap === "shiftX";
});
var labelsNeedsAdjustOnY = filter(labelList, function (item) {
return item.layoutOption.moveOverlap === "shiftY";
});
shiftLayoutOnX(labelsNeedsAdjustOnX, 0, width);
shiftLayoutOnY(labelsNeedsAdjustOnY, 0, height);
var labelsNeedsHideOverlap = filter(labelList, function (item) {
return item.layoutOption.hideOverlap;
});
hideOverlap(labelsNeedsHideOverlap);
};
/**
* Process all labels. Not only labels with layoutOption.
*/
LabelManager.prototype.processLabelsOverall = function () {
var _this = this;
each(this._chartViewList, function (chartView) {
var seriesModel = chartView.__model;
var ignoreLabelLineUpdate = chartView.ignoreLabelLineUpdate;
var animationEnabled = seriesModel.isAnimationEnabled();
chartView.group.traverse(function (child) {
if (child.ignore && !child.forceLabelAnimation) {
return true; // Stop traverse descendants.
}
var needsUpdateLabelLine = !ignoreLabelLineUpdate;
var label = child.getTextContent();
if (!needsUpdateLabelLine && label) {
needsUpdateLabelLine =
labelLayoutInnerStore(label).needsUpdateLabelLine;
}
if (needsUpdateLabelLine) {
_this._updateLabelLine(child, seriesModel);
}
if (animationEnabled) {
_this._animateLabels(child, seriesModel);
}
});
});
};
LabelManager.prototype._updateLabelLine = function (el, seriesModel) {
// Only support label being hosted on graphic elements.
var textEl = el.getTextContent(); // Update label line style.
var ecData = getECData(el);
var dataIndex = ecData.dataIndex; // Only support labelLine on the labels represent data.
if (textEl && dataIndex != null) {
var data = seriesModel.getData(ecData.dataType);
var itemModel = data.getItemModel(dataIndex);
var defaultStyle = {};
var visualStyle = data.getItemVisual(dataIndex, "style");
var visualType = data.getVisual("drawType"); // Default to be same with main color
defaultStyle.stroke = visualStyle[visualType];
var labelLineModel = itemModel.getModel("labelLine");
setLabelLineStyle(
el,
getLabelLineStatesModels(itemModel),
defaultStyle,
);
updateLabelLinePoints(el, labelLineModel);
}
};
LabelManager.prototype._animateLabels = function (el, seriesModel) {
var textEl = el.getTextContent();
var guideLine = el.getTextGuideLine(); // Animate
if (
textEl && // `forceLabelAnimation` has the highest priority
(el.forceLabelAnimation ||
(!textEl.ignore &&
!textEl.invisible &&
!el.disableLabelAnimation &&
!isElementRemoved(el)))
) {
var layoutStore = labelLayoutInnerStore(textEl);
var oldLayout = layoutStore.oldLayout;
var ecData = getECData(el);
var dataIndex = ecData.dataIndex;
var newProps = {
x: textEl.x,
y: textEl.y,
rotation: textEl.rotation,
};
var data = seriesModel.getData(ecData.dataType);
if (!oldLayout) {
textEl.attr(newProps); // Disable fade in animation if value animation is enabled.
if (!labelInner(textEl).valueAnimation) {
var oldOpacity = retrieve2(textEl.style.opacity, 1); // Fade in animation
textEl.style.opacity = 0;
initProps(
textEl,
{
style: {
opacity: oldOpacity,
},
},
seriesModel,
dataIndex,
);
}
} else {
textEl.attr(oldLayout); // Make sure the animation from is in the right status.
var prevStates = el.prevStates;
if (prevStates) {
if (indexOf(prevStates, "select") >= 0) {
textEl.attr(layoutStore.oldLayoutSelect);
}
if (indexOf(prevStates, "emphasis") >= 0) {
textEl.attr(layoutStore.oldLayoutEmphasis);
}
}
updateProps(textEl, newProps, seriesModel, dataIndex);
}
layoutStore.oldLayout = newProps;
if (textEl.states.select) {
var layoutSelect = (layoutStore.oldLayoutSelect = {});
extendWithKeys(layoutSelect, newProps, LABEL_LAYOUT_PROPS);
extendWithKeys(
layoutSelect,
textEl.states.select,
LABEL_LAYOUT_PROPS,
);
}
if (textEl.states.emphasis) {
var layoutEmphasis = (layoutStore.oldLayoutEmphasis = {});
extendWithKeys(layoutEmphasis, newProps, LABEL_LAYOUT_PROPS);
extendWithKeys(
layoutEmphasis,
textEl.states.emphasis,
LABEL_LAYOUT_PROPS,
);
}
animateLabelValue(textEl, dataIndex, data, seriesModel, seriesModel);
}
if (guideLine && !guideLine.ignore && !guideLine.invisible) {
var layoutStore = labelLineAnimationStore(guideLine);
var oldLayout = layoutStore.oldLayout;
var newLayout = {
points: guideLine.shape.points,
};
if (!oldLayout) {
guideLine.setShape(newLayout);
guideLine.style.strokePercent = 0;
initProps(
guideLine,
{
style: {
strokePercent: 1,
},
},
seriesModel,
);
} else {
guideLine.attr({
shape: oldLayout,
});
updateProps(
guideLine,
{
shape: newLayout,
},
seriesModel,
);
}
layoutStore.oldLayout = newLayout;
}
};
return LabelManager;
})();
var getLabelManager = makeInner();
function installLabelLayout(registers) {
registers.registerUpdateLifecycle(
"series:beforeupdate",
function (ecModel, api, params) {
// TODO api provide an namespace that can save stuff per instance
var labelManager = getLabelManager(api).labelManager;
if (!labelManager) {
labelManager = getLabelManager(api).labelManager = new LabelManager();
}
labelManager.clearLabels();
},
);
registers.registerUpdateLifecycle(
"series:layoutlabels",
function (ecModel, api, params) {
var labelManager = getLabelManager(api).labelManager;
params.updatedSeries.forEach(function (series) {
labelManager.addLabelsOfSeries(api.getViewOfSeriesModel(series));
});
labelManager.updateLayoutConfig(api);
labelManager.layout(api);
labelManager.processLabelsOverall();
},
);
}
var mathSin$4 = Math.sin;
var mathCos$4 = Math.cos;
var PI$4 = Math.PI;
var PI2$7 = Math.PI * 2;
var degree = 180 / PI$4;
var SVGPathRebuilder = (function () {
function SVGPathRebuilder() {}
SVGPathRebuilder.prototype.reset = function (precision) {
this._start = true;
this._d = [];
this._str = "";
this._p = Math.pow(10, precision || 4);
};
SVGPathRebuilder.prototype.moveTo = function (x, y) {
this._add("M", x, y);
};
SVGPathRebuilder.prototype.lineTo = function (x, y) {
this._add("L", x, y);
};
SVGPathRebuilder.prototype.bezierCurveTo = function (x, y, x2, y2, x3, y3) {
this._add("C", x, y, x2, y2, x3, y3);
};
SVGPathRebuilder.prototype.quadraticCurveTo = function (x, y, x2, y2) {
this._add("Q", x, y, x2, y2);
};
SVGPathRebuilder.prototype.arc = function (
cx,
cy,
r,
startAngle,
endAngle,
anticlockwise,
) {
this.ellipse(cx, cy, r, r, 0, startAngle, endAngle, anticlockwise);
};
SVGPathRebuilder.prototype.ellipse = function (
cx,
cy,
rx,
ry,
psi,
startAngle,
endAngle,
anticlockwise,
) {
var dTheta = endAngle - startAngle;
var clockwise = !anticlockwise;
var dThetaPositive = Math.abs(dTheta);
var isCircle =
isAroundZero$1(dThetaPositive - PI2$7) ||
(clockwise ? dTheta >= PI2$7 : -dTheta >= PI2$7);
var unifiedTheta = dTheta > 0 ? dTheta % PI2$7 : (dTheta % PI2$7) + PI2$7;
var large = false;
if (isCircle) {
large = true;
} else if (isAroundZero$1(dThetaPositive)) {
large = false;
} else {
large = unifiedTheta >= PI$4 === !!clockwise;
}
var x0 = cx + rx * mathCos$4(startAngle);
var y0 = cy + ry * mathSin$4(startAngle);
if (this._start) {
this._add("M", x0, y0);
}
var xRot = Math.round(psi * degree);
if (isCircle) {
var p = 1 / this._p;
var dTheta_1 = (clockwise ? 1 : -1) * (PI2$7 - p);
this._add(
"A",
rx,
ry,
xRot,
1,
+clockwise,
cx + rx * mathCos$4(startAngle + dTheta_1),
cy + ry * mathSin$4(startAngle + dTheta_1),
);
if (p > 1e-2) {
this._add("A", rx, ry, xRot, 0, +clockwise, x0, y0);
}
} else {
var x = cx + rx * mathCos$4(endAngle);
var y = cy + ry * mathSin$4(endAngle);
this._add("A", rx, ry, xRot, +large, +clockwise, x, y);
}
};
SVGPathRebuilder.prototype.rect = function (x, y, w, h) {
this._add("M", x, y);
this._add("l", w, 0);
this._add("l", 0, h);
this._add("l", -w, 0);
this._add("Z");
};
SVGPathRebuilder.prototype.closePath = function () {
if (this._d.length > 0) {
this._add("Z");
}
};
SVGPathRebuilder.prototype._add = function (cmd, a, b, c, d, e, f, g, h) {
var vals = [];
var p = this._p;
for (var i = 1; i < arguments.length; i++) {
var val = arguments[i];
if (isNaN(val)) {
this._invalid = true;
return;
}
vals.push(Math.round(val * p) / p);
}
this._d.push(cmd + vals.join(" "));
this._start = cmd === "Z";
};
SVGPathRebuilder.prototype.generateStr = function () {
this._str = this._invalid ? "" : this._d.join("");
this._d = [];
};
SVGPathRebuilder.prototype.getStr = function () {
return this._str;
};
return SVGPathRebuilder;
})();
var NONE = "none";
var mathRound$1 = Math.round;
function pathHasFill(style) {
var fill = style.fill;
return fill != null && fill !== NONE;
}
function pathHasStroke(style) {
var stroke = style.stroke;
return stroke != null && stroke !== NONE;
}
var strokeProps = ["lineCap", "miterLimit", "lineJoin"];
var svgStrokeProps = map(strokeProps, function (prop) {
return "stroke-" + prop.toLowerCase();
});
function mapStyleToAttrs(updateAttr, style, el, forceUpdate) {
var opacity = style.opacity == null ? 1 : style.opacity;
if (el instanceof ZRImage) {
updateAttr("opacity", opacity);
return;
}
if (pathHasFill(style)) {
var fill = normalizeColor(style.fill);
updateAttr("fill", fill.color);
var fillOpacity =
style.fillOpacity != null
? style.fillOpacity * fill.opacity * opacity
: fill.opacity * opacity;
if (forceUpdate || fillOpacity < 1) {
updateAttr("fill-opacity", fillOpacity);
}
} else {
updateAttr("fill", NONE);
}
if (pathHasStroke(style)) {
var stroke = normalizeColor(style.stroke);
updateAttr("stroke", stroke.color);
var strokeScale = style.strokeNoScale ? el.getLineScale() : 1;
var strokeWidth = strokeScale ? (style.lineWidth || 0) / strokeScale : 0;
var strokeOpacity =
style.strokeOpacity != null
? style.strokeOpacity * stroke.opacity * opacity
: stroke.opacity * opacity;
var strokeFirst = style.strokeFirst;
if (forceUpdate || strokeWidth !== 1) {
updateAttr("stroke-width", strokeWidth);
}
if (forceUpdate || strokeFirst) {
updateAttr("paint-order", strokeFirst ? "stroke" : "fill");
}
if (forceUpdate || strokeOpacity < 1) {
updateAttr("stroke-opacity", strokeOpacity);
}
if (style.lineDash) {
var _a = getLineDash(el),
lineDash = _a[0],
lineDashOffset = _a[1];
if (lineDash) {
lineDashOffset = mathRound$1(lineDashOffset || 0);
updateAttr("stroke-dasharray", lineDash.join(","));
if (lineDashOffset || forceUpdate) {
updateAttr("stroke-dashoffset", lineDashOffset);
}
}
} else if (forceUpdate) {
updateAttr("stroke-dasharray", NONE);
}
for (var i = 0; i < strokeProps.length; i++) {
var propName = strokeProps[i];
if (forceUpdate || style[propName] !== DEFAULT_PATH_STYLE[propName]) {
var val = style[propName] || DEFAULT_PATH_STYLE[propName];
val && updateAttr(svgStrokeProps[i], val);
}
}
} else if (forceUpdate) {
updateAttr("stroke", NONE);
}
}
var SVGNS = "http://www.w3.org/2000/svg";
var XLINKNS = "http://www.w3.org/1999/xlink";
var XMLNS = "http://www.w3.org/2000/xmlns/";
var XML_NAMESPACE = "http://www.w3.org/XML/1998/namespace";
function createElement(name) {
return document.createElementNS(SVGNS, name);
}
function createVNode(tag, key, attrs, children, text) {
return {
tag: tag,
attrs: attrs || {},
children: children,
text: text,
key: key,
};
}
function createElementOpen(name, attrs) {
var attrsStr = [];
if (attrs) {
for (var key in attrs) {
var val = attrs[key];
var part = key;
if (val === false) {
continue;
} else if (val !== true && val != null) {
part += '="' + val + '"';
}
attrsStr.push(part);
}
}
return "<" + name + " " + attrsStr.join(" ") + ">";
}
function createElementClose(name) {
return "";
}
function vNodeToString(el, opts) {
opts = opts || {};
var S = opts.newline ? "\n" : "";
function convertElToString(el) {
var children = el.children,
tag = el.tag,
attrs = el.attrs;
return (
createElementOpen(tag, attrs) +
(el.text || "") +
(children
? "" +
S +
map(children, function (child) {
return convertElToString(child);
}).join(S) +
S
: "") +
createElementClose(tag)
);
}
return convertElToString(el);
}
function getCssString(selectorNodes, animationNodes, opts) {
opts = opts || {};
var S = opts.newline ? "\n" : "";
var bracketBegin = " {" + S;
var bracketEnd = S + "}";
var selectors = map(keys(selectorNodes), function (className) {
return (
className +
bracketBegin +
map(keys(selectorNodes[className]), function (attrName) {
return attrName + ":" + selectorNodes[className][attrName] + ";";
}).join(S) +
bracketEnd
);
}).join(S);
var animations = map(keys(animationNodes), function (animationName) {
return (
"@keyframes " +
animationName +
bracketBegin +
map(keys(animationNodes[animationName]), function (percent) {
return (
percent +
bracketBegin +
map(
keys(animationNodes[animationName][percent]),
function (attrName) {
var val = animationNodes[animationName][percent][attrName];
if (attrName === "d") {
val = 'path("' + val + '")';
}
return attrName + ":" + val + ";";
},
).join(S) +
bracketEnd
);
}).join(S) +
bracketEnd
);
}).join(S);
if (!selectors && !animations) {
return "";
}
return [""].join(S);
}
function createBrushScope(zrId) {
return {
zrId: zrId,
shadowCache: {},
patternCache: {},
gradientCache: {},
clipPathCache: {},
defs: {},
cssNodes: {},
cssAnims: {},
cssClassIdx: 0,
cssAnimIdx: 0,
shadowIdx: 0,
gradientIdx: 0,
patternIdx: 0,
clipPathIdx: 0,
};
}
function createSVGVNode(width, height, children, useViewBox) {
return createVNode(
"svg",
"root",
{
width: width,
height: height,
xmlns: SVGNS,
"xmlns:xlink": XLINKNS,
version: "1.1",
baseProfile: "full",
viewBox: useViewBox ? "0 0 " + width + " " + height : false,
},
children,
);
}
var EASING_MAP = {
cubicIn: "0.32,0,0.67,0",
cubicOut: "0.33,1,0.68,1",
cubicInOut: "0.65,0,0.35,1",
quadraticIn: "0.11,0,0.5,0",
quadraticOut: "0.5,1,0.89,1",
quadraticInOut: "0.45,0,0.55,1",
quarticIn: "0.5,0,0.75,0",
quarticOut: "0.25,1,0.5,1",
quarticInOut: "0.76,0,0.24,1",
quinticIn: "0.64,0,0.78,0",
quinticOut: "0.22,1,0.36,1",
quinticInOut: "0.83,0,0.17,1",
sinusoidalIn: "0.12,0,0.39,0",
sinusoidalOut: "0.61,1,0.88,1",
sinusoidalInOut: "0.37,0,0.63,1",
exponentialIn: "0.7,0,0.84,0",
exponentialOut: "0.16,1,0.3,1",
exponentialInOut: "0.87,0,0.13,1",
circularIn: "0.55,0,1,0.45",
circularOut: "0,0.55,0.45,1",
circularInOut: "0.85,0,0.15,1",
};
var transformOriginKey = "transform-origin";
function buildPathString(el, kfShape, path) {
var shape = extend({}, el.shape);
extend(shape, kfShape);
el.buildPath(path, shape);
var svgPathBuilder = new SVGPathRebuilder();
svgPathBuilder.reset(getPathPrecision(el));
path.rebuildPath(svgPathBuilder, 1);
svgPathBuilder.generateStr();
return svgPathBuilder.getStr();
}
function setTransformOrigin(target, transform) {
var originX = transform.originX,
originY = transform.originY;
if (originX || originY) {
target[transformOriginKey] = originX + "px " + originY + "px";
}
}
var ANIMATE_STYLE_MAP = {
fill: "fill",
opacity: "opacity",
lineWidth: "stroke-width",
lineDashOffset: "stroke-dashoffset",
};
function addAnimation(cssAnim, scope) {
var animationName = scope.zrId + "-ani-" + scope.cssAnimIdx++;
scope.cssAnims[animationName] = cssAnim;
return animationName;
}
function createCompoundPathCSSAnimation(el, attrs, scope) {
var paths = el.shape.paths;
var composedAnim = {};
var cssAnimationCfg;
var cssAnimationName;
each(paths, function (path) {
var subScope = createBrushScope(scope.zrId);
subScope.animation = true;
createCSSAnimation(path, {}, subScope, true);
var cssAnims = subScope.cssAnims;
var cssNodes = subScope.cssNodes;
var animNames = keys(cssAnims);
var len = animNames.length;
if (!len) {
return;
}
cssAnimationName = animNames[len - 1];
var lastAnim = cssAnims[cssAnimationName];
for (var percent in lastAnim) {
var kf = lastAnim[percent];
composedAnim[percent] = composedAnim[percent] || { d: "" };
composedAnim[percent].d += kf.d || "";
}
for (var className in cssNodes) {
var val = cssNodes[className].animation;
if (val.indexOf(cssAnimationName) >= 0) {
cssAnimationCfg = val;
}
}
});
if (!cssAnimationCfg) {
return;
}
attrs.d = false;
var animationName = addAnimation(composedAnim, scope);
return cssAnimationCfg.replace(cssAnimationName, animationName);
}
function getEasingFunc(easing) {
return isString(easing)
? EASING_MAP[easing]
? "cubic-bezier(" + EASING_MAP[easing] + ")"
: createCubicEasingFunc(easing)
? easing
: ""
: "";
}
function createCSSAnimation(el, attrs, scope, onlyShape) {
var animators = el.animators;
var len = animators.length;
var cssAnimations = [];
if (el instanceof CompoundPath) {
var animationCfg = createCompoundPathCSSAnimation(el, attrs, scope);
if (animationCfg) {
cssAnimations.push(animationCfg);
} else if (!len) {
return;
}
} else if (!len) {
return;
}
var groupAnimators = {};
for (var i = 0; i < len; i++) {
var animator = animators[i];
var cfgArr = [animator.getMaxTime() / 1000 + "s"];
var easing = getEasingFunc(animator.getClip().easing);
var delay = animator.getDelay();
if (easing) {
cfgArr.push(easing);
} else {
cfgArr.push("linear");
}
if (delay) {
cfgArr.push(delay / 1000 + "s");
}
if (animator.getLoop()) {
cfgArr.push("infinite");
}
var cfg = cfgArr.join(" ");
groupAnimators[cfg] = groupAnimators[cfg] || [cfg, []];
groupAnimators[cfg][1].push(animator);
}
function createSingleCSSAnimation(groupAnimator) {
var animators = groupAnimator[1];
var len = animators.length;
var transformKfs = {};
var shapeKfs = {};
var finalKfs = {};
var animationTimingFunctionAttrName = "animation-timing-function";
function saveAnimatorTrackToCssKfs(animator, cssKfs, toCssAttrName) {
var tracks = animator.getTracks();
var maxTime = animator.getMaxTime();
for (var k = 0; k < tracks.length; k++) {
var track = tracks[k];
if (track.needsAnimate()) {
var kfs = track.keyframes;
var attrName = track.propName;
toCssAttrName && (attrName = toCssAttrName(attrName));
if (attrName) {
for (var i = 0; i < kfs.length; i++) {
var kf = kfs[i];
var percent = Math.round((kf.time / maxTime) * 100) + "%";
var kfEasing = getEasingFunc(kf.easing);
var rawValue = kf.rawValue;
if (isString(rawValue) || isNumber(rawValue)) {
cssKfs[percent] = cssKfs[percent] || {};
cssKfs[percent][attrName] = kf.rawValue;
if (kfEasing) {
cssKfs[percent][animationTimingFunctionAttrName] = kfEasing;
}
}
}
}
}
}
}
for (var i = 0; i < len; i++) {
var animator = animators[i];
var targetProp = animator.targetName;
if (!targetProp) {
!onlyShape && saveAnimatorTrackToCssKfs(animator, transformKfs);
} else if (targetProp === "shape") {
saveAnimatorTrackToCssKfs(animator, shapeKfs);
}
}
for (var percent in transformKfs) {
var transform = {};
copyTransform(transform, el);
extend(transform, transformKfs[percent]);
var str = getSRTTransformString(transform);
var timingFunction =
transformKfs[percent][animationTimingFunctionAttrName];
finalKfs[percent] = str
? {
transform: str,
}
: {};
setTransformOrigin(finalKfs[percent], transform);
if (timingFunction) {
finalKfs[percent][animationTimingFunctionAttrName] = timingFunction;
}
}
var path;
var canAnimateShape = true;
for (var percent in shapeKfs) {
finalKfs[percent] = finalKfs[percent] || {};
var isFirst = !path;
var timingFunction = shapeKfs[percent][animationTimingFunctionAttrName];
if (isFirst) {
path = new PathProxy();
}
var len_1 = path.len();
path.reset();
finalKfs[percent].d = buildPathString(el, shapeKfs[percent], path);
var newLen = path.len();
if (!isFirst && len_1 !== newLen) {
canAnimateShape = false;
break;
}
if (timingFunction) {
finalKfs[percent][animationTimingFunctionAttrName] = timingFunction;
}
}
if (!canAnimateShape) {
for (var percent in finalKfs) {
delete finalKfs[percent].d;
}
}
if (!onlyShape) {
for (var i = 0; i < len; i++) {
var animator = animators[i];
var targetProp = animator.targetName;
if (targetProp === "style") {
saveAnimatorTrackToCssKfs(animator, finalKfs, function (propName) {
return ANIMATE_STYLE_MAP[propName];
});
}
}
}
var percents = keys(finalKfs);
var allTransformOriginSame = true;
var transformOrigin;
for (var i = 1; i < percents.length; i++) {
var p0 = percents[i - 1];
var p1 = percents[i];
if (
finalKfs[p0][transformOriginKey] !== finalKfs[p1][transformOriginKey]
) {
allTransformOriginSame = false;
break;
}
transformOrigin = finalKfs[p0][transformOriginKey];
}
if (allTransformOriginSame && transformOrigin) {
for (var percent in finalKfs) {
if (finalKfs[percent][transformOriginKey]) {
delete finalKfs[percent][transformOriginKey];
}
}
attrs[transformOriginKey] = transformOrigin;
}
if (
filter(percents, function (percent) {
return keys(finalKfs[percent]).length > 0;
}).length
) {
var animationName = addAnimation(finalKfs, scope);
return animationName + " " + groupAnimator[0] + " both";
}
}
for (var key in groupAnimators) {
var animationCfg = createSingleCSSAnimation(groupAnimators[key]);
if (animationCfg) {
cssAnimations.push(animationCfg);
}
}
if (cssAnimations.length) {
var className = scope.zrId + "-cls-" + scope.cssClassIdx++;
scope.cssNodes["." + className] = {
animation: cssAnimations.join(","),
};
attrs["class"] = className;
}
}
var round$2 = Math.round;
function isImageLike$1(val) {
return val && isString(val.src);
}
function isCanvasLike(val) {
return val && isFunction(val.toDataURL);
}
function setStyleAttrs(attrs, style, el, scope) {
mapStyleToAttrs(
function (key, val) {
var isFillStroke = key === "fill" || key === "stroke";
if (isFillStroke && isGradient(val)) {
setGradient(style, attrs, key, scope);
} else if (isFillStroke && isPattern(val)) {
setPattern(el, attrs, key, scope);
} else {
attrs[key] = val;
}
},
style,
el,
false,
);
setShadow(el, attrs, scope);
}
function noRotateScale(m) {
return (
isAroundZero$1(m[0] - 1) &&
isAroundZero$1(m[1]) &&
isAroundZero$1(m[2]) &&
isAroundZero$1(m[3] - 1)
);
}
function noTranslate(m) {
return isAroundZero$1(m[4]) && isAroundZero$1(m[5]);
}
function setTransform(attrs, m, compress) {
if (m && !(noTranslate(m) && noRotateScale(m))) {
var mul = compress ? 10 : 1e4;
attrs.transform = noRotateScale(m)
? "translate(" +
round$2(m[4] * mul) / mul +
" " +
round$2(m[5] * mul) / mul +
")"
: getMatrixStr(m);
}
}
function convertPolyShape(shape, attrs, mul) {
var points = shape.points;
var strArr = [];
for (var i = 0; i < points.length; i++) {
strArr.push(round$2(points[i][0] * mul) / mul);
strArr.push(round$2(points[i][1] * mul) / mul);
}
attrs.points = strArr.join(" ");
}
function validatePolyShape(shape) {
return !shape.smooth;
}
function createAttrsConvert(desc) {
var normalizedDesc = map(desc, function (item) {
return typeof item === "string" ? [item, item] : item;
});
return function (shape, attrs, mul) {
for (var i = 0; i < normalizedDesc.length; i++) {
var item = normalizedDesc[i];
var val = shape[item[0]];
if (val != null) {
attrs[item[1]] = round$2(val * mul) / mul;
}
}
};
}
var buitinShapesDef = {
circle: [createAttrsConvert(["cx", "cy", "r"])],
polyline: [convertPolyShape, validatePolyShape],
polygon: [convertPolyShape, validatePolyShape],
};
function hasShapeAnimation(el) {
var animators = el.animators;
for (var i = 0; i < animators.length; i++) {
if (animators[i].targetName === "shape") {
return true;
}
}
return false;
}
function brushSVGPath(el, scope) {
var style = el.style;
var shape = el.shape;
var builtinShpDef = buitinShapesDef[el.type];
var attrs = {};
var needsAnimate = scope.animation;
var svgElType = "path";
var strokePercent = el.style.strokePercent;
var precision = (scope.compress && getPathPrecision(el)) || 4;
if (
builtinShpDef &&
!scope.willUpdate &&
!(builtinShpDef[1] && !builtinShpDef[1](shape)) &&
!(needsAnimate && hasShapeAnimation(el)) &&
!(strokePercent < 1)
) {
svgElType = el.type;
var mul = Math.pow(10, precision);
builtinShpDef[0](shape, attrs, mul);
} else {
if (!el.path) {
el.createPathProxy();
}
var path = el.path;
if (el.shapeChanged()) {
path.beginPath();
el.buildPath(path, el.shape);
el.pathUpdated();
}
var pathVersion = path.getVersion();
var elExt = el;
var svgPathBuilder = elExt.__svgPathBuilder;
if (
elExt.__svgPathVersion !== pathVersion ||
!svgPathBuilder ||
strokePercent !== elExt.__svgPathStrokePercent
) {
if (!svgPathBuilder) {
svgPathBuilder = elExt.__svgPathBuilder = new SVGPathRebuilder();
}
svgPathBuilder.reset(precision);
path.rebuildPath(svgPathBuilder, strokePercent);
svgPathBuilder.generateStr();
elExt.__svgPathVersion = pathVersion;
elExt.__svgPathStrokePercent = strokePercent;
}
attrs.d = svgPathBuilder.getStr();
}
setTransform(attrs, el.transform);
setStyleAttrs(attrs, style, el, scope);
scope.animation && createCSSAnimation(el, attrs, scope);
return createVNode(svgElType, el.id + "", attrs);
}
function brushSVGImage(el, scope) {
var style = el.style;
var image = style.image;
if (image && !isString(image)) {
if (isImageLike$1(image)) {
image = image.src;
} else if (isCanvasLike(image)) {
image = image.toDataURL();
}
}
if (!image) {
return;
}
var x = style.x || 0;
var y = style.y || 0;
var dw = style.width;
var dh = style.height;
var attrs = {
href: image,
width: dw,
height: dh,
};
if (x) {
attrs.x = x;
}
if (y) {
attrs.y = y;
}
setTransform(attrs, el.transform);
setStyleAttrs(attrs, style, el, scope);
scope.animation && createCSSAnimation(el, attrs, scope);
return createVNode("image", el.id + "", attrs);
}
function brushSVGTSpan(el, scope) {
var style = el.style;
var text = style.text;
text != null && (text += "");
if (!text || isNaN(style.x) || isNaN(style.y)) {
return;
}
var font = style.font || DEFAULT_FONT;
var x = style.x || 0;
var y = adjustTextY(style.y || 0, getLineHeight(font), style.textBaseline);
var textAlign = TEXT_ALIGN_TO_ANCHOR[style.textAlign] || style.textAlign;
var attrs = {
"dominant-baseline": "central",
"text-anchor": textAlign,
};
if (hasSeparateFont(style)) {
var separatedFontStr = "";
var fontStyle = style.fontStyle;
var fontSize = parseFontSize(style.fontSize);
if (!parseFloat(fontSize)) {
return;
}
var fontFamily = style.fontFamily || DEFAULT_FONT_FAMILY;
var fontWeight = style.fontWeight;
separatedFontStr +=
"font-size:" + fontSize + ";font-family:" + fontFamily + ";";
if (fontStyle && fontStyle !== "normal") {
separatedFontStr += "font-style:" + fontStyle + ";";
}
if (fontWeight && fontWeight !== "normal") {
separatedFontStr += "font-weight:" + fontWeight + ";";
}
attrs.style = separatedFontStr;
} else {
attrs.style = "font: " + font;
}
if (text.match(/\s/)) {
attrs["xml:space"] = "preserve";
}
if (x) {
attrs.x = x;
}
if (y) {
attrs.y = y;
}
setTransform(attrs, el.transform);
setStyleAttrs(attrs, style, el, scope);
scope.animation && createCSSAnimation(el, attrs, scope);
return createVNode("text", el.id + "", attrs, undefined, text);
}
function brush$1(el, scope) {
if (el instanceof Path) {
return brushSVGPath(el, scope);
} else if (el instanceof ZRImage) {
return brushSVGImage(el, scope);
} else if (el instanceof TSpan) {
return brushSVGTSpan(el, scope);
}
}
function setShadow(el, attrs, scope) {
var style = el.style;
if (hasShadow(style)) {
var shadowKey = getShadowKey(el);
var shadowCache = scope.shadowCache;
var shadowId = shadowCache[shadowKey];
if (!shadowId) {
var globalScale = el.getGlobalScale();
var scaleX = globalScale[0];
var scaleY = globalScale[1];
if (!scaleX || !scaleY) {
return;
}
var offsetX = style.shadowOffsetX || 0;
var offsetY = style.shadowOffsetY || 0;
var blur_1 = style.shadowBlur;
var _a = normalizeColor(style.shadowColor),
opacity = _a.opacity,
color = _a.color;
var stdDx = blur_1 / 2 / scaleX;
var stdDy = blur_1 / 2 / scaleY;
var stdDeviation = stdDx + " " + stdDy;
shadowId = scope.zrId + "-s" + scope.shadowIdx++;
scope.defs[shadowId] = createVNode(
"filter",
shadowId,
{
id: shadowId,
x: "-100%",
y: "-100%",
width: "300%",
height: "300%",
},
[
createVNode("feDropShadow", "", {
dx: offsetX / scaleX,
dy: offsetY / scaleY,
stdDeviation: stdDeviation,
"flood-color": color,
"flood-opacity": opacity,
}),
],
);
shadowCache[shadowKey] = shadowId;
}
attrs.filter = getIdURL(shadowId);
}
}
function setGradient(style, attrs, target, scope) {
var val = style[target];
var gradientTag;
var gradientAttrs = {
gradientUnits: val.global ? "userSpaceOnUse" : "objectBoundingBox",
};
if (isLinearGradient(val)) {
gradientTag = "linearGradient";
gradientAttrs.x1 = val.x;
gradientAttrs.y1 = val.y;
gradientAttrs.x2 = val.x2;
gradientAttrs.y2 = val.y2;
} else if (isRadialGradient(val)) {
gradientTag = "radialGradient";
gradientAttrs.cx = retrieve2(val.x, 0.5);
gradientAttrs.cy = retrieve2(val.y, 0.5);
gradientAttrs.r = retrieve2(val.r, 0.5);
} else {
if ("development" !== "production") {
logError("Illegal gradient type.");
}
return;
}
var colors = val.colorStops;
var colorStops = [];
for (var i = 0, len = colors.length; i < len; ++i) {
var offset = round4(colors[i].offset) * 100 + "%";
var stopColor = colors[i].color;
var _a = normalizeColor(stopColor),
color = _a.color,
opacity = _a.opacity;
var stopsAttrs = {
offset: offset,
};
stopsAttrs["stop-color"] = color;
if (opacity < 1) {
stopsAttrs["stop-opacity"] = opacity;
}
colorStops.push(createVNode("stop", i + "", stopsAttrs));
}
var gradientVNode = createVNode(gradientTag, "", gradientAttrs, colorStops);
var gradientKey = vNodeToString(gradientVNode);
var gradientCache = scope.gradientCache;
var gradientId = gradientCache[gradientKey];
if (!gradientId) {
gradientId = scope.zrId + "-g" + scope.gradientIdx++;
gradientCache[gradientKey] = gradientId;
gradientAttrs.id = gradientId;
scope.defs[gradientId] = createVNode(
gradientTag,
gradientId,
gradientAttrs,
colorStops,
);
}
attrs[target] = getIdURL(gradientId);
}
function setPattern(el, attrs, target, scope) {
var val = el.style[target];
var patternAttrs = {
patternUnits: "userSpaceOnUse",
};
var child;
if (isImagePattern(val)) {
var imageWidth_1 = val.imageWidth;
var imageHeight_1 = val.imageHeight;
var imageSrc = void 0;
var patternImage = val.image;
if (isString(patternImage)) {
imageSrc = patternImage;
} else if (isImageLike$1(patternImage)) {
imageSrc = patternImage.src;
} else if (isCanvasLike(patternImage)) {
imageSrc = patternImage.toDataURL();
}
if (typeof Image === "undefined") {
var errMsg =
"Image width/height must been given explictly in svg-ssr renderer.";
assert(imageWidth_1, errMsg);
assert(imageHeight_1, errMsg);
} else if (imageWidth_1 == null || imageHeight_1 == null) {
var setSizeToVNode_1 = function (vNode, img) {
if (vNode) {
var svgEl = vNode.elm;
var width = (vNode.attrs.width = imageWidth_1 || img.width);
var height = (vNode.attrs.height = imageHeight_1 || img.height);
if (svgEl) {
svgEl.setAttribute("width", width);
svgEl.setAttribute("height", height);
}
}
};
var createdImage = createOrUpdateImage(
imageSrc,
null,
el,
function (img) {
setSizeToVNode_1(patternVNode, img);
setSizeToVNode_1(child, img);
},
);
if (createdImage && createdImage.width && createdImage.height) {
imageWidth_1 = imageWidth_1 || createdImage.width;
imageHeight_1 = imageHeight_1 || createdImage.height;
}
}
child = createVNode("image", "img", {
href: imageSrc,
width: imageWidth_1,
height: imageHeight_1,
});
patternAttrs.width = imageWidth_1;
patternAttrs.height = imageHeight_1;
} else if (val.svgElement) {
child = clone(val.svgElement);
patternAttrs.width = val.svgWidth;
patternAttrs.height = val.svgHeight;
}
if (!child) {
return;
}
patternAttrs.patternTransform = getSRTTransformString(val);
var patternVNode = createVNode("pattern", "", patternAttrs, [child]);
var patternKey = vNodeToString(patternVNode);
var patternCache = scope.patternCache;
var patternId = patternCache[patternKey];
if (!patternId) {
patternId = scope.zrId + "-p" + scope.patternIdx++;
patternCache[patternKey] = patternId;
patternAttrs.id = patternId;
patternVNode = scope.defs[patternId] = createVNode(
"pattern",
patternId,
patternAttrs,
[child],
);
}
attrs[target] = getIdURL(patternId);
}
function setClipPath(clipPath, attrs, scope) {
var clipPathCache = scope.clipPathCache,
defs = scope.defs;
var clipPathId = clipPathCache[clipPath.id];
if (!clipPathId) {
clipPathId = scope.zrId + "-c" + scope.clipPathIdx++;
var clipPathAttrs = {
id: clipPathId,
};
clipPathCache[clipPath.id] = clipPathId;
defs[clipPathId] = createVNode("clipPath", clipPathId, clipPathAttrs, [
brushSVGPath(clipPath, scope),
]);
}
attrs["clip-path"] = getIdURL(clipPathId);
}
function createTextNode(text) {
return document.createTextNode(text);
}
function insertBefore(parentNode, newNode, referenceNode) {
parentNode.insertBefore(newNode, referenceNode);
}
function removeChild(node, child) {
node.removeChild(child);
}
function appendChild(node, child) {
node.appendChild(child);
}
function parentNode(node) {
return node.parentNode;
}
function nextSibling(node) {
return node.nextSibling;
}
function setTextContent(node, text) {
node.textContent = text;
}
var colonChar = 58;
var xChar = 120;
var emptyNode = createVNode("", "");
function isUndef(s) {
return s === undefined;
}
function isDef(s) {
return s !== undefined;
}
function createKeyToOldIdx(children, beginIdx, endIdx) {
var map = {};
for (var i = beginIdx; i <= endIdx; ++i) {
var key = children[i].key;
if (key !== undefined) {
if ("development" !== "production") {
if (map[key] != null) {
console.error("Duplicate key " + key);
}
}
map[key] = i;
}
}
return map;
}
function sameVnode(vnode1, vnode2) {
var isSameKey = vnode1.key === vnode2.key;
var isSameTag = vnode1.tag === vnode2.tag;
return isSameTag && isSameKey;
}
function createElm(vnode) {
var i;
var children = vnode.children;
var tag = vnode.tag;
if (isDef(tag)) {
var elm = (vnode.elm = createElement(tag));
updateAttrs(emptyNode, vnode);
if (isArray(children)) {
for (i = 0; i < children.length; ++i) {
var ch = children[i];
if (ch != null) {
appendChild(elm, createElm(ch));
}
}
} else if (isDef(vnode.text) && !isObject(vnode.text)) {
appendChild(elm, createTextNode(vnode.text));
}
} else {
vnode.elm = createTextNode(vnode.text);
}
return vnode.elm;
}
function addVnodes(parentElm, before, vnodes, startIdx, endIdx) {
for (; startIdx <= endIdx; ++startIdx) {
var ch = vnodes[startIdx];
if (ch != null) {
insertBefore(parentElm, createElm(ch), before);
}
}
}
function removeVnodes(parentElm, vnodes, startIdx, endIdx) {
for (; startIdx <= endIdx; ++startIdx) {
var ch = vnodes[startIdx];
if (ch != null) {
if (isDef(ch.tag)) {
var parent_1 = parentNode(ch.elm);
removeChild(parent_1, ch.elm);
} else {
removeChild(parentElm, ch.elm);
}
}
}
}
function updateAttrs(oldVnode, vnode) {
var key;
var elm = vnode.elm;
var oldAttrs = (oldVnode && oldVnode.attrs) || {};
var attrs = vnode.attrs || {};
if (oldAttrs === attrs) {
return;
}
for (key in attrs) {
var cur = attrs[key];
var old = oldAttrs[key];
if (old !== cur) {
if (cur === true) {
elm.setAttribute(key, "");
} else if (cur === false) {
elm.removeAttribute(key);
} else {
if (key.charCodeAt(0) !== xChar) {
elm.setAttribute(key, cur);
} else if (key === "xmlns:xlink" || key === "xmlns") {
elm.setAttributeNS(XMLNS, key, cur);
} else if (key.charCodeAt(3) === colonChar) {
elm.setAttributeNS(XML_NAMESPACE, key, cur);
} else if (key.charCodeAt(5) === colonChar) {
elm.setAttributeNS(XLINKNS, key, cur);
} else {
elm.setAttribute(key, cur);
}
}
}
}
for (key in oldAttrs) {
if (!(key in attrs)) {
elm.removeAttribute(key);
}
}
}
function updateChildren(parentElm, oldCh, newCh) {
var oldStartIdx = 0;
var newStartIdx = 0;
var oldEndIdx = oldCh.length - 1;
var oldStartVnode = oldCh[0];
var oldEndVnode = oldCh[oldEndIdx];
var newEndIdx = newCh.length - 1;
var newStartVnode = newCh[0];
var newEndVnode = newCh[newEndIdx];
var oldKeyToIdx;
var idxInOld;
var elmToMove;
var before;
while (oldStartIdx <= oldEndIdx && newStartIdx <= newEndIdx) {
if (oldStartVnode == null) {
oldStartVnode = oldCh[++oldStartIdx];
} else if (oldEndVnode == null) {
oldEndVnode = oldCh[--oldEndIdx];
} else if (newStartVnode == null) {
newStartVnode = newCh[++newStartIdx];
} else if (newEndVnode == null) {
newEndVnode = newCh[--newEndIdx];
} else if (sameVnode(oldStartVnode, newStartVnode)) {
patchVnode(oldStartVnode, newStartVnode);
oldStartVnode = oldCh[++oldStartIdx];
newStartVnode = newCh[++newStartIdx];
} else if (sameVnode(oldEndVnode, newEndVnode)) {
patchVnode(oldEndVnode, newEndVnode);
oldEndVnode = oldCh[--oldEndIdx];
newEndVnode = newCh[--newEndIdx];
} else if (sameVnode(oldStartVnode, newEndVnode)) {
patchVnode(oldStartVnode, newEndVnode);
insertBefore(
parentElm,
oldStartVnode.elm,
nextSibling(oldEndVnode.elm),
);
oldStartVnode = oldCh[++oldStartIdx];
newEndVnode = newCh[--newEndIdx];
} else if (sameVnode(oldEndVnode, newStartVnode)) {
patchVnode(oldEndVnode, newStartVnode);
insertBefore(parentElm, oldEndVnode.elm, oldStartVnode.elm);
oldEndVnode = oldCh[--oldEndIdx];
newStartVnode = newCh[++newStartIdx];
} else {
if (isUndef(oldKeyToIdx)) {
oldKeyToIdx = createKeyToOldIdx(oldCh, oldStartIdx, oldEndIdx);
}
idxInOld = oldKeyToIdx[newStartVnode.key];
if (isUndef(idxInOld)) {
insertBefore(parentElm, createElm(newStartVnode), oldStartVnode.elm);
} else {
elmToMove = oldCh[idxInOld];
if (elmToMove.tag !== newStartVnode.tag) {
insertBefore(
parentElm,
createElm(newStartVnode),
oldStartVnode.elm,
);
} else {
patchVnode(elmToMove, newStartVnode);
oldCh[idxInOld] = undefined;
insertBefore(parentElm, elmToMove.elm, oldStartVnode.elm);
}
}
newStartVnode = newCh[++newStartIdx];
}
}
if (oldStartIdx <= oldEndIdx || newStartIdx <= newEndIdx) {
if (oldStartIdx > oldEndIdx) {
before = newCh[newEndIdx + 1] == null ? null : newCh[newEndIdx + 1].elm;
addVnodes(parentElm, before, newCh, newStartIdx, newEndIdx);
} else {
removeVnodes(parentElm, oldCh, oldStartIdx, oldEndIdx);
}
}
}
function patchVnode(oldVnode, vnode) {
var elm = (vnode.elm = oldVnode.elm);
var oldCh = oldVnode.children;
var ch = vnode.children;
if (oldVnode === vnode) {
return;
}
updateAttrs(oldVnode, vnode);
if (isUndef(vnode.text)) {
if (isDef(oldCh) && isDef(ch)) {
if (oldCh !== ch) {
updateChildren(elm, oldCh, ch);
}
} else if (isDef(ch)) {
if (isDef(oldVnode.text)) {
setTextContent(elm, "");
}
addVnodes(elm, null, ch, 0, ch.length - 1);
} else if (isDef(oldCh)) {
removeVnodes(elm, oldCh, 0, oldCh.length - 1);
} else if (isDef(oldVnode.text)) {
setTextContent(elm, "");
}
} else if (oldVnode.text !== vnode.text) {
if (isDef(oldCh)) {
removeVnodes(elm, oldCh, 0, oldCh.length - 1);
}
setTextContent(elm, vnode.text);
}
}
function patch(oldVnode, vnode) {
if (sameVnode(oldVnode, vnode)) {
patchVnode(oldVnode, vnode);
} else {
var elm = oldVnode.elm;
var parent_2 = parentNode(elm);
createElm(vnode);
if (parent_2 !== null) {
insertBefore(parent_2, vnode.elm, nextSibling(elm));
removeVnodes(parent_2, [oldVnode], 0, 0);
}
}
return vnode;
}
var svgId = 0;
var SVGPainter = (function () {
function SVGPainter(root, storage, opts) {
this.type = "svg";
this.refreshHover = createMethodNotSupport("refreshHover");
this.configLayer = createMethodNotSupport("configLayer");
this.storage = storage;
this._opts = opts = extend({}, opts);
this.root = root;
this._id = "zr" + svgId++;
this._oldVNode = createSVGVNode(opts.width, opts.height);
if (root && !opts.ssr) {
var viewport = (this._viewport = document.createElement("div"));
viewport.style.cssText = "position:relative;overflow:hidden";
var svgDom = (this._svgDom = this._oldVNode.elm = createElement("svg"));
updateAttrs(null, this._oldVNode);
viewport.appendChild(svgDom);
root.appendChild(viewport);
}
this.resize(opts.width, opts.height);
}
SVGPainter.prototype.getType = function () {
return this.type;
};
SVGPainter.prototype.getViewportRoot = function () {
return this._viewport;
};
SVGPainter.prototype.getViewportRootOffset = function () {
var viewportRoot = this.getViewportRoot();
if (viewportRoot) {
return {
offsetLeft: viewportRoot.offsetLeft || 0,
offsetTop: viewportRoot.offsetTop || 0,
};
}
};
SVGPainter.prototype.getSvgDom = function () {
return this._svgDom;
};
SVGPainter.prototype.refresh = function () {
if (this.root) {
var vnode = this.renderToVNode({
willUpdate: true,
});
vnode.attrs.style = "position:absolute;left:0;top:0;user-select:none";
patch(this._oldVNode, vnode);
this._oldVNode = vnode;
}
};
SVGPainter.prototype.renderOneToVNode = function (el) {
return brush$1(el, createBrushScope(this._id));
};
SVGPainter.prototype.renderToVNode = function (opts) {
opts = opts || {};
var list = this.storage.getDisplayList(true);
var bgColor = this._backgroundColor;
var width = this._width;
var height = this._height;
var scope = createBrushScope(this._id);
scope.animation = opts.animation;
scope.willUpdate = opts.willUpdate;
scope.compress = opts.compress;
var children = [];
if (bgColor && bgColor !== "none") {
var _a = normalizeColor(bgColor),
color = _a.color,
opacity = _a.opacity;
this._bgVNode = createVNode("rect", "bg", {
width: width,
height: height,
x: "0",
y: "0",
id: "0",
fill: color,
"fill-opacity": opacity,
});
children.push(this._bgVNode);
} else {
this._bgVNode = null;
}
var mainVNode = !opts.compress
? (this._mainVNode = createVNode("g", "main", {}, []))
: null;
this._paintList(list, scope, mainVNode ? mainVNode.children : children);
mainVNode && children.push(mainVNode);
var defs = map(keys(scope.defs), function (id) {
return scope.defs[id];
});
if (defs.length) {
children.push(createVNode("defs", "defs", {}, defs));
}
if (opts.animation) {
var animationCssStr = getCssString(scope.cssNodes, scope.cssAnims, {
newline: true,
});
if (animationCssStr) {
var styleNode = createVNode("style", "stl", {}, [], animationCssStr);
children.push(styleNode);
}
}
return createSVGVNode(width, height, children, opts.useViewBox);
};
SVGPainter.prototype.renderToString = function (opts) {
opts = opts || {};
return vNodeToString(
this.renderToVNode({
animation: retrieve2(opts.cssAnimation, true),
willUpdate: false,
compress: true,
useViewBox: retrieve2(opts.useViewBox, true),
}),
{ newline: true },
);
};
SVGPainter.prototype.setBackgroundColor = function (backgroundColor) {
this._backgroundColor = backgroundColor;
var bgVNode = this._bgVNode;
if (bgVNode && bgVNode.elm) {
var _a = normalizeColor(backgroundColor),
color = _a.color,
opacity = _a.opacity;
bgVNode.elm.setAttribute("fill", color);
if (opacity < 1) {
bgVNode.elm.setAttribute("fill-opacity", opacity);
}
}
};
SVGPainter.prototype.getSvgRoot = function () {
return this._mainVNode && this._mainVNode.elm;
};
SVGPainter.prototype._paintList = function (list, scope, out) {
var listLen = list.length;
var clipPathsGroupsStack = [];
var clipPathsGroupsStackDepth = 0;
var currentClipPathGroup;
var prevClipPaths;
var clipGroupNodeIdx = 0;
for (var i = 0; i < listLen; i++) {
var displayable = list[i];
if (!displayable.invisible) {
var clipPaths = displayable.__clipPaths;
var len = (clipPaths && clipPaths.length) || 0;
var prevLen = (prevClipPaths && prevClipPaths.length) || 0;
var lca = void 0;
for (lca = Math.max(len - 1, prevLen - 1); lca >= 0; lca--) {
if (
clipPaths &&
prevClipPaths &&
clipPaths[lca] === prevClipPaths[lca]
) {
break;
}
}
for (var i_1 = prevLen - 1; i_1 > lca; i_1--) {
clipPathsGroupsStackDepth--;
currentClipPathGroup =
clipPathsGroupsStack[clipPathsGroupsStackDepth - 1];
}
for (var i_2 = lca + 1; i_2 < len; i_2++) {
var groupAttrs = {};
setClipPath(clipPaths[i_2], groupAttrs, scope);
var g = createVNode(
"g",
"clip-g-" + clipGroupNodeIdx++,
groupAttrs,
[],
);
(currentClipPathGroup ? currentClipPathGroup.children : out).push(
g,
);
clipPathsGroupsStack[clipPathsGroupsStackDepth++] = g;
currentClipPathGroup = g;
}
prevClipPaths = clipPaths;
var ret = brush$1(displayable, scope);
if (ret) {
(currentClipPathGroup ? currentClipPathGroup.children : out).push(
ret,
);
}
}
}
};
SVGPainter.prototype.resize = function (width, height) {
var opts = this._opts;
var root = this.root;
var viewport = this._viewport;
width != null && (opts.width = width);
height != null && (opts.height = height);
if (root && viewport) {
viewport.style.display = "none";
width = getSize(root, 0, opts);
height = getSize(root, 1, opts);
viewport.style.display = "";
}
if (this._width !== width || this._height !== height) {
this._width = width;
this._height = height;
if (viewport) {
var viewportStyle = viewport.style;
viewportStyle.width = width + "px";
viewportStyle.height = height + "px";
}
var svgDom = this._svgDom;
if (svgDom) {
svgDom.setAttribute("width", width);
svgDom.setAttribute("height", height);
}
}
};
SVGPainter.prototype.getWidth = function () {
return this._width;
};
SVGPainter.prototype.getHeight = function () {
return this._height;
};
SVGPainter.prototype.dispose = function () {
if (this.root) {
this.root.innerHTML = "";
}
this._svgDom =
this._viewport =
this.storage =
this._oldVNode =
this._bgVNode =
this._mainVNode =
null;
};
SVGPainter.prototype.clear = function () {
if (this._svgDom) {
this._svgDom.innerHTML = null;
}
this._oldVNode = null;
};
SVGPainter.prototype.toDataURL = function (base64) {
var str = encodeURIComponent(this.renderToString());
var prefix = "data:image/svg+xml;";
if (base64) {
str = encodeBase64(str);
return str && prefix + "base64," + str;
}
return prefix + "charset=UTF-8," + str;
};
return SVGPainter;
})();
function createMethodNotSupport(method) {
return function () {
if ("development" !== "production") {
logError('In SVG mode painter not support method "' + method + '"');
}
};
}
function install(registers) {
registers.registerPainter("svg", SVGPainter);
}
function createDom(id, painter, dpr) {
var newDom = platformApi.createCanvas();
var width = painter.getWidth();
var height = painter.getHeight();
var newDomStyle = newDom.style;
if (newDomStyle) {
newDomStyle.position = "absolute";
newDomStyle.left = "0";
newDomStyle.top = "0";
newDomStyle.width = width + "px";
newDomStyle.height = height + "px";
newDom.setAttribute("data-zr-dom-id", id);
}
newDom.width = width * dpr;
newDom.height = height * dpr;
return newDom;
}
var Layer = (function (_super) {
__extends(Layer, _super);
function Layer(id, painter, dpr) {
var _this = _super.call(this) || this;
_this.motionBlur = false;
_this.lastFrameAlpha = 0.7;
_this.dpr = 1;
_this.virtual = false;
_this.config = {};
_this.incremental = false;
_this.zlevel = 0;
_this.maxRepaintRectCount = 5;
_this.__dirty = true;
_this.__firstTimePaint = true;
_this.__used = false;
_this.__drawIndex = 0;
_this.__startIndex = 0;
_this.__endIndex = 0;
_this.__prevStartIndex = null;
_this.__prevEndIndex = null;
var dom;
dpr = dpr || devicePixelRatio;
if (typeof id === "string") {
dom = createDom(id, painter, dpr);
} else if (isObject(id)) {
dom = id;
id = dom.id;
}
_this.id = id;
_this.dom = dom;
var domStyle = dom.style;
if (domStyle) {
disableUserSelect(dom);
dom.onselectstart = function () {
return false;
};
domStyle.padding = "0";
domStyle.margin = "0";
domStyle.borderWidth = "0";
}
_this.painter = painter;
_this.dpr = dpr;
return _this;
}
Layer.prototype.getElementCount = function () {
return this.__endIndex - this.__startIndex;
};
Layer.prototype.afterBrush = function () {
this.__prevStartIndex = this.__startIndex;
this.__prevEndIndex = this.__endIndex;
};
Layer.prototype.initContext = function () {
this.ctx = this.dom.getContext("2d");
this.ctx.dpr = this.dpr;
};
Layer.prototype.setUnpainted = function () {
this.__firstTimePaint = true;
};
Layer.prototype.createBackBuffer = function () {
var dpr = this.dpr;
this.domBack = createDom("back-" + this.id, this.painter, dpr);
this.ctxBack = this.domBack.getContext("2d");
if (dpr !== 1) {
this.ctxBack.scale(dpr, dpr);
}
};
Layer.prototype.createRepaintRects = function (
displayList,
prevList,
viewWidth,
viewHeight,
) {
if (this.__firstTimePaint) {
this.__firstTimePaint = false;
return null;
}
var mergedRepaintRects = [];
var maxRepaintRectCount = this.maxRepaintRectCount;
var full = false;
var pendingRect = new BoundingRect(0, 0, 0, 0);
function addRectToMergePool(rect) {
if (!rect.isFinite() || rect.isZero()) {
return;
}
if (mergedRepaintRects.length === 0) {
var boundingRect = new BoundingRect(0, 0, 0, 0);
boundingRect.copy(rect);
mergedRepaintRects.push(boundingRect);
} else {
var isMerged = false;
var minDeltaArea = Infinity;
var bestRectToMergeIdx = 0;
for (var i = 0; i < mergedRepaintRects.length; ++i) {
var mergedRect = mergedRepaintRects[i];
if (mergedRect.intersect(rect)) {
var pendingRect_1 = new BoundingRect(0, 0, 0, 0);
pendingRect_1.copy(mergedRect);
pendingRect_1.union(rect);
mergedRepaintRects[i] = pendingRect_1;
isMerged = true;
break;
} else if (full) {
pendingRect.copy(rect);
pendingRect.union(mergedRect);
var aArea = rect.width * rect.height;
var bArea = mergedRect.width * mergedRect.height;
var pendingArea = pendingRect.width * pendingRect.height;
var deltaArea = pendingArea - aArea - bArea;
if (deltaArea < minDeltaArea) {
minDeltaArea = deltaArea;
bestRectToMergeIdx = i;
}
}
}
if (full) {
mergedRepaintRects[bestRectToMergeIdx].union(rect);
isMerged = true;
}
if (!isMerged) {
var boundingRect = new BoundingRect(0, 0, 0, 0);
boundingRect.copy(rect);
mergedRepaintRects.push(boundingRect);
}
if (!full) {
full = mergedRepaintRects.length >= maxRepaintRectCount;
}
}
}
for (var i = this.__startIndex; i < this.__endIndex; ++i) {
var el = displayList[i];
if (el) {
var shouldPaint = el.shouldBePainted(
viewWidth,
viewHeight,
true,
true,
);
var prevRect =
el.__isRendered && (el.__dirty & REDRAW_BIT || !shouldPaint)
? el.getPrevPaintRect()
: null;
if (prevRect) {
addRectToMergePool(prevRect);
}
var curRect =
shouldPaint && (el.__dirty & REDRAW_BIT || !el.__isRendered)
? el.getPaintRect()
: null;
if (curRect) {
addRectToMergePool(curRect);
}
}
}
for (var i = this.__prevStartIndex; i < this.__prevEndIndex; ++i) {
var el = prevList[i];
var shouldPaint = el.shouldBePainted(viewWidth, viewHeight, true, true);
if (el && (!shouldPaint || !el.__zr) && el.__isRendered) {
var prevRect = el.getPrevPaintRect();
if (prevRect) {
addRectToMergePool(prevRect);
}
}
}
var hasIntersections;
do {
hasIntersections = false;
for (var i = 0; i < mergedRepaintRects.length; ) {
if (mergedRepaintRects[i].isZero()) {
mergedRepaintRects.splice(i, 1);
continue;
}
for (var j = i + 1; j < mergedRepaintRects.length; ) {
if (mergedRepaintRects[i].intersect(mergedRepaintRects[j])) {
hasIntersections = true;
mergedRepaintRects[i].union(mergedRepaintRects[j]);
mergedRepaintRects.splice(j, 1);
} else {
j++;
}
}
i++;
}
} while (hasIntersections);
this._paintRects = mergedRepaintRects;
return mergedRepaintRects;
};
Layer.prototype.debugGetPaintRects = function () {
return (this._paintRects || []).slice();
};
Layer.prototype.resize = function (width, height) {
var dpr = this.dpr;
var dom = this.dom;
var domStyle = dom.style;
var domBack = this.domBack;
if (domStyle) {
domStyle.width = width + "px";
domStyle.height = height + "px";
}
dom.width = width * dpr;
dom.height = height * dpr;
if (domBack) {
domBack.width = width * dpr;
domBack.height = height * dpr;
if (dpr !== 1) {
this.ctxBack.scale(dpr, dpr);
}
}
};
Layer.prototype.clear = function (clearAll, clearColor, repaintRects) {
var dom = this.dom;
var ctx = this.ctx;
var width = dom.width;
var height = dom.height;
clearColor = clearColor || this.clearColor;
var haveMotionBLur = this.motionBlur && !clearAll;
var lastFrameAlpha = this.lastFrameAlpha;
var dpr = this.dpr;
var self = this;
if (haveMotionBLur) {
if (!this.domBack) {
this.createBackBuffer();
}
this.ctxBack.globalCompositeOperation = "copy";
this.ctxBack.drawImage(dom, 0, 0, width / dpr, height / dpr);
}
var domBack = this.domBack;
function doClear(x, y, width, height) {
ctx.clearRect(x, y, width, height);
if (clearColor && clearColor !== "transparent") {
var clearColorGradientOrPattern = void 0;
if (isGradientObject(clearColor)) {
clearColorGradientOrPattern =
clearColor.__canvasGradient ||
getCanvasGradient(ctx, clearColor, {
x: 0,
y: 0,
width: width,
height: height,
});
clearColor.__canvasGradient = clearColorGradientOrPattern;
} else if (isImagePatternObject(clearColor)) {
clearColorGradientOrPattern = createCanvasPattern(ctx, clearColor, {
dirty: function () {
self.setUnpainted();
self.__painter.refresh();
},
});
}
ctx.save();
ctx.fillStyle = clearColorGradientOrPattern || clearColor;
ctx.fillRect(x, y, width, height);
ctx.restore();
}
if (haveMotionBLur) {
ctx.save();
ctx.globalAlpha = lastFrameAlpha;
ctx.drawImage(domBack, x, y, width, height);
ctx.restore();
}
}
if (!repaintRects || haveMotionBLur) {
doClear(0, 0, width, height);
} else if (repaintRects.length) {
each(repaintRects, function (rect) {
doClear(
rect.x * dpr,
rect.y * dpr,
rect.width * dpr,
rect.height * dpr,
);
});
}
};
return Layer;
})(Eventful);
var HOVER_LAYER_ZLEVEL = 1e5;
var CANVAS_ZLEVEL = 314159;
var EL_AFTER_INCREMENTAL_INC = 0.01;
var INCREMENTAL_INC = 0.001;
function isLayerValid(layer) {
if (!layer) {
return false;
}
if (layer.__builtin__) {
return true;
}
if (
typeof layer.resize !== "function" ||
typeof layer.refresh !== "function"
) {
return false;
}
return true;
}
function createRoot(width, height) {
var domRoot = document.createElement("div");
domRoot.style.cssText =
[
"position:relative",
"width:" + width + "px",
"height:" + height + "px",
"padding:0",
"margin:0",
"border-width:0",
].join(";") + ";";
return domRoot;
}
var CanvasPainter = (function () {
function CanvasPainter(root, storage, opts, id) {
this.type = "canvas";
this._zlevelList = [];
this._prevDisplayList = [];
this._layers = {};
this._layerConfig = {};
this._needsManuallyCompositing = false;
this.type = "canvas";
var singleCanvas =
!root.nodeName || root.nodeName.toUpperCase() === "CANVAS";
this._opts = opts = extend({}, opts || {});
this.dpr = opts.devicePixelRatio || devicePixelRatio;
this._singleCanvas = singleCanvas;
this.root = root;
var rootStyle = root.style;
if (rootStyle) {
disableUserSelect(root);
root.innerHTML = "";
}
this.storage = storage;
var zlevelList = this._zlevelList;
this._prevDisplayList = [];
var layers = this._layers;
if (!singleCanvas) {
this._width = getSize(root, 0, opts);
this._height = getSize(root, 1, opts);
var domRoot = (this._domRoot = createRoot(this._width, this._height));
root.appendChild(domRoot);
} else {
var rootCanvas = root;
var width = rootCanvas.width;
var height = rootCanvas.height;
if (opts.width != null) {
width = opts.width;
}
if (opts.height != null) {
height = opts.height;
}
this.dpr = opts.devicePixelRatio || 1;
rootCanvas.width = width * this.dpr;
rootCanvas.height = height * this.dpr;
this._width = width;
this._height = height;
var mainLayer = new Layer(rootCanvas, this, this.dpr);
mainLayer.__builtin__ = true;
mainLayer.initContext();
layers[CANVAS_ZLEVEL] = mainLayer;
mainLayer.zlevel = CANVAS_ZLEVEL;
zlevelList.push(CANVAS_ZLEVEL);
this._domRoot = root;
}
}
CanvasPainter.prototype.getType = function () {
return "canvas";
};
CanvasPainter.prototype.isSingleCanvas = function () {
return this._singleCanvas;
};
CanvasPainter.prototype.getViewportRoot = function () {
return this._domRoot;
};
CanvasPainter.prototype.getViewportRootOffset = function () {
var viewportRoot = this.getViewportRoot();
if (viewportRoot) {
return {
offsetLeft: viewportRoot.offsetLeft || 0,
offsetTop: viewportRoot.offsetTop || 0,
};
}
};
CanvasPainter.prototype.refresh = function (paintAll) {
var list = this.storage.getDisplayList(true);
var prevList = this._prevDisplayList;
var zlevelList = this._zlevelList;
this._redrawId = Math.random();
this._paintList(list, prevList, paintAll, this._redrawId);
for (var i = 0; i < zlevelList.length; i++) {
var z = zlevelList[i];
var layer = this._layers[z];
if (!layer.__builtin__ && layer.refresh) {
var clearColor = i === 0 ? this._backgroundColor : null;
layer.refresh(clearColor);
}
}
if (this._opts.useDirtyRect) {
this._prevDisplayList = list.slice();
}
return this;
};
CanvasPainter.prototype.refreshHover = function () {
this._paintHoverList(this.storage.getDisplayList(false));
};
CanvasPainter.prototype._paintHoverList = function (list) {
var len = list.length;
var hoverLayer = this._hoverlayer;
hoverLayer && hoverLayer.clear();
if (!len) {
return;
}
var scope = {
inHover: true,
viewWidth: this._width,
viewHeight: this._height,
};
var ctx;
for (var i = 0; i < len; i++) {
var el = list[i];
if (el.__inHover) {
if (!hoverLayer) {
hoverLayer = this._hoverlayer = this.getLayer(HOVER_LAYER_ZLEVEL);
}
if (!ctx) {
ctx = hoverLayer.ctx;
ctx.save();
}
brush(ctx, el, scope, i === len - 1);
}
}
if (ctx) {
ctx.restore();
}
};
CanvasPainter.prototype.getHoverLayer = function () {
return this.getLayer(HOVER_LAYER_ZLEVEL);
};
CanvasPainter.prototype.paintOne = function (ctx, el) {
brushSingle(ctx, el);
};
CanvasPainter.prototype._paintList = function (
list,
prevList,
paintAll,
redrawId,
) {
if (this._redrawId !== redrawId) {
return;
}
paintAll = paintAll || false;
this._updateLayerStatus(list);
var _a = this._doPaintList(list, prevList, paintAll),
finished = _a.finished,
needsRefreshHover = _a.needsRefreshHover;
if (this._needsManuallyCompositing) {
this._compositeManually();
}
if (needsRefreshHover) {
this._paintHoverList(list);
}
if (!finished) {
var self_1 = this;
requestAnimationFrame$1(function () {
self_1._paintList(list, prevList, paintAll, redrawId);
});
} else {
this.eachLayer(function (layer) {
layer.afterBrush && layer.afterBrush();
});
}
};
CanvasPainter.prototype._compositeManually = function () {
var ctx = this.getLayer(CANVAS_ZLEVEL).ctx;
var width = this._domRoot.width;
var height = this._domRoot.height;
ctx.clearRect(0, 0, width, height);
this.eachBuiltinLayer(function (layer) {
if (layer.virtual) {
ctx.drawImage(layer.dom, 0, 0, width, height);
}
});
};
CanvasPainter.prototype._doPaintList = function (list, prevList, paintAll) {
var _this = this;
var layerList = [];
var useDirtyRect = this._opts.useDirtyRect;
for (var zi = 0; zi < this._zlevelList.length; zi++) {
var zlevel = this._zlevelList[zi];
var layer = this._layers[zlevel];
if (
layer.__builtin__ &&
layer !== this._hoverlayer &&
(layer.__dirty || paintAll)
) {
layerList.push(layer);
}
}
var finished = true;
var needsRefreshHover = false;
var _loop_1 = function (k) {
var layer = layerList[k];
var ctx = layer.ctx;
var repaintRects =
useDirtyRect &&
layer.createRepaintRects(
list,
prevList,
this_1._width,
this_1._height,
);
var start = paintAll ? layer.__startIndex : layer.__drawIndex;
var useTimer = !paintAll && layer.incremental && Date.now;
var startTime = useTimer && Date.now();
var clearColor =
layer.zlevel === this_1._zlevelList[0]
? this_1._backgroundColor
: null;
if (layer.__startIndex === layer.__endIndex) {
layer.clear(false, clearColor, repaintRects);
} else if (start === layer.__startIndex) {
var firstEl = list[start];
if (!firstEl.incremental || !firstEl.notClear || paintAll) {
layer.clear(false, clearColor, repaintRects);
}
}
if (start === -1) {
console.error("For some unknown reason. drawIndex is -1");
start = layer.__startIndex;
}
var i;
var repaint = function (repaintRect) {
var scope = {
inHover: false,
allClipped: false,
prevEl: null,
viewWidth: _this._width,
viewHeight: _this._height,
};
for (i = start; i < layer.__endIndex; i++) {
var el = list[i];
if (el.__inHover) {
needsRefreshHover = true;
}
_this._doPaintEl(
el,
layer,
useDirtyRect,
repaintRect,
scope,
i === layer.__endIndex - 1,
);
if (useTimer) {
var dTime = Date.now() - startTime;
if (dTime > 15) {
break;
}
}
}
if (scope.prevElClipPaths) {
ctx.restore();
}
};
if (repaintRects) {
if (repaintRects.length === 0) {
i = layer.__endIndex;
} else {
var dpr = this_1.dpr;
for (var r = 0; r < repaintRects.length; ++r) {
var rect = repaintRects[r];
ctx.save();
ctx.beginPath();
ctx.rect(
rect.x * dpr,
rect.y * dpr,
rect.width * dpr,
rect.height * dpr,
);
ctx.clip();
repaint(rect);
ctx.restore();
}
}
} else {
ctx.save();
repaint();
ctx.restore();
}
layer.__drawIndex = i;
if (layer.__drawIndex < layer.__endIndex) {
finished = false;
}
};
var this_1 = this;
for (var k = 0; k < layerList.length; k++) {
_loop_1(k);
}
if (env.wxa) {
each(this._layers, function (layer) {
if (layer && layer.ctx && layer.ctx.draw) {
layer.ctx.draw();
}
});
}
return {
finished: finished,
needsRefreshHover: needsRefreshHover,
};
};
CanvasPainter.prototype._doPaintEl = function (
el,
currentLayer,
useDirtyRect,
repaintRect,
scope,
isLast,
) {
var ctx = currentLayer.ctx;
if (useDirtyRect) {
var paintRect = el.getPaintRect();
if (!repaintRect || (paintRect && paintRect.intersect(repaintRect))) {
brush(ctx, el, scope, isLast);
el.setPrevPaintRect(paintRect);
}
} else {
brush(ctx, el, scope, isLast);
}
};
CanvasPainter.prototype.getLayer = function (zlevel, virtual) {
if (this._singleCanvas && !this._needsManuallyCompositing) {
zlevel = CANVAS_ZLEVEL;
}
var layer = this._layers[zlevel];
if (!layer) {
layer = new Layer("zr_" + zlevel, this, this.dpr);
layer.zlevel = zlevel;
layer.__builtin__ = true;
if (this._layerConfig[zlevel]) {
merge(layer, this._layerConfig[zlevel], true);
} else if (this._layerConfig[zlevel - EL_AFTER_INCREMENTAL_INC]) {
merge(
layer,
this._layerConfig[zlevel - EL_AFTER_INCREMENTAL_INC],
true,
);
}
if (virtual) {
layer.virtual = virtual;
}
this.insertLayer(zlevel, layer);
layer.initContext();
}
return layer;
};
CanvasPainter.prototype.insertLayer = function (zlevel, layer) {
var layersMap = this._layers;
var zlevelList = this._zlevelList;
var len = zlevelList.length;
var domRoot = this._domRoot;
var prevLayer = null;
var i = -1;
if (layersMap[zlevel]) {
if ("development" !== "production") {
logError("ZLevel " + zlevel + " has been used already");
}
return;
}
if (!isLayerValid(layer)) {
if ("development" !== "production") {
logError("Layer of zlevel " + zlevel + " is not valid");
}
return;
}
if (len > 0 && zlevel > zlevelList[0]) {
for (i = 0; i < len - 1; i++) {
if (zlevelList[i] < zlevel && zlevelList[i + 1] > zlevel) {
break;
}
}
prevLayer = layersMap[zlevelList[i]];
}
zlevelList.splice(i + 1, 0, zlevel);
layersMap[zlevel] = layer;
if (!layer.virtual) {
if (prevLayer) {
var prevDom = prevLayer.dom;
if (prevDom.nextSibling) {
domRoot.insertBefore(layer.dom, prevDom.nextSibling);
} else {
domRoot.appendChild(layer.dom);
}
} else {
if (domRoot.firstChild) {
domRoot.insertBefore(layer.dom, domRoot.firstChild);
} else {
domRoot.appendChild(layer.dom);
}
}
}
layer.__painter = this;
};
CanvasPainter.prototype.eachLayer = function (cb, context) {
var zlevelList = this._zlevelList;
for (var i = 0; i < zlevelList.length; i++) {
var z = zlevelList[i];
cb.call(context, this._layers[z], z);
}
};
CanvasPainter.prototype.eachBuiltinLayer = function (cb, context) {
var zlevelList = this._zlevelList;
for (var i = 0; i < zlevelList.length; i++) {
var z = zlevelList[i];
var layer = this._layers[z];
if (layer.__builtin__) {
cb.call(context, layer, z);
}
}
};
CanvasPainter.prototype.eachOtherLayer = function (cb, context) {
var zlevelList = this._zlevelList;
for (var i = 0; i < zlevelList.length; i++) {
var z = zlevelList[i];
var layer = this._layers[z];
if (!layer.__builtin__) {
cb.call(context, layer, z);
}
}
};
CanvasPainter.prototype.getLayers = function () {
return this._layers;
};
CanvasPainter.prototype._updateLayerStatus = function (list) {
this.eachBuiltinLayer(function (layer, z) {
layer.__dirty = layer.__used = false;
});
function updatePrevLayer(idx) {
if (prevLayer) {
if (prevLayer.__endIndex !== idx) {
prevLayer.__dirty = true;
}
prevLayer.__endIndex = idx;
}
}
if (this._singleCanvas) {
for (var i_1 = 1; i_1 < list.length; i_1++) {
var el = list[i_1];
if (el.zlevel !== list[i_1 - 1].zlevel || el.incremental) {
this._needsManuallyCompositing = true;
break;
}
}
}
var prevLayer = null;
var incrementalLayerCount = 0;
var prevZlevel;
var i;
for (i = 0; i < list.length; i++) {
var el = list[i];
var zlevel = el.zlevel;
var layer = void 0;
if (prevZlevel !== zlevel) {
prevZlevel = zlevel;
incrementalLayerCount = 0;
}
if (el.incremental) {
layer = this.getLayer(
zlevel + INCREMENTAL_INC,
this._needsManuallyCompositing,
);
layer.incremental = true;
incrementalLayerCount = 1;
} else {
layer = this.getLayer(
zlevel + (incrementalLayerCount > 0 ? EL_AFTER_INCREMENTAL_INC : 0),
this._needsManuallyCompositing,
);
}
if (!layer.__builtin__) {
logError(
"ZLevel " + zlevel + " has been used by unkown layer " + layer.id,
);
}
if (layer !== prevLayer) {
layer.__used = true;
if (layer.__startIndex !== i) {
layer.__dirty = true;
}
layer.__startIndex = i;
if (!layer.incremental) {
layer.__drawIndex = i;
} else {
layer.__drawIndex = -1;
}
updatePrevLayer(i);
prevLayer = layer;
}
if (el.__dirty & REDRAW_BIT && !el.__inHover) {
layer.__dirty = true;
if (layer.incremental && layer.__drawIndex < 0) {
layer.__drawIndex = i;
}
}
}
updatePrevLayer(i);
this.eachBuiltinLayer(function (layer, z) {
if (!layer.__used && layer.getElementCount() > 0) {
layer.__dirty = true;
layer.__startIndex = layer.__endIndex = layer.__drawIndex = 0;
}
if (layer.__dirty && layer.__drawIndex < 0) {
layer.__drawIndex = layer.__startIndex;
}
});
};
CanvasPainter.prototype.clear = function () {
this.eachBuiltinLayer(this._clearLayer);
return this;
};
CanvasPainter.prototype._clearLayer = function (layer) {
layer.clear();
};
CanvasPainter.prototype.setBackgroundColor = function (backgroundColor) {
this._backgroundColor = backgroundColor;
each(this._layers, function (layer) {
layer.setUnpainted();
});
};
CanvasPainter.prototype.configLayer = function (zlevel, config) {
if (config) {
var layerConfig = this._layerConfig;
if (!layerConfig[zlevel]) {
layerConfig[zlevel] = config;
} else {
merge(layerConfig[zlevel], config, true);
}
for (var i = 0; i < this._zlevelList.length; i++) {
var _zlevel = this._zlevelList[i];
if (
_zlevel === zlevel ||
_zlevel === zlevel + EL_AFTER_INCREMENTAL_INC
) {
var layer = this._layers[_zlevel];
merge(layer, layerConfig[zlevel], true);
}
}
}
};
CanvasPainter.prototype.delLayer = function (zlevel) {
var layers = this._layers;
var zlevelList = this._zlevelList;
var layer = layers[zlevel];
if (!layer) {
return;
}
layer.dom.parentNode.removeChild(layer.dom);
delete layers[zlevel];
zlevelList.splice(indexOf(zlevelList, zlevel), 1);
};
CanvasPainter.prototype.resize = function (width, height) {
if (!this._domRoot.style) {
if (width == null || height == null) {
return;
}
this._width = width;
this._height = height;
this.getLayer(CANVAS_ZLEVEL).resize(width, height);
} else {
var domRoot = this._domRoot;
domRoot.style.display = "none";
var opts = this._opts;
var root = this.root;
width != null && (opts.width = width);
height != null && (opts.height = height);
width = getSize(root, 0, opts);
height = getSize(root, 1, opts);
domRoot.style.display = "";
if (this._width !== width || height !== this._height) {
domRoot.style.width = width + "px";
domRoot.style.height = height + "px";
for (var id in this._layers) {
if (this._layers.hasOwnProperty(id)) {
this._layers[id].resize(width, height);
}
}
this.refresh(true);
}
this._width = width;
this._height = height;
}
return this;
};
CanvasPainter.prototype.clearLayer = function (zlevel) {
var layer = this._layers[zlevel];
if (layer) {
layer.clear();
}
};
CanvasPainter.prototype.dispose = function () {
this.root.innerHTML = "";
this.root = this.storage = this._domRoot = this._layers = null;
};
CanvasPainter.prototype.getRenderedCanvas = function (opts) {
opts = opts || {};
if (this._singleCanvas && !this._compositeManually) {
return this._layers[CANVAS_ZLEVEL].dom;
}
var imageLayer = new Layer("image", this, opts.pixelRatio || this.dpr);
imageLayer.initContext();
imageLayer.clear(false, opts.backgroundColor || this._backgroundColor);
var ctx = imageLayer.ctx;
if (opts.pixelRatio <= this.dpr) {
this.refresh();
var width_1 = imageLayer.dom.width;
var height_1 = imageLayer.dom.height;
this.eachLayer(function (layer) {
if (layer.__builtin__) {
ctx.drawImage(layer.dom, 0, 0, width_1, height_1);
} else if (layer.renderToCanvas) {
ctx.save();
layer.renderToCanvas(ctx);
ctx.restore();
}
});
} else {
var scope = {
inHover: false,
viewWidth: this._width,
viewHeight: this._height,
};
var displayList = this.storage.getDisplayList(true);
for (var i = 0, len = displayList.length; i < len; i++) {
var el = displayList[i];
brush(ctx, el, scope, i === len - 1);
}
}
return imageLayer.dom;
};
CanvasPainter.prototype.getWidth = function () {
return this._width;
};
CanvasPainter.prototype.getHeight = function () {
return this._height;
};
return CanvasPainter;
})();
function install$1(registers) {
registers.registerPainter("canvas", CanvasPainter);
}
var LineSeriesModel =
/** @class */
(function (_super) {
__extends(LineSeriesModel, _super);
function LineSeriesModel() {
var _this = (_super !== null && _super.apply(this, arguments)) || this;
_this.type = LineSeriesModel.type;
_this.hasSymbolVisual = true;
return _this;
}
LineSeriesModel.prototype.getInitialData = function (option) {
if ("development" !== "production") {
var coordSys = option.coordinateSystem;
if (coordSys !== "polar" && coordSys !== "cartesian2d") {
throw new Error(
"Line not support coordinateSystem besides cartesian and polar",
);
}
}
return createSeriesData(null, this, {
useEncodeDefaulter: true,
});
};
LineSeriesModel.prototype.getLegendIcon = function (opt) {
var group = new Group();
var line = createSymbol(
"line",
0,
opt.itemHeight / 2,
opt.itemWidth,
0,
opt.lineStyle.stroke,
false,
);
group.add(line);
line.setStyle(opt.lineStyle);
var visualType = this.getData().getVisual("symbol");
var visualRotate = this.getData().getVisual("symbolRotate");
var symbolType = visualType === "none" ? "circle" : visualType; // Symbol size is 80% when there is a line
var size = opt.itemHeight * 0.8;
var symbol = createSymbol(
symbolType,
(opt.itemWidth - size) / 2,
(opt.itemHeight - size) / 2,
size,
size,
opt.itemStyle.fill,
);
group.add(symbol);
symbol.setStyle(opt.itemStyle);
var symbolRotate =
opt.iconRotate === "inherit" ? visualRotate : opt.iconRotate || 0;
symbol.rotation = (symbolRotate * Math.PI) / 180;
symbol.setOrigin([opt.itemWidth / 2, opt.itemHeight / 2]);
if (symbolType.indexOf("empty") > -1) {
symbol.style.stroke = symbol.style.fill;
symbol.style.fill = "#fff";
symbol.style.lineWidth = 2;
}
return group;
};
LineSeriesModel.type = "series.line";
LineSeriesModel.dependencies = ["grid", "polar"];
LineSeriesModel.defaultOption = {
// zlevel: 0,
z: 3,
coordinateSystem: "cartesian2d",
legendHoverLink: true,
clip: true,
label: {
position: "top",
},
// itemStyle: {
// },
endLabel: {
show: false,
valueAnimation: true,
distance: 8,
},
lineStyle: {
width: 2,
type: "solid",
},
emphasis: {
scale: true,
},
// areaStyle: {
// origin of areaStyle. Valid values:
// `'auto'/null/undefined`: from axisLine to data
// `'start'`: from min to data
// `'end'`: from data to max
// origin: 'auto'
// },
// false, 'start', 'end', 'middle'
step: false,
// Disabled if step is true
smooth: false,
smoothMonotone: null,
symbol: "emptyCircle",
symbolSize: 4,
symbolRotate: null,
showSymbol: true,
// `false`: follow the label interval strategy.
// `true`: show all symbols.
// `'auto'`: If possible, show all symbols, otherwise
// follow the label interval strategy.
showAllSymbol: "auto",
// Whether to connect break point.
connectNulls: false,
// Sampling for large data. Can be: 'average', 'max', 'min', 'sum', 'lttb'.
sampling: "none",
animationEasing: "linear",
// Disable progressive
progressive: 0,
hoverLayerThreshold: Infinity,
universalTransition: {
divideShape: "clone",
},
triggerLineEvent: false,
};
return LineSeriesModel;
})(SeriesModel);
/**
* @return label string. Not null/undefined
*/
function getDefaultLabel(data, dataIndex) {
var labelDims = data.mapDimensionsAll("defaultedLabel");
var len = labelDims.length; // Simple optimization (in lots of cases, label dims length is 1)
if (len === 1) {
var rawVal = retrieveRawValue(data, dataIndex, labelDims[0]);
return rawVal != null ? rawVal + "" : null;
} else if (len) {
var vals = [];
for (var i = 0; i < labelDims.length; i++) {
vals.push(retrieveRawValue(data, dataIndex, labelDims[i]));
}
return vals.join(" ");
}
}
function getDefaultInterpolatedLabel(data, interpolatedValue) {
var labelDims = data.mapDimensionsAll("defaultedLabel");
if (!isArray(interpolatedValue)) {
return interpolatedValue + "";
}
var vals = [];
for (var i = 0; i < labelDims.length; i++) {
var dimIndex = data.getDimensionIndex(labelDims[i]);
if (dimIndex >= 0) {
vals.push(interpolatedValue[dimIndex]);
}
}
return vals.join(" ");
}
var Symbol =
/** @class */
(function (_super) {
__extends(Symbol, _super);
function Symbol(data, idx, seriesScope, opts) {
var _this = _super.call(this) || this;
_this.updateData(data, idx, seriesScope, opts);
return _this;
}
Symbol.prototype._createSymbol = function (
symbolType,
data,
idx,
symbolSize,
keepAspect,
) {
// Remove paths created before
this.removeAll(); // let symbolPath = createSymbol(
// symbolType, -0.5, -0.5, 1, 1, color
// );
// If width/height are set too small (e.g., set to 1) on ios10
// and macOS Sierra, a circle stroke become a rect, no matter what
// the scale is set. So we set width/height as 2. See #4150.
var symbolPath = createSymbol(
symbolType,
-1,
-1,
2,
2,
null,
keepAspect,
);
symbolPath.attr({
z2: 100,
culling: true,
scaleX: symbolSize[0] / 2,
scaleY: symbolSize[1] / 2,
}); // Rewrite drift method
symbolPath.drift = driftSymbol;
this._symbolType = symbolType;
this.add(symbolPath);
};
/**
* Stop animation
* @param {boolean} toLastFrame
*/
Symbol.prototype.stopSymbolAnimation = function (toLastFrame) {
this.childAt(0).stopAnimation(null, toLastFrame);
};
Symbol.prototype.getSymbolType = function () {
return this._symbolType;
};
/**
* FIXME:
* Caution: This method breaks the encapsulation of this module,
* but it indeed brings convenience. So do not use the method
* unless you detailedly know all the implements of `Symbol`,
* especially animation.
*
* Get symbol path element.
*/
Symbol.prototype.getSymbolPath = function () {
return this.childAt(0);
};
/**
* Highlight symbol
*/
Symbol.prototype.highlight = function () {
enterEmphasis(this.childAt(0));
};
/**
* Downplay symbol
*/
Symbol.prototype.downplay = function () {
leaveEmphasis(this.childAt(0));
};
/**
* @param {number} zlevel
* @param {number} z
*/
Symbol.prototype.setZ = function (zlevel, z) {
var symbolPath = this.childAt(0);
symbolPath.zlevel = zlevel;
symbolPath.z = z;
};
Symbol.prototype.setDraggable = function (draggable) {
var symbolPath = this.childAt(0);
symbolPath.draggable = draggable;
symbolPath.cursor = draggable ? "move" : symbolPath.cursor;
};
/**
* Update symbol properties
*/
Symbol.prototype.updateData = function (data, idx, seriesScope, opts) {
this.silent = false;
var symbolType = data.getItemVisual(idx, "symbol") || "circle";
var seriesModel = data.hostModel;
var symbolSize = Symbol.getSymbolSize(data, idx);
var isInit = symbolType !== this._symbolType;
var disableAnimation = opts && opts.disableAnimation;
if (isInit) {
var keepAspect = data.getItemVisual(idx, "symbolKeepAspect");
this._createSymbol(symbolType, data, idx, symbolSize, keepAspect);
} else {
var symbolPath = this.childAt(0);
symbolPath.silent = false;
var target = {
scaleX: symbolSize[0] / 2,
scaleY: symbolSize[1] / 2,
};
disableAnimation
? symbolPath.attr(target)
: updateProps(symbolPath, target, seriesModel, idx);
saveOldStyle(symbolPath);
}
this._updateCommon(data, idx, symbolSize, seriesScope, opts);
if (isInit) {
var symbolPath = this.childAt(0);
if (!disableAnimation) {
var target = {
scaleX: this._sizeX,
scaleY: this._sizeY,
style: {
// Always fadeIn. Because it has fadeOut animation when symbol is removed..
opacity: symbolPath.style.opacity,
},
};
symbolPath.scaleX = symbolPath.scaleY = 0;
symbolPath.style.opacity = 0;
initProps(symbolPath, target, seriesModel, idx);
}
}
if (disableAnimation) {
// Must stop leave transition manually if don't call initProps or updateProps.
this.childAt(0).stopAnimation("leave");
}
};
Symbol.prototype._updateCommon = function (
data,
idx,
symbolSize,
seriesScope,
opts,
) {
var symbolPath = this.childAt(0);
var seriesModel = data.hostModel;
var emphasisItemStyle;
var blurItemStyle;
var selectItemStyle;
var focus;
var blurScope;
var emphasisDisabled;
var labelStatesModels;
var hoverScale;
var cursorStyle;
if (seriesScope) {
emphasisItemStyle = seriesScope.emphasisItemStyle;
blurItemStyle = seriesScope.blurItemStyle;
selectItemStyle = seriesScope.selectItemStyle;
focus = seriesScope.focus;
blurScope = seriesScope.blurScope;
labelStatesModels = seriesScope.labelStatesModels;
hoverScale = seriesScope.hoverScale;
cursorStyle = seriesScope.cursorStyle;
emphasisDisabled = seriesScope.emphasisDisabled;
}
if (!seriesScope || data.hasItemOption) {
var itemModel =
seriesScope && seriesScope.itemModel
? seriesScope.itemModel
: data.getItemModel(idx);
var emphasisModel = itemModel.getModel("emphasis");
emphasisItemStyle = emphasisModel
.getModel("itemStyle")
.getItemStyle();
selectItemStyle = itemModel
.getModel(["select", "itemStyle"])
.getItemStyle();
blurItemStyle = itemModel
.getModel(["blur", "itemStyle"])
.getItemStyle();
focus = emphasisModel.get("focus");
blurScope = emphasisModel.get("blurScope");
emphasisDisabled = emphasisModel.get("disabled");
labelStatesModels = getLabelStatesModels(itemModel);
hoverScale = emphasisModel.getShallow("scale");
cursorStyle = itemModel.getShallow("cursor");
}
var symbolRotate = data.getItemVisual(idx, "symbolRotate");
symbolPath.attr("rotation", ((symbolRotate || 0) * Math.PI) / 180 || 0);
var symbolOffset = normalizeSymbolOffset(
data.getItemVisual(idx, "symbolOffset"),
symbolSize,
);
if (symbolOffset) {
symbolPath.x = symbolOffset[0];
symbolPath.y = symbolOffset[1];
}
cursorStyle && symbolPath.attr("cursor", cursorStyle);
var symbolStyle = data.getItemVisual(idx, "style");
var visualColor = symbolStyle.fill;
if (symbolPath instanceof ZRImage) {
var pathStyle = symbolPath.style;
symbolPath.useStyle(
extend(
{
// TODO other properties like x, y ?
image: pathStyle.image,
x: pathStyle.x,
y: pathStyle.y,
width: pathStyle.width,
height: pathStyle.height,
},
symbolStyle,
),
);
} else {
if (symbolPath.__isEmptyBrush) {
// fill and stroke will be swapped if it's empty.
// So we cloned a new style to avoid it affecting the original style in visual storage.
// TODO Better implementation. No empty logic!
symbolPath.useStyle(extend({}, symbolStyle));
} else {
symbolPath.useStyle(symbolStyle);
} // Disable decal because symbol scale will been applied on the decal.
symbolPath.style.decal = null;
symbolPath.setColor(visualColor, opts && opts.symbolInnerColor);
symbolPath.style.strokeNoScale = true;
}
var liftZ = data.getItemVisual(idx, "liftZ");
var z2Origin = this._z2;
if (liftZ != null) {
if (z2Origin == null) {
this._z2 = symbolPath.z2;
symbolPath.z2 += liftZ;
}
} else if (z2Origin != null) {
symbolPath.z2 = z2Origin;
this._z2 = null;
}
var useNameLabel = opts && opts.useNameLabel;
setLabelStyle(symbolPath, labelStatesModels, {
labelFetcher: seriesModel,
labelDataIndex: idx,
defaultText: getLabelDefaultText,
inheritColor: visualColor,
defaultOpacity: symbolStyle.opacity,
}); // Do not execute util needed.
function getLabelDefaultText(idx) {
return useNameLabel ? data.getName(idx) : getDefaultLabel(data, idx);
}
this._sizeX = symbolSize[0] / 2;
this._sizeY = symbolSize[1] / 2;
var emphasisState = symbolPath.ensureState("emphasis");
emphasisState.style = emphasisItemStyle;
symbolPath.ensureState("select").style = selectItemStyle;
symbolPath.ensureState("blur").style = blurItemStyle;
if (hoverScale) {
var scaleRatio = Math.max(
isNumber(hoverScale) ? hoverScale : 1.1,
3 / this._sizeY,
);
emphasisState.scaleX = this._sizeX * scaleRatio;
emphasisState.scaleY = this._sizeY * scaleRatio;
}
this.setSymbolScale(1);
toggleHoverEmphasis(this, focus, blurScope, emphasisDisabled);
};
Symbol.prototype.setSymbolScale = function (scale) {
this.scaleX = this.scaleY = scale;
};
Symbol.prototype.fadeOut = function (cb, seriesModel, opt) {
var symbolPath = this.childAt(0);
var dataIndex = getECData(this).dataIndex;
var animationOpt = opt && opt.animation; // Avoid mistaken hover when fading out
this.silent = symbolPath.silent = true; // Not show text when animating
if (opt && opt.fadeLabel) {
var textContent = symbolPath.getTextContent();
if (textContent) {
removeElement(
textContent,
{
style: {
opacity: 0,
},
},
seriesModel,
{
dataIndex: dataIndex,
removeOpt: animationOpt,
cb: function () {
symbolPath.removeTextContent();
},
},
);
}
} else {
symbolPath.removeTextContent();
}
removeElement(
symbolPath,
{
style: {
opacity: 0,
},
scaleX: 0,
scaleY: 0,
},
seriesModel,
{
dataIndex: dataIndex,
cb: cb,
removeOpt: animationOpt,
},
);
};
Symbol.getSymbolSize = function (data, idx) {
return normalizeSymbolSize(data.getItemVisual(idx, "symbolSize"));
};
return Symbol;
})(Group);
function driftSymbol(dx, dy) {
this.parent.drift(dx, dy);
}
function symbolNeedsDraw(data, point, idx, opt) {
return (
point &&
!isNaN(point[0]) &&
!isNaN(point[1]) &&
!(opt.isIgnore && opt.isIgnore(idx)) && // We do not set clipShape on group, because it will cut part of
// the symbol element shape. We use the same clip shape here as
// the line clip.
!(opt.clipShape && !opt.clipShape.contain(point[0], point[1])) &&
data.getItemVisual(idx, "symbol") !== "none"
);
}
function normalizeUpdateOpt(opt) {
if (opt != null && !isObject(opt)) {
opt = {
isIgnore: opt,
};
}
return opt || {};
}
function makeSeriesScope(data) {
var seriesModel = data.hostModel;
var emphasisModel = seriesModel.getModel("emphasis");
return {
emphasisItemStyle: emphasisModel.getModel("itemStyle").getItemStyle(),
blurItemStyle: seriesModel.getModel(["blur", "itemStyle"]).getItemStyle(),
selectItemStyle: seriesModel
.getModel(["select", "itemStyle"])
.getItemStyle(),
focus: emphasisModel.get("focus"),
blurScope: emphasisModel.get("blurScope"),
emphasisDisabled: emphasisModel.get("disabled"),
hoverScale: emphasisModel.get("scale"),
labelStatesModels: getLabelStatesModels(seriesModel),
cursorStyle: seriesModel.get("cursor"),
};
}
var SymbolDraw =
/** @class */
(function () {
function SymbolDraw(SymbolCtor) {
this.group = new Group();
this._SymbolCtor = SymbolCtor || Symbol;
}
/**
* Update symbols draw by new data
*/
SymbolDraw.prototype.updateData = function (data, opt) {
// Remove progressive els.
this._progressiveEls = null;
opt = normalizeUpdateOpt(opt);
var group = this.group;
var seriesModel = data.hostModel;
var oldData = this._data;
var SymbolCtor = this._SymbolCtor;
var disableAnimation = opt.disableAnimation;
var seriesScope = makeSeriesScope(data);
var symbolUpdateOpt = {
disableAnimation: disableAnimation,
};
var getSymbolPoint =
opt.getSymbolPoint ||
function (idx) {
return data.getItemLayout(idx);
}; // There is no oldLineData only when first rendering or switching from
// stream mode to normal mode, where previous elements should be removed.
if (!oldData) {
group.removeAll();
}
data
.diff(oldData)
.add(function (newIdx) {
var point = getSymbolPoint(newIdx);
if (symbolNeedsDraw(data, point, newIdx, opt)) {
var symbolEl = new SymbolCtor(
data,
newIdx,
seriesScope,
symbolUpdateOpt,
);
symbolEl.setPosition(point);
data.setItemGraphicEl(newIdx, symbolEl);
group.add(symbolEl);
}
})
.update(function (newIdx, oldIdx) {
var symbolEl = oldData.getItemGraphicEl(oldIdx);
var point = getSymbolPoint(newIdx);
if (!symbolNeedsDraw(data, point, newIdx, opt)) {
group.remove(symbolEl);
return;
}
var newSymbolType =
data.getItemVisual(newIdx, "symbol") || "circle";
var oldSymbolType =
symbolEl && symbolEl.getSymbolType && symbolEl.getSymbolType();
if (
!symbolEl || // Create a new if symbol type changed.
(oldSymbolType && oldSymbolType !== newSymbolType)
) {
group.remove(symbolEl);
symbolEl = new SymbolCtor(
data,
newIdx,
seriesScope,
symbolUpdateOpt,
);
symbolEl.setPosition(point);
} else {
symbolEl.updateData(data, newIdx, seriesScope, symbolUpdateOpt);
var target = {
x: point[0],
y: point[1],
};
disableAnimation
? symbolEl.attr(target)
: updateProps(symbolEl, target, seriesModel);
} // Add back
group.add(symbolEl);
data.setItemGraphicEl(newIdx, symbolEl);
})
.remove(function (oldIdx) {
var el = oldData.getItemGraphicEl(oldIdx);
el &&
el.fadeOut(function () {
group.remove(el);
}, seriesModel);
})
.execute();
this._getSymbolPoint = getSymbolPoint;
this._data = data;
};
SymbolDraw.prototype.updateLayout = function () {
var _this = this;
var data = this._data;
if (data) {
// Not use animation
data.eachItemGraphicEl(function (el, idx) {
var point = _this._getSymbolPoint(idx);
el.setPosition(point);
el.markRedraw();
});
}
};
SymbolDraw.prototype.incrementalPrepareUpdate = function (data) {
this._seriesScope = makeSeriesScope(data);
this._data = null;
this.group.removeAll();
};
/**
* Update symbols draw by new data
*/
SymbolDraw.prototype.incrementalUpdate = function (
taskParams,
data,
opt,
) {
// Clear
this._progressiveEls = [];
opt = normalizeUpdateOpt(opt);
function updateIncrementalAndHover(el) {
if (!el.isGroup) {
el.incremental = true;
el.ensureState("emphasis").hoverLayer = true;
}
}
for (var idx = taskParams.start; idx < taskParams.end; idx++) {
var point = data.getItemLayout(idx);
if (symbolNeedsDraw(data, point, idx, opt)) {
var el = new this._SymbolCtor(data, idx, this._seriesScope);
el.traverse(updateIncrementalAndHover);
el.setPosition(point);
this.group.add(el);
data.setItemGraphicEl(idx, el);
this._progressiveEls.push(el);
}
}
};
SymbolDraw.prototype.eachRendered = function (cb) {
traverseElements(this._progressiveEls || this.group, cb);
};
SymbolDraw.prototype.remove = function (enableAnimation) {
var group = this.group;
var data = this._data; // Incremental model do not have this._data.
if (data && enableAnimation) {
data.eachItemGraphicEl(function (el) {
el.fadeOut(function () {
group.remove(el);
}, data.hostModel);
});
} else {
group.removeAll();
}
};
return SymbolDraw;
})();
function prepareDataCoordInfo(coordSys, data, valueOrigin) {
var baseAxis = coordSys.getBaseAxis();
var valueAxis = coordSys.getOtherAxis(baseAxis);
var valueStart = getValueStart(valueAxis, valueOrigin);
var baseAxisDim = baseAxis.dim;
var valueAxisDim = valueAxis.dim;
var valueDim = data.mapDimension(valueAxisDim);
var baseDim = data.mapDimension(baseAxisDim);
var baseDataOffset =
valueAxisDim === "x" || valueAxisDim === "radius" ? 1 : 0;
var dims = map(coordSys.dimensions, function (coordDim) {
return data.mapDimension(coordDim);
});
var stacked = false;
var stackResultDim = data.getCalculationInfo("stackResultDimension");
if (
isDimensionStacked(
data,
dims[0],
/*, dims[1]*/
)
) {
// jshint ignore:line
stacked = true;
dims[0] = stackResultDim;
}
if (
isDimensionStacked(
data,
dims[1],
/*, dims[0]*/
)
) {
// jshint ignore:line
stacked = true;
dims[1] = stackResultDim;
}
return {
dataDimsForPoint: dims,
valueStart: valueStart,
valueAxisDim: valueAxisDim,
baseAxisDim: baseAxisDim,
stacked: !!stacked,
valueDim: valueDim,
baseDim: baseDim,
baseDataOffset: baseDataOffset,
stackedOverDimension: data.getCalculationInfo("stackedOverDimension"),
};
}
function getValueStart(valueAxis, valueOrigin) {
var valueStart = 0;
var extent = valueAxis.scale.getExtent();
if (valueOrigin === "start") {
valueStart = extent[0];
} else if (valueOrigin === "end") {
valueStart = extent[1];
} // If origin is specified as a number, use it as
// valueStart directly
else if (isNumber(valueOrigin) && !isNaN(valueOrigin)) {
valueStart = valueOrigin;
} // auto
else {
// Both positive
if (extent[0] > 0) {
valueStart = extent[0];
} // Both negative
else if (extent[1] < 0) {
valueStart = extent[1];
} // If is one positive, and one negative, onZero shall be true
}
return valueStart;
}
function getStackedOnPoint(dataCoordInfo, coordSys, data, idx) {
var value = NaN;
if (dataCoordInfo.stacked) {
value = data.get(data.getCalculationInfo("stackedOverDimension"), idx);
}
if (isNaN(value)) {
value = dataCoordInfo.valueStart;
}
var baseDataOffset = dataCoordInfo.baseDataOffset;
var stackedData = [];
stackedData[baseDataOffset] = data.get(dataCoordInfo.baseDim, idx);
stackedData[1 - baseDataOffset] = value;
return coordSys.dataToPoint(stackedData);
}
function diffData(oldData, newData) {
var diffResult = [];
newData
.diff(oldData)
.add(function (idx) {
diffResult.push({
cmd: "+",
idx: idx,
});
})
.update(function (newIdx, oldIdx) {
diffResult.push({
cmd: "=",
idx: oldIdx,
idx1: newIdx,
});
})
.remove(function (idx) {
diffResult.push({
cmd: "-",
idx: idx,
});
})
.execute();
return diffResult;
}
function lineAnimationDiff(
oldData,
newData,
oldStackedOnPoints,
newStackedOnPoints,
oldCoordSys,
newCoordSys,
oldValueOrigin,
newValueOrigin,
) {
var diff = diffData(oldData, newData); // let newIdList = newData.mapArray(newData.getId);
// let oldIdList = oldData.mapArray(oldData.getId);
// convertToIntId(newIdList, oldIdList);
// // FIXME One data ?
// diff = arrayDiff(oldIdList, newIdList);
var currPoints = [];
var nextPoints = []; // Points for stacking base line
var currStackedPoints = [];
var nextStackedPoints = [];
var status = [];
var sortedIndices = [];
var rawIndices = [];
var newDataOldCoordInfo = prepareDataCoordInfo(
oldCoordSys,
newData,
oldValueOrigin,
); // const oldDataNewCoordInfo = prepareDataCoordInfo(newCoordSys, oldData, newValueOrigin);
var oldPoints = oldData.getLayout("points") || [];
var newPoints = newData.getLayout("points") || [];
for (var i = 0; i < diff.length; i++) {
var diffItem = diff[i];
var pointAdded = true;
var oldIdx2 = void 0;
var newIdx2 = void 0; // FIXME, animation is not so perfect when dataZoom window moves fast
// Which is in case remvoing or add more than one data in the tail or head
switch (diffItem.cmd) {
case "=":
oldIdx2 = diffItem.idx * 2;
newIdx2 = diffItem.idx1 * 2;
var currentX = oldPoints[oldIdx2];
var currentY = oldPoints[oldIdx2 + 1];
var nextX = newPoints[newIdx2];
var nextY = newPoints[newIdx2 + 1]; // If previous data is NaN, use next point directly
if (isNaN(currentX) || isNaN(currentY)) {
currentX = nextX;
currentY = nextY;
}
currPoints.push(currentX, currentY);
nextPoints.push(nextX, nextY);
currStackedPoints.push(
oldStackedOnPoints[oldIdx2],
oldStackedOnPoints[oldIdx2 + 1],
);
nextStackedPoints.push(
newStackedOnPoints[newIdx2],
newStackedOnPoints[newIdx2 + 1],
);
rawIndices.push(newData.getRawIndex(diffItem.idx1));
break;
case "+":
var newIdx = diffItem.idx;
var newDataDimsForPoint = newDataOldCoordInfo.dataDimsForPoint;
var oldPt = oldCoordSys.dataToPoint([
newData.get(newDataDimsForPoint[0], newIdx),
newData.get(newDataDimsForPoint[1], newIdx),
]);
newIdx2 = newIdx * 2;
currPoints.push(oldPt[0], oldPt[1]);
nextPoints.push(newPoints[newIdx2], newPoints[newIdx2 + 1]);
var stackedOnPoint = getStackedOnPoint(
newDataOldCoordInfo,
oldCoordSys,
newData,
newIdx,
);
currStackedPoints.push(stackedOnPoint[0], stackedOnPoint[1]);
nextStackedPoints.push(
newStackedOnPoints[newIdx2],
newStackedOnPoints[newIdx2 + 1],
);
rawIndices.push(newData.getRawIndex(newIdx));
break;
case "-":
pointAdded = false;
} // Original indices
if (pointAdded) {
status.push(diffItem);
sortedIndices.push(sortedIndices.length);
}
} // Diff result may be crossed if all items are changed
// Sort by data index
sortedIndices.sort(function (a, b) {
return rawIndices[a] - rawIndices[b];
});
var len = currPoints.length;
var sortedCurrPoints = createFloat32Array(len);
var sortedNextPoints = createFloat32Array(len);
var sortedCurrStackedPoints = createFloat32Array(len);
var sortedNextStackedPoints = createFloat32Array(len);
var sortedStatus = [];
for (var i = 0; i < sortedIndices.length; i++) {
var idx = sortedIndices[i];
var i2 = i * 2;
var idx2 = idx * 2;
sortedCurrPoints[i2] = currPoints[idx2];
sortedCurrPoints[i2 + 1] = currPoints[idx2 + 1];
sortedNextPoints[i2] = nextPoints[idx2];
sortedNextPoints[i2 + 1] = nextPoints[idx2 + 1];
sortedCurrStackedPoints[i2] = currStackedPoints[idx2];
sortedCurrStackedPoints[i2 + 1] = currStackedPoints[idx2 + 1];
sortedNextStackedPoints[i2] = nextStackedPoints[idx2];
sortedNextStackedPoints[i2 + 1] = nextStackedPoints[idx2 + 1];
sortedStatus[i] = status[idx];
}
return {
current: sortedCurrPoints,
next: sortedNextPoints,
stackedOnCurrent: sortedCurrStackedPoints,
stackedOnNext: sortedNextStackedPoints,
status: sortedStatus,
};
}
var mathMin$5 = Math.min;
var mathMax$5 = Math.max;
function isPointNull(x, y) {
return isNaN(x) || isNaN(y);
}
/**
* Draw smoothed line in non-monotone, in may cause undesired curve in extreme
* situations. This should be used when points are non-monotone neither in x or
* y dimension.
*/
function drawSegment(
ctx,
points,
start,
segLen,
allLen,
dir,
smooth,
smoothMonotone,
connectNulls,
) {
var prevX;
var prevY;
var cpx0;
var cpy0;
var cpx1;
var cpy1;
var idx = start;
var k = 0;
for (; k < segLen; k++) {
var x = points[idx * 2];
var y = points[idx * 2 + 1];
if (idx >= allLen || idx < 0) {
break;
}
if (isPointNull(x, y)) {
if (connectNulls) {
idx += dir;
continue;
}
break;
}
if (idx === start) {
ctx[dir > 0 ? "moveTo" : "lineTo"](x, y);
cpx0 = x;
cpy0 = y;
} else {
var dx = x - prevX;
var dy = y - prevY; // Ignore tiny segment.
if (dx * dx + dy * dy < 0.5) {
idx += dir;
continue;
}
if (smooth > 0) {
var nextIdx = idx + dir;
var nextX = points[nextIdx * 2];
var nextY = points[nextIdx * 2 + 1]; // Ignore duplicate point
while (nextX === x && nextY === y && k < segLen) {
k++;
nextIdx += dir;
idx += dir;
nextX = points[nextIdx * 2];
nextY = points[nextIdx * 2 + 1];
x = points[idx * 2];
y = points[idx * 2 + 1];
dx = x - prevX;
dy = y - prevY;
}
var tmpK = k + 1;
if (connectNulls) {
// Find next point not null
while (isPointNull(nextX, nextY) && tmpK < segLen) {
tmpK++;
nextIdx += dir;
nextX = points[nextIdx * 2];
nextY = points[nextIdx * 2 + 1];
}
}
var ratioNextSeg = 0.5;
var vx = 0;
var vy = 0;
var nextCpx0 = void 0;
var nextCpy0 = void 0; // Is last point
if (tmpK >= segLen || isPointNull(nextX, nextY)) {
cpx1 = x;
cpy1 = y;
} else {
vx = nextX - prevX;
vy = nextY - prevY;
var dx0 = x - prevX;
var dx1 = nextX - x;
var dy0 = y - prevY;
var dy1 = nextY - y;
var lenPrevSeg = void 0;
var lenNextSeg = void 0;
if (smoothMonotone === "x") {
lenPrevSeg = Math.abs(dx0);
lenNextSeg = Math.abs(dx1);
var dir_1 = vx > 0 ? 1 : -1;
cpx1 = x - dir_1 * lenPrevSeg * smooth;
cpy1 = y;
nextCpx0 = x + dir_1 * lenNextSeg * smooth;
nextCpy0 = y;
} else if (smoothMonotone === "y") {
lenPrevSeg = Math.abs(dy0);
lenNextSeg = Math.abs(dy1);
var dir_2 = vy > 0 ? 1 : -1;
cpx1 = x;
cpy1 = y - dir_2 * lenPrevSeg * smooth;
nextCpx0 = x;
nextCpy0 = y + dir_2 * lenNextSeg * smooth;
} else {
lenPrevSeg = Math.sqrt(dx0 * dx0 + dy0 * dy0);
lenNextSeg = Math.sqrt(dx1 * dx1 + dy1 * dy1); // Use ratio of seg length
ratioNextSeg = lenNextSeg / (lenNextSeg + lenPrevSeg);
cpx1 = x - vx * smooth * (1 - ratioNextSeg);
cpy1 = y - vy * smooth * (1 - ratioNextSeg); // cp0 of next segment
nextCpx0 = x + vx * smooth * ratioNextSeg;
nextCpy0 = y + vy * smooth * ratioNextSeg; // Smooth constraint between point and next point.
// Avoid exceeding extreme after smoothing.
nextCpx0 = mathMin$5(nextCpx0, mathMax$5(nextX, x));
nextCpy0 = mathMin$5(nextCpy0, mathMax$5(nextY, y));
nextCpx0 = mathMax$5(nextCpx0, mathMin$5(nextX, x));
nextCpy0 = mathMax$5(nextCpy0, mathMin$5(nextY, y)); // Reclaculate cp1 based on the adjusted cp0 of next seg.
vx = nextCpx0 - x;
vy = nextCpy0 - y;
cpx1 = x - (vx * lenPrevSeg) / lenNextSeg;
cpy1 = y - (vy * lenPrevSeg) / lenNextSeg; // Smooth constraint between point and prev point.
// Avoid exceeding extreme after smoothing.
cpx1 = mathMin$5(cpx1, mathMax$5(prevX, x));
cpy1 = mathMin$5(cpy1, mathMax$5(prevY, y));
cpx1 = mathMax$5(cpx1, mathMin$5(prevX, x));
cpy1 = mathMax$5(cpy1, mathMin$5(prevY, y)); // Adjust next cp0 again.
vx = x - cpx1;
vy = y - cpy1;
nextCpx0 = x + (vx * lenNextSeg) / lenPrevSeg;
nextCpy0 = y + (vy * lenNextSeg) / lenPrevSeg;
}
}
ctx.bezierCurveTo(cpx0, cpy0, cpx1, cpy1, x, y);
cpx0 = nextCpx0;
cpy0 = nextCpy0;
} else {
ctx.lineTo(x, y);
}
}
prevX = x;
prevY = y;
idx += dir;
}
return k;
}
var ECPolylineShape =
/** @class */
(function () {
function ECPolylineShape() {
this.smooth = 0;
this.smoothConstraint = true;
}
return ECPolylineShape;
})();
var ECPolyline =
/** @class */
(function (_super) {
__extends(ECPolyline, _super);
function ECPolyline(opts) {
var _this = _super.call(this, opts) || this;
_this.type = "ec-polyline";
return _this;
}
ECPolyline.prototype.getDefaultStyle = function () {
return {
stroke: "#000",
fill: null,
};
};
ECPolyline.prototype.getDefaultShape = function () {
return new ECPolylineShape();
};
ECPolyline.prototype.buildPath = function (ctx, shape) {
var points = shape.points;
var i = 0;
var len = points.length / 2; // const result = getBoundingBox(points, shape.smoothConstraint);
if (shape.connectNulls) {
// Must remove first and last null values avoid draw error in polygon
for (; len > 0; len--) {
if (!isPointNull(points[len * 2 - 2], points[len * 2 - 1])) {
break;
}
}
for (; i < len; i++) {
if (!isPointNull(points[i * 2], points[i * 2 + 1])) {
break;
}
}
}
while (i < len) {
i +=
drawSegment(
ctx,
points,
i,
len,
len,
1,
shape.smooth,
shape.smoothMonotone,
shape.connectNulls,
) + 1;
}
};
ECPolyline.prototype.getPointOn = function (xOrY, dim) {
if (!this.path) {
this.createPathProxy();
this.buildPath(this.path, this.shape);
}
var path = this.path;
var data = path.data;
var CMD = PathProxy.CMD;
var x0;
var y0;
var isDimX = dim === "x";
var roots = [];
for (var i = 0; i < data.length; ) {
var cmd = data[i++];
var x = void 0;
var y = void 0;
var x2 = void 0;
var y2 = void 0;
var x3 = void 0;
var y3 = void 0;
var t = void 0;
switch (cmd) {
case CMD.M:
x0 = data[i++];
y0 = data[i++];
break;
case CMD.L:
x = data[i++];
y = data[i++];
t = isDimX ? (xOrY - x0) / (x - x0) : (xOrY - y0) / (y - y0);
if (t <= 1 && t >= 0) {
var val = isDimX ? (y - y0) * t + y0 : (x - x0) * t + x0;
return isDimX ? [xOrY, val] : [val, xOrY];
}
x0 = x;
y0 = y;
break;
case CMD.C:
x = data[i++];
y = data[i++];
x2 = data[i++];
y2 = data[i++];
x3 = data[i++];
y3 = data[i++];
var nRoot = isDimX
? cubicRootAt(x0, x, x2, x3, xOrY, roots)
: cubicRootAt(y0, y, y2, y3, xOrY, roots);
if (nRoot > 0) {
for (var i_1 = 0; i_1 < nRoot; i_1++) {
var t_1 = roots[i_1];
if (t_1 <= 1 && t_1 >= 0) {
var val = isDimX
? cubicAt(y0, y, y2, y3, t_1)
: cubicAt(x0, x, x2, x3, t_1);
return isDimX ? [xOrY, val] : [val, xOrY];
}
}
}
x0 = x3;
y0 = y3;
break;
}
}
};
return ECPolyline;
})(Path);
var ECPolygonShape =
/** @class */
(function (_super) {
__extends(ECPolygonShape, _super);
function ECPolygonShape() {
return (_super !== null && _super.apply(this, arguments)) || this;
}
return ECPolygonShape;
})(ECPolylineShape);
var ECPolygon =
/** @class */
(function (_super) {
__extends(ECPolygon, _super);
function ECPolygon(opts) {
var _this = _super.call(this, opts) || this;
_this.type = "ec-polygon";
return _this;
}
ECPolygon.prototype.getDefaultShape = function () {
return new ECPolygonShape();
};
ECPolygon.prototype.buildPath = function (ctx, shape) {
var points = shape.points;
var stackedOnPoints = shape.stackedOnPoints;
var i = 0;
var len = points.length / 2;
var smoothMonotone = shape.smoothMonotone;
if (shape.connectNulls) {
// Must remove first and last null values avoid draw error in polygon
for (; len > 0; len--) {
if (!isPointNull(points[len * 2 - 2], points[len * 2 - 1])) {
break;
}
}
for (; i < len; i++) {
if (!isPointNull(points[i * 2], points[i * 2 + 1])) {
break;
}
}
}
while (i < len) {
var k = drawSegment(
ctx,
points,
i,
len,
len,
1,
shape.smooth,
smoothMonotone,
shape.connectNulls,
);
drawSegment(
ctx,
stackedOnPoints,
i + k - 1,
k,
len,
-1,
shape.stackedOnSmooth,
smoothMonotone,
shape.connectNulls,
);
i += k + 1;
ctx.closePath();
}
};
return ECPolygon;
})(Path);
function createGridClipPath(
cartesian,
hasAnimation,
seriesModel,
done,
during,
) {
var rect = cartesian.getArea();
var x = rect.x;
var y = rect.y;
var width = rect.width;
var height = rect.height;
var lineWidth = seriesModel.get(["lineStyle", "width"]) || 2; // Expand the clip path a bit to avoid the border is clipped and looks thinner
x -= lineWidth / 2;
y -= lineWidth / 2;
width += lineWidth;
height += lineWidth; // fix: https://github.com/apache/incubator-echarts/issues/11369
x = Math.floor(x);
width = Math.round(width);
var clipPath = new Rect({
shape: {
x: x,
y: y,
width: width,
height: height,
},
});
if (hasAnimation) {
var baseAxis = cartesian.getBaseAxis();
var isHorizontal = baseAxis.isHorizontal();
var isAxisInversed = baseAxis.inverse;
if (isHorizontal) {
if (isAxisInversed) {
clipPath.shape.x += width;
}
clipPath.shape.width = 0;
} else {
if (!isAxisInversed) {
clipPath.shape.y += height;
}
clipPath.shape.height = 0;
}
var duringCb = isFunction(during)
? function (percent) {
during(percent, clipPath);
}
: null;
initProps(
clipPath,
{
shape: {
width: width,
height: height,
x: x,
y: y,
},
},
seriesModel,
null,
done,
duringCb,
);
}
return clipPath;
}
function createPolarClipPath(polar, hasAnimation, seriesModel) {
var sectorArea = polar.getArea(); // Avoid float number rounding error for symbol on the edge of axis extent.
var r0 = round(sectorArea.r0, 1);
var r = round(sectorArea.r, 1);
var clipPath = new Sector({
shape: {
cx: round(polar.cx, 1),
cy: round(polar.cy, 1),
r0: r0,
r: r,
startAngle: sectorArea.startAngle,
endAngle: sectorArea.endAngle,
clockwise: sectorArea.clockwise,
},
});
if (hasAnimation) {
var isRadial = polar.getBaseAxis().dim === "angle";
if (isRadial) {
clipPath.shape.endAngle = sectorArea.startAngle;
} else {
clipPath.shape.r = r0;
}
initProps(
clipPath,
{
shape: {
endAngle: sectorArea.endAngle,
r: r,
},
},
seriesModel,
);
}
return clipPath;
}
function createClipPath(coordSys, hasAnimation, seriesModel, done, during) {
if (!coordSys) {
return null;
} else if (coordSys.type === "polar") {
return createPolarClipPath(coordSys, hasAnimation, seriesModel);
} else if (coordSys.type === "cartesian2d") {
return createGridClipPath(
coordSys,
hasAnimation,
seriesModel,
done,
during,
);
}
return null;
}
/*
* 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.
*/
function isCoordinateSystemType(coordSys, type) {
return coordSys.type === type;
}
function isPointsSame(points1, points2) {
if (points1.length !== points2.length) {
return;
}
for (var i = 0; i < points1.length; i++) {
if (points1[i] !== points2[i]) {
return;
}
}
return true;
}
function bboxFromPoints(points) {
var minX = Infinity;
var minY = Infinity;
var maxX = -Infinity;
var maxY = -Infinity;
for (var i = 0; i < points.length; ) {
var x = points[i++];
var y = points[i++];
if (!isNaN(x)) {
minX = Math.min(x, minX);
maxX = Math.max(x, maxX);
}
if (!isNaN(y)) {
minY = Math.min(y, minY);
maxY = Math.max(y, maxY);
}
}
return [
[minX, minY],
[maxX, maxY],
];
}
function getBoundingDiff(points1, points2) {
var _a = bboxFromPoints(points1),
min1 = _a[0],
max1 = _a[1];
var _b = bboxFromPoints(points2),
min2 = _b[0],
max2 = _b[1]; // Get a max value from each corner of two boundings.
return Math.max(
Math.abs(min1[0] - min2[0]),
Math.abs(min1[1] - min2[1]),
Math.abs(max1[0] - max2[0]),
Math.abs(max1[1] - max2[1]),
);
}
function getSmooth(smooth) {
return isNumber(smooth) ? smooth : smooth ? 0.5 : 0;
}
function getStackedOnPoints(coordSys, data, dataCoordInfo) {
if (!dataCoordInfo.valueDim) {
return [];
}
var len = data.count();
var points = createFloat32Array(len * 2);
for (var idx = 0; idx < len; idx++) {
var pt = getStackedOnPoint(dataCoordInfo, coordSys, data, idx);
points[idx * 2] = pt[0];
points[idx * 2 + 1] = pt[1];
}
return points;
}
function turnPointsIntoStep(points, coordSys, stepTurnAt, connectNulls) {
var baseAxis = coordSys.getBaseAxis();
var baseIndex = baseAxis.dim === "x" || baseAxis.dim === "radius" ? 0 : 1;
var stepPoints = [];
var i = 0;
var stepPt = [];
var pt = [];
var nextPt = [];
var filteredPoints = [];
if (connectNulls) {
for (i = 0; i < points.length; i += 2) {
if (!isNaN(points[i]) && !isNaN(points[i + 1])) {
filteredPoints.push(points[i], points[i + 1]);
}
}
points = filteredPoints;
}
for (i = 0; i < points.length - 2; i += 2) {
nextPt[0] = points[i + 2];
nextPt[1] = points[i + 3];
pt[0] = points[i];
pt[1] = points[i + 1];
stepPoints.push(pt[0], pt[1]);
switch (stepTurnAt) {
case "end":
stepPt[baseIndex] = nextPt[baseIndex];
stepPt[1 - baseIndex] = pt[1 - baseIndex];
stepPoints.push(stepPt[0], stepPt[1]);
break;
case "middle":
var middle = (pt[baseIndex] + nextPt[baseIndex]) / 2;
var stepPt2 = [];
stepPt[baseIndex] = stepPt2[baseIndex] = middle;
stepPt[1 - baseIndex] = pt[1 - baseIndex];
stepPt2[1 - baseIndex] = nextPt[1 - baseIndex];
stepPoints.push(stepPt[0], stepPt[1]);
stepPoints.push(stepPt2[0], stepPt2[1]);
break;
default:
// default is start
stepPt[baseIndex] = pt[baseIndex];
stepPt[1 - baseIndex] = nextPt[1 - baseIndex];
stepPoints.push(stepPt[0], stepPt[1]);
}
} // Last points
stepPoints.push(points[i++], points[i++]);
return stepPoints;
}
/**
* Clip color stops to edge. Avoid creating too large gradients.
* Which may lead to blurry when GPU acceleration is enabled. See #15680
*
* The stops has been sorted from small to large.
*/
function clipColorStops(colorStops, maxSize) {
var newColorStops = [];
var len = colorStops.length; // coord will always < 0 in prevOutOfRangeColorStop.
var prevOutOfRangeColorStop;
var prevInRangeColorStop;
function lerpStop(stop0, stop1, clippedCoord) {
var coord0 = stop0.coord;
var p = (clippedCoord - coord0) / (stop1.coord - coord0);
var color = lerp$1(p, [stop0.color, stop1.color]);
return {
coord: clippedCoord,
color: color,
};
}
for (var i = 0; i < len; i++) {
var stop_1 = colorStops[i];
var coord = stop_1.coord;
if (coord < 0) {
prevOutOfRangeColorStop = stop_1;
} else if (coord > maxSize) {
if (prevInRangeColorStop) {
newColorStops.push(lerpStop(prevInRangeColorStop, stop_1, maxSize));
} else if (prevOutOfRangeColorStop) {
// If there are two stops and coord range is between these two stops
newColorStops.push(
lerpStop(prevOutOfRangeColorStop, stop_1, 0),
lerpStop(prevOutOfRangeColorStop, stop_1, maxSize),
);
} // All following stop will be out of range. So just ignore them.
break;
} else {
if (prevOutOfRangeColorStop) {
newColorStops.push(lerpStop(prevOutOfRangeColorStop, stop_1, 0)); // Reset
prevOutOfRangeColorStop = null;
}
newColorStops.push(stop_1);
prevInRangeColorStop = stop_1;
}
}
return newColorStops;
}
function getVisualGradient(data, coordSys, api) {
var visualMetaList = data.getVisual("visualMeta");
if (!visualMetaList || !visualMetaList.length || !data.count()) {
// When data.count() is 0, gradient range can not be calculated.
return;
}
if (coordSys.type !== "cartesian2d") {
if ("development" !== "production") {
console.warn(
"Visual map on line style is only supported on cartesian2d.",
);
}
return;
}
var coordDim;
var visualMeta;
for (var i = visualMetaList.length - 1; i >= 0; i--) {
var dimInfo = data.getDimensionInfo(visualMetaList[i].dimension);
coordDim = dimInfo && dimInfo.coordDim; // Can only be x or y
if (coordDim === "x" || coordDim === "y") {
visualMeta = visualMetaList[i];
break;
}
}
if (!visualMeta) {
if ("development" !== "production") {
console.warn("Visual map on line style only support x or y dimension.");
}
return;
} // If the area to be rendered is bigger than area defined by LinearGradient,
// the canvas spec prescribes that the color of the first stop and the last
// stop should be used. But if two stops are added at offset 0, in effect
// browsers use the color of the second stop to render area outside
// LinearGradient. So we can only infinitesimally extend area defined in
// LinearGradient to render `outerColors`.
var axis = coordSys.getAxis(coordDim); // dataToCoord mapping may not be linear, but must be monotonic.
var colorStops = map(visualMeta.stops, function (stop) {
// offset will be calculated later.
return {
coord: axis.toGlobalCoord(axis.dataToCoord(stop.value)),
color: stop.color,
};
});
var stopLen = colorStops.length;
var outerColors = visualMeta.outerColors.slice();
if (stopLen && colorStops[0].coord > colorStops[stopLen - 1].coord) {
colorStops.reverse();
outerColors.reverse();
}
var colorStopsInRange = clipColorStops(
colorStops,
coordDim === "x" ? api.getWidth() : api.getHeight(),
);
var inRangeStopLen = colorStopsInRange.length;
if (!inRangeStopLen && stopLen) {
// All stops are out of range. All will be the same color.
return colorStops[0].coord < 0
? outerColors[1]
? outerColors[1]
: colorStops[stopLen - 1].color
: outerColors[0]
? outerColors[0]
: colorStops[0].color;
}
var tinyExtent = 10; // Arbitrary value: 10px
var minCoord = colorStopsInRange[0].coord - tinyExtent;
var maxCoord = colorStopsInRange[inRangeStopLen - 1].coord + tinyExtent;
var coordSpan = maxCoord - minCoord;
if (coordSpan < 1e-3) {
return "transparent";
}
each(colorStopsInRange, function (stop) {
stop.offset = (stop.coord - minCoord) / coordSpan;
});
colorStopsInRange.push({
// NOTE: inRangeStopLen may still be 0 if stoplen is zero.
offset: inRangeStopLen
? colorStopsInRange[inRangeStopLen - 1].offset
: 0.5,
color: outerColors[1] || "transparent",
});
colorStopsInRange.unshift({
offset: inRangeStopLen ? colorStopsInRange[0].offset : 0.5,
color: outerColors[0] || "transparent",
});
var gradient = new LinearGradient(0, 0, 0, 0, colorStopsInRange, true);
gradient[coordDim] = minCoord;
gradient[coordDim + "2"] = maxCoord;
return gradient;
}
function getIsIgnoreFunc(seriesModel, data, coordSys) {
var showAllSymbol = seriesModel.get("showAllSymbol");
var isAuto = showAllSymbol === "auto";
if (showAllSymbol && !isAuto) {
return;
}
var categoryAxis = coordSys.getAxesByScale("ordinal")[0];
if (!categoryAxis) {
return;
} // Note that category label interval strategy might bring some weird effect
// in some scenario: users may wonder why some of the symbols are not
// displayed. So we show all symbols as possible as we can.
if (
isAuto && // Simplify the logic, do not determine label overlap here.
canShowAllSymbolForCategory(categoryAxis, data)
) {
return;
} // Otherwise follow the label interval strategy on category axis.
var categoryDataDim = data.mapDimension(categoryAxis.dim);
var labelMap = {};
each(categoryAxis.getViewLabels(), function (labelItem) {
var ordinalNumber = categoryAxis.scale.getRawOrdinalNumber(
labelItem.tickValue,
);
labelMap[ordinalNumber] = 1;
});
return function (dataIndex) {
return !labelMap.hasOwnProperty(data.get(categoryDataDim, dataIndex));
};
}
function canShowAllSymbolForCategory(categoryAxis, data) {
// In mose cases, line is monotonous on category axis, and the label size
// is close with each other. So we check the symbol size and some of the
// label size alone with the category axis to estimate whether all symbol
// can be shown without overlap.
var axisExtent = categoryAxis.getExtent();
var availSize =
Math.abs(axisExtent[1] - axisExtent[0]) / categoryAxis.scale.count();
isNaN(availSize) && (availSize = 0); // 0/0 is NaN.
// Sampling some points, max 5.
var dataLen = data.count();
var step = Math.max(1, Math.round(dataLen / 5));
for (var dataIndex = 0; dataIndex < dataLen; dataIndex += step) {
if (
Symbol.getSymbolSize(
data,
dataIndex, // Only for cartesian, where `isHorizontal` exists.
)[categoryAxis.isHorizontal() ? 1 : 0] * // Empirical number
1.5 >
availSize
) {
return false;
}
}
return true;
}
function isPointNull$1(x, y) {
return isNaN(x) || isNaN(y);
}
function getLastIndexNotNull(points) {
var len = points.length / 2;
for (; len > 0; len--) {
if (!isPointNull$1(points[len * 2 - 2], points[len * 2 - 1])) {
break;
}
}
return len - 1;
}
function getPointAtIndex(points, idx) {
return [points[idx * 2], points[idx * 2 + 1]];
}
function getIndexRange(points, xOrY, dim) {
var len = points.length / 2;
var dimIdx = dim === "x" ? 0 : 1;
var a;
var b;
var prevIndex = 0;
var nextIndex = -1;
for (var i = 0; i < len; i++) {
b = points[i * 2 + dimIdx];
if (isNaN(b) || isNaN(points[i * 2 + 1 - dimIdx])) {
continue;
}
if (i === 0) {
a = b;
continue;
}
if ((a <= xOrY && b >= xOrY) || (a >= xOrY && b <= xOrY)) {
nextIndex = i;
break;
}
prevIndex = i;
a = b;
}
return {
range: [prevIndex, nextIndex],
t: (xOrY - a) / (b - a),
};
}
function anyStateShowEndLabel(seriesModel) {
if (seriesModel.get(["endLabel", "show"])) {
return true;
}
for (var i = 0; i < SPECIAL_STATES.length; i++) {
if (seriesModel.get([SPECIAL_STATES[i], "endLabel", "show"])) {
return true;
}
}
return false;
}
function createLineClipPath(lineView, coordSys, hasAnimation, seriesModel) {
if (isCoordinateSystemType(coordSys, "cartesian2d")) {
var endLabelModel_1 = seriesModel.getModel("endLabel");
var valueAnimation_1 = endLabelModel_1.get("valueAnimation");
var data_1 = seriesModel.getData();
var labelAnimationRecord_1 = {
lastFrameIndex: 0,
};
var during = anyStateShowEndLabel(seriesModel)
? function (percent, clipRect) {
lineView._endLabelOnDuring(
percent,
clipRect,
data_1,
labelAnimationRecord_1,
valueAnimation_1,
endLabelModel_1,
coordSys,
);
}
: null;
var isHorizontal = coordSys.getBaseAxis().isHorizontal();
var clipPath = createGridClipPath(
coordSys,
hasAnimation,
seriesModel,
function () {
var endLabel = lineView._endLabel;
if (endLabel && hasAnimation) {
if (labelAnimationRecord_1.originalX != null) {
endLabel.attr({
x: labelAnimationRecord_1.originalX,
y: labelAnimationRecord_1.originalY,
});
}
}
},
during,
); // Expand clip shape to avoid clipping when line value exceeds axis
if (!seriesModel.get("clip", true)) {
var rectShape = clipPath.shape;
var expandSize = Math.max(rectShape.width, rectShape.height);
if (isHorizontal) {
rectShape.y -= expandSize;
rectShape.height += expandSize * 2;
} else {
rectShape.x -= expandSize;
rectShape.width += expandSize * 2;
}
} // Set to the final frame. To make sure label layout is right.
if (during) {
during(1, clipPath);
}
return clipPath;
} else {
if ("development" !== "production") {
if (seriesModel.get(["endLabel", "show"])) {
console.warn("endLabel is not supported for lines in polar systems.");
}
}
return createPolarClipPath(coordSys, hasAnimation, seriesModel);
}
}
function getEndLabelStateSpecified(endLabelModel, coordSys) {
var baseAxis = coordSys.getBaseAxis();
var isHorizontal = baseAxis.isHorizontal();
var isBaseInversed = baseAxis.inverse;
var align = isHorizontal ? (isBaseInversed ? "right" : "left") : "center";
var verticalAlign = isHorizontal
? "middle"
: isBaseInversed
? "top"
: "bottom";
return {
normal: {
align: endLabelModel.get("align") || align,
verticalAlign: endLabelModel.get("verticalAlign") || verticalAlign,
},
};
}
var LineView =
/** @class */
(function (_super) {
__extends(LineView, _super);
function LineView() {
return (_super !== null && _super.apply(this, arguments)) || this;
}
LineView.prototype.init = function () {
var lineGroup = new Group();
var symbolDraw = new SymbolDraw();
this.group.add(symbolDraw.group);
this._symbolDraw = symbolDraw;
this._lineGroup = lineGroup;
};
LineView.prototype.render = function (seriesModel, ecModel, api) {
var _this = this;
var coordSys = seriesModel.coordinateSystem;
var group = this.group;
var data = seriesModel.getData();
var lineStyleModel = seriesModel.getModel("lineStyle");
var areaStyleModel = seriesModel.getModel("areaStyle");
var points = data.getLayout("points") || [];
var isCoordSysPolar = coordSys.type === "polar";
var prevCoordSys = this._coordSys;
var symbolDraw = this._symbolDraw;
var polyline = this._polyline;
var polygon = this._polygon;
var lineGroup = this._lineGroup;
var hasAnimation = seriesModel.get("animation");
var isAreaChart = !areaStyleModel.isEmpty();
var valueOrigin = areaStyleModel.get("origin");
var dataCoordInfo = prepareDataCoordInfo(coordSys, data, valueOrigin);
var stackedOnPoints =
isAreaChart && getStackedOnPoints(coordSys, data, dataCoordInfo);
var showSymbol = seriesModel.get("showSymbol");
var connectNulls = seriesModel.get("connectNulls");
var isIgnoreFunc =
showSymbol &&
!isCoordSysPolar &&
getIsIgnoreFunc(seriesModel, data, coordSys); // Remove temporary symbols
var oldData = this._data;
oldData &&
oldData.eachItemGraphicEl(function (el, idx) {
if (el.__temp) {
group.remove(el);
oldData.setItemGraphicEl(idx, null);
}
}); // Remove previous created symbols if showSymbol changed to false
if (!showSymbol) {
symbolDraw.remove();
}
group.add(lineGroup); // FIXME step not support polar
var step = !isCoordSysPolar ? seriesModel.get("step") : false;
var clipShapeForSymbol;
if (coordSys && coordSys.getArea && seriesModel.get("clip", true)) {
clipShapeForSymbol = coordSys.getArea(); // Avoid float number rounding error for symbol on the edge of axis extent.
// See #7913 and `test/dataZoom-clip.html`.
if (clipShapeForSymbol.width != null) {
clipShapeForSymbol.x -= 0.1;
clipShapeForSymbol.y -= 0.1;
clipShapeForSymbol.width += 0.2;
clipShapeForSymbol.height += 0.2;
} else if (clipShapeForSymbol.r0) {
clipShapeForSymbol.r0 -= 0.5;
clipShapeForSymbol.r += 0.5;
}
}
this._clipShapeForSymbol = clipShapeForSymbol;
var visualColor =
getVisualGradient(data, coordSys, api) ||
data.getVisual("style")[data.getVisual("drawType")]; // Initialization animation or coordinate system changed
if (
!(
polyline &&
prevCoordSys.type === coordSys.type &&
step === this._step
)
) {
showSymbol &&
symbolDraw.updateData(data, {
isIgnore: isIgnoreFunc,
clipShape: clipShapeForSymbol,
disableAnimation: true,
getSymbolPoint: function (idx) {
return [points[idx * 2], points[idx * 2 + 1]];
},
});
hasAnimation &&
this._initSymbolLabelAnimation(data, coordSys, clipShapeForSymbol);
if (step) {
// TODO If stacked series is not step
points = turnPointsIntoStep(points, coordSys, step, connectNulls);
if (stackedOnPoints) {
stackedOnPoints = turnPointsIntoStep(
stackedOnPoints,
coordSys,
step,
connectNulls,
);
}
}
polyline = this._newPolyline(points);
if (isAreaChart) {
polygon = this._newPolygon(points, stackedOnPoints);
} // NOTE: Must update _endLabel before setClipPath.
if (!isCoordSysPolar) {
this._initOrUpdateEndLabel(
seriesModel,
coordSys,
convertToColorString(visualColor),
);
}
lineGroup.setClipPath(
createLineClipPath(this, coordSys, true, seriesModel),
);
} else {
if (isAreaChart && !polygon) {
// If areaStyle is added
polygon = this._newPolygon(points, stackedOnPoints);
} else if (polygon && !isAreaChart) {
// If areaStyle is removed
lineGroup.remove(polygon);
polygon = this._polygon = null;
} // NOTE: Must update _endLabel before setClipPath.
if (!isCoordSysPolar) {
this._initOrUpdateEndLabel(
seriesModel,
coordSys,
convertToColorString(visualColor),
);
} // Update clipPath
var oldClipPath = lineGroup.getClipPath();
if (oldClipPath) {
var newClipPath = createLineClipPath(
this,
coordSys,
false,
seriesModel,
);
initProps(
oldClipPath,
{
shape: newClipPath.shape,
},
seriesModel,
);
} else {
lineGroup.setClipPath(
createLineClipPath(this, coordSys, true, seriesModel),
);
} // Always update, or it is wrong in the case turning on legend
// because points are not changed
showSymbol &&
symbolDraw.updateData(data, {
isIgnore: isIgnoreFunc,
clipShape: clipShapeForSymbol,
disableAnimation: true,
getSymbolPoint: function (idx) {
return [points[idx * 2], points[idx * 2 + 1]];
},
}); // In the case data zoom triggerred refreshing frequently
// Data may not change if line has a category axis. So it should animate nothing
if (
!isPointsSame(this._stackedOnPoints, stackedOnPoints) ||
!isPointsSame(this._points, points)
) {
if (hasAnimation) {
this._doUpdateAnimation(
data,
stackedOnPoints,
coordSys,
api,
step,
valueOrigin,
connectNulls,
);
} else {
// Not do it in update with animation
if (step) {
// TODO If stacked series is not step
points = turnPointsIntoStep(
points,
coordSys,
step,
connectNulls,
);
if (stackedOnPoints) {
stackedOnPoints = turnPointsIntoStep(
stackedOnPoints,
coordSys,
step,
connectNulls,
);
}
}
polyline.setShape({
points: points,
});
polygon &&
polygon.setShape({
points: points,
stackedOnPoints: stackedOnPoints,
});
}
}
}
var emphasisModel = seriesModel.getModel("emphasis");
var focus = emphasisModel.get("focus");
var blurScope = emphasisModel.get("blurScope");
var emphasisDisabled = emphasisModel.get("disabled");
polyline.useStyle(
defaults(
// Use color in lineStyle first
lineStyleModel.getLineStyle(),
{
fill: "none",
stroke: visualColor,
lineJoin: "bevel",
},
),
);
setStatesStylesFromModel(polyline, seriesModel, "lineStyle");
if (
polyline.style.lineWidth > 0 &&
seriesModel.get(["emphasis", "lineStyle", "width"]) === "bolder"
) {
var emphasisLineStyle = polyline.getState("emphasis").style;
emphasisLineStyle.lineWidth = +polyline.style.lineWidth + 1;
} // Needs seriesIndex for focus
getECData(polyline).seriesIndex = seriesModel.seriesIndex;
toggleHoverEmphasis(polyline, focus, blurScope, emphasisDisabled);
var smooth = getSmooth(seriesModel.get("smooth"));
var smoothMonotone = seriesModel.get("smoothMonotone");
polyline.setShape({
smooth: smooth,
smoothMonotone: smoothMonotone,
connectNulls: connectNulls,
});
if (polygon) {
var stackedOnSeries = data.getCalculationInfo("stackedOnSeries");
var stackedOnSmooth = 0;
polygon.useStyle(
defaults(areaStyleModel.getAreaStyle(), {
fill: visualColor,
opacity: 0.7,
lineJoin: "bevel",
decal: data.getVisual("style").decal,
}),
);
if (stackedOnSeries) {
stackedOnSmooth = getSmooth(stackedOnSeries.get("smooth"));
}
polygon.setShape({
smooth: smooth,
stackedOnSmooth: stackedOnSmooth,
smoothMonotone: smoothMonotone,
connectNulls: connectNulls,
});
setStatesStylesFromModel(polygon, seriesModel, "areaStyle"); // Needs seriesIndex for focus
getECData(polygon).seriesIndex = seriesModel.seriesIndex;
toggleHoverEmphasis(polygon, focus, blurScope, emphasisDisabled);
}
var changePolyState = function (toState) {
_this._changePolyState(toState);
};
data.eachItemGraphicEl(function (el) {
// Switch polyline / polygon state if element changed its state.
el && (el.onHoverStateChange = changePolyState);
});
this._polyline.onHoverStateChange = changePolyState;
this._data = data; // Save the coordinate system for transition animation when data changed
this._coordSys = coordSys;
this._stackedOnPoints = stackedOnPoints;
this._points = points;
this._step = step;
this._valueOrigin = valueOrigin;
if (seriesModel.get("triggerLineEvent")) {
this.packEventData(seriesModel, polyline);
polygon && this.packEventData(seriesModel, polygon);
}
};
LineView.prototype.packEventData = function (seriesModel, el) {
getECData(el).eventData = {
componentType: "series",
componentSubType: "line",
componentIndex: seriesModel.componentIndex,
seriesIndex: seriesModel.seriesIndex,
seriesName: seriesModel.name,
seriesType: "line",
};
};
LineView.prototype.highlight = function (
seriesModel,
ecModel,
api,
payload,
) {
var data = seriesModel.getData();
var dataIndex = queryDataIndex(data, payload);
this._changePolyState("emphasis");
if (
!(dataIndex instanceof Array) &&
dataIndex != null &&
dataIndex >= 0
) {
var points = data.getLayout("points");
var symbol = data.getItemGraphicEl(dataIndex);
if (!symbol) {
// Create a temporary symbol if it is not exists
var x = points[dataIndex * 2];
var y = points[dataIndex * 2 + 1];
if (isNaN(x) || isNaN(y)) {
// Null data
return;
} // fix #11360: should't draw symbol outside clipShapeForSymbol
if (
this._clipShapeForSymbol &&
!this._clipShapeForSymbol.contain(x, y)
) {
return;
}
var zlevel = seriesModel.get("zlevel");
var z = seriesModel.get("z");
symbol = new Symbol(data, dataIndex);
symbol.x = x;
symbol.y = y;
symbol.setZ(zlevel, z); // ensure label text of the temporary symbol is in front of line and area polygon
var symbolLabel = symbol.getSymbolPath().getTextContent();
if (symbolLabel) {
symbolLabel.zlevel = zlevel;
symbolLabel.z = z;
symbolLabel.z2 = this._polyline.z2 + 1;
}
symbol.__temp = true;
data.setItemGraphicEl(dataIndex, symbol); // Stop scale animation
symbol.stopSymbolAnimation(true);
this.group.add(symbol);
}
symbol.highlight();
} else {
// Highlight whole series
ChartView.prototype.highlight.call(
this,
seriesModel,
ecModel,
api,
payload,
);
}
};
LineView.prototype.downplay = function (
seriesModel,
ecModel,
api,
payload,
) {
var data = seriesModel.getData();
var dataIndex = queryDataIndex(data, payload);
this._changePolyState("normal");
if (dataIndex != null && dataIndex >= 0) {
var symbol = data.getItemGraphicEl(dataIndex);
if (symbol) {
if (symbol.__temp) {
data.setItemGraphicEl(dataIndex, null);
this.group.remove(symbol);
} else {
symbol.downplay();
}
}
} else {
// FIXME
// can not downplay completely.
// Downplay whole series
ChartView.prototype.downplay.call(
this,
seriesModel,
ecModel,
api,
payload,
);
}
};
LineView.prototype._changePolyState = function (toState) {
var polygon = this._polygon;
setStatesFlag(this._polyline, toState);
polygon && setStatesFlag(polygon, toState);
};
LineView.prototype._newPolyline = function (points) {
var polyline = this._polyline; // Remove previous created polyline
if (polyline) {
this._lineGroup.remove(polyline);
}
polyline = new ECPolyline({
shape: {
points: points,
},
segmentIgnoreThreshold: 2,
z2: 10,
});
this._lineGroup.add(polyline);
this._polyline = polyline;
return polyline;
};
LineView.prototype._newPolygon = function (points, stackedOnPoints) {
var polygon = this._polygon; // Remove previous created polygon
if (polygon) {
this._lineGroup.remove(polygon);
}
polygon = new ECPolygon({
shape: {
points: points,
stackedOnPoints: stackedOnPoints,
},
segmentIgnoreThreshold: 2,
});
this._lineGroup.add(polygon);
this._polygon = polygon;
return polygon;
};
LineView.prototype._initSymbolLabelAnimation = function (
data,
coordSys,
clipShape,
) {
var isHorizontalOrRadial;
var isCoordSysPolar;
var baseAxis = coordSys.getBaseAxis();
var isAxisInverse = baseAxis.inverse;
if (coordSys.type === "cartesian2d") {
isHorizontalOrRadial = baseAxis.isHorizontal();
isCoordSysPolar = false;
} else if (coordSys.type === "polar") {
isHorizontalOrRadial = baseAxis.dim === "angle";
isCoordSysPolar = true;
}
var seriesModel = data.hostModel;
var seriesDuration = seriesModel.get("animationDuration");
if (isFunction(seriesDuration)) {
seriesDuration = seriesDuration(null);
}
var seriesDalay = seriesModel.get("animationDelay") || 0;
var seriesDalayValue = isFunction(seriesDalay)
? seriesDalay(null)
: seriesDalay;
data.eachItemGraphicEl(function (symbol, idx) {
var el = symbol;
if (el) {
var point = [symbol.x, symbol.y];
var start = void 0;
var end = void 0;
var current = void 0;
if (clipShape) {
if (isCoordSysPolar) {
var polarClip = clipShape;
var coord = coordSys.pointToCoord(point);
if (isHorizontalOrRadial) {
start = polarClip.startAngle;
end = polarClip.endAngle;
current = (-coord[1] / 180) * Math.PI;
} else {
start = polarClip.r0;
end = polarClip.r;
current = coord[0];
}
} else {
var gridClip = clipShape;
if (isHorizontalOrRadial) {
start = gridClip.x;
end = gridClip.x + gridClip.width;
current = symbol.x;
} else {
start = gridClip.y + gridClip.height;
end = gridClip.y;
current = symbol.y;
}
}
}
var ratio = end === start ? 0 : (current - start) / (end - start);
if (isAxisInverse) {
ratio = 1 - ratio;
}
var delay = isFunction(seriesDalay)
? seriesDalay(idx)
: seriesDuration * ratio + seriesDalayValue;
var symbolPath = el.getSymbolPath();
var text = symbolPath.getTextContent();
el.attr({
scaleX: 0,
scaleY: 0,
});
el.animateTo(
{
scaleX: 1,
scaleY: 1,
},
{
duration: 200,
setToFinal: true,
delay: delay,
},
);
if (text) {
text.animateFrom(
{
style: {
opacity: 0,
},
},
{
duration: 300,
delay: delay,
},
);
}
symbolPath.disableLabelAnimation = true;
}
});
};
LineView.prototype._initOrUpdateEndLabel = function (
seriesModel,
coordSys,
inheritColor,
) {
var endLabelModel = seriesModel.getModel("endLabel");
if (anyStateShowEndLabel(seriesModel)) {
var data_2 = seriesModel.getData();
var polyline = this._polyline; // series may be filtered.
var points = data_2.getLayout("points");
if (!points) {
polyline.removeTextContent();
this._endLabel = null;
return;
}
var endLabel = this._endLabel;
if (!endLabel) {
endLabel = this._endLabel = new ZRText({
z2: 200, // should be higher than item symbol
});
endLabel.ignoreClip = true;
polyline.setTextContent(this._endLabel);
polyline.disableLabelAnimation = true;
} // Find last non-NaN data to display data
var dataIndex = getLastIndexNotNull(points);
if (dataIndex >= 0) {
setLabelStyle(
polyline,
getLabelStatesModels(seriesModel, "endLabel"),
{
inheritColor: inheritColor,
labelFetcher: seriesModel,
labelDataIndex: dataIndex,
defaultText: function (dataIndex, opt, interpolatedValue) {
return interpolatedValue != null
? getDefaultInterpolatedLabel(data_2, interpolatedValue)
: getDefaultLabel(data_2, dataIndex);
},
enableTextSetter: true,
},
getEndLabelStateSpecified(endLabelModel, coordSys),
);
polyline.textConfig.position = null;
}
} else if (this._endLabel) {
this._polyline.removeTextContent();
this._endLabel = null;
}
};
LineView.prototype._endLabelOnDuring = function (
percent,
clipRect,
data,
animationRecord,
valueAnimation,
endLabelModel,
coordSys,
) {
var endLabel = this._endLabel;
var polyline = this._polyline;
if (endLabel) {
// NOTE: Don't remove percent < 1. percent === 1 means the first frame during render.
// The label is not prepared at this time.
if (percent < 1 && animationRecord.originalX == null) {
animationRecord.originalX = endLabel.x;
animationRecord.originalY = endLabel.y;
}
var points = data.getLayout("points");
var seriesModel = data.hostModel;
var connectNulls = seriesModel.get("connectNulls");
var precision = endLabelModel.get("precision");
var distance = endLabelModel.get("distance") || 0;
var baseAxis = coordSys.getBaseAxis();
var isHorizontal = baseAxis.isHorizontal();
var isBaseInversed = baseAxis.inverse;
var clipShape = clipRect.shape;
var xOrY = isBaseInversed
? isHorizontal
? clipShape.x
: clipShape.y + clipShape.height
: isHorizontal
? clipShape.x + clipShape.width
: clipShape.y;
var distanceX =
(isHorizontal ? distance : 0) * (isBaseInversed ? -1 : 1);
var distanceY =
(isHorizontal ? 0 : -distance) * (isBaseInversed ? -1 : 1);
var dim = isHorizontal ? "x" : "y";
var dataIndexRange = getIndexRange(points, xOrY, dim);
var indices = dataIndexRange.range;
var diff = indices[1] - indices[0];
var value = void 0;
if (diff >= 1) {
// diff > 1 && connectNulls, which is on the null data.
if (diff > 1 && !connectNulls) {
var pt = getPointAtIndex(points, indices[0]);
endLabel.attr({
x: pt[0] + distanceX,
y: pt[1] + distanceY,
});
valueAnimation && (value = seriesModel.getRawValue(indices[0]));
} else {
var pt = polyline.getPointOn(xOrY, dim);
pt &&
endLabel.attr({
x: pt[0] + distanceX,
y: pt[1] + distanceY,
});
var startValue = seriesModel.getRawValue(indices[0]);
var endValue = seriesModel.getRawValue(indices[1]);
valueAnimation &&
(value = interpolateRawValues(
data,
precision,
startValue,
endValue,
dataIndexRange.t,
));
}
animationRecord.lastFrameIndex = indices[0];
} else {
// If diff <= 0, which is the range is not found(Include NaN)
// Choose the first point or last point.
var idx =
percent === 1 || animationRecord.lastFrameIndex > 0
? indices[0]
: 0;
var pt = getPointAtIndex(points, idx);
valueAnimation && (value = seriesModel.getRawValue(idx));
endLabel.attr({
x: pt[0] + distanceX,
y: pt[1] + distanceY,
});
}
if (valueAnimation) {
labelInner(endLabel).setLabelText(value);
}
}
};
/**
* @private
*/
// FIXME Two value axis
LineView.prototype._doUpdateAnimation = function (
data,
stackedOnPoints,
coordSys,
api,
step,
valueOrigin,
connectNulls,
) {
var polyline = this._polyline;
var polygon = this._polygon;
var seriesModel = data.hostModel;
var diff = lineAnimationDiff(
this._data,
data,
this._stackedOnPoints,
stackedOnPoints,
this._coordSys,
coordSys,
this._valueOrigin,
);
var current = diff.current;
var stackedOnCurrent = diff.stackedOnCurrent;
var next = diff.next;
var stackedOnNext = diff.stackedOnNext;
if (step) {
// TODO If stacked series is not step
current = turnPointsIntoStep(
diff.current,
coordSys,
step,
connectNulls,
);
stackedOnCurrent = turnPointsIntoStep(
diff.stackedOnCurrent,
coordSys,
step,
connectNulls,
);
next = turnPointsIntoStep(diff.next, coordSys, step, connectNulls);
stackedOnNext = turnPointsIntoStep(
diff.stackedOnNext,
coordSys,
step,
connectNulls,
);
} // Don't apply animation if diff is large.
// For better result and avoid memory explosion problems like
// https://github.com/apache/incubator-echarts/issues/12229
if (
getBoundingDiff(current, next) > 3000 ||
(polygon && getBoundingDiff(stackedOnCurrent, stackedOnNext) > 3000)
) {
polyline.stopAnimation();
polyline.setShape({
points: next,
});
if (polygon) {
polygon.stopAnimation();
polygon.setShape({
points: next,
stackedOnPoints: stackedOnNext,
});
}
return;
}
polyline.shape.__points = diff.current;
polyline.shape.points = current;
var target = {
shape: {
points: next,
},
}; // Also animate the original points.
// If points reference is changed when turning into step line.
if (diff.current !== current) {
target.shape.__points = diff.next;
} // Stop previous animation.
polyline.stopAnimation();
updateProps(polyline, target, seriesModel);
if (polygon) {
polygon.setShape({
// Reuse the points with polyline.
points: current,
stackedOnPoints: stackedOnCurrent,
});
polygon.stopAnimation();
updateProps(
polygon,
{
shape: {
stackedOnPoints: stackedOnNext,
},
},
seriesModel,
); // If use attr directly in updateProps.
if (polyline.shape.points !== polygon.shape.points) {
polygon.shape.points = polyline.shape.points;
}
}
var updatedDataInfo = [];
var diffStatus = diff.status;
for (var i = 0; i < diffStatus.length; i++) {
var cmd = diffStatus[i].cmd;
if (cmd === "=") {
var el = data.getItemGraphicEl(diffStatus[i].idx1);
if (el) {
updatedDataInfo.push({
el: el,
ptIdx: i, // Index of points
});
}
}
}
if (polyline.animators && polyline.animators.length) {
polyline.animators[0].during(function () {
polygon && polygon.dirtyShape();
var points = polyline.shape.__points;
for (var i = 0; i < updatedDataInfo.length; i++) {
var el = updatedDataInfo[i].el;
var offset = updatedDataInfo[i].ptIdx * 2;
el.x = points[offset];
el.y = points[offset + 1];
el.markRedraw();
}
});
}
};
LineView.prototype.remove = function (ecModel) {
var group = this.group;
var oldData = this._data;
this._lineGroup.removeAll();
this._symbolDraw.remove(true); // Remove temporary created elements when highlighting
oldData &&
oldData.eachItemGraphicEl(function (el, idx) {
if (el.__temp) {
group.remove(el);
oldData.setItemGraphicEl(idx, null);
}
});
this._polyline =
this._polygon =
this._coordSys =
this._points =
this._stackedOnPoints =
this._endLabel =
this._data =
null;
};
LineView.type = "line";
return LineView;
})(ChartView);
function pointsLayout(seriesType, forceStoreInTypedArray) {
return {
seriesType: seriesType,
plan: createRenderPlanner(),
reset: function (seriesModel) {
var data = seriesModel.getData();
var coordSys = seriesModel.coordinateSystem;
var pipelineContext = seriesModel.pipelineContext;
var useTypedArray = forceStoreInTypedArray || pipelineContext.large;
if (!coordSys) {
return;
}
var dims = map(coordSys.dimensions, function (dim) {
return data.mapDimension(dim);
}).slice(0, 2);
var dimLen = dims.length;
var stackResultDim = data.getCalculationInfo("stackResultDimension");
if (isDimensionStacked(data, dims[0])) {
dims[0] = stackResultDim;
}
if (isDimensionStacked(data, dims[1])) {
dims[1] = stackResultDim;
}
var store = data.getStore();
var dimIdx0 = data.getDimensionIndex(dims[0]);
var dimIdx1 = data.getDimensionIndex(dims[1]);
return (
dimLen && {
progress: function (params, data) {
var segCount = params.end - params.start;
var points =
useTypedArray && createFloat32Array(segCount * dimLen);
var tmpIn = [];
var tmpOut = [];
for (var i = params.start, offset = 0; i < params.end; i++) {
var point = void 0;
if (dimLen === 1) {
var x = store.get(dimIdx0, i); // NOTE: Make sure the second parameter is null to use default strategy.
point = coordSys.dataToPoint(x, null, tmpOut);
} else {
tmpIn[0] = store.get(dimIdx0, i);
tmpIn[1] = store.get(dimIdx1, i); // Let coordinate system to handle the NaN data.
point = coordSys.dataToPoint(tmpIn, null, tmpOut);
}
if (useTypedArray) {
points[offset++] = point[0];
points[offset++] = point[1];
} else {
data.setItemLayout(i, point.slice());
}
}
useTypedArray && data.setLayout("points", points);
},
}
);
},
};
}
var samplers = {
average: function (frame) {
var sum = 0;
var count = 0;
for (var i = 0; i < frame.length; i++) {
if (!isNaN(frame[i])) {
sum += frame[i];
count++;
}
} // Return NaN if count is 0
return count === 0 ? NaN : sum / count;
},
sum: function (frame) {
var sum = 0;
for (var i = 0; i < frame.length; i++) {
// Ignore NaN
sum += frame[i] || 0;
}
return sum;
},
max: function (frame) {
var max = -Infinity;
for (var i = 0; i < frame.length; i++) {
frame[i] > max && (max = frame[i]);
} // NaN will cause illegal axis extent.
return isFinite(max) ? max : NaN;
},
min: function (frame) {
var min = Infinity;
for (var i = 0; i < frame.length; i++) {
frame[i] < min && (min = frame[i]);
} // NaN will cause illegal axis extent.
return isFinite(min) ? min : NaN;
},
// TODO
// Median
nearest: function (frame) {
return frame[0];
},
};
var indexSampler = function (frame) {
return Math.round(frame.length / 2);
};
function dataSample(seriesType) {
return {
seriesType: seriesType,
// FIXME:TS never used, so comment it
// modifyOutputEnd: true,
reset: function (seriesModel, ecModel, api) {
var data = seriesModel.getData();
var sampling = seriesModel.get("sampling");
var coordSys = seriesModel.coordinateSystem;
var count = data.count(); // Only cartesian2d support down sampling. Disable it when there is few data.
if (count > 10 && coordSys.type === "cartesian2d" && sampling) {
var baseAxis = coordSys.getBaseAxis();
var valueAxis = coordSys.getOtherAxis(baseAxis);
var extent = baseAxis.getExtent();
var dpr = api.getDevicePixelRatio(); // Coordinste system has been resized
var size = Math.abs(extent[1] - extent[0]) * (dpr || 1);
var rate = Math.round(count / size);
if (isFinite(rate) && rate > 1) {
if (sampling === "lttb") {
seriesModel.setData(
data.lttbDownSample(data.mapDimension(valueAxis.dim), 1 / rate),
);
}
var sampler = void 0;
if (isString(sampling)) {
sampler = samplers[sampling];
} else if (isFunction(sampling)) {
sampler = sampling;
}
if (sampler) {
// Only support sample the first dim mapped from value axis.
seriesModel.setData(
data.downSample(
data.mapDimension(valueAxis.dim),
1 / rate,
sampler,
indexSampler,
),
);
}
}
}
},
};
}
function install$2(registers) {
registers.registerChartView(LineView);
registers.registerSeriesModel(LineSeriesModel);
registers.registerLayout(pointsLayout("line", true));
registers.registerVisual({
seriesType: "line",
reset: function (seriesModel) {
var data = seriesModel.getData(); // Visual coding for legend
var lineStyle = seriesModel.getModel("lineStyle").getLineStyle();
if (lineStyle && !lineStyle.stroke) {
// Fill in visual should be palette color if
// has color callback
lineStyle.stroke = data.getVisual("style").fill;
}
data.setVisual("legendLineStyle", lineStyle);
},
}); // Down sample after filter
registers.registerProcessor(
registers.PRIORITY.PROCESSOR.STATISTIC,
dataSample("line"),
);
}
var BaseBarSeriesModel =
/** @class */
(function (_super) {
__extends(BaseBarSeriesModel, _super);
function BaseBarSeriesModel() {
var _this = (_super !== null && _super.apply(this, arguments)) || this;
_this.type = BaseBarSeriesModel.type;
return _this;
}
BaseBarSeriesModel.prototype.getInitialData = function (option, ecModel) {
return createSeriesData(null, this, {
useEncodeDefaulter: true,
});
};
BaseBarSeriesModel.prototype.getMarkerPosition = function (value) {
var coordSys = this.coordinateSystem;
if (coordSys && coordSys.clampData) {
// PENDING if clamp ?
var pt = coordSys.dataToPoint(coordSys.clampData(value));
var data = this.getData();
var offset = data.getLayout("offset");
var size = data.getLayout("size");
var offsetIndex = coordSys.getBaseAxis().isHorizontal() ? 0 : 1;
pt[offsetIndex] += offset + size / 2;
return pt;
}
return [NaN, NaN];
};
BaseBarSeriesModel.type = "series.__base_bar__";
BaseBarSeriesModel.defaultOption = {
// zlevel: 0,
z: 2,
coordinateSystem: "cartesian2d",
legendHoverLink: true,
// stack: null
// Cartesian coordinate system
// xAxisIndex: 0,
// yAxisIndex: 0,
barMinHeight: 0,
barMinAngle: 0,
// cursor: null,
large: false,
largeThreshold: 400,
progressive: 3e3,
progressiveChunkMode: "mod",
};
return BaseBarSeriesModel;
})(SeriesModel);
SeriesModel.registerClass(BaseBarSeriesModel);
var BarSeriesModel =
/** @class */
(function (_super) {
__extends(BarSeriesModel, _super);
function BarSeriesModel() {
var _this = (_super !== null && _super.apply(this, arguments)) || this;
_this.type = BarSeriesModel.type;
return _this;
}
BarSeriesModel.prototype.getInitialData = function () {
return createSeriesData(null, this, {
useEncodeDefaulter: true,
createInvertedIndices: !!this.get("realtimeSort", true) || null,
});
};
/**
* @override
*/
BarSeriesModel.prototype.getProgressive = function () {
// Do not support progressive in normal mode.
return this.get("large") ? this.get("progressive") : false;
};
/**
* @override
*/
BarSeriesModel.prototype.getProgressiveThreshold = function () {
// Do not support progressive in normal mode.
var progressiveThreshold = this.get("progressiveThreshold");
var largeThreshold = this.get("largeThreshold");
if (largeThreshold > progressiveThreshold) {
progressiveThreshold = largeThreshold;
}
return progressiveThreshold;
};
BarSeriesModel.prototype.brushSelector = function (
dataIndex,
data,
selectors,
) {
return selectors.rect(data.getItemLayout(dataIndex));
};
BarSeriesModel.type = "series.bar";
BarSeriesModel.dependencies = ["grid", "polar"];
BarSeriesModel.defaultOption = inheritDefaultOption(
BaseBarSeriesModel.defaultOption,
{
// If clipped
// Only available on cartesian2d
clip: true,
roundCap: false,
showBackground: false,
backgroundStyle: {
color: "rgba(180, 180, 180, 0.2)",
borderColor: null,
borderWidth: 0,
borderType: "solid",
borderRadius: 0,
shadowBlur: 0,
shadowColor: null,
shadowOffsetX: 0,
shadowOffsetY: 0,
opacity: 1,
},
select: {
itemStyle: {
borderColor: "#212121",
},
},
realtimeSort: false,
},
);
return BarSeriesModel;
})(BaseBarSeriesModel);
/**
* Sausage: similar to sector, but have half circle on both sides
*/
var SausageShape =
/** @class */
(function () {
function SausageShape() {
this.cx = 0;
this.cy = 0;
this.r0 = 0;
this.r = 0;
this.startAngle = 0;
this.endAngle = Math.PI * 2;
this.clockwise = true;
}
return SausageShape;
})();
var SausagePath =
/** @class */
(function (_super) {
__extends(SausagePath, _super);
function SausagePath(opts) {
var _this = _super.call(this, opts) || this;
_this.type = "sausage";
return _this;
}
SausagePath.prototype.getDefaultShape = function () {
return new SausageShape();
};
SausagePath.prototype.buildPath = function (ctx, shape) {
var cx = shape.cx;
var cy = shape.cy;
var r0 = Math.max(shape.r0 || 0, 0);
var r = Math.max(shape.r, 0);
var dr = (r - r0) * 0.5;
var rCenter = r0 + dr;
var startAngle = shape.startAngle;
var endAngle = shape.endAngle;
var clockwise = shape.clockwise;
var PI2 = Math.PI * 2;
var lessThanCircle = clockwise
? endAngle - startAngle < PI2
: startAngle - endAngle < PI2;
if (!lessThanCircle) {
// Normalize angles
startAngle = endAngle - (clockwise ? PI2 : -PI2);
}
var unitStartX = Math.cos(startAngle);
var unitStartY = Math.sin(startAngle);
var unitEndX = Math.cos(endAngle);
var unitEndY = Math.sin(endAngle);
if (lessThanCircle) {
ctx.moveTo(unitStartX * r0 + cx, unitStartY * r0 + cy);
ctx.arc(
unitStartX * rCenter + cx,
unitStartY * rCenter + cy,
dr,
-Math.PI + startAngle,
startAngle,
!clockwise,
);
} else {
ctx.moveTo(unitStartX * r + cx, unitStartY * r + cy);
}
ctx.arc(cx, cy, r, startAngle, endAngle, !clockwise);
ctx.arc(
unitEndX * rCenter + cx,
unitEndY * rCenter + cy,
dr,
endAngle - Math.PI * 2,
endAngle - Math.PI,
!clockwise,
);
if (r0 !== 0) {
ctx.arc(cx, cy, r0, endAngle, startAngle, clockwise);
} // ctx.closePath();
};
return SausagePath;
})(Path);
function createSectorCalculateTextPosition(positionMapping, opts) {
opts = opts || {};
var isRoundCap = opts.isRoundCap;
return function (out, opts, boundingRect) {
var textPosition = opts.position;
if (!textPosition || textPosition instanceof Array) {
return calculateTextPosition(out, opts, boundingRect);
}
var mappedSectorPosition = positionMapping(textPosition);
var distance = opts.distance != null ? opts.distance : 5;
var sector = this.shape;
var cx = sector.cx;
var cy = sector.cy;
var r = sector.r;
var r0 = sector.r0;
var middleR = (r + r0) / 2;
var startAngle = sector.startAngle;
var endAngle = sector.endAngle;
var middleAngle = (startAngle + endAngle) / 2;
var extraDist = isRoundCap ? Math.abs(r - r0) / 2 : 0;
var mathCos = Math.cos;
var mathSin = Math.sin; // base position: top-left
var x = cx + r * mathCos(startAngle);
var y = cy + r * mathSin(startAngle);
var textAlign = "left";
var textVerticalAlign = "top";
switch (mappedSectorPosition) {
case "startArc":
x = cx + (r0 - distance) * mathCos(middleAngle);
y = cy + (r0 - distance) * mathSin(middleAngle);
textAlign = "center";
textVerticalAlign = "top";
break;
case "insideStartArc":
x = cx + (r0 + distance) * mathCos(middleAngle);
y = cy + (r0 + distance) * mathSin(middleAngle);
textAlign = "center";
textVerticalAlign = "bottom";
break;
case "startAngle":
x =
cx +
middleR * mathCos(startAngle) +
adjustAngleDistanceX(startAngle, distance + extraDist, false);
y =
cy +
middleR * mathSin(startAngle) +
adjustAngleDistanceY(startAngle, distance + extraDist, false);
textAlign = "right";
textVerticalAlign = "middle";
break;
case "insideStartAngle":
x =
cx +
middleR * mathCos(startAngle) +
adjustAngleDistanceX(startAngle, -distance + extraDist, false);
y =
cy +
middleR * mathSin(startAngle) +
adjustAngleDistanceY(startAngle, -distance + extraDist, false);
textAlign = "left";
textVerticalAlign = "middle";
break;
case "middle":
x = cx + middleR * mathCos(middleAngle);
y = cy + middleR * mathSin(middleAngle);
textAlign = "center";
textVerticalAlign = "middle";
break;
case "endArc":
x = cx + (r + distance) * mathCos(middleAngle);
y = cy + (r + distance) * mathSin(middleAngle);
textAlign = "center";
textVerticalAlign = "bottom";
break;
case "insideEndArc":
x = cx + (r - distance) * mathCos(middleAngle);
y = cy + (r - distance) * mathSin(middleAngle);
textAlign = "center";
textVerticalAlign = "top";
break;
case "endAngle":
x =
cx +
middleR * mathCos(endAngle) +
adjustAngleDistanceX(endAngle, distance + extraDist, true);
y =
cy +
middleR * mathSin(endAngle) +
adjustAngleDistanceY(endAngle, distance + extraDist, true);
textAlign = "left";
textVerticalAlign = "middle";
break;
case "insideEndAngle":
x =
cx +
middleR * mathCos(endAngle) +
adjustAngleDistanceX(endAngle, -distance + extraDist, true);
y =
cy +
middleR * mathSin(endAngle) +
adjustAngleDistanceY(endAngle, -distance + extraDist, true);
textAlign = "right";
textVerticalAlign = "middle";
break;
default:
return calculateTextPosition(out, opts, boundingRect);
}
out = out || {};
out.x = x;
out.y = y;
out.align = textAlign;
out.verticalAlign = textVerticalAlign;
return out;
};
}
function setSectorTextRotation(
sector,
textPosition,
positionMapping,
rotateType,
) {
if (isNumber(rotateType)) {
// user-set rotation
sector.setTextConfig({
rotation: rotateType,
});
return;
} else if (isArray(textPosition)) {
// user-set position, use 0 as auto rotation
sector.setTextConfig({
rotation: 0,
});
return;
}
var shape = sector.shape;
var startAngle = shape.clockwise ? shape.startAngle : shape.endAngle;
var endAngle = shape.clockwise ? shape.endAngle : shape.startAngle;
var middleAngle = (startAngle + endAngle) / 2;
var anchorAngle;
var mappedSectorPosition = positionMapping(textPosition);
switch (mappedSectorPosition) {
case "startArc":
case "insideStartArc":
case "middle":
case "insideEndArc":
case "endArc":
anchorAngle = middleAngle;
break;
case "startAngle":
case "insideStartAngle":
anchorAngle = startAngle;
break;
case "endAngle":
case "insideEndAngle":
anchorAngle = endAngle;
break;
default:
sector.setTextConfig({
rotation: 0,
});
return;
}
var rotate = Math.PI * 1.5 - anchorAngle;
/**
* TODO: labels with rotate > Math.PI / 2 should be rotate another
* half round flipped to increase readability. However, only middle
* position supports this for now, because in other positions, the
* anchor point is not at the center of the text, so the positions
* after rotating is not as expected.
*/
if (
mappedSectorPosition === "middle" &&
rotate > Math.PI / 2 &&
rotate < Math.PI * 1.5
) {
rotate -= Math.PI;
}
sector.setTextConfig({
rotation: rotate,
});
}
function adjustAngleDistanceX(angle, distance, isEnd) {
return distance * Math.sin(angle) * (isEnd ? -1 : 1);
}
function adjustAngleDistanceY(angle, distance, isEnd) {
return distance * Math.cos(angle) * (isEnd ? 1 : -1);
}
var mathMax$6 = Math.max;
var mathMin$6 = Math.min;
function getClipArea(coord, data) {
var coordSysClipArea = coord.getArea && coord.getArea();
if (isCoordinateSystemType(coord, "cartesian2d")) {
var baseAxis = coord.getBaseAxis(); // When boundaryGap is false or using time axis. bar may exceed the grid.
// We should not clip this part.
// See test/bar2.html
if (baseAxis.type !== "category" || !baseAxis.onBand) {
var expandWidth = data.getLayout("bandWidth");
if (baseAxis.isHorizontal()) {
coordSysClipArea.x -= expandWidth;
coordSysClipArea.width += expandWidth * 2;
} else {
coordSysClipArea.y -= expandWidth;
coordSysClipArea.height += expandWidth * 2;
}
}
}
return coordSysClipArea;
}
var BarView =
/** @class */
(function (_super) {
__extends(BarView, _super);
function BarView() {
var _this = _super.call(this) || this;
_this.type = BarView.type;
_this._isFirstFrame = true;
return _this;
}
BarView.prototype.render = function (seriesModel, ecModel, api, payload) {
this._model = seriesModel;
this._removeOnRenderedListener(api);
this._updateDrawMode(seriesModel);
var coordinateSystemType = seriesModel.get("coordinateSystem");
if (
coordinateSystemType === "cartesian2d" ||
coordinateSystemType === "polar"
) {
// Clear previously rendered progressive elements.
this._progressiveEls = null;
this._isLargeDraw
? this._renderLarge(seriesModel, ecModel, api)
: this._renderNormal(seriesModel, ecModel, api, payload);
} else if ("development" !== "production") {
warn("Only cartesian2d and polar supported for bar.");
}
};
BarView.prototype.incrementalPrepareRender = function (seriesModel) {
this._clear();
this._updateDrawMode(seriesModel); // incremental also need to clip, otherwise might be overlow.
// But must not set clip in each frame, otherwise all of the children will be marked redraw.
this._updateLargeClip(seriesModel);
};
BarView.prototype.incrementalRender = function (params, seriesModel) {
// Reset
this._progressiveEls = []; // Do not support progressive in normal mode.
this._incrementalRenderLarge(params, seriesModel);
};
BarView.prototype.eachRendered = function (cb) {
traverseElements(this._progressiveEls || this.group, cb);
};
BarView.prototype._updateDrawMode = function (seriesModel) {
var isLargeDraw = seriesModel.pipelineContext.large;
if (this._isLargeDraw == null || isLargeDraw !== this._isLargeDraw) {
this._isLargeDraw = isLargeDraw;
this._clear();
}
};
BarView.prototype._renderNormal = function (
seriesModel,
ecModel,
api,
payload,
) {
var group = this.group;
var data = seriesModel.getData();
var oldData = this._data;
var coord = seriesModel.coordinateSystem;
var baseAxis = coord.getBaseAxis();
var isHorizontalOrRadial;
if (coord.type === "cartesian2d") {
isHorizontalOrRadial = baseAxis.isHorizontal();
} else if (coord.type === "polar") {
isHorizontalOrRadial = baseAxis.dim === "angle";
}
var animationModel = seriesModel.isAnimationEnabled()
? seriesModel
: null;
var realtimeSortCfg = shouldRealtimeSort(seriesModel, coord);
if (realtimeSortCfg) {
this._enableRealtimeSort(realtimeSortCfg, data, api);
}
var needsClip = seriesModel.get("clip", true) || realtimeSortCfg;
var coordSysClipArea = getClipArea(coord, data); // If there is clipPath created in large mode. Remove it.
group.removeClipPath(); // We don't use clipPath in normal mode because we needs a perfect animation
// And don't want the label are clipped.
var roundCap = seriesModel.get("roundCap", true);
var drawBackground = seriesModel.get("showBackground", true);
var backgroundModel = seriesModel.getModel("backgroundStyle");
var barBorderRadius = backgroundModel.get("borderRadius") || 0;
var bgEls = [];
var oldBgEls = this._backgroundEls;
var isInitSort = payload && payload.isInitSort;
var isChangeOrder = payload && payload.type === "changeAxisOrder";
function createBackground(dataIndex) {
var bgLayout = getLayout[coord.type](data, dataIndex);
var bgEl = createBackgroundEl(coord, isHorizontalOrRadial, bgLayout);
bgEl.useStyle(backgroundModel.getItemStyle()); // Only cartesian2d support borderRadius.
if (coord.type === "cartesian2d") {
bgEl.setShape("r", barBorderRadius);
}
bgEls[dataIndex] = bgEl;
return bgEl;
}
data
.diff(oldData)
.add(function (dataIndex) {
var itemModel = data.getItemModel(dataIndex);
var layout = getLayout[coord.type](data, dataIndex, itemModel);
if (drawBackground) {
createBackground(dataIndex);
} // If dataZoom in filteMode: 'empty', the baseValue can be set as NaN in "axisProxy".
if (
!data.hasValue(dataIndex) ||
!isValidLayout[coord.type](layout)
) {
return;
}
var isClipped = false;
if (needsClip) {
// Clip will modify the layout params.
// And return a boolean to determine if the shape are fully clipped.
isClipped = clip[coord.type](coordSysClipArea, layout);
}
var el = elementCreator[coord.type](
seriesModel,
data,
dataIndex,
layout,
isHorizontalOrRadial,
animationModel,
baseAxis.model,
false,
roundCap,
);
if (realtimeSortCfg) {
/**
* Force label animation because even if the element is
* ignored because it's clipped, it may not be clipped after
* changing order. Then, if not using forceLabelAnimation,
* the label animation was never started, in which case,
* the label will be the final value and doesn't have label
* animation.
*/
el.forceLabelAnimation = true;
}
updateStyle(
el,
data,
dataIndex,
itemModel,
layout,
seriesModel,
isHorizontalOrRadial,
coord.type === "polar",
);
if (isInitSort) {
el.attr({
shape: layout,
});
} else if (realtimeSortCfg) {
updateRealtimeAnimation(
realtimeSortCfg,
animationModel,
el,
layout,
dataIndex,
isHorizontalOrRadial,
false,
false,
);
} else {
initProps(
el,
{
shape: layout,
},
seriesModel,
dataIndex,
);
}
data.setItemGraphicEl(dataIndex, el);
group.add(el);
el.ignore = isClipped;
})
.update(function (newIndex, oldIndex) {
var itemModel = data.getItemModel(newIndex);
var layout = getLayout[coord.type](data, newIndex, itemModel);
if (drawBackground) {
var bgEl = void 0;
if (oldBgEls.length === 0) {
bgEl = createBackground(oldIndex);
} else {
bgEl = oldBgEls[oldIndex];
bgEl.useStyle(backgroundModel.getItemStyle()); // Only cartesian2d support borderRadius.
if (coord.type === "cartesian2d") {
bgEl.setShape("r", barBorderRadius);
}
bgEls[newIndex] = bgEl;
}
var bgLayout = getLayout[coord.type](data, newIndex);
var shape = createBackgroundShape(
isHorizontalOrRadial,
bgLayout,
coord,
);
updateProps(
bgEl,
{
shape: shape,
},
animationModel,
newIndex,
);
}
var el = oldData.getItemGraphicEl(oldIndex);
if (
!data.hasValue(newIndex) ||
!isValidLayout[coord.type](layout)
) {
group.remove(el);
return;
}
var isClipped = false;
if (needsClip) {
isClipped = clip[coord.type](coordSysClipArea, layout);
if (isClipped) {
group.remove(el);
}
}
if (!el) {
el = elementCreator[coord.type](
seriesModel,
data,
newIndex,
layout,
isHorizontalOrRadial,
animationModel,
baseAxis.model,
!!el,
roundCap,
);
} else {
saveOldStyle(el);
}
if (realtimeSortCfg) {
el.forceLabelAnimation = true;
}
if (isChangeOrder) {
var textEl = el.getTextContent();
if (textEl) {
var labelInnerStore = labelInner(textEl);
if (labelInnerStore.prevValue != null) {
/**
* Set preValue to be value so that no new label
* should be started, otherwise, it will take a full
* `animationDurationUpdate` time to finish the
* animation, which is not expected.
*/
labelInnerStore.prevValue = labelInnerStore.value;
}
}
} // Not change anything if only order changed.
// Especially not change label.
else {
updateStyle(
el,
data,
newIndex,
itemModel,
layout,
seriesModel,
isHorizontalOrRadial,
coord.type === "polar",
);
}
if (isInitSort) {
el.attr({
shape: layout,
});
} else if (realtimeSortCfg) {
updateRealtimeAnimation(
realtimeSortCfg,
animationModel,
el,
layout,
newIndex,
isHorizontalOrRadial,
true,
isChangeOrder,
);
} else {
updateProps(
el,
{
shape: layout,
},
seriesModel,
newIndex,
null,
);
}
data.setItemGraphicEl(newIndex, el);
el.ignore = isClipped;
group.add(el);
})
.remove(function (dataIndex) {
var el = oldData.getItemGraphicEl(dataIndex);
el && removeElementWithFadeOut(el, seriesModel, dataIndex);
})
.execute();
var bgGroup =
this._backgroundGroup || (this._backgroundGroup = new Group());
bgGroup.removeAll();
for (var i = 0; i < bgEls.length; ++i) {
bgGroup.add(bgEls[i]);
}
group.add(bgGroup);
this._backgroundEls = bgEls;
this._data = data;
};
BarView.prototype._renderLarge = function (seriesModel, ecModel, api) {
this._clear();
createLarge(seriesModel, this.group);
this._updateLargeClip(seriesModel);
};
BarView.prototype._incrementalRenderLarge = function (
params,
seriesModel,
) {
this._removeBackground();
createLarge(seriesModel, this.group, this._progressiveEls, true);
};
BarView.prototype._updateLargeClip = function (seriesModel) {
// Use clipPath in large mode.
var clipPath =
seriesModel.get("clip", true) &&
createClipPath(seriesModel.coordinateSystem, false, seriesModel);
var group = this.group;
if (clipPath) {
group.setClipPath(clipPath);
} else {
group.removeClipPath();
}
};
BarView.prototype._enableRealtimeSort = function (
realtimeSortCfg,
data,
api,
) {
var _this = this; // If no data in the first frame, wait for data to initSort
if (!data.count()) {
return;
}
var baseAxis = realtimeSortCfg.baseAxis;
if (this._isFirstFrame) {
this._dispatchInitSort(data, realtimeSortCfg, api);
this._isFirstFrame = false;
} else {
var orderMapping_1 = function (idx) {
var el = data.getItemGraphicEl(idx);
var shape = el && el.shape;
return (
(shape && // The result should be consistent with the initial sort by data value.
// Do not support the case that both positive and negative exist.
Math.abs(
baseAxis.isHorizontal() ? shape.height : shape.width,
)) || // If data is NaN, shape.xxx may be NaN, so use || 0 here in case
0
);
};
this._onRendered = function () {
_this._updateSortWithinSameData(
data,
orderMapping_1,
baseAxis,
api,
);
};
api.getZr().on("rendered", this._onRendered);
}
};
BarView.prototype._dataSort = function (data, baseAxis, orderMapping) {
var info = [];
data.each(
data.mapDimension(baseAxis.dim),
function (ordinalNumber, dataIdx) {
var mappedValue = orderMapping(dataIdx);
mappedValue = mappedValue == null ? NaN : mappedValue;
info.push({
dataIndex: dataIdx,
mappedValue: mappedValue,
ordinalNumber: ordinalNumber,
});
},
);
info.sort(function (a, b) {
// If NaN, it will be treated as min val.
return b.mappedValue - a.mappedValue;
});
return {
ordinalNumbers: map(info, function (item) {
return item.ordinalNumber;
}),
};
};
BarView.prototype._isOrderChangedWithinSameData = function (
data,
orderMapping,
baseAxis,
) {
var scale = baseAxis.scale;
var ordinalDataDim = data.mapDimension(baseAxis.dim);
var lastValue = Number.MAX_VALUE;
for (
var tickNum = 0, len = scale.getOrdinalMeta().categories.length;
tickNum < len;
++tickNum
) {
var rawIdx = data.rawIndexOf(
ordinalDataDim,
scale.getRawOrdinalNumber(tickNum),
);
var value =
rawIdx < 0 // If some tick have no bar, the tick will be treated as min.
? Number.MIN_VALUE // PENDING: if dataZoom on baseAxis exits, is it a performance issue?
: orderMapping(data.indexOfRawIndex(rawIdx));
if (value > lastValue) {
return true;
}
lastValue = value;
}
return false;
};
/*
* Consider the case when A and B changed order, whose representing
* bars are both out of sight, we don't wish to trigger reorder action
* as long as the order in the view doesn't change.
*/
BarView.prototype._isOrderDifferentInView = function (
orderInfo,
baseAxis,
) {
var scale = baseAxis.scale;
var extent = scale.getExtent();
var tickNum = Math.max(0, extent[0]);
var tickMax = Math.min(
extent[1],
scale.getOrdinalMeta().categories.length - 1,
);
for (; tickNum <= tickMax; ++tickNum) {
if (
orderInfo.ordinalNumbers[tickNum] !==
scale.getRawOrdinalNumber(tickNum)
) {
return true;
}
}
};
BarView.prototype._updateSortWithinSameData = function (
data,
orderMapping,
baseAxis,
api,
) {
if (!this._isOrderChangedWithinSameData(data, orderMapping, baseAxis)) {
return;
}
var sortInfo = this._dataSort(data, baseAxis, orderMapping);
if (this._isOrderDifferentInView(sortInfo, baseAxis)) {
this._removeOnRenderedListener(api);
api.dispatchAction({
type: "changeAxisOrder",
componentType: baseAxis.dim + "Axis",
axisId: baseAxis.index,
sortInfo: sortInfo,
});
}
};
BarView.prototype._dispatchInitSort = function (
data,
realtimeSortCfg,
api,
) {
var baseAxis = realtimeSortCfg.baseAxis;
var sortResult = this._dataSort(data, baseAxis, function (dataIdx) {
return data.get(
data.mapDimension(realtimeSortCfg.otherAxis.dim),
dataIdx,
);
});
api.dispatchAction({
type: "changeAxisOrder",
componentType: baseAxis.dim + "Axis",
isInitSort: true,
axisId: baseAxis.index,
sortInfo: sortResult,
});
};
BarView.prototype.remove = function (ecModel, api) {
this._clear(this._model);
this._removeOnRenderedListener(api);
};
BarView.prototype.dispose = function (ecModel, api) {
this._removeOnRenderedListener(api);
};
BarView.prototype._removeOnRenderedListener = function (api) {
if (this._onRendered) {
api.getZr().off("rendered", this._onRendered);
this._onRendered = null;
}
};
BarView.prototype._clear = function (model) {
var group = this.group;
var data = this._data;
if (model && model.isAnimationEnabled() && data && !this._isLargeDraw) {
this._removeBackground();
this._backgroundEls = [];
data.eachItemGraphicEl(function (el) {
removeElementWithFadeOut(el, model, getECData(el).dataIndex);
});
} else {
group.removeAll();
}
this._data = null;
this._isFirstFrame = true;
};
BarView.prototype._removeBackground = function () {
this.group.remove(this._backgroundGroup);
this._backgroundGroup = null;
};
BarView.type = "bar";
return BarView;
})(ChartView);
var clip = {
cartesian2d: function (coordSysBoundingRect, layout) {
var signWidth = layout.width < 0 ? -1 : 1;
var signHeight = layout.height < 0 ? -1 : 1; // Needs positive width and height
if (signWidth < 0) {
layout.x += layout.width;
layout.width = -layout.width;
}
if (signHeight < 0) {
layout.y += layout.height;
layout.height = -layout.height;
}
var coordSysX2 = coordSysBoundingRect.x + coordSysBoundingRect.width;
var coordSysY2 = coordSysBoundingRect.y + coordSysBoundingRect.height;
var x = mathMax$6(layout.x, coordSysBoundingRect.x);
var x2 = mathMin$6(layout.x + layout.width, coordSysX2);
var y = mathMax$6(layout.y, coordSysBoundingRect.y);
var y2 = mathMin$6(layout.y + layout.height, coordSysY2);
var xClipped = x2 < x;
var yClipped = y2 < y; // When xClipped or yClipped, the element will be marked as `ignore`.
// But we should also place the element at the edge of the coord sys bounding rect.
// Beause if data changed and the bar show again, its transition animaiton
// will begin at this place.
layout.x = xClipped && x > coordSysX2 ? x2 : x;
layout.y = yClipped && y > coordSysY2 ? y2 : y;
layout.width = xClipped ? 0 : x2 - x;
layout.height = yClipped ? 0 : y2 - y; // Reverse back
if (signWidth < 0) {
layout.x += layout.width;
layout.width = -layout.width;
}
if (signHeight < 0) {
layout.y += layout.height;
layout.height = -layout.height;
}
return xClipped || yClipped;
},
polar: function (coordSysClipArea, layout) {
var signR = layout.r0 <= layout.r ? 1 : -1; // Make sure r is larger than r0
if (signR < 0) {
var tmp = layout.r;
layout.r = layout.r0;
layout.r0 = tmp;
}
var r = mathMin$6(layout.r, coordSysClipArea.r);
var r0 = mathMax$6(layout.r0, coordSysClipArea.r0);
layout.r = r;
layout.r0 = r0;
var clipped = r - r0 < 0; // Reverse back
if (signR < 0) {
var tmp = layout.r;
layout.r = layout.r0;
layout.r0 = tmp;
}
return clipped;
},
};
var elementCreator = {
cartesian2d: function (
seriesModel,
data,
newIndex,
layout,
isHorizontal,
animationModel,
axisModel,
isUpdate,
roundCap,
) {
var rect = new Rect({
shape: extend({}, layout),
z2: 1,
});
rect.__dataIndex = newIndex;
rect.name = "item";
if (animationModel) {
var rectShape = rect.shape;
var animateProperty = isHorizontal ? "height" : "width";
rectShape[animateProperty] = 0;
}
return rect;
},
polar: function (
seriesModel,
data,
newIndex,
layout,
isRadial,
animationModel,
axisModel,
isUpdate,
roundCap,
) {
var ShapeClass = !isRadial && roundCap ? SausagePath : Sector;
var sector = new ShapeClass({
shape: layout,
z2: 1,
});
sector.name = "item";
var positionMap = createPolarPositionMapping(isRadial);
sector.calculateTextPosition = createSectorCalculateTextPosition(
positionMap,
{
isRoundCap: ShapeClass === SausagePath,
},
); // Animation
if (animationModel) {
var sectorShape = sector.shape;
var animateProperty = isRadial ? "r" : "endAngle";
var animateTarget = {};
sectorShape[animateProperty] = isRadial ? 0 : layout.startAngle;
animateTarget[animateProperty] = layout[animateProperty];
(isUpdate ? updateProps : initProps)(
sector,
{
shape: animateTarget, // __value: typeof dataValue === 'string' ? parseInt(dataValue, 10) : dataValue
},
animationModel,
);
}
return sector;
},
};
function shouldRealtimeSort(seriesModel, coordSys) {
var realtimeSortOption = seriesModel.get("realtimeSort", true);
var baseAxis = coordSys.getBaseAxis();
if ("development" !== "production") {
if (realtimeSortOption) {
if (baseAxis.type !== "category") {
warn(
"`realtimeSort` will not work because this bar series is not based on a category axis.",
);
}
if (coordSys.type !== "cartesian2d") {
warn(
"`realtimeSort` will not work because this bar series is not on cartesian2d.",
);
}
}
}
if (
realtimeSortOption &&
baseAxis.type === "category" &&
coordSys.type === "cartesian2d"
) {
return {
baseAxis: baseAxis,
otherAxis: coordSys.getOtherAxis(baseAxis),
};
}
}
function updateRealtimeAnimation(
realtimeSortCfg,
seriesAnimationModel,
el,
layout,
newIndex,
isHorizontal,
isUpdate,
isChangeOrder,
) {
var seriesTarget;
var axisTarget;
if (isHorizontal) {
axisTarget = {
x: layout.x,
width: layout.width,
};
seriesTarget = {
y: layout.y,
height: layout.height,
};
} else {
axisTarget = {
y: layout.y,
height: layout.height,
};
seriesTarget = {
x: layout.x,
width: layout.width,
};
}
if (!isChangeOrder) {
// Keep the original growth animation if only axis order changed.
// Not start a new animation.
(isUpdate ? updateProps : initProps)(
el,
{
shape: seriesTarget,
},
seriesAnimationModel,
newIndex,
null,
);
}
var axisAnimationModel = seriesAnimationModel
? realtimeSortCfg.baseAxis.model
: null;
(isUpdate ? updateProps : initProps)(
el,
{
shape: axisTarget,
},
axisAnimationModel,
newIndex,
);
}
function checkPropertiesNotValid(obj, props) {
for (var i = 0; i < props.length; i++) {
if (!isFinite(obj[props[i]])) {
return true;
}
}
return false;
}
var rectPropties = ["x", "y", "width", "height"];
var polarPropties = ["cx", "cy", "r", "startAngle", "endAngle"];
var isValidLayout = {
cartesian2d: function (layout) {
return !checkPropertiesNotValid(layout, rectPropties);
},
polar: function (layout) {
return !checkPropertiesNotValid(layout, polarPropties);
},
};
var getLayout = {
// itemModel is only used to get borderWidth, which is not needed
// when calculating bar background layout.
cartesian2d: function (data, dataIndex, itemModel) {
var layout = data.getItemLayout(dataIndex);
var fixedLineWidth = itemModel ? getLineWidth(itemModel, layout) : 0; // fix layout with lineWidth
var signX = layout.width > 0 ? 1 : -1;
var signY = layout.height > 0 ? 1 : -1;
return {
x: layout.x + (signX * fixedLineWidth) / 2,
y: layout.y + (signY * fixedLineWidth) / 2,
width: layout.width - signX * fixedLineWidth,
height: layout.height - signY * fixedLineWidth,
};
},
polar: function (data, dataIndex, itemModel) {
var layout = data.getItemLayout(dataIndex);
return {
cx: layout.cx,
cy: layout.cy,
r0: layout.r0,
r: layout.r,
startAngle: layout.startAngle,
endAngle: layout.endAngle,
clockwise: layout.clockwise,
};
},
};
function isZeroOnPolar(layout) {
return (
layout.startAngle != null &&
layout.endAngle != null &&
layout.startAngle === layout.endAngle
);
}
function createPolarPositionMapping(isRadial) {
return (function (isRadial) {
var arcOrAngle = isRadial ? "Arc" : "Angle";
return function (position) {
switch (position) {
case "start":
case "insideStart":
case "end":
case "insideEnd":
return position + arcOrAngle;
default:
return position;
}
};
})(isRadial);
}
function updateStyle(
el,
data,
dataIndex,
itemModel,
layout,
seriesModel,
isHorizontalOrRadial,
isPolar,
) {
var style = data.getItemVisual(dataIndex, "style");
if (!isPolar) {
el.setShape("r", itemModel.get(["itemStyle", "borderRadius"]) || 0);
}
el.useStyle(style);
var cursorStyle = itemModel.getShallow("cursor");
cursorStyle && el.attr("cursor", cursorStyle);
var labelPositionOutside = isPolar
? isHorizontalOrRadial
? layout.r >= layout.r0
? "endArc"
: "startArc"
: layout.endAngle >= layout.startAngle
? "endAngle"
: "startAngle"
: isHorizontalOrRadial
? layout.height >= 0
? "bottom"
: "top"
: layout.width >= 0
? "right"
: "left";
var labelStatesModels = getLabelStatesModels(itemModel);
setLabelStyle(el, labelStatesModels, {
labelFetcher: seriesModel,
labelDataIndex: dataIndex,
defaultText: getDefaultLabel(seriesModel.getData(), dataIndex),
inheritColor: style.fill,
defaultOpacity: style.opacity,
defaultOutsidePosition: labelPositionOutside,
});
var label = el.getTextContent();
if (isPolar && label) {
var position = itemModel.get(["label", "position"]);
el.textConfig.inside = position === "middle" ? true : null;
setSectorTextRotation(
el,
position === "outside" ? labelPositionOutside : position,
createPolarPositionMapping(isHorizontalOrRadial),
itemModel.get(["label", "rotate"]),
);
}
setLabelValueAnimation(
label,
labelStatesModels,
seriesModel.getRawValue(dataIndex),
function (value) {
return getDefaultInterpolatedLabel(data, value);
},
);
var emphasisModel = itemModel.getModel(["emphasis"]);
toggleHoverEmphasis(
el,
emphasisModel.get("focus"),
emphasisModel.get("blurScope"),
emphasisModel.get("disabled"),
);
setStatesStylesFromModel(el, itemModel);
if (isZeroOnPolar(layout)) {
el.style.fill = "none";
el.style.stroke = "none";
each(el.states, function (state) {
if (state.style) {
state.style.fill = state.style.stroke = "none";
}
});
}
} // In case width or height are too small.
function getLineWidth(itemModel, rawLayout) {
// Has no border.
var borderColor = itemModel.get(["itemStyle", "borderColor"]);
if (!borderColor || borderColor === "none") {
return 0;
}
var lineWidth = itemModel.get(["itemStyle", "borderWidth"]) || 0; // width or height may be NaN for empty data
var width = isNaN(rawLayout.width)
? Number.MAX_VALUE
: Math.abs(rawLayout.width);
var height = isNaN(rawLayout.height)
? Number.MAX_VALUE
: Math.abs(rawLayout.height);
return Math.min(lineWidth, width, height);
}
var LagePathShape =
/** @class */
(function () {
function LagePathShape() {}
return LagePathShape;
})();
var LargePath =
/** @class */
(function (_super) {
__extends(LargePath, _super);
function LargePath(opts) {
var _this = _super.call(this, opts) || this;
_this.type = "largeBar";
return _this;
}
LargePath.prototype.getDefaultShape = function () {
return new LagePathShape();
};
LargePath.prototype.buildPath = function (ctx, shape) {
// Drawing lines is more efficient than drawing
// a whole line or drawing rects.
var points = shape.points;
var baseDimIdx = this.baseDimIdx;
var valueDimIdx = 1 - this.baseDimIdx;
var startPoint = [];
var size = [];
var barWidth = this.barWidth;
for (var i = 0; i < points.length; i += 3) {
size[baseDimIdx] = barWidth;
size[valueDimIdx] = points[i + 2];
startPoint[baseDimIdx] = points[i + baseDimIdx];
startPoint[valueDimIdx] = points[i + valueDimIdx];
ctx.rect(startPoint[0], startPoint[1], size[0], size[1]);
}
};
return LargePath;
})(Path);
function createLarge(seriesModel, group, progressiveEls, incremental) {
// TODO support polar
var data = seriesModel.getData();
var baseDimIdx = data.getLayout("valueAxisHorizontal") ? 1 : 0;
var largeDataIndices = data.getLayout("largeDataIndices");
var barWidth = data.getLayout("size");
var backgroundModel = seriesModel.getModel("backgroundStyle");
var bgPoints = data.getLayout("largeBackgroundPoints");
if (bgPoints) {
var bgEl = new LargePath({
shape: {
points: bgPoints,
},
incremental: !!incremental,
silent: true,
z2: 0,
});
bgEl.baseDimIdx = baseDimIdx;
bgEl.largeDataIndices = largeDataIndices;
bgEl.barWidth = barWidth;
bgEl.useStyle(backgroundModel.getItemStyle());
group.add(bgEl);
progressiveEls && progressiveEls.push(bgEl);
}
var el = new LargePath({
shape: {
points: data.getLayout("largePoints"),
},
incremental: !!incremental,
z2: 1,
});
el.baseDimIdx = baseDimIdx;
el.largeDataIndices = largeDataIndices;
el.barWidth = barWidth;
group.add(el);
el.useStyle(data.getVisual("style")); // Enable tooltip and user mouse/touch event handlers.
getECData(el).seriesIndex = seriesModel.seriesIndex;
if (!seriesModel.get("silent")) {
el.on("mousedown", largePathUpdateDataIndex);
el.on("mousemove", largePathUpdateDataIndex);
}
progressiveEls && progressiveEls.push(el);
} // Use throttle to avoid frequently traverse to find dataIndex.
var largePathUpdateDataIndex = throttle(
function (event) {
var largePath = this;
var dataIndex = largePathFindDataIndex(
largePath,
event.offsetX,
event.offsetY,
);
getECData(largePath).dataIndex = dataIndex >= 0 ? dataIndex : null;
},
30,
false,
);
function largePathFindDataIndex(largePath, x, y) {
var baseDimIdx = largePath.baseDimIdx;
var valueDimIdx = 1 - baseDimIdx;
var points = largePath.shape.points;
var largeDataIndices = largePath.largeDataIndices;
var startPoint = [];
var size = [];
var barWidth = largePath.barWidth;
for (var i = 0, len = points.length / 3; i < len; i++) {
var ii = i * 3;
size[baseDimIdx] = barWidth;
size[valueDimIdx] = points[ii + 2];
startPoint[baseDimIdx] = points[ii + baseDimIdx];
startPoint[valueDimIdx] = points[ii + valueDimIdx];
if (size[valueDimIdx] < 0) {
startPoint[valueDimIdx] += size[valueDimIdx];
size[valueDimIdx] = -size[valueDimIdx];
}
if (
x >= startPoint[0] &&
x <= startPoint[0] + size[0] &&
y >= startPoint[1] &&
y <= startPoint[1] + size[1]
) {
return largeDataIndices[i];
}
}
return -1;
}
function createBackgroundShape(isHorizontalOrRadial, layout, coord) {
if (isCoordinateSystemType(coord, "cartesian2d")) {
var rectShape = layout;
var coordLayout = coord.getArea();
return {
x: isHorizontalOrRadial ? rectShape.x : coordLayout.x,
y: isHorizontalOrRadial ? coordLayout.y : rectShape.y,
width: isHorizontalOrRadial ? rectShape.width : coordLayout.width,
height: isHorizontalOrRadial ? coordLayout.height : rectShape.height,
};
} else {
var coordLayout = coord.getArea();
var sectorShape = layout;
return {
cx: coordLayout.cx,
cy: coordLayout.cy,
r0: isHorizontalOrRadial ? coordLayout.r0 : sectorShape.r0,
r: isHorizontalOrRadial ? coordLayout.r : sectorShape.r,
startAngle: isHorizontalOrRadial ? sectorShape.startAngle : 0,
endAngle: isHorizontalOrRadial ? sectorShape.endAngle : Math.PI * 2,
};
}
}
function createBackgroundEl(coord, isHorizontalOrRadial, layout) {
var ElementClz = coord.type === "polar" ? Sector : Rect;
return new ElementClz({
shape: createBackgroundShape(isHorizontalOrRadial, layout, coord),
silent: true,
z2: 0,
});
}
function install$3(registers) {
registers.registerChartView(BarView);
registers.registerSeriesModel(BarSeriesModel);
registers.registerLayout(
registers.PRIORITY.VISUAL.LAYOUT,
curry(layout, "bar"),
); // Do layout after other overall layout, which can preapre some informations.
registers.registerLayout(
registers.PRIORITY.VISUAL.PROGRESSIVE_LAYOUT,
createProgressiveLayout("bar"),
); // Down sample after filter
registers.registerProcessor(
registers.PRIORITY.PROCESSOR.STATISTIC,
dataSample("bar"),
);
/**
* @payload
* @property {string} [componentType=series]
* @property {number} [dx]
* @property {number} [dy]
* @property {number} [zoom]
* @property {number} [originX]
* @property {number} [originY]
*/
registers.registerAction(
{
type: "changeAxisOrder",
event: "changeAxisOrder",
update: "update",
},
function (payload, ecModel) {
var componentType = payload.componentType || "series";
ecModel.eachComponent(
{
mainType: componentType,
query: payload,
},
function (componentModel) {
if (payload.sortInfo) {
componentModel.axis.setCategorySortInfo(payload.sortInfo);
}
},
);
},
);
}
var PI2$8 = Math.PI * 2;
var RADIAN = Math.PI / 180;
function getViewRect(seriesModel, api) {
return getLayoutRect(seriesModel.getBoxLayoutParams(), {
width: api.getWidth(),
height: api.getHeight(),
});
}
function getBasicPieLayout(seriesModel, api) {
var viewRect = getViewRect(seriesModel, api);
var center = seriesModel.get("center");
var radius = seriesModel.get("radius");
if (!isArray(radius)) {
radius = [0, radius];
}
if (!isArray(center)) {
center = [center, center];
}
var width = parsePercent$1(viewRect.width, api.getWidth());
var height = parsePercent$1(viewRect.height, api.getHeight());
var size = Math.min(width, height);
var cx = parsePercent$1(center[0], width) + viewRect.x;
var cy = parsePercent$1(center[1], height) + viewRect.y;
var r0 = parsePercent$1(radius[0], size / 2);
var r = parsePercent$1(radius[1], size / 2);
return {
cx: cx,
cy: cy,
r0: r0,
r: r,
};
}
function pieLayout(seriesType, ecModel, api) {
ecModel.eachSeriesByType(seriesType, function (seriesModel) {
var data = seriesModel.getData();
var valueDim = data.mapDimension("value");
var viewRect = getViewRect(seriesModel, api);
var _a = getBasicPieLayout(seriesModel, api),
cx = _a.cx,
cy = _a.cy,
r = _a.r,
r0 = _a.r0;
var startAngle = -seriesModel.get("startAngle") * RADIAN;
var minAngle = seriesModel.get("minAngle") * RADIAN;
var validDataCount = 0;
data.each(valueDim, function (value) {
!isNaN(value) && validDataCount++;
});
var sum = data.getSum(valueDim); // Sum may be 0
var unitRadian = (Math.PI / (sum || validDataCount)) * 2;
var clockwise = seriesModel.get("clockwise");
var roseType = seriesModel.get("roseType");
var stillShowZeroSum = seriesModel.get("stillShowZeroSum"); // [0...max]
var extent = data.getDataExtent(valueDim);
extent[0] = 0; // In the case some sector angle is smaller than minAngle
var restAngle = PI2$8;
var valueSumLargerThanMinAngle = 0;
var currentAngle = startAngle;
var dir = clockwise ? 1 : -1;
data.setLayout({
viewRect: viewRect,
r: r,
});
data.each(valueDim, function (value, idx) {
var angle;
if (isNaN(value)) {
data.setItemLayout(idx, {
angle: NaN,
startAngle: NaN,
endAngle: NaN,
clockwise: clockwise,
cx: cx,
cy: cy,
r0: r0,
r: roseType ? NaN : r,
});
return;
} // FIXME 兼容 2.0 但是 roseType 是 area 的时候才是这样？
if (roseType !== "area") {
angle =
sum === 0 && stillShowZeroSum ? unitRadian : value * unitRadian;
} else {
angle = PI2$8 / validDataCount;
}
if (angle < minAngle) {
angle = minAngle;
restAngle -= minAngle;
} else {
valueSumLargerThanMinAngle += value;
}
var endAngle = currentAngle + dir * angle;
data.setItemLayout(idx, {
angle: angle,
startAngle: currentAngle,
endAngle: endAngle,
clockwise: clockwise,
cx: cx,
cy: cy,
r0: r0,
r: roseType ? linearMap(value, extent, [r0, r]) : r,
});
currentAngle = endAngle;
}); // Some sector is constrained by minAngle
// Rest sectors needs recalculate angle
if (restAngle < PI2$8 && validDataCount) {
// Average the angle if rest angle is not enough after all angles is
// Constrained by minAngle
if (restAngle <= 1e-3) {
var angle_1 = PI2$8 / validDataCount;
data.each(valueDim, function (value, idx) {
if (!isNaN(value)) {
var layout_1 = data.getItemLayout(idx);
layout_1.angle = angle_1;
layout_1.startAngle = startAngle + dir * idx * angle_1;
layout_1.endAngle = startAngle + dir * (idx + 1) * angle_1;
}
});
} else {
unitRadian = restAngle / valueSumLargerThanMinAngle;
currentAngle = startAngle;
data.each(valueDim, function (value, idx) {
if (!isNaN(value)) {
var layout_2 = data.getItemLayout(idx);
var angle =
layout_2.angle === minAngle ? minAngle : value * unitRadian;
layout_2.startAngle = currentAngle;
layout_2.endAngle = currentAngle + dir * angle;
currentAngle += dir * angle;
}
});
}
}
});
}
/*
* 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.
*/
function dataFilter(seriesType) {
return {
seriesType: seriesType,
reset: function (seriesModel, ecModel) {
var legendModels = ecModel.findComponents({
mainType: "legend",
});
if (!legendModels || !legendModels.length) {
return;
}
var data = seriesModel.getData();
data.filterSelf(function (idx) {
var name = data.getName(idx); // If in any legend component the status is not selected.
for (var i = 0; i < legendModels.length; i++) {
// @ts-ignore FIXME: LegendModel
if (!legendModels[i].isSelected(name)) {
return false;
}
}
return true;
});
},
};
}
var RADIAN$1 = Math.PI / 180;
function adjustSingleSide(
list,
cx,
cy,
r,
dir,
viewWidth,
viewHeight,
viewLeft,
viewTop,
farthestX,
) {
if (list.length < 2) {
return;
}
function recalculateXOnSemiToAlignOnEllipseCurve(semi) {
var rB = semi.rB;
var rB2 = rB * rB;
for (var i = 0; i < semi.list.length; i++) {
var item = semi.list[i];
var dy = Math.abs(item.label.y - cy); // horizontal r is always same with original r because x is not changed.
var rA = r + item.len;
var rA2 = rA * rA; // Use ellipse implicit function to calculate x
var dx = Math.sqrt((1 - Math.abs((dy * dy) / rB2)) * rA2);
var newX = cx + (dx + item.len2) * dir;
var deltaX = newX - item.label.x;
var newTargetWidth = item.targetTextWidth - deltaX * dir; // text x is changed, so need to recalculate width.
constrainTextWidth(item, newTargetWidth, true);
item.label.x = newX;
}
} // Adjust X based on the shifted y. Make tight labels aligned on an ellipse curve.
function recalculateX(items) {
// Extremes of
var topSemi = {
list: [],
maxY: 0,
};
var bottomSemi = {
list: [],
maxY: 0,
};
for (var i = 0; i < items.length; i++) {
if (items[i].labelAlignTo !== "none") {
continue;
}
var item = items[i];
var semi = item.label.y > cy ? bottomSemi : topSemi;
var dy = Math.abs(item.label.y - cy);
if (dy >= semi.maxY) {
var dx = item.label.x - cx - item.len2 * dir; // horizontal r is always same with original r because x is not changed.
var rA = r + item.len; // Canculate rB based on the topest / bottemest label.
var rB =
Math.abs(dx) < rA
? Math.sqrt((dy * dy) / (1 - (dx * dx) / rA / rA))
: rA;
semi.rB = rB;
semi.maxY = dy;
}
semi.list.push(item);
}
recalculateXOnSemiToAlignOnEllipseCurve(topSemi);
recalculateXOnSemiToAlignOnEllipseCurve(bottomSemi);
}
var len = list.length;
for (var i = 0; i < len; i++) {
if (
list[i].position === "outer" &&
list[i].labelAlignTo === "labelLine"
) {
var dx = list[i].label.x - farthestX;
list[i].linePoints[1][0] += dx;
list[i].label.x = farthestX;
}
}
if (shiftLayoutOnY(list, viewTop, viewTop + viewHeight)) {
recalculateX(list);
}
}
function avoidOverlap(
labelLayoutList,
cx,
cy,
r,
viewWidth,
viewHeight,
viewLeft,
viewTop,
) {
var leftList = [];
var rightList = [];
var leftmostX = Number.MAX_VALUE;
var rightmostX = -Number.MAX_VALUE;
for (var i = 0; i < labelLayoutList.length; i++) {
var label = labelLayoutList[i].label;
if (isPositionCenter(labelLayoutList[i])) {
continue;
}
if (label.x < cx) {
leftmostX = Math.min(leftmostX, label.x);
leftList.push(labelLayoutList[i]);
} else {
rightmostX = Math.max(rightmostX, label.x);
rightList.push(labelLayoutList[i]);
}
}
for (var i = 0; i < labelLayoutList.length; i++) {
var layout = labelLayoutList[i];
if (!isPositionCenter(layout) && layout.linePoints) {
if (layout.labelStyleWidth != null) {
continue;
}
var label = layout.label;
var linePoints = layout.linePoints;
var targetTextWidth = void 0;
if (layout.labelAlignTo === "edge") {
if (label.x < cx) {
targetTextWidth =
linePoints[2][0] -
layout.labelDistance -
viewLeft -
layout.edgeDistance;
} else {
targetTextWidth =
viewLeft +
viewWidth -
layout.edgeDistance -
linePoints[2][0] -
layout.labelDistance;
}
} else if (layout.labelAlignTo === "labelLine") {
if (label.x < cx) {
targetTextWidth = leftmostX - viewLeft - layout.bleedMargin;
} else {
targetTextWidth =
viewLeft + viewWidth - rightmostX - layout.bleedMargin;
}
} else {
if (label.x < cx) {
targetTextWidth = label.x - viewLeft - layout.bleedMargin;
} else {
targetTextWidth =
viewLeft + viewWidth - label.x - layout.bleedMargin;
}
}
layout.targetTextWidth = targetTextWidth;
constrainTextWidth(layout, targetTextWidth);
}
}
adjustSingleSide(
rightList,
cx,
cy,
r,
1,
viewWidth,
viewHeight,
viewLeft,
viewTop,
rightmostX,
);
adjustSingleSide(
leftList,
cx,
cy,
r,
-1,
viewWidth,
viewHeight,
viewLeft,
viewTop,
leftmostX,
);
for (var i = 0; i < labelLayoutList.length; i++) {
var layout = labelLayoutList[i];
if (!isPositionCenter(layout) && layout.linePoints) {
var label = layout.label;
var linePoints = layout.linePoints;
var isAlignToEdge = layout.labelAlignTo === "edge";
var padding = label.style.padding;
var paddingH = padding ? padding[1] + padding[3] : 0; // textRect.width already contains paddingH if bgColor is set
var extraPaddingH = label.style.backgroundColor ? 0 : paddingH;
var realTextWidth = layout.rect.width + extraPaddingH;
var dist = linePoints[1][0] - linePoints[2][0];
if (isAlignToEdge) {
if (label.x < cx) {
linePoints[2][0] =
viewLeft +
layout.edgeDistance +
realTextWidth +
layout.labelDistance;
} else {
linePoints[2][0] =
viewLeft +
viewWidth -
layout.edgeDistance -
realTextWidth -
layout.labelDistance;
}
} else {
if (label.x < cx) {
linePoints[2][0] = label.x + layout.labelDistance;
} else {
linePoints[2][0] = label.x - layout.labelDistance;
}
linePoints[1][0] = linePoints[2][0] + dist;
}
linePoints[1][1] = linePoints[2][1] = label.y;
}
}
}
/**
* Set max width of each label, and then wrap each label to the max width.
*
* @param layout label layout
* @param availableWidth max width for the label to display
* @param forceRecalculate recaculate the text layout even if the current width
* is smaller than `availableWidth`. This is useful when the text was previously
* wrapped by calling `constrainTextWidth` but now `availableWidth` changed, in
* which case, previous wrapping should be redo.
*/
function constrainTextWidth(layout, availableWidth, forceRecalculate) {
if (forceRecalculate === void 0) {
forceRecalculate = false;
}
if (layout.labelStyleWidth != null) {
// User-defined style.width has the highest priority.
return;
}
var label = layout.label;
var style = label.style;
var textRect = layout.rect;
var bgColor = style.backgroundColor;
var padding = style.padding;
var paddingH = padding ? padding[1] + padding[3] : 0;
var overflow = style.overflow; // textRect.width already contains paddingH if bgColor is set
var oldOuterWidth = textRect.width + (bgColor ? 0 : paddingH);
if (availableWidth < oldOuterWidth || forceRecalculate) {
var oldHeight = textRect.height;
if (overflow && overflow.match("break")) {
// Temporarily set background to be null to calculate
// the bounding box without backgroud.
label.setStyle("backgroundColor", null); // Set constraining width
label.setStyle("width", availableWidth - paddingH); // This is the real bounding box of the text without padding
var innerRect = label.getBoundingRect();
label.setStyle("width", Math.ceil(innerRect.width));
label.setStyle("backgroundColor", bgColor);
} else {
var availableInnerWidth = availableWidth - paddingH;
var newWidth =
availableWidth < oldOuterWidth // Current text is too wide, use `availableWidth` as max width.
? availableInnerWidth // Current available width is enough, but the text may have
: // already been wrapped with a smaller available width.
forceRecalculate
? availableInnerWidth > layout.unconstrainedWidth // Current available is larger than text width,
? // so don't constrain width (otherwise it may have
// empty space in the background).
null // Current available is smaller than text width, so
: // use the current available width as constraining
// width.
availableInnerWidth // Current available width is enough, so no need to
: // constrain.
null;
label.setStyle("width", newWidth);
}
var newRect = label.getBoundingRect();
textRect.width = newRect.width;
var margin = (label.style.margin || 0) + 2.1;
textRect.height = newRect.height + margin;
textRect.y -= (textRect.height - oldHeight) / 2;
}
}
function isPositionCenter(sectorShape) {
// Not change x for center label
return sectorShape.position === "center";
}
function pieLabelLayout(seriesModel) {
var data = seriesModel.getData();
var labelLayoutList = [];
var cx;
var cy;
var hasLabelRotate = false;
var minShowLabelRadian =
(seriesModel.get("minShowLabelAngle") || 0) * RADIAN$1;
var viewRect = data.getLayout("viewRect");
var r = data.getLayout("r");
var viewWidth = viewRect.width;
var viewLeft = viewRect.x;
var viewTop = viewRect.y;
var viewHeight = viewRect.height;
function setNotShow(el) {
el.ignore = true;
}
function isLabelShown(label) {
if (!label.ignore) {
return true;
}
for (var key in label.states) {
if (label.states[key].ignore === false) {
return true;
}
}
return false;
}
data.each(function (idx) {
var sector = data.getItemGraphicEl(idx);
var sectorShape = sector.shape;
var label = sector.getTextContent();
var labelLine = sector.getTextGuideLine();
var itemModel = data.getItemModel(idx);
var labelModel = itemModel.getModel("label"); // Use position in normal or emphasis
var labelPosition =
labelModel.get("position") ||
itemModel.get(["emphasis", "label", "position"]);
var labelDistance = labelModel.get("distanceToLabelLine");
var labelAlignTo = labelModel.get("alignTo");
var edgeDistance = parsePercent$1(
labelModel.get("edgeDistance"),
viewWidth,
);
var bleedMargin = labelModel.get("bleedMargin");
var labelLineModel = itemModel.getModel("labelLine");
var labelLineLen = labelLineModel.get("length");
labelLineLen = parsePercent$1(labelLineLen, viewWidth);
var labelLineLen2 = labelLineModel.get("length2");
labelLineLen2 = parsePercent$1(labelLineLen2, viewWidth);
if (
Math.abs(sectorShape.endAngle - sectorShape.startAngle) <
minShowLabelRadian
) {
each(label.states, setNotShow);
label.ignore = true;
return;
}
if (!isLabelShown(label)) {
return;
}
var midAngle = (sectorShape.startAngle + sectorShape.endAngle) / 2;
var nx = Math.cos(midAngle);
var ny = Math.sin(midAngle);
var textX;
var textY;
var linePoints;
var textAlign;
cx = sectorShape.cx;
cy = sectorShape.cy;
var isLabelInside =
labelPosition === "inside" || labelPosition === "inner";
if (labelPosition === "center") {
textX = sectorShape.cx;
textY = sectorShape.cy;
textAlign = "center";
} else {
var x1 =
(isLabelInside
? ((sectorShape.r + sectorShape.r0) / 2) * nx
: sectorShape.r * nx) + cx;
var y1 =
(isLabelInside
? ((sectorShape.r + sectorShape.r0) / 2) * ny
: sectorShape.r * ny) + cy;
textX = x1 + nx * 3;
textY = y1 + ny * 3;
if (!isLabelInside) {
// For roseType
var x2 = x1 + nx * (labelLineLen + r - sectorShape.r);
var y2 = y1 + ny * (labelLineLen + r - sectorShape.r);
var x3 = x2 + (nx < 0 ? -1 : 1) * labelLineLen2;
var y3 = y2;
if (labelAlignTo === "edge") {
// Adjust textX because text align of edge is opposite
textX =
nx < 0
? viewLeft + edgeDistance
: viewLeft + viewWidth - edgeDistance;
} else {
textX = x3 + (nx < 0 ? -labelDistance : labelDistance);
}
textY = y3;
linePoints = [
[x1, y1],
[x2, y2],
[x3, y3],
];
}
textAlign = isLabelInside
? "center"
: labelAlignTo === "edge"
? nx > 0
? "right"
: "left"
: nx > 0
? "left"
: "right";
}
var PI = Math.PI;
var labelRotate = 0;
var rotate = labelModel.get("rotate");
if (isNumber(rotate)) {
labelRotate = rotate * (PI / 180);
} else if (labelPosition === "center") {
labelRotate = 0;
} else if (rotate === "radial" || rotate === true) {
var radialAngle = nx < 0 ? -midAngle + PI : -midAngle;
labelRotate = radialAngle;
} else if (
rotate === "tangential" &&
labelPosition !== "outside" &&
labelPosition !== "outer"
) {
var rad = Math.atan2(nx, ny);
if (rad < 0) {
rad = PI * 2 + rad;
}
var isDown = ny > 0;
if (isDown) {
rad = PI + rad;
}
labelRotate = rad - PI;
}
hasLabelRotate = !!labelRotate;
label.x = textX;
label.y = textY;
label.rotation = labelRotate;
label.setStyle({
verticalAlign: "middle",
}); // Not sectorShape the inside label
if (!isLabelInside) {
var textRect = label.getBoundingRect().clone();
textRect.applyTransform(label.getComputedTransform()); // Text has a default 1px stroke. Exclude this.
var margin = (label.style.margin || 0) + 2.1;
textRect.y -= margin / 2;
textRect.height += margin;
labelLayoutList.push({
label: label,
labelLine: labelLine,
position: labelPosition,
len: labelLineLen,
len2: labelLineLen2,
minTurnAngle: labelLineModel.get("minTurnAngle"),
maxSurfaceAngle: labelLineModel.get("maxSurfaceAngle"),
surfaceNormal: new Point(nx, ny),
linePoints: linePoints,
textAlign: textAlign,
labelDistance: labelDistance,
labelAlignTo: labelAlignTo,
edgeDistance: edgeDistance,
bleedMargin: bleedMargin,
rect: textRect,
unconstrainedWidth: textRect.width,
labelStyleWidth: label.style.width,
});
} else {
label.setStyle({
align: textAlign,
});
var selectState = label.states.select;
if (selectState) {
selectState.x += label.x;
selectState.y += label.y;
}
}
sector.setTextConfig({
inside: isLabelInside,
});
});
if (!hasLabelRotate && seriesModel.get("avoidLabelOverlap")) {
avoidOverlap(
labelLayoutList,
cx,
cy,
r,
viewWidth,
viewHeight,
viewLeft,
viewTop,
);
}
for (var i = 0; i < labelLayoutList.length; i++) {
var layout = labelLayoutList[i];
var label = layout.label;
var labelLine = layout.labelLine;
var notShowLabel = isNaN(label.x) || isNaN(label.y);
if (label) {
label.setStyle({
align: layout.textAlign,
});
if (notShowLabel) {
each(label.states, setNotShow);
label.ignore = true;
}
var selectState = label.states.select;
if (selectState) {
selectState.x += label.x;
selectState.y += label.y;
}
}
if (labelLine) {
var linePoints = layout.linePoints;
if (notShowLabel || !linePoints) {
each(labelLine.states, setNotShow);
labelLine.ignore = true;
} else {
limitTurnAngle(linePoints, layout.minTurnAngle);
limitSurfaceAngle(
linePoints,
layout.surfaceNormal,
layout.maxSurfaceAngle,
);
labelLine.setShape({
points: linePoints,
}); // Set the anchor to the midpoint of sector
label.__hostTarget.textGuideLineConfig = {
anchor: new Point(linePoints[0][0], linePoints[0][1]),
};
}
}
}
}
function getSectorCornerRadius(model, shape, zeroIfNull) {
var cornerRadius = model.get("borderRadius");
if (cornerRadius == null) {
return zeroIfNull
? {
cornerRadius: 0,
}
: null;
}
if (!isArray(cornerRadius)) {
cornerRadius = [cornerRadius, cornerRadius, cornerRadius, cornerRadius];
}
var dr = Math.abs(shape.r || 0 - shape.r0 || 0);
return {
cornerRadius: map(cornerRadius, function (cr) {
return parsePercent(cr, dr);
}),
};
}
/**
* Piece of pie including Sector, Label, LabelLine
*/
var PiePiece =
/** @class */
(function (_super) {
__extends(PiePiece, _super);
function PiePiece(data, idx, startAngle) {
var _this = _super.call(this) || this;
_this.z2 = 2;
var text = new ZRText();
_this.setTextContent(text);
_this.updateData(data, idx, startAngle, true);
return _this;
}
PiePiece.prototype.updateData = function (
data,
idx,
startAngle,
firstCreate,
) {
var sector = this;
var seriesModel = data.hostModel;
var itemModel = data.getItemModel(idx);
var emphasisModel = itemModel.getModel("emphasis");
var layout = data.getItemLayout(idx); // cornerRadius & innerCornerRadius doesn't exist in the item layout. Use `0` if null value is specified.
// see `setItemLayout` in `pieLayout.ts`.
var sectorShape = extend(
getSectorCornerRadius(itemModel.getModel("itemStyle"), layout, true),
layout,
); // Ignore NaN data.
if (isNaN(sectorShape.startAngle)) {
// Use NaN shape to avoid drawing shape.
sector.setShape(sectorShape);
return;
}
if (firstCreate) {
sector.setShape(sectorShape);
var animationType = seriesModel.getShallow("animationType");
if (seriesModel.ecModel.ssr) {
// Use scale animation in SSR mode(opacity?)
// Because CSS SVG animation doesn't support very customized shape animation.
initProps(
sector,
{
scaleX: 0,
scaleY: 0,
},
seriesModel,
{
dataIndex: idx,
isFrom: true,
},
);
sector.originX = sectorShape.cx;
sector.originY = sectorShape.cy;
} else if (animationType === "scale") {
sector.shape.r = layout.r0;
initProps(
sector,
{
shape: {
r: layout.r,
},
},
seriesModel,
idx,
);
} // Expansion
else {
if (startAngle != null) {
sector.setShape({
startAngle: startAngle,
endAngle: startAngle,
});
initProps(
sector,
{
shape: {
startAngle: layout.startAngle,
endAngle: layout.endAngle,
},
},
seriesModel,
idx,
);
} else {
sector.shape.endAngle = layout.startAngle;
updateProps(
sector,
{
shape: {
endAngle: layout.endAngle,
},
},
seriesModel,
idx,
);
}
}
} else {
saveOldStyle(sector); // Transition animation from the old shape
updateProps(
sector,
{
shape: sectorShape,
},
seriesModel,
idx,
);
}
sector.useStyle(data.getItemVisual(idx, "style"));
setStatesStylesFromModel(sector, itemModel);
var midAngle = (layout.startAngle + layout.endAngle) / 2;
var offset = seriesModel.get("selectedOffset");
var dx = Math.cos(midAngle) * offset;
var dy = Math.sin(midAngle) * offset;
var cursorStyle = itemModel.getShallow("cursor");
cursorStyle && sector.attr("cursor", cursorStyle);
this._updateLabel(seriesModel, data, idx);
sector.ensureState("emphasis").shape = extend(
{
r:
layout.r +
(emphasisModel.get("scale")
? emphasisModel.get("scaleSize") || 0
: 0),
},
getSectorCornerRadius(emphasisModel.getModel("itemStyle"), layout),
);
extend(sector.ensureState("select"), {
x: dx,
y: dy,
shape: getSectorCornerRadius(
itemModel.getModel(["select", "itemStyle"]),
layout,
),
});
extend(sector.ensureState("blur"), {
shape: getSectorCornerRadius(
itemModel.getModel(["blur", "itemStyle"]),
layout,
),
});
var labelLine = sector.getTextGuideLine();
var labelText = sector.getTextContent();
labelLine &&
extend(labelLine.ensureState("select"), {
x: dx,
y: dy,
}); // TODO: needs dx, dy in zrender?
extend(labelText.ensureState("select"), {
x: dx,
y: dy,
});
toggleHoverEmphasis(
this,
emphasisModel.get("focus"),
emphasisModel.get("blurScope"),
emphasisModel.get("disabled"),
);
};
PiePiece.prototype._updateLabel = function (seriesModel, data, idx) {
var sector = this;
var itemModel = data.getItemModel(idx);
var labelLineModel = itemModel.getModel("labelLine");
var style = data.getItemVisual(idx, "style");
var visualColor = style && style.fill;
var visualOpacity = style && style.opacity;
setLabelStyle(sector, getLabelStatesModels(itemModel), {
labelFetcher: data.hostModel,
labelDataIndex: idx,
inheritColor: visualColor,
defaultOpacity: visualOpacity,
defaultText:
seriesModel.getFormattedLabel(idx, "normal") || data.getName(idx),
});
var labelText = sector.getTextContent(); // Set textConfig on sector.
sector.setTextConfig({
// reset position, rotation
position: null,
rotation: null,
}); // Make sure update style on labelText after setLabelStyle.
// Because setLabelStyle will replace a new style on it.
labelText.attr({
z2: 10,
});
var labelPosition = seriesModel.get(["label", "position"]);
if (labelPosition !== "outside" && labelPosition !== "outer") {
sector.removeTextGuideLine();
} else {
var polyline = this.getTextGuideLine();
if (!polyline) {
polyline = new Polyline();
this.setTextGuideLine(polyline);
} // Default use item visual color
setLabelLineStyle(this, getLabelLineStatesModels(itemModel), {
stroke: visualColor,
opacity: retrieve3(
labelLineModel.get(["lineStyle", "opacity"]),
visualOpacity,
1,
),
});
}
};
return PiePiece;
})(Sector); // Pie view
var PieView =
/** @class */
(function (_super) {
__extends(PieView, _super);
function PieView() {
var _this = (_super !== null && _super.apply(this, arguments)) || this;
_this.ignoreLabelLineUpdate = true;
return _this;
}
PieView.prototype.render = function (seriesModel, ecModel, api, payload) {
var data = seriesModel.getData();
var oldData = this._data;
var group = this.group;
var startAngle; // First render
if (!oldData && data.count() > 0) {
var shape = data.getItemLayout(0);
for (
var s = 1;
isNaN(shape && shape.startAngle) && s < data.count();
++s
) {
shape = data.getItemLayout(s);
}
if (shape) {
startAngle = shape.startAngle;
}
} // remove empty-circle if it exists
if (this._emptyCircleSector) {
group.remove(this._emptyCircleSector);
} // when all data are filtered, show lightgray empty circle
if (data.count() === 0 && seriesModel.get("showEmptyCircle")) {
var sector = new Sector({
shape: getBasicPieLayout(seriesModel, api),
});
sector.useStyle(
seriesModel.getModel("emptyCircleStyle").getItemStyle(),
);
this._emptyCircleSector = sector;
group.add(sector);
}
data
.diff(oldData)
.add(function (idx) {
var piePiece = new PiePiece(data, idx, startAngle);
data.setItemGraphicEl(idx, piePiece);
group.add(piePiece);
})
.update(function (newIdx, oldIdx) {
var piePiece = oldData.getItemGraphicEl(oldIdx);
piePiece.updateData(data, newIdx, startAngle);
piePiece.off("click");
group.add(piePiece);
data.setItemGraphicEl(newIdx, piePiece);
})
.remove(function (idx) {
var piePiece = oldData.getItemGraphicEl(idx);
removeElementWithFadeOut(piePiece, seriesModel, idx);
})
.execute();
pieLabelLayout(seriesModel); // Always use initial animation.
if (seriesModel.get("animationTypeUpdate") !== "expansion") {
this._data = data;
}
};
PieView.prototype.dispose = function () {};
PieView.prototype.containPoint = function (point, seriesModel) {
var data = seriesModel.getData();
var itemLayout = data.getItemLayout(0);
if (itemLayout) {
var dx = point[0] - itemLayout.cx;
var dy = point[1] - itemLayout.cy;
var radius = Math.sqrt(dx * dx + dy * dy);
return radius <= itemLayout.r && radius >= itemLayout.r0;
}
};
PieView.type = "pie";
return PieView;
})(ChartView);
/**
* [Usage]:
* (1)
* createListSimply(seriesModel, ['value']);
* (2)
* createListSimply(seriesModel, {
* coordDimensions: ['value'],
* dimensionsCount: 5
* });
*/
function createSeriesDataSimply(seriesModel, opt, nameList) {
opt =
(isArray(opt) && {
coordDimensions: opt,
}) ||
extend(
{
encodeDefine: seriesModel.getEncode(),
},
opt,
);
var source = seriesModel.getSource();
var dimensions = prepareSeriesDataSchema(source, opt).dimensions;
var list = new SeriesData(dimensions, seriesModel);
list.initData(source, nameList);
return list;
}
/*
* 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.
*/
/**
* LegendVisualProvider is an bridge that pick encoded color from data and
* provide to the legend component.
*/
var LegendVisualProvider =
/** @class */
(function () {
function LegendVisualProvider( // Function to get data after filtered. It stores all the encoding info
getDataWithEncodedVisual, // Function to get raw data before filtered.
getRawData,
) {
this._getDataWithEncodedVisual = getDataWithEncodedVisual;
this._getRawData = getRawData;
}
LegendVisualProvider.prototype.getAllNames = function () {
var rawData = this._getRawData(); // We find the name from the raw data. In case it's filtered by the legend component.
// Normally, the name can be found in rawData, but can't be found in filtered data will display as gray.
return rawData.mapArray(rawData.getName);
};
LegendVisualProvider.prototype.containName = function (name) {
var rawData = this._getRawData();
return rawData.indexOfName(name) >= 0;
};
LegendVisualProvider.prototype.indexOfName = function (name) {
// Only get data when necessary.
// Because LegendVisualProvider constructor may be new in the stage that data is not prepared yet.
// Invoking Series#getData immediately will throw an error.
var dataWithEncodedVisual = this._getDataWithEncodedVisual();
return dataWithEncodedVisual.indexOfName(name);
};
LegendVisualProvider.prototype.getItemVisual = function (dataIndex, key) {
// Get encoded visual properties from final filtered data.
var dataWithEncodedVisual = this._getDataWithEncodedVisual();
return dataWithEncodedVisual.getItemVisual(dataIndex, key);
};
return LegendVisualProvider;
})();
var PieSeriesModel =
/** @class */
(function (_super) {
__extends(PieSeriesModel, _super);
function PieSeriesModel() {
return (_super !== null && _super.apply(this, arguments)) || this;
}
/**
* @overwrite
*/
PieSeriesModel.prototype.init = function (option) {
_super.prototype.init.apply(this, arguments); // Enable legend selection for each data item
// Use a function instead of direct access because data reference may changed
this.legendVisualProvider = new LegendVisualProvider(
bind(this.getData, this),
bind(this.getRawData, this),
);
this._defaultLabelLine(option);
};
/**
* @overwrite
*/
PieSeriesModel.prototype.mergeOption = function () {
_super.prototype.mergeOption.apply(this, arguments);
};
/**
* @overwrite
*/
PieSeriesModel.prototype.getInitialData = function () {
return createSeriesDataSimply(this, {
coordDimensions: ["value"],
encodeDefaulter: curry(makeSeriesEncodeForNameBased, this),
});
};
/**
* @overwrite
*/
PieSeriesModel.prototype.getDataParams = function (dataIndex) {
var data = this.getData();
var params = _super.prototype.getDataParams.call(this, dataIndex); // FIXME toFixed?
var valueList = [];
data.each(data.mapDimension("value"), function (value) {
valueList.push(value);
});
params.percent = getPercentWithPrecision(
valueList,
dataIndex,
data.hostModel.get("percentPrecision"),
);
params.$vars.push("percent");
return params;
};
PieSeriesModel.prototype._defaultLabelLine = function (option) {
// Extend labelLine emphasis
defaultEmphasis(option, "labelLine", ["show"]);
var labelLineNormalOpt = option.labelLine;
var labelLineEmphasisOpt = option.emphasis.labelLine; // Not show label line if `label.normal.show = false`
labelLineNormalOpt.show = labelLineNormalOpt.show && option.label.show;
labelLineEmphasisOpt.show =
labelLineEmphasisOpt.show && option.emphasis.label.show;
};
PieSeriesModel.type = "series.pie";
PieSeriesModel.defaultOption = {
// zlevel: 0,
z: 2,
legendHoverLink: true,
colorBy: "data",
// 默认全局居中
center: ["50%", "50%"],
radius: [0, "75%"],
// 默认顺时针
clockwise: true,
startAngle: 90,
// 最小角度改为0
minAngle: 0,
// If the angle of a sector less than `minShowLabelAngle`,
// the label will not be displayed.
minShowLabelAngle: 0,
// 选中时扇区偏移量
selectedOffset: 10,
// 选择模式，默认关闭，可选single，multiple
// selectedMode: false,
// 南丁格尔玫瑰图模式，'radius'（半径） | 'area'（面积）
// roseType: null,
percentPrecision: 2,
// If still show when all data zero.
stillShowZeroSum: true,
// cursor: null,
left: 0,
top: 0,
right: 0,
bottom: 0,
width: null,
height: null,
label: {
// color: 'inherit',
// If rotate around circle
rotate: 0,
show: true,
overflow: "truncate",
// 'outer', 'inside', 'center'
position: "outer",
// 'none', 'labelLine', 'edge'. Works only when position is 'outer'
alignTo: "none",
// Closest distance between label and chart edge.
// Works only position is 'outer' and alignTo is 'edge'.
edgeDistance: "25%",
// Works only position is 'outer' and alignTo is not 'edge'.
bleedMargin: 10,
// Distance between text and label line.
distanceToLabelLine: 5, // formatter: 标签文本格式器，同Tooltip.formatter，不支持异步回调
// 默认使用全局文本样式，详见TEXTSTYLE
// distance: 当position为inner时有效，为label位置到圆心的距离与圆半径(环状图为内外半径和)的比例系数
},
// Enabled when label.normal.position is 'outer'
labelLine: {
show: true,
// 引导线两段中的第一段长度
length: 15,
// 引导线两段中的第二段长度
length2: 15,
smooth: false,
minTurnAngle: 90,
maxSurfaceAngle: 90,
lineStyle: {
// color: 各异,
width: 1,
type: "solid",
},
},
itemStyle: {
borderWidth: 1,
borderJoin: "round",
},
showEmptyCircle: true,
emptyCircleStyle: {
color: "lightgray",
opacity: 1,
},
labelLayout: {
// Hide the overlapped label.
hideOverlap: true,
},
emphasis: {
scale: true,
scaleSize: 5,
},
// If use strategy to avoid label overlapping
avoidLabelOverlap: true,
// Animation type. Valid values: expansion, scale
animationType: "expansion",
animationDuration: 1000,
// Animation type when update. Valid values: transition, expansion
animationTypeUpdate: "transition",
animationEasingUpdate: "cubicInOut",
animationDurationUpdate: 500,
animationEasing: "cubicInOut",
};
return PieSeriesModel;
})(SeriesModel);
function negativeDataFilter(seriesType) {
return {
seriesType: seriesType,
reset: function (seriesModel, ecModel) {
var data = seriesModel.getData();
data.filterSelf(function (idx) {
// handle negative value condition
var valueDim = data.mapDimension("value");
var curValue = data.get(valueDim, idx);
if (isNumber(curValue) && !isNaN(curValue) && curValue < 0) {
return false;
}
return true;
});
},
};
}
function install$4(registers) {
registers.registerChartView(PieView);
registers.registerSeriesModel(PieSeriesModel);
createLegacyDataSelectAction("pie", registers.registerAction);
registers.registerLayout(curry(pieLayout, "pie"));
registers.registerProcessor(dataFilter("pie"));
registers.registerProcessor(negativeDataFilter("pie"));
}
var ScatterSeriesModel =
/** @class */
(function (_super) {
__extends(ScatterSeriesModel, _super);
function ScatterSeriesModel() {
var _this = (_super !== null && _super.apply(this, arguments)) || this;
_this.type = ScatterSeriesModel.type;
_this.hasSymbolVisual = true;
return _this;
}
ScatterSeriesModel.prototype.getInitialData = function (option, ecModel) {
return createSeriesData(null, this, {
useEncodeDefaulter: true,
});
};
ScatterSeriesModel.prototype.getProgressive = function () {
var progressive = this.option.progressive;
if (progressive == null) {
// PENDING
return this.option.large ? 5e3 : this.get("progressive");
}
return progressive;
};
ScatterSeriesModel.prototype.getProgressiveThreshold = function () {
var progressiveThreshold = this.option.progressiveThreshold;
if (progressiveThreshold == null) {
// PENDING
return this.option.large ? 1e4 : this.get("progressiveThreshold");
}
return progressiveThreshold;
};
ScatterSeriesModel.prototype.brushSelector = function (
dataIndex,
data,
selectors,
) {
return selectors.point(data.getItemLayout(dataIndex));
};
ScatterSeriesModel.prototype.getZLevelKey = function () {
// Each progressive series has individual key.
return this.getData().count() > this.getProgressiveThreshold()
? this.id
: "";
};
ScatterSeriesModel.type = "series.scatter";
ScatterSeriesModel.dependencies = [
"grid",
"polar",
"geo",
"singleAxis",
"calendar",
];
ScatterSeriesModel.defaultOption = {
coordinateSystem: "cartesian2d",
// zlevel: 0,
z: 2,
legendHoverLink: true,
symbolSize: 10,
// symbolRotate: null, // 图形旋转控制
large: false,
// Available when large is true
largeThreshold: 2000,
// cursor: null,
itemStyle: {
opacity: 0.8, // color: 各异
},
emphasis: {
scale: true,
},
// If clip the overflow graphics
// Works on cartesian / polar series
clip: true,
select: {
itemStyle: {
borderColor: "#212121",
},
},
universalTransition: {
divideShape: "clone",
}, // progressive: null
};
return ScatterSeriesModel;
})(SeriesModel);
var BOOST_SIZE_THRESHOLD = 4;
var LargeSymbolPathShape =
/** @class */
(function () {
function LargeSymbolPathShape() {}
return LargeSymbolPathShape;
})();
var LargeSymbolPath =
/** @class */
(function (_super) {
__extends(LargeSymbolPath, _super);
function LargeSymbolPath(opts) {
var _this = _super.call(this, opts) || this;
_this._off = 0;
_this.hoverDataIdx = -1;
return _this;
}
LargeSymbolPath.prototype.getDefaultShape = function () {
return new LargeSymbolPathShape();
};
LargeSymbolPath.prototype.reset = function () {
this.notClear = false;
this._off = 0;
};
LargeSymbolPath.prototype.buildPath = function (path, shape) {
var points = shape.points;
var size = shape.size;
var symbolProxy = this.symbolProxy;
var symbolProxyShape = symbolProxy.shape;
var ctx = path.getContext ? path.getContext() : path;
var canBoost = ctx && size[0] < BOOST_SIZE_THRESHOLD;
var softClipShape = this.softClipShape;
var i; // Do draw in afterBrush.
if (canBoost) {
this._ctx = ctx;
return;
}
this._ctx = null;
for (i = this._off; i < points.length; ) {
var x = points[i++];
var y = points[i++];
if (isNaN(x) || isNaN(y)) {
continue;
}
if (softClipShape && !softClipShape.contain(x, y)) {
continue;
}
symbolProxyShape.x = x - size[0] / 2;
symbolProxyShape.y = y - size[1] / 2;
symbolProxyShape.width = size[0];
symbolProxyShape.height = size[1];
symbolProxy.buildPath(path, symbolProxyShape, true);
}
if (this.incremental) {
this._off = i;
this.notClear = true;
}
};
LargeSymbolPath.prototype.afterBrush = function () {
var shape = this.shape;
var points = shape.points;
var size = shape.size;
var ctx = this._ctx;
var softClipShape = this.softClipShape;
var i;
if (!ctx) {
return;
} // PENDING If style or other canvas status changed?
for (i = this._off; i < points.length; ) {
var x = points[i++];
var y = points[i++];
if (isNaN(x) || isNaN(y)) {
continue;
}
if (softClipShape && !softClipShape.contain(x, y)) {
continue;
} // fillRect is faster than building a rect path and draw.
// And it support light globalCompositeOperation.
ctx.fillRect(x - size[0] / 2, y - size[1] / 2, size[0], size[1]);
}
if (this.incremental) {
this._off = i;
this.notClear = true;
}
};
LargeSymbolPath.prototype.findDataIndex = function (x, y) {
// TODO ???
// Consider transform
var shape = this.shape;
var points = shape.points;
var size = shape.size;
var w = Math.max(size[0], 4);
var h = Math.max(size[1], 4); // Not consider transform
// Treat each element as a rect
// top down traverse
for (var idx = points.length / 2 - 1; idx >= 0; idx--) {
var i = idx * 2;
var x0 = points[i] - w / 2;
var y0 = points[i + 1] - h / 2;
if (x >= x0 && y >= y0 && x <= x0 + w && y <= y0 + h) {
return idx;
}
}
return -1;
};
LargeSymbolPath.prototype.contain = function (x, y) {
var localPos = this.transformCoordToLocal(x, y);
var rect = this.getBoundingRect();
x = localPos[0];
y = localPos[1];
if (rect.contain(x, y)) {
// Cache found data index.
var dataIdx = (this.hoverDataIdx = this.findDataIndex(x, y));
return dataIdx >= 0;
}
this.hoverDataIdx = -1;
return false;
};
LargeSymbolPath.prototype.getBoundingRect = function () {
// Ignore stroke for large symbol draw.
var rect = this._rect;
if (!rect) {
var shape = this.shape;
var points = shape.points;
var size = shape.size;
var w = size[0];
var h = size[1];
var minX = Infinity;
var minY = Infinity;
var maxX = -Infinity;
var maxY = -Infinity;
for (var i = 0; i < points.length; ) {
var x = points[i++];
var y = points[i++];
minX = Math.min(x, minX);
maxX = Math.max(x, maxX);
minY = Math.min(y, minY);
maxY = Math.max(y, maxY);
}
rect = this._rect = new BoundingRect(
minX - w / 2,
minY - h / 2,
maxX - minX + w,
maxY - minY + h,
);
}
return rect;
};
return LargeSymbolPath;
})(Path);
var LargeSymbolDraw =
/** @class */
(function () {
function LargeSymbolDraw() {
this.group = new Group();
}
/**
* Update symbols draw by new data
*/
LargeSymbolDraw.prototype.updateData = function (data, opt) {
this._clear();
var symbolEl = this._create();
symbolEl.setShape({
points: data.getLayout("points"),
});
this._setCommon(symbolEl, data, opt);
};
LargeSymbolDraw.prototype.updateLayout = function (data) {
var points = data.getLayout("points");
this.group.eachChild(function (child) {
if (child.startIndex != null) {
var len = (child.endIndex - child.startIndex) * 2;
var byteOffset = child.startIndex * 4 * 2;
points = new Float32Array(points.buffer, byteOffset, len);
}
child.setShape("points", points); // Reset draw cursor.
child.reset();
});
};
LargeSymbolDraw.prototype.incrementalPrepareUpdate = function (data) {
this._clear();
};
LargeSymbolDraw.prototype.incrementalUpdate = function (
taskParams,
data,
opt,
) {
var lastAdded = this._newAdded[0];
var points = data.getLayout("points");
var oldPoints = lastAdded && lastAdded.shape.points; // Merging the exists. Each element has 1e4 points.
// Consider the performance balance between too much elements and too much points in one shape(may affect hover optimization)
if (oldPoints && oldPoints.length < 2e4) {
var oldLen = oldPoints.length;
var newPoints = new Float32Array(oldLen + points.length); // Concat two array
newPoints.set(oldPoints);
newPoints.set(points, oldLen); // Update endIndex
lastAdded.endIndex = taskParams.end;
lastAdded.setShape({
points: newPoints,
});
} else {
// Clear
this._newAdded = [];
var symbolEl = this._create();
symbolEl.startIndex = taskParams.start;
symbolEl.endIndex = taskParams.end;
symbolEl.incremental = true;
symbolEl.setShape({
points: points,
});
this._setCommon(symbolEl, data, opt);
}
};
LargeSymbolDraw.prototype.eachRendered = function (cb) {
this._newAdded[0] && cb(this._newAdded[0]);
};
LargeSymbolDraw.prototype._create = function () {
var symbolEl = new LargeSymbolPath({
cursor: "default",
});
this.group.add(symbolEl);
this._newAdded.push(symbolEl);
return symbolEl;
};
LargeSymbolDraw.prototype._setCommon = function (symbolEl, data, opt) {
var hostModel = data.hostModel;
opt = opt || {};
var size = data.getVisual("symbolSize");
symbolEl.setShape("size", size instanceof Array ? size : [size, size]);
symbolEl.softClipShape = opt.clipShape || null; // Create symbolProxy to build path for each data
symbolEl.symbolProxy = createSymbol(
data.getVisual("symbol"),
0,
0,
0,
0,
); // Use symbolProxy setColor method
symbolEl.setColor = symbolEl.symbolProxy.setColor;
var extrudeShadow = symbolEl.shape.size[0] < BOOST_SIZE_THRESHOLD;
symbolEl.useStyle(
// Draw shadow when doing fillRect is extremely slow.
hostModel
.getModel("itemStyle")
.getItemStyle(
extrudeShadow
? ["color", "shadowBlur", "shadowColor"]
: ["color"],
),
);
var globalStyle = data.getVisual("style");
var visualColor = globalStyle && globalStyle.fill;
if (visualColor) {
symbolEl.setColor(visualColor);
}
var ecData = getECData(symbolEl); // Enable tooltip
// PENDING May have performance issue when path is extremely large
ecData.seriesIndex = hostModel.seriesIndex;
symbolEl.on("mousemove", function (e) {
ecData.dataIndex = null;
var dataIndex = symbolEl.hoverDataIdx;
if (dataIndex >= 0) {
// Provide dataIndex for tooltip
ecData.dataIndex = dataIndex + (symbolEl.startIndex || 0);
}
});
};
LargeSymbolDraw.prototype.remove = function () {
this._clear();
};
LargeSymbolDraw.prototype._clear = function () {
this._newAdded = [];
this.group.removeAll();
};
return LargeSymbolDraw;
})();
var ScatterView =
/** @class */
(function (_super) {
__extends(ScatterView, _super);
function ScatterView() {
var _this = (_super !== null && _super.apply(this, arguments)) || this;
_this.type = ScatterView.type;
return _this;
}
ScatterView.prototype.render = function (seriesModel, ecModel, api) {
var data = seriesModel.getData();
var symbolDraw = this._updateSymbolDraw(data, seriesModel);
symbolDraw.updateData(data, {
// TODO
// If this parameter should be a shape or a bounding volume
// shape will be more general.
// But bounding volume like bounding rect will be much faster in the contain calculation
clipShape: this._getClipShape(seriesModel),
});
this._finished = true;
};
ScatterView.prototype.incrementalPrepareRender = function (
seriesModel,
ecModel,
api,
) {
var data = seriesModel.getData();
var symbolDraw = this._updateSymbolDraw(data, seriesModel);
symbolDraw.incrementalPrepareUpdate(data);
this._finished = false;
};
ScatterView.prototype.incrementalRender = function (
taskParams,
seriesModel,
ecModel,
) {
this._symbolDraw.incrementalUpdate(taskParams, seriesModel.getData(), {
clipShape: this._getClipShape(seriesModel),
});
this._finished = taskParams.end === seriesModel.getData().count();
};
ScatterView.prototype.updateTransform = function (
seriesModel,
ecModel,
api,
) {
var data = seriesModel.getData(); // Must mark group dirty and make sure the incremental layer will be cleared
// PENDING
this.group.dirty();
if (!this._finished || data.count() > 1e4) {
return {
update: true,
};
} else {
var res = pointsLayout("").reset(seriesModel, ecModel, api);
if (res.progress) {
res.progress(
{
start: 0,
end: data.count(),
count: data.count(),
},
data,
);
}
this._symbolDraw.updateLayout(data);
}
};
ScatterView.prototype.eachRendered = function (cb) {
this._symbolDraw && this._symbolDraw.eachRendered(cb);
};
ScatterView.prototype._getClipShape = function (seriesModel) {
var coordSys = seriesModel.coordinateSystem;
var clipArea = coordSys && coordSys.getArea && coordSys.getArea();
return seriesModel.get("clip", true) ? clipArea : null;
};
ScatterView.prototype._updateSymbolDraw = function (data, seriesModel) {
var symbolDraw = this._symbolDraw;
var pipelineContext = seriesModel.pipelineContext;
var isLargeDraw = pipelineContext.large;
if (!symbolDraw || isLargeDraw !== this._isLargeDraw) {
symbolDraw && symbolDraw.remove();
symbolDraw = this._symbolDraw = isLargeDraw
? new LargeSymbolDraw()
: new SymbolDraw();
this._isLargeDraw = isLargeDraw;
this.group.removeAll();
}
this.group.add(symbolDraw.group);
return symbolDraw;
};
ScatterView.prototype.remove = function (ecModel, api) {
this._symbolDraw && this._symbolDraw.remove(true);
this._symbolDraw = null;
};
ScatterView.prototype.dispose = function () {};
ScatterView.type = "scatter";
return ScatterView;
})(ChartView);
var GridModel =
/** @class */
(function (_super) {
__extends(GridModel, _super);
function GridModel() {
return (_super !== null && _super.apply(this, arguments)) || this;
}
GridModel.type = "grid";
GridModel.dependencies = ["xAxis", "yAxis"];
GridModel.layoutMode = "box";
GridModel.defaultOption = {
show: false,
// zlevel: 0,
z: 0,
left: "10%",
top: 60,
right: "10%",
bottom: 70,
// If grid size contain label
containLabel: false,
// width: {totalWidth} - left - right,
// height: {totalHeight} - top - bottom,
backgroundColor: "rgba(0,0,0,0)",
borderWidth: 1,
borderColor: "#ccc",
};
return GridModel;
})(ComponentModel);
var CartesianAxisModel =
/** @class */
(function (_super) {
__extends(CartesianAxisModel, _super);
function CartesianAxisModel() {
return (_super !== null && _super.apply(this, arguments)) || this;
}
CartesianAxisModel.prototype.getCoordSysModel = function () {
return this.getReferringComponents("grid", SINGLE_REFERRING).models[0];
};
CartesianAxisModel.type = "cartesian2dAxis";
return CartesianAxisModel;
})(ComponentModel);
mixin(CartesianAxisModel, AxisModelCommonMixin);
var defaultOption = {
show: true,
// zlevel: 0,
z: 0,
// Inverse the axis.
inverse: false,
// Axis name displayed.
name: "",
// 'start' | 'middle' | 'end'
nameLocation: "end",
// By degree. By default auto rotate by nameLocation.
nameRotate: null,
nameTruncate: {
maxWidth: null,
ellipsis: "...",
placeholder: ".",
},
// Use global text style by default.
nameTextStyle: {},
// The gap between axisName and axisLine.
nameGap: 15,
// Default `false` to support tooltip.
silent: false,
// Default `false` to avoid legacy user event listener fail.
triggerEvent: false,
tooltip: {
show: false,
},
axisPointer: {},
axisLine: {
show: true,
onZero: true,
onZeroAxisIndex: null,
lineStyle: {
color: "#6E7079",
width: 1,
type: "solid",
},
// The arrow at both ends the the axis.
symbol: ["none", "none"],
symbolSize: [10, 15],
},
axisTick: {
show: true,
// Whether axisTick is inside the grid or outside the grid.
inside: false,
// The length of axisTick.
length: 5,
lineStyle: {
width: 1,
},
},
axisLabel: {
show: true,
// Whether axisLabel is inside the grid or outside the grid.
inside: false,
rotate: 0,
// true | false | null/undefined (auto)
showMinLabel: null,
// true | false | null/undefined (auto)
showMaxLabel: null,
margin: 8,
// formatter: null,
fontSize: 12,
},
splitLine: {
show: true,
lineStyle: {
color: ["#E0E6F1"],
width: 1,
type: "solid",
},
},
splitArea: {
show: false,
areaStyle: {
color: ["rgba(250,250,250,0.2)", "rgba(210,219,238,0.2)"],
},
},
};
var categoryAxis = merge(
{
// The gap at both ends of the axis. For categoryAxis, boolean.
boundaryGap: true,
// Set false to faster category collection.
deduplication: null,
// splitArea: {
// show: false
// },
splitLine: {
show: false,
},
axisTick: {
// If tick is align with label when boundaryGap is true
alignWithLabel: false,
interval: "auto",
},
axisLabel: {
interval: "auto",
},
},
defaultOption,
);
var valueAxis = merge(
{
boundaryGap: [0, 0],
axisLine: {
// Not shown when other axis is categoryAxis in cartesian
show: "auto",
},
axisTick: {
// Not shown when other axis is categoryAxis in cartesian
show: "auto",
},
// TODO
// min/max: [30, datamin, 60] or [20, datamin] or [datamin, 60]
splitNumber: 5,
minorTick: {
// Minor tick, not available for cateogry axis.
show: false,
// Split number of minor ticks. The value should be in range of (0, 100)
splitNumber: 5,
// Lenght of minor tick
length: 3,
// Line style
lineStyle: {
// Default to be same with axisTick
},
},
minorSplitLine: {
show: false,
lineStyle: {
color: "#F4F7FD",
width: 1,
},
},
},
defaultOption,
);
var timeAxis = merge(
{
splitNumber: 6,
axisLabel: {
// To eliminate labels that are not nice
showMinLabel: false,
showMaxLabel: false,
rich: {
primary: {
fontWeight: "bold",
},
},
},
splitLine: {
show: false,
},
},
valueAxis,
);
var logAxis = defaults(
{
logBase: 10,
},
valueAxis,
);
var axisDefault = {
category: categoryAxis,
value: valueAxis,
time: timeAxis,
log: logAxis,
};
/*
* 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.
*/
var AXIS_TYPES = {
value: 1,
category: 1,
time: 1,
log: 1,
};
/**
* Generate sub axis model class
* @param axisName 'x' 'y' 'radius' 'angle' 'parallel' ...
*/
function axisModelCreator(
registers,
axisName,
BaseAxisModelClass,
extraDefaultOption,
) {
each(AXIS_TYPES, function (v, axisType) {
var defaultOption = merge(
merge({}, axisDefault[axisType], true),
extraDefaultOption,
true,
);
var AxisModel =
/** @class */
(function (_super) {
__extends(AxisModel, _super);
function AxisModel() {
var _this =
(_super !== null && _super.apply(this, arguments)) || this;
_this.type = axisName + "Axis." + axisType;
return _this;
}
AxisModel.prototype.mergeDefaultAndTheme = function (
option,
ecModel,
) {
var layoutMode = fetchLayoutMode(this);
var inputPositionParams = layoutMode ? getLayoutParams(option) : {};
var themeModel = ecModel.getTheme();
merge(option, themeModel.get(axisType + "Axis"));
merge(option, this.getDefaultOption());
option.type = getAxisType(option);
if (layoutMode) {
mergeLayoutParam(option, inputPositionParams, layoutMode);
}
};
AxisModel.prototype.optionUpdated = function () {
var thisOption = this.option;
if (thisOption.type === "category") {
this.__ordinalMeta = OrdinalMeta.createByAxisModel(this);
}
};
/**
* Should not be called before all of 'getInitailData' finished.
* Because categories are collected during initializing data.
*/
AxisModel.prototype.getCategories = function (rawData) {
var option = this.option; // FIXME
// warning if called before all of 'getInitailData' finished.
if (option.type === "category") {
if (rawData) {
return option.data;
}
return this.__ordinalMeta.categories;
}
};
AxisModel.prototype.getOrdinalMeta = function () {
return this.__ordinalMeta;
};
AxisModel.type = axisName + "Axis." + axisType;
AxisModel.defaultOption = defaultOption;
return AxisModel;
})(BaseAxisModelClass);
registers.registerComponentModel(AxisModel);
});
registers.registerSubTypeDefaulter(axisName + "Axis", getAxisType);
}
function getAxisType(option) {
// Default axis with data is category axis
return option.type || (option.data ? "category" : "value");
}
var Cartesian =
/** @class */
(function () {
function Cartesian(name) {
this.type = "cartesian";
this._dimList = [];
this._axes = {};
this.name = name || "";
}
Cartesian.prototype.getAxis = function (dim) {
return this._axes[dim];
};
Cartesian.prototype.getAxes = function () {
return map(
this._dimList,
function (dim) {
return this._axes[dim];
},
this,
);
};
Cartesian.prototype.getAxesByScale = function (scaleType) {
scaleType = scaleType.toLowerCase();
return filter(this.getAxes(), function (axis) {
return axis.scale.type === scaleType;
});
};
Cartesian.prototype.addAxis = function (axis) {
var dim = axis.dim;
this._axes[dim] = axis;
this._dimList.push(dim);
};
return Cartesian;
})();
var cartesian2DDimensions = ["x", "y"];
function canCalculateAffineTransform(scale) {
return scale.type === "interval" || scale.type === "time";
}
var Cartesian2D =
/** @class */
(function (_super) {
__extends(Cartesian2D, _super);
function Cartesian2D() {
var _this = (_super !== null && _super.apply(this, arguments)) || this;
_this.type = "cartesian2d";
_this.dimensions = cartesian2DDimensions;
return _this;
}
/**
* Calculate an affine transform matrix if two axes are time or value.
* It's mainly for accelartion on the large time series data.
*/
Cartesian2D.prototype.calcAffineTransform = function () {
this._transform = this._invTransform = null;
var xAxisScale = this.getAxis("x").scale;
var yAxisScale = this.getAxis("y").scale;
if (
!canCalculateAffineTransform(xAxisScale) ||
!canCalculateAffineTransform(yAxisScale)
) {
return;
}
var xScaleExtent = xAxisScale.getExtent();
var yScaleExtent = yAxisScale.getExtent();
var start = this.dataToPoint([xScaleExtent[0], yScaleExtent[0]]);
var end = this.dataToPoint([xScaleExtent[1], yScaleExtent[1]]);
var xScaleSpan = xScaleExtent[1] - xScaleExtent[0];
var yScaleSpan = yScaleExtent[1] - yScaleExtent[0];
if (!xScaleSpan || !yScaleSpan) {
return;
} // Accelerate data to point calculation on the special large time series data.
var scaleX = (end[0] - start[0]) / xScaleSpan;
var scaleY = (end[1] - start[1]) / yScaleSpan;
var translateX = start[0] - xScaleExtent[0] * scaleX;
var translateY = start[1] - yScaleExtent[0] * scaleY;
var m = (this._transform = [
scaleX,
0,
0,
scaleY,
translateX,
translateY,
]);
this._invTransform = invert([], m);
};
/**
* Base axis will be used on stacking.
*/
Cartesian2D.prototype.getBaseAxis = function () {
return (
this.getAxesByScale("ordinal")[0] ||
this.getAxesByScale("time")[0] ||
this.getAxis("x")
);
};
Cartesian2D.prototype.containPoint = function (point) {
var axisX = this.getAxis("x");
var axisY = this.getAxis("y");
return (
axisX.contain(axisX.toLocalCoord(point[0])) &&
axisY.contain(axisY.toLocalCoord(point[1]))
);
};
Cartesian2D.prototype.containData = function (data) {
return (
this.getAxis("x").containData(data[0]) &&
this.getAxis("y").containData(data[1])
);
};
Cartesian2D.prototype.dataToPoint = function (data, clamp, out) {
out = out || [];
var xVal = data[0];
var yVal = data[1]; // Fast path
if (
this._transform && // It's supported that if data is like `[Inifity, 123]`, where only Y pixel calculated.
xVal != null &&
isFinite(xVal) &&
yVal != null &&
isFinite(yVal)
) {
return applyTransform(out, data, this._transform);
}
var xAxis = this.getAxis("x");
var yAxis = this.getAxis("y");
out[0] = xAxis.toGlobalCoord(xAxis.dataToCoord(xVal, clamp));
out[1] = yAxis.toGlobalCoord(yAxis.dataToCoord(yVal, clamp));
return out;
};
Cartesian2D.prototype.clampData = function (data, out) {
var xScale = this.getAxis("x").scale;
var yScale = this.getAxis("y").scale;
var xAxisExtent = xScale.getExtent();
var yAxisExtent = yScale.getExtent();
var x = xScale.parse(data[0]);
var y = yScale.parse(data[1]);
out = out || [];
out[0] = Math.min(
Math.max(Math.min(xAxisExtent[0], xAxisExtent[1]), x),
Math.max(xAxisExtent[0], xAxisExtent[1]),
);
out[1] = Math.min(
Math.max(Math.min(yAxisExtent[0], yAxisExtent[1]), y),
Math.max(yAxisExtent[0], yAxisExtent[1]),
);
return out;
};
Cartesian2D.prototype.pointToData = function (point, clamp) {
var out = [];
if (this._invTransform) {
return applyTransform(out, point, this._invTransform);
}
var xAxis = this.getAxis("x");
var yAxis = this.getAxis("y");
out[0] = xAxis.coordToData(xAxis.toLocalCoord(point[0]), clamp);
out[1] = yAxis.coordToData(yAxis.toLocalCoord(point[1]), clamp);
return out;
};
Cartesian2D.prototype.getOtherAxis = function (axis) {
return this.getAxis(axis.dim === "x" ? "y" : "x");
};
/**
* Get rect area of cartesian.
* Area will have a contain function to determine if a point is in the coordinate system.
*/
Cartesian2D.prototype.getArea = function () {
var xExtent = this.getAxis("x").getGlobalExtent();
var yExtent = this.getAxis("y").getGlobalExtent();
var x = Math.min(xExtent[0], xExtent[1]);
var y = Math.min(yExtent[0], yExtent[1]);
var width = Math.max(xExtent[0], xExtent[1]) - x;
var height = Math.max(yExtent[0], yExtent[1]) - y;
return new BoundingRect(x, y, width, height);
};
return Cartesian2D;
})(Cartesian);
var Axis2D =
/** @class */
(function (_super) {
__extends(Axis2D, _super);
function Axis2D(dim, scale, coordExtent, axisType, position) {
var _this = _super.call(this, dim, scale, coordExtent) || this;
/**
* Index of axis, can be used as key
* Injected outside.
*/
_this.index = 0;
_this.type = axisType || "value";
_this.position = position || "bottom";
return _this;
}
Axis2D.prototype.isHorizontal = function () {
var position = this.position;
return position === "top" || position === "bottom";
};
/**
* Each item cooresponds to this.getExtent(), which
* means globalExtent[0] may greater than globalExtent[1],
* unless `asc` is input.
*
* @param {boolean} [asc]
* @return {Array.}
*/
Axis2D.prototype.getGlobalExtent = function (asc) {
var ret = this.getExtent();
ret[0] = this.toGlobalCoord(ret[0]);
ret[1] = this.toGlobalCoord(ret[1]);
asc && ret[0] > ret[1] && ret.reverse();
return ret;
};
Axis2D.prototype.pointToData = function (point, clamp) {
return this.coordToData(
this.toLocalCoord(point[this.dim === "x" ? 0 : 1]),
clamp,
);
};
/**
* Set ordinalSortInfo
* @param info new OrdinalSortInfo
*/
Axis2D.prototype.setCategorySortInfo = function (info) {
if (this.type !== "category") {
return false;
}
this.model.option.categorySortInfo = info;
this.scale.setSortInfo(info);
};
return Axis2D;
})(Axis);
/**
* Can only be called after coordinate system creation stage.
* (Can be called before coordinate system update stage).
*/
function layout$1(gridModel, axisModel, opt) {
opt = opt || {};
var grid = gridModel.coordinateSystem;
var axis = axisModel.axis;
var layout = {};
var otherAxisOnZeroOf = axis.getAxesOnZeroOf()[0];
var rawAxisPosition = axis.position;
var axisPosition = otherAxisOnZeroOf ? "onZero" : rawAxisPosition;
var axisDim = axis.dim;
var rect = grid.getRect();
var rectBound = [rect.x, rect.x + rect.width, rect.y, rect.y + rect.height];
var idx = {
left: 0,
right: 1,
top: 0,
bottom: 1,
onZero: 2,
};
var axisOffset = axisModel.get("offset") || 0;
var posBound =
axisDim === "x"
? [rectBound[2] - axisOffset, rectBound[3] + axisOffset]
: [rectBound[0] - axisOffset, rectBound[1] + axisOffset];
if (otherAxisOnZeroOf) {
var onZeroCoord = otherAxisOnZeroOf.toGlobalCoord(
otherAxisOnZeroOf.dataToCoord(0),
);
posBound[idx.onZero] = Math.max(
Math.min(onZeroCoord, posBound[1]),
posBound[0],
);
} // Axis position
layout.position = [
axisDim === "y" ? posBound[idx[axisPosition]] : rectBound[0],
axisDim === "x" ? posBound[idx[axisPosition]] : rectBound[3],
]; // Axis rotation
layout.rotation = (Math.PI / 2) * (axisDim === "x" ? 0 : 1); // Tick and label direction, x y is axisDim
var dirMap = {
top: -1,
bottom: 1,
left: -1,
right: 1,
};
layout.labelDirection =
layout.tickDirection =
layout.nameDirection =
dirMap[rawAxisPosition];
layout.labelOffset = otherAxisOnZeroOf
? posBound[idx[rawAxisPosition]] - posBound[idx.onZero]
: 0;
if (axisModel.get(["axisTick", "inside"])) {
layout.tickDirection = -layout.tickDirection;
}
if (retrieve(opt.labelInside, axisModel.get(["axisLabel", "inside"]))) {
layout.labelDirection = -layout.labelDirection;
} // Special label rotation
var labelRotate = axisModel.get(["axisLabel", "rotate"]);
layout.labelRotate = axisPosition === "top" ? -labelRotate : labelRotate; // Over splitLine and splitArea
layout.z2 = 1;
return layout;
}
function isCartesian2DSeries(seriesModel) {
return seriesModel.get("coordinateSystem") === "cartesian2d";
}
function findAxisModels(seriesModel) {
var axisModelMap = {
xAxisModel: null,
yAxisModel: null,
};
each(axisModelMap, function (v, key) {
var axisType = key.replace(/Model$/, "");
var axisModel = seriesModel.getReferringComponents(
axisType,
SINGLE_REFERRING,
).models[0];
if ("development" !== "production") {
if (!axisModel) {
throw new Error(
axisType +
' "' +
retrieve3(
seriesModel.get(axisType + "Index"),
seriesModel.get(axisType + "Id"),
0,
) +
'" not found',
);
}
}
axisModelMap[key] = axisModel;
});
return axisModelMap;
}
var mathLog$1 = Math.log;
function alignScaleTicks(scale, axisModel, alignToScale) {
var intervalScaleProto = IntervalScale.prototype; // NOTE: There is a precondition for log scale here:
// In log scale we store _interval and _extent of exponent value.
// So if we use the method of InternalScale to set/get these data.
// It process the exponent value, which is linear and what we want here.
var alignToTicks = intervalScaleProto.getTicks.call(alignToScale);
var alignToNicedTicks = intervalScaleProto.getTicks.call(
alignToScale,
true,
);
var alignToSplitNumber = alignToTicks.length - 1;
var alignToInterval = intervalScaleProto.getInterval.call(alignToScale);
var scaleExtent = getScaleExtent(scale, axisModel);
var rawExtent = scaleExtent.extent;
var isMinFixed = scaleExtent.fixMin;
var isMaxFixed = scaleExtent.fixMax;
if (scale.type === "log") {
var logBase = mathLog$1(scale.base);
rawExtent = [
mathLog$1(rawExtent[0]) / logBase,
mathLog$1(rawExtent[1]) / logBase,
];
}
scale.setExtent(rawExtent[0], rawExtent[1]);
scale.calcNiceExtent({
splitNumber: alignToSplitNumber,
fixMin: isMinFixed,
fixMax: isMaxFixed,
});
var extent = intervalScaleProto.getExtent.call(scale); // Need to update the rawExtent.
// Because value in rawExtent may be not parsed. e.g. 'dataMin', 'dataMax'
if (isMinFixed) {
rawExtent[0] = extent[0];
}
if (isMaxFixed) {
rawExtent[1] = extent[1];
}
var interval = intervalScaleProto.getInterval.call(scale);
var min = rawExtent[0];
var max = rawExtent[1];
if (isMinFixed && isMaxFixed) {
// User set min, max, divide to get new interval
interval = (max - min) / alignToSplitNumber;
} else if (isMinFixed) {
max = rawExtent[0] + interval * alignToSplitNumber; // User set min, expand extent on the other side
while (max < rawExtent[1] && isFinite(max) && isFinite(rawExtent[1])) {
interval = increaseInterval(interval);
max = rawExtent[0] + interval * alignToSplitNumber;
}
} else if (isMaxFixed) {
// User set max, expand extent on the other side
min = rawExtent[1] - interval * alignToSplitNumber;
while (min > rawExtent[0] && isFinite(min) && isFinite(rawExtent[0])) {
interval = increaseInterval(interval);
min = rawExtent[1] - interval * alignToSplitNumber;
}
} else {
var nicedSplitNumber = scale.getTicks().length - 1;
if (nicedSplitNumber > alignToSplitNumber) {
interval = increaseInterval(interval);
}
var range = interval * alignToSplitNumber;
max = Math.ceil(rawExtent[1] / interval) * interval;
min = round(max - range); // Not change the result that crossing zero.
if (min < 0 && rawExtent[0] >= 0) {
min = 0;
max = round(range);
} else if (max > 0 && rawExtent[1] <= 0) {
max = 0;
min = -round(range);
}
} // Adjust min, max based on the extent of alignTo. When min or max is set in alignTo scale
var t0 =
(alignToTicks[0].value - alignToNicedTicks[0].value) / alignToInterval;
var t1 =
(alignToTicks[alignToSplitNumber].value -
alignToNicedTicks[alignToSplitNumber].value) /
alignToInterval; // NOTE: Must in setExtent -> setInterval -> setNiceExtent order.
intervalScaleProto.setExtent.call(
scale,
min + interval * t0,
max + interval * t1,
);
intervalScaleProto.setInterval.call(scale, interval);
if (t0 || t1) {
intervalScaleProto.setNiceExtent.call(
scale,
min + interval,
max - interval,
);
}
if ("development" !== "production") {
var ticks = intervalScaleProto.getTicks.call(scale);
if (
ticks[1] &&
(!isValueNice(interval) ||
getPrecisionSafe(ticks[1].value) > getPrecisionSafe(interval))
) {
warn(
// eslint-disable-next-line
"The ticks may be not readable when set min: " +
axisModel.get("min") +
", max: " +
axisModel.get("max") +
" and alignTicks: true",
);
}
}
}
var Grid =
/** @class */
(function () {
function Grid(gridModel, ecModel, api) {
// FIXME:TS where used (different from registered type 'cartesian2d')?
this.type = "grid";
this._coordsMap = {};
this._coordsList = [];
this._axesMap = {};
this._axesList = [];
this.axisPointerEnabled = true;
this.dimensions = cartesian2DDimensions;
this._initCartesian(gridModel, ecModel, api);
this.model = gridModel;
}
Grid.prototype.getRect = function () {
return this._rect;
};
Grid.prototype.update = function (ecModel, api) {
var axesMap = this._axesMap;
this._updateScale(ecModel, this.model);
function updateAxisTicks(axes) {
var alignTo; // Axis is added in order of axisIndex.
var axesIndices = keys(axes);
var len = axesIndices.length;
if (!len) {
return;
}
var axisNeedsAlign = []; // Process once and calculate the ticks for those don't use alignTicks.
for (var i = len - 1; i >= 0; i--) {
var idx = +axesIndices[i]; // Convert to number.
var axis = axes[idx];
var model = axis.model;
var scale = axis.scale;
if (
// Only value and log axis without interval support alignTicks.
isIntervalOrLogScale(scale) &&
model.get("alignTicks") &&
model.get("interval") == null
) {
axisNeedsAlign.push(axis);
} else {
niceScaleExtent(scale, model);
if (isIntervalOrLogScale(scale)) {
// Can only align to interval or log axis.
alignTo = axis;
}
}
}
// PENDING. Should we find the axis that both set interval, min, max and align to this one?
if (axisNeedsAlign.length) {
if (!alignTo) {
alignTo = axisNeedsAlign.pop();
niceScaleExtent(alignTo.scale, alignTo.model);
}
each(axisNeedsAlign, function (axis) {
alignScaleTicks(axis.scale, axis.model, alignTo.scale);
});
}
}
updateAxisTicks(axesMap.x);
updateAxisTicks(axesMap.y); // Key: axisDim_axisIndex, value: boolean, whether onZero target.
var onZeroRecords = {};
each(axesMap.x, function (xAxis) {
fixAxisOnZero(axesMap, "y", xAxis, onZeroRecords);
});
each(axesMap.y, function (yAxis) {
fixAxisOnZero(axesMap, "x", yAxis, onZeroRecords);
}); // Resize again if containLabel is enabled
// FIXME It may cause getting wrong grid size in data processing stage
this.resize(this.model, api);
};
/**
* Resize the grid
*/
Grid.prototype.resize = function (gridModel, api, ignoreContainLabel) {
var boxLayoutParams = gridModel.getBoxLayoutParams();
var isContainLabel =
!ignoreContainLabel && gridModel.get("containLabel");
var gridRect = getLayoutRect(boxLayoutParams, {
width: api.getWidth(),
height: api.getHeight(),
});
this._rect = gridRect;
var axesList = this._axesList;
adjustAxes(); // Minus label size
if (isContainLabel) {
each(axesList, function (axis) {
if (!axis.model.get(["axisLabel", "inside"])) {
var labelUnionRect = estimateLabelUnionRect(axis);
if (labelUnionRect) {
var dim = axis.isHorizontal() ? "height" : "width";
var margin = axis.model.get(["axisLabel", "margin"]);
gridRect[dim] -= labelUnionRect[dim] + margin;
if (axis.position === "top") {
gridRect.y += labelUnionRect.height + margin;
} else if (axis.position === "left") {
gridRect.x += labelUnionRect.width + margin;
}
}
}
});
adjustAxes();
}
each(this._coordsList, function (coord) {
// Calculate affine matrix to accelerate the data to point transform.
// If all the axes scales are time or value.
coord.calcAffineTransform();
});
function adjustAxes() {
each(axesList, function (axis) {
var isHorizontal = axis.isHorizontal();
var extent = isHorizontal
? [0, gridRect.width]
: [0, gridRect.height];
var idx = axis.inverse ? 1 : 0;
axis.setExtent(extent[idx], extent[1 - idx]);
updateAxisTransform(axis, isHorizontal ? gridRect.x : gridRect.y);
});
}
};
Grid.prototype.getAxis = function (dim, axisIndex) {
var axesMapOnDim = this._axesMap[dim];
if (axesMapOnDim != null) {
return axesMapOnDim[axisIndex || 0];
}
};
Grid.prototype.getAxes = function () {
return this._axesList.slice();
};
Grid.prototype.getCartesian = function (xAxisIndex, yAxisIndex) {
if (xAxisIndex != null && yAxisIndex != null) {
var key = "x" + xAxisIndex + "y" + yAxisIndex;
return this._coordsMap[key];
}
if (isObject(xAxisIndex)) {
yAxisIndex = xAxisIndex.yAxisIndex;
xAxisIndex = xAxisIndex.xAxisIndex;
}
for (
var i = 0, coordList = this._coordsList;
i < coordList.length;
i++
) {
if (
coordList[i].getAxis("x").index === xAxisIndex ||
coordList[i].getAxis("y").index === yAxisIndex
) {
return coordList[i];
}
}
};
Grid.prototype.getCartesians = function () {
return this._coordsList.slice();
};
/**
* @implements
*/
Grid.prototype.convertToPixel = function (ecModel, finder, value) {
var target = this._findConvertTarget(finder);
return target.cartesian
? target.cartesian.dataToPoint(value)
: target.axis
? target.axis.toGlobalCoord(target.axis.dataToCoord(value))
: null;
};
/**
* @implements
*/
Grid.prototype.convertFromPixel = function (ecModel, finder, value) {
var target = this._findConvertTarget(finder);
return target.cartesian
? target.cartesian.pointToData(value)
: target.axis
? target.axis.coordToData(target.axis.toLocalCoord(value))
: null;
};
Grid.prototype._findConvertTarget = function (finder) {
var seriesModel = finder.seriesModel;
var xAxisModel =
finder.xAxisModel ||
(seriesModel &&
seriesModel.getReferringComponents("xAxis", SINGLE_REFERRING)
.models[0]);
var yAxisModel =
finder.yAxisModel ||
(seriesModel &&
seriesModel.getReferringComponents("yAxis", SINGLE_REFERRING)
.models[0]);
var gridModel = finder.gridModel;
var coordsList = this._coordsList;
var cartesian;
var axis;
if (seriesModel) {
cartesian = seriesModel.coordinateSystem;
indexOf(coordsList, cartesian) < 0 && (cartesian = null);
} else if (xAxisModel && yAxisModel) {
cartesian = this.getCartesian(
xAxisModel.componentIndex,
yAxisModel.componentIndex,
);
} else if (xAxisModel) {
axis = this.getAxis("x", xAxisModel.componentIndex);
} else if (yAxisModel) {
axis = this.getAxis("y", yAxisModel.componentIndex);
} // Lowest priority.
else if (gridModel) {
var grid = gridModel.coordinateSystem;
if (grid === this) {
cartesian = this._coordsList[0];
}
}
return {
cartesian: cartesian,
axis: axis,
};
};
/**
* @implements
*/
Grid.prototype.containPoint = function (point) {
var coord = this._coordsList[0];
if (coord) {
return coord.containPoint(point);
}
};
/**
* Initialize cartesian coordinate systems
*/
Grid.prototype._initCartesian = function (gridModel, ecModel, api) {
var _this = this;
var grid = this;
var axisPositionUsed = {
left: false,
right: false,
top: false,
bottom: false,
};
var axesMap = {
x: {},
y: {},
};
var axesCount = {
x: 0,
y: 0,
}; /// Create axis
ecModel.eachComponent("xAxis", createAxisCreator("x"), this);
ecModel.eachComponent("yAxis", createAxisCreator("y"), this);
if (!axesCount.x || !axesCount.y) {
// Roll back when there no either x or y axis
this._axesMap = {};
this._axesList = [];
return;
}
this._axesMap = axesMap; /// Create cartesian2d
each(axesMap.x, function (xAxis, xAxisIndex) {
each(axesMap.y, function (yAxis, yAxisIndex) {
var key = "x" + xAxisIndex + "y" + yAxisIndex;
var cartesian = new Cartesian2D(key);
cartesian.master = _this;
cartesian.model = gridModel;
_this._coordsMap[key] = cartesian;
_this._coordsList.push(cartesian);
cartesian.addAxis(xAxis);
cartesian.addAxis(yAxis);
});
});
function createAxisCreator(dimName) {
return function (axisModel, idx) {
if (!isAxisUsedInTheGrid(axisModel, gridModel)) {
return;
}
var axisPosition = axisModel.get("position");
if (dimName === "x") {
// Fix position
if (axisPosition !== "top" && axisPosition !== "bottom") {
// Default bottom of X
axisPosition = axisPositionUsed.bottom ? "top" : "bottom";
}
} else {
// Fix position
if (axisPosition !== "left" && axisPosition !== "right") {
// Default left of Y
axisPosition = axisPositionUsed.left ? "right" : "left";
}
}
axisPositionUsed[axisPosition] = true;
var axis = new Axis2D(
dimName,
createScaleByModel(axisModel),
[0, 0],
axisModel.get("type"),
axisPosition,
);
var isCategory = axis.type === "category";
axis.onBand = isCategory && axisModel.get("boundaryGap");
axis.inverse = axisModel.get("inverse"); // Inject axis into axisModel
axisModel.axis = axis; // Inject axisModel into axis
axis.model = axisModel; // Inject grid info axis
axis.grid = grid; // Index of axis, can be used as key
axis.index = idx;
grid._axesList.push(axis);
axesMap[dimName][idx] = axis;
axesCount[dimName]++;
};
}
};
/**
* Update cartesian properties from series.
*/
Grid.prototype._updateScale = function (ecModel, gridModel) {
// Reset scale
each(this._axesList, function (axis) {
axis.scale.setExtent(Infinity, -Infinity);
if (axis.type === "category") {
var categorySortInfo = axis.model.get("categorySortInfo");
axis.scale.setSortInfo(categorySortInfo);
}
});
ecModel.eachSeries(function (seriesModel) {
if (isCartesian2DSeries(seriesModel)) {
var axesModelMap = findAxisModels(seriesModel);
var xAxisModel = axesModelMap.xAxisModel;
var yAxisModel = axesModelMap.yAxisModel;
if (
!isAxisUsedInTheGrid(xAxisModel, gridModel) ||
!isAxisUsedInTheGrid(yAxisModel, gridModel)
) {
return;
}
var cartesian = this.getCartesian(
xAxisModel.componentIndex,
yAxisModel.componentIndex,
);
var data = seriesModel.getData();
var xAxis = cartesian.getAxis("x");
var yAxis = cartesian.getAxis("y");
unionExtent(data, xAxis);
unionExtent(data, yAxis);
}
}, this);
function unionExtent(data, axis) {
each(getDataDimensionsOnAxis(data, axis.dim), function (dim) {
axis.scale.unionExtentFromData(data, dim);
});
}
};
/**
* @param dim 'x' or 'y' or 'auto' or null/undefined
*/
Grid.prototype.getTooltipAxes = function (dim) {
var baseAxes = [];
var otherAxes = [];
each(this.getCartesians(), function (cartesian) {
var baseAxis =
dim != null && dim !== "auto"
? cartesian.getAxis(dim)
: cartesian.getBaseAxis();
var otherAxis = cartesian.getOtherAxis(baseAxis);
indexOf(baseAxes, baseAxis) < 0 && baseAxes.push(baseAxis);
indexOf(otherAxes, otherAxis) < 0 && otherAxes.push(otherAxis);
});
return {
baseAxes: baseAxes,
otherAxes: otherAxes,
};
};
Grid.create = function (ecModel, api) {
var grids = [];
ecModel.eachComponent("grid", function (gridModel, idx) {
var grid = new Grid(gridModel, ecModel, api);
grid.name = "grid_" + idx; // dataSampling requires axis extent, so resize
// should be performed in create stage.
grid.resize(gridModel, api, true);
gridModel.coordinateSystem = grid;
grids.push(grid);
}); // Inject the coordinateSystems into seriesModel
ecModel.eachSeries(function (seriesModel) {
if (!isCartesian2DSeries(seriesModel)) {
return;
}
var axesModelMap = findAxisModels(seriesModel);
var xAxisModel = axesModelMap.xAxisModel;
var yAxisModel = axesModelMap.yAxisModel;
var gridModel = xAxisModel.getCoordSysModel();
if ("development" !== "production") {
if (!gridModel) {
throw new Error(
'Grid "' +
retrieve3(
xAxisModel.get("gridIndex"),
xAxisModel.get("gridId"),
0,
) +
'" not found',
);
}
if (
xAxisModel.getCoordSysModel() !== yAxisModel.getCoordSysModel()
) {
throw new Error("xAxis and yAxis must use the same grid");
}
}
var grid = gridModel.coordinateSystem;
seriesModel.coordinateSystem = grid.getCartesian(
xAxisModel.componentIndex,
yAxisModel.componentIndex,
);
});
return grids;
}; // For deciding which dimensions to use when creating list data
Grid.dimensions = cartesian2DDimensions;
return Grid;
})();
/**
* Check if the axis is used in the specified grid.
*/
function isAxisUsedInTheGrid(axisModel, gridModel) {
return axisModel.getCoordSysModel() === gridModel;
}
function fixAxisOnZero(
axesMap,
otherAxisDim,
axis, // Key: see `getOnZeroRecordKey`
onZeroRecords,
) {
axis.getAxesOnZeroOf = function () {
// TODO: onZero of multiple axes.
return otherAxisOnZeroOf ? [otherAxisOnZeroOf] : [];
}; // onZero can not be enabled in these two situations:
// 1. When any other axis is a category axis.
// 2. When no axis is cross 0 point.
var otherAxes = axesMap[otherAxisDim];
var otherAxisOnZeroOf;
var axisModel = axis.model;
var onZero = axisModel.get(["axisLine", "onZero"]);
var onZeroAxisIndex = axisModel.get(["axisLine", "onZeroAxisIndex"]);
if (!onZero) {
return;
} // If target axis is specified.
if (onZeroAxisIndex != null) {
if (canOnZeroToAxis(otherAxes[onZeroAxisIndex])) {
otherAxisOnZeroOf = otherAxes[onZeroAxisIndex];
}
} else {
// Find the first available other axis.
for (var idx in otherAxes) {
if (
otherAxes.hasOwnProperty(idx) &&
canOnZeroToAxis(otherAxes[idx]) && // Consider that two Y axes on one value axis,
// if both onZero, the two Y axes overlap.
!onZeroRecords[getOnZeroRecordKey(otherAxes[idx])]
) {
otherAxisOnZeroOf = otherAxes[idx];
break;
}
}
}
if (otherAxisOnZeroOf) {
onZeroRecords[getOnZeroRecordKey(otherAxisOnZeroOf)] = true;
}
function getOnZeroRecordKey(axis) {
return axis.dim + "_" + axis.index;
}
}
function canOnZeroToAxis(axis) {
return (
axis &&
axis.type !== "category" &&
axis.type !== "time" &&
ifAxisCrossZero(axis)
);
}
function updateAxisTransform(axis, coordBase) {
var axisExtent = axis.getExtent();
var axisExtentSum = axisExtent[0] + axisExtent[1]; // Fast transform
axis.toGlobalCoord =
axis.dim === "x"
? function (coord) {
return coord + coordBase;
}
: function (coord) {
return axisExtentSum - coord + coordBase;
};
axis.toLocalCoord =
axis.dim === "x"
? function (coord) {
return coord - coordBase;
}
: function (coord) {
return axisExtentSum - coord + coordBase;
};
}
var PI$5 = Math.PI;
/**
* A final axis is translated and rotated from a "standard axis".
* So opt.position and opt.rotation is required.
*
* A standard axis is and axis from [0, 0] to [0, axisExtent[1]],
* for example: (0, 0) ------------> (0, 50)
*
* nameDirection or tickDirection or labelDirection is 1 means tick
* or label is below the standard axis, whereas is -1 means above
* the standard axis. labelOffset means offset between label and axis,
* which is useful when 'onZero', where axisLabel is in the grid and
* label in outside grid.
*
* Tips: like always,
* positive rotation represents anticlockwise, and negative rotation
* represents clockwise.
* The direction of position coordinate is the same as the direction
* of screen coordinate.
*
* Do not need to consider axis 'inverse', which is auto processed by
* axis extent.
*/
var AxisBuilder =
/** @class */
(function () {
function AxisBuilder(axisModel, opt) {
this.group = new Group();
this.opt = opt;
this.axisModel = axisModel; // Default value
defaults(opt, {
labelOffset: 0,
nameDirection: 1,
tickDirection: 1,
labelDirection: 1,
silent: true,
handleAutoShown: function () {
return true;
},
}); // FIXME Not use a seperate text group?
var transformGroup = new Group({
x: opt.position[0],
y: opt.position[1],
rotation: opt.rotation,
}); // this.group.add(transformGroup);
// this._transformGroup = transformGroup;
transformGroup.updateTransform();
this._transformGroup = transformGroup;
}
AxisBuilder.prototype.hasBuilder = function (name) {
return !!builders[name];
};
AxisBuilder.prototype.add = function (name) {
builders[name](
this.opt,
this.axisModel,
this.group,
this._transformGroup,
);
};
AxisBuilder.prototype.getGroup = function () {
return this.group;
};
AxisBuilder.innerTextLayout = function (
axisRotation,
textRotation,
direction,
) {
var rotationDiff = remRadian(textRotation - axisRotation);
var textAlign;
var textVerticalAlign;
if (isRadianAroundZero(rotationDiff)) {
// Label is parallel with axis line.
textVerticalAlign = direction > 0 ? "top" : "bottom";
textAlign = "center";
} else if (isRadianAroundZero(rotationDiff - PI$5)) {
// Label is inverse parallel with axis line.
textVerticalAlign = direction > 0 ? "bottom" : "top";
textAlign = "center";
} else {
textVerticalAlign = "middle";
if (rotationDiff > 0 && rotationDiff < PI$5) {
textAlign = direction > 0 ? "right" : "left";
} else {
textAlign = direction > 0 ? "left" : "right";
}
}
return {
rotation: rotationDiff,
textAlign: textAlign,
textVerticalAlign: textVerticalAlign,
};
};
AxisBuilder.makeAxisEventDataBase = function (axisModel) {
var eventData = {
componentType: axisModel.mainType,
componentIndex: axisModel.componentIndex,
};
eventData[axisModel.mainType + "Index"] = axisModel.componentIndex;
return eventData;
};
AxisBuilder.isLabelSilent = function (axisModel) {
var tooltipOpt = axisModel.get("tooltip");
return (
axisModel.get("silent") || // Consider mouse cursor, add these restrictions.
!(axisModel.get("triggerEvent") || (tooltipOpt && tooltipOpt.show))
);
};
return AxisBuilder;
})();
var builders = {
axisLine: function (opt, axisModel, group, transformGroup) {
var shown = axisModel.get(["axisLine", "show"]);
if (shown === "auto" && opt.handleAutoShown) {
shown = opt.handleAutoShown("axisLine");
}
if (!shown) {
return;
}
var extent = axisModel.axis.getExtent();
var matrix = transformGroup.transform;
var pt1 = [extent[0], 0];
var pt2 = [extent[1], 0];
if (matrix) {
applyTransform(pt1, pt1, matrix);
applyTransform(pt2, pt2, matrix);
}
var lineStyle = extend(
{
lineCap: "round",
},
axisModel.getModel(["axisLine", "lineStyle"]).getLineStyle(),
);
var line = new Line({
// Id for animation
subPixelOptimize: true,
shape: {
x1: pt1[0],
y1: pt1[1],
x2: pt2[0],
y2: pt2[1],
},
style: lineStyle,
strokeContainThreshold: opt.strokeContainThreshold || 5,
silent: true,
z2: 1,
});
line.anid = "line";
group.add(line);
var arrows = axisModel.get(["axisLine", "symbol"]);
if (arrows != null) {
var arrowSize = axisModel.get(["axisLine", "symbolSize"]);
if (isString(arrows)) {
// Use the same arrow for start and end point
arrows = [arrows, arrows];
}
if (isString(arrowSize) || isNumber(arrowSize)) {
// Use the same size for width and height
arrowSize = [arrowSize, arrowSize];
}
var arrowOffset = normalizeSymbolOffset(
axisModel.get(["axisLine", "symbolOffset"]) || 0,
arrowSize,
);
var symbolWidth_1 = arrowSize[0];
var symbolHeight_1 = arrowSize[1];
each(
[
{
rotate: opt.rotation + Math.PI / 2,
offset: arrowOffset[0],
r: 0,
},
{
rotate: opt.rotation - Math.PI / 2,
offset: arrowOffset[1],
r: Math.sqrt(
(pt1[0] - pt2[0]) * (pt1[0] - pt2[0]) +
(pt1[1] - pt2[1]) * (pt1[1] - pt2[1]),
),
},
],
function (point, index) {
if (arrows[index] !== "none" && arrows[index] != null) {
var symbol = createSymbol(
arrows[index],
-symbolWidth_1 / 2,
-symbolHeight_1 / 2,
symbolWidth_1,
symbolHeight_1,
lineStyle.stroke,
true,
); // Calculate arrow position with offset
var r = point.r + point.offset;
symbol.attr({
rotation: point.rotate,
x: pt1[0] + r * Math.cos(opt.rotation),
y: pt1[1] - r * Math.sin(opt.rotation),
silent: true,
z2: 11,
});
group.add(symbol);
}
},
);
}
},
axisTickLabel: function (opt, axisModel, group, transformGroup) {
var ticksEls = buildAxisMajorTicks(group, transformGroup, axisModel, opt);
var labelEls = buildAxisLabel(group, transformGroup, axisModel, opt);
fixMinMaxLabelShow(axisModel, labelEls, ticksEls);
buildAxisMinorTicks(group, transformGroup, axisModel, opt.tickDirection); // This bit fixes the label overlap issue for the time chart.
// See https://github.com/apache/echarts/issues/14266 for more.
if (axisModel.get(["axisLabel", "hideOverlap"])) {
var labelList = prepareLayoutList(
map(labelEls, function (label) {
return {
label: label,
priority: label.z2,
defaultAttr: {
ignore: label.ignore,
},
};
}),
);
hideOverlap(labelList);
}
},
axisName: function (opt, axisModel, group, transformGroup) {
var name = retrieve(opt.axisName, axisModel.get("name"));
if (!name) {
return;
}
var nameLocation = axisModel.get("nameLocation");
var nameDirection = opt.nameDirection;
var textStyleModel = axisModel.getModel("nameTextStyle");
var gap = axisModel.get("nameGap") || 0;
var extent = axisModel.axis.getExtent();
var gapSignal = extent[0] > extent[1] ? -1 : 1;
var pos = [
nameLocation === "start"
? extent[0] - gapSignal * gap
: nameLocation === "end"
? extent[1] + gapSignal * gap
: (extent[0] + extent[1]) / 2, // Reuse labelOffset.
isNameLocationCenter(nameLocation)
? opt.labelOffset + nameDirection * gap
: 0,
];
var labelLayout;
var nameRotation = axisModel.get("nameRotate");
if (nameRotation != null) {
nameRotation = (nameRotation * PI$5) / 180; // To radian.
}
var axisNameAvailableWidth;
if (isNameLocationCenter(nameLocation)) {
labelLayout = AxisBuilder.innerTextLayout(
opt.rotation,
nameRotation != null ? nameRotation : opt.rotation, // Adapt to axis.
nameDirection,
);
} else {
labelLayout = endTextLayout(
opt.rotation,
nameLocation,
nameRotation || 0,
extent,
);
axisNameAvailableWidth = opt.axisNameAvailableWidth;
if (axisNameAvailableWidth != null) {
axisNameAvailableWidth = Math.abs(
axisNameAvailableWidth / Math.sin(labelLayout.rotation),
);
!isFinite(axisNameAvailableWidth) && (axisNameAvailableWidth = null);
}
}
var textFont = textStyleModel.getFont();
var truncateOpt = axisModel.get("nameTruncate", true) || {};
var ellipsis = truncateOpt.ellipsis;
var maxWidth = retrieve(
opt.nameTruncateMaxWidth,
truncateOpt.maxWidth,
axisNameAvailableWidth,
);
var textEl = new ZRText({
x: pos[0],
y: pos[1],
rotation: labelLayout.rotation,
silent: AxisBuilder.isLabelSilent(axisModel),
style: createTextStyle(textStyleModel, {
text: name,
font: textFont,
overflow: "truncate",
width: maxWidth,
ellipsis: ellipsis,
fill:
textStyleModel.getTextColor() ||
axisModel.get(["axisLine", "lineStyle", "color"]),
align: textStyleModel.get("align") || labelLayout.textAlign,
verticalAlign:
textStyleModel.get("verticalAlign") ||
labelLayout.textVerticalAlign,
}),
z2: 1,
});
setTooltipConfig({
el: textEl,
componentModel: axisModel,
itemName: name,
});
textEl.__fullText = name; // Id for animation
textEl.anid = "name";
if (axisModel.get("triggerEvent")) {
var eventData = AxisBuilder.makeAxisEventDataBase(axisModel);
eventData.targetType = "axisName";
eventData.name = name;
getECData(textEl).eventData = eventData;
} // FIXME
transformGroup.add(textEl);
textEl.updateTransform();
group.add(textEl);
textEl.decomposeTransform();
},
};
function endTextLayout(rotation, textPosition, textRotate, extent) {
var rotationDiff = remRadian(textRotate - rotation);
var textAlign;
var textVerticalAlign;
var inverse = extent[0] > extent[1];
var onLeft =
(textPosition === "start" && !inverse) ||
(textPosition !== "start" && inverse);
if (isRadianAroundZero(rotationDiff - PI$5 / 2)) {
textVerticalAlign = onLeft ? "bottom" : "top";
textAlign = "center";
} else if (isRadianAroundZero(rotationDiff - PI$5 * 1.5)) {
textVerticalAlign = onLeft ? "top" : "bottom";
textAlign = "center";
} else {
textVerticalAlign = "middle";
if (rotationDiff < PI$5 * 1.5 && rotationDiff > PI$5 / 2) {
textAlign = onLeft ? "left" : "right";
} else {
textAlign = onLeft ? "right" : "left";
}
}
return {
rotation: rotationDiff,
textAlign: textAlign,
textVerticalAlign: textVerticalAlign,
};
}
function fixMinMaxLabelShow(axisModel, labelEls, tickEls) {
if (shouldShowAllLabels(axisModel.axis)) {
return;
} // If min or max are user set, we need to check
// If the tick on min(max) are overlap on their neighbour tick
// If they are overlapped, we need to hide the min(max) tick label
var showMinLabel = axisModel.get(["axisLabel", "showMinLabel"]);
var showMaxLabel = axisModel.get(["axisLabel", "showMaxLabel"]); // FIXME
// Have not consider onBand yet, where tick els is more than label els.
labelEls = labelEls || [];
tickEls = tickEls || [];
var firstLabel = labelEls[0];
var nextLabel = labelEls[1];
var lastLabel = labelEls[labelEls.length - 1];
var prevLabel = labelEls[labelEls.length - 2];
var firstTick = tickEls[0];
var nextTick = tickEls[1];
var lastTick = tickEls[tickEls.length - 1];
var prevTick = tickEls[tickEls.length - 2];
if (showMinLabel === false) {
ignoreEl(firstLabel);
ignoreEl(firstTick);
} else if (isTwoLabelOverlapped(firstLabel, nextLabel)) {
if (showMinLabel) {
ignoreEl(nextLabel);
ignoreEl(nextTick);
} else {
ignoreEl(firstLabel);
ignoreEl(firstTick);
}
}
if (showMaxLabel === false) {
ignoreEl(lastLabel);
ignoreEl(lastTick);
} else if (isTwoLabelOverlapped(prevLabel, lastLabel)) {
if (showMaxLabel) {
ignoreEl(prevLabel);
ignoreEl(prevTick);
} else {
ignoreEl(lastLabel);
ignoreEl(lastTick);
}
}
}
function ignoreEl(el) {
el && (el.ignore = true);
}
function isTwoLabelOverlapped(current, next) {
// current and next has the same rotation.
var firstRect = current && current.getBoundingRect().clone();
var nextRect = next && next.getBoundingRect().clone();
if (!firstRect || !nextRect) {
return;
} // When checking intersect of two rotated labels, we use mRotationBack
// to avoid that boundingRect is enlarge when using `boundingRect.applyTransform`.
var mRotationBack = identity([]);
rotate(mRotationBack, mRotationBack, -current.rotation);
firstRect.applyTransform(
mul$1([], mRotationBack, current.getLocalTransform()),
);
nextRect.applyTransform(mul$1([], mRotationBack, next.getLocalTransform()));
return firstRect.intersect(nextRect);
}
function isNameLocationCenter(nameLocation) {
return nameLocation === "middle" || nameLocation === "center";
}
function createTicks(
ticksCoords,
tickTransform,
tickEndCoord,
tickLineStyle,
anidPrefix,
) {
var tickEls = [];
var pt1 = [];
var pt2 = [];
for (var i = 0; i < ticksCoords.length; i++) {
var tickCoord = ticksCoords[i].coord;
pt1[0] = tickCoord;
pt1[1] = 0;
pt2[0] = tickCoord;
pt2[1] = tickEndCoord;
if (tickTransform) {
applyTransform(pt1, pt1, tickTransform);
applyTransform(pt2, pt2, tickTransform);
} // Tick line, Not use group transform to have better line draw
var tickEl = new Line({
subPixelOptimize: true,
shape: {
x1: pt1[0],
y1: pt1[1],
x2: pt2[0],
y2: pt2[1],
},
style: tickLineStyle,
z2: 2,
autoBatch: true,
silent: true,
});
tickEl.anid = anidPrefix + "_" + ticksCoords[i].tickValue;
tickEls.push(tickEl);
}
return tickEls;
}
function buildAxisMajorTicks(group, transformGroup, axisModel, opt) {
var axis = axisModel.axis;
var tickModel = axisModel.getModel("axisTick");
var shown = tickModel.get("show");
if (shown === "auto" && opt.handleAutoShown) {
shown = opt.handleAutoShown("axisTick");
}
if (!shown || axis.scale.isBlank()) {
return;
}
var lineStyleModel = tickModel.getModel("lineStyle");
var tickEndCoord = opt.tickDirection * tickModel.get("length");
var ticksCoords = axis.getTicksCoords();
var ticksEls = createTicks(
ticksCoords,
transformGroup.transform,
tickEndCoord,
defaults(lineStyleModel.getLineStyle(), {
stroke: axisModel.get(["axisLine", "lineStyle", "color"]),
}),
"ticks",
);
for (var i = 0; i < ticksEls.length; i++) {
group.add(ticksEls[i]);
}
return ticksEls;
}
function buildAxisMinorTicks(
group,
transformGroup,
axisModel,
tickDirection,
) {
var axis = axisModel.axis;
var minorTickModel = axisModel.getModel("minorTick");
if (!minorTickModel.get("show") || axis.scale.isBlank()) {
return;
}
var minorTicksCoords = axis.getMinorTicksCoords();
if (!minorTicksCoords.length) {
return;
}
var lineStyleModel = minorTickModel.getModel("lineStyle");
var tickEndCoord = tickDirection * minorTickModel.get("length");
var minorTickLineStyle = defaults(
lineStyleModel.getLineStyle(),
defaults(axisModel.getModel("axisTick").getLineStyle(), {
stroke: axisModel.get(["axisLine", "lineStyle", "color"]),
}),
);
for (var i = 0; i < minorTicksCoords.length; i++) {
var minorTicksEls = createTicks(
minorTicksCoords[i],
transformGroup.transform,
tickEndCoord,
minorTickLineStyle,
"minorticks_" + i,
);
for (var k = 0; k < minorTicksEls.length; k++) {
group.add(minorTicksEls[k]);
}
}
}
function buildAxisLabel(group, transformGroup, axisModel, opt) {
var axis = axisModel.axis;
var show = retrieve(
opt.axisLabelShow,
axisModel.get(["axisLabel", "show"]),
);
if (!show || axis.scale.isBlank()) {
return;
}
var labelModel = axisModel.getModel("axisLabel");
var labelMargin = labelModel.get("margin");
var labels = axis.getViewLabels(); // Special label rotate.
var labelRotation =
((retrieve(opt.labelRotate, labelModel.get("rotate")) || 0) * PI$5) / 180;
var labelLayout = AxisBuilder.innerTextLayout(
opt.rotation,
labelRotation,
opt.labelDirection,
);
var rawCategoryData =
axisModel.getCategories && axisModel.getCategories(true);
var labelEls = [];
var silent = AxisBuilder.isLabelSilent(axisModel);
var triggerEvent = axisModel.get("triggerEvent");
each(labels, function (labelItem, index) {
var tickValue =
axis.scale.type === "ordinal"
? axis.scale.getRawOrdinalNumber(labelItem.tickValue)
: labelItem.tickValue;
var formattedLabel = labelItem.formattedLabel;
var rawLabel = labelItem.rawLabel;
var itemLabelModel = labelModel;
if (rawCategoryData && rawCategoryData[tickValue]) {
var rawCategoryItem = rawCategoryData[tickValue];
if (isObject(rawCategoryItem) && rawCategoryItem.textStyle) {
itemLabelModel = new Model(
rawCategoryItem.textStyle,
labelModel,
axisModel.ecModel,
);
}
}
var textColor =
itemLabelModel.getTextColor() ||
axisModel.get(["axisLine", "lineStyle", "color"]);
var tickCoord = axis.dataToCoord(tickValue);
var textEl = new ZRText({
x: tickCoord,
y: opt.labelOffset + opt.labelDirection * labelMargin,
rotation: labelLayout.rotation,
silent: silent,
z2: 10 + (labelItem.level || 0),
style: createTextStyle(itemLabelModel, {
text: formattedLabel,
align:
itemLabelModel.getShallow("align", true) || labelLayout.textAlign,
verticalAlign:
itemLabelModel.getShallow("verticalAlign", true) ||
itemLabelModel.getShallow("baseline", true) ||
labelLayout.textVerticalAlign,
fill: isFunction(textColor)
? textColor(
// (1) In category axis with data zoom, tick is not the original
// index of axis.data. So tick should not be exposed to user
// in category axis.
// (2) Compatible with previous version, which always use formatted label as
// input. But in interval scale the formatted label is like '223,445', which
// maked user repalce ','. So we modify it to return original val but remain
// it as 'string' to avoid error in replacing.
axis.type === "category"
? rawLabel
: axis.type === "value"
? tickValue + ""
: tickValue,
index,
)
: textColor,
}),
});
textEl.anid = "label_" + tickValue; // Pack data for mouse event
if (triggerEvent) {
var eventData = AxisBuilder.makeAxisEventDataBase(axisModel);
eventData.targetType = "axisLabel";
eventData.value = rawLabel;
eventData.tickIndex = index;
if (axis.type === "category") {
eventData.dataIndex = tickValue;
}
getECData(textEl).eventData = eventData;
} // FIXME
transformGroup.add(textEl);
textEl.updateTransform();
labelEls.push(textEl);
group.add(textEl);
textEl.decomposeTransform();
});
return labelEls;
}
// allAxesInfo should be updated when setOption performed.
function collect(ecModel, api) {
var result = {
/**
* key: makeKey(axis.model)
* value: {
* axis,
* coordSys,
* axisPointerModel,
* triggerTooltip,
* involveSeries,
* snap,
* seriesModels,
* seriesDataCount
* }
*/
axesInfo: {},
seriesInvolved: false,
/**
* key: makeKey(coordSys.model)
* value: Object: key makeKey(axis.model), value: axisInfo
*/
coordSysAxesInfo: {},
coordSysMap: {},
};
collectAxesInfo(result, ecModel, api); // Check seriesInvolved for performance, in case too many series in some chart.
result.seriesInvolved && collectSeriesInfo(result, ecModel);
return result;
}
function collectAxesInfo(result, ecModel, api) {
var globalTooltipModel = ecModel.getComponent("tooltip");
var globalAxisPointerModel = ecModel.getComponent("axisPointer"); // links can only be set on global.
var linksOption = globalAxisPointerModel.get("link", true) || [];
var linkGroups = []; // Collect axes info.
each(api.getCoordinateSystems(), function (coordSys) {
// Some coordinate system do not support axes, like geo.
if (!coordSys.axisPointerEnabled) {
return;
}
var coordSysKey = makeKey(coordSys.model);
var axesInfoInCoordSys = (result.coordSysAxesInfo[coordSysKey] = {});
result.coordSysMap[coordSysKey] = coordSys; // Set tooltip (like 'cross') is a convienent way to show axisPointer
// for user. So we enable seting tooltip on coordSys model.
var coordSysModel = coordSys.model;
var baseTooltipModel = coordSysModel.getModel(
"tooltip",
globalTooltipModel,
);
each(coordSys.getAxes(), curry(saveTooltipAxisInfo, false, null)); // If axis tooltip used, choose tooltip axis for each coordSys.
// Notice this case: coordSys is `grid` but not `cartesian2D` here.
if (
coordSys.getTooltipAxes &&
globalTooltipModel && // If tooltip.showContent is set as false, tooltip will not
// show but axisPointer will show as normal.
baseTooltipModel.get("show")
) {
// Compatible with previous logic. But series.tooltip.trigger: 'axis'
// or series.data[n].tooltip.trigger: 'axis' are not support any more.
var triggerAxis = baseTooltipModel.get("trigger") === "axis";
var cross = baseTooltipModel.get(["axisPointer", "type"]) === "cross";
var tooltipAxes = coordSys.getTooltipAxes(
baseTooltipModel.get(["axisPointer", "axis"]),
);
if (triggerAxis || cross) {
each(
tooltipAxes.baseAxes,
curry(saveTooltipAxisInfo, cross ? "cross" : true, triggerAxis),
);
}
if (cross) {
each(
tooltipAxes.otherAxes,
curry(saveTooltipAxisInfo, "cross", false),
);
}
} // fromTooltip: true | false | 'cross'
// triggerTooltip: true | false | null
function saveTooltipAxisInfo(fromTooltip, triggerTooltip, axis) {
var axisPointerModel = axis.model.getModel(
"axisPointer",
globalAxisPointerModel,
);
var axisPointerShow = axisPointerModel.get("show");
if (
!axisPointerShow ||
(axisPointerShow === "auto" &&
!fromTooltip &&
!isHandleTrigger(axisPointerModel))
) {
return;
}
if (triggerTooltip == null) {
triggerTooltip = axisPointerModel.get("triggerTooltip");
}
axisPointerModel = fromTooltip
? makeAxisPointerModel(
axis,
baseTooltipModel,
globalAxisPointerModel,
ecModel,
fromTooltip,
triggerTooltip,
)
: axisPointerModel;
var snap = axisPointerModel.get("snap");
var axisKey = makeKey(axis.model);
var involveSeries = triggerTooltip || snap || axis.type === "category"; // If result.axesInfo[key] exist, override it (tooltip has higher priority).
var axisInfo = (result.axesInfo[axisKey] = {
key: axisKey,
axis: axis,
coordSys: coordSys,
axisPointerModel: axisPointerModel,
triggerTooltip: triggerTooltip,
involveSeries: involveSeries,
snap: snap,
useHandle: isHandleTrigger(axisPointerModel),
seriesModels: [],
linkGroup: null,
});
axesInfoInCoordSys[axisKey] = axisInfo;
result.seriesInvolved = result.seriesInvolved || involveSeries;
var groupIndex = getLinkGroupIndex(linksOption, axis);
if (groupIndex != null) {
var linkGroup =
linkGroups[groupIndex] ||
(linkGroups[groupIndex] = {
axesInfo: {},
});
linkGroup.axesInfo[axisKey] = axisInfo;
linkGroup.mapper = linksOption[groupIndex].mapper;
axisInfo.linkGroup = linkGroup;
}
}
});
}
function makeAxisPointerModel(
axis,
baseTooltipModel,
globalAxisPointerModel,
ecModel,
fromTooltip,
triggerTooltip,
) {
var tooltipAxisPointerModel = baseTooltipModel.getModel("axisPointer");
var fields = [
"type",
"snap",
"lineStyle",
"shadowStyle",
"label",
"animation",
"animationDurationUpdate",
"animationEasingUpdate",
"z",
];
var volatileOption = {};
each(fields, function (field) {
volatileOption[field] = clone(tooltipAxisPointerModel.get(field));
}); // category axis do not auto snap, otherwise some tick that do not
// has value can not be hovered. value/time/log axis default snap if
// triggered from tooltip and trigger tooltip.
volatileOption.snap = axis.type !== "category" && !!triggerTooltip; // Compatibel with previous behavior, tooltip axis do not show label by default.
// Only these properties can be overrided from tooltip to axisPointer.
if (tooltipAxisPointerModel.get("type") === "cross") {
volatileOption.type = "line";
}
var labelOption = volatileOption.label || (volatileOption.label = {}); // Follow the convention, do not show label when triggered by tooltip by default.
labelOption.show == null && (labelOption.show = false);
if (fromTooltip === "cross") {
// When 'cross', both axes show labels.
var tooltipAxisPointerLabelShow = tooltipAxisPointerModel.get([
"label",
"show",
]);
labelOption.show =
tooltipAxisPointerLabelShow != null
? tooltipAxisPointerLabelShow
: true; // If triggerTooltip, this is a base axis, which should better not use cross style
// (cross style is dashed by default)
if (!triggerTooltip) {
var crossStyle = (volatileOption.lineStyle =
tooltipAxisPointerModel.get("crossStyle"));
crossStyle && defaults(labelOption, crossStyle.textStyle);
}
}
return axis.model.getModel(
"axisPointer",
new Model(volatileOption, globalAxisPointerModel, ecModel),
);
}
function collectSeriesInfo(result, ecModel) {
// Prepare data for axis trigger
ecModel.eachSeries(function (seriesModel) {
// Notice this case: this coordSys is `cartesian2D` but not `grid`.
var coordSys = seriesModel.coordinateSystem;
var seriesTooltipTrigger = seriesModel.get(["tooltip", "trigger"], true);
var seriesTooltipShow = seriesModel.get(["tooltip", "show"], true);
if (
!coordSys ||
seriesTooltipTrigger === "none" ||
seriesTooltipTrigger === false ||
seriesTooltipTrigger === "item" ||
seriesTooltipShow === false ||
seriesModel.get(["axisPointer", "show"], true) === false
) {
return;
}
each(
result.coordSysAxesInfo[makeKey(coordSys.model)],
function (axisInfo) {
var axis = axisInfo.axis;
if (coordSys.getAxis(axis.dim) === axis) {
axisInfo.seriesModels.push(seriesModel);
axisInfo.seriesDataCount == null && (axisInfo.seriesDataCount = 0);
axisInfo.seriesDataCount += seriesModel.getData().count();
}
},
);
});
}
/**
* For example:
* {
* axisPointer: {
* links: [{
* xAxisIndex: [2, 4],
* yAxisIndex: 'all'
* }, {
* xAxisId: ['a5', 'a7'],
* xAxisName: 'xxx'
* }]
* }
* }
*/
function getLinkGroupIndex(linksOption, axis) {
var axisModel = axis.model;
var dim = axis.dim;
for (var i = 0; i < linksOption.length; i++) {
var linkOption = linksOption[i] || {};
if (
checkPropInLink(linkOption[dim + "AxisId"], axisModel.id) ||
checkPropInLink(
linkOption[dim + "AxisIndex"],
axisModel.componentIndex,
) ||
checkPropInLink(linkOption[dim + "AxisName"], axisModel.name)
) {
return i;
}
}
}
function checkPropInLink(linkPropValue, axisPropValue) {
return (
linkPropValue === "all" ||
(isArray(linkPropValue) && indexOf(linkPropValue, axisPropValue) >= 0) ||
linkPropValue === axisPropValue
);
}
function fixValue(axisModel) {
var axisInfo = getAxisInfo(axisModel);
if (!axisInfo) {
return;
}
var axisPointerModel = axisInfo.axisPointerModel;
var scale = axisInfo.axis.scale;
var option = axisPointerModel.option;
var status = axisPointerModel.get("status");
var value = axisPointerModel.get("value"); // Parse init value for category and time axis.
if (value != null) {
value = scale.parse(value);
}
var useHandle = isHandleTrigger(axisPointerModel); // If `handle` used, `axisPointer` will always be displayed, so value
// and status should be initialized.
if (status == null) {
option.status = useHandle ? "show" : "hide";
}
var extent = scale.getExtent().slice();
extent[0] > extent[1] && extent.reverse();
if (
// Pick a value on axis when initializing.
value == null || // If both `handle` and `dataZoom` are used, value may be out of axis extent,
// where we should re-pick a value to keep `handle` displaying normally.
value > extent[1]
) {
// Make handle displayed on the end of the axis when init, which looks better.
value = extent[1];
}
if (value < extent[0]) {
value = extent[0];
}
option.value = value;
if (useHandle) {
option.status = axisInfo.axis.scale.isBlank() ? "hide" : "show";
}
}
function getAxisInfo(axisModel) {
var coordSysAxesInfo = (axisModel.ecModel.getComponent("axisPointer") || {})
.coordSysAxesInfo;
return coordSysAxesInfo && coordSysAxesInfo.axesInfo[makeKey(axisModel)];
}
function getAxisPointerModel(axisModel) {
var axisInfo = getAxisInfo(axisModel);
return axisInfo && axisInfo.axisPointerModel;
}
function isHandleTrigger(axisPointerModel) {
return !!axisPointerModel.get(["handle", "show"]);
}
/**
* @param {module:echarts/model/Model} model
* @return {string} unique key
*/
function makeKey(model) {
return model.type + "||" + model.id;
}
var axisPointerClazz = {};
/**
* Base class of AxisView.
*/
var AxisView =
/** @class */
(function (_super) {
__extends(AxisView, _super);
function AxisView() {
var _this = (_super !== null && _super.apply(this, arguments)) || this;
_this.type = AxisView.type;
return _this;
}
/**
* @override
*/
AxisView.prototype.render = function (axisModel, ecModel, api, payload) {
// FIXME
// This process should proformed after coordinate systems updated
// (axis scale updated), and should be performed each time update.
// So put it here temporarily, although it is not appropriate to
// put a model-writing procedure in `view`.
this.axisPointerClass && fixValue(axisModel);
_super.prototype.render.apply(this, arguments);
this._doUpdateAxisPointerClass(axisModel, api, true);
};
/**
* Action handler.
*/
AxisView.prototype.updateAxisPointer = function (
axisModel,
ecModel,
api,
payload,
) {
this._doUpdateAxisPointerClass(axisModel, api, false);
};
/**
* @override
*/
AxisView.prototype.remove = function (ecModel, api) {
var axisPointer = this._axisPointer;
axisPointer && axisPointer.remove(api);
};
/**
* @override
*/
AxisView.prototype.dispose = function (ecModel, api) {
this._disposeAxisPointer(api);
_super.prototype.dispose.apply(this, arguments);
};
AxisView.prototype._doUpdateAxisPointerClass = function (
axisModel,
api,
forceRender,
) {
var Clazz = AxisView.getAxisPointerClass(this.axisPointerClass);
if (!Clazz) {
return;
}
var axisPointerModel = getAxisPointerModel(axisModel);
axisPointerModel
? (this._axisPointer || (this._axisPointer = new Clazz())).render(
axisModel,
axisPointerModel,
api,
forceRender,
)
: this._disposeAxisPointer(api);
};
AxisView.prototype._disposeAxisPointer = function (api) {
this._axisPointer && this._axisPointer.dispose(api);
this._axisPointer = null;
};
AxisView.registerAxisPointerClass = function (type, clazz) {
if ("development" !== "production") {
if (axisPointerClazz[type]) {
throw new Error("axisPointer " + type + " exists");
}
}
axisPointerClazz[type] = clazz;
};
AxisView.getAxisPointerClass = function (type) {
return type && axisPointerClazz[type];
};
AxisView.type = "axis";
return AxisView;
})(ComponentView);
var inner$6 = makeInner();
function rectCoordAxisBuildSplitArea(
axisView,
axisGroup,
axisModel,
gridModel,
) {
var axis = axisModel.axis;
if (axis.scale.isBlank()) {
return;
} // TODO: TYPE
var splitAreaModel = axisModel.getModel("splitArea");
var areaStyleModel = splitAreaModel.getModel("areaStyle");
var areaColors = areaStyleModel.get("color");
var gridRect = gridModel.coordinateSystem.getRect();
var ticksCoords = axis.getTicksCoords({
tickModel: splitAreaModel,
clamp: true,
});
if (!ticksCoords.length) {
return;
} // For Making appropriate splitArea animation, the color and anid
// should be corresponding to previous one if possible.
var areaColorsLen = areaColors.length;
var lastSplitAreaColors = inner$6(axisView).splitAreaColors;
var newSplitAreaColors = createHashMap();
var colorIndex = 0;
if (lastSplitAreaColors) {
for (var i = 0; i < ticksCoords.length; i++) {
var cIndex = lastSplitAreaColors.get(ticksCoords[i].tickValue);
if (cIndex != null) {
colorIndex = (cIndex + (areaColorsLen - 1) * i) % areaColorsLen;
break;
}
}
}
var prev = axis.toGlobalCoord(ticksCoords[0].coord);
var areaStyle = areaStyleModel.getAreaStyle();
areaColors = isArray(areaColors) ? areaColors : [areaColors];
for (var i = 1; i < ticksCoords.length; i++) {
var tickCoord = axis.toGlobalCoord(ticksCoords[i].coord);
var x = void 0;
var y = void 0;
var width = void 0;
var height = void 0;
if (axis.isHorizontal()) {
x = prev;
y = gridRect.y;
width = tickCoord - x;
height = gridRect.height;
prev = x + width;
} else {
x = gridRect.x;
y = prev;
width = gridRect.width;
height = tickCoord - y;
prev = y + height;
}
var tickValue = ticksCoords[i - 1].tickValue;
tickValue != null && newSplitAreaColors.set(tickValue, colorIndex);
axisGroup.add(
new Rect({
anid: tickValue != null ? "area_" + tickValue : null,
shape: {
x: x,
y: y,
width: width,
height: height,
},
style: defaults(
{
fill: areaColors[colorIndex],
},
areaStyle,
),
autoBatch: true,
silent: true,
}),
);
colorIndex = (colorIndex + 1) % areaColorsLen;
}
inner$6(axisView).splitAreaColors = newSplitAreaColors;
}
function rectCoordAxisHandleRemove(axisView) {
inner$6(axisView).splitAreaColors = null;
}
var axisBuilderAttrs = ["axisLine", "axisTickLabel", "axisName"];
var selfBuilderAttrs = ["splitArea", "splitLine", "minorSplitLine"];
var CartesianAxisView =
/** @class */
(function (_super) {
__extends(CartesianAxisView, _super);
function CartesianAxisView() {
var _this = (_super !== null && _super.apply(this, arguments)) || this;
_this.type = CartesianAxisView.type;
_this.axisPointerClass = "CartesianAxisPointer";
return _this;
}
/**
* @override
*/
CartesianAxisView.prototype.render = function (
axisModel,
ecModel,
api,
payload,
) {
this.group.removeAll();
var oldAxisGroup = this._axisGroup;
this._axisGroup = new Group();
this.group.add(this._axisGroup);
if (!axisModel.get("show")) {
return;
}
var gridModel = axisModel.getCoordSysModel();
var layout = layout$1(gridModel, axisModel);
var axisBuilder = new AxisBuilder(
axisModel,
extend(
{
handleAutoShown: function (elementType) {
var cartesians = gridModel.coordinateSystem.getCartesians();
for (var i = 0; i < cartesians.length; i++) {
if (
isIntervalOrLogScale(
cartesians[i].getOtherAxis(axisModel.axis).scale,
)
) {
// Still show axis tick or axisLine if other axis is value / log
return true;
}
} // Not show axisTick or axisLine if other axis is category / time
return false;
},
},
layout,
),
);
each(axisBuilderAttrs, axisBuilder.add, axisBuilder);
this._axisGroup.add(axisBuilder.getGroup());
each(
selfBuilderAttrs,
function (name) {
if (axisModel.get([name, "show"])) {
axisElementBuilders[name](
this,
this._axisGroup,
axisModel,
gridModel,
);
}
},
this,
); // THIS is a special case for bar racing chart.
// Update the axis label from the natural initial layout to
// sorted layout should has no animation.
var isInitialSortFromBarRacing =
payload && payload.type === "changeAxisOrder" && payload.isInitSort;
if (!isInitialSortFromBarRacing) {
groupTransition(oldAxisGroup, this._axisGroup, axisModel);
}
_super.prototype.render.call(this, axisModel, ecModel, api, payload);
};
CartesianAxisView.prototype.remove = function () {
rectCoordAxisHandleRemove(this);
};
CartesianAxisView.type = "cartesianAxis";
return CartesianAxisView;
})(AxisView);
var axisElementBuilders = {
splitLine: function (axisView, axisGroup, axisModel, gridModel) {
var axis = axisModel.axis;
if (axis.scale.isBlank()) {
return;
}
var splitLineModel = axisModel.getModel("splitLine");
var lineStyleModel = splitLineModel.getModel("lineStyle");
var lineColors = lineStyleModel.get("color");
lineColors = isArray(lineColors) ? lineColors : [lineColors];
var gridRect = gridModel.coordinateSystem.getRect();
var isHorizontal = axis.isHorizontal();
var lineCount = 0;
var ticksCoords = axis.getTicksCoords({
tickModel: splitLineModel,
});
var p1 = [];
var p2 = [];
var lineStyle = lineStyleModel.getLineStyle();
for (var i = 0; i < ticksCoords.length; i++) {
var tickCoord = axis.toGlobalCoord(ticksCoords[i].coord);
if (isHorizontal) {
p1[0] = tickCoord;
p1[1] = gridRect.y;
p2[0] = tickCoord;
p2[1] = gridRect.y + gridRect.height;
} else {
p1[0] = gridRect.x;
p1[1] = tickCoord;
p2[0] = gridRect.x + gridRect.width;
p2[1] = tickCoord;
}
var colorIndex = lineCount++ % lineColors.length;
var tickValue = ticksCoords[i].tickValue;
axisGroup.add(
new Line({
anid: tickValue != null ? "line_" + ticksCoords[i].tickValue : null,
subPixelOptimize: true,
autoBatch: true,
shape: {
x1: p1[0],
y1: p1[1],
x2: p2[0],
y2: p2[1],
},
style: defaults(
{
stroke: lineColors[colorIndex],
},
lineStyle,
),
silent: true,
}),
);
}
},
minorSplitLine: function (axisView, axisGroup, axisModel, gridModel) {
var axis = axisModel.axis;
var minorSplitLineModel = axisModel.getModel("minorSplitLine");
var lineStyleModel = minorSplitLineModel.getModel("lineStyle");
var gridRect = gridModel.coordinateSystem.getRect();
var isHorizontal = axis.isHorizontal();
var minorTicksCoords = axis.getMinorTicksCoords();
if (!minorTicksCoords.length) {
return;
}
var p1 = [];
var p2 = [];
var lineStyle = lineStyleModel.getLineStyle();
for (var i = 0; i < minorTicksCoords.length; i++) {
for (var k = 0; k < minorTicksCoords[i].length; k++) {
var tickCoord = axis.toGlobalCoord(minorTicksCoords[i][k].coord);
if (isHorizontal) {
p1[0] = tickCoord;
p1[1] = gridRect.y;
p2[0] = tickCoord;
p2[1] = gridRect.y + gridRect.height;
} else {
p1[0] = gridRect.x;
p1[1] = tickCoord;
p2[0] = gridRect.x + gridRect.width;
p2[1] = tickCoord;
}
axisGroup.add(
new Line({
anid: "minor_line_" + minorTicksCoords[i][k].tickValue,
subPixelOptimize: true,
autoBatch: true,
shape: {
x1: p1[0],
y1: p1[1],
x2: p2[0],
y2: p2[1],
},
style: lineStyle,
silent: true,
}),
);
}
}
},
splitArea: function (axisView, axisGroup, axisModel, gridModel) {
rectCoordAxisBuildSplitArea(axisView, axisGroup, axisModel, gridModel);
},
};
var CartesianXAxisView =
/** @class */
(function (_super) {
__extends(CartesianXAxisView, _super);
function CartesianXAxisView() {
var _this = (_super !== null && _super.apply(this, arguments)) || this;
_this.type = CartesianXAxisView.type;
return _this;
}
CartesianXAxisView.type = "xAxis";
return CartesianXAxisView;
})(CartesianAxisView);
var CartesianYAxisView =
/** @class */
(function (_super) {
__extends(CartesianYAxisView, _super);
function CartesianYAxisView() {
var _this = (_super !== null && _super.apply(this, arguments)) || this;
_this.type = CartesianXAxisView.type;
return _this;
}
CartesianYAxisView.type = "yAxis";
return CartesianYAxisView;
})(CartesianAxisView);
var GridView =
/** @class */
(function (_super) {
__extends(GridView, _super);
function GridView() {
var _this = (_super !== null && _super.apply(this, arguments)) || this;
_this.type = "grid";
return _this;
}
GridView.prototype.render = function (gridModel, ecModel) {
this.group.removeAll();
if (gridModel.get("show")) {
this.group.add(
new Rect({
shape: gridModel.coordinateSystem.getRect(),
style: defaults(
{
fill: gridModel.get("backgroundColor"),
},
gridModel.getItemStyle(),
),
silent: true,
z2: -1,
}),
);
}
};
GridView.type = "grid";
return GridView;
})(ComponentView);
var extraOption = {
// gridIndex: 0,
// gridId: '',
offset: 0,
};
function install$5(registers) {
registers.registerComponentView(GridView);
registers.registerComponentModel(GridModel);
registers.registerCoordinateSystem("cartesian2d", Grid);
axisModelCreator(registers, "x", CartesianAxisModel, extraOption);
axisModelCreator(registers, "y", CartesianAxisModel, extraOption);
registers.registerComponentView(CartesianXAxisView);
registers.registerComponentView(CartesianYAxisView);
registers.registerPreprocessor(function (option) {
// Only create grid when need
if (option.xAxis && option.yAxis && !option.grid) {
option.grid = {};
}
});
}
function install$6(registers) {
// In case developer forget to include grid component
use(install$5);
registers.registerSeriesModel(ScatterSeriesModel);
registers.registerChartView(ScatterView);
registers.registerLayout(pointsLayout("scatter"));
}
function radarLayout(ecModel) {
ecModel.eachSeriesByType("radar", function (seriesModel) {
var data = seriesModel.getData();
var points = [];
var coordSys = seriesModel.coordinateSystem;
if (!coordSys) {
return;
}
var axes = coordSys.getIndicatorAxes();
each(axes, function (axis, axisIndex) {
data.each(
data.mapDimension(axes[axisIndex].dim),
function (val, dataIndex) {
points[dataIndex] = points[dataIndex] || [];
var point = coordSys.dataToPoint(val, axisIndex);
points[dataIndex][axisIndex] = isValidPoint(point)
? point
: getValueMissingPoint(coordSys);
},
);
}); // Close polygon
data.each(function (idx) {
// TODO
// Is it appropriate to connect to the next data when some data is missing?
// Or, should trade it like `connectNull` in line chart?
var firstPoint =
find(points[idx], function (point) {
return isValidPoint(point);
}) || getValueMissingPoint(coordSys); // Copy the first actual point to the end of the array
points[idx].push(firstPoint.slice());
data.setItemLayout(idx, points[idx]);
});
});
}
function isValidPoint(point) {
return !isNaN(point[0]) && !isNaN(point[1]);
}
function getValueMissingPoint(coordSys) {
// It is error-prone to input [NaN, NaN] into polygon, polygon.
// (probably cause problem when refreshing or animating)
return [coordSys.cx, coordSys.cy];
}
function radarBackwardCompat(option) {
var polarOptArr = option.polar;
if (polarOptArr) {
if (!isArray(polarOptArr)) {
polarOptArr = [polarOptArr];
}
var polarNotRadar_1 = [];
each(polarOptArr, function (polarOpt, idx) {
if (polarOpt.indicator) {
if (polarOpt.type && !polarOpt.shape) {
polarOpt.shape = polarOpt.type;
}
option.radar = option.radar || [];
if (!isArray(option.radar)) {
option.radar = [option.radar];
}
option.radar.push(polarOpt);
} else {
polarNotRadar_1.push(polarOpt);
}
});
option.polar = polarNotRadar_1;
}
each(option.series, function (seriesOpt) {
if (seriesOpt && seriesOpt.type === "radar" && seriesOpt.polarIndex) {
seriesOpt.radarIndex = seriesOpt.polarIndex;
}
});
}
var RadarView =
/** @class */
(function (_super) {
__extends(RadarView, _super);
function RadarView() {
var _this = (_super !== null && _super.apply(this, arguments)) || this;
_this.type = RadarView.type;
return _this;
}
RadarView.prototype.render = function (seriesModel, ecModel, api) {
var polar = seriesModel.coordinateSystem;
var group = this.group;
var data = seriesModel.getData();
var oldData = this._data;
function createSymbol$1(data, idx) {
var symbolType = data.getItemVisual(idx, "symbol") || "circle";
if (symbolType === "none") {
return;
}
var symbolSize = normalizeSymbolSize(
data.getItemVisual(idx, "symbolSize"),
);
var symbolPath = createSymbol(symbolType, -1, -1, 2, 2);
var symbolRotate = data.getItemVisual(idx, "symbolRotate") || 0;
symbolPath.attr({
style: {
strokeNoScale: true,
},
z2: 100,
scaleX: symbolSize[0] / 2,
scaleY: symbolSize[1] / 2,
rotation: (symbolRotate * Math.PI) / 180 || 0,
});
return symbolPath;
}
function updateSymbols(
oldPoints,
newPoints,
symbolGroup,
data,
idx,
isInit,
) {
// Simply rerender all
symbolGroup.removeAll();
for (var i = 0; i < newPoints.length - 1; i++) {
var symbolPath = createSymbol$1(data, idx);
if (symbolPath) {
symbolPath.__dimIdx = i;
if (oldPoints[i]) {
symbolPath.setPosition(oldPoints[i]);
graphic[isInit ? "initProps" : "updateProps"](
symbolPath,
{
x: newPoints[i][0],
y: newPoints[i][1],
},
seriesModel,
idx,
);
} else {
symbolPath.setPosition(newPoints[i]);
}
symbolGroup.add(symbolPath);
}
}
}
function getInitialPoints(points) {
return map(points, function (pt) {
return [polar.cx, polar.cy];
});
}
data
.diff(oldData)
.add(function (idx) {
var points = data.getItemLayout(idx);
if (!points) {
return;
}
var polygon = new Polygon();
var polyline = new Polyline();
var target = {
shape: {
points: points,
},
};
polygon.shape.points = getInitialPoints(points);
polyline.shape.points = getInitialPoints(points);
initProps(polygon, target, seriesModel, idx);
initProps(polyline, target, seriesModel, idx);
var itemGroup = new Group();
var symbolGroup = new Group();
itemGroup.add(polyline);
itemGroup.add(polygon);
itemGroup.add(symbolGroup);
updateSymbols(
polyline.shape.points,
points,
symbolGroup,
data,
idx,
true,
);
data.setItemGraphicEl(idx, itemGroup);
})
.update(function (newIdx, oldIdx) {
var itemGroup = oldData.getItemGraphicEl(oldIdx);
var polyline = itemGroup.childAt(0);
var polygon = itemGroup.childAt(1);
var symbolGroup = itemGroup.childAt(2);
var target = {
shape: {
points: data.getItemLayout(newIdx),
},
};
if (!target.shape.points) {
return;
}
updateSymbols(
polyline.shape.points,
target.shape.points,
symbolGroup,
data,
newIdx,
false,
);
saveOldStyle(polygon);
saveOldStyle(polyline);
updateProps(polyline, target, seriesModel);
updateProps(polygon, target, seriesModel);
data.setItemGraphicEl(newIdx, itemGroup);
})
.remove(function (idx) {
group.remove(oldData.getItemGraphicEl(idx));
})
.execute();
data.eachItemGraphicEl(function (itemGroup, idx) {
var itemModel = data.getItemModel(idx);
var polyline = itemGroup.childAt(0);
var polygon = itemGroup.childAt(1);
var symbolGroup = itemGroup.childAt(2); // Radar uses the visual encoded from itemStyle.
var itemStyle = data.getItemVisual(idx, "style");
var color = itemStyle.fill;
group.add(itemGroup);
polyline.useStyle(
defaults(itemModel.getModel("lineStyle").getLineStyle(), {
fill: "none",
stroke: color,
}),
);
setStatesStylesFromModel(polyline, itemModel, "lineStyle");
setStatesStylesFromModel(polygon, itemModel, "areaStyle");
var areaStyleModel = itemModel.getModel("areaStyle");
var polygonIgnore =
areaStyleModel.isEmpty() && areaStyleModel.parentModel.isEmpty();
polygon.ignore = polygonIgnore;
each(["emphasis", "select", "blur"], function (stateName) {
var stateModel = itemModel.getModel([stateName, "areaStyle"]);
var stateIgnore =
stateModel.isEmpty() && stateModel.parentModel.isEmpty(); // Won't be ignore if normal state is not ignore.
polygon.ensureState(stateName).ignore =
stateIgnore && polygonIgnore;
});
polygon.useStyle(
defaults(areaStyleModel.getAreaStyle(), {
fill: color,
opacity: 0.7,
decal: itemStyle.decal,
}),
);
var emphasisModel = itemModel.getModel("emphasis");
var itemHoverStyle = emphasisModel
.getModel("itemStyle")
.getItemStyle();
symbolGroup.eachChild(function (symbolPath) {
if (symbolPath instanceof ZRImage) {
var pathStyle = symbolPath.style;
symbolPath.useStyle(
extend(
{
// TODO other properties like x, y ?
image: pathStyle.image,
x: pathStyle.x,
y: pathStyle.y,
width: pathStyle.width,
height: pathStyle.height,
},
itemStyle,
),
);
} else {
symbolPath.useStyle(itemStyle);
symbolPath.setColor(color);
symbolPath.style.strokeNoScale = true;
}
var pathEmphasisState = symbolPath.ensureState("emphasis");
pathEmphasisState.style = clone(itemHoverStyle);
var defaultText = data
.getStore()
.get(data.getDimensionIndex(symbolPath.__dimIdx), idx);
(defaultText == null || isNaN(defaultText)) && (defaultText = "");
setLabelStyle(symbolPath, getLabelStatesModels(itemModel), {
labelFetcher: data.hostModel,
labelDataIndex: idx,
labelDimIndex: symbolPath.__dimIdx,
defaultText: defaultText,
inheritColor: color,
defaultOpacity: itemStyle.opacity,
});
});
toggleHoverEmphasis(
itemGroup,
emphasisModel.get("focus"),
emphasisModel.get("blurScope"),
emphasisModel.get("disabled"),
);
});
this._data = data;
};
RadarView.prototype.remove = function () {
this.group.removeAll();
this._data = null;
};
RadarView.type = "radar";
return RadarView;
})(ChartView);
var RadarSeriesModel =
/** @class */
(function (_super) {
__extends(RadarSeriesModel, _super);
function RadarSeriesModel() {
var _this = (_super !== null && _super.apply(this, arguments)) || this;
_this.type = RadarSeriesModel.type;
_this.hasSymbolVisual = true;
return _this;
} // Overwrite
RadarSeriesModel.prototype.init = function (option) {
_super.prototype.init.apply(this, arguments); // Enable legend selection for each data item
// Use a function instead of direct access because data reference may changed
this.legendVisualProvider = new LegendVisualProvider(
bind(this.getData, this),
bind(this.getRawData, this),
);
};
RadarSeriesModel.prototype.getInitialData = function (option, ecModel) {
return createSeriesDataSimply(this, {
generateCoord: "indicator_",
generateCoordCount: Infinity,
});
};
RadarSeriesModel.prototype.formatTooltip = function (
dataIndex,
multipleSeries,
dataType,
) {
var data = this.getData();
var coordSys = this.coordinateSystem;
var indicatorAxes = coordSys.getIndicatorAxes();
var name = this.getData().getName(dataIndex);
var nameToDisplay = name === "" ? this.name : name;
var markerColor = retrieveVisualColorForTooltipMarker(this, dataIndex);
return createTooltipMarkup("section", {
header: nameToDisplay,
sortBlocks: true,
blocks: map(indicatorAxes, function (axis) {
var val = data.get(data.mapDimension(axis.dim), dataIndex);
return createTooltipMarkup("nameValue", {
markerType: "subItem",
markerColor: markerColor,
name: axis.name,
value: val,
sortParam: val,
});
}),
});
};
RadarSeriesModel.prototype.getTooltipPosition = function (dataIndex) {
if (dataIndex != null) {
var data_1 = this.getData();
var coordSys = this.coordinateSystem;
var values = data_1.getValues(
map(coordSys.dimensions, function (dim) {
return data_1.mapDimension(dim);
}),
dataIndex,
);
for (var i = 0, len = values.length; i < len; i++) {
if (!isNaN(values[i])) {
var indicatorAxes = coordSys.getIndicatorAxes();
return coordSys.coordToPoint(
indicatorAxes[i].dataToCoord(values[i]),
i,
);
}
}
}
};
RadarSeriesModel.type = "series.radar";
RadarSeriesModel.dependencies = ["radar"];
RadarSeriesModel.defaultOption = {
// zlevel: 0,
z: 2,
colorBy: "data",
coordinateSystem: "radar",
legendHoverLink: true,
radarIndex: 0,
lineStyle: {
width: 2,
type: "solid",
join: "round",
},
label: {
position: "top",
},
// areaStyle: {
// },
// itemStyle: {}
symbolSize: 8, // symbolRotate: null
};
return RadarSeriesModel;
})(SeriesModel);
var valueAxisDefault = axisDefault.value;
function defaultsShow(opt, show) {
return defaults(
{
show: show,
},
opt,
);
}
var RadarModel =
/** @class */
(function (_super) {
__extends(RadarModel, _super);
function RadarModel() {
var _this = (_super !== null && _super.apply(this, arguments)) || this;
_this.type = RadarModel.type;
return _this;
}
RadarModel.prototype.optionUpdated = function () {
var boundaryGap = this.get("boundaryGap");
var splitNumber = this.get("splitNumber");
var scale = this.get("scale");
var axisLine = this.get("axisLine");
var axisTick = this.get("axisTick"); // let axisType = this.get('axisType');
var axisLabel = this.get("axisLabel");
var nameTextStyle = this.get("axisName");
var showName = this.get(["axisName", "show"]);
var nameFormatter = this.get(["axisName", "formatter"]);
var nameGap = this.get("axisNameGap");
var triggerEvent = this.get("triggerEvent");
var indicatorModels = map(
this.get("indicator") || [],
function (indicatorOpt) {
// PENDING
if (
indicatorOpt.max != null &&
indicatorOpt.max > 0 &&
!indicatorOpt.min
) {
indicatorOpt.min = 0;
} else if (
indicatorOpt.min != null &&
indicatorOpt.min < 0 &&
!indicatorOpt.max
) {
indicatorOpt.max = 0;
}
var iNameTextStyle = nameTextStyle;
if (indicatorOpt.color != null) {
iNameTextStyle = defaults(
{
color: indicatorOpt.color,
},
nameTextStyle,
);
} // Use same configuration
var innerIndicatorOpt = merge(
clone(indicatorOpt),
{
boundaryGap: boundaryGap,
splitNumber: splitNumber,
scale: scale,
axisLine: axisLine,
axisTick: axisTick,
// axisType: axisType,
axisLabel: axisLabel,
// Compatible with 2 and use text
name: indicatorOpt.text,
showName: showName,
nameLocation: "end",
nameGap: nameGap,
// min: 0,
nameTextStyle: iNameTextStyle,
triggerEvent: triggerEvent,
},
false,
);
if (!showName) {
innerIndicatorOpt.name = "";
}
if (isString(nameFormatter)) {
var indName = innerIndicatorOpt.name;
innerIndicatorOpt.name = nameFormatter.replace(
"{value}",
indName != null ? indName : "",
);
} else if (isFunction(nameFormatter)) {
innerIndicatorOpt.name = nameFormatter(
innerIndicatorOpt.name,
innerIndicatorOpt,
);
}
var model = new Model(innerIndicatorOpt, null, this.ecModel);
mixin(model, AxisModelCommonMixin.prototype); // For triggerEvent.
model.mainType = "radar";
model.componentIndex = this.componentIndex;
return model;
},
this,
);
this._indicatorModels = indicatorModels;
};
RadarModel.prototype.getIndicatorModels = function () {
return this._indicatorModels;
};
RadarModel.type = "radar";
RadarModel.defaultOption = {
// zlevel: 0,
z: 0,
center: ["50%", "50%"],
radius: "75%",
startAngle: 90,
axisName: {
show: true, // formatter: null
// textStyle: {}
},
boundaryGap: [0, 0],
splitNumber: 5,
axisNameGap: 15,
scale: false,
// Polygon or circle
shape: "polygon",
axisLine: merge(
{
lineStyle: {
color: "#bbb",
},
},
valueAxisDefault.axisLine,
),
axisLabel: defaultsShow(valueAxisDefault.axisLabel, false),
axisTick: defaultsShow(valueAxisDefault.axisTick, false),
// axisType: 'value',
splitLine: defaultsShow(valueAxisDefault.splitLine, true),
splitArea: defaultsShow(valueAxisDefault.splitArea, true),
// {text, min, max}
indicator: [],
};
return RadarModel;
})(ComponentModel);
var axisBuilderAttrs$1 = ["axisLine", "axisTickLabel", "axisName"];
var RadarView$1 =
/** @class */
(function (_super) {
__extends(RadarView, _super);
function RadarView() {
var _this = (_super !== null && _super.apply(this, arguments)) || this;
_this.type = RadarView.type;
return _this;
}
RadarView.prototype.render = function (radarModel, ecModel, api) {
var group = this.group;
group.removeAll();
this._buildAxes(radarModel);
this._buildSplitLineAndArea(radarModel);
};
RadarView.prototype._buildAxes = function (radarModel) {
var radar = radarModel.coordinateSystem;
var indicatorAxes = radar.getIndicatorAxes();
var axisBuilders = map(indicatorAxes, function (indicatorAxis) {
var axisName = indicatorAxis.model.get("showName")
? indicatorAxis.name
: ""; // hide name
var axisBuilder = new AxisBuilder(indicatorAxis.model, {
axisName: axisName,
position: [radar.cx, radar.cy],
rotation: indicatorAxis.angle,
labelDirection: -1,
tickDirection: -1,
nameDirection: 1,
});
return axisBuilder;
});
each(
axisBuilders,
function (axisBuilder) {
each(axisBuilderAttrs$1, axisBuilder.add, axisBuilder);
this.group.add(axisBuilder.getGroup());
},
this,
);
};
RadarView.prototype._buildSplitLineAndArea = function (radarModel) {
var radar = radarModel.coordinateSystem;
var indicatorAxes = radar.getIndicatorAxes();
if (!indicatorAxes.length) {
return;
}
var shape = radarModel.get("shape");
var splitLineModel = radarModel.getModel("splitLine");
var splitAreaModel = radarModel.getModel("splitArea");
var lineStyleModel = splitLineModel.getModel("lineStyle");
var areaStyleModel = splitAreaModel.getModel("areaStyle");
var showSplitLine = splitLineModel.get("show");
var showSplitArea = splitAreaModel.get("show");
var splitLineColors = lineStyleModel.get("color");
var splitAreaColors = areaStyleModel.get("color");
var splitLineColorsArr = isArray(splitLineColors)
? splitLineColors
: [splitLineColors];
var splitAreaColorsArr = isArray(splitAreaColors)
? splitAreaColors
: [splitAreaColors];
var splitLines = [];
var splitAreas = [];
function getColorIndex(areaOrLine, areaOrLineColorList, idx) {
var colorIndex = idx % areaOrLineColorList.length;
areaOrLine[colorIndex] = areaOrLine[colorIndex] || [];
return colorIndex;
}
if (shape === "circle") {
var ticksRadius = indicatorAxes[0].getTicksCoords();
var cx = radar.cx;
var cy = radar.cy;
for (var i = 0; i < ticksRadius.length; i++) {
if (showSplitLine) {
var colorIndex = getColorIndex(splitLines, splitLineColorsArr, i);
splitLines[colorIndex].push(
new Circle({
shape: {
cx: cx,
cy: cy,
r: ticksRadius[i].coord,
},
}),
);
}
if (showSplitArea && i < ticksRadius.length - 1) {
var colorIndex = getColorIndex(splitAreas, splitAreaColorsArr, i);
splitAreas[colorIndex].push(
new Ring({
shape: {
cx: cx,
cy: cy,
r0: ticksRadius[i].coord,
r: ticksRadius[i + 1].coord,
},
}),
);
}
}
} // Polyyon
else {
var realSplitNumber_1;
var axesTicksPoints = map(
indicatorAxes,
function (indicatorAxis, idx) {
var ticksCoords = indicatorAxis.getTicksCoords();
realSplitNumber_1 =
realSplitNumber_1 == null
? ticksCoords.length - 1
: Math.min(ticksCoords.length - 1, realSplitNumber_1);
return map(ticksCoords, function (tickCoord) {
return radar.coordToPoint(tickCoord.coord, idx);
});
},
);
var prevPoints = [];
for (var i = 0; i <= realSplitNumber_1; i++) {
var points = [];
for (var j = 0; j < indicatorAxes.length; j++) {
points.push(axesTicksPoints[j][i]);
} // Close
if (points[0]) {
points.push(points[0].slice());
} else {
if ("development" !== "production") {
console.error("Can't draw value axis " + i);
}
}
if (showSplitLine) {
var colorIndex = getColorIndex(splitLines, splitLineColorsArr, i);
splitLines[colorIndex].push(
new Polyline({
shape: {
points: points,
},
}),
);
}
if (showSplitArea && prevPoints) {
var colorIndex = getColorIndex(
splitAreas,
splitAreaColorsArr,
i - 1,
);
splitAreas[colorIndex].push(
new Polygon({
shape: {
points: points.concat(prevPoints),
},
}),
);
}
prevPoints = points.slice().reverse();
}
}
var lineStyle = lineStyleModel.getLineStyle();
var areaStyle = areaStyleModel.getAreaStyle(); // Add splitArea before splitLine
each(
splitAreas,
function (splitAreas, idx) {
this.group.add(
mergePath$1(splitAreas, {
style: defaults(
{
stroke: "none",
fill: splitAreaColorsArr[idx % splitAreaColorsArr.length],
},
areaStyle,
),
silent: true,
}),
);
},
this,
);
each(
splitLines,
function (splitLines, idx) {
this.group.add(
mergePath$1(splitLines, {
style: defaults(
{
fill: "none",
stroke: splitLineColorsArr[idx % splitLineColorsArr.length],
},
lineStyle,
),
silent: true,
}),
);
},
this,
);
};
RadarView.type = "radar";
return RadarView;
})(ComponentView);
var IndicatorAxis =
/** @class */
(function (_super) {
__extends(IndicatorAxis, _super);
function IndicatorAxis(dim, scale, radiusExtent) {
var _this = _super.call(this, dim, scale, radiusExtent) || this;
_this.type = "value";
_this.angle = 0;
_this.name = "";
return _this;
}
return IndicatorAxis;
})(Axis);
var Radar =
/** @class */
(function () {
function Radar(radarModel, ecModel, api) {
/**
*
* Radar dimensions
*/
this.dimensions = [];
this._model = radarModel;
this._indicatorAxes = map(
radarModel.getIndicatorModels(),
function (indicatorModel, idx) {
var dim = "indicator_" + idx;
var indicatorAxis = new IndicatorAxis(
dim,
new IntervalScale(), // (indicatorModel.get('axisType') === 'log') ? new LogScale() : new IntervalScale()
);
indicatorAxis.name = indicatorModel.get("name"); // Inject model and axis
indicatorAxis.model = indicatorModel;
indicatorModel.axis = indicatorAxis;
this.dimensions.push(dim);
return indicatorAxis;
},
this,
);
this.resize(radarModel, api);
}
Radar.prototype.getIndicatorAxes = function () {
return this._indicatorAxes;
};
Radar.prototype.dataToPoint = function (value, indicatorIndex) {
var indicatorAxis = this._indicatorAxes[indicatorIndex];
return this.coordToPoint(
indicatorAxis.dataToCoord(value),
indicatorIndex,
);
}; // TODO: API should be coordToPoint([coord, indicatorIndex])
Radar.prototype.coordToPoint = function (coord, indicatorIndex) {
var indicatorAxis = this._indicatorAxes[indicatorIndex];
var angle = indicatorAxis.angle;
var x = this.cx + coord * Math.cos(angle);
var y = this.cy - coord * Math.sin(angle);
return [x, y];
};
Radar.prototype.pointToData = function (pt) {
var dx = pt[0] - this.cx;
var dy = pt[1] - this.cy;
var radius = Math.sqrt(dx * dx + dy * dy);
dx /= radius;
dy /= radius;
var radian = Math.atan2(-dy, dx); // Find the closest angle
// FIXME index can calculated directly
var minRadianDiff = Infinity;
var closestAxis;
var closestAxisIdx = -1;
for (var i = 0; i < this._indicatorAxes.length; i++) {
var indicatorAxis = this._indicatorAxes[i];
var diff = Math.abs(radian - indicatorAxis.angle);
if (diff < minRadianDiff) {
closestAxis = indicatorAxis;
closestAxisIdx = i;
minRadianDiff = diff;
}
}
return [
closestAxisIdx,
+(closestAxis && closestAxis.coordToData(radius)),
];
};
Radar.prototype.resize = function (radarModel, api) {
var center = radarModel.get("center");
var viewWidth = api.getWidth();
var viewHeight = api.getHeight();
var viewSize = Math.min(viewWidth, viewHeight) / 2;
this.cx = parsePercent$1(center[0], viewWidth);
this.cy = parsePercent$1(center[1], viewHeight);
this.startAngle = (radarModel.get("startAngle") * Math.PI) / 180; // radius may be single value like `20`, `'80%'`, or array like `[10, '80%']`
var radius = radarModel.get("radius");
if (isString(radius) || isNumber(radius)) {
radius = [0, radius];
}
this.r0 = parsePercent$1(radius[0], viewSize);
this.r = parsePercent$1(radius[1], viewSize);
each(
this._indicatorAxes,
function (indicatorAxis, idx) {
indicatorAxis.setExtent(this.r0, this.r);
var angle =
this.startAngle +
(idx * Math.PI * 2) / this._indicatorAxes.length; // Normalize to [-PI, PI]
angle = Math.atan2(Math.sin(angle), Math.cos(angle));
indicatorAxis.angle = angle;
},
this,
);
};
Radar.prototype.update = function (ecModel, api) {
var indicatorAxes = this._indicatorAxes;
var radarModel = this._model;
each(indicatorAxes, function (indicatorAxis) {
indicatorAxis.scale.setExtent(Infinity, -Infinity);
});
ecModel.eachSeriesByType(
"radar",
function (radarSeries, idx) {
if (
radarSeries.get("coordinateSystem") !== "radar" || // @ts-ignore
ecModel.getComponent("radar", radarSeries.get("radarIndex")) !==
radarModel
) {
return;
}
var data = radarSeries.getData();
each(indicatorAxes, function (indicatorAxis) {
indicatorAxis.scale.unionExtentFromData(
data,
data.mapDimension(indicatorAxis.dim),
);
});
},
this,
);
var splitNumber = radarModel.get("splitNumber");
var dummyScale = new IntervalScale();
dummyScale.setExtent(0, splitNumber);
dummyScale.setInterval(1); // Force all the axis fixing the maxSplitNumber.
each(indicatorAxes, function (indicatorAxis, idx) {
alignScaleTicks(indicatorAxis.scale, indicatorAxis.model, dummyScale);
});
};
Radar.prototype.convertToPixel = function (ecModel, finder, value) {
console.warn("Not implemented.");
return null;
};
Radar.prototype.convertFromPixel = function (ecModel, finder, pixel) {
console.warn("Not implemented.");
return null;
};
Radar.prototype.containPoint = function (point) {
console.warn("Not implemented.");
return false;
};
Radar.create = function (ecModel, api) {
var radarList = [];
ecModel.eachComponent("radar", function (radarModel) {
var radar = new Radar(radarModel, ecModel, api);
radarList.push(radar);
radarModel.coordinateSystem = radar;
});
ecModel.eachSeriesByType("radar", function (radarSeries) {
if (radarSeries.get("coordinateSystem") === "radar") {
// Inject coordinate system
// @ts-ignore
radarSeries.coordinateSystem =
radarList[radarSeries.get("radarIndex") || 0];
}
});
return radarList;
};
/**
* Radar dimensions is based on the data
*/
Radar.dimensions = [];
return Radar;
})();
function install$7(registers) {
registers.registerCoordinateSystem("radar", Radar);
registers.registerComponentModel(RadarModel);
registers.registerComponentView(RadarView$1);
registers.registerVisual({
seriesType: "radar",
reset: function (seriesModel) {
var data = seriesModel.getData(); // itemVisual symbol is for selected data
data.each(function (idx) {
data.setItemVisual(idx, "legendIcon", "roundRect");
}); // visual is for unselected data
data.setVisual("legendIcon", "roundRect");
},
});
}
function install$8(registers) {
use(install$7);
registers.registerChartView(RadarView);
registers.registerSeriesModel(RadarSeriesModel);
registers.registerLayout(radarLayout);
registers.registerProcessor(dataFilter("radar"));
registers.registerPreprocessor(radarBackwardCompat);
}
var ATTR = "\0_ec_interaction_mutex";
function take(zr, resourceKey, userKey) {
var store = getStore(zr);
store[resourceKey] = userKey;
}
function release(zr, resourceKey, userKey) {
var store = getStore(zr);
var uKey = store[resourceKey];
if (uKey === userKey) {
store[resourceKey] = null;
}
}
function isTaken(zr, resourceKey) {
return !!getStore(zr)[resourceKey];
}
function getStore(zr) {
return zr[ATTR] || (zr[ATTR] = {});
}
/**
* payload: {
* type: 'takeGlobalCursor',
* key: 'dataZoomSelect', or 'brush', or ...,
* If no userKey, release global cursor.
* }
*/
// TODO: SELF REGISTERED.
registerAction(
{
type: "takeGlobalCursor",
event: "globalCursorTaken",
update: "update",
},
noop,
);
var RoamController =
/** @class */
(function (_super) {
__extends(RoamController, _super);
function RoamController(zr) {
var _this = _super.call(this) || this;
_this._zr = zr; // Avoid two roamController bind the same handler
var mousedownHandler = bind(_this._mousedownHandler, _this);
var mousemoveHandler = bind(_this._mousemoveHandler, _this);
var mouseupHandler = bind(_this._mouseupHandler, _this);
var mousewheelHandler = bind(_this._mousewheelHandler, _this);
var pinchHandler = bind(_this._pinchHandler, _this);
/**
* Notice: only enable needed types. For example, if 'zoom'
* is not needed, 'zoom' should not be enabled, otherwise
* default mousewheel behaviour (scroll page) will be disabled.
*/
_this.enable = function (controlType, opt) {
// Disable previous first
this.disable();
this._opt = defaults(clone(opt) || {}, {
zoomOnMouseWheel: true,
moveOnMouseMove: true,
// By default, wheel do not trigger move.
moveOnMouseWheel: false,
preventDefaultMouseMove: true,
});
if (controlType == null) {
controlType = true;
}
if (
controlType === true ||
controlType === "move" ||
controlType === "pan"
) {
zr.on("mousedown", mousedownHandler);
zr.on("mousemove", mousemoveHandler);
zr.on("mouseup", mouseupHandler);
}
if (
controlType === true ||
controlType === "scale" ||
controlType === "zoom"
) {
zr.on("mousewheel", mousewheelHandler);
zr.on("pinch", pinchHandler);
}
};
_this.disable = function () {
zr.off("mousedown", mousedownHandler);
zr.off("mousemove", mousemoveHandler);
zr.off("mouseup", mouseupHandler);
zr.off("mousewheel", mousewheelHandler);
zr.off("pinch", pinchHandler);
};
return _this;
}
RoamController.prototype.isDragging = function () {
return this._dragging;
};
RoamController.prototype.isPinching = function () {
return this._pinching;
};
RoamController.prototype.setPointerChecker = function (pointerChecker) {
this.pointerChecker = pointerChecker;
};
RoamController.prototype.dispose = function () {
this.disable();
};
RoamController.prototype._mousedownHandler = function (e) {
if (
isMiddleOrRightButtonOnMouseUpDown(e) ||
(e.target && e.target.draggable)
) {
return;
}
var x = e.offsetX;
var y = e.offsetY; // Only check on mosedown, but not mousemove.
// Mouse can be out of target when mouse moving.
if (this.pointerChecker && this.pointerChecker(e, x, y)) {
this._x = x;
this._y = y;
this._dragging = true;
}
};
RoamController.prototype._mousemoveHandler = function (e) {
if (
!this._dragging ||
!isAvailableBehavior("moveOnMouseMove", e, this._opt) ||
e.gestureEvent === "pinch" ||
isTaken(this._zr, "globalPan")
) {
return;
}
var x = e.offsetX;
var y = e.offsetY;
var oldX = this._x;
var oldY = this._y;
var dx = x - oldX;
var dy = y - oldY;
this._x = x;
this._y = y;
this._opt.preventDefaultMouseMove && stop(e.event);
trigger(this, "pan", "moveOnMouseMove", e, {
dx: dx,
dy: dy,
oldX: oldX,
oldY: oldY,
newX: x,
newY: y,
isAvailableBehavior: null,
});
};
RoamController.prototype._mouseupHandler = function (e) {
if (!isMiddleOrRightButtonOnMouseUpDown(e)) {
this._dragging = false;
}
};
RoamController.prototype._mousewheelHandler = function (e) {
var shouldZoom = isAvailableBehavior("zoomOnMouseWheel", e, this._opt);
var shouldMove = isAvailableBehavior("moveOnMouseWheel", e, this._opt);
var wheelDelta = e.wheelDelta;
var absWheelDeltaDelta = Math.abs(wheelDelta);
var originX = e.offsetX;
var originY = e.offsetY; // wheelDelta maybe -0 in chrome mac.
if (wheelDelta === 0 || (!shouldZoom && !shouldMove)) {
return;
} // If both `shouldZoom` and `shouldMove` is true, trigger
// their event both, and the final behavior is determined
// by event listener themselves.
if (shouldZoom) {
// Convenience:
// Mac and VM Windows on Mac: scroll up: zoom out.
// Windows: scroll up: zoom in.
// FIXME: Should do more test in different environment.
// wheelDelta is too complicated in difference nvironment
// (https://developer.mozilla.org/en-US/docs/Web/Events/mousewheel),
// although it has been normallized by zrender.
// wheelDelta of mouse wheel is bigger than touch pad.
var factor =
absWheelDeltaDelta > 3 ? 1.4 : absWheelDeltaDelta > 1 ? 1.2 : 1.1;
var scale = wheelDelta > 0 ? factor : 1 / factor;
checkPointerAndTrigger(this, "zoom", "zoomOnMouseWheel", e, {
scale: scale,
originX: originX,
originY: originY,
isAvailableBehavior: null,
});
}
if (shouldMove) {
// FIXME: Should do more test in different environment.
var absDelta = Math.abs(wheelDelta); // wheelDelta of mouse wheel is bigger than touch pad.
var scrollDelta =
(wheelDelta > 0 ? 1 : -1) *
(absDelta > 3 ? 0.4 : absDelta > 1 ? 0.15 : 0.05);
checkPointerAndTrigger(this, "scrollMove", "moveOnMouseWheel", e, {
scrollDelta: scrollDelta,
originX: originX,
originY: originY,
isAvailableBehavior: null,
});
}
};
RoamController.prototype._pinchHandler = function (e) {
if (isTaken(this._zr, "globalPan")) {
return;
}
var scale = e.pinchScale > 1 ? 1.1 : 1 / 1.1;
checkPointerAndTrigger(this, "zoom", null, e, {
scale: scale,
originX: e.pinchX,
originY: e.pinchY,
isAvailableBehavior: null,
});
};
return RoamController;
})(Eventful);
function checkPointerAndTrigger(
controller,
eventName,
behaviorToCheck,
e,
contollerEvent,
) {
if (
controller.pointerChecker &&
controller.pointerChecker(
e,
contollerEvent.originX,
contollerEvent.originY,
)
) {
// When mouse is out of roamController rect,
// default befavoius should not be be disabled, otherwise
// page sliding is disabled, contrary to expectation.
stop(e.event);
trigger(controller, eventName, behaviorToCheck, e, contollerEvent);
}
}
function trigger(controller, eventName, behaviorToCheck, e, contollerEvent) {
// Also provide behavior checker for event listener, for some case that
// multiple components share one listener.
contollerEvent.isAvailableBehavior = bind(
isAvailableBehavior,
null,
behaviorToCheck,
e,
); // TODO should not have type issue.
controller.trigger(eventName, contollerEvent);
} // settings: {
// zoomOnMouseWheel
// moveOnMouseMove
// moveOnMouseWheel
// }
// The value can be: true / false / 'shift' / 'ctrl' / 'alt'.
function isAvailableBehavior(behaviorToCheck, e, settings) {
var setting = settings[behaviorToCheck];
return (
!behaviorToCheck ||
(setting && (!isString(setting) || e.event[setting + "Key"]))
);
}
/*
* 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.
*/
/**
* For geo and graph.
*/
function updateViewOnPan(controllerHost, dx, dy) {
var target = controllerHost.target;
target.x += dx;
target.y += dy;
target.dirty();
}
/**
* For geo and graph.
*/
function updateViewOnZoom(controllerHost, zoomDelta, zoomX, zoomY) {
var target = controllerHost.target;
var zoomLimit = controllerHost.zoomLimit;
var newZoom = (controllerHost.zoom = controllerHost.zoom || 1);
newZoom *= zoomDelta;
if (zoomLimit) {
var zoomMin = zoomLimit.min || 0;
var zoomMax = zoomLimit.max || Infinity;
newZoom = Math.max(Math.min(zoomMax, newZoom), zoomMin);
}
var zoomScale = newZoom / controllerHost.zoom;
controllerHost.zoom = newZoom; // Keep the mouse center when scaling
target.x -= (zoomX - target.x) * (zoomScale - 1);
target.y -= (zoomY - target.y) * (zoomScale - 1);
target.scaleX *= zoomScale;
target.scaleY *= zoomScale;
target.dirty();
}
/*
* 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.
*/
var IRRELEVANT_EXCLUDES = {
axisPointer: 1,
tooltip: 1,
brush: 1,
};
/**
* Avoid that: mouse click on a elements that is over geo or graph,
* but roam is triggered.
*/
function onIrrelevantElement(e, api, targetCoordSysModel) {
var model = api.getComponentByElement(e.topTarget); // If model is axisModel, it works only if it is injected with coordinateSystem.
var coordSys = model && model.coordinateSystem;
return (
model &&
model !== targetCoordSysModel &&
!IRRELEVANT_EXCLUDES.hasOwnProperty(model.mainType) &&
coordSys &&
coordSys.model !== targetCoordSysModel
);
}
function parseXML(svg) {
if (isString(svg)) {
var parser = new DOMParser();
svg = parser.parseFromString(svg, "text/xml");
}
var svgNode = svg;
if (svgNode.nodeType === 9) {
svgNode = svgNode.firstChild;
}
while (svgNode.nodeName.toLowerCase() !== "svg" || svgNode.nodeType !== 1) {
svgNode = svgNode.nextSibling;
}
return svgNode;
}
var nodeParsers;
var INHERITABLE_STYLE_ATTRIBUTES_MAP = {
fill: "fill",
stroke: "stroke",
"stroke-width": "lineWidth",
opacity: "opacity",
"fill-opacity": "fillOpacity",
"stroke-opacity": "strokeOpacity",
"stroke-dasharray": "lineDash",
"stroke-dashoffset": "lineDashOffset",
"stroke-linecap": "lineCap",
"stroke-linejoin": "lineJoin",
"stroke-miterlimit": "miterLimit",
"font-family": "fontFamily",
"font-size": "fontSize",
"font-style": "fontStyle",
"font-weight": "fontWeight",
"text-anchor": "textAlign",
visibility: "visibility",
display: "display",
};
var INHERITABLE_STYLE_ATTRIBUTES_MAP_KEYS = keys(
INHERITABLE_STYLE_ATTRIBUTES_MAP,
);
var SELF_STYLE_ATTRIBUTES_MAP = {
"alignment-baseline": "textBaseline",
"stop-color": "stopColor",
};
var SELF_STYLE_ATTRIBUTES_MAP_KEYS = keys(SELF_STYLE_ATTRIBUTES_MAP);
var SVGParser = (function () {
function SVGParser() {
this._defs = {};
this._root = null;
}
SVGParser.prototype.parse = function (xml, opt) {
opt = opt || {};
var svg = parseXML(xml);
if ("development" !== "production") {
if (!svg) {
throw new Error("Illegal svg");
}
}
this._defsUsePending = [];
var root = new Group();
this._root = root;
var named = [];
var viewBox = svg.getAttribute("viewBox") || "";
var width = parseFloat(svg.getAttribute("width") || opt.width);
var height = parseFloat(svg.getAttribute("height") || opt.height);
isNaN(width) && (width = null);
isNaN(height) && (height = null);
parseAttributes(svg, root, null, true, false);
var child = svg.firstChild;
while (child) {
this._parseNode(child, root, named, null, false, false);
child = child.nextSibling;
}
applyDefs(this._defs, this._defsUsePending);
this._defsUsePending = [];
var viewBoxRect;
var viewBoxTransform;
if (viewBox) {
var viewBoxArr = splitNumberSequence(viewBox);
if (viewBoxArr.length >= 4) {
viewBoxRect = {
x: parseFloat(viewBoxArr[0] || 0),
y: parseFloat(viewBoxArr[1] || 0),
width: parseFloat(viewBoxArr[2]),
height: parseFloat(viewBoxArr[3]),
};
}
}
if (viewBoxRect && width != null && height != null) {
viewBoxTransform = makeViewBoxTransform(viewBoxRect, {
x: 0,
y: 0,
width: width,
height: height,
});
if (!opt.ignoreViewBox) {
var elRoot = root;
root = new Group();
root.add(elRoot);
elRoot.scaleX = elRoot.scaleY = viewBoxTransform.scale;
elRoot.x = viewBoxTransform.x;
elRoot.y = viewBoxTransform.y;
}
}
if (!opt.ignoreRootClip && width != null && height != null) {
root.setClipPath(
new Rect({
shape: { x: 0, y: 0, width: width, height: height },
}),
);
}
return {
root: root,
width: width,
height: height,
viewBoxRect: viewBoxRect,
viewBoxTransform: viewBoxTransform,
named: named,
};
};
SVGParser.prototype._parseNode = function (
xmlNode,
parentGroup,
named,
namedFrom,
isInDefs,
isInText,
) {
var nodeName = xmlNode.nodeName.toLowerCase();
var el;
var namedFromForSub = namedFrom;
if (nodeName === "defs") {
isInDefs = true;
}
if (nodeName === "text") {
isInText = true;
}
if (nodeName === "defs" || nodeName === "switch") {
el = parentGroup;
} else {
if (!isInDefs) {
var parser_1 = nodeParsers[nodeName];
if (parser_1 && hasOwn(nodeParsers, nodeName)) {
el = parser_1.call(this, xmlNode, parentGroup);
var nameAttr = xmlNode.getAttribute("name");
if (nameAttr) {
var newNamed = {
name: nameAttr,
namedFrom: null,
svgNodeTagLower: nodeName,
el: el,
};
named.push(newNamed);
if (nodeName === "g") {
namedFromForSub = newNamed;
}
} else if (namedFrom) {
named.push({
name: namedFrom.name,
namedFrom: namedFrom,
svgNodeTagLower: nodeName,
el: el,
});
}
parentGroup.add(el);
}
}
var parser = paintServerParsers[nodeName];
if (parser && hasOwn(paintServerParsers, nodeName)) {
var def = parser.call(this, xmlNode);
var id = xmlNode.getAttribute("id");
if (id) {
this._defs[id] = def;
}
}
}
if (el && el.isGroup) {
var child = xmlNode.firstChild;
while (child) {
if (child.nodeType === 1) {
this._parseNode(
child,
el,
named,
namedFromForSub,
isInDefs,
isInText,
);
} else if (child.nodeType === 3 && isInText) {
this._parseText(child, el);
}
child = child.nextSibling;
}
}
};
SVGParser.prototype._parseText = function (xmlNode, parentGroup) {
var text = new TSpan({
style: {
text: xmlNode.textContent,
},
silent: true,
x: this._textX || 0,
y: this._textY || 0,
});
inheritStyle(parentGroup, text);
parseAttributes(xmlNode, text, this._defsUsePending, false, false);
applyTextAlignment(text, parentGroup);
var textStyle = text.style;
var fontSize = textStyle.fontSize;
if (fontSize && fontSize < 9) {
textStyle.fontSize = 9;
text.scaleX *= fontSize / 9;
text.scaleY *= fontSize / 9;
}
var font =
(textStyle.fontSize || textStyle.fontFamily) &&
[
textStyle.fontStyle,
textStyle.fontWeight,
(textStyle.fontSize || 12) + "px",
textStyle.fontFamily || "sans-serif",
].join(" ");
textStyle.font = font;
var rect = text.getBoundingRect();
this._textX += rect.width;
parentGroup.add(text);
return text;
};
SVGParser.internalField = (function () {
nodeParsers = {
g: function (xmlNode, parentGroup) {
var g = new Group();
inheritStyle(parentGroup, g);
parseAttributes(xmlNode, g, this._defsUsePending, false, false);
return g;
},
rect: function (xmlNode, parentGroup) {
var rect = new Rect();
inheritStyle(parentGroup, rect);
parseAttributes(xmlNode, rect, this._defsUsePending, false, false);
rect.setShape({
x: parseFloat(xmlNode.getAttribute("x") || "0"),
y: parseFloat(xmlNode.getAttribute("y") || "0"),
width: parseFloat(xmlNode.getAttribute("width") || "0"),
height: parseFloat(xmlNode.getAttribute("height") || "0"),
});
rect.silent = true;
return rect;
},
circle: function (xmlNode, parentGroup) {
var circle = new Circle();
inheritStyle(parentGroup, circle);
parseAttributes(xmlNode, circle, this._defsUsePending, false, false);
circle.setShape({
cx: parseFloat(xmlNode.getAttribute("cx") || "0"),
cy: parseFloat(xmlNode.getAttribute("cy") || "0"),
r: parseFloat(xmlNode.getAttribute("r") || "0"),
});
circle.silent = true;
return circle;
},
line: function (xmlNode, parentGroup) {
var line = new Line();
inheritStyle(parentGroup, line);
parseAttributes(xmlNode, line, this._defsUsePending, false, false);
line.setShape({
x1: parseFloat(xmlNode.getAttribute("x1") || "0"),
y1: parseFloat(xmlNode.getAttribute("y1") || "0"),
x2: parseFloat(xmlNode.getAttribute("x2") || "0"),
y2: parseFloat(xmlNode.getAttribute("y2") || "0"),
});
line.silent = true;
return line;
},
ellipse: function (xmlNode, parentGroup) {
var ellipse = new Ellipse();
inheritStyle(parentGroup, ellipse);
parseAttributes(xmlNode, ellipse, this._defsUsePending, false, false);
ellipse.setShape({
cx: parseFloat(xmlNode.getAttribute("cx") || "0"),
cy: parseFloat(xmlNode.getAttribute("cy") || "0"),
rx: parseFloat(xmlNode.getAttribute("rx") || "0"),
ry: parseFloat(xmlNode.getAttribute("ry") || "0"),
});
ellipse.silent = true;
return ellipse;
},
polygon: function (xmlNode, parentGroup) {
var pointsStr = xmlNode.getAttribute("points");
var pointsArr;
if (pointsStr) {
pointsArr = parsePoints(pointsStr);
}
var polygon = new Polygon({
shape: {
points: pointsArr || [],
},
silent: true,
});
inheritStyle(parentGroup, polygon);
parseAttributes(xmlNode, polygon, this._defsUsePending, false, false);
return polygon;
},
polyline: function (xmlNode, parentGroup) {
var pointsStr = xmlNode.getAttribute("points");
var pointsArr;
if (pointsStr) {
pointsArr = parsePoints(pointsStr);
}
var polyline = new Polyline({
shape: {
points: pointsArr || [],
},
silent: true,
});
inheritStyle(parentGroup, polyline);
parseAttributes(
xmlNode,
polyline,
this._defsUsePending,
false,
false,
);
return polyline;
},
image: function (xmlNode, parentGroup) {
var img = new ZRImage();
inheritStyle(parentGroup, img);
parseAttributes(xmlNode, img, this._defsUsePending, false, false);
img.setStyle({
image:
xmlNode.getAttribute("xlink:href") ||
xmlNode.getAttribute("href"),
x: +xmlNode.getAttribute("x"),
y: +xmlNode.getAttribute("y"),
width: +xmlNode.getAttribute("width"),
height: +xmlNode.getAttribute("height"),
});
img.silent = true;
return img;
},
text: function (xmlNode, parentGroup) {
var x = xmlNode.getAttribute("x") || "0";
var y = xmlNode.getAttribute("y") || "0";
var dx = xmlNode.getAttribute("dx") || "0";
var dy = xmlNode.getAttribute("dy") || "0";
this._textX = parseFloat(x) + parseFloat(dx);
this._textY = parseFloat(y) + parseFloat(dy);
var g = new Group();
inheritStyle(parentGroup, g);
parseAttributes(xmlNode, g, this._defsUsePending, false, true);
return g;
},
tspan: function (xmlNode, parentGroup) {
var x = xmlNode.getAttribute("x");
var y = xmlNode.getAttribute("y");
if (x != null) {
this._textX = parseFloat(x);
}
if (y != null) {
this._textY = parseFloat(y);
}
var dx = xmlNode.getAttribute("dx") || "0";
var dy = xmlNode.getAttribute("dy") || "0";
var g = new Group();
inheritStyle(parentGroup, g);
parseAttributes(xmlNode, g, this._defsUsePending, false, true);
this._textX += parseFloat(dx);
this._textY += parseFloat(dy);
return g;
},
path: function (xmlNode, parentGroup) {
var d = xmlNode.getAttribute("d") || "";
var path = createFromString(d);
inheritStyle(parentGroup, path);
parseAttributes(xmlNode, path, this._defsUsePending, false, false);
path.silent = true;
return path;
},
};
})();
return SVGParser;
})();
var paintServerParsers = {
lineargradient: function (xmlNode) {
var x1 = parseInt(xmlNode.getAttribute("x1") || "0", 10);
var y1 = parseInt(xmlNode.getAttribute("y1") || "0", 10);
var x2 = parseInt(xmlNode.getAttribute("x2") || "10", 10);
var y2 = parseInt(xmlNode.getAttribute("y2") || "0", 10);
var gradient = new LinearGradient(x1, y1, x2, y2);
parsePaintServerUnit(xmlNode, gradient);
parseGradientColorStops(xmlNode, gradient);
return gradient;
},
radialgradient: function (xmlNode) {
var cx = parseInt(xmlNode.getAttribute("cx") || "0", 10);
var cy = parseInt(xmlNode.getAttribute("cy") || "0", 10);
var r = parseInt(xmlNode.getAttribute("r") || "0", 10);
var gradient = new RadialGradient(cx, cy, r);
parsePaintServerUnit(xmlNode, gradient);
parseGradientColorStops(xmlNode, gradient);
return gradient;
},
};
function parsePaintServerUnit(xmlNode, gradient) {
var gradientUnits = xmlNode.getAttribute("gradientUnits");
if (gradientUnits === "userSpaceOnUse") {
gradient.global = true;
}
}
function parseGradientColorStops(xmlNode, gradient) {
var stop = xmlNode.firstChild;
while (stop) {
if (stop.nodeType === 1 && stop.nodeName.toLocaleLowerCase() === "stop") {
var offsetStr = stop.getAttribute("offset");
var offset = void 0;
if (offsetStr && offsetStr.indexOf("%") > 0) {
offset = parseInt(offsetStr, 10) / 100;
} else if (offsetStr) {
offset = parseFloat(offsetStr);
} else {
offset = 0;
}
var styleVals = {};
parseInlineStyle(stop, styleVals, styleVals);
var stopColor =
styleVals.stopColor || stop.getAttribute("stop-color") || "#000000";
gradient.colorStops.push({
offset: offset,
color: stopColor,
});
}
stop = stop.nextSibling;
}
}
function inheritStyle(parent, child) {
if (parent && parent.__inheritedStyle) {
if (!child.__inheritedStyle) {
child.__inheritedStyle = {};
}
defaults(child.__inheritedStyle, parent.__inheritedStyle);
}
}
function parsePoints(pointsString) {
var list = splitNumberSequence(pointsString);
var points = [];
for (var i = 0; i < list.length; i += 2) {
var x = parseFloat(list[i]);
var y = parseFloat(list[i + 1]);
points.push([x, y]);
}
return points;
}
function parseAttributes(
xmlNode,
el,
defsUsePending,
onlyInlineStyle,
isTextGroup,
) {
var disp = el;
var inheritedStyle = (disp.__inheritedStyle = disp.__inheritedStyle || {});
var selfStyle = {};
if (xmlNode.nodeType === 1) {
parseTransformAttribute(xmlNode, el);
parseInlineStyle(xmlNode, inheritedStyle, selfStyle);
if (!onlyInlineStyle) {
parseAttributeStyle(xmlNode, inheritedStyle, selfStyle);
}
}
disp.style = disp.style || {};
if (inheritedStyle.fill != null) {
disp.style.fill = getFillStrokeStyle(
disp,
"fill",
inheritedStyle.fill,
defsUsePending,
);
}
if (inheritedStyle.stroke != null) {
disp.style.stroke = getFillStrokeStyle(
disp,
"stroke",
inheritedStyle.stroke,
defsUsePending,
);
}
each(
[
"lineWidth",
"opacity",
"fillOpacity",
"strokeOpacity",
"miterLimit",
"fontSize",
],
function (propName) {
if (inheritedStyle[propName] != null) {
disp.style[propName] = parseFloat(inheritedStyle[propName]);
}
},
);
each(
[
"lineDashOffset",
"lineCap",
"lineJoin",
"fontWeight",
"fontFamily",
"fontStyle",
"textAlign",
],
function (propName) {
if (inheritedStyle[propName] != null) {
disp.style[propName] = inheritedStyle[propName];
}
},
);
if (isTextGroup) {
disp.__selfStyle = selfStyle;
}
if (inheritedStyle.lineDash) {
disp.style.lineDash = map(
splitNumberSequence(inheritedStyle.lineDash),
function (str) {
return parseFloat(str);
},
);
}
if (
inheritedStyle.visibility === "hidden" ||
inheritedStyle.visibility === "collapse"
) {
disp.invisible = true;
}
if (inheritedStyle.display === "none") {
disp.ignore = true;
}
}
function applyTextAlignment(text, parentGroup) {
var parentSelfStyle = parentGroup.__selfStyle;
if (parentSelfStyle) {
var textBaseline = parentSelfStyle.textBaseline;
var zrTextBaseline = textBaseline;
if (!textBaseline || textBaseline === "auto") {
zrTextBaseline = "alphabetic";
} else if (textBaseline === "baseline") {
zrTextBaseline = "alphabetic";
} else if (
textBaseline === "before-edge" ||
textBaseline === "text-before-edge"
) {
zrTextBaseline = "top";
} else if (
textBaseline === "after-edge" ||
textBaseline === "text-after-edge"
) {
zrTextBaseline = "bottom";
} else if (
textBaseline === "central" ||
textBaseline === "mathematical"
) {
zrTextBaseline = "middle";
}
text.style.textBaseline = zrTextBaseline;
}
var parentInheritedStyle = parentGroup.__inheritedStyle;
if (parentInheritedStyle) {
var textAlign = parentInheritedStyle.textAlign;
var zrTextAlign = textAlign;
if (textAlign) {
if (textAlign === "middle") {
zrTextAlign = "center";
}
text.style.textAlign = zrTextAlign;
}
}
}
var urlRegex = /^url\(\s*#(.*?)\)/;
function getFillStrokeStyle(el, method, str, defsUsePending) {
var urlMatch = str && str.match(urlRegex);
if (urlMatch) {
var url = trim(urlMatch[1]);
defsUsePending.push([el, method, url]);
return;
}
if (str === "none") {
str = null;
}
return str;
}
function applyDefs(defs, defsUsePending) {
for (var i = 0; i < defsUsePending.length; i++) {
var item = defsUsePending[i];
item[0].style[item[1]] = defs[item[2]];
}
}
var numberReg$1 = /-?([0-9]*\.)?[0-9]+([eE]-?[0-9]+)?/g;
function splitNumberSequence(rawStr) {
return rawStr.match(numberReg$1) || [];
}
var transformRegex =
/(translate|scale|rotate|skewX|skewY|matrix)\(([\-\s0-9\.eE,]*)\)/g;
var DEGREE_TO_ANGLE = Math.PI / 180;
function parseTransformAttribute(xmlNode, node) {
var transform = xmlNode.getAttribute("transform");
if (transform) {
transform = transform.replace(/,/g, " ");
var transformOps_1 = [];
var mt = null;
transform.replace(transformRegex, function (str, type, value) {
transformOps_1.push(type, value);
return "";
});
for (var i = transformOps_1.length - 1; i > 0; i -= 2) {
var value = transformOps_1[i];
var type = transformOps_1[i - 1];
var valueArr = splitNumberSequence(value);
mt = mt || create$1();
switch (type) {
case "translate":
translate(mt, mt, [
parseFloat(valueArr[0]),
parseFloat(valueArr[1] || "0"),
]);
break;
case "scale":
scale$1(mt, mt, [
parseFloat(valueArr[0]),
parseFloat(valueArr[1] || valueArr[0]),
]);
break;
case "rotate":
rotate(mt, mt, -parseFloat(valueArr[0]) * DEGREE_TO_ANGLE);
break;
case "skewX":
var sx = Math.tan(parseFloat(valueArr[0]) * DEGREE_TO_ANGLE);
mul$1(mt, [1, 0, sx, 1, 0, 0], mt);
break;
case "skewY":
var sy = Math.tan(parseFloat(valueArr[0]) * DEGREE_TO_ANGLE);
mul$1(mt, [1, sy, 0, 1, 0, 0], mt);
break;
case "matrix":
mt[0] = parseFloat(valueArr[0]);
mt[1] = parseFloat(valueArr[1]);
mt[2] = parseFloat(valueArr[2]);
mt[3] = parseFloat(valueArr[3]);
mt[4] = parseFloat(valueArr[4]);
mt[5] = parseFloat(valueArr[5]);
break;
}
}
node.setLocalTransform(mt);
}
}
var styleRegex = /([^\s:;]+)\s*:\s*([^:;]+)/g;
function parseInlineStyle(xmlNode, inheritableStyleResult, selfStyleResult) {
var style = xmlNode.getAttribute("style");
if (!style) {
return;
}
styleRegex.lastIndex = 0;
var styleRegResult;
while ((styleRegResult = styleRegex.exec(style)) != null) {
var svgStlAttr = styleRegResult[1];
var zrInheritableStlAttr = hasOwn(
INHERITABLE_STYLE_ATTRIBUTES_MAP,
svgStlAttr,
)
? INHERITABLE_STYLE_ATTRIBUTES_MAP[svgStlAttr]
: null;
if (zrInheritableStlAttr) {
inheritableStyleResult[zrInheritableStlAttr] = styleRegResult[2];
}
var zrSelfStlAttr = hasOwn(SELF_STYLE_ATTRIBUTES_MAP, svgStlAttr)
? SELF_STYLE_ATTRIBUTES_MAP[svgStlAttr]
: null;
if (zrSelfStlAttr) {
selfStyleResult[zrSelfStlAttr] = styleRegResult[2];
}
}
}
function parseAttributeStyle(
xmlNode,
inheritableStyleResult,
selfStyleResult,
) {
for (var i = 0; i < INHERITABLE_STYLE_ATTRIBUTES_MAP_KEYS.length; i++) {
var svgAttrName = INHERITABLE_STYLE_ATTRIBUTES_MAP_KEYS[i];
var attrValue = xmlNode.getAttribute(svgAttrName);
if (attrValue != null) {
inheritableStyleResult[INHERITABLE_STYLE_ATTRIBUTES_MAP[svgAttrName]] =
attrValue;
}
}
for (var i = 0; i < SELF_STYLE_ATTRIBUTES_MAP_KEYS.length; i++) {
var svgAttrName = SELF_STYLE_ATTRIBUTES_MAP_KEYS[i];
var attrValue = xmlNode.getAttribute(svgAttrName);
if (attrValue != null) {
selfStyleResult[SELF_STYLE_ATTRIBUTES_MAP[svgAttrName]] = attrValue;
}
}
}
function makeViewBoxTransform(viewBoxRect, boundingRect) {
var scaleX = boundingRect.width / viewBoxRect.width;
var scaleY = boundingRect.height / viewBoxRect.height;
var scale = Math.min(scaleX, scaleY);
return {
scale: scale,
x:
-(viewBoxRect.x + viewBoxRect.width / 2) * scale +
(boundingRect.x + boundingRect.width / 2),
y:
-(viewBoxRect.y + viewBoxRect.height / 2) * scale +
(boundingRect.y + boundingRect.height / 2),
};
}
function parseSVG(xml, opt) {
var parser = new SVGParser();
return parser.parse(xml, opt);
}
/**
* "region available" means that: enable users to set attribute `name="xxx"` on those tags
* to make it be a region.
* 1. region styles and its label styles can be defined in echarts opton:
* ```js
* geo: {
* regions: [{
* name: 'xxx',
* itemStyle: { ... },
* label: { ... }
* }, {
* ...
* },
* ...]
* };
* ```
* 2. name can be duplicated in different SVG tag. All of the tags with the same name share
* a region option. For exampel if there are two representing two lung lobes. They have
* no common parents but both of them need to display label "lung" inside.
*/
var REGION_AVAILABLE_SVG_TAG_MAP = createHashMap([
"rect",
"circle",
"line",
"ellipse",
"polygon",
"polyline",
"path", // are also enabled becuase some SVG might paint text itself,
// but still need to trigger events or tooltip.
"text",
"tspan", // is also enabled because this case: if multiple tags share one name
// and need label displayed, every tags will display the name, which is not
// expected. So we can put them into a . Thereby only one label
// displayed and located based on the bounding rect of the .
"g",
]);
var GeoSVGResource =
/** @class */
(function () {
function GeoSVGResource(mapName, svg) {
this.type = "geoSVG"; // All used graphics. key: hostKey, value: root
this._usedGraphicMap = createHashMap(); // All unused graphics.
this._freedGraphics = [];
this._mapName = mapName; // Only perform parse to XML object here, which might be time
// consiming for large SVG.
// Although convert XML to zrender element is also time consiming,
// if we do it here, the clone of zrender elements has to be
// required. So we do it once for each geo instance, util real
// performance issues call for optimizing it.
this._parsedXML = parseXML(svg);
}
GeoSVGResource.prototype.load = function () /* nameMap: NameMap */
{
// In the "load" stage, graphic need to be built to
// get boundingRect for geo coordinate system.
var firstGraphic = this._firstGraphic; // Create the return data structure only when first graphic created.
// Because they will be used in geo coordinate system update stage,
// and `regions` will be mounted at `geo` coordinate system,
// in which there is no "view" info, so that it should better not to
// make references to graphic elements.
if (!firstGraphic) {
firstGraphic = this._firstGraphic = this._buildGraphic(
this._parsedXML,
);
this._freedGraphics.push(firstGraphic);
this._boundingRect = this._firstGraphic.boundingRect.clone(); // PENDING: `nameMap` will not be supported until some real requirement come.
// if (nameMap) {
// named = applyNameMap(named, nameMap);
// }
var _a = createRegions(firstGraphic.named),
regions = _a.regions,
regionsMap = _a.regionsMap;
this._regions = regions;
this._regionsMap = regionsMap;
}
return {
boundingRect: this._boundingRect,
regions: this._regions,
regionsMap: this._regionsMap,
};
};
GeoSVGResource.prototype._buildGraphic = function (svgXML) {
var result;
var rootFromParse;
try {
result =
(svgXML &&
parseSVG(svgXML, {
ignoreViewBox: true,
ignoreRootClip: true,
})) ||
{};
rootFromParse = result.root;
assert(rootFromParse != null);
} catch (e) {
throw new Error("Invalid svg format\n" + e.message);
} // Note: we keep the covenant that the root has no transform. So always add an extra root.
var root = new Group();
root.add(rootFromParse);
root.isGeoSVGGraphicRoot = true; // [THE_RULE_OF_VIEWPORT_AND_VIEWBOX]
//
// Consider: `