@c8y/ngx-components/esm2022/core/navigator/navigator.service.mjs

Angular modules for Cumulocity IoT applications

import { Injectable, InjectionToken, Injector } from '@angular/core';
import { Router } from '@angular/router';
import { distinctUntilChanged, map, shareReplay } from 'rxjs/operators';
import { fromTriggerOnce, hookGeneric, getInjectedHooks, sortByPriority, stateToFactory, ExtensionPointForPlugins } from '../common/extension-hooks';
import { PluginsResolveService } from '../plugins/plugins-resolve.service';
import { NavigatorNodeRoot } from './navigator-node-root';
import * as i0 from "@angular/core";
import * as i1 from "@angular/router";
import * as i2 from "../plugins/plugins-resolve.service";
/**
 * A hook to use for Multi Provider extension.
 * @deprecated Consider using the `hookNavigator` function instead.
 */
export const HOOK_NAVIGATOR_NODES = new InjectionToken('HOOK_NAVIGATOR_NODES');
/**
 * You can either provide a single `NavigatorNode` or `NavigatorNodeData` as parameter:
 * ```typescript
 *  hookNavigator(...)
 * ```
 *
 * Or an array to directly register multiple:
 * ```typescript
 *  hookNavigator([...])
 * ```
 *
 * Or you provide an Service that implements `ExtensionFactory<NavigatorNode | NavigatorNodeData>`
 * ```typescript
 *  export class MyNavigatorFactory implements ExtensionFactory<NavigatorNode | NavigatorNodeData> {...}
 *  ...
 *  hookNavigator(MyNavigatorFactory)
 * ```
 * A typed alternative to `HOOK_NAVIGATOR_NODES`.
 * @param nodes The `NavigatorNode`'s, `NavigatorNodeData`'s or `ExtensionFactory` to be provided.
 * @returns An `Provider` to be provided in your module.
 */
export function hookNavigator(nodes, options) {
    return hookGeneric(nodes, HOOK_NAVIGATOR_NODES, options);
}
/**
 * A service which defines the navigator.
 */
export class NavigatorService extends ExtensionPointForPlugins {
    constructor(rootInjector, router, plugins) {
        super(rootInjector, plugins);
        this.router = router;
        /**
         * Indicates whether the menu entry associated with the given URL should be expanded.
         */
        this.firstUrl = true;
        this.items$ = this.setupItemsObservable();
        this.hasItemsInNavigator$ = this.items$.pipe(map(({ length }) => !!length), distinctUntilChanged());
    }
    /**
     * Returns the current state.
     * @readonly
     * @returns The current set of actions.
     */
    get state() {
        return this.state$.value;
    }
    /**
     * Adds a new node to the navigator.
     * @param {NavigatorNode} node Navigator node to add.
     */
    add(node) {
        this.state.add(node);
        this.emitNewState();
    }
    /**
     * Removes a node from the navigator.
     * @param {NavigatorNode} node Navigator node to remove.
     */
    remove(node) {
        this.state.delete(node);
        this.emitNewState();
    }
    setupItemsObservable() {
        const rootNode = new NavigatorNodeRoot();
        return fromTriggerOnce(this.router, this.refresh$, [
            getInjectedHooks(HOOK_NAVIGATOR_NODES, this.injectors),
            () => this.factories,
            stateToFactory(this.state$)
        ]).pipe(distinctUntilChanged(), map((nodes) => {
            const noParent = nodes.filter(node => !node.parent);
            const withParent = nodes.filter(node => node.parent);
            // Based on the sortedNodes array, the nodes are sequentially created.
            // Nodes sorting is done in two steps to have the top-level nodes first.
            // This way, by the time we are adding a child node, the parent node is already present.
            const sortedNodes = sortByPriority(noParent).concat(sortByPriority(withParent));
            rootNode.empty();
            sortedNodes.forEach(node => rootNode.addRoot(node));
            return rootNode.children;
        }), shareReplay(1));
    }
    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: NavigatorService, deps: [{ token: i0.Injector }, { token: i1.Router }, { token: i2.PluginsResolveService }], target: i0.ɵɵFactoryTarget.Injectable }); }
    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: NavigatorService, providedIn: 'root' }); }
}
i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: NavigatorService, decorators: [{
            type: Injectable,
            args: [{
                    providedIn: 'root'
                }]
        }], ctorParameters: () => [{ type: i0.Injector }, { type: i1.Router }, { type: i2.PluginsResolveService }] });
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"navigator.service.js","sourceRoot":"","sources":["../../../../core/navigator/navigator.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, InjectionToken, Injector } from '@angular/core';\nimport { Router } from '@angular/router';\nimport { Observable } from 'rxjs';\nimport { distinctUntilChanged, map, shareReplay } from 'rxjs/operators';\nimport {\n  ExtensionFactory,\n  fromTriggerOnce,\n  GenericHookType,\n  hookGeneric,\n  getInjectedHooks,\n  sortByPriority,\n  stateToFactory,\n  ExtensionPointForPlugins,\n  GenericHookOptions\n} from '../common/extension-hooks';\nimport { PluginsResolveService } from '../plugins/plugins-resolve.service';\nimport { NavigatorNode } from './navigator-node';\nimport { NavigatorNodeData } from './navigator-node-data';\nimport { NavigatorNodeRoot } from './navigator-node-root';\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 */\ntype NavigatorExtension = NavigatorNode | NavigatorNode[] | ExtensionFactory<NavigatorNode>;\n\n/**\n * A hook to use for Multi Provider extension.\n * @deprecated Consider using the `hookNavigator` function instead.\n */\nexport const HOOK_NAVIGATOR_NODES = new InjectionToken<NavigatorExtension[]>(\n  'HOOK_NAVIGATOR_NODES'\n);\n\n/**\n * You can either provide a single `NavigatorNode` or `NavigatorNodeData` as parameter:\n * ```typescript\n *  hookNavigator(...)\n * ```\n *\n * Or an array to directly register multiple:\n * ```typescript\n *  hookNavigator([...])\n * ```\n *\n * Or you provide an Service that implements `ExtensionFactory<NavigatorNode | NavigatorNodeData>`\n * ```typescript\n *  export class MyNavigatorFactory implements ExtensionFactory<NavigatorNode | NavigatorNodeData> {...}\n *  ...\n *  hookNavigator(MyNavigatorFactory)\n * ```\n * A typed alternative to `HOOK_NAVIGATOR_NODES`.\n * @param nodes The `NavigatorNode`'s, `NavigatorNodeData`'s or `ExtensionFactory` to be provided.\n * @returns An `Provider` to be provided in your module.\n */\nexport function hookNavigator(\n  nodes: GenericHookType<NavigatorNode | NavigatorNodeData>,\n  options?: Partial<GenericHookOptions>\n) {\n  return hookGeneric<NavigatorNode | NavigatorNodeData>(nodes, HOOK_NAVIGATOR_NODES, options);\n}\n\n/**\n * A service which defines the navigator.\n */\n@Injectable({\n  providedIn: 'root'\n})\nexport class NavigatorService extends ExtensionPointForPlugins<NavigatorNode> {\n  /**\n   * Indicates whether the menu entry associated with the given URL should be expanded.\n   */\n  firstUrl = true;\n  hasItemsInNavigator$: Observable<boolean>;\n\n  constructor(\n    rootInjector: Injector,\n    private router: Router,\n    plugins: PluginsResolveService\n  ) {\n    super(rootInjector, plugins);\n    this.items$ = this.setupItemsObservable();\n    this.hasItemsInNavigator$ = this.items$.pipe(\n      map(({ length }) => !!length),\n      distinctUntilChanged()\n    );\n  }\n\n  /**\n   * Returns the current state.\n   * @readonly\n   * @returns The current set of actions.\n   */\n  get state(): Set<NavigatorNode> {\n    return this.state$.value;\n  }\n\n  /**\n   * Adds a new node to the navigator.\n   * @param {NavigatorNode} node Navigator node to add.\n   */\n  add(node: NavigatorNode) {\n    this.state.add(node);\n    this.emitNewState();\n  }\n\n  /**\n   * Removes a node from the navigator.\n   * @param {NavigatorNode} node Navigator node to remove.\n   */\n  remove(node: NavigatorNode) {\n    this.state.delete(node);\n    this.emitNewState();\n  }\n\n  protected setupItemsObservable(): Observable<NavigatorNode[]> {\n    const rootNode = new NavigatorNodeRoot();\n    return fromTriggerOnce<NavigatorExtension>(this.router, this.refresh$, [\n      getInjectedHooks<NavigatorNode>(HOOK_NAVIGATOR_NODES, this.injectors),\n      () => this.factories,\n      stateToFactory(this.state$)\n    ]).pipe(\n      distinctUntilChanged(),\n      map((nodes: Partial<NavigatorNodeData[]>) => {\n        const noParent = nodes.filter(node => !node.parent);\n        const withParent = nodes.filter(node => node.parent);\n\n        // Based on the sortedNodes array, the nodes are sequentially created.\n        // Nodes sorting is done in two steps to have the top-level nodes first.\n        // This way, by the time we are adding a child node, the parent node is already present.\n        const sortedNodes = sortByPriority(noParent).concat(sortByPriority(withParent));\n        rootNode.empty();\n        sortedNodes.forEach(node => rootNode.addRoot(node));\n        return rootNode.children;\n      }),\n      shareReplay(1)\n    );\n  }\n}\n"]}