@ima/core/dist/cjs/event/ObservableImpl.js

IMA.js framework for isomorphic javascript application

"use strict";
Object.defineProperty(exports, "__esModule", {
    value: true
});
Object.defineProperty(exports, "ObservableImpl", {
    enumerable: true,
    get: function() {
        return ObservableImpl;
    }
});
const _Observable = require("./Observable");
const _RouterEvents = require("../router/RouterEvents");
const MAX_HISTORY_LENGTH = 10;
class ObservableImpl extends _Observable.Observable {
    _dispatcher;
    _observers;
    _activityHistory;
    _persistentEvents;
    _settings;
    static $dependencies = [
        '$Dispatcher',
        '?$Settings.$Observable'
    ];
    /**
   * Creates an instance of Observable.
   *
   * @param dispatcher - The dispatcher responsible for managing event listeners.
   * @param settings - Optional settings for the Observable instance.
   */ constructor(dispatcher, settings){
        super();
        this._dispatcher = dispatcher;
        this._observers = new Map();
        this._activityHistory = new Map();
        this._persistentEvents = new Set();
        this._settings = settings;
    }
    /**
   * @inheritDoc
   */ init() {
        this.clear();
        this._dispatcher.listenAll(this._handleDispatcherEvent, this);
        return this;
    }
    /**
   * @inheritDoc
   */ destroy() {
        this.clear();
        this._dispatcher.unlistenAll(this._handleDispatcherEvent, this);
        return this;
    }
    /**
   * @inheritDoc
   */ clear() {
        this._persistentEvents.clear();
        this._observers.clear();
        this._activityHistory.clear();
        return this;
    }
    /**
   * @inheritDoc
   */ registerPersistentEvent(event) {
        this._persistentEvents.add(event);
        return this;
    }
    /**
   * @inheritDoc
   */ registerPersistenEvent(event) {
        console.warn('registerPersistenEvent is deprecated, please use the correctly-named registerPersistentEvent instead.');
        this.registerPersistentEvent(event);
        return this;
    }
    /**
   * @inheritDoc
   */ subscribe(event, observer, scope) {
        if (!this._observers.has(event)) {
            this._observers.set(event, new Map());
        }
        if (!this._observers.get(event).has(observer)) {
            this._observers.get(event).set(observer, new Set());
        }
        this._observers.get(event).get(observer).add(scope);
        if (this._activityHistory.has(event)) {
            this._activityHistory.get(event).forEach((data)=>observer.bind(scope)(data));
        }
        return this;
    }
    /**
   * @inheritDoc
   */ unsubscribe(event, observer, scope) {
        if (!this._observers.has(event)) {
            return this;
        }
        if (!this._observers.get(event).has(observer)) {
            return this;
        }
        this._observers.get(event).get(observer).delete(scope);
        if (this._observers.get(event).get(observer).size === 0) {
            this._observers.get(event).delete(observer);
        }
        return this;
    }
    /**
   * Handles dispatcher events by updating the activity history and notifying observers.
   * It also resets the activity history for non-persistent events on `BEFORE_HANDLE_ROUTE` ecvent.
   *
   * @param event - The name of the event being dispatched.
   * @param data - The data associated with the event.
   */ _handleDispatcherEvent(event, data) {
        if (event === _RouterEvents.RouterEvents.BEFORE_HANDLE_ROUTE) {
            for (const [eventKey] of this._activityHistory){
                if (!this._persistentEvents.has(eventKey)) {
                    this._activityHistory.delete(eventKey);
                }
            }
        }
        if (!this._activityHistory.has(event)) {
            this._activityHistory.set(event, []);
        }
        this._activityHistory.get(event).push(data);
        this._activityHistory.set(event, this._activityHistory.get(event).splice(-(this._settings?.maxHistoryLength || MAX_HISTORY_LENGTH)));
        if (!this._observers.has(event)) {
            return;
        }
        for (const [observer, scopes] of this._observers.get(event).entries()){
            for (const scope of scopes){
                observer.bind(scope)(data);
            }
        }
    }
}

//# sourceMappingURL=ObservableImpl.js.map