echarts 4.0.1 → 4.1.0

package/src/layout/barGrid.js

@@ -1,7 +1,31 @@
+/*
+* 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 * as zrUtil from 'zrender/src/core/util';
 import {parsePercent} from '../util/number';
+import {isDimensionStacked} from '../data/helper/dataStackHelper';
+import createRenderPlanner from '../chart/helper/createRenderPlanner';
 
 var STACK_PREFIX = '__ec_stack_';
+var LARGE_BAR_MIN_WIDTH = 0.5;
+
+var LargeArr = typeof Float32Array !== 'undefined' ? Float32Array : Array;
 
 function getSeriesStackId(seriesModel) {
     return seriesModel.get('stack') || STACK_PREFIX + seriesModel.seriesIndex;
@@ -21,7 +45,7 @@ function getAxisKey(axis) {
  * @param {number} [opt.barCategoryGap]
  * @return {Object} {width, offset, offsetCenter} If axis.type is not 'category', return undefined.
  */
-export function getLayoutOnAxis(opt, api) {
+export function getLayoutOnAxis(opt) {
     var params = [];
     var baseAxis = opt.axis;
     var axisKey = 'axis0';
@@ -38,7 +62,7 @@ export function getLayoutOnAxis(opt, api) {
             stackId: STACK_PREFIX + i
         }, opt));
     }
-    var widthAndOffsets = doCalBarWidthAndOffset(params, api);
+    var widthAndOffsets = doCalBarWidthAndOffset(params);
 
     var result = [];
     for (var i = 0; i < opt.count; i++) {
@@ -50,8 +74,20 @@ export function getLayoutOnAxis(opt, api) {
     return result;
 }
 
-export function calBarWidthAndOffset(barSeries, api) {
-    var seriesInfoList = zrUtil.map(barSeries, function (seriesModel) {
+export function prepareLayoutBarSeries(seriesType, ecModel) {
+    var seriesModels = [];
+    ecModel.eachSeriesByType(seriesType, function (seriesModel) {
+        // Check series coordinate, do layout for cartesian2d only
+        if (isOnCartesian(seriesModel) && !isInLargeMode(seriesModel)) {
+            seriesModels.push(seriesModel);
+        }
+    });
+    return seriesModels;
+}
+
+export function makeColumnLayout(barSeries) {
+    var seriesInfoList = [];
+    zrUtil.each(barSeries, function (seriesModel) {
         var data = seriesModel.getData();
         var cartesian = seriesModel.coordinateSystem;
         var baseAxis = cartesian.getBaseAxis();
@@ -69,7 +105,7 @@ export function calBarWidthAndOffset(barSeries, api) {
         var barGap = seriesModel.get('barGap');
         var barCategoryGap = seriesModel.get('barCategoryGap');
 
-        return {
+        seriesInfoList.push({
             bandWidth: bandWidth,
             barWidth: barWidth,
             barMaxWidth: barMaxWidth,
@@ -77,13 +113,13 @@ export function calBarWidthAndOffset(barSeries, api) {
             barCategoryGap: barCategoryGap,
             axisKey: getAxisKey(baseAxis),
             stackId: getSeriesStackId(seriesModel)
-        };
+        });
     });
 
-    return doCalBarWidthAndOffset(seriesInfoList, api);
+    return doCalBarWidthAndOffset(seriesInfoList);
 }
 
-function doCalBarWidthAndOffset(seriesInfoList, api) {
+function doCalBarWidthAndOffset(seriesInfoList) {
     // Columns info on each category axis. Key is cartesian name
     var columnsMap = {};
 
@@ -196,33 +232,35 @@ function doCalBarWidthAndOffset(seriesInfoList, api) {
     return result;
 }
 
+/**
+ * @param {Object} barWidthAndOffset The result of makeColumnLayout
+ * @param {module:echarts/coord/Axis} axis
+ * @param {module:echarts/model/Series} [seriesModel] If not provided, return all.
+ * @return {Object} {stackId: {offset, width}} or {offset, width} if seriesModel provided.
+ */
+export function retrieveColumnLayout(barWidthAndOffset, axis, seriesModel) {
+    if (barWidthAndOffset && axis) {
+        var result = barWidthAndOffset[getAxisKey(axis)];
+        if (result != null && seriesModel != null) {
+            result = result[getSeriesStackId(seriesModel)];
+        }
+        return result;
+    }
+}
+
 /**
  * @param {string} seriesType
  * @param {module:echarts/model/Global} ecModel
- * @param {module:echarts/ExtensionAPI} api
  */
-export function layout(seriesType, ecModel, api) {
-
-    var barWidthAndOffset = calBarWidthAndOffset(
-        zrUtil.filter(
-            ecModel.getSeriesByType(seriesType),
-            function (seriesModel) {
-                return !ecModel.isSeriesFiltered(seriesModel)
-                    && seriesModel.coordinateSystem
-                    && seriesModel.coordinateSystem.type === 'cartesian2d';
-            }
-        )
-    );
+export function layout(seriesType, ecModel) {
+
+    var seriesModels = prepareLayoutBarSeries(seriesType, ecModel);
+    var barWidthAndOffset = makeColumnLayout(seriesModels);
 
     var lastStackCoords = {};
     var lastStackCoordsOrigin = {};
 
-    ecModel.eachSeriesByType(seriesType, function (seriesModel) {
-
-        // Check series coordinate, do layout for cartesian2d only
-        if (seriesModel.coordinateSystem.type !== 'cartesian2d') {
-            return;
-        }
+    zrUtil.each(seriesModels, function (seriesModel) {
 
         var data = seriesModel.getData();
         var cartesian = seriesModel.coordinateSystem;
@@ -236,18 +274,6 @@ export function layout(seriesType, ecModel, api) {
 
         var barMinHeight = seriesModel.get('barMinHeight') || 0;
 
-        var valueAxisStart = baseAxis.onZero
-            ? valueAxis.toGlobalCoord(valueAxis.dataToCoord(0))
-            : valueAxis.getGlobalExtent()[0];
-
-        var coordDims = [
-            data.mapDimension('x'),
-            data.mapDimension('y')
-        ];
-        var coords = data.mapArray(coordDims, function (x, y) {
-            return cartesian.dataToPoint([x, y]);
-        }, true);
-
         lastStackCoords[stackId] = lastStackCoords[stackId] || [];
         lastStackCoordsOrigin[stackId] = lastStackCoordsOrigin[stackId] || []; // Fix #4243
 
@@ -256,54 +282,67 @@ export function layout(seriesType, ecModel, api) {
             size: columnWidth
         });
 
-        data.each(data.mapDimension(valueAxis.dim), function (value, idx) {
+        var valueDim = data.mapDimension(valueAxis.dim);
+        var baseDim = data.mapDimension(baseAxis.dim);
+        var stacked = isDimensionStacked(data, valueDim /*, baseDim*/);
+        var isValueAxisH = valueAxis.isHorizontal();
+
+        var valueAxisStart = getValueAxisStart(baseAxis, valueAxis, stacked);
+
+        for (var idx = 0, len = data.count(); idx < len; idx++) {
+            var value = data.get(valueDim, idx);
+            var baseValue = data.get(baseDim, idx);
+
             if (isNaN(value)) {
-                return;
+                continue;
             }
 
-            if (!lastStackCoords[stackId][idx]) {
-                lastStackCoords[stackId][idx] = {
-                    p: valueAxisStart, // Positive stack
-                    n: valueAxisStart  // Negative stack
-                };
-                lastStackCoordsOrigin[stackId][idx] = {
-                    p: valueAxisStart, // Positive stack
-                    n: valueAxisStart  // Negative stack
-                };
-            }
             var sign = value >= 0 ? 'p' : 'n';
-            var coord = coords[idx];
-            var lastCoord = lastStackCoords[stackId][idx][sign];
-            var lastCoordOrigin = lastStackCoordsOrigin[stackId][idx][sign];
+            var baseCoord = valueAxisStart;
+
+            // Because of the barMinHeight, we can not use the value in
+            // stackResultDimension directly.
+            if (stacked) {
+                // Only ordinal axis can be stacked.
+                if (!lastStackCoords[stackId][baseValue]) {
+                    lastStackCoords[stackId][baseValue] = {
+                        p: valueAxisStart, // Positive stack
+                        n: valueAxisStart  // Negative stack
+                    };
+                }
+                // Should also consider #4243
+                baseCoord = lastStackCoords[stackId][baseValue][sign];
+            }
+
             var x;
             var y;
             var width;
             var height;
 
-            if (valueAxis.isHorizontal()) {
-                x = lastCoord;
+            if (isValueAxisH) {
+                var coord = cartesian.dataToPoint([value, baseValue]);
+                x = baseCoord;
                 y = coord[1] + columnOffset;
-                width = coord[0] - lastCoordOrigin;
+                width = coord[0] - valueAxisStart;
                 height = columnWidth;
 
-                lastStackCoordsOrigin[stackId][idx][sign] += width;
                 if (Math.abs(width) < barMinHeight) {
                     width = (width < 0 ? -1 : 1) * barMinHeight;
                 }
-                lastStackCoords[stackId][idx][sign] += width;
+                stacked && (lastStackCoords[stackId][baseValue][sign] += width);
             }
             else {
+                var coord = cartesian.dataToPoint([baseValue, value]);
                 x = coord[0] + columnOffset;
-                y = lastCoord;
+                y = baseCoord;
                 width = columnWidth;
-                height = coord[1] - lastCoordOrigin;
+                height = coord[1] - valueAxisStart;
 
-                lastStackCoordsOrigin[stackId][idx][sign] += height;
                 if (Math.abs(height) < barMinHeight) {
                     // Include zero to has a positive bar
                     height = (height <= 0 ? -1 : 1) * barMinHeight;
                 }
-                lastStackCoords[stackId][idx][sign] += height;
+                stacked && (lastStackCoords[stackId][baseValue][sign] += height);
             }
 
             data.setItemLayout(idx, {
@@ -312,9 +351,80 @@ export function layout(seriesType, ecModel, api) {
                 width: width,
                 height: height
             });
-        }, true);
+        }
 
     }, this);
 }
 
+// TODO: Do not support stack in large mode yet.
+export var largeLayout = {
+
+    seriesType: 'bar',
+
+    plan: createRenderPlanner(),
+
+    reset: function (seriesModel) {
+        if (!isOnCartesian(seriesModel) || !isInLargeMode(seriesModel)) {
+            return;
+        }
+
+        var data = seriesModel.getData();
+        var cartesian = seriesModel.coordinateSystem;
+        var baseAxis = cartesian.getBaseAxis();
+        var valueAxis = cartesian.getOtherAxis(baseAxis);
+        var valueDim = data.mapDimension(valueAxis.dim);
+        var baseDim = data.mapDimension(baseAxis.dim);
+        var valueAxisHorizontal = valueAxis.isHorizontal();
+        var valueDimIdx = valueAxisHorizontal ? 0 : 1;
+
+        var barWidth = retrieveColumnLayout(
+            makeColumnLayout([seriesModel]), baseAxis, seriesModel
+        ).width;
+        if (!(barWidth > LARGE_BAR_MIN_WIDTH)) { // jshint ignore:line
+            barWidth = LARGE_BAR_MIN_WIDTH;
+        }
 
+        return {progress: progress};
+
+        function progress(params, data) {
+            var largePoints = new LargeArr(params.count * 2);
+            var dataIndex;
+            var coord = [];
+            var valuePair = [];
+            var offset = 0;
+
+            while ((dataIndex = params.next()) != null) {
+                valuePair[valueDimIdx] = data.get(valueDim, dataIndex);
+                valuePair[1 - valueDimIdx] = data.get(baseDim, dataIndex);
+
+                coord = cartesian.dataToPoint(valuePair, null, coord);
+                largePoints[offset++] = coord[0];
+                largePoints[offset++] = coord[1];
+            }
+
+            data.setLayout({
+                largePoints: largePoints,
+                barWidth: barWidth,
+                valueAxisStart: getValueAxisStart(baseAxis, valueAxis, false),
+                valueAxisHorizontal: valueAxisHorizontal
+            });
+        }
+    }
+};
+
+function isOnCartesian(seriesModel) {
+    return seriesModel.coordinateSystem && seriesModel.coordinateSystem.type === 'cartesian2d';
+}
+
+function isInLargeMode(seriesModel) {
+    return seriesModel.pipelineContext && seriesModel.pipelineContext.large;
+}
+
+function getValueAxisStart(baseAxis, valueAxis, stacked) {
+    return (
+        zrUtil.indexOf(baseAxis.getAxesOnZeroOf(), valueAxis) >= 0
+        || stacked
+    )
+    ? valueAxis.toGlobalCoord(valueAxis.dataToCoord(0))
+    : valueAxis.getGlobalExtent()[0];
+}

package/src/layout/barPolar.js

@@ -1,5 +1,25 @@
+/*
+* 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 * as zrUtil from 'zrender/src/core/util';
 import {parsePercent} from '../util/number';
+import {isDimensionStacked} from '../data/helper/dataStackHelper';
 
 function getSeriesStackId(seriesModel) {
     return seriesModel.get('stack')
@@ -21,7 +41,6 @@ function barLayoutPolar(seriesType, ecModel, api) {
     var height = api.getHeight();
 
     var lastStackCoords = {};
-    var lastStackCoordsOrigin = {};
 
     var barWidthAndOffset = calRadialBar(
         zrUtil.filter(
@@ -42,7 +61,6 @@ function barLayoutPolar(seriesType, ecModel, api) {
 
         var data = seriesModel.getData();
         var polar = seriesModel.coordinateSystem;
-        var angleAxis = polar.getAngleAxis();
         var baseAxis = polar.getBaseAxis();
 
         var stackId = getSeriesStackId(seriesModel);
@@ -59,91 +77,86 @@ function barLayoutPolar(seriesType, ecModel, api) {
         var barMinHeight = seriesModel.get('barMinHeight') || 0;
         var barMinAngle = seriesModel.get('barMinAngle') || 0;
 
-        var valueAxisStart = valueAxis.getExtent()[0];
-        var valueMax = valueAxis.model.get('max');
-        var valueMin = valueAxis.model.get('min');
+        lastStackCoords[stackId] = lastStackCoords[stackId] || [];
 
-        var coordDims = [
-            data.mapDimension('radius'),
-            data.mapDimension('angle')
-        ];
-        var coords = data.mapArray(coordDims, function (radius, angle) {
-            return polar.dataToPoint([radius, angle]);
-        }, true);
+        var valueDim = data.mapDimension(valueAxis.dim);
+        var baseDim = data.mapDimension(baseAxis.dim);
+        var stacked = isDimensionStacked(data, valueDim /*, baseDim*/);
 
-        lastStackCoords[stackId] = lastStackCoords[stackId] || [];
-        lastStackCoordsOrigin[stackId] = lastStackCoordsOrigin[stackId] || []; // Fix #4243
+        var valueAxisStart = valueAxis.getExtent()[0];
+
+        for (var idx = 0, len = data.count(); idx < len; idx++) {
+            var value = data.get(valueDim, idx);
+            var baseValue = data.get(baseDim, idx);
 
-        data.each(data.mapDimension(valueAxis.dim), function (value, idx) {
             if (isNaN(value)) {
-                return;
+                continue;
             }
 
-            if (!lastStackCoords[stackId][idx]) {
-                lastStackCoords[stackId][idx] = {
-                    p: valueAxisStart, // Positive stack
-                    n: valueAxisStart  // Negative stack
-                };
-                lastStackCoordsOrigin[stackId][idx] = {
-                    p: valueAxisStart, // Positive stack
-                    n: valueAxisStart  // Negative stack
-                };
-            }
             var sign = value >= 0 ? 'p' : 'n';
-            var coord = polar.pointToCoord(coords[idx]);
+            var baseCoord = valueAxisStart;
+
+            // Because of the barMinHeight, we can not use the value in
+            // stackResultDimension directly.
+            // Only ordinal axis can be stacked.
+            if (stacked) {
+                if (!lastStackCoords[stackId][baseValue]) {
+                    lastStackCoords[stackId][baseValue] = {
+                        p: valueAxisStart, // Positive stack
+                        n: valueAxisStart  // Negative stack
+                    };
+                }
+                // Should also consider #4243
+                baseCoord = lastStackCoords[stackId][baseValue][sign];
+            }
 
-            var lastCoordOrigin = lastStackCoordsOrigin[stackId][idx][sign];
             var r0;
             var r;
             var startAngle;
             var endAngle;
 
+            // radial sector
             if (valueAxis.dim === 'radius') {
-                // radial sector
-                r0 = lastCoordOrigin;
-                r = coord[0];
-                startAngle = (-coord[1] + columnOffset) * Math.PI / 180;
-                endAngle = startAngle + columnWidth * Math.PI / 180;
-
-                if (Math.abs(r) < barMinHeight) {
-                    r = r0 + (r < 0 ? -1 : 1) * barMinHeight;
+                var radiusSpan = valueAxis.dataToRadius(value) - valueAxisStart;
+                var angle = baseAxis.dataToAngle(baseValue);
+
+                if (Math.abs(radiusSpan) < barMinHeight) {
+                    radiusSpan = (radiusSpan < 0 ? -1 : 1) * barMinHeight;
                 }
 
-                lastStackCoordsOrigin[stackId][idx][sign] = r;
+                r0 = baseCoord;
+                r = baseCoord + radiusSpan;
+                startAngle = angle - columnOffset;
+                endAngle = startAngle - columnWidth;
+
+                stacked && (lastStackCoords[stackId][baseValue][sign] = r);
             }
+            // tangential sector
             else {
-                // tangential sector
-                r0 = coord[0] + columnOffset;
-                r = r0 + columnWidth;
-
-                // clamp data if min or max is defined for valueAxis
-                if (valueMax != null) {
-                    value = Math.min(value, valueMax);
-                }
-                if (valueMin != null) {
-                    value = Math.max(value, valueMin);
-                }
+                // angleAxis must be clamped.
+                var angleSpan = valueAxis.dataToAngle(value, true) - valueAxisStart;
+                var radius = baseAxis.dataToRadius(baseValue);
 
-                var angle = angleAxis.dataToAngle(value);
-                if (Math.abs(angle - lastCoordOrigin) < barMinAngle) {
-                    angle = lastCoordOrigin - (value < 0 ? -1 : 1)
-                        * barMinAngle;
+                if (Math.abs(angleSpan) < barMinAngle) {
+                    angleSpan = (angleSpan < 0 ? -1 : 1) * barMinAngle;
                 }
 
-                startAngle = -lastCoordOrigin * Math.PI / 180;
-                endAngle = -angle * Math.PI / 180;
+                r0 = radius + columnOffset;
+                r = r0 + columnWidth;
+                startAngle = baseCoord;
+                endAngle = baseCoord + angleSpan;
 
                 // if the previous stack is at the end of the ring,
                 // add a round to differentiate it from origin
-                var extent = angleAxis.getExtent();
-                var stackCoord = angle;
-                if (stackCoord === extent[0] && value > 0) {
-                    stackCoord = extent[1];
-                }
-                else if (stackCoord === extent[1] && value < 0) {
-                    stackCoord = extent[0];
-                }
-                lastStackCoordsOrigin[stackId][idx][sign] = stackCoord;
+                // var extent = angleAxis.getExtent();
+                // var stackCoord = angle;
+                // if (stackCoord === extent[0] && value > 0) {
+                //     stackCoord = extent[1];
+                // }
+                // else if (stackCoord === extent[1] && value < 0) {
+                //     stackCoord = extent[0];
+                // }
+                stacked && (lastStackCoords[stackId][baseValue][sign] = endAngle);
             }
 
             data.setItemLayout(idx, {
@@ -151,11 +164,13 @@ function barLayoutPolar(seriesType, ecModel, api) {
                 cy: cy,
                 r0: r0,
                 r: r,
-                startAngle: startAngle,
-                endAngle: endAngle
+                // Consider that positive angle is anti-clockwise,
+                // while positive radian of sector is clockwise
+                startAngle: -startAngle * Math.PI / 180,
+                endAngle: -endAngle * Math.PI / 180
             });
 
-        }, true);
+        }
 
     }, this);
 

package/src/layout/points.js

@@ -1,5 +1,25 @@
+/*
+* 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 {map} from 'zrender/src/core/util';
 import createRenderPlanner from '../chart/helper/createRenderPlanner';
+import {isDimensionStacked} from '../data/helper/dataStackHelper';
 
 export default function (seriesType) {
     return {
@@ -18,10 +38,18 @@ export default function (seriesType) {
             }
 
             var dims = map(coordSys.dimensions, function (dim) {
-                return data.getDimension(data.mapDimension(dim));
+                return data.mapDimension(dim);
             }).slice(0, 2);
             var dimLen = dims.length;
 
+            var stackResultDim = data.getCalculationInfo('stackResultDimension');
+            if (isDimensionStacked(data, dims[0] /*, dims[1]*/)) {
+                dims[0] = stackResultDim;
+            }
+            if (isDimensionStacked(data, dims[1] /*, dims[0]*/)) {
+                dims[1] = stackResultDim;
+            }
+
             function progress(params, data) {
                 var segCount = params.end - params.start;
                 var points = isLargeRender && new Float32Array(segCount * dimLen);
@@ -30,12 +58,12 @@ export default function (seriesType) {
                     var point;
 
                     if (dimLen === 1) {
-                        var x = data.get(dims[0], i, true);
+                        var x = data.get(dims[0], i);
                         point = !isNaN(x) && coordSys.dataToPoint(x, null, tmpOut);
                     }
                     else {
-                        var x = tmpIn[0] = data.get(dims[0], i, true);
-                        var y = tmpIn[1] = data.get(dims[1], i, true);
+                        var x = tmpIn[0] = data.get(dims[0], i);
+                        var y = tmpIn[1] = data.get(dims[1], i);
                         // Also {Array.<number>}, not undefined to avoid if...else... statement
                         point = !isNaN(x) && !isNaN(y) && coordSys.dataToPoint(tmpIn, null, tmpOut);
                     }

package/src/loading/default.js

@@ -1,3 +1,22 @@
+/*
+* 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 * as zrUtil from 'zrender/src/core/util';
 import * as graphic from '../util/graphic';
 

package/src/model/Component.js

@@ -1,3 +1,22 @@
+/*
+* 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.
+*/
+
 /**
  * Component model
  *