@ngxs/router-plugin 3.8.1 → 3.8.2-dev.master-0fd1fe5

package/esm2020/internals/index.mjs

@@ -0,0 +1,2 @@
+export * from './symbols';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9wYWNrYWdlcy9yb3V0ZXItcGx1Z2luL2ludGVybmFscy9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxXQUFXLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL3N5bWJvbHMnO1xuIl19

package/esm2020/internals/ngxs-router-plugin-internals.mjs

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './index';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibmd4cy1yb3V0ZXItcGx1Z2luLWludGVybmFscy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3BhY2thZ2VzL3JvdXRlci1wbHVnaW4vaW50ZXJuYWxzL3NyYy9uZ3hzLXJvdXRlci1wbHVnaW4taW50ZXJuYWxzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBRUgsY0FBYyxTQUFTLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEdlbmVyYXRlZCBidW5kbGUgaW5kZXguIERvIG5vdCBlZGl0LlxuICovXG5cbmV4cG9ydCAqIGZyb20gJy4vaW5kZXgnO1xuIl19

package/esm2020/internals/symbols.mjs

@@ -0,0 +1,10 @@
+import { InjectionToken } from '@angular/core';
+const NG_DEV_MODE = typeof ngDevMode === 'undefined' || ngDevMode;
+export const ɵUSER_OPTIONS = new InjectionToken(NG_DEV_MODE ? 'USER_OPTIONS' : '', { providedIn: 'root', factory: () => undefined });
+export const ɵNGXS_ROUTER_PLUGIN_OPTIONS = new InjectionToken(NG_DEV_MODE ? 'NGXS_ROUTER_PLUGIN_OPTIONS' : '', { providedIn: 'root', factory: () => ({}) });
+export function ɵcreateRouterPluginOptions(options) {
+    return {
+        navigationActionTiming: (options && options.navigationActionTiming) || 1 /* NavigationActionTiming.PreActivation */
+    };
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/src/public_api.mjs

@@ -0,0 +1,5 @@
+export { NgxsRouterPluginModule, withNgxsRouterPlugin } from './router.module';
+export { RouterState } from './router.state';
+export { RouterStateSerializer, DefaultRouterStateSerializer } from './serializer';
+export * from './router.actions';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljX2FwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3BhY2thZ2VzL3JvdXRlci1wbHVnaW4vc3JjL3B1YmxpY19hcGkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLHNCQUFzQixFQUFFLG9CQUFvQixFQUFFLE1BQU0saUJBQWlCLENBQUM7QUFDL0UsT0FBTyxFQUFFLFdBQVcsRUFBb0IsTUFBTSxnQkFBZ0IsQ0FBQztBQUMvRCxPQUFPLEVBQ0wscUJBQXFCLEVBQ3JCLDRCQUE0QixFQUU3QixNQUFNLGNBQWMsQ0FBQztBQUN0QixjQUFjLGtCQUFrQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IHsgTmd4c1JvdXRlclBsdWdpbk1vZHVsZSwgd2l0aE5neHNSb3V0ZXJQbHVnaW4gfSBmcm9tICcuL3JvdXRlci5tb2R1bGUnO1xuZXhwb3J0IHsgUm91dGVyU3RhdGUsIFJvdXRlclN0YXRlTW9kZWwgfSBmcm9tICcuL3JvdXRlci5zdGF0ZSc7XG5leHBvcnQge1xuICBSb3V0ZXJTdGF0ZVNlcmlhbGl6ZXIsXG4gIERlZmF1bHRSb3V0ZXJTdGF0ZVNlcmlhbGl6ZXIsXG4gIFNlcmlhbGl6ZWRSb3V0ZXJTdGF0ZVNuYXBzaG90XG59IGZyb20gJy4vc2VyaWFsaXplcic7XG5leHBvcnQgKiBmcm9tICcuL3JvdXRlci5hY3Rpb25zJztcbmV4cG9ydCB7XG4gIE5hdmlnYXRpb25BY3Rpb25UaW1pbmcsXG4gIE5neHNSb3V0ZXJQbHVnaW5PcHRpb25zXG59IGZyb20gJ0BuZ3hzL3JvdXRlci1wbHVnaW4vaW50ZXJuYWxzJztcbiJdfQ==

package/esm2020/src/router.actions.mjs

@@ -0,0 +1,85 @@
+/**
+ * Public event api of the router
+ */
+export class Navigate {
+    constructor(path, queryParams, extras) {
+        this.path = path;
+        this.queryParams = queryParams;
+        this.extras = extras;
+    }
+}
+Navigate.type = '[Router] Navigate';
+/**
+ *
+ * Angular Routers internal state events
+ *
+ */
+/**
+ * An action dispatched when the router starts the navigation.
+ */
+export class RouterRequest {
+    constructor(routerState, event, trigger = 'none') {
+        this.routerState = routerState;
+        this.event = event;
+        this.trigger = trigger;
+    }
+}
+RouterRequest.type = '[Router] RouterRequest';
+/**
+ * An action dispatched when the router navigates.
+ */
+export class RouterNavigation {
+    constructor(routerState, event, trigger = 'none') {
+        this.routerState = routerState;
+        this.event = event;
+        this.trigger = trigger;
+    }
+}
+RouterNavigation.type = '[Router] RouterNavigation';
+/**
+ * An action dispatched when the router cancel navigation.
+ */
+export class RouterCancel {
+    constructor(routerState, storeState, event, trigger = 'none') {
+        this.routerState = routerState;
+        this.storeState = storeState;
+        this.event = event;
+        this.trigger = trigger;
+    }
+}
+RouterCancel.type = '[Router] RouterCancel';
+/**
+ * An action dispatched when the router errors.
+ */
+export class RouterError {
+    constructor(routerState, storeState, event, trigger = 'none') {
+        this.routerState = routerState;
+        this.storeState = storeState;
+        this.event = event;
+        this.trigger = trigger;
+    }
+}
+RouterError.type = '[Router] RouterError';
+/**
+ * An action dispatched when the `ResolveEnd` event is triggered.
+ */
+export class RouterDataResolved {
+    constructor(routerState, event, trigger = 'none') {
+        this.routerState = routerState;
+        this.event = event;
+        this.trigger = trigger;
+    }
+}
+RouterDataResolved.type = '[Router] RouterDataResolved';
+/**
+ * An action dispatched when the router navigation has been finished successfully.
+ */
+export class RouterNavigated {
+    constructor(routerState, event, trigger = 'none') {
+        this.routerState = routerState;
+        this.event = event;
+        this.trigger = trigger;
+    }
+}
+RouterNavigated.type = '[Router] RouterNavigated';
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/src/router.module.mjs

@@ -0,0 +1,45 @@
+import { NgModule, makeEnvironmentProviders } from '@angular/core';
+import { NgxsModule, provideStates } from '@ngxs/store';
+import { ɵcreateRouterPluginOptions, ɵNGXS_ROUTER_PLUGIN_OPTIONS, ɵUSER_OPTIONS } from '@ngxs/router-plugin/internals';
+import { RouterState } from './router.state';
+import { DefaultRouterStateSerializer, RouterStateSerializer } from './serializer';
+import * as i0 from "@angular/core";
+import * as i1 from "@ngxs/store";
+export class NgxsRouterPluginModule {
+    static forRoot(options) {
+        return {
+            ngModule: NgxsRouterPluginModule,
+            providers: [
+                { provide: ɵUSER_OPTIONS, useValue: options },
+                {
+                    provide: ɵNGXS_ROUTER_PLUGIN_OPTIONS,
+                    useFactory: ɵcreateRouterPluginOptions,
+                    deps: [ɵUSER_OPTIONS]
+                },
+                { provide: RouterStateSerializer, useClass: DefaultRouterStateSerializer }
+            ]
+        };
+    }
+}
+/** @nocollapse */ NgxsRouterPluginModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.4", ngImport: i0, type: NgxsRouterPluginModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+/** @nocollapse */ NgxsRouterPluginModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "15.2.4", ngImport: i0, type: NgxsRouterPluginModule, imports: [i1.ɵNgxsFeatureModule] });
+/** @nocollapse */ NgxsRouterPluginModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "15.2.4", ngImport: i0, type: NgxsRouterPluginModule, imports: [NgxsModule.forFeature([RouterState])] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.4", ngImport: i0, type: NgxsRouterPluginModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [NgxsModule.forFeature([RouterState])]
+                }]
+        }] });
+export function withNgxsRouterPlugin(options) {
+    return makeEnvironmentProviders([
+        provideStates([RouterState]),
+        { provide: ɵUSER_OPTIONS, useValue: options },
+        {
+            provide: ɵNGXS_ROUTER_PLUGIN_OPTIONS,
+            useFactory: ɵcreateRouterPluginOptions,
+            deps: [ɵUSER_OPTIONS]
+        },
+        { provide: RouterStateSerializer, useClass: DefaultRouterStateSerializer }
+    ]);
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/src/router.state.mjs

@@ -0,0 +1,224 @@
+var RouterState_1;
+import { __decorate, __metadata } from "tslib";
+import { NgZone, Injectable, Injector } from '@angular/core';
+import { NavigationCancel, NavigationError, Router, RoutesRecognized, ResolveEnd, NavigationStart, NavigationEnd } from '@angular/router';
+import { Action, Selector, State, Store } from '@ngxs/store';
+import { ɵNGXS_ROUTER_PLUGIN_OPTIONS } from '@ngxs/router-plugin/internals';
+import { ReplaySubject } from 'rxjs';
+import { takeUntil } from 'rxjs/operators';
+import { Navigate, RouterCancel, RouterError, RouterNavigation, RouterDataResolved, RouterRequest, RouterNavigated } from './router.actions';
+import { RouterStateSerializer } from './serializer';
+import * as i0 from "@angular/core";
+import * as i1 from "@ngxs/store";
+import * as i2 from "@angular/router";
+import * as i3 from "./serializer";
+let RouterState = RouterState_1 = class RouterState {
+    constructor(_store, _router, _serializer, _ngZone, injector) {
+        this._store = _store;
+        this._router = _router;
+        this._serializer = _serializer;
+        this._ngZone = _ngZone;
+        /**
+         * Determines how navigation was performed by the `RouterState` itself
+         * or outside via `new Navigate(...)`
+         */
+        this._trigger = 'none';
+        /**
+         * That's the serialized state from the `Router` class
+         */
+        this._routerState = null;
+        /**
+         * That's the value of the `RouterState` state
+         */
+        this._storeState = null;
+        this._lastEvent = null;
+        this._options = null;
+        this._destroy$ = new ReplaySubject(1);
+        // Note: do not use `@Inject` since it fails on lower versions of Angular with Jest
+        // integration, it cannot resolve the token provider.
+        this._options = injector.get(ɵNGXS_ROUTER_PLUGIN_OPTIONS, null);
+        this._setUpStoreListener();
+        this._setUpRouterEventsListener();
+    }
+    static state(state) {
+        return state && state.state;
+    }
+    static url(state) {
+        return state && state.state && state.state.url;
+    }
+    ngOnDestroy() {
+        this._destroy$.next();
+    }
+    navigate(_, action) {
+        return this._ngZone.run(() => this._router.navigate(action.path, {
+            queryParams: action.queryParams,
+            ...action.extras
+        }));
+    }
+    angularRouterAction(ctx, action) {
+        ctx.setState({
+            trigger: action.trigger,
+            state: action.routerState,
+            navigationId: action.event.id
+        });
+    }
+    _setUpStoreListener() {
+        const routerState$ = this._store.select(RouterState_1).pipe(takeUntil(this._destroy$));
+        routerState$.subscribe((state) => {
+            this._navigateIfNeeded(state);
+        });
+    }
+    _navigateIfNeeded(routerState) {
+        if (routerState && routerState.trigger === 'devtools') {
+            this._storeState = this._store.selectSnapshot(RouterState_1);
+        }
+        const canSkipNavigation = !this._storeState ||
+            !this._storeState.state ||
+            !routerState ||
+            routerState.trigger === 'router' ||
+            this._router.url === this._storeState.state.url ||
+            this._lastEvent instanceof NavigationStart;
+        if (canSkipNavigation) {
+            return;
+        }
+        this._storeState = this._store.selectSnapshot(RouterState_1);
+        this._trigger = 'store';
+        this._ngZone.run(() => this._router.navigateByUrl(this._storeState.state.url));
+    }
+    _setUpRouterEventsListener() {
+        const dispatchRouterNavigationLate = this._options != null &&
+            this._options.navigationActionTiming === 2 /* NavigationActionTiming.PostActivation */;
+        let lastRoutesRecognized;
+        const events$ = this._router.events.pipe(takeUntil(this._destroy$));
+        events$.subscribe(event => {
+            this._lastEvent = event;
+            if (event instanceof NavigationStart) {
+                this._navigationStart(event);
+            }
+            else if (event instanceof RoutesRecognized) {
+                lastRoutesRecognized = event;
+                if (!dispatchRouterNavigationLate && this._trigger !== 'store') {
+                    this._dispatchRouterNavigation(lastRoutesRecognized);
+                }
+            }
+            else if (event instanceof ResolveEnd) {
+                this._dispatchRouterDataResolved(event);
+            }
+            else if (event instanceof NavigationCancel) {
+                this._dispatchRouterCancel(event);
+                this._reset();
+            }
+            else if (event instanceof NavigationError) {
+                this._dispatchRouterError(event);
+                this._reset();
+            }
+            else if (event instanceof NavigationEnd) {
+                if (this._trigger !== 'store') {
+                    if (dispatchRouterNavigationLate) {
+                        this._dispatchRouterNavigation(lastRoutesRecognized);
+                    }
+                    this._dispatchRouterNavigated(event);
+                }
+                this._reset();
+            }
+        });
+    }
+    /** Reacts to `NavigationStart`. */
+    _navigationStart(event) {
+        this._routerState = this._serializer.serialize(this._router.routerState.snapshot);
+        if (this._trigger !== 'none') {
+            this._storeState = this._store.selectSnapshot(RouterState_1);
+            this._dispatchRouterAction(new RouterRequest(this._routerState, event, this._trigger));
+        }
+    }
+    /** Reacts to `ResolveEnd`. */
+    _dispatchRouterDataResolved(event) {
+        const routerState = this._serializer.serialize(event.state);
+        this._dispatchRouterAction(new RouterDataResolved(routerState, event, this._trigger));
+    }
+    /** Reacts to `RoutesRecognized` or `NavigationEnd`, depends on the `navigationActionTiming`. */
+    _dispatchRouterNavigation(lastRoutesRecognized) {
+        const nextRouterState = this._serializer.serialize(lastRoutesRecognized.state);
+        this._dispatchRouterAction(new RouterNavigation(nextRouterState, new RoutesRecognized(lastRoutesRecognized.id, lastRoutesRecognized.url, lastRoutesRecognized.urlAfterRedirects, nextRouterState), this._trigger));
+    }
+    /** Reacts to `NavigationCancel`. */
+    _dispatchRouterCancel(event) {
+        this._dispatchRouterAction(new RouterCancel(this._routerState, this._storeState, event, this._trigger));
+    }
+    /** Reacts to `NavigationEnd`. */
+    _dispatchRouterError(event) {
+        this._dispatchRouterAction(new RouterError(this._routerState, this._storeState, new NavigationError(event.id, event.url, `${event}`), this._trigger));
+    }
+    /** Reacts to `NavigationEnd`. */
+    _dispatchRouterNavigated(event) {
+        const routerState = this._serializer.serialize(this._router.routerState.snapshot);
+        this._dispatchRouterAction(new RouterNavigated(routerState, event, this._trigger));
+    }
+    _dispatchRouterAction(action) {
+        this._trigger = 'router';
+        try {
+            this._store.dispatch(action);
+        }
+        finally {
+            this._trigger = 'none';
+        }
+    }
+    _reset() {
+        this._trigger = 'none';
+        this._storeState = null;
+        this._routerState = null;
+    }
+};
+/** @nocollapse */ RouterState.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.4", ngImport: i0, type: RouterState, deps: [{ token: i1.Store }, { token: i2.Router }, { token: i3.RouterStateSerializer }, { token: i0.NgZone }, { token: i0.Injector }], target: i0.ɵɵFactoryTarget.Injectable });
+/** @nocollapse */ RouterState.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.4", ngImport: i0, type: RouterState });
+__decorate([
+    Action(Navigate),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Navigate]),
+    __metadata("design:returntype", void 0)
+], RouterState.prototype, "navigate", null);
+__decorate([
+    Action([
+        RouterRequest,
+        RouterNavigation,
+        RouterError,
+        RouterCancel,
+        RouterDataResolved,
+        RouterNavigated
+    ]),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", void 0)
+], RouterState.prototype, "angularRouterAction", null);
+__decorate([
+    Selector(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", void 0)
+], RouterState, "state", null);
+__decorate([
+    Selector(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Object)
+], RouterState, "url", null);
+RouterState = RouterState_1 = __decorate([
+    State({
+        name: 'router',
+        defaults: {
+            state: undefined,
+            navigationId: undefined,
+            trigger: 'none'
+        }
+    }),
+    __metadata("design:paramtypes", [Store,
+        Router,
+        RouterStateSerializer,
+        NgZone,
+        Injector])
+], RouterState);
+export { RouterState };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.4", ngImport: i0, type: RouterState, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.Store }, { type: i2.Router }, { type: i3.RouterStateSerializer }, { type: i0.NgZone }, { type: i0.Injector }]; }, propDecorators: { navigate: [], angularRouterAction: [] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"router.state.js","sourceRoot":"","sources":["../../../../packages/router-plugin/src/router.state.ts"],"names":[],"mappings":"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","sourcesContent":["import { NgZone, Injectable, OnDestroy, Injector } from '@angular/core';\nimport {\n  NavigationCancel,\n  NavigationError,\n  Router,\n  RouterStateSnapshot,\n  RoutesRecognized,\n  ResolveEnd,\n  NavigationStart,\n  NavigationEnd,\n  Event\n} from '@angular/router';\nimport { Action, Selector, State, StateContext, Store } from '@ngxs/store';\nimport {\n  NavigationActionTiming,\n  NgxsRouterPluginOptions,\n  ɵNGXS_ROUTER_PLUGIN_OPTIONS\n} from '@ngxs/router-plugin/internals';\nimport { ReplaySubject } from 'rxjs';\nimport { takeUntil } from 'rxjs/operators';\n\nimport {\n  Navigate,\n  RouterAction,\n  RouterCancel,\n  RouterError,\n  RouterNavigation,\n  RouterDataResolved,\n  RouterRequest,\n  RouterNavigated\n} from './router.actions';\nimport { RouterStateSerializer } from './serializer';\n\nexport interface RouterStateModel<T = RouterStateSnapshot> {\n  state?: T;\n  navigationId?: number;\n  trigger: RouterTrigger;\n}\n\nexport type RouterTrigger =\n  | 'none'\n  | 'router'\n  | 'store'\n  // The `devtools` trigger means that the state change has been triggered by Redux DevTools (e.g. when the time-traveling is used).\n  | 'devtools';\n\n@State<RouterStateModel>({\n  name: 'router',\n  defaults: {\n    state: undefined,\n    navigationId: undefined,\n    trigger: 'none'\n  }\n})\n@Injectable()\nexport class RouterState implements OnDestroy {\n  /**\n   * Determines how navigation was performed by the `RouterState` itself\n   * or outside via `new Navigate(...)`\n   */\n  private _trigger: RouterTrigger = 'none';\n\n  /**\n   * That's the serialized state from the `Router` class\n   */\n  private _routerState: RouterStateSnapshot | null = null;\n\n  /**\n   * That's the value of the `RouterState` state\n   */\n  private _storeState: RouterStateModel | null = null;\n\n  private _lastEvent: Event | null = null;\n\n  private _options: NgxsRouterPluginOptions | null = null;\n\n  private _destroy$ = new ReplaySubject<void>(1);\n\n  @Selector()\n  static state<T = RouterStateSnapshot>(state: RouterStateModel<T>) {\n    return state && state.state;\n  }\n\n  @Selector()\n  static url(state: RouterStateModel): string | undefined {\n    return state && state.state && state.state.url;\n  }\n\n  constructor(\n    private _store: Store,\n    private _router: Router,\n    private _serializer: RouterStateSerializer<RouterStateSnapshot>,\n    private _ngZone: NgZone,\n    injector: Injector\n  ) {\n    // Note: do not use `@Inject` since it fails on lower versions of Angular with Jest\n    // integration, it cannot resolve the token provider.\n    this._options = injector.get(ɵNGXS_ROUTER_PLUGIN_OPTIONS, null);\n    this._setUpStoreListener();\n    this._setUpRouterEventsListener();\n  }\n\n  ngOnDestroy(): void {\n    this._destroy$.next();\n  }\n\n  @Action(Navigate)\n  navigate(_: StateContext<RouterStateModel>, action: Navigate) {\n    return this._ngZone.run(() =>\n      this._router.navigate(action.path, {\n        queryParams: action.queryParams,\n        ...action.extras\n      })\n    );\n  }\n\n  @Action([\n    RouterRequest,\n    RouterNavigation,\n    RouterError,\n    RouterCancel,\n    RouterDataResolved,\n    RouterNavigated\n  ])\n  angularRouterAction(\n    ctx: StateContext<RouterStateModel>,\n    action: RouterAction<RouterStateModel, RouterStateSnapshot>\n  ): void {\n    ctx.setState({\n      trigger: action.trigger,\n      state: action.routerState,\n      navigationId: action.event.id\n    });\n  }\n\n  private _setUpStoreListener(): void {\n    const routerState$ = this._store.select(RouterState).pipe(takeUntil(this._destroy$));\n    routerState$.subscribe((state: RouterStateModel | undefined) => {\n      this._navigateIfNeeded(state);\n    });\n  }\n\n  private _navigateIfNeeded(routerState: RouterStateModel | undefined): void {\n    if (routerState && routerState.trigger === 'devtools') {\n      this._storeState = this._store.selectSnapshot(RouterState);\n    }\n\n    const canSkipNavigation =\n      !this._storeState ||\n      !this._storeState.state ||\n      !routerState ||\n      routerState.trigger === 'router' ||\n      this._router.url === this._storeState.state.url ||\n      this._lastEvent instanceof NavigationStart;\n\n    if (canSkipNavigation) {\n      return;\n    }\n\n    this._storeState = this._store.selectSnapshot(RouterState);\n    this._trigger = 'store';\n    this._ngZone.run(() => this._router.navigateByUrl(this._storeState!.state!.url));\n  }\n\n  private _setUpRouterEventsListener(): void {\n    const dispatchRouterNavigationLate =\n      this._options != null &&\n      this._options.navigationActionTiming === NavigationActionTiming.PostActivation;\n\n    let lastRoutesRecognized: RoutesRecognized;\n\n    const events$ = this._router.events.pipe(takeUntil(this._destroy$));\n    events$.subscribe(event => {\n      this._lastEvent = event;\n\n      if (event instanceof NavigationStart) {\n        this._navigationStart(event);\n      } else if (event instanceof RoutesRecognized) {\n        lastRoutesRecognized = event;\n        if (!dispatchRouterNavigationLate && this._trigger !== 'store') {\n          this._dispatchRouterNavigation(lastRoutesRecognized);\n        }\n      } else if (event instanceof ResolveEnd) {\n        this._dispatchRouterDataResolved(event);\n      } else if (event instanceof NavigationCancel) {\n        this._dispatchRouterCancel(event);\n        this._reset();\n      } else if (event instanceof NavigationError) {\n        this._dispatchRouterError(event);\n        this._reset();\n      } else if (event instanceof NavigationEnd) {\n        if (this._trigger !== 'store') {\n          if (dispatchRouterNavigationLate) {\n            this._dispatchRouterNavigation(lastRoutesRecognized);\n          }\n          this._dispatchRouterNavigated(event);\n        }\n        this._reset();\n      }\n    });\n  }\n\n  /** Reacts to `NavigationStart`. */\n  private _navigationStart(event: NavigationStart): void {\n    this._routerState = this._serializer.serialize(this._router.routerState.snapshot);\n\n    if (this._trigger !== 'none') {\n      this._storeState = this._store.selectSnapshot(RouterState);\n      this._dispatchRouterAction(new RouterRequest(this._routerState, event, this._trigger));\n    }\n  }\n\n  /** Reacts to `ResolveEnd`. */\n  private _dispatchRouterDataResolved(event: ResolveEnd): void {\n    const routerState = this._serializer.serialize(event.state);\n    this._dispatchRouterAction(new RouterDataResolved(routerState, event, this._trigger));\n  }\n\n  /** Reacts to `RoutesRecognized` or `NavigationEnd`, depends on the `navigationActionTiming`. */\n  private _dispatchRouterNavigation(lastRoutesRecognized: RoutesRecognized): void {\n    const nextRouterState = this._serializer.serialize(lastRoutesRecognized.state);\n\n    this._dispatchRouterAction(\n      new RouterNavigation(\n        nextRouterState,\n        new RoutesRecognized(\n          lastRoutesRecognized.id,\n          lastRoutesRecognized.url,\n          lastRoutesRecognized.urlAfterRedirects,\n          nextRouterState\n        ),\n        this._trigger\n      )\n    );\n  }\n\n  /** Reacts to `NavigationCancel`. */\n  private _dispatchRouterCancel(event: NavigationCancel): void {\n    this._dispatchRouterAction(\n      new RouterCancel(this._routerState!, this._storeState, event, this._trigger)\n    );\n  }\n\n  /** Reacts to `NavigationEnd`. */\n  private _dispatchRouterError(event: NavigationError): void {\n    this._dispatchRouterAction(\n      new RouterError(\n        this._routerState!,\n        this._storeState,\n        new NavigationError(event.id, event.url, `${event}`),\n        this._trigger\n      )\n    );\n  }\n\n  /** Reacts to `NavigationEnd`. */\n  private _dispatchRouterNavigated(event: NavigationEnd): void {\n    const routerState = this._serializer.serialize(this._router.routerState.snapshot);\n    this._dispatchRouterAction(new RouterNavigated(routerState, event, this._trigger));\n  }\n\n  private _dispatchRouterAction<T>(action: RouterAction<T>): void {\n    this._trigger = 'router';\n\n    try {\n      this._store.dispatch(action);\n    } finally {\n      this._trigger = 'none';\n    }\n  }\n\n  private _reset(): void {\n    this._trigger = 'none';\n    this._storeState = null;\n    this._routerState = null;\n  }\n}\n"]}

package/esm2020/src/serializer.mjs

@@ -0,0 +1,33 @@
+export class RouterStateSerializer {
+}
+export class DefaultRouterStateSerializer {
+    serialize(routerState) {
+        return {
+            root: this.serializeRoute(routerState.root),
+            url: routerState.url
+        };
+    }
+    serializeRoute(route) {
+        const children = route.children.map(c => this.serializeRoute(c));
+        return {
+            url: route.url,
+            title: route.title,
+            params: route.params,
+            queryParams: route.queryParams,
+            fragment: route.fragment,
+            data: route.data,
+            outlet: route.outlet,
+            component: null,
+            routeConfig: null,
+            root: null,
+            parent: null,
+            firstChild: children[0],
+            children: children,
+            pathFromRoot: null,
+            paramMap: route.paramMap,
+            queryParamMap: route.queryParamMap,
+            toString: route.toString
+        };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/fesm2015/ngxs-router-plugin-internals.mjs

@@ -0,0 +1,17 @@
+import { InjectionToken } from '@angular/core';
+
+const NG_DEV_MODE = typeof ngDevMode === 'undefined' || ngDevMode;
+const ɵUSER_OPTIONS = new InjectionToken(NG_DEV_MODE ? 'USER_OPTIONS' : '', { providedIn: 'root', factory: () => undefined });
+const ɵNGXS_ROUTER_PLUGIN_OPTIONS = new InjectionToken(NG_DEV_MODE ? 'NGXS_ROUTER_PLUGIN_OPTIONS' : '', { providedIn: 'root', factory: () => ({}) });
+function ɵcreateRouterPluginOptions(options) {
+    return {
+        navigationActionTiming: (options && options.navigationActionTiming) || 1 /* NavigationActionTiming.PreActivation */
+    };
+}
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { ɵNGXS_ROUTER_PLUGIN_OPTIONS, ɵUSER_OPTIONS, ɵcreateRouterPluginOptions };
+//# sourceMappingURL=ngxs-router-plugin-internals.mjs.map

package/fesm2015/ngxs-router-plugin-internals.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"ngxs-router-plugin-internals.mjs","sources":["../../../packages/router-plugin/internals/src/symbols.ts","../../../packages/router-plugin/internals/src/ngxs-router-plugin-internals.ts"],"sourcesContent":["import { InjectionToken } from '@angular/core';\n\ndeclare const ngDevMode: boolean;\n\nconst NG_DEV_MODE = typeof ngDevMode === 'undefined' || ngDevMode;\n\nexport const enum NavigationActionTiming {\n  PreActivation = 1,\n  PostActivation = 2\n}\n\nexport interface NgxsRouterPluginOptions {\n  navigationActionTiming?: NavigationActionTiming;\n}\n\nexport const ɵUSER_OPTIONS = new InjectionToken<NgxsRouterPluginOptions | undefined>(\n  NG_DEV_MODE ? 'USER_OPTIONS' : '',\n  { providedIn: 'root', factory: () => undefined }\n);\n\nexport const ɵNGXS_ROUTER_PLUGIN_OPTIONS = new InjectionToken<NgxsRouterPluginOptions>(\n  NG_DEV_MODE ? 'NGXS_ROUTER_PLUGIN_OPTIONS' : '',\n  { providedIn: 'root', factory: () => ({}) }\n);\n\nexport function ɵcreateRouterPluginOptions(\n  options: NgxsRouterPluginOptions | undefined\n): NgxsRouterPluginOptions {\n  return {\n    navigationActionTiming:\n      (options && options.navigationActionTiming) || NavigationActionTiming.PreActivation\n  };\n}\n","/**\n * Generated bundle index. Do not edit.\n */\n\nexport * from './index';\n"],"names":[],"mappings":";;AAIA,MAAM,WAAW,GAAG,OAAO,SAAS,KAAK,WAAW,IAAI,SAAS,CAAC;AAW3D,MAAM,aAAa,GAAG,IAAI,cAAc,CAC7C,WAAW,GAAG,cAAc,GAAG,EAAE,EACjC,EAAE,UAAU,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,SAAS,EAAE,EAChD;AAEK,MAAM,2BAA2B,GAAG,IAAI,cAAc,CAC3D,WAAW,GAAG,4BAA4B,GAAG,EAAE,EAC/C,EAAE,UAAU,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,EAAE,CAAC,EAAE,EAC3C;AAEI,SAAU,0BAA0B,CACxC,OAA4C,EAAA;IAE5C,OAAO;QACL,sBAAsB,EACpB,CAAC,OAAO,IAAI,OAAO,CAAC,sBAAsB,KAAyC,CAAA;KACtF,CAAC;AACJ;;AChCA;;AAEG;;;;"}