|
/*
|
* Licensed to the Apache Software Foundation (ASF) under one
|
* or more contributor license agreements. See the NOTICE file
|
* distributed with this work for additional information
|
* regarding copyright ownership. The ASF licenses this file
|
* to you under the Apache License, Version 2.0 (the
|
* "License"); you may not use this file except in compliance
|
* with the License. You may obtain a copy of the License at
|
*
|
* http://www.apache.org/licenses/LICENSE-2.0
|
*
|
* Unless required by applicable law or agreed to in writing,
|
* software distributed under the License is distributed on an
|
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
|
* KIND, either express or implied. See the License for the
|
* specific language governing permissions and limitations
|
* under the License.
|
*/
|
|
|
/**
|
* AUTO-GENERATED FILE. DO NOT MODIFY.
|
*/
|
|
/*
|
* Licensed to the Apache Software Foundation (ASF) under one
|
* or more contributor license agreements. See the NOTICE file
|
* distributed with this work for additional information
|
* regarding copyright ownership. The ASF licenses this file
|
* to you under the Apache License, Version 2.0 (the
|
* "License"); you may not use this file except in compliance
|
* with the License. You may obtain a copy of the License at
|
*
|
* http://www.apache.org/licenses/LICENSE-2.0
|
*
|
* Unless required by applicable law or agreed to in writing,
|
* software distributed under the License is distributed on an
|
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
|
* KIND, either express or implied. See the License for the
|
* specific language governing permissions and limitations
|
* under the License.
|
*/
|
import { __extends } from "tslib";
|
/**
|
* Linear continuous scale
|
* http://en.wikipedia.org/wiki/Level_of_measurement
|
*/
|
// FIXME only one data
|
import Scale from './Scale.js';
|
import OrdinalMeta from '../data/OrdinalMeta.js';
|
import * as scaleHelper from './helper.js';
|
import { isArray, map, isObject, isString } from 'zrender/lib/core/util.js';
|
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 scaleHelper.contain(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 scaleHelper.normalize(val, this._extent);
|
};
|
/**
|
* @param val normalized value in [0, 1].
|
* @return raw ordinal number.
|
*/
|
OrdinalScale.prototype.scale = function (val) {
|
val = Math.round(scaleHelper.scale(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);
|
export default OrdinalScale;
|
