@angstone/monostone/dist/src/modules/view.module.js

monolitic event-sourced framework

"use strict";
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
    return new (P || (P = Promise))(function (resolve, reject) {
        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
        function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
        step((generator = generator.apply(thisArg, _arguments || [])).next());
    });
};
Object.defineProperty(exports, "__esModule", { value: true });
const ast = require("@angstone/node-util");
const _1 = require("./");
const state = {
    viewsData: {},
    initialRenders: [],
    viewWatchers: [],
    rendering: false,
    lastTimeRendering: Date.now(),
};
const RENDER_REST_TIME = 10;
const config = () => {
    state.viewsData = {};
    state.initialRenders = [];
    state.viewWatchers = [];
    state.rendering = false;
    state.lastTimeRendering = Date.now();
};
const loadFeatures = (features) => {
    features.forEach((feature) => {
        if (feature.views) {
            feature.views.forEach((view) => {
                state.viewsData[view.viewTag] = {};
                if (view.renderUpdate && view.watchEvents) {
                    view.watchEvents.forEach((watchEvent) => {
                        const alreadyInitiatedWatcher = state.viewWatchers
                            .filter((watch) => {
                            return watch.event == watchEvent;
                        });
                        if (alreadyInitiatedWatcher.length === 0) {
                            state.viewWatchers.push({
                                event: watchEvent,
                                renderUpdates: [],
                            });
                        }
                        state.viewWatchers = state.viewWatchers.map((watch) => {
                            if (watch.event == watchEvent && view.renderUpdate) {
                                watch.renderUpdates.push({
                                    methodRenderUpdate: view.renderUpdate,
                                    viewTag: view.viewTag,
                                });
                            }
                            return watch;
                        });
                    });
                }
                if (view.renderInitial) {
                    state.initialRenders.push({
                        methodRenderInitial: view.renderInitial,
                        viewTag: view.viewTag,
                    });
                }
            });
        }
    });
};
const start = () => __awaiter(this, void 0, void 0, function* () {
    yield renderInitialViews();
    yield ast.delay(3);
    watchEvents();
});
/**
 * renders views
 */
const renderInitialViews = () => __awaiter(this, void 0, void 0, function* () {
    state.rendering = true;
    for (const initialRenderIndex in state.initialRenders) {
        if (state.initialRenders[initialRenderIndex]) {
            state.viewsData[state.initialRenders[initialRenderIndex].viewTag] =
                yield state.initialRenders[initialRenderIndex].methodRenderInitial();
        }
    }
    state.rendering = false;
    state.lastTimeRendering = Date.now();
});
/**
 * watch for events
 */
const watchEvents = () => {
    state.viewWatchers.forEach((watcher) => {
        _1.EventModule.getEventReadStream().addListener(watcher.event, (eventRead) => {
            state.rendering = true;
            watcher.renderUpdates.forEach((render) => {
                render.methodRenderUpdate(state.viewsData[render.viewTag], eventRead).then((newViewData) => {
                    state.viewsData[render.viewTag] = newViewData;
                });
            });
            state.lastTimeRendering = Date.now();
            state.rendering = false;
        });
    });
};
const isFree = () => __awaiter(this, void 0, void 0, function* () {
    if (state.rendering)
        return false;
    else {
        if ((Date.now() - state.lastTimeRendering) > 3 * RENDER_REST_TIME)
            return !state.rendering;
        return false;
    }
});
const getViewData = (view) => state.viewsData[view.viewTag];
exports.ViewModule = Object.assign({}, _1.BasicModule, { config,
    loadFeatures,
    start,
    isFree,
    getViewData });
//# sourceMappingURL=view.module.js.map