@daffodil/external-router 0.38.7

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

@@ -0,0 +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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"}

package/model/insertion-strategy.type.d.ts

@@ -0,0 +1,8 @@
+import { Route, Routes } from '@angular/router';
+/**
+ * A function used to insert a route into a routing config.
+ * The entire routing configuration will be replaced by the return value
+ * so a typical usage should not modify the config beyond simply adding the route
+ * to the desired location.
+ */
+export declare type DaffExternalRouterInsertionStrategy = (route: Route, routes: Routes) => Routes;

package/model/public_api.d.ts

@@ -0,0 +1,7 @@
+export { DaffExternalRouterInsertionStrategy } from './insertion-strategy.type';
+export { DaffExternallyResolvableUrl } from './resolvable-route';
+export { DaffRouteInfo } from './route-info';
+export { DaffExternalRouteType } from './route-type';
+export { DaffRouteWithoutPath } from './route-without-path';
+export { DaffTypeRoutePair } from './type-route-pair';
+export { DaffRouteWithDataPath } from './route-with-data-path';

package/model/resolvable-route.d.ts

@@ -0,0 +1,27 @@
+import { DaffIdentifiable } from '@daffodil/core';
+import { DaffExternalRouteType } from './route-type';
+/**
+ * A `DaffExternallyResolvableUrl` describes the relationship between a "type" of route
+ * as determined by an external platform and a URI.
+ *
+ * ```ts
+ * export const resolvableRoute: DaffExternallyResolvableUrl = {
+ *  id: "id-of-resource",
+ * 	url: "some/path/to-a-resource",
+ * 	type: "RESOURCE_TYPE"
+ * }
+ * ```
+ */
+export interface DaffExternallyResolvableUrl extends DaffIdentifiable {
+    /**
+     * The URL that will be used for the path of the route inserted
+     * into the Angular routing config.
+     * Should not contain URL fragments, query parameters, or leading slashes.
+     */
+    url: string;
+    type: DaffExternalRouteType;
+    /**
+     * The HTTP status code for the resolvable route.
+     */
+    code: number;
+}

package/model/route-info.d.ts

@@ -0,0 +1,9 @@
+import { DaffExternalRouterInsertionStrategy } from './insertion-strategy.type';
+import { DaffRouteWithDataPath } from './route-with-data-path';
+/**
+ * An object containing the info needed to insert a route into a configuration.
+ */
+export interface DaffRouteInfo {
+    route: DaffRouteWithDataPath;
+    insertionStrategy?: DaffExternalRouterInsertionStrategy;
+}

package/model/route-type.d.ts

@@ -0,0 +1,6 @@
+/**
+ * The routing type of a particular route. E.g. if there's a category
+ * called "Sweatshirts" with an externally resolved URL of "/sweatshirts"
+ * Then, this type could be something like "CATEGORY".
+ */
+export declare type DaffExternalRouteType = string;

package/model/route-with-data-path.d.ts

@@ -0,0 +1,15 @@
+import { Route } from '@angular/router';
+import { DaffExternalRouteType } from './route-type';
+/**
+ * A type that describes the special data that Daffodil will look for when attempting
+ * to match a route based upon path data stored in the `data` key of a route.
+ *
+ * {@link daffDataPathUrlMatcher}
+ * {@link daffInsertDataPathStrategy}
+ */
+export declare type DaffRouteWithDataPath = Route & {
+    data?: {
+        daffExternalRouteType?: DaffExternalRouteType;
+        daffPaths?: Record<string, string>;
+    };
+};

package/model/route-without-path.d.ts

@@ -0,0 +1,7 @@
+import { Route } from '@angular/router';
+/**
+ * A DaffRouteWithoutPath is a special kind of route definition without a path.
+ * This is useful when defining routes that aren't provided a path initially,
+ * but will be provided with one at a later time, e.g. at runtime.
+ */
+export declare type DaffRouteWithoutPath = Omit<Route, 'path'>;

package/model/type-route-pair.d.ts

@@ -0,0 +1,26 @@
+import { DaffExternalRouterInsertionStrategy } from './insertion-strategy.type';
+import { DaffExternalRouteType } from './route-type';
+import { DaffRouteWithoutPath } from './route-without-path';
+/**
+ * A model used to describe the relationship between a {@link DaffExternalRouterType}
+ * and its corresponding route.
+ *
+ * The DaffTypeRoutePair is the pre-provided "glue" that a developer will provide
+ * ahead-of-time so that that the External Router knows what the list of available
+ * "types" are (along with that type's corresponding route).
+ *
+ * An insertion strategy can be specified if the route needs to be inserted somewhere
+ * other than the root of the route config.
+ * Omitting the insertion strategy will default to inserting the route to the root level,
+ * immediately before the wildcard route.
+ *
+ * @docs-private
+ */
+export interface DaffTypeRoutePair {
+    type: DaffExternalRouteType;
+    route: DaffRouteWithoutPath;
+    /**
+     * An optional function to provide route insertion behavior.
+     */
+    insertionStrategy?: DaffExternalRouterInsertionStrategy;
+}

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "@daffodil/external-router",
+  "version": "0.38.7",
+  "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",
+    "url": "https://github.com/graycoreio/daffodil"
+  },
+  "author": "Graycore LLC",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/graycoreio/daffodil/issues"
+  },
+  "homepage": "https://github.com/graycoreio/daffodil",
+  "peerDependencies": {
+    "@angular/common": "^10.0.0",
+    "@angular/core": "^10.0.0",
+    "@angular/router": "^10.0.0",
+    "@daffodil/core": "0.38.7",
+    "rxjs": "6.6.3"
+  },
+  "optionalDependencies": {
+    "apollo-angular": "^2.4.0",
+    "@daffodil/driver": "0.38.7"
+  },
+  "main": "bundles/daffodil-external-router.umd.js",
+  "module": "fesm2015/daffodil-external-router.js",
+  "es2015": "fesm2015/daffodil-external-router.js",
+  "esm2015": "esm2015/daffodil-external-router.js",
+  "fesm2015": "fesm2015/daffodil-external-router.js",
+  "typings": "daffodil-external-router.d.ts",
+  "metadata": "daffodil-external-router.metadata.json",
+  "sideEffects": false,
+  "dependencies": {
+    "tslib": "^2.0.0"
+  }
+}

package/public_api.d.ts

@@ -0,0 +1,10 @@
+export { DaffExternalRouterModule } from './external-router.module';
+export { DAFF_EXTERNAL_ROUTER_CONFIG, DaffExternalRouterConfiguration, } from './config';
+export { daffProvideRouteResolvableByType } from './token/type-resolvable-routes.token';
+export * from './model/public_api';
+export { DaffExternalRouter } from './router/router.service';
+export { daffInsertRouteBeforeWildCardStrategy } from './router/strategies/insert-route-before-wildcard';
+export { daffInsertDataPathStrategy } from './router/strategies/insert-data-path';
+export { daffDataPathUrlMatcher } from './router/url-matcher/data-path-matcher';
+export { DaffExternalRouterNoWildcardError } from './errors/no-wildcard';
+export { DaffExternalRouterUnknownRouteTypeError } from './errors/unknown-type';

package/router/router.service.d.ts

@@ -0,0 +1,12 @@
+import { Router } from '@angular/router';
+import { DaffExternallyResolvableUrl } from '../model/resolvable-route';
+import { DaffTypeRoutePair } from '../model/type-route-pair';
+export declare class DaffExternalRouter {
+    private router;
+    private runtimeRoutes;
+    constructor(router: Router, runtimeRoutes: DaffTypeRoutePair[]);
+    /**
+     * Adds a route to the existing router configuration.
+     */
+    add(resolvedRoute: DaffExternallyResolvableUrl): void;
+}

package/router/strategies/insert-data-path.d.ts

@@ -0,0 +1,40 @@
+import { DaffExternalRouterInsertionStrategy } from '../../model/insertion-strategy.type';
+/**
+ * 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 declare const daffInsertDataPathStrategy: DaffExternalRouterInsertionStrategy;

package/router/strategies/insert-route-before-wildcard.d.ts

@@ -0,0 +1,6 @@
+import { DaffExternalRouterInsertionStrategy } from '../../model/insertion-strategy.type';
+/**
+ * Inserts a Route into Routes right before the wildcard route.
+ * If no wildcard is found, it fails fast with a `DaffExternalRouterNoWildcardError`.
+ */
+export declare const daffInsertRouteBeforeWildCardStrategy: DaffExternalRouterInsertionStrategy;

package/router/url-matcher/data-path-matcher.d.ts

@@ -0,0 +1,20 @@
+import { UrlMatcher } from '@angular/router';
+/**
+ * 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 declare const daffDataPathUrlMatcher: UrlMatcher;

package/routing/daffodil-external-router-routing.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './index';

package/routing/daffodil-external-router-routing.metadata.json

@@ -0,0 +1 @@
+{"__symbolic":"module","version":4,"metadata":{"DaffExternalRouterExistenceGuard":{"__symbolic":"class","decorators":[{"__symbolic":"call","expression":{"__symbolic":"reference","module":"@angular/core","name":"Injectable","line":46,"character":1},"arguments":[{"providedIn":"root"}]}],"members":{"__ctor__":[{"__symbolic":"constructor","parameterDecorators":[[{"__symbolic":"call","expression":{"__symbolic":"reference","module":"@angular/core","name":"Inject","line":51,"character":5},"arguments":[{"__symbolic":"reference","module":"@daffodil/external-router/driver","name":"DaffExternalRouterDriver","line":51,"character":12}]}],null,null,[{"__symbolic":"call","expression":{"__symbolic":"reference","module":"@angular/core","name":"Inject","line":55,"character":5},"arguments":[{"__symbolic":"reference","module":"@daffodil/external-router","name":"DAFF_EXTERNAL_ROUTER_CONFIG","line":55,"character":12}]}],null],"parameters":[{"__symbolic":"reference","module":"@daffodil/external-router/driver","name":"DaffExternalRouterDriverInterface","line":52,"character":20},{"__symbolic":"reference","module":"@daffodil/external-router","name":"DaffExternalRouter","line":53,"character":28},{"__symbolic":"reference","module":"@angular/router","name":"Router","line":54,"character":20},{"__symbolic":"reference","module":"@daffodil/external-router","name":"DaffExternalRouterConfiguration","line":56,"character":20},{"__symbolic":"reference","module":"@daffodil/core/routing","name":"DaffRoutingUriNormalizer","line":57,"character":27}]}],"canActivate":[{"__symbolic":"method"}]},"statics":{"ɵprov":{}}}},"origins":{"DaffExternalRouterExistenceGuard":"./guard/existence.guard"},"importAs":"@daffodil/external-router/routing"}

package/routing/errors/client-error.d.ts

@@ -0,0 +1,8 @@
+import { DaffError, DaffInheritableError } from '@daffodil/core';
+/**
+ * An error thrown when the driver encounters a 4xx error.
+ */
+export declare class DaffExternalRouterClientError extends DaffInheritableError implements DaffError {
+    readonly code: string;
+    constructor(message?: string);
+}

package/routing/errors/not-found-error.d.ts

@@ -0,0 +1,9 @@
+import { DaffError } from '@daffodil/core';
+import { DaffExternalRouterClientError } from './client-error';
+/**
+ * An error thrown when the driver determines that a given url is not resolvable.
+ */
+export declare class DaffExternalRouterNotFoundError extends DaffExternalRouterClientError implements DaffError {
+    readonly code: string;
+    constructor(message?: string);
+}

package/routing/errors/permanent-redirect.d.ts

@@ -0,0 +1,10 @@
+import { DaffError, DaffInheritableError } from '@daffodil/core';
+/**
+ * An error thrown when the driver determines that the url needs to be routed somewhere
+ * else permanently.
+ */
+export declare class DaffExternalRouterPermanentRedirectError extends DaffInheritableError implements DaffError {
+    redirectUrl: string;
+    readonly code: string;
+    constructor(redirectUrl: string, message?: string);
+}

package/routing/errors/server-error.d.ts

@@ -0,0 +1,8 @@
+import { DaffError, DaffInheritableError } from '@daffodil/core';
+/**
+ * An error thrown when the platform performing url resolution fails.
+ */
+export declare class DaffExternalRouterServerError extends DaffInheritableError implements DaffError {
+    readonly code: string;
+    constructor(message?: string);
+}

package/routing/errors/temporary-redirect.d.ts

@@ -0,0 +1,10 @@
+import { DaffError, DaffInheritableError } from '@daffodil/core';
+/**
+ * An error thrown when the driver needs a URI to be temporarily redirected
+ * to another location.
+ */
+export declare class DaffExternalRouterTemporaryRedirectError extends DaffInheritableError implements DaffError {
+    redirectUrl: string;
+    readonly code: string;
+    constructor(redirectUrl: string, message?: string);
+}

package/routing/guard/existence.guard.d.ts

@@ -0,0 +1,19 @@
+import { CanActivate, ActivatedRouteSnapshot, Router, RouterStateSnapshot, UrlTree } from '@angular/router';
+import { Observable } from 'rxjs';
+import { DaffRoutingUriNormalizer } from '@daffodil/core/routing';
+import { DaffExternalRouter, DaffExternalRouterConfiguration } from '@daffodil/external-router';
+import { DaffExternalRouterDriverInterface } from '@daffodil/external-router/driver';
+/**
+ * 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 declare class DaffExternalRouterExistenceGuard implements CanActivate {
+    private driver;
+    private externalRouter;
+    private router;
+    private config;
+    private urlNormalizer;
+    constructor(driver: DaffExternalRouterDriverInterface, externalRouter: DaffExternalRouter, router: Router, config: DaffExternalRouterConfiguration, urlNormalizer: DaffRoutingUriNormalizer);
+    canActivate(next: ActivatedRouteSnapshot, state: RouterStateSnapshot): Observable<UrlTree | boolean>;
+}

package/routing/index.d.ts

@@ -0,0 +1 @@
+export * from './public_api';

package/routing/package.json

@@ -0,0 +1,11 @@
+{
+  "name": "@daffodil/external-router/routing",
+  "main": "../bundles/daffodil-external-router-routing.umd.js",
+  "module": "../fesm2015/daffodil-external-router-routing.js",
+  "es2015": "../fesm2015/daffodil-external-router-routing.js",
+  "esm2015": "../esm2015/routing/daffodil-external-router-routing.js",
+  "fesm2015": "../fesm2015/daffodil-external-router-routing.js",
+  "typings": "daffodil-external-router-routing.d.ts",
+  "metadata": "daffodil-external-router-routing.metadata.json",
+  "sideEffects": false
+}

package/routing/processors/process-errors.d.ts

@@ -0,0 +1,6 @@
+import { DaffExternallyResolvableUrl } from '@daffodil/external-router';
+/**
+ * Processes resolved URLs and throws the appropriate error so that External Router
+ * can handle routing errors.
+ */
+export declare const processErrors: (url: DaffExternallyResolvableUrl) => DaffExternallyResolvableUrl;

package/routing/processors/process-redirect.d.ts

@@ -0,0 +1,6 @@
+import { DaffExternallyResolvableUrl } from '@daffodil/external-router';
+/**
+ * Processes resolvedUrls and throws the appropriate error so that External Router
+ * can handle redirects.
+ */
+export declare const processRedirects: (url: DaffExternallyResolvableUrl) => DaffExternallyResolvableUrl;

package/routing/public_api.d.ts

@@ -0,0 +1 @@
+export { DaffExternalRouterExistenceGuard } from './guard/existence.guard';

package/token/type-resolvable-routes.token.d.ts

@@ -0,0 +1,14 @@
+import { InjectionToken, Provider } from '@angular/core';
+import { DaffTypeRoutePair } from '../model/type-route-pair';
+/**
+ * A multi-token that allows you to register route "types" that correspond to routes.
+ */
+export declare const DAFF_EXTERNAL_ROUTER_ROUTES_RESOLVABLE_BY_TYPE: InjectionToken<DaffTypeRoutePair[]>;
+/**
+ * A provider used to connect a type to a route to enable dynamic route resolution at runtime.
+ */
+export declare function daffProvideRouteResolvableByType(typeRoutePair: DaffTypeRoutePair): Provider;
+/**
+ * A multi-provider used to connect an array of types to their respective routes.
+ */
+export declare function daffProvideRoutesResolvableByType(routes: DaffTypeRoutePair[]): Provider[];

package/transform/resolved-route-to-route.d.ts

@@ -0,0 +1,7 @@
+import { DaffExternallyResolvableUrl } from '../model/resolvable-route';
+import { DaffRouteInfo } from '../model/route-info';
+import { DaffTypeRoutePair } from '../model/type-route-pair';
+/**
+ * Transforms a DaffExternallyResolvableUrl into an Angular Route.
+ */
+export declare const daffTransformResolvedRouteToRoute: (resolvedRoute: DaffExternallyResolvableUrl, availableTypes: DaffTypeRoutePair[]) => DaffRouteInfo;