jw-ng-forward/decorators/state-config.js

Temporary package. The default solution for those that want to write Angular 2.x style code in Angular 1.x

"use strict";
var __assign = (this && this.__assign) || function () {
    __assign = Object.assign || function(t) {
        for (var s, i = 1, n = arguments.length; i < n; i++) {
            s = arguments[i];
            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
                t[p] = s[p];
        }
        return t;
    };
    return __assign.apply(this, arguments);
};
var __read = (this && this.__read) || function (o, n) {
    var m = typeof Symbol === "function" && o[Symbol.iterator];
    if (!m) return o;
    var i = m.call(o), r, ar = [], e;
    try {
        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
    }
    catch (error) { e = { error: error }; }
    finally {
        try {
            if (r && !r.done && (m = i["return"])) m.call(i);
        }
        finally { if (e) throw e.error; }
    }
    return ar;
};
var __spread = (this && this.__spread) || function () {
    for (var ar = [], i = 0; i < arguments.length; i++) ar = ar.concat(__read(arguments[i]));
    return ar;
};
Object.defineProperty(exports, "__esModule", { value: true });
var helpers_1 = require("../util/helpers");
var writers_1 = require("../writers");
var component_1 = require("./component");
var providers_1 = require("./providers");
var childConfigsKey = 'ui-router.stateChildConfigs';
var annotatedResolvesKey = 'ui-router.annotatedResolves';
var resolvedMapKey = 'ui-router.resolvedMap';
var hooksKey = 'ui-router.hooks';
function StateConfig(stateConfigs) {
    return function (t) {
        providers_1.Providers.apply(void 0, __spread(helpers_1.flatten(stateConfigs.map(function (sc) { return sc.component; }))))(t, "while analyzing StateConfig '" + t.name + "' state components");
        writers_1.componentStore.set(childConfigsKey, stateConfigs, t);
    };
}
exports.StateConfig = StateConfig;
function targetIsStaticFn(t) {
    return t.name !== undefined && t.constructor.name === 'Function';
}
function Resolve(resolveName) {
    if (resolveName === void 0) { resolveName = null; }
    return function (target, resolveFnName, _a) {
        var resolveFn = _a.value;
        var _b;
        if (!targetIsStaticFn(target)) {
            throw new Error('@Resolve target must be a static method.');
        }
        writers_1.componentStore.merge(annotatedResolvesKey, (_b = {}, _b[resolveName || resolveFnName] = resolveFn, _b), target);
    };
}
exports.Resolve = Resolve;
function Hook() {
    return function (target, name, _a) {
        var fn = _a.value;
        var _b;
        if (!targetIsStaticFn(target))
            throw new Error('@Enter target must be a static method.');
        writers_1.componentStore.merge(hooksKey, (_b = {}, _b[name] = fn, _b), target);
    };
}
exports.Hook = Hook;
component_1.componentHooks.extendDDO(function (ddo) {
    if (ddo.template && ddo.template.replace) {
        ddo.template = ddo.template.replace(/ng-outlet/g, 'ui-view');
    }
});
component_1.componentHooks.after(function (target, name, injects, ngModule) {
    var childStateConfigs = writers_1.componentStore.get(childConfigsKey, target);
    if (childStateConfigs) {
        if (!Array.isArray(childStateConfigs)) {
            throw new TypeError(helpers_1.createConfigErrorMessage(target, ngModule, '@StateConfig param must be an array of state objects.'));
        }
        ngModule.config(['$stateRegistryProvider', function ($stateRegistry) {
                function setupConfig(config) {
                    var _a;
                    if (!config.component)
                        return null;
                    var annotatedResolves = writers_1.componentStore.get(annotatedResolvesKey, config.component) || {};
                    Object.keys(annotatedResolves).forEach(function (resolveName) {
                        var resolveFn = annotatedResolves[resolveName];
                        var fnInjects = writers_1.bundleStore.get('$inject', resolveFn);
                        resolveFn.$inject = fnInjects;
                    });
                    config.resolve = Object.assign({}, config.resolve, annotatedResolves);
                    var transitionHooks = writers_1.componentStore.get(hooksKey, config.component) || {};
                    Object.keys(transitionHooks).forEach(function (key) {
                        var hookFn = transitionHooks[key];
                        hookFn.$inject = writers_1.bundleStore.get('$inject', hookFn);
                    });
                    config = __assign({}, config, transitionHooks);
                    var name = writers_1.providerStore.get('name', config.component);
                    if (config.root) {
                        config.component = name;
                    }
                    else {
                        var root = config.name.split('.')[0];
                        config.views = (_a = {}, _a["@" + root] = name, _a);
                        delete config.component;
                    }
                    return config;
                }
                childStateConfigs.forEach(function (config) {
                    var conf = setupConfig(Object.assign({}, config));
                    if (conf)
                        $stateRegistry.register(conf);
                });
            }]);
    }
});
component_1.componentHooks.beforeCtrlInvoke(function (caller, injects, controller, ddo, $injector, locals) {
    var resolvesMap = writers_1.componentStore.get(resolvedMapKey, controller);
    Object.assign(locals, resolvesMap);
});