onroute-policy-engine 2.18.0 → 2.19.0

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

@@ -3,6 +3,7 @@ export declare enum PolicyCheckResultType {
     Fail = "fail"
 }
 export declare enum PolicyCheckId {
+    AxleGroupMaximumLegalWeightThreshold = "axle-group-maximum-legal-weight-threshold",
     BoosterAxleLimit = "booster-axle-limit",
     BridgeFormula = "bridge-formula",
     CheckPermittableWeight = "check-permittable-weight",

package/dist/enum/policy-check.js

@@ -8,6 +8,7 @@ var PolicyCheckResultType;
 })(PolicyCheckResultType || (exports.PolicyCheckResultType = PolicyCheckResultType = {}));
 var PolicyCheckId;
 (function (PolicyCheckId) {
+    PolicyCheckId["AxleGroupMaximumLegalWeightThreshold"] = "axle-group-maximum-legal-weight-threshold";
     PolicyCheckId["BoosterAxleLimit"] = "booster-axle-limit";
     PolicyCheckId["BridgeFormula"] = "bridge-formula";
     PolicyCheckId["CheckPermittableWeight"] = "check-permittable-weight";

package/dist/helper/ctr-717.helper.d.ts

@@ -0,0 +1,2 @@
+/** Returns the authoritative CTR 7.17 table value for a spread in centimetres. */
+export declare function getCtr717TableValue(spreadCm: number): number | undefined;

package/dist/helper/ctr-717.helper.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCtr717TableValue = getCtr717TableValue;
+const CTR_717_WEIGHT_BANDS = [
+    { minimumSpreadCm: 800, maximumWeightKg: 34000 },
+    { minimumSpreadCm: 760, maximumWeightKg: 33000 },
+    { minimumSpreadCm: 720, maximumWeightKg: 32000 },
+    { minimumSpreadCm: 690, maximumWeightKg: 31000 },
+    { minimumSpreadCm: 650, maximumWeightKg: 30000 },
+    { minimumSpreadCm: 610, maximumWeightKg: 29000 },
+    { minimumSpreadCm: 570, maximumWeightKg: 28000 },
+    { minimumSpreadCm: 530, maximumWeightKg: 27000 },
+    { minimumSpreadCm: 500, maximumWeightKg: 26000 },
+    { minimumSpreadCm: 460, maximumWeightKg: 25000 },
+    { minimumSpreadCm: 420, maximumWeightKg: 24000 },
+    { minimumSpreadCm: 380, maximumWeightKg: 23000 },
+    { minimumSpreadCm: 340, maximumWeightKg: 22000 },
+    { minimumSpreadCm: 300, maximumWeightKg: 21000 },
+    { minimumSpreadCm: 260, maximumWeightKg: 20000 },
+    { minimumSpreadCm: 230, maximumWeightKg: 19000 },
+    { minimumSpreadCm: 190, maximumWeightKg: 18000 },
+    { minimumSpreadCm: 120, maximumWeightKg: 17000 },
+    { minimumSpreadCm: 100, maximumWeightKg: 16500 },
+    { minimumSpreadCm: 0, maximumWeightKg: 9100 },
+];
+/** Returns the authoritative CTR 7.17 table value for a spread in centimetres. */
+function getCtr717TableValue(spreadCm) {
+    var _a;
+    if (!Number.isFinite(spreadCm) || spreadCm < 0) {
+        return undefined;
+    }
+    return (_a = CTR_717_WEIGHT_BANDS.find(({ minimumSpreadCm }) => spreadCm >= minimumSpreadCm)) === null || _a === void 0 ? void 0 : _a.maximumWeightKg;
+}

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

@@ -14,6 +14,13 @@ 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>;
+/** Applies the standard lower-of rule or the exact 7.16(g) exception. */
+export declare function getMaximumLegalAxleGroupWeightThreshold(individualLegalWeightSum: number, ctr717TableValue: number, isTandemDriveSingleJeepException: boolean): number;
+/**
+ * Validates every contiguous axle-unit group within 8 m, excluding groups
+ * beginning at axle unit 1, against the CTR 7.17 maximum legal weight.
+ */
+export declare function CheckAxleGroupMaximumLegalWeightThreshold(policy: Policy, vehicleConfiguration: Array<string>, axleConfiguration: Array<AxleConfiguration>): Array<AxleGroupPolicyCheckResult>;
 /**
  * Validates the number of axles in each axle unit.
  *
@@ -295,6 +302,7 @@ export declare function CheckDriveJeepLoadEqualization(_policy: Policy, vehicleC
  * this map with additional entries.
  *
  * Currently includes:
+ * - AxleGroupMaximumLegalWeightThreshold: Validates axle groups within 8 m against CTR 7.17
  * - 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

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

@@ -1,6 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.policyCheckMap = void 0;
+exports.getMaximumLegalAxleGroupWeightThreshold = getMaximumLegalAxleGroupWeightThreshold;
+exports.CheckAxleGroupMaximumLegalWeightThreshold = CheckAxleGroupMaximumLegalWeightThreshold;
 exports.CheckNumberOfAxles = CheckNumberOfAxles;
 exports.CheckBridgeFormula = CheckBridgeFormula;
 exports.CheckNumTiresPerAxle = CheckNumTiresPerAxle;
@@ -14,7 +16,120 @@ exports.CheckBoosterAxleLimit = CheckBoosterAxleLimit;
 exports.CheckTruckTractorWheelbase = CheckTruckTractorWheelbase;
 exports.CheckDriveJeepLoadEqualization = CheckDriveJeepLoadEqualization;
 const dimensions_helper_1 = require("./dimensions.helper");
+const ctr_717_helper_1 = require("./ctr-717.helper");
 const enum_1 = require("../enum");
+/** Applies the standard lower-of rule or the exact 7.16(g) exception. */
+function getMaximumLegalAxleGroupWeightThreshold(individualLegalWeightSum, ctr717TableValue, isTandemDriveSingleJeepException) {
+    const tandemDriveSingleJeepMinimumKg = 24000;
+    return isTandemDriveSingleJeepException
+        ? Math.max(tandemDriveSingleJeepMinimumKg, ctr717TableValue)
+        : Math.min(individualLegalWeightSum, ctr717TableValue);
+}
+function getApplicableLegalWeightThreshold(policy, vehicleConfiguration, axleConfiguration, axleUnitVehicleIndexes, axleIndex) {
+    var _a;
+    const vehicleIndex = axleUnitVehicleIndexes[axleIndex];
+    const vehicleType = vehicleConfiguration[vehicleIndex];
+    const axle = axleConfiguration[axleIndex];
+    if (!vehicleType || !axle) {
+        return undefined;
+    }
+    const weights = vehicleIndex === 0
+        ? policy.getDefaultPowerUnitWeight(vehicleType, axleConfiguration[0].numberOfAxles * 10 +
+            axleConfiguration[1].numberOfAxles)
+        : policy.getDefaultTrailerWeight(vehicleType, axle.numberOfAxles);
+    if (weights.length === 0) {
+        return undefined;
+    }
+    return (_a = policy.selectCorrectWeightDimension(weights, vehicleConfiguration, axleConfiguration, axleIndex)) === null || _a === void 0 ? void 0 : _a.legal;
+}
+/**
+ * Validates every contiguous axle-unit group within 8 m, excluding groups
+ * beginning at axle unit 1, against the CTR 7.17 maximum legal weight.
+ */
+function CheckAxleGroupMaximumLegalWeightThreshold(policy, vehicleConfiguration, axleConfiguration) {
+    var _a, _b;
+    const ctr717MaxSpreadCm = 800;
+    const policyCheckResults = new Array();
+    const policyId = enum_1.PolicyCheckId.AxleGroupMaximumLegalWeightThreshold;
+    if (axleConfiguration.length < 3) {
+        return policyCheckResults;
+    }
+    const hasVehicleIndexes = axleConfiguration.some((axleUnit) => axleUnit.vehicleIndex !== undefined);
+    const axleUnitVehicleIndexes = hasVehicleIndexes
+        ? (0, dimensions_helper_1.getAxleUnitVehicleIndexes)(policy, vehicleConfiguration, axleConfiguration)
+        : axleConfiguration.map((_, axleIndex) => axleIndex < 2 ? 0 : axleIndex - 1);
+    const legalWeightThresholds = axleConfiguration.map((_, axleIndex) => getApplicableLegalWeightThreshold(policy, vehicleConfiguration, axleConfiguration, axleUnitVehicleIndexes, axleIndex));
+    for (let startAxleIndex = 1; startAxleIndex < axleConfiguration.length - 1; startAxleIndex++) {
+        const firstAxle = axleConfiguration[startAxleIndex];
+        const firstAxleSpread = (_a = firstAxle.axleSpread) !== null && _a !== void 0 ? _a : 0;
+        let groupSpread = firstAxleSpread;
+        let actualWeight = firstAxle.axleUnitWeight;
+        let individualLegalWeightSum = legalWeightThresholds[startAxleIndex];
+        if (!Number.isFinite(firstAxleSpread) ||
+            firstAxleSpread < 0 ||
+            !Number.isFinite(actualWeight)) {
+            continue;
+        }
+        for (let endAxleIndex = startAxleIndex + 1; endAxleIndex < axleConfiguration.length; endAxleIndex++) {
+            const endAxle = axleConfiguration[endAxleIndex];
+            const endAxleSpread = (_b = endAxle.axleSpread) !== null && _b !== void 0 ? _b : 0;
+            const interaxleSpacing = endAxle.interaxleSpacing;
+            const endAxleLegalWeight = legalWeightThresholds[endAxleIndex];
+            if (!Number.isFinite(interaxleSpacing) ||
+                interaxleSpacing <= 0 ||
+                !Number.isFinite(endAxleSpread) ||
+                endAxleSpread < 0 ||
+                !Number.isFinite(endAxle.axleUnitWeight)) {
+                break;
+            }
+            groupSpread += interaxleSpacing + endAxleSpread;
+            actualWeight += endAxle.axleUnitWeight;
+            if (individualLegalWeightSum === undefined ||
+                endAxleLegalWeight === undefined) {
+                individualLegalWeightSum = undefined;
+            }
+            else {
+                individualLegalWeightSum += endAxleLegalWeight;
+            }
+            if (groupSpread > ctr717MaxSpreadCm) {
+                break;
+            }
+            const ctr717TableValue = (0, ctr_717_helper_1.getCtr717TableValue)(groupSpread);
+            const isTandemDriveSingleJeepException = startAxleIndex === 1 &&
+                endAxleIndex === 2 &&
+                vehicleConfiguration[0] === 'TRKTRAC' &&
+                vehicleConfiguration[1] === enum_1.AccessoryVehicleType.Jeep &&
+                axleUnitVehicleIndexes[1] === 0 &&
+                axleUnitVehicleIndexes[2] === 1 &&
+                axleConfiguration[1].numberOfAxles === 2 &&
+                axleConfiguration[2].numberOfAxles === 1;
+            if (ctr717TableValue === undefined ||
+                (!isTandemDriveSingleJeepException &&
+                    individualLegalWeightSum === undefined)) {
+                continue;
+            }
+            const thresholdWeight = getMaximumLegalAxleGroupWeightThreshold(individualLegalWeightSum !== null && individualLegalWeightSum !== void 0 ? individualLegalWeightSum : 0, ctr717TableValue, isTandemDriveSingleJeepException);
+            const passes = actualWeight <= thresholdWeight;
+            const startAxleUnit = startAxleIndex + 1;
+            const endAxleUnit = endAxleIndex + 1;
+            const overloadAmount = Math.max(0, actualWeight - thresholdWeight);
+            policyCheckResults.push({
+                id: policyId,
+                result: passes
+                    ? enum_1.PolicyCheckResultType.Pass
+                    : enum_1.PolicyCheckResultType.Fail,
+                message: passes
+                    ? ''
+                    : `Axle Group ${startAxleUnit} to ${endAxleUnit} exceeds the maximum legal weight threshold of ${thresholdWeight} kg by ${overloadAmount} kg.`,
+                startAxleUnit,
+                endAxleUnit,
+                actualWeight,
+                thresholdWeight,
+            });
+        }
+    }
+    return policyCheckResults;
+}
 function meetsMinimumSteerPercentageOfDriveAxleWeight(steerAxle, driveAxle, minimumPercentage) {
     return (steerAxle.axleUnitWeight >= driveAxle.axleUnitWeight * minimumPercentage);
 }
@@ -772,7 +887,8 @@ function CheckBoosterAxleLimit(_policy, vehicleConfiguration, axleConfiguration)
                 message: result
                     ? ''
                     : `No. of Axles for Axle Unit ${boosterAxleUnit} must be less than or equal to No. of Axles for Axle Unit ${trailerAxleUnit}`,
-                startAxleUnit: trailerAxleUnit,
+                // startAxleUnit and endAxleUnit should be the same for field highlighting purposes
+                startAxleUnit: boosterAxleUnit,
                 endAxleUnit: boosterAxleUnit,
             });
             return;
@@ -894,6 +1010,7 @@ function CheckDriveJeepLoadEqualization(_policy, vehicleConfiguration, axleConfi
  * this map with additional entries.
  *
  * Currently includes:
+ * - AxleGroupMaximumLegalWeightThreshold: Validates axle groups within 8 m against CTR 7.17
  * - 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
@@ -914,6 +1031,10 @@ function CheckDriveJeepLoadEqualization(_policy, vehicleConfiguration, axleConfi
 exports.policyCheckMap = new Map([
     [enum_1.PolicyCheckId.NumberOfAxles, CheckNumberOfAxles],
     [enum_1.PolicyCheckId.BridgeFormula, CheckBridgeFormula],
+    [
+        enum_1.PolicyCheckId.AxleGroupMaximumLegalWeightThreshold,
+        CheckAxleGroupMaximumLegalWeightThreshold,
+    ],
     [enum_1.PolicyCheckId.CheckPermittableWeight, CheckPermittableWeight],
     [enum_1.PolicyCheckId.MaxTireLoad, CheckMaxTireLoad],
     [enum_1.PolicyCheckId.MinDriveAxleWeight, CheckMinDriveAxleWeight],

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const version = "v2.18.0";
+export declare const version = "v2.19.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.18.0';
+exports.version = 'v2.19.0';

package/package.json

@@ -91,5 +91,5 @@
     ],
     "testEnvironment": "node"
   },
-  "version": "v2.18.0"
+  "version": "v2.19.0"
 }