@daffodil/external-router 0.38.7

package/fesm2015/daffodil-external-router-driver-testing.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"daffodil-external-router-driver-testing.js","sources":["../../../libs/external-router/driver/testing/src/config.ts","../../../libs/external-router/driver/testing/src/testing.service.ts","../../../libs/external-router/driver/testing/src/testing.module.ts"],"sourcesContent":["import { InjectionToken } from '@angular/core';\n\nimport { DaffExternalRouteType } from '@daffodil/external-router';\n\n/**\n * The configuration for the testing driver. It is a dictionary of \"url\": \"type\",\n * pairs, where the URL is a URL-safe routeable path, e.g. \"sweatshirts\" or \"t-shirts\"\n * and the type is a known type to your application, e.g. \"CATEGORY\".\n */\nexport interface DaffExternalRouterDriverTestingConfig {\n\t[url: string]: DaffExternalRouteType;\n}\n\n/**\n * The token used by Daffodil to hold the driver's configuration.\n *\n * @docs-private\n */\nexport const DAFF_EXTERNAL_ROUTER_DRIVER_TESTING_CONFIG = new InjectionToken<\n\tDaffExternalRouterDriverTestingConfig\n>('DAFF_EXTERNAL_ROUTER_DRIVER_TESTING_CONFIG', {\n  providedIn: 'root',\n  factory: () => ({}),\n});\n","import {\n  Injectable,\n  Inject,\n} from '@angular/core';\nimport * as faker from 'faker/locale/en_US';\nimport {\n  Observable,\n  of,\n  throwError,\n} from 'rxjs';\n\nimport {\n  daffUriTruncateLeadingSlash,\n  daffUriTruncateQueryFragment,\n} from '@daffodil/core/routing';\nimport { DaffExternallyResolvableUrl } from '@daffodil/external-router';\nimport { DaffExternalRouterDriverInterface } from '@daffodil/external-router/driver';\n\nimport {\n  DaffExternalRouterDriverTestingConfig,\n  DAFF_EXTERNAL_ROUTER_DRIVER_TESTING_CONFIG,\n} from './config';\n\n/**\n * The DaffExternalRouterTestingDriver is responsible for translating an\n * arbitrary URI into a DaffExternallyResolvableUrl in testing environments.\n *\n * @inheritdoc\n *\n * @see {@link DaffExternalRouterTestingDriver}\n */\n@Injectable({\n  providedIn: 'root',\n})\nexport class DaffExternalRouterTestingDriver\nimplements DaffExternalRouterDriverInterface {\n  constructor(\n\t\t@Inject(DAFF_EXTERNAL_ROUTER_DRIVER_TESTING_CONFIG)\n\t\tprivate testingConfiguration: DaffExternalRouterDriverTestingConfig = {},\n  ) {}\n\n  resolve(url: string): Observable<DaffExternallyResolvableUrl> {\n    const truncatedUrl = daffUriTruncateLeadingSlash(daffUriTruncateQueryFragment(url));\n\n    if (!this.testingConfiguration[truncatedUrl]) {\n      return throwError(`\\\nThe route '${truncatedUrl}' wasn't provided with a matching type by the testing driver. \\\nDid you configure the available route types with DaffExternalRouterDriverTestingModule.forRoot(config)`);\n    }\n\n    return of({\n      id: faker.datatype.uuid(),\n      url: truncatedUrl,\n      type: this.testingConfiguration[truncatedUrl],\n      code: 200,\n    });\n  }\n}\n","import { CommonModule } from '@angular/common';\nimport {\n  NgModule,\n  ModuleWithProviders,\n} from '@angular/core';\n\nimport { DaffExternalRouterDriver } from '@daffodil/external-router/driver';\n\nimport {\n  DaffExternalRouterDriverTestingConfig,\n  DAFF_EXTERNAL_ROUTER_DRIVER_TESTING_CONFIG,\n} from './config';\nimport { DaffExternalRouterTestingDriver } from './testing.service';\n\n/**\n * The `DaffExternalRouterDriverTestingModule` is an importable NgModule that can\n * be used to configure the {@link DaffExternalRouterTestingDriver}.\n */\n@NgModule({\n  declarations: [],\n  imports: [CommonModule],\n})\nexport class DaffExternalRouterDriverTestingModule {\n  static forRoot(\n    config: DaffExternalRouterDriverTestingConfig,\n  ): ModuleWithProviders<DaffExternalRouterDriverTestingModule> {\n    return {\n      ngModule: DaffExternalRouterDriverTestingModule,\n      providers: [\n        {\n          provide: DaffExternalRouterDriver,\n          useExisting: DaffExternalRouterTestingDriver,\n        },\n        {\n          provide: DAFF_EXTERNAL_ROUTER_DRIVER_TESTING_CONFIG,\n          useValue: config,\n        },\n      ],\n    };\n  }\n}\n"],"names":["faker.datatype"],"mappings":";;;;;;;;;;;;;;;;;;oDAWC;;;;;;;MAOY,0CAA0C,GAAG,IAAI,cAAc,CAE1E,4CAA4C,EAAE;IAC9C,UAAU,EAAE,MAAM;IAClB,OAAO;;;IAAE,OAAO,EAAE,CAAC,CAAA;CACpB;;;;;;;;;;;;;;;MCWY,+BAA+B;;;;IAE1C,YAEQ,uBAA8D,EAAE;QAAhE,yBAAoB,GAApB,oBAAoB,CAA4C;KACpE;;;;;IAEJ,OAAO,CAAC,GAAW;;cACX,YAAY,GAAG,2BAA2B,CAAC,4BAA4B,CAAC,GAAG,CAAC,CAAC;QAEnF,IAAI,CAAC,IAAI,CAAC,oBAAoB,CAAC,YAAY,CAAC,EAAE;YAC5C,OAAO,UAAU,CAAC;aACX,YAAY;uGAC8E,CAAC,CAAC;SACpG;QAED,OAAO,EAAE,CAAC;YACR,EAAE,EAAEA,QAAc,CAAC,IAAI,EAAE;YACzB,GAAG,EAAE,YAAY;YACjB,IAAI,EAAE,IAAI,CAAC,oBAAoB,CAAC,YAAY,CAAC;YAC7C,IAAI,EAAE,GAAG;SACV,CAAC,CAAC;KACJ;;;YAzBF,UAAU,SAAC;gBACV,UAAU,EAAE,MAAM;aACnB;;;;4CAIE,MAAM,SAAC,0CAA0C;;;;;;;;IAAlD,+DACwE;;;;;;;;;;;;MChB7D,qCAAqC;;;;;IAChD,OAAO,OAAO,CACZ,MAA6C;QAE7C,OAAO;YACL,QAAQ,EAAE,qCAAqC;YAC/C,SAAS,EAAE;gBACT;oBACE,OAAO,EAAE,wBAAwB;oBACjC,WAAW,EAAE,+BAA+B;iBAC7C;gBACD;oBACE,OAAO,EAAE,0CAA0C;oBACnD,QAAQ,EAAE,MAAM;iBACjB;aACF;SACF,CAAC;KACH;;;YArBF,QAAQ,SAAC;gBACR,YAAY,EAAE,EAAE;gBAChB,OAAO,EAAE,CAAC,YAAY,CAAC;aACxB;;;;;;;;;;;;;;;;;;;;;;;"}

package/fesm2015/daffodil-external-router-driver.js

@@ -0,0 +1,70 @@
+import { InjectionToken } from '@angular/core';
+
+/**
+ * @fileoverview added by tsickle
+ * Generated from: interfaces/external-router-driver.interface.ts
+ * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+/**
+ * The token for the `\@daffodil/external-router` driver.
+ * @type {?}
+ */
+const DaffExternalRouterDriver = new InjectionToken('DaffExternalRouterDriver');
+/**
+ * The interface for a \@daffodil/external-router driver.
+ *
+ * This driver is responsible for translating a URL into a Route consumable by
+ * Daffodil.
+ * @record
+ */
+function DaffExternalRouterDriverInterface() { }
+if (false) {
+    /**
+     * Resolves a URL with a platform.
+     * Returns information about the type of URL.
+     *
+     * @param {?} url The full URL path qualified with file extension and leading slash but without domain. i.e. /full/path/to/thing.html
+     * @return {?}
+     */
+    DaffExternalRouterDriverInterface.prototype.resolve = function (url) { };
+}
+
+/**
+ * @fileoverview added by tsickle
+ * Generated from: not-found-resolution.ts
+ * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+/**
+ * When a driver fails to find a resolution, it should return a 404.
+ * This const represents the standard "Not Found" resolution that a driver
+ * should return. Drivers are not required to return this value, but may do so
+ * if they would like.
+ * @type {?}
+ */
+const DAFF_EXTERNAL_ROUTER_NOT_FOUND_RESOLUTION = {
+    id: null,
+    url: null,
+    code: 404,
+    type: null,
+};
+
+/**
+ * @fileoverview added by tsickle
+ * Generated from: public_api.ts
+ * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+
+/**
+ * @fileoverview added by tsickle
+ * Generated from: index.ts
+ * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+
+/**
+ * @fileoverview added by tsickle
+ * Generated from: daffodil-external-router-driver.ts
+ * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+
+export { DAFF_EXTERNAL_ROUTER_NOT_FOUND_RESOLUTION, DaffExternalRouterDriver };
+//# sourceMappingURL=daffodil-external-router-driver.js.map

package/fesm2015/daffodil-external-router-driver.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"daffodil-external-router-driver.js","sources":["../../../libs/external-router/driver/src/interfaces/external-router-driver.interface.ts","../../../libs/external-router/driver/src/not-found-resolution.ts"],"sourcesContent":["import { InjectionToken } from '@angular/core';\nimport { Observable } from 'rxjs';\n\nimport { DaffExternallyResolvableUrl } from '@daffodil/external-router';\n\n/**\n * The token for the `@daffodil/external-router` driver.\n */\nexport const DaffExternalRouterDriver = new InjectionToken<\n\tDaffExternalRouterDriverInterface\n>('DaffExternalRouterDriver');\n\n/**\n * The interface for a @daffodil/external-router driver.\n *\n * This driver is responsible for translating a URL into a Route consumable by\n * Daffodil.\n */\nexport interface DaffExternalRouterDriverInterface {\n  /**\n   * Resolves a URL with a platform.\n   * Returns information about the type of URL.\n   *\n   * @param url The full URL path qualified with file extension and leading slash but without domain. i.e. /full/path/to/thing.html\n   */\n\tresolve(url: string): Observable<DaffExternallyResolvableUrl>;\n}\n","import { DaffExternallyResolvableUrl } from '@daffodil/external-router';\n\n/**\n * When a driver fails to find a resolution, it should return a 404.\n * This const represents the standard \"Not Found\" resolution that a driver\n * should return. Drivers are not required to return this value, but may do so\n * if they would like.\n */\nexport const DAFF_EXTERNAL_ROUTER_NOT_FOUND_RESOLUTION: DaffExternallyResolvableUrl = {\n  id: null,\n  url: null,\n  code: 404,\n  type: null,\n};\n"],"names":[],"mappings":";;;;;;;;;;;MAQa,wBAAwB,GAAG,IAAI,cAAc,CAExD,0BAA0B;;;;;;;;gDAgB3B;;;;;;;;;IADA,yEAA8D;;;;;;;;;;;;;;;MCjBlD,yCAAyC,GAAgC;IACpF,EAAE,EAAE,IAAI;IACR,GAAG,EAAE,IAAI;IACT,IAAI,EAAE,GAAG;IACT,IAAI,EAAE,IAAI;;;;;;;;;;;;;;;;;;;;;;;"}

package/fesm2015/daffodil-external-router-routing.js

@@ -0,0 +1,336 @@
+import { Injectable, Inject, ɵɵdefineInjectable, ɵɵinject } from '@angular/core';
+import { Router } from '@angular/router';
+import { of } from 'rxjs';
+import { map, switchMap, catchError } 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 { DaffInheritableError } from '@daffodil/core';
+
+/**
+ * @fileoverview added by tsickle
+ * Generated from: errors/client-error.ts
+ * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+/**
+ * An error thrown when the driver encounters a 4xx error.
+ */
+class DaffExternalRouterClientError extends DaffInheritableError {
+    /**
+     * @param {?=} message
+     */
+    constructor(message) {
+        super(message);
+        this.code = '4xx_CLIENT_ERROR';
+    }
+}
+if (false) {
+    /** @type {?} */
+    DaffExternalRouterClientError.prototype.code;
+}
+
+/**
+ * @fileoverview added by tsickle
+ * Generated from: errors/not-found-error.ts
+ * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+/**
+ * An error thrown when the driver determines that a given url is not resolvable.
+ */
+class DaffExternalRouterNotFoundError extends DaffExternalRouterClientError {
+    /**
+     * @param {?=} message
+     */
+    constructor(message) {
+        super(message);
+        this.code = '404_NOT_FOUND';
+    }
+}
+if (false) {
+    /** @type {?} */
+    DaffExternalRouterNotFoundError.prototype.code;
+}
+
+/**
+ * @fileoverview added by tsickle
+ * Generated from: errors/permanent-redirect.ts
+ * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+/**
+ * An error thrown when the driver determines that the url needs to be routed somewhere
+ * else permanently.
+ */
+class DaffExternalRouterPermanentRedirectError extends DaffInheritableError {
+    /**
+     * @param {?} redirectUrl
+     * @param {?=} message
+     */
+    constructor(redirectUrl, message) {
+        super(message);
+        this.redirectUrl = redirectUrl;
+        this.code = '302_PERMANENT_REDIRECT';
+    }
+}
+if (false) {
+    /** @type {?} */
+    DaffExternalRouterPermanentRedirectError.prototype.code;
+    /** @type {?} */
+    DaffExternalRouterPermanentRedirectError.prototype.redirectUrl;
+}
+
+/**
+ * @fileoverview added by tsickle
+ * Generated from: errors/temporary-redirect.ts
+ * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+/**
+ * An error thrown when the driver needs a URI to be temporarily redirected
+ * to another location.
+ */
+class DaffExternalRouterTemporaryRedirectError extends DaffInheritableError {
+    /**
+     * @param {?} redirectUrl
+     * @param {?=} message
+     */
+    constructor(redirectUrl, message) {
+        super(message);
+        this.redirectUrl = redirectUrl;
+        this.code = 'TEMPORARY_REDIRECT';
+    }
+}
+if (false) {
+    /** @type {?} */
+    DaffExternalRouterTemporaryRedirectError.prototype.code;
+    /** @type {?} */
+    DaffExternalRouterTemporaryRedirectError.prototype.redirectUrl;
+}
+
+/**
+ * @fileoverview added by tsickle
+ * Generated from: errors/server-error.ts
+ * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+/**
+ * An error thrown when the platform performing url resolution fails.
+ */
+class DaffExternalRouterServerError extends DaffInheritableError {
+    /**
+     * @param {?=} message
+     */
+    constructor(message) {
+        super(message);
+        this.code = '5xx_SERVER_ERROR';
+    }
+}
+if (false) {
+    /** @type {?} */
+    DaffExternalRouterServerError.prototype.code;
+}
+
+/**
+ * @fileoverview added by tsickle
+ * Generated from: processors/process-errors.ts
+ * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+/**
+ * Processes resolved URLs and throws the appropriate error so that External Router
+ * can handle routing errors.
+ * @type {?}
+ */
+const processErrors = (/**
+ * @param {?} url
+ * @return {?}
+ */
+(url) => {
+    if (url.code === 404) {
+        throw new DaffExternalRouterNotFoundError();
+    }
+    else if (url.code >= 400 && url.code < 500) {
+        throw new DaffExternalRouterClientError();
+    }
+    else if (url.code >= 500) {
+        throw new DaffExternalRouterServerError();
+    }
+    else {
+        return url;
+    }
+});
+
+/**
+ * @fileoverview added by tsickle
+ * Generated from: processors/process-redirect.ts
+ * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+/**
+ * Processes resolvedUrls and throws the appropriate error so that External Router
+ * can handle redirects.
+ * @type {?}
+ */
+const processRedirects = (/**
+ * @param {?} url
+ * @return {?}
+ */
+(url) => {
+    if (url.code === 301) {
+        throw new DaffExternalRouterPermanentRedirectError(url.url);
+    }
+    else if (url.code === 302) {
+        throw new DaffExternalRouterTemporaryRedirectError(url.url);
+    }
+    else {
+        return url;
+    }
+});
+
+/**
+ * @fileoverview added by tsickle
+ * Generated from: guard/existence.guard.ts
+ * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+/**
+ * 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.
+ */
+class DaffExternalRouterExistenceGuard {
+    /**
+     * @param {?} driver
+     * @param {?} externalRouter
+     * @param {?} router
+     * @param {?} config
+     * @param {?} urlNormalizer
+     */
+    constructor(driver, externalRouter, router, config, urlNormalizer) {
+        this.driver = driver;
+        this.externalRouter = externalRouter;
+        this.router = router;
+        this.config = config;
+        this.urlNormalizer = urlNormalizer;
+    }
+    /**
+     * @param {?} next
+     * @param {?} state
+     * @return {?}
+     */
+    canActivate(next, state) {
+        return this.driver.resolve(this.urlNormalizer.normalize(state.url)).pipe(map((/**
+         * @param {?} resolvedRoute
+         * @return {?}
+         */
+        (resolvedRoute) => processErrors(resolvedRoute))), switchMap((/**
+         * @param {?} resolvedRoute
+         * @return {?}
+         */
+        resolvedRoute => {
+            this.externalRouter.add(resolvedRoute);
+            return of(resolvedRoute);
+        })), map((/**
+         * @param {?} resolvedRoute
+         * @return {?}
+         */
+        (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((/**
+         * @return {?}
+         */
+        () => this.router.parseUrl(state.url))), 
+        // When we fail, we need to process errors as dictated by the error type.
+        // Handle redirects
+        catchError((/**
+         * @param {?} error
+         * @return {?}
+         */
+        error => {
+            if (!(error instanceof DaffExternalRouterPermanentRedirectError) &&
+                !(error instanceof DaffExternalRouterTemporaryRedirectError)) {
+                throw error;
+            }
+            return of(this.router.parseUrl(error.redirectUrl));
+        })), 
+        // Handle "404"
+        catchError((/**
+         * @param {?} error
+         * @return {?}
+         */
+        (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((/**
+         * @param {?} error
+         * @return {?}
+         */
+        (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));
+        })));
+    }
+}
+DaffExternalRouterExistenceGuard.decorators = [
+    { type: Injectable, args: [{
+                providedIn: 'root',
+            },] }
+];
+/** @nocollapse */
+DaffExternalRouterExistenceGuard.ctorParameters = () => [
+    { type: undefined, decorators: [{ type: Inject, args: [DaffExternalRouterDriver,] }] },
+    { type: DaffExternalRouter },
+    { type: Router },
+    { type: undefined, decorators: [{ type: Inject, args: [DAFF_EXTERNAL_ROUTER_CONFIG,] }] },
+    { type: DaffRoutingUriNormalizer }
+];
+/** @nocollapse */ DaffExternalRouterExistenceGuard.ɵprov = ɵɵdefineInjectable({ factory: function DaffExternalRouterExistenceGuard_Factory() { return new DaffExternalRouterExistenceGuard(ɵɵinject(DaffExternalRouterDriver), ɵɵinject(DaffExternalRouter), ɵɵinject(Router), ɵɵinject(DAFF_EXTERNAL_ROUTER_CONFIG), ɵɵinject(DaffRoutingUriNormalizer)); }, token: DaffExternalRouterExistenceGuard, providedIn: "root" });
+if (false) {
+    /**
+     * @type {?}
+     * @private
+     */
+    DaffExternalRouterExistenceGuard.prototype.driver;
+    /**
+     * @type {?}
+     * @private
+     */
+    DaffExternalRouterExistenceGuard.prototype.externalRouter;
+    /**
+     * @type {?}
+     * @private
+     */
+    DaffExternalRouterExistenceGuard.prototype.router;
+    /**
+     * @type {?}
+     * @private
+     */
+    DaffExternalRouterExistenceGuard.prototype.config;
+    /**
+     * @type {?}
+     * @private
+     */
+    DaffExternalRouterExistenceGuard.prototype.urlNormalizer;
+}
+
+/**
+ * @fileoverview added by tsickle
+ * Generated from: public_api.ts
+ * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+
+/**
+ * @fileoverview added by tsickle
+ * Generated from: index.ts
+ * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+
+/**
+ * @fileoverview added by tsickle
+ * Generated from: daffodil-external-router-routing.ts
+ * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+
+export { DaffExternalRouterExistenceGuard };
+//# sourceMappingURL=daffodil-external-router-routing.js.map

package/fesm2015/daffodil-external-router-routing.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"daffodil-external-router-routing.js","sources":["../../../libs/external-router/routing/src/errors/client-error.ts","../../../libs/external-router/routing/src/errors/not-found-error.ts","../../../libs/external-router/routing/src/errors/permanent-redirect.ts","../../../libs/external-router/routing/src/errors/temporary-redirect.ts","../../../libs/external-router/routing/src/errors/server-error.ts","../../../libs/external-router/routing/src/processors/process-errors.ts","../../../libs/external-router/routing/src/processors/process-redirect.ts","../../../libs/external-router/routing/src/guard/existence.guard.ts"],"sourcesContent":["import {\n  DaffError,\n  DaffInheritableError,\n} from '@daffodil/core';\n\n/**\n * An error thrown when the driver encounters a 4xx error.\n */\nexport class DaffExternalRouterClientError extends DaffInheritableError\n  implements DaffError {\n\tpublic readonly code: string = '4xx_CLIENT_ERROR';\n\n\tconstructor(message?: string) {\n\t  super(message);\n\t}\n}\n","import { DaffError } from '@daffodil/core';\n\nimport { DaffExternalRouterClientError } from './client-error';\n\n/**\n * An error thrown when the driver determines that a given url is not resolvable.\n */\nexport class DaffExternalRouterNotFoundError extends DaffExternalRouterClientError\n  implements DaffError {\n\tpublic readonly code: string = '404_NOT_FOUND';\n\n\tconstructor(message?: string) {\n\t  super(message);\n\t}\n}\n","import {\n  DaffError,\n  DaffInheritableError,\n} from '@daffodil/core';\n\n/**\n * An error thrown when the driver determines that the url needs to be routed somewhere\n * else permanently.\n */\nexport class DaffExternalRouterPermanentRedirectError extends DaffInheritableError\n  implements DaffError {\n\tpublic readonly code: string = '302_PERMANENT_REDIRECT';\n\n\tconstructor(public redirectUrl: string, message?: string) {\n\t  super(message);\n\t}\n}\n","import {\n  DaffError,\n  DaffInheritableError,\n} from '@daffodil/core';\n\n/**\n * An error thrown when the driver needs a URI to be temporarily redirected\n * to another location.\n */\nexport class DaffExternalRouterTemporaryRedirectError extends DaffInheritableError\n  implements DaffError {\n\tpublic readonly code: string = 'TEMPORARY_REDIRECT';\n\n\tconstructor(public redirectUrl: string, message?: string) {\n\t  super(message);\n\t}\n}\n","import {\n  DaffError,\n  DaffInheritableError,\n} from '@daffodil/core';\n\n/**\n * An error thrown when the platform performing url resolution fails.\n */\nexport class DaffExternalRouterServerError extends DaffInheritableError\n  implements DaffError {\n\tpublic readonly code: string = '5xx_SERVER_ERROR';\n\n\tconstructor(message?: string) {\n\t  super(message);\n\t}\n}\n","import { DaffExternallyResolvableUrl } from '@daffodil/external-router';\n\n\nimport { DaffExternalRouterClientError } from '../errors/client-error';\nimport { DaffExternalRouterNotFoundError } from '../errors/not-found-error';\nimport { DaffExternalRouterServerError } from '../errors/server-error';\n\n/**\n * Processes resolved URLs and throws the appropriate error so that External Router\n * can handle routing errors.\n */\nexport const processErrors = (url: DaffExternallyResolvableUrl): DaffExternallyResolvableUrl => {\n  if(url.code === 404 ){\n    throw new DaffExternalRouterNotFoundError();\n  } else if(url.code >= 400 && url.code < 500) {\n    throw new DaffExternalRouterClientError();\n  } else if(url.code >= 500) {\n    throw new DaffExternalRouterServerError();\n  } else {\n    return url;\n  }\n};\n","import { DaffExternallyResolvableUrl } from '@daffodil/external-router';\n\nimport { DaffExternalRouterPermanentRedirectError } from '../errors/permanent-redirect';\nimport { DaffExternalRouterTemporaryRedirectError } from '../errors/temporary-redirect';\n\n/**\n * Processes resolvedUrls and throws the appropriate error so that External Router\n * can handle redirects.\n */\nexport const processRedirects = (url: DaffExternallyResolvableUrl): DaffExternallyResolvableUrl => {\n  if(url.code === 301){\n    throw new DaffExternalRouterPermanentRedirectError(url.url);\n  } else if(url.code === 302) {\n    throw new DaffExternalRouterTemporaryRedirectError(url.url);\n  } else {\n    return url;\n  }\n};\n","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"],"names":[],"mappings":"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"}

package/fesm2015/daffodil-external-router.js

@@ -0,0 +1,489 @@
+import { CommonModule } from '@angular/common';
+import { InjectionToken, NgModule, Injectable, Inject, ɵɵdefineInjectable, ɵɵinject } from '@angular/core';
+import { Router } from '@angular/router';
+import { DaffInheritableError } from '@daffodil/core';
+import { daffUriTruncateLeadingSlash } from '@daffodil/core/routing';
+
+/**
+ * @fileoverview added by tsickle
+ * Generated from: config.ts
+ * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+/** @type {?} */
+const daffExternalRouterConfigurationDefault = {
+    failedResolutionPath: '/',
+    notFoundResolutionPath: '/',
+};
+/**
+ * The token holding the runtime configuration for the behavior of the
+ * `\@daffodil/external-router` package.
+ * @type {?}
+ */
+const DAFF_EXTERNAL_ROUTER_CONFIG = new InjectionToken('DAFF_EXTERNAL_ROUTER_CONFIG', {
+    providedIn: 'root',
+    factory: (/**
+     * @return {?}
+     */
+    () => daffExternalRouterConfigurationDefault),
+});
+/**
+ * The configuration object for the external router package.
+ * @record
+ */
+function DaffExternalRouterConfiguration() { }
+if (false) {
+    /**
+     * The path to redirect to when external route resolution fails.
+     * @type {?}
+     */
+    DaffExternalRouterConfiguration.prototype.failedResolutionPath;
+    /**
+     * The path to redirect to when the requested URL is not found.
+     * @type {?}
+     */
+    DaffExternalRouterConfiguration.prototype.notFoundResolutionPath;
+}
+
+/**
+ * @fileoverview added by tsickle
+ * Generated from: token/type-resolvable-routes.token.ts
+ * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+/**
+ * A multi-token that allows you to register route "types" that correspond to routes.
+ * @type {?}
+ */
+const DAFF_EXTERNAL_ROUTER_ROUTES_RESOLVABLE_BY_TYPE = new InjectionToken('DAFF_EXTERNAL_ROUTER_RESOLVABLE_TYPE_ROUTES', {
+    providedIn: 'root',
+    factory: (/**
+     * @return {?}
+     */
+    () => []),
+});
+/**
+ * A provider used to connect a type to a route to enable dynamic route resolution at runtime.
+ * @param {?} typeRoutePair
+ * @return {?}
+ */
+function daffProvideRouteResolvableByType(typeRoutePair) {
+    return {
+        provide: DAFF_EXTERNAL_ROUTER_ROUTES_RESOLVABLE_BY_TYPE,
+        multi: true,
+        useValue: typeRoutePair,
+    };
+}
+/**
+ * A multi-provider used to connect an array of types to their respective routes.
+ * @param {?} routes
+ * @return {?}
+ */
+function daffProvideRoutesResolvableByType(routes) {
+    return routes.map((/**
+     * @param {?} route
+     * @return {?}
+     */
+    (route) => ({
+        provide: DAFF_EXTERNAL_ROUTER_ROUTES_RESOLVABLE_BY_TYPE,
+        multi: true,
+        useValue: route,
+    })));
+}
+
+/**
+ * @fileoverview added by tsickle
+ * Generated from: external-router.module.ts
+ * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+/**
+ * The external `DaffExternalRouterModule` allows you to configure the
+ * `\@daffodil/external-router` package's behavior.
+ */
+class DaffExternalRouterModule {
+    /**
+     * @param {?} config
+     * @param {?=} routes
+     * @return {?}
+     */
+    static forRoot(config, routes = []) {
+        return {
+            ngModule: DaffExternalRouterModule,
+            providers: [
+                { provide: DAFF_EXTERNAL_ROUTER_CONFIG, useValue: Object.assign(Object.assign({}, daffExternalRouterConfigurationDefault), config) },
+                ...daffProvideRoutesResolvableByType(routes),
+            ],
+        };
+    }
+}
+DaffExternalRouterModule.decorators = [
+    { type: NgModule, args: [{
+                declarations: [],
+                imports: [CommonModule],
+            },] }
+];
+
+/**
+ * @fileoverview added by tsickle
+ * Generated from: model/public_api.ts
+ * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+
+/**
+ * @fileoverview added by tsickle
+ * Generated from: errors/no-wildcard.ts
+ * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+/**
+ * An error thrown when there was no wildcard route found in configuration
+ * of the Angular Router.
+ */
+class DaffExternalRouterNoWildcardError extends DaffInheritableError {
+    /**
+     * @param {?=} message
+     */
+    constructor(message) {
+        super(message);
+        this.code = 'NO_WILDCARD_ROUTE';
+    }
+}
+if (false) {
+    /** @type {?} */
+    DaffExternalRouterNoWildcardError.prototype.code;
+}
+
+/**
+ * @fileoverview added by tsickle
+ * Generated from: errors/unknown-type.ts
+ * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+/**
+ * An error thrown when there is a failure matching a configured route to a
+ * route type.
+ */
+class DaffExternalRouterUnknownRouteTypeError extends DaffInheritableError {
+    /**
+     * @param {?=} message
+     */
+    constructor(message) {
+        super(message);
+        this.code = 'UNKNOWN_ROUTE_TYPE';
+    }
+}
+if (false) {
+    /** @type {?} */
+    DaffExternalRouterUnknownRouteTypeError.prototype.code;
+}
+
+/**
+ * @fileoverview added by tsickle
+ * Generated from: transform/resolved-route-to-route.ts
+ * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+/**
+ * Transforms a DaffExternallyResolvableUrl into an Angular Route.
+ * @type {?}
+ */
+const daffTransformResolvedRouteToRoute = (/**
+ * @param {?} resolvedRoute
+ * @param {?} availableTypes
+ * @return {?}
+ */
+(resolvedRoute, availableTypes) => {
+    /** @type {?} */
+    const routeType = availableTypes
+        .filter((/**
+     * @param {?} t
+     * @return {?}
+     */
+    t => t.type === resolvedRoute.type))
+        .shift();
+    if (!routeType) {
+        throw new DaffExternalRouterUnknownRouteTypeError(`Unable to resolve the route '${resolvedRoute.url}'. Its type is '${resolvedRoute.type}' but a matching route wasn't found.`);
+    }
+    return {
+        route: Object.assign(Object.assign({ path: resolvedRoute.url }, routeType.route), { data: Object.assign({ daffExternalRouteType: resolvedRoute.type }, routeType.route.data) }),
+        insertionStrategy: routeType.insertionStrategy,
+    };
+});
+
+/**
+ * @fileoverview added by tsickle
+ * Generated from: router/strategies/insert-route-before-wildcard.ts
+ * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+/**
+ * Inserts a Route into Routes right before the wildcard route.
+ * If no wildcard is found, it fails fast with a `DaffExternalRouterNoWildcardError`.
+ * @type {?}
+ */
+const daffInsertRouteBeforeWildCardStrategy = (/**
+ * @param {?} route
+ * @param {?} routes
+ * @return {?}
+ */
+(route, routes) => {
+    /** @type {?} */
+    const index = routes.findIndex((/**
+     * @param {?} r
+     * @return {?}
+     */
+    (r) => r.path === '**'));
+    if (index === -1) {
+        throw new DaffExternalRouterNoWildcardError('No wildcard (**) route was found during route resolution.');
+    }
+    return [
+        ...routes.slice(0, index),
+        route,
+        ...routes.slice(index),
+    ];
+});
+
+/**
+ * @fileoverview added by tsickle
+ * Generated from: router/router.service.ts
+ * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+class DaffExternalRouter {
+    /**
+     * @param {?} router
+     * @param {?} runtimeRoutes
+     */
+    constructor(router, runtimeRoutes) {
+        this.router = router;
+        this.runtimeRoutes = runtimeRoutes;
+    }
+    /**
+     * Adds a route to the existing router configuration.
+     * @param {?} resolvedRoute
+     * @return {?}
+     */
+    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;
+        }
+    }
+}
+DaffExternalRouter.decorators = [
+    { type: Injectable, args: [{
+                providedIn: 'root',
+            },] }
+];
+/** @nocollapse */
+DaffExternalRouter.ctorParameters = () => [
+    { type: Router },
+    { type: Array, decorators: [{ type: Inject, args: [DAFF_EXTERNAL_ROUTER_ROUTES_RESOLVABLE_BY_TYPE,] }] }
+];
+/** @nocollapse */ DaffExternalRouter.ɵprov = ɵɵdefineInjectable({ factory: function DaffExternalRouter_Factory() { return new DaffExternalRouter(ɵɵinject(Router), ɵɵinject(DAFF_EXTERNAL_ROUTER_ROUTES_RESOLVABLE_BY_TYPE)); }, token: DaffExternalRouter, providedIn: "root" });
+if (false) {
+    /**
+     * @type {?}
+     * @private
+     */
+    DaffExternalRouter.prototype.router;
+    /**
+     * @type {?}
+     * @private
+     */
+    DaffExternalRouter.prototype.runtimeRoutes;
+}
+
+/**
+ * @fileoverview added by tsickle
+ * Generated from: router/strategies/insert-data-path.ts
+ * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+/**
+ * Tests whether or not a route matches a specific Daffodil Route type.
+ *
+ * See {\@link DaffRouteWithDataPath}
+ * @type {?}
+ */
+const routeMatchesRouteType = (/**
+ * @param {?} route
+ * @param {?} type
+ * @return {?}
+ */
+(route, type) => { var _a; return ((_a = route === null || route === void 0 ? void 0 : route.data) === null || _a === void 0 ? void 0 : _a.daffExternalRouteType) === type; });
+const ɵ0 = routeMatchesRouteType;
+/**
+ * Adds a path to the `daffPaths` of the given route.
+ *
+ * See {\@link DaffRouteWithDataPath}
+ * @type {?}
+ */
+const addRouteToDaffPaths = (/**
+ * @param {?} route
+ * @param {?} path
+ * @return {?}
+ */
+(route, path) => route.data.daffPaths = Object.assign(Object.assign({}, route.data.daffPaths), { [path]: path }));
+const ɵ1 = addRouteToDaffPaths;
+/** @type {?} */
+const operateOnRoute = (/**
+ * @param {?} externalRoute
+ * @return {?}
+ */
+(externalRoute) => (/**
+ * @param {?} route
+ * @return {?}
+ */
+(route) => addRouteToDaffPaths(route, externalRoute.path)));
+const ɵ2 = operateOnRoute;
+/**
+ * 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.
+ * @type {?}
+ */
+const traverseRouteTree = (/**
+ * @param {?=} routes
+ * @param {?=} matcher
+ * @param {?=} operate
+ * @return {?}
+ */
+(routes = [], matcher, operate) => {
+    if (routes.length === 0) {
+        return routes;
+    }
+    /** @type {?} */
+    const stack = [];
+    /** @type {?} */
+    const treeRoot = { children: routes };
+    stack.push(treeRoot);
+    while (stack.length) {
+        /** @type {?} */
+        const route = stack.pop();
+        if (matcher(route)) {
+            operate(route);
+            break;
+        }
+        if (route.children) {
+            stack.push(...route.children.reverse());
+        }
+    }
+    return routes;
+});
+const ɵ3 = traverseRouteTree;
+/**
+ * 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}
+ *
+ * @type {?}
+ */
+const daffInsertDataPathStrategy = (/**
+ * @param {?} externalRoute
+ * @param {?} routes
+ * @return {?}
+ */
+(externalRoute, routes) => traverseRouteTree(routes, (/**
+ * @param {?} route
+ * @return {?}
+ */
+(route) => { var _a; return routeMatchesRouteType(route, (_a = externalRoute.data) === null || _a === void 0 ? void 0 : _a.daffExternalRouteType); }), operateOnRoute(externalRoute)));
+
+/**
+ * @fileoverview added by tsickle
+ * Generated from: router/url-matcher/data-path-matcher.ts
+ * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+/**
+ * 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 }
+ * @type {?}
+ */
+const daffDataPathUrlMatcher = (/**
+ * @param {?} segments
+ * @param {?} group
+ * @param {?} route
+ * @return {?}
+ */
+(segments, group, route) => {
+    var _a;
+    /** @type {?} */
+    const path = daffUriTruncateLeadingSlash(segments.reduce((/**
+     * @param {?} acc
+     * @param {?} segment
+     * @return {?}
+     */
+    (acc, segment) => acc + '/' + segment.path), ''));
+    /** @type {?} */
+    const paths = (_a = route === null || route === void 0 ? void 0 : route.data) === null || _a === void 0 ? void 0 : _a.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;
+});
+
+/**
+ * @fileoverview added by tsickle
+ * Generated from: public_api.ts
+ * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+
+/**
+ * @fileoverview added by tsickle
+ * Generated from: daffodil-external-router.ts
+ * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+
+export { DAFF_EXTERNAL_ROUTER_CONFIG, DaffExternalRouter, DaffExternalRouterModule, DaffExternalRouterNoWildcardError, DaffExternalRouterUnknownRouteTypeError, daffDataPathUrlMatcher, daffInsertDataPathStrategy, daffInsertRouteBeforeWildCardStrategy, daffProvideRouteResolvableByType, DAFF_EXTERNAL_ROUTER_ROUTES_RESOLVABLE_BY_TYPE as ɵa, daffProvideRoutesResolvableByType as ɵb };
+//# sourceMappingURL=daffodil-external-router.js.map