cione-comp-lib
Version:
`$ yarn add cione-comp-lib` 或者 `$ npm i cione-comp-lib -S`
364 lines (363 loc) • 12.5 kB
JavaScript
import { clone, assert, bind, keys, isObject as isObject$1, each as each$1, isArray, isString, map, noop } from "../../../zrender/lib/core/util.mjs";
import { fastLerp, stringify, parse, modifyHSL, modifyAlpha } from "../../../zrender/lib/tool/color.mjs";
import { linearMap } from "../util/number.mjs";
import { warn } from "../util/log.mjs";
var each = each$1;
var isObject = isObject$1;
var CATEGORY_DEFAULT_VISUAL_INDEX = -1;
var VisualMapping = function() {
function VisualMapping2(option) {
var mappingMethod = option.mappingMethod;
var visualType = option.type;
var thisOption = this.option = clone(option);
this.type = visualType;
this.mappingMethod = mappingMethod;
this._normalizeData = normalizers[mappingMethod];
var visualHandler = VisualMapping2.visualHandlers[visualType];
this.applyVisual = visualHandler.applyVisual;
this.getColorMapper = visualHandler.getColorMapper;
this._normalizedToVisual = visualHandler._normalizedToVisual[mappingMethod];
if (mappingMethod === "piecewise") {
normalizeVisualRange(thisOption);
preprocessForPiecewise(thisOption);
} else if (mappingMethod === "category") {
thisOption.categories ? preprocessForSpecifiedCategory(thisOption) : normalizeVisualRange(thisOption, true);
} else {
assert(mappingMethod !== "linear" || thisOption.dataExtent);
normalizeVisualRange(thisOption);
}
}
VisualMapping2.prototype.mapValueToVisual = function(value) {
var normalized = this._normalizeData(value);
return this._normalizedToVisual(normalized, value);
};
VisualMapping2.prototype.getNormalizer = function() {
return bind(this._normalizeData, this);
};
VisualMapping2.listVisualTypes = function() {
return keys(VisualMapping2.visualHandlers);
};
VisualMapping2.isValidType = function(visualType) {
return VisualMapping2.visualHandlers.hasOwnProperty(visualType);
};
VisualMapping2.eachVisual = function(visual, callback, context) {
if (isObject$1(visual)) {
each$1(visual, callback, context);
} else {
callback.call(context, visual);
}
};
VisualMapping2.mapVisual = function(visual, callback, context) {
var isPrimary;
var newVisual = isArray(visual) ? [] : isObject$1(visual) ? {} : (isPrimary = true, null);
VisualMapping2.eachVisual(visual, function(v, key) {
var newVal = callback.call(context, v, key);
isPrimary ? newVisual = newVal : newVisual[key] = newVal;
});
return newVisual;
};
VisualMapping2.retrieveVisuals = function(obj) {
var ret = {};
var hasVisual;
obj && each(VisualMapping2.visualHandlers, function(h, visualType) {
if (obj.hasOwnProperty(visualType)) {
ret[visualType] = obj[visualType];
hasVisual = true;
}
});
return hasVisual ? ret : null;
};
VisualMapping2.prepareVisualTypes = function(visualTypes) {
if (isArray(visualTypes)) {
visualTypes = visualTypes.slice();
} else if (isObject(visualTypes)) {
var types_1 = [];
each(visualTypes, function(item, type) {
types_1.push(type);
});
visualTypes = types_1;
} else {
return [];
}
visualTypes.sort(function(type1, type2) {
return type2 === "color" && type1 !== "color" && type1.indexOf("color") === 0 ? 1 : -1;
});
return visualTypes;
};
VisualMapping2.dependsOn = function(visualType1, visualType2) {
return visualType2 === "color" ? !!(visualType1 && visualType1.indexOf(visualType2) === 0) : visualType1 === visualType2;
};
VisualMapping2.findPieceIndex = function(value, pieceList, findClosestWhenOutside) {
var possibleI;
var abs = Infinity;
for (var i = 0, len = pieceList.length; i < len; i++) {
var pieceValue = pieceList[i].value;
if (pieceValue != null) {
if (pieceValue === value || isString(pieceValue) && pieceValue === value + "") {
return i;
}
findClosestWhenOutside && updatePossible(pieceValue, i);
}
}
for (var i = 0, len = pieceList.length; i < len; i++) {
var piece = pieceList[i];
var interval = piece.interval;
var close_1 = piece.close;
if (interval) {
if (interval[0] === -Infinity) {
if (littleThan(close_1[1], value, interval[1])) {
return i;
}
} else if (interval[1] === Infinity) {
if (littleThan(close_1[0], interval[0], value)) {
return i;
}
} else if (littleThan(close_1[0], interval[0], value) && littleThan(close_1[1], value, interval[1])) {
return i;
}
findClosestWhenOutside && updatePossible(interval[0], i);
findClosestWhenOutside && updatePossible(interval[1], i);
}
}
if (findClosestWhenOutside) {
return value === Infinity ? pieceList.length - 1 : value === -Infinity ? 0 : possibleI;
}
function updatePossible(val, index) {
var newAbs = Math.abs(val - value);
if (newAbs < abs) {
abs = newAbs;
possibleI = index;
}
}
};
VisualMapping2.visualHandlers = {
color: {
applyVisual: makeApplyVisual("color"),
getColorMapper: function() {
var thisOption = this.option;
return bind(thisOption.mappingMethod === "category" ? function(value, isNormalized) {
!isNormalized && (value = this._normalizeData(value));
return doMapCategory.call(this, value);
} : function(value, isNormalized, out) {
var returnRGBArray = !!out;
!isNormalized && (value = this._normalizeData(value));
out = fastLerp(value, thisOption.parsedVisual, out);
return returnRGBArray ? out : stringify(out, "rgba");
}, this);
},
_normalizedToVisual: {
linear: function(normalized) {
return stringify(fastLerp(normalized, this.option.parsedVisual), "rgba");
},
category: doMapCategory,
piecewise: function(normalized, value) {
var result = getSpecifiedVisual.call(this, value);
if (result == null) {
result = stringify(fastLerp(normalized, this.option.parsedVisual), "rgba");
}
return result;
},
fixed: doMapFixed
}
},
colorHue: makePartialColorVisualHandler(function(color$1, value) {
return modifyHSL(color$1, value);
}),
colorSaturation: makePartialColorVisualHandler(function(color$1, value) {
return modifyHSL(color$1, null, value);
}),
colorLightness: makePartialColorVisualHandler(function(color$1, value) {
return modifyHSL(color$1, null, null, value);
}),
colorAlpha: makePartialColorVisualHandler(function(color$1, value) {
return modifyAlpha(color$1, value);
}),
decal: {
applyVisual: makeApplyVisual("decal"),
_normalizedToVisual: {
linear: null,
category: doMapCategory,
piecewise: null,
fixed: null
}
},
opacity: {
applyVisual: makeApplyVisual("opacity"),
_normalizedToVisual: createNormalizedToNumericVisual([0, 1])
},
liftZ: {
applyVisual: makeApplyVisual("liftZ"),
_normalizedToVisual: {
linear: doMapFixed,
category: doMapFixed,
piecewise: doMapFixed,
fixed: doMapFixed
}
},
symbol: {
applyVisual: function(value, getter, setter) {
var symbolCfg = this.mapValueToVisual(value);
setter("symbol", symbolCfg);
},
_normalizedToVisual: {
linear: doMapToArray,
category: doMapCategory,
piecewise: function(normalized, value) {
var result = getSpecifiedVisual.call(this, value);
if (result == null) {
result = doMapToArray.call(this, normalized);
}
return result;
},
fixed: doMapFixed
}
},
symbolSize: {
applyVisual: makeApplyVisual("symbolSize"),
_normalizedToVisual: createNormalizedToNumericVisual([0, 1])
}
};
return VisualMapping2;
}();
function preprocessForPiecewise(thisOption) {
var pieceList = thisOption.pieceList;
thisOption.hasSpecialVisual = false;
each$1(pieceList, function(piece, index) {
piece.originIndex = index;
if (piece.visual != null) {
thisOption.hasSpecialVisual = true;
}
});
}
function preprocessForSpecifiedCategory(thisOption) {
var categories = thisOption.categories;
var categoryMap = thisOption.categoryMap = {};
var visual = thisOption.visual;
each(categories, function(cate, index) {
categoryMap[cate] = index;
});
if (!isArray(visual)) {
var visualArr_1 = [];
if (isObject$1(visual)) {
each(visual, function(v, cate) {
var index = categoryMap[cate];
visualArr_1[index != null ? index : CATEGORY_DEFAULT_VISUAL_INDEX] = v;
});
} else {
visualArr_1[CATEGORY_DEFAULT_VISUAL_INDEX] = visual;
}
visual = setVisualToOption(thisOption, visualArr_1);
}
for (var i = categories.length - 1; i >= 0; i--) {
if (visual[i] == null) {
delete categoryMap[categories[i]];
categories.pop();
}
}
}
function normalizeVisualRange(thisOption, isCategory) {
var visual = thisOption.visual;
var visualArr = [];
if (isObject$1(visual)) {
each(visual, function(v) {
visualArr.push(v);
});
} else if (visual != null) {
visualArr.push(visual);
}
var doNotNeedPair = {
color: 1,
symbol: 1
};
if (!isCategory && visualArr.length === 1 && !doNotNeedPair.hasOwnProperty(thisOption.type)) {
visualArr[1] = visualArr[0];
}
setVisualToOption(thisOption, visualArr);
}
function makePartialColorVisualHandler(applyValue) {
return {
applyVisual: function(value, getter, setter) {
var colorChannel = this.mapValueToVisual(value);
setter("color", applyValue(getter("color"), colorChannel));
},
_normalizedToVisual: createNormalizedToNumericVisual([0, 1])
};
}
function doMapToArray(normalized) {
var visual = this.option.visual;
return visual[Math.round(linearMap(normalized, [0, 1], [0, visual.length - 1], true))] || {};
}
function makeApplyVisual(visualType) {
return function(value, getter, setter) {
setter(visualType, this.mapValueToVisual(value));
};
}
function doMapCategory(normalized) {
var visual = this.option.visual;
return visual[this.option.loop && normalized !== CATEGORY_DEFAULT_VISUAL_INDEX ? normalized % visual.length : normalized];
}
function doMapFixed() {
return this.option.visual[0];
}
function createNormalizedToNumericVisual(sourceExtent) {
return {
linear: function(normalized) {
return linearMap(normalized, sourceExtent, this.option.visual, true);
},
category: doMapCategory,
piecewise: function(normalized, value) {
var result = getSpecifiedVisual.call(this, value);
if (result == null) {
result = linearMap(normalized, sourceExtent, this.option.visual, true);
}
return result;
},
fixed: doMapFixed
};
}
function getSpecifiedVisual(value) {
var thisOption = this.option;
var pieceList = thisOption.pieceList;
if (thisOption.hasSpecialVisual) {
var pieceIndex = VisualMapping.findPieceIndex(value, pieceList);
var piece = pieceList[pieceIndex];
if (piece && piece.visual) {
return piece.visual[this.type];
}
}
}
function setVisualToOption(thisOption, visualArr) {
thisOption.visual = visualArr;
if (thisOption.type === "color") {
thisOption.parsedVisual = map(visualArr, function(item) {
var color$1 = parse(item);
if (!color$1 && false) {
warn("'" + item + "' is an illegal color, fallback to '#000000'", true);
}
return color$1 || [0, 0, 0, 1];
});
}
return visualArr;
}
var normalizers = {
linear: function(value) {
return linearMap(value, this.option.dataExtent, [0, 1], true);
},
piecewise: function(value) {
var pieceList = this.option.pieceList;
var pieceIndex = VisualMapping.findPieceIndex(value, pieceList, true);
if (pieceIndex != null) {
return linearMap(pieceIndex, [0, pieceList.length - 1], [0, 1], true);
}
},
category: function(value) {
var index = this.option.categories ? this.option.categoryMap[value] : value;
return index == null ? CATEGORY_DEFAULT_VISUAL_INDEX : index;
},
fixed: noop
};
function littleThan(close, a, b) {
return close ? a <= b : a < b;
}
var VisualMapping$1 = VisualMapping;
export { VisualMapping$1 as default };