Split all helper functions in different files and import them directly where used
-import helpers from '../helpers/index';
import effects from '../helpers/helpers.easing';
import {resolve} from '../helpers/helpers.options';
+import {color as helpersColor} from '../helpers/helpers.color';
const transparent = 'transparent';
const interpolators = {
return factor > 0.5 ? to : from;
},
color(from, to, factor) {
- const c0 = helpers.color(from || transparent);
- const c1 = c0.valid && helpers.color(to || transparent);
+ const c0 = helpersColor(from || transparent);
+ const c1 = c0.valid && helpersColor(to || transparent);
return c1 && c1.valid
? c1.mix(c0, factor).hexString()
: to;
-import helpers from '../helpers/index';
+import {requestAnimFrame} from '../helpers/helpers.extras';
/**
* @typedef { import("./core.controller").default } Chart
}
me._running = true;
- me._request = helpers.requestAnimFrame.call(window, () => {
+ me._request = requestAnimFrame.call(window, () => {
me._update();
me._request = null;
import Animator from './core.animator';
import controllers from '../controllers/index';
import defaults from './core.defaults';
-import helpers from '../helpers/index';
import Interaction from './core.interaction';
import layouts from './core.layouts';
import {BasicPlatform, DomPlatform} from '../platform';
import plugins from './core.plugins';
import scaleService from './core.scaleService';
-import {getMaximumWidth, getMaximumHeight} from '../helpers/helpers.dom';
+import {getMaximumWidth, getMaximumHeight, retinaScale} from '../helpers/helpers.dom';
+import {mergeIf, merge, _merger, each, callback as callCallback, uid, valueOrDefault, _elementsEqual} from '../helpers/helpers.core';
+import {clear as canvasClear, clipArea, unclipArea, _isPointInArea} from '../helpers/helpers.canvas';
// @ts-ignore
import {version} from '../../package.json';
* @typedef { import("../platform/platform.base").IEvent } IEvent
*/
-const valueOrDefault = helpers.valueOrDefault;
function mergeScaleConfig(config, options) {
options = options || {};
Object.keys(configScales).forEach(id => {
const axis = id[0];
firstIDs[axis] = firstIDs[axis] || id;
- scales[id] = helpers.mergeIf({}, [configScales[id], chartDefaults.scales[axis]]);
+ scales[id] = mergeIf({}, [configScales[id], chartDefaults.scales[axis]]);
});
// Backward compatibility
if (options.scale) {
- scales[options.scale.id || 'r'] = helpers.mergeIf({}, [options.scale, chartDefaults.scales.r]);
+ scales[options.scale.id || 'r'] = mergeIf({}, [options.scale, chartDefaults.scales.r]);
firstIDs.r = firstIDs.r || options.scale.id || 'r';
}
Object.keys(defaultScaleOptions).forEach(defaultID => {
const id = dataset[defaultID + 'AxisID'] || firstIDs[defaultID] || defaultID;
scales[id] = scales[id] || {};
- helpers.mergeIf(scales[id], [
+ mergeIf(scales[id], [
configScales[id],
defaultScaleOptions[defaultID]
]);
// apply scale defaults, if not overridden by dataset defaults
Object.keys(scales).forEach(key => {
const scale = scales[key];
- helpers.mergeIf(scale, scaleService.getScaleDefaults(scale.type));
+ mergeIf(scale, scaleService.getScaleDefaults(scale.type));
});
return scales;
* a deep copy of the result, thus doesn't alter inputs.
*/
function mergeConfig(...args/* config objects ... */) {
- return helpers.merge({}, args, {
+ return merge({}, args, {
merger(key, target, source, options) {
if (key !== 'scales' && key !== 'scale') {
- helpers._merger(key, target, source, options);
+ _merger(key, target, source, options);
}
}
});
function updateConfig(chart) {
let newOptions = chart.options;
- helpers.each(chart.scales, (scale) => {
+ each(chart.scales, (scale) => {
layouts.removeBox(chart, scale);
});
const animationOptions = chart.options.animation;
plugins.notify(chart, 'afterRender');
- helpers.callback(animationOptions && animationOptions.onComplete, [ctx], chart);
+ callCallback(animationOptions && animationOptions.onComplete, [ctx], chart);
}
function onAnimationProgress(ctx) {
const chart = ctx.chart;
const animationOptions = chart.options.animation;
- helpers.callback(animationOptions && animationOptions.onProgress, [ctx], chart);
+ callCallback(animationOptions && animationOptions.onProgress, [ctx], chart);
}
function isDomSupported() {
const height = canvas && canvas.height;
const width = canvas && canvas.width;
- this.id = helpers.uid();
+ this.id = uid();
this.ctx = context;
this.canvas = canvas;
this.config = config;
// Initial resize before chart draws (must be silent to preserve initial animations).
me.resize(true);
} else {
- helpers.dom.retinaScale(me, me.options.devicePixelRatio);
+ retinaScale(me, me.options.devicePixelRatio);
}
me.bindEvents();
}
clear() {
- helpers.canvas.clear(this);
+ canvasClear(this);
return this;
}
canvas.style.height = newHeight + 'px';
}
- helpers.dom.retinaScale(me, newRatio);
+ retinaScale(me, newRatio);
if (!silent) {
// Notify any plugins about the resize
const scalesOptions = options.scales || {};
const scaleOptions = options.scale;
- helpers.each(scalesOptions, (axisOptions, axisID) => {
+ each(scalesOptions, (axisOptions, axisID) => {
axisOptions.id = axisID;
});
);
}
- helpers.each(items, (item) => {
+ each(items, (item) => {
const scaleOptions = item.options;
const id = scaleOptions.id;
const scaleType = valueOrDefault(scaleOptions.type, item.dtype);
}
});
// clear up discarded scales
- helpers.each(updated, (hasUpdated, id) => {
+ each(updated, (hasUpdated, id) => {
if (!hasUpdated) {
delete scales[id];
}
*/
_resetElements() {
const me = this;
- helpers.each(me.data.datasets, (dataset, datasetIndex) => {
+ each(me.data.datasets, (dataset, datasetIndex) => {
me.getDatasetMeta(datasetIndex).controller.reset();
}, me);
}
// Can only reset the new controllers after the scales have been updated
if (me.options.animation) {
- helpers.each(newControllers, (controller) => {
+ each(newControllers, (controller) => {
controller.reset();
});
}
layouts.update(me, me.width, me.height);
me._layers = [];
- helpers.each(me.boxes, (box) => {
+ each(me.boxes, (box) => {
// configure is called twice, once in core.scale.update and once here.
// Here the boxes are fully updated and at their final positions.
if (box.configure) {
}
const onComplete = function() {
plugins.notify(me, 'afterRender');
- helpers.callback(animationOptions && animationOptions.onComplete, [], me);
+ callCallback(animationOptions && animationOptions.onComplete, [], me);
};
if (Animator.has(me)) {
return;
}
- helpers.canvas.clipArea(ctx, {
+ clipArea(ctx, {
left: clip.left === false ? 0 : area.left - clip.left,
right: clip.right === false ? me.width : area.right + clip.right,
top: clip.top === false ? 0 : area.top - clip.top,
meta.controller.draw();
- helpers.canvas.unclipArea(ctx);
+ unclipArea(ctx);
plugins.notify(me, 'afterDatasetDraw', [args]);
}
if (canvas) {
me.unbindEvents();
- helpers.canvas.clear(me);
+ canvasClear(me);
me.platform.releaseContext(me.ctx);
me.canvas = null;
me.ctx = null;
me._eventHandler(e);
};
- helpers.each(me.options.events, (type) => _add(type, listener));
+ each(me.options.events, (type) => _add(type, listener));
if (me.options.responsive) {
listener = (width, height) => {
}
delete me._listeners;
- helpers.each(listeners, (listener, type) => {
+ each(listeners, (listener, type) => {
me.platform.removeEventListener(me, type, listener);
});
}
// Invoke onHover hook
// Need to call with native event here to not break backwards compatibility
- helpers.callback(options.onHover || options.hover.onHover, [e.native, me.active], me);
+ callCallback(options.onHover || options.hover.onHover, [e.native, me.active], me);
if (e.type === 'mouseup' || e.type === 'click') {
- if (options.onClick && helpers.canvas._isPointInArea(e, me.chartArea)) {
+ if (options.onClick && _isPointInArea(e, me.chartArea)) {
// Use e.native here for backwards compatibility
options.onClick.call(me, e.native, me.active);
}
}
- changed = !helpers._elementsEqual(me.active, me.lastActive);
+ changed = !_elementsEqual(me.active, me.lastActive);
if (changed || replay) {
me._updateHoverStyles();
}
-import helpers from '../helpers/index';
import Animations from './core.animations';
+import {isObject, inherits, merge, _merger, isArray, valueOrDefault, mergeIf, arrayEquals} from '../helpers/helpers.core';
+import {resolve} from '../helpers/helpers.options';
+import {getHoverColor} from '../helpers/helpers.color';
+import {sign} from '../helpers/helpers.math';
/**
* @typedef { import("./core.controller").default } Chart
* @typedef { import("./core.scale").default } Scale
*/
-const resolve = helpers.options.resolve;
-
const arrayEvents = ['push', 'pop', 'shift', 'splice', 'unshift'];
/**
function toClip(value) {
let t, r, b, l;
- if (helpers.isObject(value)) {
+ if (isObject(value)) {
t = value.top;
r = value.right;
b = value.bottom;
break;
}
otherValue = stack.values[datasetIndex];
- if (!isNaN(otherValue) && (value === 0 || helpers.math.sign(value) === helpers.math.sign(otherValue))) {
+ if (!isNaN(otherValue) && (value === 0 || sign(value) === sign(otherValue))) {
value += otherValue;
}
}
export default class DatasetController {
- static extend = helpers.inherits;
+ static extend = inherits;
/**
* @param {Chart} chart
// real-time charts), we need to monitor these data modifications and synchronize
// the internal meta data accordingly.
- if (helpers.isObject(data)) {
+ if (isObject(data)) {
// Object data is currently monitored for replacement only
if (me._objectData === data) {
return false;
me._data = convertObjectDataToArray(data);
me._objectData = data;
} else {
- if (me._data === data && !me._dataModified && helpers.arrayEquals(data, me._dataCopy)) {
+ if (me._data === data && !me._dataModified && arrayEquals(data, me._dataCopy)) {
return false;
}
*/
configure() {
const me = this;
- me._config = helpers.merge({}, [
+ me._config = merge({}, [
me.chart.options[me._type].datasets,
me.getDataset(),
], {
merger(key, target, source) {
if (key !== 'data') {
- helpers._merger(key, target, source);
+ _merger(key, target, source);
}
}
});
meta._parsed = data;
meta._sorted = true;
} else {
- if (helpers.isArray(data[start])) {
+ if (isArray(data[start])) {
parsed = me.parseArrayData(meta, data, start, count);
- } else if (helpers.isObject(data[start])) {
+ } else if (isObject(data[start])) {
parsed = me.parseObjectData(meta, data, start, count);
} else {
parsed = me.parsePrimitiveData(meta, data, start, count);
me._cachedAnimations = {};
me._cachedDataOpts = {};
me.update(mode);
- meta._clip = toClip(helpers.valueOrDefault(me._config.clip, defaultClip(meta.xScale, meta.yScale, me.getMaxOverflow())));
+ meta._clip = toClip(valueOrDefault(me._config.clip, defaultClip(meta.xScale, meta.yScale, me.getMaxOverflow())));
me._cacheScaleStackStatus();
}
*/
_addAutomaticHoverColors(index, options) {
const me = this;
- const getHoverColor = helpers.getHoverColor;
const normalOptions = me.getStyle(index);
const missingColors = Object.keys(normalOptions).filter(key => key.indexOf('Color') !== -1 && !(key in options));
let i = missingColors.length - 1;
const info = {cacheable: !active};
let keys, i, ilen, key, value, readKey;
- if (helpers.isArray(elementOptions)) {
+ if (isArray(elementOptions)) {
for (i = 0, ilen = elementOptions.length; i < ilen; ++i) {
key = elementOptions[i];
readKey = active ? 'hover' + key.charAt(0).toUpperCase() + key.slice(1) : key;
const context = me._getContext(index, active);
const datasetAnim = resolve([me._config.animation], context, index, info);
const chartAnim = resolve([chart.options.animation], context, index, info);
- let config = helpers.mergeIf({}, [datasetAnim, chartAnim]);
+ let config = mergeIf({}, [datasetAnim, chartAnim]);
if (config[mode]) {
config = Object.assign({}, config, config[mode]);
-import helpers from '../helpers/index';
import {_isPointInArea} from '../helpers/helpers.canvas';
import {_lookupByKey, _rlookupByKey} from '../helpers/helpers.collection';
+import {getRelativePosition as helpersGetRelativePosition} from '../helpers/helpers.dom';
/**
* @typedef { import("./core.controller").default } Chart
};
}
- return helpers.dom.getRelativePosition(e, chart);
+ return helpersGetRelativePosition(e, chart);
}
/**
--- /dev/null
+export function fontString(pixelSize, fontStyle, fontFamily) {
+ return fontStyle + ' ' + pixelSize + 'px ' + fontFamily;
+}
+
+/**
+* Request animation polyfill
+*/
+export const requestAnimFrame = (function() {
+ if (typeof window === 'undefined') {
+ return function(callback) {
+ return callback();
+ };
+ }
+ return window.requestAnimationFrame;
+}());
import * as rtl from './helpers.rtl';
import {color, getHoverColor} from './helpers.color';
+import {requestAnimFrame, fontString} from './helpers.extras';
export default {
...coreHelpers,
math,
rtl,
- /**
- * Request animation polyfill
- */
- requestAnimFrame: (function() {
- if (typeof window === 'undefined') {
- return function(callback) {
- return callback();
- };
- }
- return window.requestAnimationFrame;
- }()),
+ requestAnimFrame,
// -- Canvas methods
- fontString(pixelSize, fontStyle, fontFamily) {
- return fontStyle + ' ' + pixelSize + 'px ' + fontFamily;
- },
+ fontString,
color,
getHoverColor
};
* Chart.Platform implementation for targeting a web browser
*/
-import helpers from '../helpers/index';
import BasePlatform from './platform.base';
-import {_getParentNode} from '../helpers/helpers.dom';
+import {_getParentNode, getStyle, getRelativePosition} from '../helpers/helpers.dom';
+import {requestAnimFrame} from '../helpers/helpers.extras';
+import {isNullOrUndef} from '../helpers/helpers.core';
/**
* @typedef { import("../core/core.controller").default } Chart
* @returns {number=} Size in pixels or undefined if unknown.
*/
function readUsedSize(element, property) {
- const value = helpers.dom.getStyle(element, property);
+ const value = getStyle(element, property);
const matches = value && value.match(/^(\d+)(\.\d+)?px$/);
return matches ? +matches[1] : undefined;
}
function fromNativeEvent(event, chart) {
const type = EVENT_TYPES[event.type] || event.type;
- const pos = helpers.dom.getRelativePosition(event, chart);
+ const pos = getRelativePosition(event, chart);
return createEvent(type, chart, pos.x, pos.y, event);
}
if (!ticking) {
ticking = true;
- helpers.requestAnimFrame.call(window, () => {
+ requestAnimFrame.call(window, () => {
ticking = false;
fn.apply(thisArg, args);
});
const initial = canvas[EXPANDO_KEY].initial;
['height', 'width'].forEach((prop) => {
const value = initial[prop];
- if (helpers.isNullOrUndef(value)) {
+ if (isNullOrUndef(value)) {
canvas.removeAttribute(prop);
} else {
canvas.setAttribute(prop, value);
import defaults from '../core/core.defaults';
import Element from '../core/core.element';
-import helpers from '../helpers/index';
import layouts from '../core/core.layouts';
+import {isArray, valueOrDefault, mergeIf} from '../helpers/helpers.core';
+import {toPadding, _parseFont} from '../helpers/helpers.options';
defaults.set('title', {
align: 'center',
return;
}
- const lineCount = helpers.isArray(opts.text) ? opts.text.length : 1;
- me._padding = helpers.options.toPadding(opts.padding);
- const textSize = lineCount * helpers.options._parseFont(opts).lineHeight + me._padding.height;
+ const lineCount = isArray(opts.text) ? opts.text.length : 1;
+ me._padding = toPadding(opts.padding);
+ const textSize = lineCount * _parseFont(opts).lineHeight + me._padding.height;
me.width = minSize.width = isHorizontal ? me.maxWidth : textSize;
me.height = minSize.height = isHorizontal ? textSize : me.maxHeight;
}
return;
}
- const fontOpts = helpers.options._parseFont(opts);
+ const fontOpts = _parseFont(opts);
const lineHeight = fontOpts.lineHeight;
const offset = lineHeight / 2 + me._padding.top;
let rotation = 0;
ctx.save();
- ctx.fillStyle = helpers.valueOrDefault(opts.fontColor, defaults.fontColor); // render in correct colour
+ ctx.fillStyle = valueOrDefault(opts.fontColor, defaults.fontColor); // render in correct colour
ctx.font = fontOpts.string;
ctx.translate(titleX, titleY);
ctx.textBaseline = 'middle';
const text = opts.text;
- if (helpers.isArray(text)) {
+ if (isArray(text)) {
let y = 0;
for (let i = 0; i < text.length; ++i) {
ctx.fillText(text[i], 0, y, maxWidth);
const titleBlock = chart.titleBlock;
if (titleOpts) {
- helpers.mergeIf(titleOpts, defaults.title);
+ mergeIf(titleOpts, defaults.title);
if (titleBlock) {
layouts.configure(chart, titleBlock, titleOpts);
import defaults from '../core/core.defaults';
import Element from '../core/core.element';
import plugins from '../core/core.plugins';
-import helpers from '../helpers/index';
+import {valueOrDefault, each, noop, isNullOrUndef, isArray, _elementsEqual} from '../helpers/helpers.core';
+import {getRtlAdapter, overrideTextDirection, restoreTextDirection} from '../helpers/helpers.rtl';
+import {fontString} from '../helpers/helpers.extras';
+import {distanceBetweenPoints} from '../helpers/helpers.math';
/**
* @typedef { import("../platform/platform.base").IEvent } IEvent
*/
-const valueOrDefault = helpers.valueOrDefault;
-const getRtlHelper = helpers.rtl.getRtlAdapter;
-
defaults.set('tooltips', {
enabled: true,
custom: null,
},
callbacks: {
// Args are: (tooltipItems, data)
- beforeTitle: helpers.noop,
+ beforeTitle: noop,
title(tooltipItems, data) {
let title = '';
const labels = data.labels;
return title;
},
- afterTitle: helpers.noop,
+ afterTitle: noop,
// Args are: (tooltipItems, data)
- beforeBody: helpers.noop,
+ beforeBody: noop,
// Args are: (tooltipItem, data)
- beforeLabel: helpers.noop,
+ beforeLabel: noop,
label(tooltipItem, data) {
let label = data.datasets[tooltipItem.datasetIndex].label || '';
label += ': ';
}
const value = tooltipItem.value;
- if (!helpers.isNullOrUndef(value)) {
+ if (!isNullOrUndef(value)) {
label += value;
}
return label;
labelTextColor() {
return this.options.bodyFontColor;
},
- afterLabel: helpers.noop,
+ afterLabel: noop,
// Args are: (tooltipItems, data)
- afterBody: helpers.noop,
+ afterBody: noop,
// Args are: (tooltipItems, data)
- beforeFooter: helpers.noop,
- footer: helpers.noop,
- afterFooter: helpers.noop
+ beforeFooter: noop,
+ footer: noop,
+ afterFooter: noop
}
});
const el = items[i].element;
if (el && el.hasValue()) {
const center = el.getCenterPoint();
- const d = helpers.math.distanceBetweenPoints(eventPosition, center);
+ const d = distanceBetweenPoints(eventPosition, center);
if (d < minDistance) {
minDistance = d;
// Helper to push or concat based on if the 2nd parameter is an array or not
function pushOrConcat(base, toPush) {
if (toPush) {
- if (helpers.isArray(toPush)) {
+ if (isArray(toPush)) {
// base = base.concat(toPush);
Array.prototype.push.apply(base, toPush);
} else {
ctx.save();
- ctx.font = helpers.fontString(titleFontSize, options.titleFontStyle, options.titleFontFamily);
- helpers.each(tooltip.title, maxLineWidth);
+ ctx.font = fontString(titleFontSize, options.titleFontStyle, options.titleFontFamily);
+ each(tooltip.title, maxLineWidth);
// Body width
- ctx.font = helpers.fontString(bodyFontSize, options.bodyFontStyle, options.bodyFontFamily);
- helpers.each(tooltip.beforeBody.concat(tooltip.afterBody), maxLineWidth);
+ ctx.font = fontString(bodyFontSize, options.bodyFontStyle, options.bodyFontFamily);
+ each(tooltip.beforeBody.concat(tooltip.afterBody), maxLineWidth);
// Body lines may include some extra width due to the color box
widthPadding = options.displayColors ? (boxWidth + 2) : 0;
- helpers.each(body, (bodyItem) => {
- helpers.each(bodyItem.before, maxLineWidth);
- helpers.each(bodyItem.lines, maxLineWidth);
- helpers.each(bodyItem.after, maxLineWidth);
+ each(body, (bodyItem) => {
+ each(bodyItem.before, maxLineWidth);
+ each(bodyItem.lines, maxLineWidth);
+ each(bodyItem.after, maxLineWidth);
});
// Reset back to 0
widthPadding = 0;
// Footer width
- ctx.font = helpers.fontString(footerFontSize, options.footerFontStyle, options.footerFontFamily);
- helpers.each(tooltip.footer, maxLineWidth);
+ ctx.font = fontString(footerFontSize, options.footerFontStyle, options.footerFontFamily);
+ each(tooltip.footer, maxLineWidth);
ctx.restore();
const callbacks = me.options.callbacks;
const bodyItems = [];
- helpers.each(tooltipItems, (tooltipItem) => {
+ each(tooltipItems, (tooltipItem) => {
const bodyItem = {
before: [],
lines: [],
}
// Determine colors for boxes
- helpers.each(tooltipItems, (tooltipItem) => {
+ each(tooltipItems, (tooltipItem) => {
labelColors.push(options.callbacks.labelColor.call(me, tooltipItem, me._chart));
labelTextColors.push(options.callbacks.labelTextColor.call(me, tooltipItem, me._chart));
});
let titleFontSize, titleSpacing, i;
if (length) {
- const rtlHelper = getRtlHelper(options.rtl, me.x, me.width);
+ const rtlHelper = getRtlAdapter(options.rtl, me.x, me.width);
pt.x = getAlignedX(me, options.titleAlign);
titleSpacing = options.titleSpacing;
ctx.fillStyle = options.titleFontColor;
- ctx.font = helpers.fontString(titleFontSize, options.titleFontStyle, options.titleFontFamily);
+ ctx.font = fontString(titleFontSize, options.titleFontStyle, options.titleFontFamily);
for (i = 0; i < length; ++i) {
ctx.fillText(title[i], rtlHelper.x(pt.x), pt.y + titleFontSize / 2);
let bodyLineHeight = bodyFontSize;
let xLinePadding = 0;
- const rtlHelper = getRtlHelper(options.rtl, me.x, me.width);
+ const rtlHelper = getRtlAdapter(options.rtl, me.x, me.width);
const fillLineOfText = function(line) {
ctx.fillText(line, rtlHelper.x(pt.x + xLinePadding), pt.y + bodyLineHeight / 2);
ctx.textAlign = bodyAlign;
ctx.textBaseline = 'middle';
- ctx.font = helpers.fontString(bodyFontSize, options.bodyFontStyle, options.bodyFontFamily);
+ ctx.font = fontString(bodyFontSize, options.bodyFontStyle, options.bodyFontFamily);
pt.x = getAlignedX(me, bodyAlignForCalculation);
// Before body lines
ctx.fillStyle = options.bodyFontColor;
- helpers.each(me.beforeBody, fillLineOfText);
+ each(me.beforeBody, fillLineOfText);
xLinePadding = displayColors && bodyAlignForCalculation !== 'right'
? bodyAlign === 'center' ? (boxWidth / 2 + 1) : (boxWidth + 2)
textColor = me.labelTextColors[i];
ctx.fillStyle = textColor;
- helpers.each(bodyItem.before, fillLineOfText);
+ each(bodyItem.before, fillLineOfText);
lines = bodyItem.lines;
// Draw Legend-like boxes if needed
bodyLineHeight = bodyFontSize;
}
- helpers.each(bodyItem.after, fillLineOfText);
+ each(bodyItem.after, fillLineOfText);
}
// Reset back to 0 for after body
bodyLineHeight = bodyFontSize;
// After body lines
- helpers.each(me.afterBody, fillLineOfText);
+ each(me.afterBody, fillLineOfText);
pt.y -= bodySpacing; // Remove last body spacing
}
let footerFontSize, i;
if (length) {
- const rtlHelper = getRtlHelper(options.rtl, me.x, me.width);
+ const rtlHelper = getRtlAdapter(options.rtl, me.x, me.width);
pt.x = getAlignedX(me, options.footerAlign);
pt.y += options.footerMarginTop;
footerFontSize = options.footerFontSize;
ctx.fillStyle = options.footerFontColor;
- ctx.font = helpers.fontString(footerFontSize, options.footerFontStyle, options.footerFontFamily);
+ ctx.font = fontString(footerFontSize, options.footerFontStyle, options.footerFontFamily);
for (i = 0; i < length; ++i) {
ctx.fillText(footer[i], rtlHelper.x(pt.x), pt.y + footerFontSize / 2);
// Draw Background
me.drawBackground(pt, ctx, tooltipSize);
- helpers.rtl.overrideTextDirection(ctx, options.textDirection);
+ overrideTextDirection(ctx, options.textDirection);
pt.y += options.yPadding;
// Footer
me.drawFooter(pt, ctx);
- helpers.rtl.restoreTextDirection(ctx, options.textDirection);
+ restoreTextDirection(ctx, options.textDirection);
ctx.restore();
}
}
// Remember Last Actives
- changed = replay || !helpers._elementsEqual(active, lastActive);
+ changed = replay || !_elementsEqual(active, lastActive);
// Only handle target event on tooltip change
if (changed) {
import defaults from '../core/core.defaults';
-import helpers from '../helpers/index';
import {_longestText} from '../helpers/helpers.canvas';
import {isNumber, toDegrees, toRadians, _normalizeAngle} from '../helpers/helpers.math';
import LinearScaleBase from './scale.linearbase';
import Ticks from '../core/core.ticks';
+import {valueOrDefault, isArray, valueAtIndexOrDefault, isFinite, callback as callCallback, isNullOrUndef} from '../helpers/helpers.core';
+import {_parseFont, resolve} from '../helpers/helpers.options';
-const valueOrDefault = helpers.valueOrDefault;
-const valueAtIndexOrDefault = helpers.valueAtIndexOrDefault;
-const resolve = helpers.options.resolve;
const defaultConfig = {
display: true,
}
function measureLabelSize(ctx, lineHeight, label) {
- if (helpers.isArray(label)) {
+ if (isArray(label)) {
return {
w: _longestText(ctx, ctx.font, label),
h: label.length * lineHeight
//
// https://dl.dropboxusercontent.com/u/34601363/yeahscience.gif
- const plFont = helpers.options._parseFont(scale.options.pointLabels);
+ const plFont = _parseFont(scale.options.pointLabels);
// Get maximum radius of the polygon. Either half the height (minus the text width) or half the width.
// Use this to calculate the offset + change. - Make sure L/R protrusion is at least 0 to stop issues with centre points
let y = position.y + lineHeight / 2;
let i, ilen;
- if (helpers.isArray(text)) {
+ if (isArray(text)) {
for (i = 0, ilen = text.length; i < ilen; ++i) {
ctx.fillText(text[i], position.x, y);
y += lineHeight;
const pointLabelOpts = opts.pointLabels;
const tickBackdropHeight = getTickBackdropHeight(opts);
const outerDistance = scale.getDistanceFromCenterForValue(opts.ticks.reverse ? scale.min : scale.max);
- const plFont = helpers.options._parseFont(pointLabelOpts);
+ const plFont = _parseFont(pointLabelOpts);
ctx.save();
const min = minmax.min;
const max = minmax.max;
- me.min = helpers.isFinite(min) && !isNaN(min) ? min : 0;
- me.max = helpers.isFinite(max) && !isNaN(max) ? max : 0;
+ me.min = isFinite(min) && !isNaN(min) ? min : 0;
+ me.max = isFinite(max) && !isNaN(max) ? max : 0;
// Common base implementation to handle min, max, beginAtZero
me.handleTickRangeOptions();
// Point labels
me.pointLabels = me.chart.data.labels.map((value, index) => {
- const label = helpers.callback(me.options.pointLabels.callback, [value, index], me);
+ const label = callCallback(me.options.pointLabels.callback, [value, index], me);
return label || label === 0 ? label : '';
});
}
getDistanceFromCenterForValue(value) {
const me = this;
- if (helpers.isNullOrUndef(value)) {
+ if (isNullOrUndef(value)) {
return NaN;
}
}
const startAngle = me.getIndexAngle(0);
- const tickFont = helpers.options._parseFont(tickOpts);
+ const tickFont = _parseFont(tickOpts);
const tickFontColor = valueOrDefault(tickOpts.fontColor, defaults.fontColor);
let offset, width;
projects / thirdparty / Chart.js.git / commitdiff
