onroute-policy-engine 2.2.1 → 2.3.0

package/dist/enum/policy-check.d.ts

@@ -5,6 +5,7 @@ export declare enum PolicyCheckResultType {
 export declare enum PolicyCheckId {
     BridgeFormula = "bridge-formula",
     CheckPermittableWeight = "check-permittable-weight",
+    MaxTireLoad = "max-tire-load",
     MinDriveAxleWeight = "minimum-drive-axle-weight",
     MinSteerAxleWeight = "minimum-steer-axle-weight",
     NumberOfWheelsPerAxle = "number-of-wheels"

package/dist/enum/policy-check.js

@@ -10,6 +10,7 @@ var PolicyCheckId;
 (function (PolicyCheckId) {
     PolicyCheckId["BridgeFormula"] = "bridge-formula";
     PolicyCheckId["CheckPermittableWeight"] = "check-permittable-weight";
+    PolicyCheckId["MaxTireLoad"] = "max-tire-load";
     PolicyCheckId["MinDriveAxleWeight"] = "minimum-drive-axle-weight";
     PolicyCheckId["MinSteerAxleWeight"] = "minimum-steer-axle-weight";
     PolicyCheckId["NumberOfWheelsPerAxle"] = "number-of-wheels";

package/dist/helper/facts.helper.js

@@ -143,7 +143,9 @@ function addRuntimeFacts(engine, policy) {
         const vehicleConfiguration = await almanac.factValue(enum_1.PolicyFacts.VehicleConfiguration);
         // Retrieve the axle configuration from permit data
         const axleConfiguration = await almanac.factValue(enum_1.PermitAppInfo.PermitData, {}, enum_1.PermitAppInfo.AxleConfiguration);
-        const results = policy.runAxleCalculation(vehicleConfiguration, axleConfiguration);
+        // Retrieve licensed GVW from permit data
+        const vehicleDetails = await almanac.factValue(enum_1.PermitAppInfo.PermitData, {}, enum_1.PermitAppInfo.VehicleDetails);
+        const results = policy.runAxleCalculation(vehicleConfiguration, axleConfiguration, vehicleDetails.licensedGVW || 0);
         const violations = results.results.filter((r) => r.result === enum_1.PolicyCheckResultType.Fail);
         return violations.map((v) => v.message);
     });

package/dist/helper/policy-check.helper.d.ts

@@ -163,6 +163,52 @@ export declare function CheckMinSteerAxleWeight(_policy: Policy, _vehicleConfigu
  * @see AxleGroupPolicyCheckResult
  */
 export declare function CheckMinDriveAxleWeight(_policy: Policy, _vehicleConfiguration: Array<string>, axleConfiguration: Array<AxleConfiguration>): Array<PolicyCheckResult>;
+/**
+ * Validates maximum tire load capacity for each axle unit based on tire size and count.
+ *
+ * This function performs tire load validation for all axle units in a vehicle configuration.
+ * It checks that the weight on each axle unit does not exceed the maximum load capacity
+ * of the tires based on their size and quantity. The validation uses different rules for
+ * steer axles versus non-steer axles.
+ *
+ * For steer axles:
+ * - Tire size must not exceed 455mm
+ * - For tires ≥445mm: Maximum weight is 9,100kg
+ * - For tires <445mm: Maximum weight is calculated as (number of tires × tire size × 10)
+ *
+ * For non-steer axles:
+ * - For tires ≥445mm: Maximum weight is (number of tires × 3,850kg)
+ * - For tires >300mm and <445mm: Maximum weight is (number of tires × 3,000kg)
+ * - For tires ≤300mm: Maximum weight is (number of tires × tire size × 10)
+ *
+ * @param _policy - The policy instance (unused in this check, but required by PolicyCheck type)
+ * @param _vehicleConfiguration - Vehicle configuration (unused in this check, but required by PolicyCheck type)
+ * @param axleConfiguration - Array of axle configurations containing tire size, tire count, and weight information
+ * @returns Array of PolicyCheckResult objects, with individual axle unit results for failures
+ *          or a single group result for successful validation
+ *
+ * @example
+ * // For a vehicle with valid tire loads
+ * const results = CheckMaxTireLoad(policy, ['TRKTRAC'], [
+ *   { tireSize: 445, numberOfTires: 2, axleUnitWeight: 8000 },  // Steer axle: 8000kg ≤ 9100kg (pass)
+ *   { tireSize: 445, numberOfTires: 8, axleUnitWeight: 30000 }  // Drive axle: 30000kg ≤ 30800kg (pass)
+ * ]);
+ * // Returns single pass result for all axle units
+ *
+ * @example
+ * // For a vehicle with invalid tire loads
+ * const results = CheckMaxTireLoad(policy, ['TRKTRAC'], [
+ *   { tireSize: 460, numberOfTires: 2, axleUnitWeight: 8000 },  // Steer axle: tire size > 455mm (fail)
+ *   { tireSize: 445, numberOfTires: 8, axleUnitWeight: 32000 }  // Drive axle: 32000kg > 30800kg (fail)
+ * ]);
+ * // Returns individual fail results for each axle unit
+ *
+ * @see PolicyCheck
+ * @see AxleUnitPolicyCheckResult
+ * @see AxleGroupPolicyCheckResult
+ * @see AxleConfiguration
+ */
+export declare function CheckMaxTireLoad(_policy: Policy, _vehicleConfiguration: Array<string>, axleConfiguration: Array<AxleConfiguration>): Array<PolicyCheckResult>;
 /**
  * Map of policy check functions keyed by their corresponding PolicyCheckId.
  *
@@ -173,6 +219,10 @@ export declare function CheckMinDriveAxleWeight(_policy: Policy, _vehicleConfigu
  *
  * Currently includes:
  * - BridgeFormula: Validates axle groups against bridge formula requirements
+ * - CheckPermittableWeight: Validates total vehicle weight against permit limits
+ * - MaxTireLoad: Validates tire load capacity for each axle unit
+ * - MinDriveAxleWeight: Validates minimum weight requirements for drive axles
+ * - MinSteerAxleWeight: Validates minimum weight requirements for steer axles
  * - NumberOfWheelsPerAxle: Validates tire count per axle unit
  *
  * @see PolicyCheck

package/dist/helper/policy-check.helper.js

@@ -6,6 +6,7 @@ exports.CheckNumTiresPerAxle = CheckNumTiresPerAxle;
 exports.CheckPermittableWeight = CheckPermittableWeight;
 exports.CheckMinSteerAxleWeight = CheckMinSteerAxleWeight;
 exports.CheckMinDriveAxleWeight = CheckMinDriveAxleWeight;
+exports.CheckMaxTireLoad = CheckMaxTireLoad;
 const enum_1 = require("../enum");
 /**
  * Performs bridge formula calculations on axle groups and returns policy check results.
@@ -312,6 +313,145 @@ function CheckMinDriveAxleWeight(_policy, _vehicleConfiguration, axleConfigurati
     });
     return policyCheckResults;
 }
+/**
+ * Validates maximum tire load capacity for each axle unit based on tire size and count.
+ *
+ * This function performs tire load validation for all axle units in a vehicle configuration.
+ * It checks that the weight on each axle unit does not exceed the maximum load capacity
+ * of the tires based on their size and quantity. The validation uses different rules for
+ * steer axles versus non-steer axles.
+ *
+ * For steer axles:
+ * - Tire size must not exceed 455mm
+ * - For tires ≥445mm: Maximum weight is 9,100kg
+ * - For tires <445mm: Maximum weight is calculated as (number of tires × tire size × 10)
+ *
+ * For non-steer axles:
+ * - For tires ≥445mm: Maximum weight is (number of tires × 3,850kg)
+ * - For tires >300mm and <445mm: Maximum weight is (number of tires × 3,000kg)
+ * - For tires ≤300mm: Maximum weight is (number of tires × tire size × 10)
+ *
+ * @param _policy - The policy instance (unused in this check, but required by PolicyCheck type)
+ * @param _vehicleConfiguration - Vehicle configuration (unused in this check, but required by PolicyCheck type)
+ * @param axleConfiguration - Array of axle configurations containing tire size, tire count, and weight information
+ * @returns Array of PolicyCheckResult objects, with individual axle unit results for failures
+ *          or a single group result for successful validation
+ *
+ * @example
+ * // For a vehicle with valid tire loads
+ * const results = CheckMaxTireLoad(policy, ['TRKTRAC'], [
+ *   { tireSize: 445, numberOfTires: 2, axleUnitWeight: 8000 },  // Steer axle: 8000kg ≤ 9100kg (pass)
+ *   { tireSize: 445, numberOfTires: 8, axleUnitWeight: 30000 }  // Drive axle: 30000kg ≤ 30800kg (pass)
+ * ]);
+ * // Returns single pass result for all axle units
+ *
+ * @example
+ * // For a vehicle with invalid tire loads
+ * const results = CheckMaxTireLoad(policy, ['TRKTRAC'], [
+ *   { tireSize: 460, numberOfTires: 2, axleUnitWeight: 8000 },  // Steer axle: tire size > 455mm (fail)
+ *   { tireSize: 445, numberOfTires: 8, axleUnitWeight: 32000 }  // Drive axle: 32000kg > 30800kg (fail)
+ * ]);
+ * // Returns individual fail results for each axle unit
+ *
+ * @see PolicyCheck
+ * @see AxleUnitPolicyCheckResult
+ * @see AxleGroupPolicyCheckResult
+ * @see AxleConfiguration
+ */
+function CheckMaxTireLoad(_policy, _vehicleConfiguration, axleConfiguration) {
+    const policyCheckResults = new Array();
+    const policyId = enum_1.PolicyCheckId.MaxTireLoad;
+    // Steer axle tire load check
+    const steerTireSize = axleConfiguration[0].tireSize;
+    if (!steerTireSize) {
+        policyCheckResults.push({
+            id: policyId,
+            result: enum_1.PolicyCheckResultType.Fail,
+            message: `Steer axle tire size is invalid`,
+            axleUnit: 1,
+        });
+    }
+    else if (steerTireSize > 455) {
+        policyCheckResults.push({
+            id: policyId,
+            result: enum_1.PolicyCheckResultType.Fail,
+            message: `Steer axle tire size must not exceed 455mm`,
+            axleUnit: 1,
+        });
+    }
+    else if (steerTireSize >= 445) {
+        if (axleConfiguration[0].axleUnitWeight > 9100) {
+            policyCheckResults.push({
+                id: policyId,
+                result: enum_1.PolicyCheckResultType.Fail,
+                message: `Steer axle weight exceeds maximum of 9100kg for ${steerTireSize}mm tire size`,
+                axleUnit: 1,
+            });
+        }
+    }
+    else {
+        const maxWeightOnSteerAxle = (axleConfiguration[0].numberOfTires || 0) * (steerTireSize * 10);
+        if (axleConfiguration[0].axleUnitWeight > maxWeightOnSteerAxle) {
+            policyCheckResults.push({
+                id: policyId,
+                result: enum_1.PolicyCheckResultType.Fail,
+                message: `Steer axle weight exceeds maximum of ${maxWeightOnSteerAxle}kg for ${steerTireSize}mm tire size`,
+                axleUnit: 1,
+            });
+        }
+    }
+    // Non-steer axle tire load checks
+    axleConfiguration.slice(1).forEach((a, i) => {
+        const tireSize = a.tireSize;
+        const numberOfTires = a.numberOfTires;
+        let maxWeight = 0;
+        if (!tireSize) {
+            policyCheckResults.push({
+                id: policyId,
+                result: enum_1.PolicyCheckResultType.Fail,
+                message: `Axle unit ${i + 1} tire size is invalid`,
+                axleUnit: i + 1,
+            });
+        }
+        else if (!numberOfTires) {
+            policyCheckResults.push({
+                id: policyId,
+                result: enum_1.PolicyCheckResultType.Fail,
+                message: `Axle unit ${i + 1} number of wheels is invalid`,
+                axleUnit: i + 1,
+            });
+        }
+        else {
+            if (tireSize >= 445) {
+                maxWeight = numberOfTires * 3850;
+            }
+            else if (tireSize > 300) {
+                maxWeight = numberOfTires * 3000;
+            }
+            else {
+                maxWeight = numberOfTires * tireSize * 10;
+            }
+            if (a.axleUnitWeight > maxWeight) {
+                policyCheckResults.push({
+                    id: policyId,
+                    result: enum_1.PolicyCheckResultType.Fail,
+                    message: `Axle unit ${i + 1} weight exceeds maximum of ${maxWeight}kg for ${numberOfTires} ${steerTireSize}mm tires`,
+                    axleUnit: 1,
+                });
+            }
+        }
+    });
+    if (policyCheckResults.length === 0) {
+        policyCheckResults.push({
+            id: policyId,
+            result: enum_1.PolicyCheckResultType.Pass,
+            message: 'Max tire load check passed for all axle units',
+            startAxleUnit: 1,
+            endAxleUnit: axleConfiguration.length,
+        });
+    }
+    return policyCheckResults;
+}
 /**
  * Map of policy check functions keyed by their corresponding PolicyCheckId.
  *
@@ -322,6 +462,10 @@ function CheckMinDriveAxleWeight(_policy, _vehicleConfiguration, axleConfigurati
  *
  * Currently includes:
  * - BridgeFormula: Validates axle groups against bridge formula requirements
+ * - CheckPermittableWeight: Validates total vehicle weight against permit limits
+ * - MaxTireLoad: Validates tire load capacity for each axle unit
+ * - MinDriveAxleWeight: Validates minimum weight requirements for drive axles
+ * - MinSteerAxleWeight: Validates minimum weight requirements for steer axles
  * - NumberOfWheelsPerAxle: Validates tire count per axle unit
  *
  * @see PolicyCheck
@@ -331,6 +475,7 @@ function CheckMinDriveAxleWeight(_policy, _vehicleConfiguration, axleConfigurati
 exports.policyCheckMap = new Map([
     [enum_1.PolicyCheckId.BridgeFormula, CheckBridgeFormula],
     [enum_1.PolicyCheckId.CheckPermittableWeight, CheckPermittableWeight],
+    [enum_1.PolicyCheckId.MaxTireLoad, CheckMaxTireLoad],
     [enum_1.PolicyCheckId.MinDriveAxleWeight, CheckMinDriveAxleWeight],
     [enum_1.PolicyCheckId.MinSteerAxleWeight, CheckMinSteerAxleWeight],
     [enum_1.PolicyCheckId.NumberOfWheelsPerAxle, CheckNumTiresPerAxle],

package/dist/policy-engine.d.ts

@@ -201,6 +201,7 @@ export declare class Policy {
      *                          Each axle configuration contains details like number of axles, spacing, tire count, etc.
      *                          The length should match the vehicleConfiguration array plus one (since the first
      *                          vehicle in the configuration is a power unit with two axle units).
+     * @param licensedGVW Licensed GVW of the vehicle being permitted.
      * @returns AxleCalcResults object containing:
      *          - results: Array of PolicyCheckResult objects, each representing the outcome of a specific policy check
      *          - totalOverload: Numeric value representing the total overload across all axle calculations
@@ -221,7 +222,7 @@ export declare class Policy {
      * @see PolicyCheckResult
      * @see AxleConfiguration
      */
-    runAxleCalculation(vehicleConfiguration: Array<string>, axleConfiguration: Array<AxleConfiguration>): AxleCalcResults;
+    runAxleCalculation(vehicleConfiguration: Array<string>, axleConfiguration: Array<AxleConfiguration>, licensedGVW: number): AxleCalcResults;
     /**
      * Gets the list of allowed vehicles separated into two maps, one
      * for trailers and one for power units. This will filter out LCV

package/dist/policy-engine.js

@@ -673,6 +673,7 @@ class Policy {
      *                          Each axle configuration contains details like number of axles, spacing, tire count, etc.
      *                          The length should match the vehicleConfiguration array plus one (since the first
      *                          vehicle in the configuration is a power unit with two axle units).
+     * @param licensedGVW Licensed GVW of the vehicle being permitted.
      * @returns AxleCalcResults object containing:
      *          - results: Array of PolicyCheckResult objects, each representing the outcome of a specific policy check
      *          - totalOverload: Numeric value representing the total overload across all axle calculations
@@ -693,11 +694,13 @@ class Policy {
      * @see PolicyCheckResult
      * @see AxleConfiguration
      */
-    runAxleCalculation(vehicleConfiguration, axleConfiguration) {
+    runAxleCalculation(vehicleConfiguration, axleConfiguration, licensedGVW) {
         const axleCalcResults = { results: [], totalOverload: 0 };
         for (const [, func] of policy_check_helper_1.policyCheckMap) {
             axleCalcResults.results.push(...func(this, vehicleConfiguration, axleConfiguration));
         }
+        const gvcw = axleConfiguration.reduce((w, curr) => w + curr.axleUnitWeight, 0);
+        axleCalcResults.totalOverload = Math.max(axleCalcResults.totalOverload, gvcw - licensedGVW);
         return axleCalcResults;
     }
     /**

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

@@ -15,6 +15,6 @@ export type AxleConfiguration = {
     axleUnitWeight: number;
     /** Number of tires on this axle unit */
     numberOfTires?: number;
-    /** Tire size in inches */
+    /** Tire size in centimetres */
     tireSize?: number;
 };

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const version = "v2.2.1";
+export declare const version = "v2.3.0";

package/dist/version.js

@@ -2,4 +2,4 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.version = void 0;
 // Generated by genversion.
-exports.version = 'v2.2.1';
+exports.version = 'v2.3.0';

package/package.json

@@ -91,5 +91,5 @@
     ],
     "testEnvironment": "node"
   },
-  "version": "v2.2.1"
+  "version": "v2.3.0"
 }