@daffodil/external-router 0.39.12 → 0.41.0

package/esm2020/driver/magento/2.4.2/magento.module.mjs

@@ -0,0 +1,55 @@
+import { CommonModule } from '@angular/common';
+import { NgModule, } from '@angular/core';
+import { DAFF_MAGENTO_CACHEABLE_OPERATIONS } from '@daffodil/driver/magento';
+import { DaffExternalRouterDriver } from '@daffodil/external-router/driver';
+import { DAFF_MAGENTO_RESOLVE_URL_QUERY_NAME } from './graphql/queries/resolve-url-v2.4.2';
+import { DaffExternalRouterMagentoDriver } from './magento.service';
+import * as i0 from "@angular/core";
+/**
+ * The module used to configure the {@link DaffExternalRouterDriver} for usage with Magento.
+ *
+ * ```ts
+ * @NgModule({
+ *   declarations: [],
+ *   imports: [
+ *     ...
+ *     DaffExternalRouterDriverMagentoModule.forRoot()
+ *   ],
+ * })
+ * export class AppModule{}
+ * ```
+ *
+ * Note that this package depends upon ApolloClient, as the Magento driver uses GraphQl to make it's API calls.
+ */
+export class DaffExternalRouterDriverMagentoModule {
+    /**
+     * Configures the package for the root injector.
+     */
+    static forRoot() {
+        return {
+            ngModule: DaffExternalRouterDriverMagentoModule,
+            providers: [
+                {
+                    provide: DaffExternalRouterDriver,
+                    useExisting: DaffExternalRouterMagentoDriver,
+                },
+                {
+                    provide: DAFF_MAGENTO_CACHEABLE_OPERATIONS,
+                    useValue: DAFF_MAGENTO_RESOLVE_URL_QUERY_NAME,
+                    multi: true,
+                },
+            ],
+        };
+    }
+}
+/** @nocollapse */ /** @nocollapse */ DaffExternalRouterDriverMagentoModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: DaffExternalRouterDriverMagentoModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+/** @nocollapse */ /** @nocollapse */ DaffExternalRouterDriverMagentoModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: DaffExternalRouterDriverMagentoModule, imports: [CommonModule] });
+/** @nocollapse */ /** @nocollapse */ DaffExternalRouterDriverMagentoModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: DaffExternalRouterDriverMagentoModule, imports: [[CommonModule]] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: DaffExternalRouterDriverMagentoModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [],
+                    imports: [CommonModule],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/driver/magento/2.4.2/magento.service.mjs

@@ -0,0 +1,37 @@
+import { Injectable } from '@angular/core';
+import { Apollo } from 'apollo-angular';
+import { map } from 'rxjs/operators';
+import { MagentoResolveUrlv242 } from './graphql/queries/resolve-url-v2.4.2';
+import { transformResolutionToResolvableUrlv242 } from './transforms/resolution-to-resolvable-url';
+import * as i0 from "@angular/core";
+import * as i1 from "apollo-angular";
+/**
+ * The DaffExternalRouterMagentoDriver is responsible for translating an
+ * arbitrary URI into a DaffExternallyResolvableUrl with Magento environments.
+ *
+ * @inheritdoc
+ */
+export class DaffExternalRouterMagentoDriver {
+    constructor(apollo) {
+        this.apollo = apollo;
+    }
+    resolve(url) {
+        return this.apollo
+            .query({
+            query: MagentoResolveUrlv242,
+            variables: {
+                url,
+            },
+        })
+            .pipe(map(response => transformResolutionToResolvableUrlv242(response.data.urlResolver)));
+    }
+}
+/** @nocollapse */ /** @nocollapse */ DaffExternalRouterMagentoDriver.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: DaffExternalRouterMagentoDriver, deps: [{ token: i1.Apollo }], target: i0.ɵɵFactoryTarget.Injectable });
+/** @nocollapse */ /** @nocollapse */ DaffExternalRouterMagentoDriver.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: DaffExternalRouterMagentoDriver, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: DaffExternalRouterMagentoDriver, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: i1.Apollo }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/driver/testing/daffodil-external-router-driver-testing.mjs

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

package/esm2020/driver/testing/testing.module.mjs

@@ -0,0 +1,38 @@
+import { CommonModule } from '@angular/common';
+import { NgModule, } from '@angular/core';
+import { DaffExternalRouterDriver } from '@daffodil/external-router/driver';
+import { DAFF_EXTERNAL_ROUTER_DRIVER_TESTING_CONFIG, } from './config';
+import { DaffExternalRouterTestingDriver } from './testing.service';
+import * as i0 from "@angular/core";
+/**
+ * The `DaffExternalRouterDriverTestingModule` is an importable NgModule that can
+ * be used to configure the {@link DaffExternalRouterTestingDriver}.
+ */
+export class DaffExternalRouterDriverTestingModule {
+    static forRoot(config) {
+        return {
+            ngModule: DaffExternalRouterDriverTestingModule,
+            providers: [
+                {
+                    provide: DaffExternalRouterDriver,
+                    useExisting: DaffExternalRouterTestingDriver,
+                },
+                {
+                    provide: DAFF_EXTERNAL_ROUTER_DRIVER_TESTING_CONFIG,
+                    useValue: config,
+                },
+            ],
+        };
+    }
+}
+/** @nocollapse */ /** @nocollapse */ DaffExternalRouterDriverTestingModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: DaffExternalRouterDriverTestingModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+/** @nocollapse */ /** @nocollapse */ DaffExternalRouterDriverTestingModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: DaffExternalRouterDriverTestingModule, imports: [CommonModule] });
+/** @nocollapse */ /** @nocollapse */ DaffExternalRouterDriverTestingModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: DaffExternalRouterDriverTestingModule, imports: [[CommonModule]] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: DaffExternalRouterDriverTestingModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [],
+                    imports: [CommonModule],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/driver/testing/testing.service.mjs

@@ -0,0 +1,45 @@
+import { Injectable, Inject, } from '@angular/core';
+import * as faker from '@faker-js/faker/locale/en_US';
+import { of, throwError, } from 'rxjs';
+import { daffUriTruncateLeadingSlash, daffUriTruncateQueryFragment, } from '@daffodil/core/routing';
+import { DAFF_EXTERNAL_ROUTER_DRIVER_TESTING_CONFIG, } from './config';
+import * as i0 from "@angular/core";
+/**
+ * The DaffExternalRouterTestingDriver is responsible for translating an
+ * arbitrary URI into a DaffExternallyResolvableUrl in testing environments.
+ *
+ * @inheritdoc
+ *
+ * @see {@link DaffExternalRouterTestingDriver}
+ */
+export class DaffExternalRouterTestingDriver {
+    constructor(testingConfiguration = {}) {
+        this.testingConfiguration = testingConfiguration;
+    }
+    resolve(url) {
+        const truncatedUrl = daffUriTruncateLeadingSlash(daffUriTruncateQueryFragment(url));
+        if (!this.testingConfiguration[truncatedUrl]) {
+            return throwError(`\
+The route '${truncatedUrl}' wasn't provided with a matching type by the testing driver. \
+Did you configure the available route types with DaffExternalRouterDriverTestingModule.forRoot(config)`);
+        }
+        return of({
+            id: faker.datatype.uuid(),
+            url: truncatedUrl,
+            type: this.testingConfiguration[truncatedUrl],
+            code: 200,
+        });
+    }
+}
+/** @nocollapse */ /** @nocollapse */ DaffExternalRouterTestingDriver.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: DaffExternalRouterTestingDriver, deps: [{ token: DAFF_EXTERNAL_ROUTER_DRIVER_TESTING_CONFIG }], target: i0.ɵɵFactoryTarget.Injectable });
+/** @nocollapse */ /** @nocollapse */ DaffExternalRouterTestingDriver.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: DaffExternalRouterTestingDriver, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: DaffExternalRouterTestingDriver, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [DAFF_EXTERNAL_ROUTER_DRIVER_TESTING_CONFIG]
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/external-router.module.mjs

@@ -0,0 +1,31 @@
+import { CommonModule } from '@angular/common';
+import { NgModule, } from '@angular/core';
+import { DAFF_EXTERNAL_ROUTER_CONFIG, daffExternalRouterConfigurationDefault, } from './config';
+import { daffProvideRoutesResolvableByType } from './token/type-resolvable-routes.token';
+import * as i0 from "@angular/core";
+/**
+ * The external `DaffExternalRouterModule` allows you to configure the
+ * `@daffodil/external-router` package's behavior.
+ */
+export class DaffExternalRouterModule {
+    static forRoot(config, routes = []) {
+        return {
+            ngModule: DaffExternalRouterModule,
+            providers: [
+                { provide: DAFF_EXTERNAL_ROUTER_CONFIG, useValue: { ...daffExternalRouterConfigurationDefault, ...config } },
+                ...daffProvideRoutesResolvableByType(routes),
+            ],
+        };
+    }
+}
+/** @nocollapse */ /** @nocollapse */ DaffExternalRouterModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: DaffExternalRouterModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+/** @nocollapse */ /** @nocollapse */ DaffExternalRouterModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: DaffExternalRouterModule, imports: [CommonModule] });
+/** @nocollapse */ /** @nocollapse */ DaffExternalRouterModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: DaffExternalRouterModule, imports: [[CommonModule]] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: DaffExternalRouterModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [],
+                    imports: [CommonModule],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/router/router.service.mjs

@@ -0,0 +1,43 @@
+import { Inject, Injectable, } from '@angular/core';
+import { Router, } from '@angular/router';
+import { DaffExternalRouterNoWildcardError } from '../errors/no-wildcard';
+import { DAFF_EXTERNAL_ROUTER_ROUTES_RESOLVABLE_BY_TYPE } from '../token/type-resolvable-routes.token';
+import { daffTransformResolvedRouteToRoute } from '../transform/resolved-route-to-route';
+import { daffInsertRouteBeforeWildCardStrategy } from './strategies/insert-route-before-wildcard';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/router";
+export class DaffExternalRouter {
+    constructor(router, runtimeRoutes) {
+        this.router = router;
+        this.runtimeRoutes = runtimeRoutes;
+    }
+    /**
+     * Adds a route to the existing router configuration.
+     */
+    add(resolvedRoute) {
+        //Get the route.
+        const { route, insertionStrategy, } = daffTransformResolvedRouteToRoute(resolvedRoute, this.runtimeRoutes);
+        try {
+            //Add it to configuration.
+            this.router.config = (insertionStrategy || daffInsertRouteBeforeWildCardStrategy)(route, this.router.config);
+        }
+        catch (e) {
+            if (e instanceof DaffExternalRouterNoWildcardError) {
+                throw new DaffExternalRouterNoWildcardError(`${e.message} This usually means you have misconfigured your routes.`);
+            }
+            throw e;
+        }
+    }
+}
+/** @nocollapse */ /** @nocollapse */ DaffExternalRouter.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: DaffExternalRouter, deps: [{ token: i1.Router }, { token: DAFF_EXTERNAL_ROUTER_ROUTES_RESOLVABLE_BY_TYPE }], target: i0.ɵɵFactoryTarget.Injectable });
+/** @nocollapse */ /** @nocollapse */ DaffExternalRouter.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: DaffExternalRouter, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: DaffExternalRouter, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: i1.Router }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [DAFF_EXTERNAL_ROUTER_ROUTES_RESOLVABLE_BY_TYPE]
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/router/strategies/insert-data-path.mjs

@@ -0,0 +1,81 @@
+/**
+ * Tests whether or not a route matches a specific Daffodil Route type.
+ *
+ * See {@link DaffRouteWithDataPath}
+ */
+const routeMatchesRouteType = (route, type) => route?.data?.daffExternalRouteType === type;
+/**
+ * Adds a path to the `daffPaths` of the given route.
+ *
+ * See {@link DaffRouteWithDataPath}
+ */
+const addRouteToDaffPaths = (route, path) => route.data.daffPaths = {
+    ...route.data.daffPaths,
+    [path]: path,
+};
+const operateOnRoute = (externalRoute) => (route) => addRouteToDaffPaths(route, externalRoute.path);
+/**
+ * Traverse the router config tree, halting after the first match.
+ * This traversal is implemented in a pre-order manner. As such, for large
+ * configuration trees, it will be most efficient to place externally routed
+ * components at the top of router configuration.
+ */
+const traverseRouteTree = (routes = [], matcher, operate) => {
+    if (routes.length === 0) {
+        return routes;
+    }
+    const stack = [];
+    const treeRoot = { children: routes };
+    stack.push(treeRoot);
+    while (stack.length) {
+        const route = stack.pop();
+        if (matcher(route)) {
+            operate(route);
+            break;
+        }
+        if (route.children) {
+            stack.push(...route.children.reverse());
+        }
+    }
+    return routes;
+};
+/**
+ * A route insertion strategy that can be used to append external routes onto
+ * existing Angular routes. This can be useful when you need to route to
+ * an existing lazy-loaded module from multiple externally defined urls.
+ *
+ * This should be used in combination with the {@link daffDataPathUrlMatcher} to match lazy-loaded modules with
+ * associated external urls.
+ *
+ * For example, you can provide the insertion strategy in the {@link DaffExternalRouterModule} as below.
+ *
+ * ```ts
+ * DaffExternalRouterModule.forRoot({}, [
+ *  {
+ *    type: 'CATEGORY',
+ *    insertionStrategy: daffInsertDataPathStrategy,
+ *    route: {}
+ *  }
+ * ],
+ * ```
+ *
+ * Then, you can match it with an associated route defined in your Routing
+ * configuration with the {@link daffDataPathUrlMatcher}.
+ *
+ * ```ts
+ *  export const routes: Routes = [
+ *    {
+ *      matcher: daffDataPathUrlMatcher,
+ *      data: {
+ *        daffExternalRouteType: "CATEGORY",
+ *      },
+ *      loadChildren: () => import('./category/category.module').then((m) => m.MyCategoryModule),
+ *    }
+ * ]
+ * ```
+ *
+ * See {@link DaffRouteWithDataPath}
+ *
+ */
+export const daffInsertDataPathStrategy = (externalRoute, routes) => traverseRouteTree(routes, (route) => routeMatchesRouteType(route, externalRoute.data?.daffExternalRouteType), operateOnRoute(externalRoute));
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/router/url-matcher/data-path-matcher.mjs

@@ -0,0 +1,31 @@
+import { daffUriTruncateLeadingSlash } from '@daffodil/core/routing';
+/**
+ * A UrlMatcher that does an exact match against a path stored in the special
+ * configuration fields that External Router stores on a Route's data.
+ *
+ * ```ts
+ *  export const routes: Routes = [
+ *    {
+ *      matcher: daffDataPathUrlMatcher,
+ *      data: {
+ *        daffExternalRouteType: "CATEGORY",
+ *      },
+ *      loadChildren: () => import('./category/category.module').then((m) => m.ShopCategoryModule),
+ *    }
+ * ]
+ * ```
+ * {@link daffInsertDataPathStrategy }
+ * {@link DaffRouteWithDataPath }
+ */
+export const daffDataPathUrlMatcher = (segments, group, route) => {
+    const path = daffUriTruncateLeadingSlash(segments.reduce((acc, segment) => acc + '/' + segment.path, ''));
+    const paths = route?.data?.daffPaths;
+    // If we don't have any paths, we can safely fail a match.
+    if (!paths) {
+        return null;
+    }
+    // Otherwise, look up the path in the dictionary, failing if a match isn't found,
+    // but matching the entire segment if a match is found.
+    return path in paths ? { consumed: segments } : null;
+};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/routing/guard/existence.guard.mjs

@@ -0,0 +1,77 @@
+import { Injectable, Inject, } from '@angular/core';
+import { Router, } from '@angular/router';
+import { of, } from 'rxjs';
+import { catchError, map, switchMap, } from 'rxjs/operators';
+import { DaffRoutingUriNormalizer } from '@daffodil/core/routing';
+import { DaffExternalRouter, DAFF_EXTERNAL_ROUTER_CONFIG, } from '@daffodil/external-router';
+import { DaffExternalRouterDriver, } from '@daffodil/external-router/driver';
+import { DaffExternalRouterNotFoundError } from '../errors/not-found-error';
+import { DaffExternalRouterPermanentRedirectError } from '../errors/permanent-redirect';
+import { DaffExternalRouterTemporaryRedirectError } from '../errors/temporary-redirect';
+import { processErrors } from '../processors/process-errors';
+import { processRedirects } from '../processors/process-redirect';
+import * as i0 from "@angular/core";
+import * as i1 from "@daffodil/external-router";
+import * as i2 from "@angular/router";
+import * as i3 from "@daffodil/core/routing";
+/**
+ * The DaffExternalRouterExistenceGuard is responsible for guarding the wildcard route
+ * of an Angular App and either navigating to a resolved route upon successful resolution
+ * or navigating to the configured route upon a failed resolution.
+ */
+export class DaffExternalRouterExistenceGuard {
+    constructor(driver, externalRouter, router, config, urlNormalizer) {
+        this.driver = driver;
+        this.externalRouter = externalRouter;
+        this.router = router;
+        this.config = config;
+        this.urlNormalizer = urlNormalizer;
+    }
+    canActivate(next, state) {
+        return this.driver.resolve(this.urlNormalizer.normalize(state.url)).pipe(map((resolvedRoute) => processErrors(resolvedRoute)), switchMap(resolvedRoute => {
+            this.externalRouter.add(resolvedRoute);
+            return of(resolvedRoute);
+        }), map((resolvedRoute) => processRedirects(resolvedRoute)), 
+        // Note that we have to use state.url as we want to ensure that we keep any fragments or query strings.
+        // When we succeed, redirect to the new route, as config has changed since we init'd.
+        map(() => this.router.parseUrl(state.url)), 
+        // When we fail, we need to process errors as dictated by the error type.
+        // Handle redirects
+        catchError(error => {
+            if (!(error instanceof DaffExternalRouterPermanentRedirectError) &&
+                !(error instanceof DaffExternalRouterTemporaryRedirectError)) {
+                throw error;
+            }
+            return of(this.router.parseUrl(error.redirectUrl));
+        }), 
+        // Handle "404"
+        catchError((error) => {
+            if (!(error instanceof DaffExternalRouterNotFoundError)) {
+                throw error;
+            }
+            return of(this.router.parseUrl(this.config.notFoundResolutionPath));
+        }), 
+        //Otherwise something went horribly wrong and we need to bail out.
+        catchError((error) => {
+            //TODO(damienwebdev): Add a logging system.
+            //This log is intentional until we have a better logging system in place.
+            console.log(error);
+            return of(this.router.parseUrl(this.config.failedResolutionPath));
+        }));
+    }
+}
+/** @nocollapse */ /** @nocollapse */ DaffExternalRouterExistenceGuard.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: DaffExternalRouterExistenceGuard, deps: [{ token: DaffExternalRouterDriver }, { token: i1.DaffExternalRouter }, { token: i2.Router }, { token: DAFF_EXTERNAL_ROUTER_CONFIG }, { token: i3.DaffRoutingUriNormalizer }], target: i0.ɵɵFactoryTarget.Injectable });
+/** @nocollapse */ /** @nocollapse */ DaffExternalRouterExistenceGuard.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: DaffExternalRouterExistenceGuard, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: DaffExternalRouterExistenceGuard, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [DaffExternalRouterDriver]
+                }] }, { type: i1.DaffExternalRouter }, { type: i2.Router }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [DAFF_EXTERNAL_ROUTER_CONFIG]
+                }] }, { type: i3.DaffRoutingUriNormalizer }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"existence.guard.js","sourceRoot":"","sources":["../../../../../libs/external-router/routing/src/guard/existence.guard.ts"],"names":[],"mappings":"AACA,OAAO,EACL,UAAU,EACV,MAAM,GAEP,MAAM,eAAe,CAAC;AACvB,OAAO,EAGL,MAAM,GAGP,MAAM,iBAAiB,CAAC;AACzB,OAAO,EAEL,EAAE,GACH,MAAM,MAAM,CAAC;AACd,OAAO,EACL,UAAU,EACV,GAAG,EACH,SAAS,GACV,MAAM,gBAAgB,CAAC;AAExB,OAAO,EAAE,wBAAwB,EAAE,MAAM,wBAAwB,CAAC;AAClE,OAAO,EACL,kBAAkB,EAElB,2BAA2B,GAE5B,MAAM,2BAA2B,CAAC;AACnC,OAAO,EAEL,wBAAwB,GACzB,MAAM,kCAAkC,CAAC;AAE1C,OAAO,EAAE,+BAA+B,EAAE,MAAM,2BAA2B,CAAC;AAC5E,OAAO,EAAE,wCAAwC,EAAE,MAAM,8BAA8B,CAAC;AACxF,OAAO,EAAE,wCAAwC,EAAE,MAAM,8BAA8B,CAAC;AACxF,OAAO,EAAE,aAAa,EAAE,MAAM,8BAA8B,CAAC;AAC7D,OAAO,EAAE,gBAAgB,EAAE,MAAM,gCAAgC,CAAC;;;;;AAElE;;;;GAIG;AAIH,MAAM,OAAO,gCAAgC;IAC3C,YAEU,MAAyC,EACzC,cAAkC,EAClC,MAAc,EAEd,MAAuC,EACvC,aAAuC;QALvC,WAAM,GAAN,MAAM,CAAmC;QACzC,mBAAc,GAAd,cAAc,CAAoB;QAClC,WAAM,GAAN,MAAM,CAAQ;QAEd,WAAM,GAAN,MAAM,CAAiC;QACvC,kBAAa,GAAb,aAAa,CAA0B;IAC7C,CAAC;IAEL,WAAW,CACT,IAA4B,EAC5B,KAA0B;QAE1B,OAAO,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC,aAAa,CAAC,SAAS,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,IAAI,CACtE,GAAG,CAAC,CAAC,aAA0C,EAAE,EAAE,CAAC,aAAa,CAAC,aAAa,CAAC,CAAC,EACjF,SAAS,CAAC,aAAa,CAAC,EAAE;YACxB,IAAI,CAAC,cAAc,CAAC,GAAG,CAAC,aAAa,CAAC,CAAC;YACvC,OAAO,EAAE,CAAC,aAAa,CAAC,CAAC;QAC3B,CAAC,CAAC,EACF,GAAG,CAAC,CAAC,aAA0C,EAAE,EAAE,CAAC,gBAAgB,CAAC,aAAa,CAAC,CAAC;QACpF,uGAAuG;QACvG,qFAAqF;QACrF,GAAG,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;QAC1C,yEAAyE;QACzE,mBAAmB;QACnB,UAAU,CAAC,KAAK,CAAC,EAAE;YACjB,IACE,CAAC,CAAC,KAAK,YAAY,wCAAwC,CAAC;gBAC5D,CAAC,CAAC,KAAK,YAAY,wCAAwC,CAAC,EAAE;gBAC9D,MAAM,KAAK,CAAC;aACb;YAED,OAAO,EAAE,CAAC,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC,WAAW,CAAC,CAAC,CAAC;QACrD,CAAC,CAAC;QACF,eAAe;QACf,UAAU,CAAC,CAAC,KAAK,EAAE,EAAE;YACnB,IAAI,CAAC,CAAC,KAAK,YAAY,+BAA+B,CAAC,EAAE;gBACvD,MAAM,KAAK,CAAC;aACb;YAED,OAAO,EAAE,CAAC,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,IAAI,CAAC,MAAM,CAAC,sBAAsB,CAAC,CAAC,CAAC;QACtE,CAAC,CAAC;QAEF,kEAAkE;QAClE,UAAU,CAAC,CAAC,KAAK,EAAE,EAAE;YACnB,2CAA2C;YAC3C,yEAAyE;YACzE,OAAO,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;YACnB,OAAO,EAAE,CAAC,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,IAAI,CAAC,MAAM,CAAC,oBAAoB,CAAC,CAAC,CAAC;QACpE,CAAC,CAAC,CACH,CAAC;IACJ,CAAC;;mKArDU,gCAAgC,kBAEjC,wBAAwB,qEAIxB,2BAA2B;uKAN1B,gCAAgC,cAF/B,MAAM;2FAEP,gCAAgC;kBAH5C,UAAU;mBAAC;oBACV,UAAU,EAAE,MAAM;iBACnB;;0BAGI,MAAM;2BAAC,wBAAwB;;0BAI/B,MAAM;2BAAC,2BAA2B","sourcesContent":["import { isPlatformServer } from '@angular/common';\nimport {\n  Injectable,\n  Inject,\n  PLATFORM_ID,\n} from '@angular/core';\nimport {\n  CanActivate,\n  ActivatedRouteSnapshot,\n  Router,\n  RouterStateSnapshot,\n  UrlTree,\n} from '@angular/router';\nimport {\n  Observable,\n  of,\n} from 'rxjs';\nimport {\n  catchError,\n  map,\n  switchMap,\n} from 'rxjs/operators';\n\nimport { DaffRoutingUriNormalizer } from '@daffodil/core/routing';\nimport {\n  DaffExternalRouter,\n  DaffExternalRouterConfiguration,\n  DAFF_EXTERNAL_ROUTER_CONFIG,\n  DaffExternallyResolvableUrl,\n} from '@daffodil/external-router';\nimport {\n  DaffExternalRouterDriverInterface,\n  DaffExternalRouterDriver,\n} from '@daffodil/external-router/driver';\n\nimport { DaffExternalRouterNotFoundError } from '../errors/not-found-error';\nimport { DaffExternalRouterPermanentRedirectError } from '../errors/permanent-redirect';\nimport { DaffExternalRouterTemporaryRedirectError } from '../errors/temporary-redirect';\nimport { processErrors } from '../processors/process-errors';\nimport { processRedirects } from '../processors/process-redirect';\n\n/**\n * The DaffExternalRouterExistenceGuard is responsible for guarding the wildcard route\n * of an Angular App and either navigating to a resolved route upon successful resolution\n * or navigating to the configured route upon a failed resolution.\n */\n@Injectable({\n  providedIn: 'root',\n})\nexport class DaffExternalRouterExistenceGuard implements CanActivate {\n  constructor(\n    @Inject(DaffExternalRouterDriver)\n    private driver: DaffExternalRouterDriverInterface,\n    private externalRouter: DaffExternalRouter,\n    private router: Router,\n    @Inject(DAFF_EXTERNAL_ROUTER_CONFIG)\n    private config: DaffExternalRouterConfiguration,\n    private urlNormalizer: DaffRoutingUriNormalizer,\n  ) { }\n\n  canActivate(\n    next: ActivatedRouteSnapshot,\n    state: RouterStateSnapshot,\n  ): Observable<UrlTree | boolean> {\n    return this.driver.resolve(this.urlNormalizer.normalize(state.url)).pipe(\n      map((resolvedRoute: DaffExternallyResolvableUrl) => processErrors(resolvedRoute)),\n      switchMap(resolvedRoute => {\n        this.externalRouter.add(resolvedRoute);\n        return of(resolvedRoute);\n      }),\n      map((resolvedRoute: DaffExternallyResolvableUrl) => processRedirects(resolvedRoute)),\n      // Note that we have to use state.url as we want to ensure that we keep any fragments or query strings.\n      // When we succeed, redirect to the new route, as config has changed since we init'd.\n      map(() => this.router.parseUrl(state.url)),\n      // When we fail, we need to process errors as dictated by the error type.\n      // Handle redirects\n      catchError(error => {\n        if (\n          !(error instanceof DaffExternalRouterPermanentRedirectError) &&\n          !(error instanceof DaffExternalRouterTemporaryRedirectError)) {\n          throw error;\n        }\n\n        return of(this.router.parseUrl(error.redirectUrl));\n      }),\n      // Handle \"404\"\n      catchError((error) => {\n        if (!(error instanceof DaffExternalRouterNotFoundError)) {\n          throw error;\n        }\n\n        return of(this.router.parseUrl(this.config.notFoundResolutionPath));\n      }),\n\n      //Otherwise something went horribly wrong and we need to bail out.\n      catchError((error) => {\n        //TODO(damienwebdev): Add a logging system.\n        //This log is intentional until we have a better logging system in place.\n        console.log(error);\n        return of(this.router.parseUrl(this.config.failedResolutionPath));\n      }),\n    );\n  }\n}\n"]}