@kospa/base/activator.js

Base components for kospa framework

var __spreadArrays = (this && this.__spreadArrays) || function () {
    for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;
    for (var r = Array(s), k = 0, i = 0; i < il; i++)
        for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)
            r[k] = a[j];
    return r;
};
(function (factory) {
    if (typeof module === "object" && typeof module.exports === "object") {
        var v = factory(require, exports);
        if (v !== undefined) module.exports = v;
    }
    else if (typeof define === "function" && define.amd) {
        define(["require", "exports", "knockout", "./loader", "./system"], factory);
    }
})(function (require, exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.createActivateObservable = exports.call = exports.deactivate = exports.activate = exports.constructs = void 0;
    var ko = require("knockout");
    var loader = require("./loader");
    var system = require("./system");
    function constructs(VmModule) {
        return isConstructor(VmModule) ? new VmModule() : VmModule;
    }
    exports.constructs = constructs;
    function activate(VmModule, args) {
        var vm = constructs(VmModule);
        if (!vm || vm.activated) {
            return Promise.resolve(vm);
        }
        return call.apply(void 0, __spreadArrays([vm, "activate"], (args || []))).then(function () {
            vm.activated = true;
            return vm;
        });
    }
    exports.activate = activate;
    function deactivate(vm, newVm) {
        if (!vm || !vm.activated) {
            return Promise.resolve(vm);
        }
        return call(vm, "deactivate", newVm !== vm)
            .then(function () {
            vm.activated = false;
            return vm;
        });
    }
    exports.deactivate = deactivate;
    function call(vm, key) {
        var args = [];
        for (var _i = 2; _i < arguments.length; _i++) {
            args[_i - 2] = arguments[_i];
        }
        try {
            if (typeof vm[key] !== "function") {
                return Promise.resolve(null);
            }
            return Promise.resolve(vm[key].apply(vm, args));
        }
        catch (err) {
            return Promise.reject(err);
        }
    }
    exports.call = call;
    function createActivateObservable(target, config) {
        var opts = ensureArgs(target, config);
        var prom = Promise.resolve(null);
        var result = system.extend(ko.computed({
            read: opts.target,
            write: function (val) {
                var old = opts.target(), args = getArgs(result.args);
                prom = loadModule(val)
                    .then(function (vm) {
                    return deactivate(old, vm)
                        .then(function () { return activate(vm, args); });
                })
                    .then(function (vm) {
                    opts.target(vm);
                    return vm;
                })
                    .catch(function (err) {
                    if (typeof result.onError !== "function") {
                        throw err;
                    }
                    return result.onError(err);
                });
            }
        }), {
            then: function (onSuccess, onError) { return prom.then(onSuccess, onError); },
            catch: function (onError) { return prom.catch(onError); },
            args: opts.config.args || [],
            onError: opts.config.onError || (function (err) {
                system.error("activator>", err);
                throw err;
            })
        });
        return result;
    }
    exports.createActivateObservable = createActivateObservable;
    ko.extenders["activate"] = function (target, config) {
        return createActivateObservable(target, config);
    };
    function loadModule(mod) {
        return typeof mod === "string" ?
            loader.loadModule(mod) :
            Promise.resolve(mod);
    }
    function getArgs(args) {
        return typeof args === "function" ? args() : args;
    }
    function ensureArgs(target, config) {
        if (!config && !ko.isWriteableObservable(target)) {
            config = target;
            target = undefined;
        }
        return {
            target: target || ko.observable(),
            config: config || {}
        };
    }
    function isConstructor(obj) {
        return typeof obj === "function";
    }
});