@trapcode/codebase/vue/extensions/RequiresServerEngine.js

For TrapCode

let RequiresServerEngine, ng, vueEar, api, sh;

if (window.hasOwnProperty('_____RequiresServerEngineApi')) {
    api = window._____RequiresServerEngineApi
} else {
    api = window.ng;
}

if (window.hasOwnProperty('_____ComponentEngineStorage')) {
    sh = window._____ComponentEngineStorage
} else {
    let ng = window.ng;
    sh = ng;
    if (typeof ng.s === 'function') {
        sh = ng.s();
    }
}


vueEar = window.vueEar;

export default RequiresServerEngine = (function () {
    class RequiresServerEngine {
        getFrom() {
            return {
                route: '',
                params: {},
                jobs: {}
            };
        }

        constructor(getFrom) {
            if (typeof getFrom === 'function') {
                this.getFrom = getFrom;
            } else {
                this.getFrom = function () {
                    return getFrom;
                };
            }
            return this.getServerMixin();
        }

        getServerMixin() {
            let vm;
            vm = this;
            return {
                data: function () {
                    return {
                        serverRequests: {
                            data: null,
                            count: 0,
                            completed: 0,
                            countBeforeClear: 0,
                            dataBeforeClear: null
                        },
                    };
                },
                mounted: function () {
                    let getFrom = vm.getFrom(this)
                    let length = -1;

                    if (getFrom !== null) {
                        if (Array.isArray(getFrom)) {
                            length = getFrom.length
                        } else if (typeof getFrom == 'object') {
                            length = 1
                        }
                    }

                    this.serverRequests.count = length;

                    return this.fetchData();
                },

                computed: {
                    hasServerData() {
                        return this.serverRequests.count === this.serverRequests.completed;
                    }
                },

                methods: {
                    clearFetchedData() {
                        this.serverRequests.countBeforeClear = this.serverRequests.count;
                        this.serverRequests.completed = 0;

                        if (this.hasOwnProperty('pageData')) {
                            this.serverRequests.dataBeforeClear = this.pageData;
                            this.pageData = null
                        }
                        this.$forceUpdate();
                    },

                    restoreFetchedData() {
                        this.serverRequests.completed = this.serverRequests.countBeforeClear;

                        if (this.hasOwnProperty('pageData')) {
                            this.pageData = this.serverRequests.dataBeforeClear
                        }

                        this.$forceUpdate();
                    },

                    reloadFetchedData(fromServer = null) {
                        this.fetchData(true, fromServer)
                    },

                    fetchData: function (clear = false, getFrom = null) {
                        let component, jobs, r, requests;
                        component = this;

                        if (clear) {
                            component.serverRequests.completed = 0;

                            if (component.hasOwnProperty('pageData')) {
                                component.pageData = null
                            }
                        }

                        if (getFrom === null) {
                            r = vm.getFrom(component);
                        } else {
                            if (typeof getFrom === 'function') {
                                r = getFrom(component);
                            } else {
                                r = getFrom;
                            }
                        }

                        if (Array.isArray(r) && r.length) {
                            requests = r;
                            requests.forEach(function (request) {
                                let thisJob = {
                                    yes: function (data) {
                                        component.serverRequests.completed++;
                                        if (typeof component['mountFromServer'] === 'function') {
                                            component.mountFromServer(data, request);
                                        }
                                    }
                                };
                                if (!request.hasOwnProperty('jobs')) {
                                    request.jobs = {};
                                }
                                if (!request.hasOwnProperty('params')) {
                                    request.params = {};
                                }
                                vm.doServerGet(request, thisJob);
                            });
                        } else {
                            jobs = {
                                yes: function (data) {
                                    component.serverRequests.completed++;
                                    if (typeof component['mountFromServer'] === 'function') {
                                        component.mountFromServer(data, r);
                                    }
                                }
                            };

                            if (typeof r === 'object' && Object.keys(r).length) {
                                jobs = _.extend(jobs, r.jobs);
                                if (!r.hasOwnProperty('params')) {
                                    r.params = {};
                                }
                                vm.doServerGet(r, jobs);
                            }
                        }
                    }
                }
            };
        }

        doServerGet(request, jobs) {
            let cacheKey, data, newJob, thisCacheGetter, thisCacheKey;
            cacheKey = 'componentCache:';
            if (request.hasOwnProperty('cache')) {
                if (Array.isArray(request.cache)) {
                    thisCacheKey = request.cache[0];
                    thisCacheGetter = request.cache[1];
                } else {
                    thisCacheKey = request.cache;
                    thisCacheGetter = null;
                }
                cacheKey = cacheKey + thisCacheKey;
                if (sh.hasData(cacheKey)) {
                    data = sh.getData(cacheKey);
                    return jobs.yes(data);
                } else {
                    newJob = {
                        yes: function (data) {
                            if (thisCacheGetter !== null) {
                                data = thisCacheGetter(data);
                            }
                            sh.setData(cacheKey, data);
                            vueEar.talkTo(cacheKey, data);
                            return jobs.yes(data);
                        }
                    };
                    return api.getFromRoute(request.route, request.params, newJob);
                }
            } else {
                return api.getFromRoute(request.route, request.params, jobs);
            }
        }

    }

    RequiresServerEngine.prototype.route = '#';

    RequiresServerEngine.prototype.params = {};

    RequiresServerEngine.prototype.jobs = {};
    // RequiresServerEngine.prototype.requestCount = 0;

    return RequiresServerEngine;

}).call(this);