@daffodil/external-router 0.38.9 → 0.39.3

package/fesm2015/daffodil-external-router.js

@@ -1,69 +1,31 @@
 import { CommonModule } from '@angular/common';
-import { InjectionToken, NgModule, Injectable, Inject, ɵɵdefineInjectable, ɵɵinject } from '@angular/core';
+import { InjectionToken, NgModule, ɵɵdefineInjectable, ɵɵinject, Injectable, 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 {?}
+ * `@daffodil/external-router` package.
  */
 const DAFF_EXTERNAL_ROUTER_CONFIG = new InjectionToken('DAFF_EXTERNAL_ROUTER_CONFIG', {
     providedIn: 'root',
-    factory: (/**
-     * @return {?}
-     */
-    () => daffExternalRouterConfigurationDefault),
+    factory: () => 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 {?}
-     */
-    () => []),
+    factory: () => [],
 });
 /**
  * A provider used to connect a type to a route to enable dynamic route resolution at runtime.
- * @param {?} typeRoutePair
- * @return {?}
  */
 function daffProvideRouteResolvableByType(typeRoutePair) {
     return {
@@ -74,36 +36,20 @@ function daffProvideRouteResolvableByType(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) => ({
+    return routes.map((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.
+ * `@daffodil/external-router` package's behavior.
  */
 class DaffExternalRouterModule {
-    /**
-     * @param {?} config
-     * @param {?=} routes
-     * @return {?}
-     */
     static forRoot(config, routes = []) {
         return {
             ngModule: DaffExternalRouterModule,
@@ -121,80 +67,34 @@ DaffExternalRouterModule.decorators = [
             },] }
 ];
 
-/**
- * @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 daffTransformResolvedRouteToRoute = (resolvedRoute, availableTypes) => {
     const routeType = availableTypes
-        .filter((/**
-     * @param {?} t
-     * @return {?}
-     */
-    t => t.type === resolvedRoute.type))
+        .filter(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.`);
@@ -203,30 +103,14 @@ const daffTransformResolvedRouteToRoute = (/**
         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 === '**'));
+const daffInsertRouteBeforeWildCardStrategy = (route, routes) => {
+    const index = routes.findIndex((r) => r.path === '**');
     if (index === -1) {
         throw new DaffExternalRouterNoWildcardError('No wildcard (**) route was found during route resolution.');
     }
@@ -235,26 +119,15 @@ const daffInsertRouteBeforeWildCardStrategy = (/**
         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.
@@ -271,6 +144,7 @@ class DaffExternalRouter {
         }
     }
 }
+/** @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" });
 DaffExternalRouter.decorators = [
     { type: Injectable, args: [{
                 providedIn: 'root',
@@ -281,86 +155,37 @@ 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 {?}
+ * See {@link DaffRouteWithDataPath}
  */
-(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 routeMatchesRouteType = (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 {?}
+ * See {@link DaffRouteWithDataPath}
  */
-const addRouteToDaffPaths = (/**
- * @param {?} route
- * @param {?} path
- * @return {?}
- */
-(route, path) => route.data.daffPaths = Object.assign(Object.assign({}, route.data.daffPaths), { [path]: path }));
+const addRouteToDaffPaths = (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 operateOnRoute = (externalRoute) => (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) => {
+const traverseRouteTree = (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);
@@ -371,17 +196,17 @@ const traverseRouteTree = (/**
         }
     }
     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
+ * 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.
+ * For example, you can provide the insertion strategy in the {@link DaffExternalRouterModule} as below.
  *
  * ```ts
  * DaffExternalRouterModule.forRoot({}, [
@@ -394,7 +219,7 @@ const ɵ3 = traverseRouteTree;
  * ```
  *
  * Then, you can match it with an associated route defined in your Routing
- * configuration with the {\@link daffDataPathUrlMatcher}.
+ * configuration with the {@link daffDataPathUrlMatcher}.
  *
  * ```ts
  *  export const routes: Routes = [
@@ -408,26 +233,11 @@ const ɵ3 = traverseRouteTree;
  * ]
  * ```
  *
- * See {\@link DaffRouteWithDataPath}
+ * 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)));
+const daffInsertDataPathStrategy = (externalRoute, routes) => traverseRouteTree(routes, (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.
@@ -443,26 +253,12 @@ const daffInsertDataPathStrategy = (/**
  *    }
  * ]
  * ```
- * {\@link daffInsertDataPathStrategy }
- * {\@link DaffRouteWithDataPath }
- * @type {?}
- */
-const daffDataPathUrlMatcher = (/**
- * @param {?} segments
- * @param {?} group
- * @param {?} route
- * @return {?}
+ * {@link daffInsertDataPathStrategy }
+ * {@link DaffRouteWithDataPath }
  */
-(segments, group, route) => {
+const daffDataPathUrlMatcher = (segments, group, route) => {
     var _a;
-    /** @type {?} */
-    const path = daffUriTruncateLeadingSlash(segments.reduce((/**
-     * @param {?} acc
-     * @param {?} segment
-     * @return {?}
-     */
-    (acc, segment) => acc + '/' + segment.path), ''));
-    /** @type {?} */
+    const path = daffUriTruncateLeadingSlash(segments.reduce((acc, segment) => acc + '/' + segment.path, ''));
     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) {
@@ -471,18 +267,14 @@ const daffDataPathUrlMatcher = (/**
     // 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
+/*
+ * Public API Surface of @daffodil/external-router
  */
 
 /**
- * @fileoverview added by tsickle
- * Generated from: daffodil-external-router.ts
- * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ * Generated bundle index. Do not edit.
  */
 
 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 };

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

@@ -1 +1 @@
-{"version":3,"file":"daffodil-external-router.js","sources":["../../../libs/external-router/src/config.ts","../../../libs/external-router/src/token/type-resolvable-routes.token.ts","../../../libs/external-router/src/external-router.module.ts","../../../libs/external-router/src/errors/no-wildcard.ts","../../../libs/external-router/src/errors/unknown-type.ts","../../../libs/external-router/src/transform/resolved-route-to-route.ts","../../../libs/external-router/src/router/strategies/insert-route-before-wildcard.ts","../../../libs/external-router/src/router/router.service.ts","../../../libs/external-router/src/router/strategies/insert-data-path.ts","../../../libs/external-router/src/router/url-matcher/data-path-matcher.ts"],"sourcesContent":["import { InjectionToken } from '@angular/core';\n\nexport const daffExternalRouterConfigurationDefault: DaffExternalRouterConfiguration = {\n  failedResolutionPath: '/',\n  notFoundResolutionPath: '/',\n};\n\n/**\n * The token holding the runtime configuration for the behavior of the\n * `@daffodil/external-router` package.\n */\nexport const DAFF_EXTERNAL_ROUTER_CONFIG = new InjectionToken<\n\tDaffExternalRouterConfiguration\n>('DAFF_EXTERNAL_ROUTER_CONFIG', {\n  providedIn: 'root',\n  factory: () => daffExternalRouterConfigurationDefault,\n});\n\n/**\n * The configuration object for the external router package.\n */\nexport interface DaffExternalRouterConfiguration {\n\t/**\n\t * The path to redirect to when external route resolution fails.\n\t */\n\tfailedResolutionPath: string;\n\n\t/**\n\t * The path to redirect to when the requested URL is not found.\n\t */\n\tnotFoundResolutionPath: string;\n}\n","import {\n  InjectionToken,\n  Provider,\n} from '@angular/core';\n\nimport { DaffExternalRouterInsertionStrategy } from '../model/insertion-strategy.type';\nimport { DaffExternalRouteType } from '../model/route-type';\nimport { DaffRouteWithoutPath } from '../model/route-without-path';\nimport { DaffTypeRoutePair } from '../model/type-route-pair';\n\n/**\n * A multi-token that allows you to register route \"types\" that correspond to routes.\n */\nexport const DAFF_EXTERNAL_ROUTER_ROUTES_RESOLVABLE_BY_TYPE = new InjectionToken<\n\tDaffTypeRoutePair[]\n>('DAFF_EXTERNAL_ROUTER_RESOLVABLE_TYPE_ROUTES', {\n  providedIn: 'root',\n  factory: () => [],\n});\n\n/**\n * A provider used to connect a type to a route to enable dynamic route resolution at runtime.\n */\nexport function daffProvideRouteResolvableByType(typeRoutePair: DaffTypeRoutePair): Provider {\n  return {\n    provide: DAFF_EXTERNAL_ROUTER_ROUTES_RESOLVABLE_BY_TYPE,\n    multi: true,\n    useValue: typeRoutePair,\n  };\n}\n\n/**\n * A multi-provider used to connect an array of types to their respective routes.\n */\nexport function daffProvideRoutesResolvableByType(routes: DaffTypeRoutePair[]): Provider[] {\n  return routes.map((route: DaffTypeRoutePair) => ({\n    provide: DAFF_EXTERNAL_ROUTER_ROUTES_RESOLVABLE_BY_TYPE,\n    multi: true,\n    useValue: route,\n  }));\n}\n","import { CommonModule } from '@angular/common';\nimport {\n  ModuleWithProviders,\n  NgModule,\n} from '@angular/core';\n\nimport {\n  DaffExternalRouterConfiguration,\n  DAFF_EXTERNAL_ROUTER_CONFIG,\n  daffExternalRouterConfigurationDefault,\n} from './config';\nimport { DaffTypeRoutePair } from './model/type-route-pair';\nimport { daffProvideRoutesResolvableByType } from './token/type-resolvable-routes.token';\n\n/**\n * The external `DaffExternalRouterModule` allows you to configure the\n * `@daffodil/external-router` package's behavior.\n */\n@NgModule({\n  declarations: [],\n  imports: [CommonModule],\n})\nexport class DaffExternalRouterModule {\n  static forRoot(\n    config: Partial<DaffExternalRouterConfiguration>,\n    routes: DaffTypeRoutePair[] = [],\n  ): ModuleWithProviders<DaffExternalRouterModule> {\n    return {\n      ngModule: DaffExternalRouterModule,\n      providers: [\n        { provide: DAFF_EXTERNAL_ROUTER_CONFIG, useValue: { ...daffExternalRouterConfigurationDefault, ...config }},\n        ...daffProvideRoutesResolvableByType(routes),\n      ],\n    };\n  }\n}\n","import {\n  DaffError,\n  DaffInheritableError,\n} from '@daffodil/core';\n\n/**\n * An error thrown when there was no wildcard route found in configuration\n * of the Angular Router.\n */\nexport class DaffExternalRouterNoWildcardError extends DaffInheritableError\n  implements DaffError {\n\tpublic readonly code: string = 'NO_WILDCARD_ROUTE';\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 there is a failure matching a configured route to a\n * route type.\n */\nexport class DaffExternalRouterUnknownRouteTypeError extends DaffInheritableError\n  implements DaffError {\n\tpublic readonly code: string = 'UNKNOWN_ROUTE_TYPE';\n\n\tconstructor(message?: string) {\n\t  super(message);\n\t}\n}\n","import { DaffExternalRouterUnknownRouteTypeError } from '../errors/unknown-type';\nimport { DaffExternallyResolvableUrl } from '../model/resolvable-route';\nimport { DaffRouteInfo } from '../model/route-info';\nimport { DaffTypeRoutePair } from '../model/type-route-pair';\n\n/**\n * Transforms a DaffExternallyResolvableUrl into an Angular Route.\n */\nexport const daffTransformResolvedRouteToRoute = (\n  resolvedRoute: DaffExternallyResolvableUrl,\n  availableTypes: DaffTypeRoutePair[],\n): DaffRouteInfo => {\n  const routeType = availableTypes\n    .filter(t => t.type === resolvedRoute.type)\n    .shift();\n  if (!routeType) {\n    throw new DaffExternalRouterUnknownRouteTypeError(\n      `Unable to resolve the route '${resolvedRoute.url}'. Its type is '${resolvedRoute.type}' but a matching route wasn't found.`,\n    );\n  }\n\n  return {\n    route: {\n      path: resolvedRoute.url,\n      ...routeType.route,\n      data: {\n        daffExternalRouteType: resolvedRoute.type,\n        ...routeType.route.data,\n      },\n    },\n    insertionStrategy: routeType.insertionStrategy,\n  };\n};\n","import {\n  Route,\n  Routes,\n} from '@angular/router';\n\nimport { DaffExternalRouterNoWildcardError } from '../../errors/no-wildcard';\nimport { DaffExternalRouterInsertionStrategy } from '../../model/insertion-strategy.type';\n\n/**\n * Inserts a Route into Routes right before the wildcard route.\n * If no wildcard is found, it fails fast with a `DaffExternalRouterNoWildcardError`.\n */\nexport const daffInsertRouteBeforeWildCardStrategy: DaffExternalRouterInsertionStrategy = (\n  route: Route,\n  routes: Routes,\n): Routes => {\n  const index = routes.findIndex((r: Route) => r.path === '**');\n  if (index === -1) {\n    throw new DaffExternalRouterNoWildcardError(\n      'No wildcard (**) route was found during route resolution.',\n    );\n  }\n  return [\n    ...routes.slice(0, index),\n    route,\n    ...routes.slice(index),\n  ];\n};\n","import {\n  Inject,\n  Injectable,\n} from '@angular/core';\nimport {\n  Router,\n  Route,\n} from '@angular/router';\n\n\nimport { DaffExternalRouterNoWildcardError } from '../errors/no-wildcard';\nimport { DaffExternallyResolvableUrl } from '../model/resolvable-route';\nimport { DaffTypeRoutePair } from '../model/type-route-pair';\nimport { DAFF_EXTERNAL_ROUTER_ROUTES_RESOLVABLE_BY_TYPE } from '../token/type-resolvable-routes.token';\nimport { daffTransformResolvedRouteToRoute } from '../transform/resolved-route-to-route';\nimport { daffInsertRouteBeforeWildCardStrategy } from './strategies/insert-route-before-wildcard';\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class DaffExternalRouter {\n  constructor(\n    private router: Router,\n    @Inject(DAFF_EXTERNAL_ROUTER_ROUTES_RESOLVABLE_BY_TYPE)\n    private runtimeRoutes: DaffTypeRoutePair[],\n  ) { }\n\n  /**\n   * Adds a route to the existing router configuration.\n   */\n  add(resolvedRoute: DaffExternallyResolvableUrl) {\n    //Get the route.\n    const {\n      route,\n      insertionStrategy,\n    } = daffTransformResolvedRouteToRoute(\n      resolvedRoute,\n      this.runtimeRoutes,\n    );\n\n    try {\n      //Add it to configuration.\n      this.router.config = (insertionStrategy || daffInsertRouteBeforeWildCardStrategy)(route, this.router.config);\n    } catch (e) {\n      if (e instanceof DaffExternalRouterNoWildcardError) {\n        throw new DaffExternalRouterNoWildcardError(\n          `${e.message} This usually means you have misconfigured your routes.`,\n        );\n      }\n\n      throw e;\n    }\n  }\n}\n","import {\n  Route,\n  Routes,\n} from '@angular/router';\n\nimport { DaffExternalRouterInsertionStrategy } from '../../model/insertion-strategy.type';\nimport { DaffExternalRouteType } from '../../model/route-type';\nimport { DaffRouteWithDataPath } from '../../model/route-with-data-path';\n\n/**\n * Tests whether or not a route matches a specific Daffodil Route type.\n *\n * See {@link DaffRouteWithDataPath}\n */\nconst routeMatchesRouteType = (route: DaffRouteWithDataPath, type: DaffExternalRouteType): boolean => route?.data?.daffExternalRouteType === type;\n\n/**\n * Adds a path to the `daffPaths` of the given route.\n *\n * See {@link DaffRouteWithDataPath}\n */\nconst addRouteToDaffPaths:\n  (route: DaffRouteWithDataPath, path: string) => Route =\n  (route: DaffRouteWithDataPath, path: string) => route.data.daffPaths  = {\n    ...route.data.daffPaths,\n    [path]: path,\n  };\n\nconst operateOnRoute = (externalRoute: Route): (route: Route) => Route =>\n  (route: DaffRouteWithDataPath) => addRouteToDaffPaths(route, externalRoute.path);\n\n/**\n * Traverse the router config tree, halting after the first match.\n * This traversal is implemented in a pre-order manner. As such, for large\n * configuration trees, it will be most efficient to place externally routed\n * components at the top of router configuration.\n */\nconst traverseRouteTree = (routes: Routes = [], matcher: (route: Route) => boolean, operate: (route: Route) => void): Routes => {\n  if(routes.length === 0) {\n    return routes;\n  }\n\n  const stack: Routes = [];\n  const treeRoot = { children: routes };\n  stack.push(treeRoot);\n\n  while(stack.length) {\n    const route = stack.pop();\n    if(matcher(route)) {\n      operate(route);\n      break;\n    }\n    if(route.children){\n      stack.push(...route.children.reverse());\n    }\n  }\n  return routes;\n};\n\n/**\n * A route insertion strategy that can be used to append external routes onto\n * existing Angular routes. This can be useful when you need to route to\n * an existing lazy-loaded module from multiple externally defined urls.\n *\n * This should be used in combination with the {@link daffDataPathUrlMatcher} to match lazy-loaded modules with\n * associated external urls.\n *\n * For example, you can provide the insertion strategy in the {@link DaffExternalRouterModule} as below.\n *\n * ```ts\n * DaffExternalRouterModule.forRoot({}, [\n *  {\n *    type: 'CATEGORY',\n *    insertionStrategy: daffInsertDataPathStrategy,\n *    route: {}\n *  }\n * ],\n * ```\n *\n * Then, you can match it with an associated route defined in your Routing\n * configuration with the {@link daffDataPathUrlMatcher}.\n *\n * ```ts\n *  export const routes: Routes = [\n *    {\n *      matcher: daffDataPathUrlMatcher,\n *      data: {\n *        daffExternalRouteType: \"CATEGORY\",\n *      },\n *      loadChildren: () => import('./category/category.module').then((m) => m.MyCategoryModule),\n *    }\n * ]\n * ```\n *\n * See {@link DaffRouteWithDataPath}\n *\n */\nexport const daffInsertDataPathStrategy: DaffExternalRouterInsertionStrategy = (externalRoute: DaffRouteWithDataPath, routes: Routes) => traverseRouteTree(\n  routes,\n  (route) => routeMatchesRouteType(route, externalRoute.data?.daffExternalRouteType),\n  operateOnRoute(externalRoute),\n);\n","import {\n  UrlMatcher,\n  UrlSegment,\n  UrlSegmentGroup,\n} from '@angular/router';\n\nimport { daffUriTruncateLeadingSlash } from '@daffodil/core/routing';\n\nimport { DaffRouteWithDataPath } from '../../model/public_api';\n\n/**\n * A UrlMatcher that does an exact match against a path stored in the special\n * configuration fields that External Router stores on a Route's data.\n *\n * ```ts\n *  export const routes: Routes = [\n *    {\n *      matcher: daffDataPathUrlMatcher,\n *      data: {\n *        daffExternalRouteType: \"CATEGORY\",\n *      },\n *      loadChildren: () => import('./category/category.module').then((m) => m.ShopCategoryModule),\n *    }\n * ]\n * ```\n * {@link daffInsertDataPathStrategy }\n * {@link DaffRouteWithDataPath }\n */\nexport const daffDataPathUrlMatcher: UrlMatcher = (segments: UrlSegment[], group: UrlSegmentGroup, route: DaffRouteWithDataPath) => {\n  const path = daffUriTruncateLeadingSlash(segments.reduce((acc: string, segment) => acc + '/' + segment.path, ''));\n  const paths = route?.data?.daffPaths;\n\n  // If we don't have any paths, we can safely fail a match.\n  if(!paths) {\n    return null;\n  }\n\n  // Otherwise, look up the path in the dictionary, failing if a match isn't found,\n  // but matching the entire segment if a match is found.\n  return path in paths ?  { consumed: segments } : null;\n};\n\n"],"names":[],"mappings":"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"}
+{"version":3,"file":"daffodil-external-router.js","sources":["../../../libs/external-router/src/config.ts","../../../libs/external-router/src/token/type-resolvable-routes.token.ts","../../../libs/external-router/src/external-router.module.ts","../../../libs/external-router/src/errors/no-wildcard.ts","../../../libs/external-router/src/errors/unknown-type.ts","../../../libs/external-router/src/transform/resolved-route-to-route.ts","../../../libs/external-router/src/router/strategies/insert-route-before-wildcard.ts","../../../libs/external-router/src/router/router.service.ts","../../../libs/external-router/src/router/strategies/insert-data-path.ts","../../../libs/external-router/src/router/url-matcher/data-path-matcher.ts","../../../libs/external-router/src/public_api.ts","../../../libs/external-router/src/daffodil-external-router.ts"],"sourcesContent":["import { InjectionToken } from '@angular/core';\n\nexport const daffExternalRouterConfigurationDefault: DaffExternalRouterConfiguration = {\n  failedResolutionPath: '/',\n  notFoundResolutionPath: '/',\n};\n\n/**\n * The token holding the runtime configuration for the behavior of the\n * `@daffodil/external-router` package.\n */\nexport const DAFF_EXTERNAL_ROUTER_CONFIG = new InjectionToken<\n\tDaffExternalRouterConfiguration\n>('DAFF_EXTERNAL_ROUTER_CONFIG', {\n  providedIn: 'root',\n  factory: () => daffExternalRouterConfigurationDefault,\n});\n\n/**\n * The configuration object for the external router package.\n */\nexport interface DaffExternalRouterConfiguration {\n\t/**\n\t * The path to redirect to when external route resolution fails.\n\t */\n\tfailedResolutionPath: string;\n\n\t/**\n\t * The path to redirect to when the requested URL is not found.\n\t */\n\tnotFoundResolutionPath: string;\n}\n","import {\n  InjectionToken,\n  Provider,\n} from '@angular/core';\n\nimport { DaffExternalRouterInsertionStrategy } from '../model/insertion-strategy.type';\nimport { DaffExternalRouteType } from '../model/route-type';\nimport { DaffRouteWithoutPath } from '../model/route-without-path';\nimport { DaffTypeRoutePair } from '../model/type-route-pair';\n\n/**\n * A multi-token that allows you to register route \"types\" that correspond to routes.\n */\nexport const DAFF_EXTERNAL_ROUTER_ROUTES_RESOLVABLE_BY_TYPE = new InjectionToken<\n\tDaffTypeRoutePair[]\n>('DAFF_EXTERNAL_ROUTER_RESOLVABLE_TYPE_ROUTES', {\n  providedIn: 'root',\n  factory: () => [],\n});\n\n/**\n * A provider used to connect a type to a route to enable dynamic route resolution at runtime.\n */\nexport function daffProvideRouteResolvableByType(typeRoutePair: DaffTypeRoutePair): Provider {\n  return {\n    provide: DAFF_EXTERNAL_ROUTER_ROUTES_RESOLVABLE_BY_TYPE,\n    multi: true,\n    useValue: typeRoutePair,\n  };\n}\n\n/**\n * A multi-provider used to connect an array of types to their respective routes.\n */\nexport function daffProvideRoutesResolvableByType(routes: DaffTypeRoutePair[]): Provider[] {\n  return routes.map((route: DaffTypeRoutePair) => ({\n    provide: DAFF_EXTERNAL_ROUTER_ROUTES_RESOLVABLE_BY_TYPE,\n    multi: true,\n    useValue: route,\n  }));\n}\n","import { CommonModule } from '@angular/common';\nimport {\n  ModuleWithProviders,\n  NgModule,\n} from '@angular/core';\n\nimport {\n  DaffExternalRouterConfiguration,\n  DAFF_EXTERNAL_ROUTER_CONFIG,\n  daffExternalRouterConfigurationDefault,\n} from './config';\nimport { DaffTypeRoutePair } from './model/type-route-pair';\nimport { daffProvideRoutesResolvableByType } from './token/type-resolvable-routes.token';\n\n/**\n * The external `DaffExternalRouterModule` allows you to configure the\n * `@daffodil/external-router` package's behavior.\n */\n@NgModule({\n  declarations: [],\n  imports: [CommonModule],\n})\nexport class DaffExternalRouterModule {\n  static forRoot(\n    config: Partial<DaffExternalRouterConfiguration>,\n    routes: DaffTypeRoutePair[] = [],\n  ): ModuleWithProviders<DaffExternalRouterModule> {\n    return {\n      ngModule: DaffExternalRouterModule,\n      providers: [\n        { provide: DAFF_EXTERNAL_ROUTER_CONFIG, useValue: { ...daffExternalRouterConfigurationDefault, ...config }},\n        ...daffProvideRoutesResolvableByType(routes),\n      ],\n    };\n  }\n}\n","import {\n  DaffError,\n  DaffInheritableError,\n} from '@daffodil/core';\n\n/**\n * An error thrown when there was no wildcard route found in configuration\n * of the Angular Router.\n */\nexport class DaffExternalRouterNoWildcardError extends DaffInheritableError\n  implements DaffError {\n\tpublic readonly code: string = 'NO_WILDCARD_ROUTE';\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 there is a failure matching a configured route to a\n * route type.\n */\nexport class DaffExternalRouterUnknownRouteTypeError extends DaffInheritableError\n  implements DaffError {\n\tpublic readonly code: string = 'UNKNOWN_ROUTE_TYPE';\n\n\tconstructor(message?: string) {\n\t  super(message);\n\t}\n}\n","import { DaffExternalRouterUnknownRouteTypeError } from '../errors/unknown-type';\nimport { DaffExternallyResolvableUrl } from '../model/resolvable-route';\nimport { DaffRouteInfo } from '../model/route-info';\nimport { DaffTypeRoutePair } from '../model/type-route-pair';\n\n/**\n * Transforms a DaffExternallyResolvableUrl into an Angular Route.\n */\nexport const daffTransformResolvedRouteToRoute = (\n  resolvedRoute: DaffExternallyResolvableUrl,\n  availableTypes: DaffTypeRoutePair[],\n): DaffRouteInfo => {\n  const routeType = availableTypes\n    .filter(t => t.type === resolvedRoute.type)\n    .shift();\n  if (!routeType) {\n    throw new DaffExternalRouterUnknownRouteTypeError(\n      `Unable to resolve the route '${resolvedRoute.url}'. Its type is '${resolvedRoute.type}' but a matching route wasn't found.`,\n    );\n  }\n\n  return {\n    route: {\n      path: resolvedRoute.url,\n      ...routeType.route,\n      data: {\n        daffExternalRouteType: resolvedRoute.type,\n        ...routeType.route.data,\n      },\n    },\n    insertionStrategy: routeType.insertionStrategy,\n  };\n};\n","import {\n  Route,\n  Routes,\n} from '@angular/router';\n\nimport { DaffExternalRouterNoWildcardError } from '../../errors/no-wildcard';\nimport { DaffExternalRouterInsertionStrategy } from '../../model/insertion-strategy.type';\n\n/**\n * Inserts a Route into Routes right before the wildcard route.\n * If no wildcard is found, it fails fast with a `DaffExternalRouterNoWildcardError`.\n */\nexport const daffInsertRouteBeforeWildCardStrategy: DaffExternalRouterInsertionStrategy = (\n  route: Route,\n  routes: Routes,\n): Routes => {\n  const index = routes.findIndex((r: Route) => r.path === '**');\n  if (index === -1) {\n    throw new DaffExternalRouterNoWildcardError(\n      'No wildcard (**) route was found during route resolution.',\n    );\n  }\n  return [\n    ...routes.slice(0, index),\n    route,\n    ...routes.slice(index),\n  ];\n};\n","import {\n  Inject,\n  Injectable,\n} from '@angular/core';\nimport {\n  Router,\n  Route,\n} from '@angular/router';\n\n\nimport { DaffExternalRouterNoWildcardError } from '../errors/no-wildcard';\nimport { DaffExternallyResolvableUrl } from '../model/resolvable-route';\nimport { DaffTypeRoutePair } from '../model/type-route-pair';\nimport { DAFF_EXTERNAL_ROUTER_ROUTES_RESOLVABLE_BY_TYPE } from '../token/type-resolvable-routes.token';\nimport { daffTransformResolvedRouteToRoute } from '../transform/resolved-route-to-route';\nimport { daffInsertRouteBeforeWildCardStrategy } from './strategies/insert-route-before-wildcard';\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class DaffExternalRouter {\n  constructor(\n    private router: Router,\n    @Inject(DAFF_EXTERNAL_ROUTER_ROUTES_RESOLVABLE_BY_TYPE)\n    private runtimeRoutes: DaffTypeRoutePair[],\n  ) { }\n\n  /**\n   * Adds a route to the existing router configuration.\n   */\n  add(resolvedRoute: DaffExternallyResolvableUrl) {\n    //Get the route.\n    const {\n      route,\n      insertionStrategy,\n    } = daffTransformResolvedRouteToRoute(\n      resolvedRoute,\n      this.runtimeRoutes,\n    );\n\n    try {\n      //Add it to configuration.\n      this.router.config = (insertionStrategy || daffInsertRouteBeforeWildCardStrategy)(route, this.router.config);\n    } catch (e) {\n      if (e instanceof DaffExternalRouterNoWildcardError) {\n        throw new DaffExternalRouterNoWildcardError(\n          `${e.message} This usually means you have misconfigured your routes.`,\n        );\n      }\n\n      throw e;\n    }\n  }\n}\n","import {\n  Route,\n  Routes,\n} from '@angular/router';\n\nimport { DaffExternalRouterInsertionStrategy } from '../../model/insertion-strategy.type';\nimport { DaffExternalRouteType } from '../../model/route-type';\nimport { DaffRouteWithDataPath } from '../../model/route-with-data-path';\n\n/**\n * Tests whether or not a route matches a specific Daffodil Route type.\n *\n * See {@link DaffRouteWithDataPath}\n */\nconst routeMatchesRouteType = (route: DaffRouteWithDataPath, type: DaffExternalRouteType): boolean => route?.data?.daffExternalRouteType === type;\n\n/**\n * Adds a path to the `daffPaths` of the given route.\n *\n * See {@link DaffRouteWithDataPath}\n */\nconst addRouteToDaffPaths:\n  (route: DaffRouteWithDataPath, path: string) => Route =\n  (route: DaffRouteWithDataPath, path: string) => route.data.daffPaths  = {\n    ...route.data.daffPaths,\n    [path]: path,\n  };\n\nconst operateOnRoute = (externalRoute: Route): (route: Route) => Route =>\n  (route: DaffRouteWithDataPath) => addRouteToDaffPaths(route, externalRoute.path);\n\n/**\n * Traverse the router config tree, halting after the first match.\n * This traversal is implemented in a pre-order manner. As such, for large\n * configuration trees, it will be most efficient to place externally routed\n * components at the top of router configuration.\n */\nconst traverseRouteTree = (routes: Routes = [], matcher: (route: Route) => boolean, operate: (route: Route) => void): Routes => {\n  if(routes.length === 0) {\n    return routes;\n  }\n\n  const stack: Routes = [];\n  const treeRoot = { children: routes };\n  stack.push(treeRoot);\n\n  while(stack.length) {\n    const route = stack.pop();\n    if(matcher(route)) {\n      operate(route);\n      break;\n    }\n    if(route.children){\n      stack.push(...route.children.reverse());\n    }\n  }\n  return routes;\n};\n\n/**\n * A route insertion strategy that can be used to append external routes onto\n * existing Angular routes. This can be useful when you need to route to\n * an existing lazy-loaded module from multiple externally defined urls.\n *\n * This should be used in combination with the {@link daffDataPathUrlMatcher} to match lazy-loaded modules with\n * associated external urls.\n *\n * For example, you can provide the insertion strategy in the {@link DaffExternalRouterModule} as below.\n *\n * ```ts\n * DaffExternalRouterModule.forRoot({}, [\n *  {\n *    type: 'CATEGORY',\n *    insertionStrategy: daffInsertDataPathStrategy,\n *    route: {}\n *  }\n * ],\n * ```\n *\n * Then, you can match it with an associated route defined in your Routing\n * configuration with the {@link daffDataPathUrlMatcher}.\n *\n * ```ts\n *  export const routes: Routes = [\n *    {\n *      matcher: daffDataPathUrlMatcher,\n *      data: {\n *        daffExternalRouteType: \"CATEGORY\",\n *      },\n *      loadChildren: () => import('./category/category.module').then((m) => m.MyCategoryModule),\n *    }\n * ]\n * ```\n *\n * See {@link DaffRouteWithDataPath}\n *\n */\nexport const daffInsertDataPathStrategy: DaffExternalRouterInsertionStrategy = (externalRoute: DaffRouteWithDataPath, routes: Routes) => traverseRouteTree(\n  routes,\n  (route) => routeMatchesRouteType(route, externalRoute.data?.daffExternalRouteType),\n  operateOnRoute(externalRoute),\n);\n","import {\n  UrlMatcher,\n  UrlSegment,\n  UrlSegmentGroup,\n} from '@angular/router';\n\nimport { daffUriTruncateLeadingSlash } from '@daffodil/core/routing';\n\nimport { DaffRouteWithDataPath } from '../../model/public_api';\n\n/**\n * A UrlMatcher that does an exact match against a path stored in the special\n * configuration fields that External Router stores on a Route's data.\n *\n * ```ts\n *  export const routes: Routes = [\n *    {\n *      matcher: daffDataPathUrlMatcher,\n *      data: {\n *        daffExternalRouteType: \"CATEGORY\",\n *      },\n *      loadChildren: () => import('./category/category.module').then((m) => m.ShopCategoryModule),\n *    }\n * ]\n * ```\n * {@link daffInsertDataPathStrategy }\n * {@link DaffRouteWithDataPath }\n */\nexport const daffDataPathUrlMatcher: UrlMatcher = (segments: UrlSegment[], group: UrlSegmentGroup, route: DaffRouteWithDataPath) => {\n  const path = daffUriTruncateLeadingSlash(segments.reduce((acc: string, segment) => acc + '/' + segment.path, ''));\n  const paths = route?.data?.daffPaths;\n\n  // If we don't have any paths, we can safely fail a match.\n  if(!paths) {\n    return null;\n  }\n\n  // Otherwise, look up the path in the dictionary, failing if a match isn't found,\n  // but matching the entire segment if a match is found.\n  return path in paths ?  { consumed: segments } : null;\n};\n\n","/*\n * Public API Surface of @daffodil/external-router\n */\n\nexport { DaffExternalRouterModule } from './external-router.module';\n\nexport {\n  DAFF_EXTERNAL_ROUTER_CONFIG,\n  DaffExternalRouterConfiguration,\n} from './config';\n\nexport { daffProvideRouteResolvableByType } from './token/type-resolvable-routes.token';\n\nexport * from './model/public_api';\n\nexport { DaffExternalRouter } from './router/router.service';\nexport { daffInsertRouteBeforeWildCardStrategy } from './router/strategies/insert-route-before-wildcard';\n\nexport { daffInsertDataPathStrategy } from './router/strategies/insert-data-path';\nexport { daffDataPathUrlMatcher } from './router/url-matcher/data-path-matcher';\n\nexport { DaffExternalRouterNoWildcardError } from './errors/no-wildcard';\nexport { DaffExternalRouterUnknownRouteTypeError } from './errors/unknown-type';\n","/**\n * Generated bundle index. Do not edit.\n */\n\nexport * from './public_api';\n\nexport {DAFF_EXTERNAL_ROUTER_ROUTES_RESOLVABLE_BY_TYPE as ɵa,daffProvideRoutesResolvableByType as ɵb} from './token/type-resolvable-routes.token';"],"names":[],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@daffodil/external-router",
-  "version": "0.38.9",
+  "version": "0.39.3",
   "description": "A platform-agnostic package that connects the @angular/router with an external routing service (e.g. an API), allowing for runtime route resolution.",
   "repository": {
     "type": "git",
@@ -16,12 +16,12 @@
     "@angular/common": "^11.0.0",
     "@angular/core": "^11.0.0",
     "@angular/router": "^11.0.0",
-    "@daffodil/core": "0.38.9",
+    "@daffodil/core": "0.39.3",
     "rxjs": "6.6.3"
   },
   "optionalDependencies": {
     "apollo-angular": "^2.4.0",
-    "@daffodil/driver": "0.38.9"
+    "@daffodil/driver": "0.39.3"
   },
   "main": "bundles/daffodil-external-router.umd.js",
   "module": "fesm2015/daffodil-external-router.js",

package/routing/package.json

@@ -8,4 +8,4 @@
   "typings": "daffodil-external-router-routing.d.ts",
   "metadata": "daffodil-external-router-routing.metadata.json",
   "sideEffects": false
-}
+}