@uirouter/angular-hybrid/esm2015/angular-hybrid.js

var UIRouterUpgradeModule_1;
import * as tslib_1 from "tslib";
import { Component, ElementRef, Inject, Injector, Input, ModuleWithProviders, NgModule } from '@angular/core';
import { downgradeComponent, UpgradeModule, getAngularJSGlobal, getAngularLib } from '@angular/upgrade/static';
import { StateObject, forEach, PathNode, Resolvable, StateRegistry, UIRouter, ViewConfig, ViewService, } from '@uirouter/core';
import { applyModuleConfig, NATIVE_INJECTOR_TOKEN, ng2LazyLoadBuilder, Ng2ViewConfig, UIView, _UIROUTER_SERVICE_PROVIDERS, UIROUTER_MODULE_TOKEN, UIROUTER_ROOT_MODULE, UIRouterModule, makeChildProviders, } from '@uirouter/angular';
import { Ng1ViewConfig } from '@uirouter/angularjs';
import { UIRouterRx } from '@uirouter/rx';
const getAngularJS = getAngularJSGlobal || getAngularLib;
const angular = getAngularJS();
if (!angular) {
    throw new Error('AngularJS not found on window.  https://github.com/ui-router/angular-hybrid/wiki/AngularJS-not-found-on-window');
}
/**
 * Create a ng1 module for the ng1 half of the hybrid application to depend on.
 *
 * Example:
 * const myApp = angular.module('myApp', ['ui.router.upgrade']);
 */
export const upgradeModule = angular.module('ui.router.upgrade', ['ui.router']);
export function objectFactory() {
    return {};
}
/**
 * UIViewNgUpgrade is a component bridge from ng1 ui-view to ng2 ui-view
 *
 * When a ui-router for ng1 is registering a state it checks if a view's
 * `component:` is an ng2 Component class. If so, it creates a special ng1 template
 * which references this component, i.e., <ui-view-ng-upgrade></ui-view-ng-upgrade>
 *
 * See that code by searching ng1-to-ng2 source for: "$stateProvider.decorator"
 *
 * ---
 *
 * ng1-to-ng2 component bridge process:
 *
 * 1)
 * When an ng1 template creates a ui-view which is targeted by a ng2 Component,
 *
 * ```
 * <a ui-sref="foo">Go to foo</a>
 * <div ui-view> <!-- ui-view created in ng1 template -->
 * </div> <!-- targeted with { component: Ng2RoutedComponent } -->
 * ```
 *
 * the state decorator spits out a custom template.  That template loads this
 * ng2 Component adapter as a downgraded-to-ng1 directive.
 *
 * ```
 * <a ui-sref="foo">Go to foo</a>
 * <div ui-view> <!-- decorated template references the downgraded component -->
 *   <ui-view-ng-upgrade> <!-- downgraded adapter component -->
 *   </ui-view-ng-upgrade>
 * </div>
 * ```
 *
 * This downgraded ng2 Component then creates a child UIView (ng2 component)
 *
 * ```
 * <a ui-sref="foo">Go to foo</a>
 * <div ui-view> <!-- custom template references the downgraded component -->
 *   <ui-view-ng-upgrade> <!-- ng2 component adapter downgraded to ng1-->
 *     <ui-view> <!-- pure ng2 ui-view -->
 *      </ui-view>
 *   </ui-view-ng-upgrade>
 * </div>
 * ```
 *
 * which in turn is filled with the routed ng2 component.
 *
 * ```
 * <a ui-sref="foo">Go to foo</a>
 * <div ui-view> <!-- ng1 ui-view -->
 *   <ui-view-ng-upgrade> <!-- ng2 component adapter (downgraded to ng1)-->
 *     <ui-view> <!-- pure ng2 ui-view -->
 *       <ng2-routed-component> <!-- ng2 component hosted in ng2 ui-view -->
 *         <h1>ng2 routed component contents</h1>
 *       </ng2-routed-component>
 *     </ui-view>
 *   </ui-view-ng-upgrade>
 * </div>
 * ```
 *
 * This adapter exposes exposes the parent view context (ParentUIViewInject)
 * as an ng2 DI Provider, which the nested ng2 UIView requires.
 *
 * It gets the ParentUIViewContext information (from the parent ng1 ui-view) by walking
 * up the DOM and grabbing the .data('$uiView') which the ng1 ui-view directive exposes.
 */
let UIViewNgUpgrade = class UIViewNgUpgrade {
    constructor(ref, parent, registry // access the root state
    ) {
        // From the ui-view-ng-upgrade component's element ref, walk up the DOM two elements...
        // There will first be an ng1 ui-view which hosts this element, and then that ui-view's parent element.
        // That (parent) element has access to the proper "parent viewcontext"
        // The ng2 ui-view component is inside this ui-view-ng-upgrade directive, which is inside the ng1 "host" ui-view.
        // Both ui-views share the same "view context" information (the view's fqn and created-by-state context information)
        const ng1elem = angular
            .element(ref.nativeElement)
            .parent()
            .parent();
        // Expose getters on PARENT_INJECT for context (creation state) and fqn (view address)
        // These will be used by further nested UIView
        Object.defineProperty(parent, 'context', {
            get: function () {
                const data = ng1elem['inheritedData']('$uiView');
                return data && data.$cfg ? data.$cfg.viewDecl.$context : registry.root();
            },
            enumerable: true,
        });
        Object.defineProperty(parent, 'fqn', {
            get: function () {
                const data = ng1elem['inheritedData']('$uiView');
                return data && data.$uiView ? data.$uiView.fqn : null;
            },
            enumerable: true,
        });
    }
};
UIViewNgUpgrade.ctorParameters = () => [
    { type: ElementRef },
    { type: undefined, decorators: [{ type: Inject, args: [UIView.PARENT_INJECT,] }] },
    { type: StateRegistry // access the root state
     }
];
tslib_1.__decorate([
    Input()
], UIViewNgUpgrade.prototype, "name", void 0);
UIViewNgUpgrade = tslib_1.__decorate([
    Component({
        selector: 'ui-view-ng-upgrade',
        template: `
    <ui-view [name]="name"></ui-view>
  `,
        // provide a blank object as PARENT_INJECT.
        // The component will add property getters when it is constructed.
        viewProviders: [{ provide: UIView.PARENT_INJECT, useFactory: objectFactory }]
    }),
    tslib_1.__param(1, Inject(UIView.PARENT_INJECT))
], UIViewNgUpgrade);
export { UIViewNgUpgrade };
/**********************************
 * Ng2 @NgModule and bootstrap code
 **********************************/
// Register the ng1 DI '$uiRouter' object as an ng2 Provider.
export function uiRouterUpgradeFactory(router, injector) {
    const modules = injector.get(UIROUTER_MODULE_TOKEN, []);
    modules.forEach(module => applyModuleConfig(router, injector, module));
    return router;
}
export function getUIRouter($injector) {
    return $injector.get('$uiRouter');
}
export function getParentUIViewInject(r) {
    return { fqn: null, context: r.root() };
}
const ɵ0 = {};
/**
 * This NgModule should be added to the root module of the hybrid app.
 */
let UIRouterUpgradeModule = UIRouterUpgradeModule_1 = class UIRouterUpgradeModule {
    static forRoot(module = {}) {
        return {
            ngModule: UIRouterUpgradeModule_1,
            providers: makeChildProviders(module),
        };
    }
    static forChild(module = {}) {
        return {
            ngModule: UIRouterModule,
            providers: makeChildProviders(module),
        };
    }
};
UIRouterUpgradeModule = UIRouterUpgradeModule_1 = tslib_1.__decorate([
    NgModule({
        imports: [UIRouterModule, UpgradeModule],
        declarations: [UIViewNgUpgrade],
        providers: [
            // @uirouter/angular code will use the ng1 $uiRouter instance instead of creating its own.
            { provide: '$uiRouter', useFactory: getUIRouter, deps: ['$injector'] },
            { provide: UIRouter, useFactory: uiRouterUpgradeFactory, deps: ['$uiRouter', Injector] },
            { provide: UIROUTER_ROOT_MODULE, useValue: ɵ0, multi: true },
            { provide: UIView.PARENT_INJECT, useFactory: getParentUIViewInject, deps: [StateRegistry] },
            ..._UIROUTER_SERVICE_PROVIDERS,
        ],
        entryComponents: [UIViewNgUpgrade],
        exports: [UIViewNgUpgrade, UIRouterModule],
    })
], UIRouterUpgradeModule);
export { UIRouterUpgradeModule };
// Downgrade the UIViewNgUpgrade ng2 Component to an ng1 directive.
// The directive is used in a (generated) view template by the (host) ng1 ui-router,
// whenever it finds a view configured with a `component: <Ng2ComponentClass>`
upgradeModule.directive('uiViewNgUpgrade', downgradeComponent({
    component: UIViewNgUpgrade,
    inputs: ['name'],
}));
upgradeModule.run([
    '$injector',
    (ng1Injector) => {
        const $uiRouter = ng1Injector.get('$uiRouter');
        /** Add support for observable state and param changes */
        $uiRouter.plugin(UIRouterRx);
        // Expose a merged ng1/ng2 injector as a Resolvable (on the root state).
        // This mimics how ui-router-ng2 exposes the root ng2 Injector, but
        // it retrieves from ng1 injector first, then ng2 injector if the token isn't found.
        const mergedInjector = {
            get: function (token, ng2NotFoundValue) {
                const ng2Injector = ng1Injector.get('$$angularInjector');
                if (ng1Injector.has(token)) {
                    return ng1Injector.get(token);
                }
                return ng2Injector.get(token, ng2NotFoundValue);
            },
        };
        const ng2InjectorResolvable = Resolvable.fromData(NATIVE_INJECTOR_TOKEN, mergedInjector);
        $uiRouter.stateRegistry.root().resolvables.push(ng2InjectorResolvable);
    },
]);
/** Adds support for `loadChildren`: Angular NgModule lazy loading via @gntools/webpack */
upgradeModule.config([
    '$stateRegistryProvider',
    ($stateRegistry) => {
        $stateRegistry.decorator('lazyLoad', ng2LazyLoadBuilder);
    },
]);
/**
 * Define a stateProvider `views` builder decorator.
 * The decorator first applies the standard views builder function.
 * Then it finds any view components which are **actually** a Ng2 Component Class.
 * It overwrites that view's config with a ng1-to-ng2 hybrid config.
 *
 * In place of the template provider, it simply puts a <ui-view-ng-upgrade/> component
 * which that provides a ng1 -> ng2 boundary in the component tree.
 */
upgradeModule.config([
    '$stateRegistryProvider',
    ($stateRegistry) => {
        $stateRegistry.decorator('views', function (state, parentFn) {
            const views = parentFn(state);
            forEach(views, (viewDecl, viewName) => {
                if (viewDecl.$type === 'ng1-to-ng2' || typeof viewDecl.component === 'function') {
                    // Update the view config.
                    // Override default ng1 `component:` behavior (of defining a templateProvider)
                    // with a <ui-view-ng-upgrade> adapter directive template
                    viewDecl.$type = 'ng1-to-ng2';
                    viewDecl.templateProvider = null;
                    viewDecl.template = `<ui-view-ng-upgrade name='${viewDecl.$uiViewName}'></ui-view-ng-upgrade>`;
                }
            });
            return views;
        });
    },
]);
// UI-Router ViewConfig factories take a view declaration object from a state.views: { foo: <ViewDeclaration> }
// and return a runtime config object (a ViewConfig)
upgradeModule.run([
    '$view',
    '$templateFactory',
    ($view, $templateFactory) => {
        // Register a ViewConfig factory for views of type `ng2`
        $view._pluginapi._viewConfigFactory('ng2', (path, config) => new Ng2ViewConfig(path, config));
        // Register a ViewConfig factory for views of type `ng1-to-ng2`.
        // Returns both an ng1 config and an ng2 config allowing either ng1 or ng2 ui-view components to be targeted.
        $view._pluginapi._viewConfigFactory('ng1-to-ng2', (path, config) => {
            const ng1ViewConfig = (new Ng1ViewConfig(path, Object.assign({}, config, { $type: 'ng1' }), $templateFactory));
            const ng2ViewConfig = (new Ng2ViewConfig(path, Object.assign({}, config, { $type: 'ng2' })));
            return [ng2ViewConfig, ng1ViewConfig];
        });
    },
]);
export { ɵ0 };
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"angular-hybrid.js","sourceRoot":"ng://@uirouter/angular-hybrid/","sources":["angular-hybrid.ts"],"names":[],"mappings":"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","sourcesContent":["import { Component, ElementRef, Inject, Injector, Input, ModuleWithProviders, NgModule } from '@angular/core';\nimport { downgradeComponent, UpgradeModule, getAngularJSGlobal, getAngularLib } from '@angular/upgrade/static';\n\nimport {\n  StateObject,\n  forEach,\n  PathNode,\n  Resolvable,\n  StateRegistry,\n  UIRouter,\n  ViewConfig,\n  ViewService,\n} from '@uirouter/core';\n\nimport {\n  applyModuleConfig,\n  NATIVE_INJECTOR_TOKEN,\n  ng2LazyLoadBuilder,\n  Ng2ViewConfig,\n  UIView,\n  _UIROUTER_SERVICE_PROVIDERS,\n  Ng2ViewDeclaration,\n  ParentUIViewInject,\n  StatesModule,\n  UIROUTER_MODULE_TOKEN,\n  UIROUTER_ROOT_MODULE,\n  UIRouterModule,\n  makeChildProviders,\n} from '@uirouter/angular';\n\nimport { $InjectorLike, Ng1ViewConfig } from '@uirouter/angularjs';\n\nimport { UIRouterRx } from '@uirouter/rx';\nimport { NgHybridStatesModule } from './interfaces';\n\nconst getAngularJS = getAngularJSGlobal || getAngularLib;\nconst angular = getAngularJS();\n\nif (!angular) {\n  throw new Error(\n    'AngularJS not found on window.  https://github.com/ui-router/angular-hybrid/wiki/AngularJS-not-found-on-window'\n  );\n}\n\n/**\n * Create a ng1 module for the ng1 half of the hybrid application to depend on.\n *\n * Example:\n * const myApp = angular.module('myApp', ['ui.router.upgrade']);\n */\nexport const upgradeModule = angular.module('ui.router.upgrade', ['ui.router']);\n\nexport function objectFactory() {\n  return {};\n}\n\n/**\n * UIViewNgUpgrade is a component bridge from ng1 ui-view to ng2 ui-view\n *\n * When a ui-router for ng1 is registering a state it checks if a view's\n * `component:` is an ng2 Component class. If so, it creates a special ng1 template\n * which references this component, i.e., <ui-view-ng-upgrade></ui-view-ng-upgrade>\n *\n * See that code by searching ng1-to-ng2 source for: \"$stateProvider.decorator\"\n *\n * ---\n *\n * ng1-to-ng2 component bridge process:\n *\n * 1)\n * When an ng1 template creates a ui-view which is targeted by a ng2 Component,\n *\n * ```\n * <a ui-sref=\"foo\">Go to foo</a>\n * <div ui-view> <!-- ui-view created in ng1 template -->\n * </div> <!-- targeted with { component: Ng2RoutedComponent } -->\n * ```\n *\n * the state decorator spits out a custom template.  That template loads this\n * ng2 Component adapter as a downgraded-to-ng1 directive.\n *\n * ```\n * <a ui-sref=\"foo\">Go to foo</a>\n * <div ui-view> <!-- decorated template references the downgraded component -->\n *   <ui-view-ng-upgrade> <!-- downgraded adapter component -->\n *   </ui-view-ng-upgrade>\n * </div>\n * ```\n *\n * This downgraded ng2 Component then creates a child UIView (ng2 component)\n *\n * ```\n * <a ui-sref=\"foo\">Go to foo</a>\n * <div ui-view> <!-- custom template references the downgraded component -->\n *   <ui-view-ng-upgrade> <!-- ng2 component adapter downgraded to ng1-->\n *     <ui-view> <!-- pure ng2 ui-view -->\n *      </ui-view>\n *   </ui-view-ng-upgrade>\n * </div>\n * ```\n *\n * which in turn is filled with the routed ng2 component.\n *\n * ```\n * <a ui-sref=\"foo\">Go to foo</a>\n * <div ui-view> <!-- ng1 ui-view -->\n *   <ui-view-ng-upgrade> <!-- ng2 component adapter (downgraded to ng1)-->\n *     <ui-view> <!-- pure ng2 ui-view -->\n *       <ng2-routed-component> <!-- ng2 component hosted in ng2 ui-view -->\n *         <h1>ng2 routed component contents</h1>\n *       </ng2-routed-component>\n *     </ui-view>\n *   </ui-view-ng-upgrade>\n * </div>\n * ```\n *\n * This adapter exposes exposes the parent view context (ParentUIViewInject)\n * as an ng2 DI Provider, which the nested ng2 UIView requires.\n *\n * It gets the ParentUIViewContext information (from the parent ng1 ui-view) by walking\n * up the DOM and grabbing the .data('$uiView') which the ng1 ui-view directive exposes.\n */\n@Component({\n  selector: 'ui-view-ng-upgrade',\n  template: `\n    <ui-view [name]=\"name\"></ui-view>\n  `,\n  // provide a blank object as PARENT_INJECT.\n  // The component will add property getters when it is constructed.\n  viewProviders: [{ provide: UIView.PARENT_INJECT, useFactory: objectFactory }],\n})\nexport class UIViewNgUpgrade {\n  // The ui-view's name (or '$default')\n  @Input()\n  name: string;\n\n  constructor(\n    ref: ElementRef,\n    @Inject(UIView.PARENT_INJECT) parent: ParentUIViewInject,\n    registry: StateRegistry // access the root state\n  ) {\n    // From the ui-view-ng-upgrade component's element ref, walk up the DOM two elements...\n    // There will first be an ng1 ui-view which hosts this element, and then that ui-view's parent element.\n    // That (parent) element has access to the proper \"parent viewcontext\"\n\n    // The ng2 ui-view component is inside this ui-view-ng-upgrade directive, which is inside the ng1 \"host\" ui-view.\n    // Both ui-views share the same \"view context\" information (the view's fqn and created-by-state context information)\n    const ng1elem = angular\n      .element(ref.nativeElement)\n      .parent()\n      .parent();\n\n    // Expose getters on PARENT_INJECT for context (creation state) and fqn (view address)\n    // These will be used by further nested UIView\n    Object.defineProperty(parent, 'context', {\n      get: function() {\n        const data = ng1elem['inheritedData']('$uiView');\n        return data && data.$cfg ? data.$cfg.viewDecl.$context : registry.root();\n      },\n      enumerable: true,\n    });\n\n    Object.defineProperty(parent, 'fqn', {\n      get: function() {\n        const data = ng1elem['inheritedData']('$uiView');\n        return data && data.$uiView ? data.$uiView.fqn : null;\n      },\n      enumerable: true,\n    });\n  }\n}\n\n/**********************************\n * Ng2 @NgModule and bootstrap code\n **********************************/\n\n// Register the ng1 DI '$uiRouter' object as an ng2 Provider.\nexport function uiRouterUpgradeFactory(router: UIRouter, injector: Injector) {\n  const modules: StatesModule[] = injector.get<StatesModule[]>(UIROUTER_MODULE_TOKEN, []);\n  modules.forEach(module => applyModuleConfig(router, injector, module));\n  return router;\n}\n\nexport function getUIRouter($injector: any) {\n  return $injector.get('$uiRouter');\n}\n\nexport function getParentUIViewInject(r: StateRegistry): ParentUIViewInject {\n  return { fqn: null, context: r.root() };\n}\n\n/**\n * This NgModule should be added to the root module of the hybrid app.\n */\n@NgModule({\n  imports: [UIRouterModule, UpgradeModule],\n  declarations: [UIViewNgUpgrade],\n  providers: [\n    // @uirouter/angular code will use the ng1 $uiRouter instance instead of creating its own.\n    { provide: '$uiRouter', useFactory: getUIRouter, deps: ['$injector'] },\n\n    { provide: UIRouter, useFactory: uiRouterUpgradeFactory, deps: ['$uiRouter', Injector] },\n\n    { provide: UIROUTER_ROOT_MODULE, useValue: {}, multi: true },\n\n    { provide: UIView.PARENT_INJECT, useFactory: getParentUIViewInject, deps: [StateRegistry] },\n\n    ..._UIROUTER_SERVICE_PROVIDERS,\n  ],\n  entryComponents: [UIViewNgUpgrade],\n  exports: [UIViewNgUpgrade, UIRouterModule],\n})\nexport class UIRouterUpgradeModule {\n  static forRoot(module: NgHybridStatesModule = {}): ModuleWithProviders {\n    return {\n      ngModule: UIRouterUpgradeModule,\n      providers: makeChildProviders(module as StatesModule),\n    };\n  }\n\n  static forChild(module: NgHybridStatesModule = {}): ModuleWithProviders {\n    return {\n      ngModule: UIRouterModule,\n      providers: makeChildProviders(module as StatesModule),\n    };\n  }\n}\n\n// Downgrade the UIViewNgUpgrade ng2 Component to an ng1 directive.\n// The directive is used in a (generated) view template by the (host) ng1 ui-router,\n// whenever it finds a view configured with a `component: <Ng2ComponentClass>`\nupgradeModule.directive('uiViewNgUpgrade', <any>downgradeComponent({\n  component: UIViewNgUpgrade,\n  inputs: ['name'],\n}));\n\nupgradeModule.run([\n  '$injector',\n  (ng1Injector: $InjectorLike) => {\n    const $uiRouter: UIRouter = ng1Injector.get('$uiRouter');\n\n    /** Add support for observable state and param changes */\n    $uiRouter.plugin(UIRouterRx);\n\n    // Expose a merged ng1/ng2 injector as a Resolvable (on the root state).\n    // This mimics how ui-router-ng2 exposes the root ng2 Injector, but\n    // it retrieves from ng1 injector first, then ng2 injector if the token isn't found.\n    const mergedInjector = {\n      get: function(token: any, ng2NotFoundValue?: any) {\n        const ng2Injector = ng1Injector.get('$$angularInjector');\n        if (ng1Injector.has(token)) {\n          return ng1Injector.get(token);\n        }\n        return ng2Injector.get(token, ng2NotFoundValue);\n      },\n    };\n\n    const ng2InjectorResolvable = Resolvable.fromData(NATIVE_INJECTOR_TOKEN, mergedInjector);\n    $uiRouter.stateRegistry.root().resolvables.push(ng2InjectorResolvable);\n  },\n]);\n\n/** Adds support for `loadChildren`: Angular NgModule lazy loading via @gntools/webpack */\nupgradeModule.config([\n  '$stateRegistryProvider',\n  ($stateRegistry: StateRegistry) => {\n    $stateRegistry.decorator('lazyLoad', ng2LazyLoadBuilder);\n  },\n]);\n\n/**\n * Define a stateProvider `views` builder decorator.\n * The decorator first applies the standard views builder function.\n * Then it finds any view components which are **actually** a Ng2 Component Class.\n * It overwrites that view's config with a ng1-to-ng2 hybrid config.\n *\n * In place of the template provider, it simply puts a <ui-view-ng-upgrade/> component\n * which that provides a ng1 -> ng2 boundary in the component tree.\n */\nupgradeModule.config([\n  '$stateRegistryProvider',\n  ($stateRegistry: StateRegistry) => {\n    $stateRegistry.decorator('views', function(state: StateObject, parentFn: Function) {\n      const views = parentFn(state);\n\n      forEach(views, (viewDecl: any, viewName: string) => {\n        if (viewDecl.$type === 'ng1-to-ng2' || typeof viewDecl.component === 'function') {\n          // Update the view config.\n          // Override default ng1 `component:` behavior (of defining a templateProvider)\n          // with a <ui-view-ng-upgrade> adapter directive template\n          viewDecl.$type = 'ng1-to-ng2';\n          viewDecl.templateProvider = null;\n          viewDecl.template = `<ui-view-ng-upgrade name='${viewDecl.$uiViewName}'></ui-view-ng-upgrade>`;\n        }\n      });\n      return views;\n    });\n  },\n]);\n\n// UI-Router ViewConfig factories take a view declaration object from a state.views: { foo: <ViewDeclaration> }\n// and return a runtime config object (a ViewConfig)\nupgradeModule.run([\n  '$view',\n  '$templateFactory',\n  ($view: ViewService, $templateFactory: any) => {\n    // Register a ViewConfig factory for views of type `ng2`\n    $view._pluginapi._viewConfigFactory(\n      'ng2',\n      (path: PathNode[], config: Ng2ViewDeclaration) => new Ng2ViewConfig(path, config)\n    );\n\n    // Register a ViewConfig factory for views of type `ng1-to-ng2`.\n    // Returns both an ng1 config and an ng2 config allowing either ng1 or ng2 ui-view components to be targeted.\n    $view._pluginapi._viewConfigFactory('ng1-to-ng2', (path: PathNode[], config: Ng2ViewDeclaration) => {\n      const ng1ViewConfig: ViewConfig = <any>(\n        new Ng1ViewConfig(<any>path, <any>Object.assign({}, config, { $type: 'ng1' }), $templateFactory)\n      );\n      const ng2ViewConfig: ViewConfig = <any>(\n        new Ng2ViewConfig(<any>path, <any>Object.assign({}, config, { $type: 'ng2' }))\n      );\n\n      return [ng2ViewConfig, ng1ViewConfig];\n    });\n  },\n]);\n"]}