@antv/g2plot/esm/plots/area/layer.js

G2 Plot, a market of plots built with the Grammar of Graphics'

import { __extends } from "tslib";
import * as _ from '@antv/util';
import { registerPlotType } from '../../base/global';
import ViewLayer from '../../base/view-layer';
import { getComponent } from '../../components/factory';
import { getGeom } from '../../geoms/factory';
import { extractScale } from '../../util/scale';
import responsiveMethods from './apply-responsive';
import * as EventParser from './event';
import './theme';
var GEOM_MAP = {
    area: 'area',
    line: 'line',
    point: 'point',
};
var AreaLayer = /** @class */ (function (_super) {
    __extends(AreaLayer, _super);
    function AreaLayer() {
        var _this = _super !== null && _super.apply(this, arguments) || this;
        _this.type = 'area';
        return _this;
    }
    AreaLayer.getDefaultOptions = function () {
        return _.deepMix({}, _super.getDefaultOptions.call(this), {
            smooth: false,
            areaStyle: {
                opacity: 0.25,
                fillOpacity: 1,
            },
            line: {
                visible: true,
                size: 2,
                style: {
                    opacity: 1,
                    lineJoin: 'round',
                    lineCap: 'round',
                },
            },
            point: {
                visible: false,
                size: 4,
                shape: 'point',
            },
            label: {
                visible: false,
                type: 'point',
            },
            legend: {
                visible: true,
                position: 'top-left',
                wordSpacing: 4,
            },
        });
    };
    AreaLayer.prototype.beforeInit = function () {
        _super.prototype.beforeInit.call(this);
        /** 响应式图形 */
        if (this.options.responsive && this.options.padding !== 'auto') {
            this.applyResponsive('preRender');
        }
    };
    AreaLayer.prototype.afterRender = function () {
        /** 响应式 */
        if (this.options.responsive && this.options.padding !== 'auto') {
            this.applyResponsive('afterRender');
        }
        _super.prototype.afterRender.call(this);
    };
    AreaLayer.prototype.geometryParser = function (dim, type) {
        return GEOM_MAP[type];
    };
    AreaLayer.prototype.scale = function () {
        var props = this.options;
        var scales = {};
        /** 配置x-scale */
        scales[props.xField] = {
            type: 'cat',
        };
        if (_.has(props, 'xAxis')) {
            extractScale(scales[props.xField], props.xAxis);
        }
        /** 配置y-scale */
        scales[props.yField] = {};
        if (_.has(props, 'yAxis')) {
            extractScale(scales[props.yField], props.yAxis);
        }
        this.setConfig('scales', scales);
        _super.prototype.scale.call(this);
    };
    AreaLayer.prototype.coord = function () { };
    AreaLayer.prototype.addGeometry = function () {
        var props = this.options;
        var area = getGeom('area', 'main', {
            plot: this,
        });
        this.area = area;
        if (props.label) {
            this.label();
        }
        this.adjustArea(area);
        this.setConfig('element', area);
        this.addLine();
        this.addPoint();
    };
    AreaLayer.prototype.adjustArea = function (area) {
        return;
    };
    AreaLayer.prototype.adjustLine = function (line) {
        return;
    };
    AreaLayer.prototype.adjustPoint = function (point) {
        return;
    };
    AreaLayer.prototype.addLine = function () {
        var props = this.options;
        var lineConfig = _.deepMix({}, props.line);
        if (lineConfig.visible) {
            var line = getGeom('line', 'guide', {
                type: 'line',
                plot: this,
                line: lineConfig,
            });
            this.adjustLine(line);
            this.setConfig('element', line);
            this.line = line;
        }
    };
    AreaLayer.prototype.addPoint = function () {
        var props = this.options;
        var pointConfig = _.deepMix({}, props.point);
        if (pointConfig.visible) {
            var point = getGeom('point', 'guide', {
                plot: this,
            });
            this.adjustPoint(point);
            this.setConfig('element', point);
            this.point = point;
        }
    };
    AreaLayer.prototype.animation = function () {
        _super.prototype.animation.call(this);
        var props = this.options;
        if (props.animation === false) {
            // 关闭动画
            this.area.animate = false;
            if (this.line)
                this.line.animate = false;
            if (this.point)
                this.point.animate = false;
        }
    };
    AreaLayer.prototype.label = function () {
        var props = this.options;
        var label = props.label;
        if (label.visible === false) {
            if (this.line) {
                this.line.label = false;
            }
            this.area.label = false;
            return;
        }
        this.area.label = getComponent('label', {
            fields: [props.yField],
            plot: this,
        });
    };
    AreaLayer.prototype.parseEvents = function (eventParser) {
        _super.prototype.parseEvents.call(this, EventParser);
    };
    AreaLayer.prototype.applyResponsive = function (stage) {
        var _this = this;
        var methods = responsiveMethods[stage];
        _.each(methods, function (r) {
            var responsive = r;
            responsive.method(_this);
        });
    };
    return AreaLayer;
}(ViewLayer));
export default AreaLayer;
registerPlotType('area', AreaLayer);
//# sourceMappingURL=layer.js.map