@dwp/govuk-casa 8.2.3 → 8.2.4

package/dist/lib/Plan.d.ts

@@ -1,3 +1,6 @@
+/**
+ * @memberof module:@dwp/govuk-casa
+ */
 export default class Plan {
     /**
      * Waypoints using the url:// protocol are known as "exit nodes" as they
@@ -10,15 +13,15 @@ export default class Plan {
     /**
      * Create a Plan.
      *
-     * @param {object} opts Options
-     * @param {boolean} [opts.validateBeforeRouteCondition=true] Check page validity before conditions
-     * @param {Function|string} [opts.arbiter=undefined] Arbitration mechanism
+     * @param {PlanConstructorOptions} opts Options
      */
-    constructor(opts?: {
-        validateBeforeRouteCondition?: boolean | undefined;
-        arbiter?: string | Function | undefined;
-    });
-    getOptions(): any;
+    constructor(opts?: PlanConstructorOptions);
+    /**
+     * Retrieve the options set on this Plan.
+     *
+     * @returns {PlanConstructorOptions} Options map
+     */
+    getOptions(): PlanConstructorOptions;
     /**
      * Retrieve the list of skippable waypoints.
      *
@@ -29,7 +32,7 @@ export default class Plan {
      * Add one or more skippable waypoints.
      *
      * @param  {...string} waypoints Waypoints
-     * @returns {Plan}{ Chain}
+     * @returns {Plan} Chain
      */
     addSkippables(...waypoints: string[]): Plan;
     /**
@@ -39,40 +42,87 @@ export default class Plan {
      * @returns {boolean} True if waypoint can be skipped
      */
     isSkippable(waypoint: string): boolean;
-    getWaypoints(): any;
-    containsWaypoint(waypoint: any): any;
-    getRoutes(): any;
-    getRouteCondition(src: any, tgt: any, name: any): any;
+    /**
+     * Retrieve all waypoints in this Plan (order is arbitrary).
+     *
+     * @returns {string[]} List of waypoints
+     */
+    getWaypoints(): string[];
+    /**
+     * Determine if the given waypoint exists in this Plan.
+     *
+     * @param {string} waypoint Waypoint to search for
+     * @returns {boolean} Result
+     */
+    containsWaypoint(waypoint: string): boolean;
+    /**
+     * Get all route information.
+     *
+     * @returns {PlanRoute[]} Routes
+     */
+    getRoutes(): PlanRoute[];
+    /**
+     * Get the condition function for the given parameters.
+     *
+     * @param {string} src Source waypoint
+     * @param {string} tgt Target waypoint
+     * @param {string} name Route name
+     * @returns {PlanRouteCondition} Route condition function
+     */
+    getRouteCondition(src: string, tgt: string, name: string): PlanRouteCondition;
     /**
      * Return all outward routes (out-edges) from the given waypoint, to the
      * optional target waypoint.
      *
      * @param {string} src Source waypoint.
-     * @param {string} tgt Target waypoint (optional).
-     * @returns {Array<object>} Route objects found.
+     * @param {string} [tgt] Target waypoint.
+     * @returns {PlanRoute[]} Route objects found.
      */
-    getOutwardRoutes(src: string, tgt?: string): Array<object>;
+    getOutwardRoutes(src: string, tgt?: string | undefined): PlanRoute[];
     /**
      * Return all outward routes (out-edges) from the given waypoint, to the
      * optional target waypoint, matching the "prev" name.
      *
      * @param {string} src Source waypoint.
-     * @param {string} tgt Target waypoint (optional).
-     * @returns {Array<object>} Route objects found.
+     * @param {string} [tgt] Target waypoint.
+     * @returns {PlanRoute[]} Route objects found.
      */
-    getPrevOutwardRoutes(src: string, tgt?: string): Array<object>;
-    addSequence(...waypoints: any[]): void;
-    setNextRoute(src: any, tgt: any, follow: any): Plan;
-    setPrevRoute(src: any, tgt: any, follow: any): Plan;
+    getPrevOutwardRoutes(src: string, tgt?: string | undefined): PlanRoute[];
+    /**
+     * Add a sequence of waypoints that will follow on from each other, with no
+     * routing logic between them.
+     *
+     * @param  {...string} waypoints Waypoints to add
+     * @returns {void}
+     */
+    addSequence(...waypoints: string[]): void;
+    /**
+     * Create a new directed route between two waypoints, labelled as "next".
+     *
+     * @param {string} src Source waypoint
+     * @param {string} tgt Target waypoint
+     * @param {PlanRouteCondition} follow Route condition function
+     * @returns {Plan} Chain
+     */
+    setNextRoute(src: string, tgt: string, follow: PlanRouteCondition): Plan;
+    /**
+     * Create a new directed route between two waypoints, labelled as "prev".
+     *
+     * @param {string} src Source waypoint
+     * @param {string} tgt Target waypoint
+     * @param {PlanRouteCondition} follow Route condition function
+     * @returns {Plan} Chain
+     */
+    setPrevRoute(src: string, tgt: string, follow: PlanRouteCondition): Plan;
     /**
      * Adds both a "next" and "prev" route between the two waypoints.
      *
-     * By default, the "prev" route will use the same "follow" test as the "next"
-     * route. This makes sense in that in order to get the target, the test must
-     * have been true, and so to reverse the direction we also need that same test
-     * to be true.
+     * By default, the "prev" route will use the same "follow" condition as the
+     * "next" route. This makes sense in that in order to get to the target, the
+     * condition must be true, and so to reverse the direction we also need that
+     * same condition to be true.
      *
-     * However, if the condition function uses the `source`/`target`
+     * However, if the condition function uses the `source`/`target` property
      * of the route in some way, then we must reverse these before passing to the
      * condition on the "prev" route because `source` in the condition will almost
      * certainly be referring to the source of the "next" route.
@@ -82,11 +132,11 @@ export default class Plan {
      *
      * @param {string} src Source waypoint.
      * @param {string} tgt Target waypoint.
-     * @param {Function} followNext Follow test function.
-     * @param {Function} followPrev Follow test function.
-     * @returns {Plan} Self.
+     * @param {PlanRouteCondition} [followNext] Follow test function.
+     * @param {PlanRouteCondition} [followPrev] Follow test function.
+     * @returns {Plan} Chain
      */
-    setRoute(src: string, tgt: string, followNext?: Function, followPrev?: Function): Plan;
+    setRoute(src: string, tgt: string, followNext?: import("../casa").PlanRouteCondition | undefined, followPrev?: import("../casa").PlanRouteCondition | undefined): Plan;
     /**
      * Create a named route between two waypoints, and give that route a function
      * that determine whether it should be followed during traversal operations.
@@ -103,22 +153,38 @@ export default class Plan {
      * @param {string} src Source waypoint.
      * @param {string} tgt Target waypoint.
      * @param {string} name Name of the route (must be unique for this waypoint pairing).
-     * @param {Function} follow Test function to determine if route can be followed.
+     * @param {PlanRouteCondition} follow Test function to determine if route can be followed.
      * @returns {Plan} Chain
      * @throws {Error} If attempting to create a "next" route from an exit node
      */
-    setNamedRoute(src: string, tgt: string, name: string, follow: Function): Plan;
+    setNamedRoute(src: string, tgt: string, name: string, follow: PlanRouteCondition): Plan;
     /**
      * This is a convenience method for traversing all "next" routes, and returning
      * the IDs of all waypoints visited along the way.
      *
-     * @param {JourneyContext} context Journey Context.
-     * @param {object} options Options.
-     * @returns {Array<string>} List of traversed waypoints.
+     * @param {JourneyContext} context Journey Context
+     * @param {PlanTraverseOptions} options Options
+     * @returns {string[]} List of traversed waypoints
      */
-    traverse(context: JourneyContext, options?: object): Array<string>;
-    traverseNextRoutes(context: any, options?: {}): object[];
-    traversePrevRoutes(context: any, options?: {}): object[];
+    traverse(context: JourneyContext, options?: PlanTraverseOptions): string[];
+    /**
+     * Traverse the Plan by following all "next" routes, and returning the IDs of
+     * all waypoints visited along the way.
+     *
+     * @param {JourneyContext} context Journey Context
+     * @param {PlanTraverseOptions} options Options
+     * @returns {PlanRoute[]} List of traversed waypoints
+     */
+    traverseNextRoutes(context: JourneyContext, options?: PlanTraverseOptions): PlanRoute[];
+    /**
+     * Traverse the Plan by following all "prev" routes, and returning the IDs of
+     * all waypoints visited along the way.
+     *
+     * @param {JourneyContext} context Journey Context
+     * @param {PlanTraverseOptions} options Options
+     * @returns {PlanRoute[]} List of traversed waypoints
+     */
+    traversePrevRoutes(context: JourneyContext, options?: PlanTraverseOptions): PlanRoute[];
     /**
      * Traverse through the plan from a particular starting waypoint. This is a
      * non-exhaustive Graph Exploration.
@@ -129,19 +195,12 @@ export default class Plan {
      * If a cyclical set of routes are encountered, traversal will stop after
      * reaching the first repeated waypoint.
      *
-     * Options:
-     * string startWaypoint = Waypoint from which to start traversal
-     * string routeName = Follow routes matching this name (next | prev)
-     * Map history = Used to detect loops in traversal (internal use)
-     * function stopCondition = Condition that, if true, will stop traversal (useful for performance)
-     * function|string arbiter = If mutliple target routes found, this decides which to use (if any)
-     *
      * @param {JourneyContext} context Journey context
-     * @param {object} options Options
-     * @returns {Array<object>} Routes that were traversed
+     * @param {PlanTraverseOptions} options Options
+     * @returns {PlanRoute[]} Routes that were traversed
      * @throws {TypeError} When context is not a JourneyContext
      */
-    traverseRoutes(context: JourneyContext, options?: object): Array<object>;
+    traverseRoutes(context: JourneyContext, options?: PlanTraverseOptions): PlanRoute[];
     /**
      * Get raw graph data structure. This can be used with other libraries to
      * generate graph visualisations, for example.
@@ -151,4 +210,18 @@ export default class Plan {
     getGraphStructure(): Graph;
     #private;
 }
+export type PlanRoute = import('../casa').PlanRoute;
+export type PlanRouteCondition = import('../casa').PlanRouteCondition;
+export type PlanTraverseOptions = import('../casa').PlanTraverseOptions;
+export type PlanArbiter = import('../casa').PlanArbiter;
+export type PlanConstructorOptions = {
+    /**
+     * Check page validity before conditions
+     */
+    validateBeforeRouteCondition?: boolean | undefined;
+    /**
+     * Arbitration mechanism
+     */
+    arbiter?: string | import("../casa").PlanArbiter | undefined;
+};
 import JourneyContext from "./JourneyContext.js";

package/dist/lib/Plan.js

@@ -19,13 +19,33 @@ const graphlib_1 = require("graphlib");
 const JourneyContext_js_1 = __importDefault(require("./JourneyContext.js"));
 const logger_js_1 = __importDefault(require("./logger.js"));
 const log = (0, logger_js_1.default)('lib:plan');
+/**
+ * @access private
+ * @typedef {import('../casa').PlanRoute} PlanRoute
+ */
+/**
+ * @access private
+ * @typedef {import('../casa').PlanRouteCondition} PlanRouteCondition
+ */
+/**
+ * @access private
+ * @typedef {import('../casa').PlanTraverseOptions} PlanTraverseOptions
+ */
+/**
+ * @access private
+ * @typedef {import('../casa').PlanArbiter} PlanArbiter
+ */
+/**
+ * @typedef {object} PlanConstructorOptions
+ * @property {boolean} [validateBeforeRouteCondition=true] Check page validity before conditions
+ * @property {string|PlanArbiter} [arbiter=undefined] Arbitration mechanism
+ */
 /**
  * Will check if the source waypoint has specifically passed validation, i.e
  * there is a "null" validation entry for the route source.
  *
- * @param {object} r Route meta.
- * @param {JourneyContext} context Journey Context.
- * @returns {boolean} Condition result.
+ * @access private
+ * @type {PlanRouteCondition}
  */
 function defaultNextFollow(r, context) {
     const { validation: v = {} } = context.toObject();
@@ -35,14 +55,22 @@ function defaultNextFollow(r, context) {
  * Will check if the target waypoint (the one we're moving back to) has
  * specifically passed validation.
  *
- * @param {object} r Route meta.
- * @param {JourneyContext} context Journey context.
- * @returns {boolean} Condition result.
+ * @access private
+ * @type {PlanRouteCondition}
  */
 function defaultPrevFollow(r, context) {
     const { validation: v = {} } = context.toObject();
     return Object.prototype.hasOwnProperty.call(v, r.target) && v[r.target] === null;
 }
+/**
+ * Validate a given waypoint ID.
+ *
+ * @access private
+ * @param {string} val Waypoint ID
+ * @returns {void}
+ * @throws {TypeError} If waypoint ID is not a string
+ * @throws {SyntaxError} If waypoint ID is incorrectly formatted
+ */
 function validateWaypointId(val) {
     if (typeof val !== 'string') {
         throw new TypeError(`Expected waypoint id to be a string, got ${typeof val}`);
@@ -51,6 +79,15 @@ function validateWaypointId(val) {
         throw new SyntaxError('url:// waypoints must include a trailing /');
     }
 }
+/**
+ * Validate a given route name.
+ *
+ * @access private
+ * @param {string} val Route name
+ * @returns {string} The route name
+ * @throws {TypeError} If route name is not a string
+ * @throws {ReferenceError} If route name is neither "next" or "prev"
+ */
 function validateRouteName(val) {
     if (typeof val !== 'string') {
         throw new TypeError(`Expected route name to be a string, got ${typeof val}`);
@@ -60,6 +97,14 @@ function validateRouteName(val) {
     }
     return val;
 }
+/**
+ * Validate a given route condition.
+ *
+ * @access private
+ * @param {PlanRouteCondition} val The condition function
+ * @returns {void}
+ * @throws {TypeError} If condition is not a string
+ */
 function validateRouteCondition(val) {
     if (!(val instanceof Function)) {
         throw new TypeError(`Expected route condition to be a function, got ${typeof val}`);
@@ -70,9 +115,10 @@ function validateRouteCondition(val) {
  * be used in userland. This is the object that will be passed into follow
  * functions too as the "route" parameter.
  *
+ * @access private
  * @param {object} dgraph Directed graph instance.
  * @param {object} edge Graph edge object.
- * @returns {object} Route.
+ * @returns {PlanRoute} Route.
  */
 const makeRouteObject = (dgraph, edge) => {
     const label = dgraph.edge(edge) || {};
@@ -86,16 +132,25 @@ const makeRouteObject = (dgraph, edge) => {
 };
 /**
  * Exit nodes begin with a protocol format, such as `url://`, `http://`, etc
+ *
+ * @access private
  */
 const reExitNodeProtocol = /^[a-z]+:\/\//i;
+/**
+ * For storing private properties for each instance
+ *
+ * @access private
+ * @todo Use property private class properties.
+ */
 const priv = new WeakMap();
+/**
+ * @memberof module:@dwp/govuk-casa
+ */
 class Plan {
     /**
      * Create a Plan.
      *
-     * @param {object} opts Options
-     * @param {boolean} [opts.validateBeforeRouteCondition=true] Check page validity before conditions
-     * @param {Function|string} [opts.arbiter=undefined] Arbitration mechanism
+     * @param {PlanConstructorOptions} opts Options
      */
     constructor(opts = {}) {
         /**
@@ -137,6 +192,11 @@ class Plan {
     static isExitNode(name) {
         return reExitNodeProtocol.test(name);
     }
+    /**
+     * Retrieve the options set on this Plan.
+     *
+     * @returns {PlanConstructorOptions} Options map
+     */
     getOptions() {
         return priv.get(this).options;
     }
@@ -152,7 +212,7 @@ class Plan {
      * Add one or more skippable waypoints.
      *
      * @param  {...string} waypoints Waypoints
-     * @returns {Plan}{ Chain}
+     * @returns {Plan} Chain
      */
     addSkippables(...waypoints) {
         __classPrivateFieldSet(this, _Plan_skippableWaypoints, [...__classPrivateFieldGet(this, _Plan_skippableWaypoints, "f"), ...waypoints], "f");
@@ -167,16 +227,40 @@ class Plan {
     isSkippable(waypoint) {
         return __classPrivateFieldGet(this, _Plan_skippableWaypoints, "f").indexOf(waypoint) > -1;
     }
+    /**
+     * Retrieve all waypoints in this Plan (order is arbitrary).
+     *
+     * @returns {string[]} List of waypoints
+     */
     getWaypoints() {
         return priv.get(this).dgraph.nodes();
     }
+    /**
+     * Determine if the given waypoint exists in this Plan.
+     *
+     * @param {string} waypoint Waypoint to search for
+     * @returns {boolean} Result
+     */
     containsWaypoint(waypoint) {
         return this.getWaypoints().includes(waypoint);
     }
+    /**
+     * Get all route information.
+     *
+     * @returns {PlanRoute[]} Routes
+     */
     getRoutes() {
         const self = priv.get(this);
         return self.dgraph.edges().map((edge) => makeRouteObject(self.dgraph, edge));
     }
+    /**
+     * Get the condition function for the given parameters.
+     *
+     * @param {string} src Source waypoint
+     * @param {string} tgt Target waypoint
+     * @param {string} name Route name
+     * @returns {PlanRouteCondition} Route condition function
+     */
     getRouteCondition(src, tgt, name) {
         return priv.get(this).follows[validateRouteName(name)][`${src}/${tgt}`];
     }
@@ -185,8 +269,8 @@ class Plan {
      * optional target waypoint.
      *
      * @param {string} src Source waypoint.
-     * @param {string} tgt Target waypoint (optional).
-     * @returns {Array<object>} Route objects found.
+     * @param {string} [tgt] Target waypoint.
+     * @returns {PlanRoute[]} Route objects found.
      */
     getOutwardRoutes(src, tgt = null) {
         const self = priv.get(this);
@@ -197,12 +281,19 @@ class Plan {
      * optional target waypoint, matching the "prev" name.
      *
      * @param {string} src Source waypoint.
-     * @param {string} tgt Target waypoint (optional).
-     * @returns {Array<object>} Route objects found.
+     * @param {string} [tgt] Target waypoint.
+     * @returns {PlanRoute[]} Route objects found.
      */
     getPrevOutwardRoutes(src, tgt = null) {
         return this.getOutwardRoutes(src, tgt).filter((r) => r.name === 'prev');
     }
+    /**
+     * Add a sequence of waypoints that will follow on from each other, with no
+     * routing logic between them.
+     *
+     * @param  {...string} waypoints Waypoints to add
+     * @returns {void}
+     */
     addSequence(...waypoints) {
         // Setup simple double routes (next/prev) between all waypoints in this list
         for (let i = 0, l = waypoints.length - 1; i < l; i += 1) {
@@ -211,21 +302,37 @@ class Plan {
             this.setRoute(waypoints[i], waypoints[i + 1]);
         }
     }
+    /**
+     * Create a new directed route between two waypoints, labelled as "next".
+     *
+     * @param {string} src Source waypoint
+     * @param {string} tgt Target waypoint
+     * @param {PlanRouteCondition} follow Route condition function
+     * @returns {Plan} Chain
+     */
     setNextRoute(src, tgt, follow) {
         return this.setNamedRoute(src, tgt, 'next', follow);
     }
+    /**
+     * Create a new directed route between two waypoints, labelled as "prev".
+     *
+     * @param {string} src Source waypoint
+     * @param {string} tgt Target waypoint
+     * @param {PlanRouteCondition} follow Route condition function
+     * @returns {Plan} Chain
+     */
     setPrevRoute(src, tgt, follow) {
         return this.setNamedRoute(src, tgt, 'prev', follow);
     }
     /**
      * Adds both a "next" and "prev" route between the two waypoints.
      *
-     * By default, the "prev" route will use the same "follow" test as the "next"
-     * route. This makes sense in that in order to get the target, the test must
-     * have been true, and so to reverse the direction we also need that same test
-     * to be true.
+     * By default, the "prev" route will use the same "follow" condition as the
+     * "next" route. This makes sense in that in order to get to the target, the
+     * condition must be true, and so to reverse the direction we also need that
+     * same condition to be true.
      *
-     * However, if the condition function uses the `source`/`target`
+     * However, if the condition function uses the `source`/`target` property
      * of the route in some way, then we must reverse these before passing to the
      * condition on the "prev" route because `source` in the condition will almost
      * certainly be referring to the source of the "next" route.
@@ -235,9 +342,9 @@ class Plan {
      *
      * @param {string} src Source waypoint.
      * @param {string} tgt Target waypoint.
-     * @param {Function} followNext Follow test function.
-     * @param {Function} followPrev Follow test function.
-     * @returns {Plan} Self.
+     * @param {PlanRouteCondition} [followNext] Follow test function.
+     * @param {PlanRouteCondition} [followPrev] Follow test function.
+     * @returns {Plan} Chain
      */
     setRoute(src, tgt, followNext = undefined, followPrev = undefined) {
         this.setNamedRoute(src, tgt, 'next', followNext);
@@ -267,7 +374,7 @@ class Plan {
      * @param {string} src Source waypoint.
      * @param {string} tgt Target waypoint.
      * @param {string} name Name of the route (must be unique for this waypoint pairing).
-     * @param {Function} follow Test function to determine if route can be followed.
+     * @param {PlanRouteCondition} follow Test function to determine if route can be followed.
      * @returns {Plan} Chain
      * @throws {Error} If attempting to create a "next" route from an exit node
      */
@@ -321,16 +428,32 @@ class Plan {
      * This is a convenience method for traversing all "next" routes, and returning
      * the IDs of all waypoints visited along the way.
      *
-     * @param {JourneyContext} context Journey Context.
-     * @param {object} options Options.
-     * @returns {Array<string>} List of traversed waypoints.
+     * @param {JourneyContext} context Journey Context
+     * @param {PlanTraverseOptions} options Options
+     * @returns {string[]} List of traversed waypoints
      */
     traverse(context, options = {}) {
         return this.traverseNextRoutes(context, options).map((e) => e.source);
     }
+    /**
+     * Traverse the Plan by following all "next" routes, and returning the IDs of
+     * all waypoints visited along the way.
+     *
+     * @param {JourneyContext} context Journey Context
+     * @param {PlanTraverseOptions} options Options
+     * @returns {PlanRoute[]} List of traversed waypoints
+     */
     traverseNextRoutes(context, options = {}) {
         return this.traverseRoutes(context, Object.assign(Object.assign({}, options), { routeName: 'next' }));
     }
+    /**
+     * Traverse the Plan by following all "prev" routes, and returning the IDs of
+     * all waypoints visited along the way.
+     *
+     * @param {JourneyContext} context Journey Context
+     * @param {PlanTraverseOptions} options Options
+     * @returns {PlanRoute[]} List of traversed waypoints
+     */
     traversePrevRoutes(context, options = {}) {
         return this.traverseRoutes(context, Object.assign(Object.assign({}, options), { routeName: 'prev' }));
     }
@@ -344,16 +467,9 @@ class Plan {
      * If a cyclical set of routes are encountered, traversal will stop after
      * reaching the first repeated waypoint.
      *
-     * Options:
-     * string startWaypoint = Waypoint from which to start traversal
-     * string routeName = Follow routes matching this name (next | prev)
-     * Map history = Used to detect loops in traversal (internal use)
-     * function stopCondition = Condition that, if true, will stop traversal (useful for performance)
-     * function|string arbiter = If mutliple target routes found, this decides which to use (if any)
-     *
      * @param {JourneyContext} context Journey context
-     * @param {object} options Options
-     * @returns {Array<object>} Routes that were traversed
+     * @param {PlanTraverseOptions} options Options
+     * @returns {PlanRoute[]} Routes that were traversed
      * @throws {TypeError} When context is not a JourneyContext
      */
     traverseRoutes(context, options = {}) {
@@ -361,6 +477,7 @@ class Plan {
             throw new TypeError(`Expected context to be an instance of JourneyContext, got ${typeof context}`);
         }
         const self = priv.get(this);
+        /** @type {PlanTraverseOptions} */
         const { startWaypoint = this.getWaypoints()[0], stopCondition = () => (false), arbiter = self.options.arbiter, routeName, } = options;
         if (!self.dgraph.hasNode(startWaypoint)) {
             throw new ReferenceError(`Plan does not contain waypoint '${startWaypoint}'`);
@@ -398,7 +515,14 @@ class Plan {
                 }
                 else if (arbiter instanceof Function) {
                     log.debug('Using custom arbitration process');
-                    target = arbiter(target, Object.assign({ context }, options));
+                    // Convert to routeObject and back to edge object so that only the
+                    // routeObject is used in the public API
+                    target = arbiter({
+                        targets: target.map((t) => makeRouteObject(self.dgraph, t)),
+                        journeyContext: context,
+                        travereOptions: options,
+                    });
+                    target = target.map((r) => ({ v: r.source, w: r.target, name: r.name }));
                 }
                 else {
                     log.warn('Unable to arbitrate');