@c8y/ngx-components
Version:
Angular modules for Cumulocity IoT applications
169 lines • 23.6 kB
JavaScript
import { importProvidersFrom, Injectable, InjectionToken, Injector } from '@angular/core';
import { Router, ROUTES } from '@angular/router';
import { flatten } from 'lodash';
import { distinctUntilChanged, filter, shareReplay, take } from 'rxjs/operators';
import { ExtensionPointWithoutStateForPlugins, fromTriggerOnce, getInjectedHooks, hookGeneric, InjectionType } from '../common/extension-hooks';
import { OptionsService } from '../common/options.service';
import { PluginsResolveService } from '../plugins';
import { ContextRouteService } from './context-route.service';
import { ViewContext } from './router.model';
import * as i0 from "@angular/core";
import * as i1 from "@angular/router";
import * as i2 from "./context-route.service";
import * as i3 from "../plugins";
import * as i4 from "../common/options.service";
/**
* A hook to use for Multi Provider extension.
* @deprecated Consider using the `hookRoute` function instead.
*/
export const HOOK_ROUTE = new InjectionToken('HOOK_ROUTE');
/**
* You can either provide a single `Route` as parameter:
* ```typescript
* hookRoute(...)
* ```
*
* Or an array to directly register multiple:
* ```typescript
* hookRoute([...])
* ```
*
* Or you provide an Service that implements `ExtensionFactory<Route>`
* ```typescript
* export class MyRouteFactory implements ExtensionFactory<Route> {...}
* ...
* hookRoute(MyRouteFactory)
* ```
* A typed alternative to `HOOK_ROUTE`.
* @param route The `Route`'s or `ExtensionFactory` to be provided.
* @returns An `Provider` to be provided in your module.
*/
export function hookRoute(route, options) {
return hookGeneric(route, HOOK_ROUTE, options);
}
/**
* A service which defines routes for the application. You can use
* HOOK_ROUTES or pass
*/
export class RouterService extends ExtensionPointWithoutStateForPlugins {
constructor(rootInjector, router, contextRouteService, plugins, options) {
super(rootInjector, plugins);
this.router = router;
this.contextRouteService = contextRouteService;
this.state = new Map();
this.items$ = this.setupItemsObservable();
// We are doing a self subscription to add the new routes
// to the router configuration.
this.items$.subscribe((routes) => {
const toAddRoutes = routes.filter((route) => {
const path = `${route.context || ''}${route.path}`;
const isAlreadyAdded = this.state.has(path);
if (!isAlreadyAdded) {
this.state.set(path, route);
}
return !isAlreadyAdded;
});
this.addRoute(toAddRoutes);
});
plugins.pluginDetails$.subscribe(({ moduleRef, remoteNgModule }) => {
this.resolveRouterForChildRoutes(moduleRef, remoteNgModule);
});
// only needed in case of pure angular application
// otherwise handled by bridge service
if (!options.upgrade) {
plugins.allPluginsLoaded$
.pipe(filter(tmp => !!tmp), take(1))
.subscribe(() => {
this.router.initialNavigation();
});
}
}
/**
* Refresh the current context
*/
refresh() {
super.refresh();
this.contextRouteService.refreshContext();
}
/**
* Add a new route to the router configuration or a context.
* @param route The route to add
*/
addRoute(route) {
this.addRoutes(Array.isArray(route) ? route : [route]);
}
/**
* Determines if the given MO is an group or an device and returns
* the correct href to link correctly to that MO.
* @param groupOrDevice The MO of a group or the device.
* @param prefix How should the link be prefixed.
*/
getHref(groupOrDevice, prefix = '#/') {
if (groupOrDevice.c8y_IsDeviceGroup || groupOrDevice.c8y_IsDynamicGroup) {
return `${prefix}${ViewContext.Group.replace(':id', groupOrDevice.id)}`;
}
return `${prefix}${ViewContext.Device.replace(':id', groupOrDevice.id)}`;
}
setupItemsObservable() {
return fromTriggerOnce(this.router, this.refresh$, [
getInjectedHooks(HOOK_ROUTE, this.injectors, InjectionType.ROUTE),
() => this.factories
]).pipe(distinctUntilChanged(), shareReplay(1));
}
addRoutes(routes) {
// Empty route needs to be last as of navigation to angularjs routes
// if ** route hit, the angularjs routes are loaded.
const emptyRoute = this.router.config.find(r => r.path === '**');
const rootContextRoutes = this.findAllRootContextRoutes([...this.router.config, ...routes]);
this.router.resetConfig([
...this.router.config.filter(r => r.path !== '**'),
...routes.map((r) => this.convertRoute(rootContextRoutes, r)),
emptyRoute
].filter(Boolean));
}
convertRoute(rootContextRoutes, route) {
if (route.context) {
rootContextRoutes.forEach((r) => {
if (r.rootContext === route.context) {
r.children = [route, ...(r.children || [])];
}
});
return;
}
return route;
}
findAllRootContextRoutes(routes) {
const result = [];
routes.forEach(route => {
if (route.rootContext) {
result.push(route);
}
if (route.children) {
const childRoutes = this.findAllRootContextRoutes(route.children);
result.push(...childRoutes);
}
});
return result;
}
resolveRouterForChildRoutes(moduleRef, remoteNgModule) {
// NOTE: stolen from lazy loaded routes from Angular itself.
// https://github.com/angular/angular/blob/da58801f95c66c201e332189af25702bdd722f3f/packages/router/src/router_config_loader.ts#L103-L108
const rawRoutes = flatten(moduleRef.injector.get(ROUTES, [], { self: true, optional: true }));
if (rawRoutes.length > 0) {
const routeWithInjector = rawRoutes.map(route => {
route.providers = [importProvidersFrom(remoteNgModule)];
return route;
});
this.addRoute(routeWithInjector);
}
}
static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: RouterService, deps: [{ token: i0.Injector }, { token: i1.Router }, { token: i2.ContextRouteService }, { token: i3.PluginsResolveService }, { token: i4.OptionsService }], target: i0.ɵɵFactoryTarget.Injectable }); }
static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: RouterService, providedIn: 'root' }); }
}
i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: RouterService, decorators: [{
type: Injectable,
args: [{
providedIn: 'root'
}]
}], ctorParameters: () => [{ type: i0.Injector }, { type: i1.Router }, { type: i2.ContextRouteService }, { type: i3.PluginsResolveService }, { type: i4.OptionsService }] });
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"router.service.js","sourceRoot":"","sources":["../../../../core/router/router.service.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  importProvidersFrom,\n  Injectable,\n  InjectionToken,\n  Injector,\n  NgModuleRef\n} from '@angular/core';\nimport { Router, Routes, ROUTES } from '@angular/router';\nimport { IManagedObject } from '@c8y/client';\nimport { flatten } from 'lodash';\nimport { Observable } from 'rxjs';\nimport { distinctUntilChanged, filter, shareReplay, take } from 'rxjs/operators';\nimport {\n  ExtensionFactory,\n  ExtensionPointWithoutStateForPlugins,\n  fromTriggerOnce,\n  GenericHookOptions,\n  GenericHookType,\n  getInjectedHooks,\n  hookGeneric,\n  InjectionType\n} from '../common/extension-hooks';\nimport { OptionsService } from '../common/options.service';\nimport { PluginsResolveService } from '../plugins';\nimport { ContextRouteService } from './context-route.service';\nimport { Route, RouteFactory, ViewContext, ViewContextRootRoute } from './router.model';\n\n/**\n * An extension HOOK can use either a pure value:\n * ```typescript\n *  { provide: HOOK_X, useValue: { ...hookValue }, multi: true }\n * ```\n *\n * Or an array to directly register multiple:\n * ```typescript\n *  { provide: HOOK_X, useValue: [{ ...hookValues }], multi: true }\n * ```\n *\n * Or an ExtensionFactory which allows to define a get() function. This function\n * gets called on each navigation with the current route and can return values\n * async (observable or promise).\n * ```typescript\n *  { provide: HOOK_X, useFactory: { get: (route) => doSomethingAsync(route) }, multi: true }\n * ```\n */\nexport type RouteExtension = Route | Route[] | ExtensionFactory<Route>;\n\n/**\n * A hook to use for Multi Provider extension.\n * @deprecated Consider using the `hookRoute` function instead.\n */\nexport const HOOK_ROUTE = new InjectionToken<RouteFactory>('HOOK_ROUTE');\n\n/**\n * You can either provide a single `Route` as parameter:\n * ```typescript\n *  hookRoute(...)\n * ```\n *\n * Or an array to directly register multiple:\n * ```typescript\n *  hookRoute([...])\n * ```\n *\n * Or you provide an Service that implements `ExtensionFactory<Route>`\n * ```typescript\n *  export class MyRouteFactory implements ExtensionFactory<Route> {...}\n *  ...\n *  hookRoute(MyRouteFactory)\n * ```\n * A typed alternative to `HOOK_ROUTE`.\n * @param route The `Route`'s or `ExtensionFactory` to be provided.\n * @returns An `Provider` to be provided in your module.\n */\nexport function hookRoute(route: GenericHookType<Route>, options?: Partial<GenericHookOptions>) {\n  return hookGeneric<Route>(route, HOOK_ROUTE, options);\n}\n\n/**\n * A service which defines routes for the application. You can use\n * HOOK_ROUTES or pass\n */\n@Injectable({\n  providedIn: 'root'\n})\nexport class RouterService extends ExtensionPointWithoutStateForPlugins<Route> {\n  readonly state = new Map<string, Route>();\n\n  constructor(\n    rootInjector: Injector,\n    public router: Router,\n    private contextRouteService: ContextRouteService,\n    plugins: PluginsResolveService,\n    options: OptionsService\n  ) {\n    super(rootInjector, plugins);\n    this.items$ = this.setupItemsObservable();\n\n    // We are doing a self subscription to add the new routes\n    // to the router configuration.\n    this.items$.subscribe((routes: Route[]) => {\n      const toAddRoutes = routes.filter((route: Route) => {\n        const path = `${route.context || ''}${route.path}`;\n        const isAlreadyAdded = this.state.has(path);\n        if (!isAlreadyAdded) {\n          this.state.set(path, route);\n        }\n        return !isAlreadyAdded;\n      });\n      this.addRoute(toAddRoutes);\n    });\n\n    plugins.pluginDetails$.subscribe(({ moduleRef, remoteNgModule }) => {\n      this.resolveRouterForChildRoutes(moduleRef, remoteNgModule);\n    });\n\n    // only needed in case of pure angular application\n    // otherwise handled by bridge service\n    if (!options.upgrade) {\n      plugins.allPluginsLoaded$\n        .pipe(\n          filter(tmp => !!tmp),\n          take(1)\n        )\n        .subscribe(() => {\n          this.router.initialNavigation();\n        });\n    }\n  }\n\n  /**\n   * Refresh the current context\n   */\n  refresh() {\n    super.refresh();\n    this.contextRouteService.refreshContext();\n  }\n\n  /**\n   * Add a new route to the router configuration or a context.\n   * @param route The route to add\n   */\n  addRoute(route: Route | Route[]) {\n    this.addRoutes(Array.isArray(route) ? route : [route]);\n  }\n\n  /**\n   * Determines if the given MO is an group or an device and returns\n   * the correct href to link correctly to that MO.\n   * @param groupOrDevice The MO of a group or the device.\n   * @param prefix How should the link be prefixed.\n   */\n  getHref(groupOrDevice: IManagedObject, prefix = '#/'): string {\n    if (groupOrDevice.c8y_IsDeviceGroup || groupOrDevice.c8y_IsDynamicGroup) {\n      return `${prefix}${ViewContext.Group.replace(':id', groupOrDevice.id)}`;\n    }\n    return `${prefix}${ViewContext.Device.replace(':id', groupOrDevice.id)}`;\n  }\n\n  protected setupItemsObservable(): Observable<Route[]> {\n    return fromTriggerOnce<Route>(this.router, this.refresh$, [\n      getInjectedHooks<Route>(HOOK_ROUTE, this.injectors, InjectionType.ROUTE),\n      () => this.factories\n    ]).pipe(distinctUntilChanged(), shareReplay(1));\n  }\n\n  private addRoutes(routes) {\n    // Empty route needs to be last as of navigation to angularjs routes\n    // if ** route hit, the angularjs routes are loaded.\n    const emptyRoute = this.router.config.find(r => r.path === '**');\n    const rootContextRoutes = this.findAllRootContextRoutes([...this.router.config, ...routes]);\n\n    this.router.resetConfig(\n      [\n        ...this.router.config.filter(r => r.path !== '**'),\n        ...routes.map((r: Route) => this.convertRoute(rootContextRoutes, r)),\n        emptyRoute\n      ].filter(Boolean)\n    );\n  }\n\n  private convertRoute(rootContextRoutes: Routes, route: Route) {\n    if (route.context) {\n      rootContextRoutes.forEach((r: ViewContextRootRoute) => {\n        if (r.rootContext === route.context) {\n          r.children = [route, ...(r.children || [])];\n        }\n      });\n      return;\n    }\n    return route;\n  }\n\n  private findAllRootContextRoutes(routes: Routes): ViewContextRootRoute[] {\n    const result: ViewContextRootRoute[] = [];\n    routes.forEach(route => {\n      if ((route as ViewContextRootRoute).rootContext) {\n        result.push(route as ViewContextRootRoute);\n      }\n      if (route.children) {\n        const childRoutes = this.findAllRootContextRoutes(route.children);\n        result.push(...childRoutes);\n      }\n    });\n    return result;\n  }\n\n  private resolveRouterForChildRoutes(moduleRef: NgModuleRef<any>, remoteNgModule: any) {\n    // NOTE: stolen from lazy loaded routes from Angular itself.\n    // https://github.com/angular/angular/blob/da58801f95c66c201e332189af25702bdd722f3f/packages/router/src/router_config_loader.ts#L103-L108\n    const rawRoutes = flatten(moduleRef.injector.get(ROUTES, [], { self: true, optional: true }));\n\n    if (rawRoutes.length > 0) {\n      const routeWithInjector = rawRoutes.map(route => {\n        route.providers = [importProvidersFrom(remoteNgModule)];\n        return route;\n      });\n      this.addRoute(routeWithInjector);\n    }\n  }\n}\n"]}