onroute-policy-engine 0.2.1 → 0.4.0

package/.github/workflows/pipeline.yml

@@ -45,3 +45,10 @@ jobs:
         run: npm publish --provenance --access public
         env:
           NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}
+
+      - name: Create Release
+        run: |
+          gh release create "${{ steps.semver.outputs.next }}" \
+          --repo="${{ github.repository }}" \
+          --title="${{ steps.semver.outputs.next }}" \
+          --generate-notes

package/dist/helper/bridge-calculation.helper.d.ts

@@ -0,0 +1,13 @@
+import { BridgeCalculationResult, AxleConfiguration } from 'onroute-policy-engine/types';
+import { Policy } from '../policy-engine';
+/**
+ * Runs the bridge formula against the supplied vehicle axle configuration.
+ * Evaluates the weight against all possible axle group combinations and returns
+ * the result of each group comparison, with an indicator of whether or not the
+ * axle group failed the bridge calculation.
+ * @param axleConfig Vehicle dimensions and weights per axle
+ * @param policy Policy Enging object initialized with policy config
+ * @returns Array of BridgeCalculationResult objects, one for each
+ * axle group in the vehicle configuration
+ */
+export declare function runBridgeFormula(axleConfig: Array<AxleConfiguration>, policy: Policy): Array<BridgeCalculationResult>;

package/dist/helper/bridge-calculation.helper.js

@@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runBridgeFormula = runBridgeFormula;
+/**
+ * Runs the bridge formula against the supplied vehicle axle configuration.
+ * Evaluates the weight against all possible axle group combinations and returns
+ * the result of each group comparison, with an indicator of whether or not the
+ * axle group failed the bridge calculation.
+ * @param axleConfig Vehicle dimensions and weights per axle
+ * @param policy Policy Enging object initialized with policy config
+ * @returns Array of BridgeCalculationResult objects, one for each
+ * axle group in the vehicle configuration
+ */
+function runBridgeFormula(axleConfig, policy) {
+    const BRIDGE_MULTIPLIER = policy.policyDefinition.bridgeCalculationConstants.multiplier;
+    const BRIDGE_MIN_WEIGHT = policy.policyDefinition.bridgeCalculationConstants.minWeight;
+    const results = [];
+    let index = 0;
+    if (!axleConfig || axleConfig.length < 2) {
+        throw new Error('Invalid axle configuration, bridge formula requires a minimum of two axle units');
+    }
+    // Loop through each axle unit in the configuration, and
+    // calculate the bridge formula for each other axle unit. The
+    // number of axle groups calculated will be the Nth triangular
+    // number, where N = (number of axle units) - 1.
+    axleConfig.forEach((axle) => {
+        var _a;
+        // Do not process once we reach the last axle unit
+        // in the configuration, as they have all been calculated
+        // by then.
+        if (index < axleConfig.length - 1) {
+            // Initialize the variables for our start axle
+            const firstAxle = index + 1;
+            let nextAxle = firstAxle + 1;
+            if (!axle.numberOfAxles || axle.numberOfAxles < 0) {
+                throw new Error(`Invalid or missing number of axles for axle unit number ${firstAxle}`);
+            }
+            if (!axle.weight || axle.weight < 0) {
+                throw new Error(`Invalid or missing weight for axle unit number ${firstAxle}`);
+            }
+            let totalWeight = axle.weight;
+            // Spread may be zero or undefined if the axle unit
+            // is a single axle. Spacing to next will be zero or
+            // undefined for the final axle unit in the configuration.
+            if (axle.numberOfAxles > 1 && (!axle.spread || axle.spread < 0)) {
+                throw new Error(`Invalid or missing axle spread for axle unit number ${firstAxle}`);
+            }
+            if (axle.numberOfAxles == 1 && axle.spread && axle.spread < 0) {
+                throw new Error(`Invalid axle spread for single axle unit, cannot be a negative number`);
+            }
+            if (!axle.spacingToNext || axle.spacingToNext < 0) {
+                throw new Error(`Invalid or missing axle spacing between axle units ${firstAxle} and ${firstAxle + 1}`);
+            }
+            let wheelbase = ((_a = axle.spread) !== null && _a !== void 0 ? _a : 0) + axle.spacingToNext;
+            // Now loop through all of the next axles, building up a group
+            // for each.
+            axleConfig.slice(firstAxle).forEach((axleN) => {
+                var _a, _b;
+                if (!axleN.weight || axleN.weight < 0) {
+                    throw new Error(`Invalid or missing weight for axle unit number ${nextAxle}`);
+                }
+                totalWeight += axleN.weight;
+                if (axleN.numberOfAxles > 1 && (!axleN.spread || axleN.spread < 0)) {
+                    throw new Error(`Invalid or missing axle spread for axle unit number ${nextAxle}`);
+                }
+                wheelbase += (_a = axleN.spread) !== null && _a !== void 0 ? _a : 0;
+                // The magic is in the next line
+                const maxBridge = BRIDGE_MULTIPLIER * wheelbase + BRIDGE_MIN_WEIGHT;
+                // Push the axle group result to the results array, including
+                // a convenience success indicator.
+                results.push({
+                    startAxleUnit: firstAxle,
+                    endAxleUnit: nextAxle,
+                    maxBridge: maxBridge,
+                    actualWeight: totalWeight,
+                    success: totalWeight <= maxBridge,
+                });
+                // Add the wheelbase only if this end axle unit is not the
+                // final one in the configuration
+                if (nextAxle < axleConfig.length) {
+                    if (!axleN.spacingToNext || axleN.spacingToNext < 0) {
+                        throw new Error(`Invalid or missing axle spacing between axle units ${nextAxle} and ${nextAxle + 1}`);
+                    }
+                    wheelbase += (_b = axleN.spacingToNext) !== null && _b !== void 0 ? _b : 0;
+                }
+                nextAxle++;
+            });
+        }
+        index++;
+    });
+    return results;
+}

package/dist/policy-engine.d.ts

@@ -1,4 +1,4 @@
-import { PolicyDefinition, PermitType, Commodity, SizeDimension } from 'onroute-policy-engine/types';
+import { PolicyDefinition, PermitType, Commodity, SizeDimension, AxleConfiguration, BridgeCalculationResult } from 'onroute-policy-engine/types';
 import { Engine } from 'json-rules-engine';
 import { ValidationResults } from './validation-results';
 /** Class representing commercial vehicle policy. */
@@ -136,4 +136,12 @@ export declare class Policy {
      * @returns Commodity definition for the supplied ID.
      */
     getCommodityDefinition(type?: string): Commodity | null;
+    /**
+     * Convenience method of policy that delegates the bridge calculation
+     * to the helper method.
+     * @param axleConfig Vehicle dimensions and weights per axle
+     * @returns Array of BridgeCalculationResult objects, one for each
+     * axle group in the vehicle configuration
+     */
+    calculateBridge(axleConfig: Array<AxleConfiguration>): Array<BridgeCalculationResult>;
 }

package/dist/policy-engine.js

@@ -7,6 +7,7 @@ const validation_results_1 = require("./validation-results");
 const validation_result_1 = require("./validation-result");
 const facts_helper_1 = require("./helper/facts.helper");
 const enum_1 = require("onroute-policy-engine/enum");
+const bridge_calculation_helper_1 = require("./helper/bridge-calculation.helper");
 /** Class representing commercial vehicle policy. */
 class Policy {
     /**
@@ -614,5 +615,23 @@ class Policy {
             return null;
         }
     }
+    /**
+     * Convenience method of policy that delegates the bridge calculation
+     * to the helper method.
+     * @param axleConfig Vehicle dimensions and weights per axle
+     * @returns Array of BridgeCalculationResult objects, one for each
+     * axle group in the vehicle configuration
+     */
+    calculateBridge(axleConfig) {
+        let bridgeResults;
+        try {
+            bridgeResults = (0, bridge_calculation_helper_1.runBridgeFormula)(axleConfig, this);
+        }
+        catch (e) {
+            console.log(`Error calculating bridge formula: ${e.message}`);
+            throw e;
+        }
+        return bridgeResults;
+    }
 }
 exports.Policy = Policy;

package/dist/types/axle-configuration.d.ts

@@ -0,0 +1,8 @@
+export type AxleConfiguration = {
+    numberOfAxles: number;
+    spread?: number;
+    spacingToNext?: number;
+    weight: number;
+    numberOfTires?: number;
+    tireSize?: number;
+};

package/dist/types/axle-configuration.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/bridge-calculation-constants.d.ts

@@ -0,0 +1,4 @@
+export type BridgeCalculationConstants = {
+    multiplier: number;
+    minWeight: number;
+};

package/dist/types/bridge-calculation-constants.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/bridge-calculation-result.d.ts

@@ -0,0 +1,7 @@
+export type BridgeCalculationResult = {
+    startAxleUnit: number;
+    endAxleUnit: number;
+    maxBridge: number;
+    actualWeight: number;
+    success: boolean;
+};

package/dist/types/bridge-calculation-result.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/index.d.ts

@@ -1,3 +1,6 @@
+export { AxleConfiguration } from './axle-configuration';
+export { BridgeCalculationConstants } from './bridge-calculation-constants';
+export { BridgeCalculationResult } from './bridge-calculation-result';
 export { Commodity, CommoditySize, CommodityWeight } from './commodity';
 export { CostRule } from './cost-rule';
 export { DimensionModifier } from './dimension-modifier';

package/dist/types/policy-definition.d.ts

@@ -1,4 +1,4 @@
-import { GeographicRegion, PermitType, DefaultWeightDimensions, VehicleTypes, Commodity, SizeDimension, VehicleCategories, RangeMatrix } from 'onroute-policy-engine/types';
+import { GeographicRegion, PermitType, DefaultWeightDimensions, VehicleTypes, Commodity, SizeDimension, VehicleCategories, RangeMatrix, BridgeCalculationConstants } from 'onroute-policy-engine/types';
 import { RuleProperties } from 'json-rules-engine';
 export type PolicyDefinition = {
     version: string;
@@ -11,4 +11,5 @@ export type PolicyDefinition = {
     vehicleTypes: VehicleTypes;
     commodities: Array<Commodity>;
     rangeMatrices?: Array<RangeMatrix>;
+    bridgeCalculationConstants: BridgeCalculationConstants;
 };

package/package.json

@@ -7,6 +7,19 @@
     "./types": "./dist/types/index.js",
     "./enum": "./dist/enum/index.js"
   },
+  "typesVersions": {
+    "*": {
+      ".": [
+        "dist/index.d.ts"
+      ],
+      "types": [
+        "dist/types/index.d.ts"
+      ],
+      "enum": [
+        "dist/enum/index.d.ts"
+      ]
+    }
+  },
   "types": "dist/index.d.ts",
   "private": false,
   "scripts": {
@@ -73,5 +86,5 @@
     ],
     "testEnvironment": "node"
   },
-  "version": "v0.2.1"
+  "version": "v0.4.0"
 }