@visactor/vchart/cjs/event/event.js

charts lib based @visactor/VGrammar

"use strict";

Object.defineProperty(exports, "__esModule", {
    value: !0
}), exports.Event = void 0;

const factory_1 = require("../core/factory");

class Event {
    getComposedEventMap() {
        return this._composedEventMap;
    }
    constructor(eventDispatcher, mode) {
        this._composedEventMap = new Map, this._eventHandlerMap = new Map, this._eventDispatcher = eventDispatcher, 
        this._mode = mode;
    }
    on(eType, query, callback) {
        const handler = "function" == typeof query ? {
            query: null,
            callback: query
        } : {
            query: query,
            callback: callback
        }, ComposedEventCtor = factory_1.Factory.getComposedEvent(eType);
        if (ComposedEventCtor) {
            const composedEvent = new ComposedEventCtor(this._eventDispatcher, this._mode);
            composedEvent.register(eType, handler), this._composedEventMap.set(handler.callback, {
                eventType: eType,
                event: composedEvent
            });
        } else this._eventDispatcher.register(eType, handler), this._addEventHandler(eType, handler);
        return this;
    }
    off(eType, query, cb) {
        var _a, _b, _c;
        const callback = null != cb ? cb : query;
        if (factory_1.Factory.getComposedEvent(eType)) if (callback) null === (_a = this._composedEventMap.get(callback)) || void 0 === _a || _a.event.unregister(), 
        this._composedEventMap.delete(callback); else for (const entry of this._composedEventMap.entries()) entry[1].eventType === eType && (null === (_b = this._composedEventMap.get(entry[0])) || void 0 === _b || _b.event.unregister(), 
        this._composedEventMap.delete(entry[0])); else if (callback) {
            const handler = null !== (_c = this._getEventHandler(eType, callback)) && void 0 !== _c ? _c : {
                callback: callback,
                query: null,
                filter: {
                    nodeName: null,
                    type: eType,
                    level: null,
                    source: query.source,
                    markName: null,
                    filter: null,
                    userId: null
                }
            };
            this._eventDispatcher.unregister(eType, handler), this._removeEventHandler(eType, callback);
        } else this._eventDispatcher.unregister(eType), this._eventHandlerMap.delete(eType);
        return this;
    }
    emit(eType, params, level) {
        return this._eventDispatcher.dispatch(eType, params, level), this;
    }
    prevent(eType, except) {
        return this._eventDispatcher.prevent(eType, except), this;
    }
    allow(eType) {
        return this._eventDispatcher.allow(eType), this;
    }
    release() {
        this._eventHandlerMap.forEach(((handlers, eventType) => {
            handlers.forEach((handler => {
                this._eventDispatcher.unregister(eventType, handler);
            }));
        })), this._eventHandlerMap.clear(), this._composedEventMap.forEach((entry => {
            entry.event.unregister();
        })), this._composedEventMap.clear();
    }
    _addEventHandler(eventType, handler) {
        handler.callback && (this._eventHandlerMap.has(eventType) || this._eventHandlerMap.set(eventType, new Map), 
        this._eventHandlerMap.get(eventType).set(handler.callback, handler));
    }
    _getEventHandler(eventType, callback) {
        var _a;
        return null === (_a = this._eventHandlerMap.get(eventType)) || void 0 === _a ? void 0 : _a.get(callback);
    }
    _removeEventHandler(eventType, callback) {
        const handlerMap = this._eventHandlerMap.get(eventType);
        handlerMap && (handlerMap.delete(callback), handlerMap.size || this._eventHandlerMap.delete(eventType));
    }
}

exports.Event = Event;
//# sourceMappingURL=event.js.map