@ngqp/core
Version:
314 lines • 53.9 kB
JavaScript
import { Inject, Injectable, isDevMode, Optional } from '@angular/core';
import { EMPTY, forkJoin, from, Subject, zip } from 'rxjs';
import { catchError, concatMap, debounceTime, distinctUntilChanged, filter, map, startWith, switchMap, takeUntil, tap } from 'rxjs/operators';
import { compareParamMaps, filterParamMap, isMissing, isPresent, NOP } from '../util';
import { PartitionedQueryParam } from '../model/query-param';
import { NGQP_ROUTER_ADAPTER, NGQP_ROUTER_OPTIONS } from '../router-adapter/router-adapter.interface';
/** @internal */
function isMultiQueryParam(queryParam) {
return queryParam.multi;
}
/** @internal */
class NavigationData {
constructor(params, synthetic = false) {
this.params = params;
this.synthetic = synthetic;
}
}
/**
* Service implementing the synchronization logic
*
* This service is the key to the synchronization process by binding a {@link QueryParamGroup}
* to the router.
*
* @internal
*/
export class QueryParamGroupService {
constructor(routerAdapter, globalRouterOptions) {
this.routerAdapter = routerAdapter;
this.globalRouterOptions = globalRouterOptions;
/** The {@link QueryParamGroup} to bind. */
this.queryParamGroup = null;
/** List of {@link QueryParamAccessor} registered to this service. */
this.directives = new Map();
/**
* Queue of navigation parameters
*
* A queue is used for navigations as we need to make sure all parameter changes
* are executed in sequence as otherwise navigations might overwrite each other.
*/
this.queue$ = new Subject();
/** @ignore */
this.synchronizeRouter$ = new Subject();
/** @ignore */
this.destroy$ = new Subject();
this.setupNavigationQueue();
}
/** @ignore */
ngOnDestroy() {
var _a, _b, _c;
this.destroy$.next();
this.destroy$.complete();
this.synchronizeRouter$.complete();
(_a = this.queryParamGroup) === null || _a === void 0 ? void 0 : _a._clearChangeFunctions();
if ((_c = (_b = this.queryParamGroup) === null || _b === void 0 ? void 0 : _b.options) === null || _c === void 0 ? void 0 : _c.clearOnDestroy) {
const nullParams = Object.values(this.queryParamGroup.queryParams)
.map(queryParam => this.wrapIntoPartition(queryParam))
.map(partitionedQueryParam => partitionedQueryParam.queryParams.map(queryParam => queryParam.urlParam))
.reduce((a, b) => [...a, ...b], [])
.map(urlParam => ({ [urlParam]: null }))
.reduce((a, b) => (Object.assign(Object.assign({}, a), b)), {});
this.routerAdapter.navigate(nullParams, {
replaceUrl: true,
}).then();
}
}
/**
* Uses the given {@link QueryParamGroup} for synchronization.
*/
setQueryParamGroup(queryParamGroup) {
// FIXME: If this is called when we already have a group, we probably need to do
// some cleanup first.
if (this.queryParamGroup) {
throw new Error(`A QueryParamGroup has already been setup. Changing the group is currently not supported.`);
}
this.queryParamGroup = queryParamGroup;
this.startSynchronization();
}
/**
* Registers a {@link QueryParamAccessor}.
*/
registerQueryParamDirective(directive) {
if (!directive.valueAccessor) {
throw new Error(`No value accessor found for the form control. Please make sure to implement ControlValueAccessor on this component.`);
}
// Capture the name here, particularly for the queue below to avoid re-evaluating
// it as it might change over time.
const queryParamName = directive.name;
const partitionedQueryParam = this.getQueryParamAsPartition(queryParamName);
// Chances are that we read the initial route before a directive has been registered here.
// The value in the model will be correct, but we need to sync it to the view once initially.
directive.valueAccessor.writeValue(partitionedQueryParam.value);
// Proxy updates from the view to debounce them (if needed).
const queues = partitionedQueryParam.queryParams.map(() => new Subject());
zip(...queues.map((queue$, index) => {
const queryParam = partitionedQueryParam.queryParams[index];
return queue$.pipe(isPresent(queryParam.debounceTime) ? debounceTime(queryParam.debounceTime) : tap());
})).pipe(
// Do not synchronize while the param is detached from the group
filter(() => !!this.getQueryParamGroup().get(queryParamName)), map((newValue) => this.getParamsForValue(partitionedQueryParam, partitionedQueryParam.reduce(newValue))), takeUntil(this.destroy$)).subscribe(params => this.enqueueNavigation(new NavigationData(params)));
directive.valueAccessor.registerOnChange((newValue) => {
const partitioned = partitionedQueryParam.partition(newValue);
queues.forEach((queue$, index) => queue$.next(partitioned[index]));
});
this.directives.set(queryParamName, [...(this.directives.get(queryParamName) || []), directive]);
}
/**
* Deregisters a {@link QueryParamAccessor} by referencing its name.
*/
deregisterQueryParamDirective(queryParamName) {
if (!queryParamName) {
return;
}
const directives = this.directives.get(queryParamName);
if (!directives) {
return;
}
directives.forEach(directive => {
directive.valueAccessor.registerOnChange(NOP);
directive.valueAccessor.registerOnTouched(NOP);
});
this.directives.delete(queryParamName);
const queryParam = this.getQueryParamGroup().get(queryParamName);
if (queryParam) {
queryParam._clearChangeFunctions();
}
}
startSynchronization() {
this.setupGroupChangeListener();
this.setupParamChangeListeners();
this.setupRouterListener();
this.watchNewParams();
}
/** Listens for programmatic changes on group level and synchronizes to the router. */
setupGroupChangeListener() {
this.getQueryParamGroup()._registerOnChange((newValue) => {
if (newValue === null) {
throw new Error(`Received null value from QueryParamGroup.`);
}
let params = {};
Object.keys(newValue).forEach(queryParamName => {
const queryParam = this.getQueryParamGroup().get(queryParamName);
if (isMissing(queryParam)) {
return;
}
params = Object.assign(Object.assign({}, params), this.getParamsForValue(queryParam, newValue[queryParamName]));
});
this.enqueueNavigation(new NavigationData(params, true));
});
}
/** Listens for programmatic changes on parameter level and synchronizes to the router. */
setupParamChangeListeners() {
Object.keys(this.getQueryParamGroup().queryParams)
.forEach(queryParamName => this.setupParamChangeListener(queryParamName));
}
setupParamChangeListener(queryParamName) {
const queryParam = this.getQueryParamGroup().get(queryParamName);
if (!queryParam) {
throw new Error(`No param in group found for name ${queryParamName}`);
}
queryParam._registerOnChange((newValue) => this.enqueueNavigation(new NavigationData(this.getParamsForValue(queryParam, newValue), true)));
}
/** Listens for changes in the router and synchronizes to the model. */
setupRouterListener() {
this.synchronizeRouter$.pipe(startWith(undefined), switchMap(() => this.routerAdapter.queryParamMap.pipe(
// We want to ignore changes to query parameters which aren't related to this
// particular group; however, we do need to react if one of our parameters has
// vanished when it was set before.
distinctUntilChanged((previousMap, currentMap) => {
const keys = Object.values(this.getQueryParamGroup().queryParams)
.map(queryParam => this.wrapIntoPartition(queryParam))
.map(partitionedQueryParam => partitionedQueryParam.queryParams.map(queryParam => queryParam.urlParam))
.reduce((a, b) => [...a, ...b], []);
// It is important that we filter the maps only here so that both are filtered
// with the same set of keys; otherwise, e.g. removing a parameter from the group
// would interfere.
return compareParamMaps(filterParamMap(previousMap, keys), filterParamMap(currentMap, keys));
}))), switchMap(queryParamMap => {
// We need to capture this right here since this is only set during the on-going navigation.
const synthetic = this.isSyntheticNavigation();
const queryParamNames = Object.keys(this.getQueryParamGroup().queryParams);
return forkJoin(...queryParamNames
.map(queryParamName => {
const partitionedQueryParam = this.getQueryParamAsPartition(queryParamName);
return forkJoin(...partitionedQueryParam.queryParams
.map(queryParam => isMultiQueryParam(queryParam)
? queryParam.deserializeValue(queryParamMap.getAll(queryParam.urlParam))
: queryParam.deserializeValue(queryParamMap.get(queryParam.urlParam)))).pipe(map(newValues => partitionedQueryParam.reduce(newValues)), tap(newValue => {
const directives = this.directives.get(queryParamName);
if (directives) {
directives.forEach(directive => directive.valueAccessor.writeValue(newValue));
}
}), map(newValue => {
return { [queryParamName]: newValue };
}), takeUntil(this.destroy$));
})).pipe(map((values) => values.reduce((groupValue, value) => {
return Object.assign(Object.assign({}, groupValue), value);
}, {})), tap(groupValue => this.getQueryParamGroup().setValue(groupValue, {
emitEvent: !synthetic,
emitModelToViewChange: false,
})));
}), takeUntil(this.destroy$)).subscribe();
}
/** Listens for newly added parameters and starts synchronization for them. */
watchNewParams() {
this.getQueryParamGroup().queryParamAdded$.pipe(takeUntil(this.destroy$)).subscribe(queryParamName => {
this.setupParamChangeListener(queryParamName);
this.synchronizeRouter$.next();
});
}
/** Returns true if the current navigation is synthetic. */
isSyntheticNavigation() {
const navigation = this.routerAdapter.getCurrentNavigation();
if (!navigation || navigation.trigger !== 'imperative') {
// When using the back / forward buttons, the state is passed along with it, even though
// for us it's now a navigation initiated by the user. Therefore, a navigation can only
// be synthetic if it has been triggered imperatively.
// See https://github.com/angular/angular/issues/28108.
return false;
}
return navigation.extras && navigation.extras.state && navigation.extras.state['synthetic'];
}
/** Subscribes to the parameter queue and executes navigations in sequence. */
setupNavigationQueue() {
this.queue$.pipe(takeUntil(this.destroy$), concatMap(data => this.navigateSafely(data))).subscribe();
}
navigateSafely(data) {
return from(this.routerAdapter.navigate(data.params, Object.assign(Object.assign({}, this.routerOptions), { state: { synthetic: data.synthetic } }))).pipe(catchError((err) => {
if (isDevMode()) {
console.error(`There was an error while navigating`, err);
}
return EMPTY;
}));
}
/** Sends a change of parameters to the queue. */
enqueueNavigation(data) {
this.queue$.next(data);
}
/**
* Returns the full set of parameters given a value for a parameter model.
*
* This consists mainly of properly serializing the model value and ensuring to take
* side effect changes into account that may have been configured.
*/
getParamsForValue(queryParam, value) {
const partitionedQueryParam = this.wrapIntoPartition(queryParam);
const partitioned = partitionedQueryParam.partition(value);
const combinedParams = partitionedQueryParam.queryParams
.map((current, index) => isMissing(current.combineWith) ? null : current.combineWith(partitioned[index]))
.reduce((a, b) => {
return Object.assign(Object.assign({}, (a || {})), (b || {}));
}, {});
const newValues = partitionedQueryParam.queryParams
.map((current, index) => {
return {
[current.urlParam]: current.serializeValue(partitioned[index]),
};
})
.reduce((a, b) => {
return Object.assign(Object.assign({}, a), b);
}, {});
// Note that we list the side-effect parameters first so that our actual parameter can't be
// overridden by it.
return Object.assign(Object.assign({}, combinedParams), newValues);
}
/**
* Returns the current set of options to pass to the router.
*
* This merges the global configuration with the group specific configuration.
*/
get routerOptions() {
const groupOptions = this.getQueryParamGroup().routerOptions;
return Object.assign(Object.assign({}, (this.globalRouterOptions || {})), (groupOptions || {}));
}
/**
* Returns the query parameter with the given name as a partition.
*
* If the query parameter is partitioned, it is returned unchanged. Otherwise
* it is wrapped into a noop partition. This makes it easy to operate on
* query parameters independent of whether they are partitioned.
*/
getQueryParamAsPartition(queryParamName) {
const queryParam = this.getQueryParamGroup().get(queryParamName);
if (!queryParam) {
throw new Error(`Could not find query param with name ${queryParamName}. Did you forget to add it to your QueryParamGroup?`);
}
return this.wrapIntoPartition(queryParam);
}
/**
* Wraps a query parameter into a partition if it isn't already.
*/
wrapIntoPartition(queryParam) {
if (queryParam instanceof PartitionedQueryParam) {
return queryParam;
}
return new PartitionedQueryParam([queryParam], {
partition: value => [value],
reduce: values => values[0],
});
}
getQueryParamGroup() {
if (!this.queryParamGroup) {
throw new Error(`No QueryParamGroup has been registered yet.`);
}
return this.queryParamGroup;
}
}
QueryParamGroupService.decorators = [
{ type: Injectable }
];
QueryParamGroupService.ctorParameters = () => [
{ type: undefined, decorators: [{ type: Inject, args: [NGQP_ROUTER_ADAPTER,] }] },
{ type: undefined, decorators: [{ type: Optional }, { type: Inject, args: [NGQP_ROUTER_OPTIONS,] }] }
];
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"query-param-group.service.js","sourceRoot":"../../../../projects/ngqp/core/src/","sources":["lib/directives/query-param-group.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Inject, Injectable, isDevMode, OnDestroy, Optional } from '@angular/core';\nimport { Params } from '@angular/router';\nimport { EMPTY, forkJoin, from, Observable, Subject, zip } from 'rxjs';\nimport {\n    catchError,\n    concatMap,\n    debounceTime,\n    distinctUntilChanged,\n    filter,\n    map,\n    startWith,\n    switchMap,\n    takeUntil,\n    tap\n} from 'rxjs/operators';\nimport { compareParamMaps, filterParamMap, isMissing, isPresent, NOP } from '../util';\nimport { QueryParamGroup } from '../model/query-param-group';\nimport { MultiQueryParam, PartitionedQueryParam, QueryParam } from '../model/query-param';\nimport { NGQP_ROUTER_ADAPTER, NGQP_ROUTER_OPTIONS, RouterAdapter, RouterOptions } from '../router-adapter/router-adapter.interface';\nimport { QueryParamAccessor } from './query-param-accessor.interface';\n\n/** @internal */\nfunction isMultiQueryParam<T>(queryParam: QueryParam<T> | MultiQueryParam<T>): queryParam is MultiQueryParam<T> {\n    return queryParam.multi;\n}\n\n/** @internal */\nclass NavigationData {\n    constructor(public params: Params, public synthetic: boolean = false) {\n    }\n}\n\n/**\n * Service implementing the synchronization logic\n *\n * This service is the key to the synchronization process by binding a {@link QueryParamGroup}\n * to the router.\n *\n * @internal\n */\n@Injectable()\nexport class QueryParamGroupService implements OnDestroy {\n\n    /** The {@link QueryParamGroup} to bind. */\n    private queryParamGroup: QueryParamGroup | null = null;\n\n    /** List of {@link QueryParamAccessor} registered to this service. */\n    private directives = new Map<string, QueryParamAccessor[]>();\n\n    /**\n     * Queue of navigation parameters\n     *\n     * A queue is used for navigations as we need to make sure all parameter changes\n     * are executed in sequence as otherwise navigations might overwrite each other.\n     */\n    private queue$ = new Subject<NavigationData>();\n\n    /** @ignore */\n    private synchronizeRouter$ = new Subject<void>();\n\n    /** @ignore */\n    private destroy$ = new Subject<void>();\n\n    constructor(\n        @Inject(NGQP_ROUTER_ADAPTER) private routerAdapter: RouterAdapter,\n        @Optional() @Inject(NGQP_ROUTER_OPTIONS) private globalRouterOptions: RouterOptions\n    ) {\n        this.setupNavigationQueue();\n    }\n\n    /** @ignore */\n    public ngOnDestroy() {\n        this.destroy$.next();\n        this.destroy$.complete();\n\n        this.synchronizeRouter$.complete();\n\n        this.queryParamGroup?._clearChangeFunctions();\n        if (this.queryParamGroup?.options?.clearOnDestroy) {\n            const nullParams = Object.values(this.queryParamGroup.queryParams)\n                .map(queryParam => this.wrapIntoPartition(queryParam))\n                .map(partitionedQueryParam => partitionedQueryParam.queryParams.map(queryParam => queryParam.urlParam))\n                .reduce((a, b) => [...a, ...b], [])\n                .map(urlParam => ({[urlParam]: null}))\n                .reduce((a, b) => ({...a, ...b}), {});\n            this.routerAdapter.navigate(nullParams, {\n                replaceUrl: true,\n            }).then();\n        }\n    }\n\n\n    /**\n     * Uses the given {@link QueryParamGroup} for synchronization.\n     */\n    public setQueryParamGroup(queryParamGroup: QueryParamGroup): void {\n        // FIXME: If this is called when we already have a group, we probably need to do\n        //        some cleanup first.\n        if (this.queryParamGroup) {\n            throw new Error(`A QueryParamGroup has already been setup. Changing the group is currently not supported.`);\n        }\n\n        this.queryParamGroup = queryParamGroup;\n        this.startSynchronization();\n    }\n\n    /**\n     * Registers a {@link QueryParamAccessor}.\n     */\n    public registerQueryParamDirective(directive: QueryParamAccessor): void {\n        if (!directive.valueAccessor) {\n            throw new Error(`No value accessor found for the form control. Please make sure to implement ControlValueAccessor on this component.`);\n        }\n\n        // Capture the name here, particularly for the queue below to avoid re-evaluating\n        // it as it might change over time.\n        const queryParamName = directive.name;\n        const partitionedQueryParam = this.getQueryParamAsPartition(queryParamName);\n\n        // Chances are that we read the initial route before a directive has been registered here.\n        // The value in the model will be correct, but we need to sync it to the view once initially.\n        directive.valueAccessor.writeValue(partitionedQueryParam.value);\n\n        // Proxy updates from the view to debounce them (if needed).\n        const queues = partitionedQueryParam.queryParams.map(() => new Subject<unknown>());\n        zip(\n            ...queues.map((queue$, index) => {\n                const queryParam = partitionedQueryParam.queryParams[index];\n                return queue$.pipe(\n                    isPresent(queryParam.debounceTime) ? debounceTime(queryParam.debounceTime) : tap(),\n                );\n            })\n        ).pipe(\n            // Do not synchronize while the param is detached from the group\n            filter(() => !!this.getQueryParamGroup().get(queryParamName)),\n            map((newValue: unknown[]) => this.getParamsForValue(partitionedQueryParam, partitionedQueryParam.reduce(newValue))),\n            takeUntil(this.destroy$),\n        ).subscribe(params => this.enqueueNavigation(new NavigationData(params)));\n\n        directive.valueAccessor.registerOnChange((newValue: unknown) => {\n            const partitioned = partitionedQueryParam.partition(newValue);\n            queues.forEach((queue$, index) => queue$.next(partitioned[index]));\n        });\n\n        this.directives.set(queryParamName, [...(this.directives.get(queryParamName) || []), directive]);\n    }\n\n    /**\n     * Deregisters a {@link QueryParamAccessor} by referencing its name.\n     */\n    public deregisterQueryParamDirective(queryParamName: string): void {\n        if (!queryParamName) {\n            return;\n        }\n\n        const directives = this.directives.get(queryParamName);\n        if (!directives) {\n            return;\n        }\n\n        directives.forEach(directive => {\n            directive.valueAccessor.registerOnChange(NOP);\n            directive.valueAccessor.registerOnTouched(NOP);\n        });\n\n        this.directives.delete(queryParamName);\n        const queryParam = this.getQueryParamGroup().get(queryParamName);\n        if (queryParam) {\n            queryParam._clearChangeFunctions();\n        }\n    }\n\n    private startSynchronization() {\n        this.setupGroupChangeListener();\n        this.setupParamChangeListeners();\n        this.setupRouterListener();\n\n        this.watchNewParams();\n    }\n\n    /** Listens for programmatic changes on group level and synchronizes to the router. */\n    private setupGroupChangeListener(): void {\n        this.getQueryParamGroup()._registerOnChange((newValue: Record<string, unknown> | null) => {\n            if (newValue === null) {\n                throw new Error(`Received null value from QueryParamGroup.`);\n            }\n\n            let params: Params = {};\n            Object.keys(newValue).forEach(queryParamName => {\n                const queryParam = this.getQueryParamGroup().get(queryParamName);\n                if (isMissing(queryParam)) {\n                    return;\n                }\n\n                params = { ...params, ...this.getParamsForValue(queryParam, newValue[ queryParamName ]) };\n            });\n\n            this.enqueueNavigation(new NavigationData(params, true));\n        });\n    }\n\n    /** Listens for programmatic changes on parameter level and synchronizes to the router. */\n    private setupParamChangeListeners(): void {\n        Object.keys(this.getQueryParamGroup().queryParams)\n            .forEach(queryParamName => this.setupParamChangeListener(queryParamName));\n    }\n\n    private setupParamChangeListener(queryParamName: string): void {\n        const queryParam = this.getQueryParamGroup().get(queryParamName);\n        if (!queryParam) {\n            throw new Error(`No param in group found for name ${queryParamName}`);\n        }\n\n        queryParam._registerOnChange((newValue: unknown) =>\n            this.enqueueNavigation(new NavigationData(this.getParamsForValue(queryParam, newValue), true))\n        );\n    }\n\n    /** Listens for changes in the router and synchronizes to the model. */\n    private setupRouterListener(): void {\n        this.synchronizeRouter$.pipe(\n            startWith(undefined),\n            switchMap(() => this.routerAdapter.queryParamMap.pipe(\n                // We want to ignore changes to query parameters which aren't related to this\n                // particular group; however, we do need to react if one of our parameters has\n                // vanished when it was set before.\n                distinctUntilChanged((previousMap, currentMap) => {\n                    const keys = Object.values(this.getQueryParamGroup().queryParams)\n                        .map(queryParam => this.wrapIntoPartition(queryParam))\n                        .map(partitionedQueryParam => partitionedQueryParam.queryParams.map(queryParam => queryParam.urlParam))\n                        .reduce((a, b) => [...a, ...b], []);\n\n                    // It is important that we filter the maps only here so that both are filtered\n                    // with the same set of keys; otherwise, e.g. removing a parameter from the group\n                    // would interfere.\n                    return compareParamMaps(filterParamMap(previousMap, keys), filterParamMap(currentMap, keys));\n                }),\n            )),\n            switchMap(queryParamMap => {\n                // We need to capture this right here since this is only set during the on-going navigation.\n                const synthetic = this.isSyntheticNavigation();\n                const queryParamNames = Object.keys(this.getQueryParamGroup().queryParams);\n\n                return forkJoin<Record<string, unknown>>(...queryParamNames\n                    .map(queryParamName => {\n                        const partitionedQueryParam = this.getQueryParamAsPartition(queryParamName);\n\n                        return forkJoin<unknown>(...partitionedQueryParam.queryParams\n                            .map(queryParam => isMultiQueryParam<unknown>(queryParam)\n                                ? queryParam.deserializeValue(queryParamMap.getAll(queryParam.urlParam))\n                                : queryParam.deserializeValue(queryParamMap.get(queryParam.urlParam))\n                            )\n                        ).pipe(\n                            map(newValues => partitionedQueryParam.reduce(newValues)),\n                            tap(newValue => {\n                                const directives = this.directives.get(queryParamName);\n                                if (directives) {\n                                    directives.forEach(directive => directive.valueAccessor.writeValue(newValue));\n                                }\n                            }),\n                            map(newValue => {\n                                return { [ queryParamName ]: newValue };\n                            }),\n                            takeUntil(this.destroy$),\n                        );\n                    })\n                ).pipe(\n                    map((values: Record<string, unknown>[]) => values.reduce((groupValue, value) => {\n                        return {\n                            ...groupValue,\n                            ...value,\n                        };\n                    }, {})),\n                    tap(groupValue => this.getQueryParamGroup().setValue(groupValue, {\n                        emitEvent: !synthetic,\n                        emitModelToViewChange: false,\n                    })),\n                );\n            }),\n            takeUntil(this.destroy$),\n        ).subscribe();\n    }\n\n    /** Listens for newly added parameters and starts synchronization for them. */\n    private watchNewParams(): void {\n        this.getQueryParamGroup().queryParamAdded$.pipe(\n            takeUntil(this.destroy$)\n        ).subscribe(queryParamName => {\n            this.setupParamChangeListener(queryParamName);\n            this.synchronizeRouter$.next();\n        });\n    }\n\n    /** Returns true if the current navigation is synthetic. */\n    private isSyntheticNavigation(): boolean {\n        const navigation = this.routerAdapter.getCurrentNavigation();\n        if (!navigation || navigation.trigger !== 'imperative') {\n            // When using the back / forward buttons, the state is passed along with it, even though\n            // for us it's now a navigation initiated by the user. Therefore, a navigation can only\n            // be synthetic if it has been triggered imperatively.\n            // See https://github.com/angular/angular/issues/28108.\n            return false;\n        }\n\n        return navigation.extras && navigation.extras.state && navigation.extras.state['synthetic'];\n    }\n\n    /** Subscribes to the parameter queue and executes navigations in sequence. */\n    private setupNavigationQueue() {\n        this.queue$.pipe(\n            takeUntil(this.destroy$),\n            concatMap(data => this.navigateSafely(data)),\n        ).subscribe();\n    }\n\n    private navigateSafely(data: NavigationData): Observable<boolean> {\n        return from(this.routerAdapter.navigate(data.params, {\n            ...this.routerOptions,\n            state: { synthetic: data.synthetic },\n        })).pipe(\n            catchError((err: unknown) => {\n                if (isDevMode()) {\n                    console.error(`There was an error while navigating`, err);\n                }\n\n                return EMPTY;\n            })\n        );\n    }\n\n    /** Sends a change of parameters to the queue. */\n    private enqueueNavigation(data: NavigationData): void {\n        this.queue$.next(data);\n    }\n\n    /**\n     * Returns the full set of parameters given a value for a parameter model.\n     *\n     * This consists mainly of properly serializing the model value and ensuring to take\n     * side effect changes into account that may have been configured.\n     */\n    private getParamsForValue(queryParam: QueryParam<unknown> | MultiQueryParam<unknown> | PartitionedQueryParam<unknown>, value: any): Params {\n        const partitionedQueryParam = this.wrapIntoPartition(queryParam);\n     