@daffodil/external-router 0.38.9 → 0.39.3

package/bundles/daffodil-external-router.umd.js

@@ -239,7 +239,7 @@
                     ar[i] = from[i];
                 }
             }
-        return to.concat(ar || from);
+        return to.concat(ar || Array.prototype.slice.call(from));
     }
     function __await(v) {
         return this instanceof __await ? (this.v = v, this) : new __await(v);
@@ -322,64 +322,28 @@
         return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
     }
 
-    /**
-     * @fileoverview added by tsickle
-     * Generated from: config.ts
-     * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
-     */
-    /** @type {?} */
     var daffExternalRouterConfigurationDefault = {
         failedResolutionPath: '/',
         notFoundResolutionPath: '/',
     };
     /**
      * The token holding the runtime configuration for the behavior of the
-     * `\@daffodil/external-router` package.
-     * @type {?}
+     * `@daffodil/external-router` package.
      */
     var DAFF_EXTERNAL_ROUTER_CONFIG = new i0.InjectionToken('DAFF_EXTERNAL_ROUTER_CONFIG', {
         providedIn: 'root',
-        factory: ( /**
-         * @return {?}
-         */function () { return daffExternalRouterConfigurationDefault; }),
+        factory: function () { 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 {?}
      */
     var DAFF_EXTERNAL_ROUTER_ROUTES_RESOLVABLE_BY_TYPE = new i0.InjectionToken('DAFF_EXTERNAL_ROUTER_RESOLVABLE_TYPE_ROUTES', {
         providedIn: 'root',
-        factory: ( /**
-         * @return {?}
-         */function () { return []; }),
+        factory: function () { 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 {
@@ -390,32 +354,22 @@
     }
     /**
      * 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 {?}
-         */function (route) { return ({
+        return routes.map(function (route) { return ({
             provide: DAFF_EXTERNAL_ROUTER_ROUTES_RESOLVABLE_BY_TYPE,
             multi: true,
             useValue: route,
-        }); }));
+        }); });
     }
 
     /**
      * The external `DaffExternalRouterModule` allows you to configure the
-     * `\@daffodil/external-router` package's behavior.
+     * `@daffodil/external-router` package's behavior.
      */
     var DaffExternalRouterModule = /** @class */ (function () {
         function DaffExternalRouterModule() {
         }
-        /**
-         * @param {?} config
-         * @param {?=} routes
-         * @return {?}
-         */
         DaffExternalRouterModule.forRoot = function (config, routes) {
             if (routes === void 0) { routes = []; }
             return {
@@ -440,9 +394,6 @@
      */
     var DaffExternalRouterNoWildcardError = /** @class */ (function (_super) {
         __extends(DaffExternalRouterNoWildcardError, _super);
-        /**
-         * @param {?=} message
-         */
         function DaffExternalRouterNoWildcardError(message) {
             var _this = _super.call(this, message) || this;
             _this.code = 'NO_WILDCARD_ROUTE';
@@ -450,10 +401,6 @@
         }
         return DaffExternalRouterNoWildcardError;
     }(core.DaffInheritableError));
-    if (false) {
-        /** @type {?} */
-        DaffExternalRouterNoWildcardError.prototype.code;
-    }
 
     /**
      * An error thrown when there is a failure matching a configured route to a
@@ -461,9 +408,6 @@
      */
     var DaffExternalRouterUnknownRouteTypeError = /** @class */ (function (_super) {
         __extends(DaffExternalRouterUnknownRouteTypeError, _super);
-        /**
-         * @param {?=} message
-         */
         function DaffExternalRouterUnknownRouteTypeError(message) {
             var _this = _super.call(this, message) || this;
             _this.code = 'UNKNOWN_ROUTE_TYPE';
@@ -471,34 +415,13 @@
         }
         return DaffExternalRouterUnknownRouteTypeError;
     }(core.DaffInheritableError));
-    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 {?}
      */
-    var daffTransformResolvedRouteToRoute = ( /**
-     * @param {?} resolvedRoute
-     * @param {?} availableTypes
-     * @return {?}
-     */function (resolvedRoute, availableTypes) {
-        /** @type {?} */
+    var daffTransformResolvedRouteToRoute = function (resolvedRoute, availableTypes) {
         var routeType = availableTypes
-            .filter(( /**
-     * @param {?} t
-     * @return {?}
-     */function (/**
-     * @param {?} t
-     * @return {?}
-     */ t) { return t.type === resolvedRoute.type; }))
+            .filter(function (t) { return 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.");
@@ -507,49 +430,29 @@
             route: Object.assign(Object.assign({ path: resolvedRoute.url }, routeType.route), { data: Object.assign({ daffExternalRouteType: resolvedRoute.type }, routeType.route.data) }),
             insertionStrategy: routeType.insertionStrategy,
         };
-    });
+    };
 
     /**
      * Inserts a Route into Routes right before the wildcard route.
      * If no wildcard is found, it fails fast with a `DaffExternalRouterNoWildcardError`.
-     * @type {?}
      */
-    var daffInsertRouteBeforeWildCardStrategy = ( /**
-     * @param {?} route
-     * @param {?} routes
-     * @return {?}
-     */function (route, routes) {
-        /** @type {?} */
-        var index = routes.findIndex(( /**
-         * @param {?} r
-         * @return {?}
-         */function (r) { return r.path === '**'; }));
+    var daffInsertRouteBeforeWildCardStrategy = function (route, routes) {
+        var index = routes.findIndex(function (r) { return r.path === '**'; });
         if (index === -1) {
             throw new DaffExternalRouterNoWildcardError('No wildcard (**) route was found during route resolution.');
         }
         return __spread(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
-     */
     var DaffExternalRouter = /** @class */ (function () {
-        /**
-         * @param {?} router
-         * @param {?} runtimeRoutes
-         */
         function DaffExternalRouter(router, runtimeRoutes) {
             this.router = router;
             this.runtimeRoutes = runtimeRoutes;
         }
         /**
          * Adds a route to the existing router configuration.
-         * @param {?} resolvedRoute
-         * @return {?}
          */
         DaffExternalRouter.prototype.add = function (resolvedRoute) {
             //Get the route.
@@ -567,6 +470,7 @@
         };
         return DaffExternalRouter;
     }());
+    /** @nocollapse */ DaffExternalRouter.ɵprov = i0.ɵɵdefineInjectable({ factory: function DaffExternalRouter_Factory() { return new DaffExternalRouter(i0.ɵɵinject(i1.Router), i0.ɵɵinject(DAFF_EXTERNAL_ROUTER_ROUTES_RESOLVABLE_BY_TYPE)); }, token: DaffExternalRouter, providedIn: "root" });
     DaffExternalRouter.decorators = [
         { type: i0.Injectable, args: [{
                     providedIn: 'root',
@@ -577,85 +481,41 @@
         { type: i1.Router },
         { type: Array, decorators: [{ type: i0.Inject, args: [DAFF_EXTERNAL_ROUTER_ROUTES_RESOLVABLE_BY_TYPE,] }] }
     ]; };
-    /** @nocollapse */ DaffExternalRouter.ɵprov = i0.ɵɵdefineInjectable({ factory: function DaffExternalRouter_Factory() { return new DaffExternalRouter(i0.ɵɵinject(i1.Router), i0.ɵɵ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 {?}
+     * See {@link DaffRouteWithDataPath}
      */
-    var routeMatchesRouteType = ( /**
-     * @param {?} route
-     * @param {?} type
-     * @return {?}
-     */function (route, type) { var _a; return ((_a = route === null || route === void 0 ? void 0 : route.data) === null || _a === void 0 ? void 0 : _a.daffExternalRouteType) === type; });
+    var routeMatchesRouteType = function (route, type) { var _a; return ((_a = route === null || route === void 0 ? void 0 : route.data) === null || _a === void 0 ? void 0 : _a.daffExternalRouteType) === type; };
     var ɵ0 = routeMatchesRouteType;
     /**
      * Adds a path to the `daffPaths` of the given route.
      *
-     * See {\@link DaffRouteWithDataPath}
-     * @type {?}
+     * See {@link DaffRouteWithDataPath}
      */
-    var addRouteToDaffPaths = ( /**
-     * @param {?} route
-     * @param {?} path
-     * @return {?}
-     */function (route, path) {
+    var addRouteToDaffPaths = function (route, path) {
         var _b;
         return route.data.daffPaths = Object.assign(Object.assign({}, route.data.daffPaths), (_b = {}, _b[path] = path, _b));
-    });
+    };
     var ɵ1 = addRouteToDaffPaths;
-    /** @type {?} */
-    var operateOnRoute = ( /**
-     * @param {?} externalRoute
-     * @return {?}
-     */function (externalRoute) { return ( /**
-     * @param {?} route
-     * @return {?}
-     */function (route) { return addRouteToDaffPaths(route, externalRoute.path); }); });
+    var operateOnRoute = function (externalRoute) { return function (route) { return addRouteToDaffPaths(route, externalRoute.path); }; };
     var ɵ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 {?}
      */
-    var traverseRouteTree = ( /**
-     * @param {?=} routes
-     * @param {?=} matcher
-     * @param {?=} operate
-     * @return {?}
-     */function (routes, matcher, operate) {
+    var traverseRouteTree = function (routes, matcher, operate) {
         if (routes === void 0) { routes = []; }
         if (routes.length === 0) {
             return routes;
         }
-        /** @type {?} */
         var stack = [];
-        /** @type {?} */
         var treeRoot = { children: routes };
         stack.push(treeRoot);
         while (stack.length) {
-            /** @type {?} */
             var route = stack.pop();
             if (matcher(route)) {
                 operate(route);
@@ -666,17 +526,17 @@
             }
         }
         return routes;
-    });
+    };
     var ɵ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({}, [
@@ -689,7 +549,7 @@
      * ```
      *
      * 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 = [
@@ -703,24 +563,11 @@
      * ]
      * ```
      *
-     * See {\@link DaffRouteWithDataPath}
+     * See {@link DaffRouteWithDataPath}
      *
-     * @type {?}
      */
-    var daffInsertDataPathStrategy = ( /**
-     * @param {?} externalRoute
-     * @param {?} routes
-     * @return {?}
-     */function (externalRoute, routes) { return traverseRouteTree(routes, ( /**
-     * @param {?} route
-     * @return {?}
-     */function (route) { var _a; return routeMatchesRouteType(route, (_a = externalRoute.data) === null || _a === void 0 ? void 0 : _a.daffExternalRouteType); }), operateOnRoute(externalRoute)); });
+    var daffInsertDataPathStrategy = function (externalRoute, routes) { return traverseRouteTree(routes, function (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.
@@ -736,24 +583,12 @@
      *    }
      * ]
      * ```
-     * {\@link daffInsertDataPathStrategy }
-     * {\@link DaffRouteWithDataPath }
-     * @type {?}
+     * {@link daffInsertDataPathStrategy }
+     * {@link DaffRouteWithDataPath }
      */
-    var daffDataPathUrlMatcher = ( /**
-     * @param {?} segments
-     * @param {?} group
-     * @param {?} route
-     * @return {?}
-     */function (segments, group, route) {
+    var daffDataPathUrlMatcher = function (segments, group, route) {
         var _a;
-        /** @type {?} */
-        var path = routing.daffUriTruncateLeadingSlash(segments.reduce(( /**
-         * @param {?} acc
-         * @param {?} segment
-         * @return {?}
-         */function (acc, segment) { return acc + '/' + segment.path; }), ''));
-        /** @type {?} */
+        var path = routing.daffUriTruncateLeadingSlash(segments.reduce(function (acc, segment) { return acc + '/' + segment.path; }, ''));
         var 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) {
@@ -762,18 +597,14 @@
         // 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.
      */
 
     exports.DAFF_EXTERNAL_ROUTER_CONFIG = DAFF_EXTERNAL_ROUTER_CONFIG;