onroute-policy-engine 2.4.1 → 2.5.1

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

@@ -8,5 +8,6 @@ export declare enum PolicyCheckId {
     MaxTireLoad = "max-tire-load",
     MinDriveAxleWeight = "minimum-drive-axle-weight",
     MinSteerAxleWeight = "minimum-steer-axle-weight",
+    NumberOfAxles = "number-of-axles",
     NumberOfWheelsPerAxle = "number-of-wheels"
 }

package/dist/enum/policy-check.js

@@ -13,5 +13,6 @@ var PolicyCheckId;
     PolicyCheckId["MaxTireLoad"] = "max-tire-load";
     PolicyCheckId["MinDriveAxleWeight"] = "minimum-drive-axle-weight";
     PolicyCheckId["MinSteerAxleWeight"] = "minimum-steer-axle-weight";
+    PolicyCheckId["NumberOfAxles"] = "number-of-axles";
     PolicyCheckId["NumberOfWheelsPerAxle"] = "number-of-wheels";
 })(PolicyCheckId || (exports.PolicyCheckId = PolicyCheckId = {}));

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

@@ -1,4 +1,4 @@
-import { PolicyCheckResult, AxleConfiguration } from 'onroute-policy-engine/types';
+import { PolicyCheckResult, AxleConfiguration, AxleGroupPolicyCheckResult } from 'onroute-policy-engine/types';
 import { Policy } from 'onroute-policy-engine';
 /**
  * Type definition for policy check functions.
@@ -14,6 +14,19 @@ import { Policy } from 'onroute-policy-engine';
  * @returns Array of PolicyCheckResult objects representing the outcomes of the policy check
  */
 type PolicyCheck = (policy: Policy, vehicleConfiguration: Array<string>, axleConfiguration: Array<AxleConfiguration>) => Array<PolicyCheckResult>;
+/**
+ * Validates the number of axles in each axle unit.
+ *
+ * Axle unit counts must be whole numbers from 1 to 3. This check runs before
+ * the other axle policy checks because bridge and weight calculations assume a
+ * valid axle count.
+ *
+ * @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 axle count information
+ * @returns Array of AxleGroupPolicyCheckResult objects, one for each axle unit tested
+ */
+export declare function CheckNumberOfAxles(_policy: Policy, _vehicleConfiguration: Array<string>, axleConfiguration: Array<AxleConfiguration>): Array<AxleGroupPolicyCheckResult>;
 /**
  * Performs bridge formula calculations on axle groups and returns policy check results.
  *
@@ -223,6 +236,7 @@ export declare function CheckMaxTireLoad(_policy: Policy, _vehicleConfiguration:
  * - 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
+ * - NumberOfAxles: Validates axle count per axle unit
  * - NumberOfWheelsPerAxle: Validates tire count per axle unit
  *
  * @see PolicyCheck

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

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.policyCheckMap = void 0;
+exports.CheckNumberOfAxles = CheckNumberOfAxles;
 exports.CheckBridgeFormula = CheckBridgeFormula;
 exports.CheckNumTiresPerAxle = CheckNumTiresPerAxle;
 exports.CheckPermittableWeight = CheckPermittableWeight;
@@ -8,6 +9,45 @@ exports.CheckMinSteerAxleWeight = CheckMinSteerAxleWeight;
 exports.CheckMinDriveAxleWeight = CheckMinDriveAxleWeight;
 exports.CheckMaxTireLoad = CheckMaxTireLoad;
 const enum_1 = require("../enum");
+/**
+ * Validates the number of axles in each axle unit.
+ *
+ * Axle unit counts must be whole numbers from 1 to 3. This check runs before
+ * the other axle policy checks because bridge and weight calculations assume a
+ * valid axle count.
+ *
+ * @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 axle count information
+ * @returns Array of AxleGroupPolicyCheckResult objects, one for each axle unit tested
+ */
+function CheckNumberOfAxles(_policy, _vehicleConfiguration, axleConfiguration) {
+    const policyCheckResults = new Array();
+    const policyId = enum_1.PolicyCheckId.NumberOfAxles;
+    axleConfiguration.forEach((ac, i) => {
+        const axleUnit = i + 1;
+        const numberOfAxles = ac.numberOfAxles;
+        const validNumber = Number.isFinite(numberOfAxles) && Number.isInteger(numberOfAxles);
+        let result = enum_1.PolicyCheckResultType.Pass;
+        let message = `No. of Axles for Axle Unit ${axleUnit} is permittable.`;
+        if (!validNumber || numberOfAxles < 1) {
+            result = enum_1.PolicyCheckResultType.Fail;
+            message = `No. of Axles for Axle Unit ${axleUnit} cannot be 0.`;
+        }
+        else if (numberOfAxles > 3) {
+            result = enum_1.PolicyCheckResultType.Fail;
+            message = `No. of Axles for Axle Unit ${axleUnit} is not permittable.`;
+        }
+        policyCheckResults.push({
+            id: policyId,
+            message,
+            result,
+            startAxleUnit: axleUnit,
+            endAxleUnit: axleUnit,
+        });
+    });
+    return policyCheckResults;
+}
 /**
  * Performs bridge formula calculations on axle groups and returns policy check results.
  *
@@ -467,6 +507,7 @@ function CheckMaxTireLoad(_policy, _vehicleConfiguration, axleConfiguration) {
  * - 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
+ * - NumberOfAxles: Validates axle count per axle unit
  * - NumberOfWheelsPerAxle: Validates tire count per axle unit
  *
  * @see PolicyCheck
@@ -474,6 +515,7 @@ function CheckMaxTireLoad(_policy, _vehicleConfiguration, axleConfiguration) {
  * @see runAxleCalculation
  */
 exports.policyCheckMap = new Map([
+    [enum_1.PolicyCheckId.NumberOfAxles, CheckNumberOfAxles],
     [enum_1.PolicyCheckId.BridgeFormula, CheckBridgeFormula],
     [enum_1.PolicyCheckId.CheckPermittableWeight, CheckPermittableWeight],
     [enum_1.PolicyCheckId.MaxTireLoad, CheckMaxTireLoad],

package/dist/policy-engine.js

@@ -696,11 +696,30 @@ class Policy {
      */
     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));
-        }
+        // This is a little helper closure that just converts any PolicyCheckResult into an AxleGroupPolicyCheckResult,
+        // basically giving us startAxleUnit and endAxleUnit, which can help with frontend form highlighting.
+        const toAxleGroupPolicyCheckResult = (result) => {
+            if ('startAxleUnit' in result && 'endAxleUnit' in result) {
+                return result;
+            }
+            if ('axleUnit' in result && typeof result.axleUnit === 'number') {
+                return Object.assign(Object.assign({}, result), { startAxleUnit: result.axleUnit, endAxleUnit: result.axleUnit });
+            }
+            return Object.assign(Object.assign({}, result), { startAxleUnit: 1, endAxleUnit: axleConfiguration.length });
+        };
         const gvcw = axleConfiguration.reduce((w, curr) => w + curr.axleUnitWeight, 0);
         axleCalcResults.totalOverload = Math.max(axleCalcResults.totalOverload, gvcw - licensedGVW);
+        const axleCountResults = (0, policy_check_helper_1.CheckNumberOfAxles)(this, vehicleConfiguration, axleConfiguration);
+        axleCalcResults.results.push(...axleCountResults.map(toAxleGroupPolicyCheckResult));
+        if (axleCountResults.some((r) => r.result === enum_1.PolicyCheckResultType.Fail)) {
+            return axleCalcResults;
+        }
+        for (const [policyCheckId, policyCheck] of policy_check_helper_1.policyCheckMap) {
+            if (policyCheckId === enum_1.PolicyCheckId.NumberOfAxles) {
+                continue;
+            }
+            axleCalcResults.results.push(...policyCheck(this, vehicleConfiguration, axleConfiguration).map(toAxleGroupPolicyCheckResult));
+        }
         return axleCalcResults;
     }
     /**

package/dist/types/axle-calculation-results.d.ts

@@ -9,8 +9,8 @@ import { PolicyCheckResultType } from 'onroute-policy-engine/enum';
  * Complete results from axle calculations including all policy checks and total overload
  */
 export type AxleCalcResults = {
-    /** Array of individual policy check results */
-    results: Array<PolicyCheckResult>;
+    /** Array of individual axle group policy check results */
+    results: Array<AxleGroupPolicyCheckResult>;
     /** Total weight overload across all axles in kilograms */
     totalOverload: number;
 };

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const version = "v2.4.1";
+export declare const version = "v2.5.1";

package/dist/version.js

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

package/package.json

@@ -91,5 +91,5 @@
     ],
     "testEnvironment": "node"
   },
-  "version": "v2.4.1"
+  "version": "v2.5.1"
 }