@knapsack/app/dist/server/events.js

Build Design Systems with Knapsack

"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.knapsackEvents = void 0;
const events_1 = require("events");
const debounce_1 = __importDefault(require("debounce"));
const utils_1 = require("@knapsack/utils");
const log_1 = require("../cli/log");
const EVENTS = {
    CONFIG_READY: 'CONFIG_READY',
    PATTERNS_DATA_READY: 'PATTERNS_DATA_READY',
    PATTERN_TEMPLATE_ADDED: 'PATTERN_TEMPLATE_ADDED',
    PATTERN_TEMPLATE_CHANGED: 'PATTERN_TEMPLATE_CHANGED',
    PATTERN_TEMPLATE_REMOVED: 'PATTERN_TEMPLATE_REMOVED',
    PATTERN_ASSET_CHANGED: 'PATTERN_ASSET_CHANGED',
    PATTERN_CONFIG_CHANGED: 'PATTERN_CONFIG_CHANGED',
    DESIGN_TOKENS_CHANGED: 'DESIGN_TOKENS_CHANGED',
    SHUTDOWN: 'SHUTDOWN',
    REQUEST_RENDERER_CLIENT_RELOAD: 'REQUEST_RENDERER_CLIENT_RELOAD',
    APP_CLIENT_DATA_CHANGED: 'APP_CLIENT_DATA_CHANGED',
};
class KnapsackEventEmitter extends events_1.EventEmitter {
    constructor() {
        super(...arguments);
        this.debouncedEmit = (0, debounce_1.default)((eventName, eventData) => {
            this.emit(eventName, eventData);
        }, 100);
    }
    onPatternAssetChange(handle) {
        this.on(EVENTS.PATTERN_ASSET_CHANGED, handle);
    }
    emitPatternAssetChanged(data) {
        const event = {
            type: EVENTS.PATTERN_ASSET_CHANGED,
            data,
        };
        this.emit(event.type, event.data);
    }
    onAppClientDataChange(handle) {
        this.on(EVENTS.APP_CLIENT_DATA_CHANGED, handle);
    }
    emitAppClientDataChanged() {
        const event = {
            type: EVENTS.APP_CLIENT_DATA_CHANGED,
            data: null,
        };
        this.emit(event.type, event.data);
    }
    onPatternsDataReady(handle) {
        this.on(EVENTS.PATTERNS_DATA_READY, handle);
    }
    emitPatternsDataReady(data) {
        const event = {
            type: EVENTS.PATTERNS_DATA_READY,
            data,
        };
        // this.emit(event.type, event.data)
        this.debouncedEmit(event.type, event.data);
    }
    onPatternTemplateChanged(handle) {
        this.on(EVENTS.PATTERN_TEMPLATE_CHANGED, handle);
    }
    emitPatternTemplateChanged(data) {
        const event = {
            type: EVENTS.PATTERN_TEMPLATE_CHANGED,
            data,
        };
        this.emit(event.type, event.data);
    }
    onShutdown(handle) {
        this.on(EVENTS.SHUTDOWN, handle);
    }
    emitShutdown() {
        this.emit(EVENTS.SHUTDOWN);
    }
    onDesignTokensChanged(handle) {
        this.on(EVENTS.DESIGN_TOKENS_CHANGED, handle);
    }
    emitDesignTokensChanged(data = {}) {
        const event = {
            type: EVENTS.DESIGN_TOKENS_CHANGED,
            data,
        };
        this.emit(event.type, event.data);
    }
    onConfigReady(handle) {
        this.on(EVENTS.CONFIG_READY, handle);
    }
    emitConfigReady(data) {
        const event = {
            type: EVENTS.CONFIG_READY,
            data,
        };
        this.emit(event.type, event.data);
    }
    onRequestRendererClientReload(handle) {
        this.on(EVENTS.REQUEST_RENDERER_CLIENT_RELOAD, handle);
    }
    emitRequestRendererClientReload(data = {}) {
        const event = {
            type: EVENTS.REQUEST_RENDERER_CLIENT_RELOAD,
            data,
        };
        this.emit(event.type, event.data);
    }
}
exports.knapsackEvents = new KnapsackEventEmitter().setMaxListeners(15);
(0, utils_1.keys)(EVENTS).forEach((event) => {
    const eventName = EVENTS[event];
    // each event should emit either nothing or a single object, no more
    exports.knapsackEvents.on(eventName, (info) => {
        log_1.log.verbose(`event fired: ${eventName}`, '', 'events');
    });
});
//# sourceMappingURL=events.js.map