onroute-policy-engine 2.22.1 → 2.23.0

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

@@ -7,6 +7,7 @@ export declare enum PolicyCheckId {
     AxleGroupMaximumLegalWeightThreshold = "axle-group-maximum-legal-weight-threshold",
     BoosterAxleLimit = "booster-axle-limit",
     BridgeFormula = "bridge-formula",
+    CheckLegalWeight = "check-legal-weight",
     CheckPermittableWeight = "check-permittable-weight",
     DriveJeepLoadEqualization = "drive-jeep-load-equalization",
     MaxTireLoad = "max-tire-load",

package/dist/enum/policy-check.js

@@ -12,6 +12,7 @@ var PolicyCheckId;
     PolicyCheckId["AxleGroupMaximumLegalWeightThreshold"] = "axle-group-maximum-legal-weight-threshold";
     PolicyCheckId["BoosterAxleLimit"] = "booster-axle-limit";
     PolicyCheckId["BridgeFormula"] = "bridge-formula";
+    PolicyCheckId["CheckLegalWeight"] = "check-legal-weight";
     PolicyCheckId["CheckPermittableWeight"] = "check-permittable-weight";
     PolicyCheckId["DriveJeepLoadEqualization"] = "drive-jeep-load-equalization";
     PolicyCheckId["MaxTireLoad"] = "max-tire-load";

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

@@ -16,6 +16,14 @@ import { Policy } from 'onroute-policy-engine';
 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 each axle unit against its legal weight maximum.
+ *
+ * The feature-defined steering and drive limits are authoritative for the
+ * standard truck/truck-tractor and PME subtypes. Other axle units retain
+ * their configured legal weight lookup.
+ */
+export declare function CheckLegalWeight(policy: Policy, vehicleConfiguration: Array<string>, axleConfiguration: Array<AxleConfiguration>): Array<PolicyCheckResult>;
 /**
  * Validates every contiguous axle-unit group within 8 m, excluding groups
  * beginning at axle unit 1, against the CTR 7.17 maximum legal weight.
@@ -301,6 +309,7 @@ export declare function CheckDriveJeepLoadEqualization(_policy: Policy, vehicleC
  * Currently includes:
  * - AxleGroupMaximumLegalWeightThreshold: Validates axle groups within 8 m against CTR 7.17
  * - BridgeFormula: Validates axle groups against bridge formula requirements
+ * - CheckLegalWeight: Validates axle units against legal weight limits
  * - 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

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

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.policyCheckMap = void 0;
 exports.getMaximumLegalAxleGroupWeightThreshold = getMaximumLegalAxleGroupWeightThreshold;
+exports.CheckLegalWeight = CheckLegalWeight;
 exports.CheckAxleGroupMaximumLegalWeightThreshold = CheckAxleGroupMaximumLegalWeightThreshold;
 exports.CheckNumberOfAxles = CheckNumberOfAxles;
 exports.CheckBridgeFormula = CheckBridgeFormula;
@@ -18,6 +19,27 @@ exports.CheckDriveJeepLoadEqualization = CheckDriveJeepLoadEqualization;
 const dimensions_helper_1 = require("./dimensions.helper");
 const ctr_717_helper_1 = require("./ctr-717.helper");
 const enum_1 = require("../enum");
+const POWER_UNIT_AXLE_CODE_MULTIPLIER = 10;
+const LEGAL_WEIGHT_MAXIMUM_KG = {
+    SINGLE_AXLE: 9100,
+    STANDARD_TRUCK_TRACTOR_STEER: 6000,
+    STANDARD_SINGLE_STEER_WITH_TRIDEM_DRIVE: 7300,
+    TANDEM_AXLE: 17000,
+    STANDARD_TANDEM_STEER_WITH_TRIDEM_DRIVE: 13600,
+    PME_TANDEM_STEER_WITH_TRIDEM_DRIVE: 15200,
+    TRIDEM_AXLE: 24000,
+};
+const PERMITTABLE_WEIGHT_MAXIMUM_KG = {
+    SINGLE_STEER: 9100,
+    SINGLE_NON_STEER: 11000,
+    TANDEM: 23000,
+    STANDARD_TRIDEM: 28000,
+    QUALIFYING_TRIDEM: 29000,
+};
+const QUALIFYING_TRIDEM_SPREAD_CM = {
+    MINIMUM: 240,
+    MAXIMUM: 370,
+};
 /** Applies the standard lower-of rule or the exact 7.16(g) exception. */
 function getMaximumLegalAxleGroupWeightThreshold(individualLegalWeightSum, ctr717TableValue, isTandemDriveSingleJeepException) {
     const tandemDriveSingleJeepMinimumKg = 24000;
@@ -34,7 +56,7 @@ function getApplicableLegalWeightThreshold(policy, vehicleConfiguration, axleCon
         return undefined;
     }
     const weights = vehicleIndex === 0
-        ? policy.getDefaultPowerUnitWeight(vehicleType, axleConfiguration[0].numberOfAxles * 10 +
+        ? policy.getDefaultPowerUnitWeight(vehicleType, axleConfiguration[0].numberOfAxles * POWER_UNIT_AXLE_CODE_MULTIPLIER +
             axleConfiguration[1].numberOfAxles)
         : policy.getDefaultTrailerWeight(vehicleType, axle.numberOfAxles);
     if (weights.length === 0) {
@@ -42,6 +64,98 @@ function getApplicableLegalWeightThreshold(policy, vehicleConfiguration, axleCon
     }
     return (_a = policy.selectCorrectWeightDimension(weights, vehicleConfiguration, axleConfiguration, axleIndex)) === null || _a === void 0 ? void 0 : _a.legal;
 }
+function getAxleUnitVehicleIndexLookup(policy, vehicleConfiguration, axleConfiguration) {
+    return axleConfiguration.some((axleUnit) => axleUnit.vehicleIndex !== undefined)
+        ? (0, dimensions_helper_1.getAxleUnitVehicleIndexes)(policy, vehicleConfiguration, axleConfiguration)
+        : axleConfiguration.map((_, axleIndex) => axleIndex < 2 ? 0 : axleIndex - 1);
+}
+function getConfiguredAxleUnitWeightThreshold(policy, vehicleConfiguration, axleConfiguration, axleUnitVehicleIndexes, axleIndex, threshold) {
+    var _a;
+    var _b;
+    const vehicleIndex = axleUnitVehicleIndexes[axleIndex];
+    const vehicleType = vehicleConfiguration[vehicleIndex];
+    const axleUnit = axleConfiguration[axleIndex];
+    if (!vehicleType || !axleUnit) {
+        return 0;
+    }
+    const weights = vehicleIndex === 0
+        ? policy.getDefaultPowerUnitWeight(vehicleType, axleConfiguration[0].numberOfAxles * POWER_UNIT_AXLE_CODE_MULTIPLIER +
+            axleConfiguration[1].numberOfAxles)
+        : policy.getDefaultTrailerWeight(vehicleType, axleUnit.numberOfAxles);
+    if (weights.length === 0) {
+        return 0;
+    }
+    return ((_b = (_a = policy.selectCorrectWeightDimension(weights, vehicleConfiguration, axleConfiguration, axleIndex)) === null || _a === void 0 ? void 0 : _a[threshold]) !== null && _b !== void 0 ? _b : 0);
+}
+function isFeatureLegalWeightPowerUnit(vehicleType) {
+    return (vehicleType === 'REGTRCK' ||
+        vehicleType === 'TRKTRAC' ||
+        vehicleType === 'TRCKPME' ||
+        vehicleType === 'TRACPME');
+}
+function getFeatureLegalPowerUnitWeightThreshold(vehicleType, axleConfiguration, axleIndex) {
+    const steerAxle = axleConfiguration[0];
+    const driveAxle = axleConfiguration[1];
+    const hasPme = vehicleType === 'TRCKPME' || vehicleType === 'TRACPME';
+    if (axleIndex === 0) {
+        if (steerAxle.numberOfAxles === 1 &&
+            (driveAxle.numberOfAxles === 1 || driveAxle.numberOfAxles === 2)) {
+            return hasPme || vehicleType === 'REGTRCK'
+                ? LEGAL_WEIGHT_MAXIMUM_KG.SINGLE_AXLE
+                : LEGAL_WEIGHT_MAXIMUM_KG.STANDARD_TRUCK_TRACTOR_STEER;
+        }
+        if (steerAxle.numberOfAxles === 1 && driveAxle.numberOfAxles === 3) {
+            return hasPme
+                ? LEGAL_WEIGHT_MAXIMUM_KG.SINGLE_AXLE
+                : LEGAL_WEIGHT_MAXIMUM_KG.STANDARD_SINGLE_STEER_WITH_TRIDEM_DRIVE;
+        }
+        if (steerAxle.numberOfAxles === 2 && driveAxle.numberOfAxles === 2) {
+            return LEGAL_WEIGHT_MAXIMUM_KG.TANDEM_AXLE;
+        }
+        if (steerAxle.numberOfAxles === 2 && driveAxle.numberOfAxles === 3) {
+            return hasPme
+                ? LEGAL_WEIGHT_MAXIMUM_KG.PME_TANDEM_STEER_WITH_TRIDEM_DRIVE
+                : LEGAL_WEIGHT_MAXIMUM_KG.STANDARD_TANDEM_STEER_WITH_TRIDEM_DRIVE;
+        }
+    }
+    if (axleIndex === 1) {
+        return {
+            1: LEGAL_WEIGHT_MAXIMUM_KG.SINGLE_AXLE,
+            2: LEGAL_WEIGHT_MAXIMUM_KG.TANDEM_AXLE,
+            3: LEGAL_WEIGHT_MAXIMUM_KG.TRIDEM_AXLE,
+        }[driveAxle.numberOfAxles];
+    }
+    return undefined;
+}
+/**
+ * Validates each axle unit against its legal weight maximum.
+ *
+ * The feature-defined steering and drive limits are authoritative for the
+ * standard truck/truck-tractor and PME subtypes. Other axle units retain
+ * their configured legal weight lookup.
+ */
+function CheckLegalWeight(policy, vehicleConfiguration, axleConfiguration) {
+    const policyId = enum_1.PolicyCheckId.CheckLegalWeight;
+    const powerUnitType = vehicleConfiguration[0];
+    const axleUnitVehicleIndexes = getAxleUnitVehicleIndexLookup(policy, vehicleConfiguration, axleConfiguration);
+    return axleConfiguration.map((axleUnit, axleIndex) => {
+        const featureThreshold = axleUnitVehicleIndexes[axleIndex] === 0 &&
+            isFeatureLegalWeightPowerUnit(powerUnitType)
+            ? getFeatureLegalPowerUnitWeightThreshold(powerUnitType, axleConfiguration, axleIndex)
+            : undefined;
+        const legalWeight = featureThreshold !== null && featureThreshold !== void 0 ? featureThreshold : getConfiguredAxleUnitWeightThreshold(policy, vehicleConfiguration, axleConfiguration, axleUnitVehicleIndexes, axleIndex, 'legal');
+        const result = axleUnit.axleUnitWeight <= legalWeight;
+        const axleUnitNumber = axleIndex + 1;
+        return {
+            id: policyId,
+            message: `Weight for axle unit ${axleUnitNumber} ${result ? 'is legal' : `must not exceed ${legalWeight} kgs`}`,
+            result: result ? enum_1.PolicyCheckResultType.Pass : enum_1.PolicyCheckResultType.Fail,
+            axleUnit: axleUnitNumber,
+            actualWeight: axleUnit.axleUnitWeight,
+            thresholdWeight: legalWeight,
+        };
+    });
+}
 /**
  * Validates every contiguous axle-unit group within 8 m, excluding groups
  * beginning at axle unit 1, against the CTR 7.17 maximum legal weight.
@@ -172,6 +286,37 @@ function CheckNumberOfAxles(_policy, _vehicleConfiguration, axleConfiguration) {
     });
     return policyCheckResults;
 }
+function getBridgeFormulaInputFailure(axleConfiguration) {
+    for (let axleIndex = 0; axleIndex < axleConfiguration.length; axleIndex++) {
+        const axleUnit = axleConfiguration[axleIndex];
+        const axleUnitNumber = axleIndex + 1;
+        let message;
+        if (!Number.isFinite(axleUnit.axleUnitWeight) ||
+            axleUnit.axleUnitWeight <= 0) {
+            message = `Axle unit weight for axle unit ${axleUnitNumber} must be a finite number greater than 0.`;
+        }
+        else if (axleUnit.numberOfAxles > 1 &&
+            (!Number.isFinite(axleUnit.axleSpread) ||
+                axleUnit.axleSpread <= 0)) {
+            message = `Axle spread for axle unit ${axleUnitNumber} must be a finite number greater than 0 when the unit has multiple axles.`;
+        }
+        else if (axleIndex > 0 &&
+            (!Number.isFinite(axleUnit.interaxleSpacing) ||
+                axleUnit.interaxleSpacing <= 0)) {
+            message = `Axle spacing before axle unit ${axleUnitNumber} must be a finite number greater than 0.`;
+        }
+        if (message) {
+            return {
+                id: enum_1.PolicyCheckId.BridgeFormula,
+                message,
+                result: enum_1.PolicyCheckResultType.Fail,
+                startAxleUnit: axleUnitNumber,
+                endAxleUnit: axleUnitNumber,
+            };
+        }
+    }
+    return undefined;
+}
 /**
  * Performs bridge formula calculations on axle groups and returns policy check results.
  *
@@ -201,6 +346,10 @@ function CheckNumberOfAxles(_policy, _vehicleConfiguration, axleConfiguration) {
 function CheckBridgeFormula(policy, _vehicleConfiguration, axleConfiguration) {
     const policyCheckResults = new Array();
     const policyId = enum_1.PolicyCheckId.BridgeFormula;
+    const inputFailure = getBridgeFormulaInputFailure(axleConfiguration);
+    if (inputFailure) {
+        return [inputFailure];
+    }
     const bridgeCalcResults = policy.calculateBridge(axleConfiguration);
     bridgeCalcResults.forEach((br) => {
         const message = `Axle group ${br.startAxleUnit} to ${br.endAxleUnit} ${br.success ? 'passes' : 'does not pass'} bridge formula.`;
@@ -338,77 +487,51 @@ function CheckNumTiresPerAxle(_policy, _vehicleConfiguration, axleConfiguration)
  * @see SingleAxleDimension
  */
 function CheckPermittableWeight(policy, vehicleConfiguration, axleConfiguration) {
-    const policyCheckResults = new Array();
     const policyId = enum_1.PolicyCheckId.CheckPermittableWeight;
-    const hasVehicleIndexes = axleConfiguration.some((axleUnit) => axleUnit.vehicleIndex !== undefined);
-    // Legacy John Fletcher implementation, restored from:
-    // git show e4a9d6badd025dec844df43379f776a4995ad75b^:src/helper/policy-check.helper.ts
-    if (!hasVehicleIndexes) {
-        const singleAxleDimensions = [];
-        vehicleConfiguration.forEach((vc, i) => {
-            let weight;
-            if (i === 0) {
-                const powerUnitAxles = axleConfiguration[0].numberOfAxles * 10 +
-                    axleConfiguration[1].numberOfAxles;
-                weight = policy.getDefaultPowerUnitWeight(vc, powerUnitAxles);
-                const steerAxleDimension = policy.selectCorrectWeightDimension(weight, vehicleConfiguration, axleConfiguration, 0) || {};
-                singleAxleDimensions.push(steerAxleDimension);
-                const driveAxleDimension = policy.selectCorrectWeightDimension(weight, vehicleConfiguration, axleConfiguration, 1) || {};
-                singleAxleDimensions.push(driveAxleDimension);
+    const axleUnitVehicleIndexes = getAxleUnitVehicleIndexLookup(policy, vehicleConfiguration, axleConfiguration);
+    return axleConfiguration.map((axleUnit, axleIndex) => {
+        const vehicleIndex = axleUnitVehicleIndexes[axleIndex];
+        const isSingleSteer = axleIndex === 0 && vehicleIndex === 0 && axleUnit.numberOfAxles === 1;
+        const isTandemSteer = axleIndex === 0 && vehicleIndex === 0 && axleUnit.numberOfAxles === 2;
+        let permittableWeight;
+        if (isSingleSteer) {
+            permittableWeight = PERMITTABLE_WEIGHT_MAXIMUM_KG.SINGLE_STEER;
+        }
+        else if (!isTandemSteer) {
+            if (axleUnit.numberOfAxles === 1) {
+                permittableWeight = PERMITTABLE_WEIGHT_MAXIMUM_KG.SINGLE_NON_STEER;
             }
-            else if (i + 1 < axleConfiguration.length) {
-                weight = policy.getDefaultTrailerWeight(vc, axleConfiguration[i + 1].numberOfAxles);
-                const trailerDimension = policy.selectCorrectWeightDimension(weight, vehicleConfiguration, axleConfiguration, i + 1) || {};
-                singleAxleDimensions.push(trailerDimension);
+            else if (axleUnit.numberOfAxles === 2) {
+                permittableWeight = PERMITTABLE_WEIGHT_MAXIMUM_KG.TANDEM;
             }
-        });
-        axleConfiguration.forEach((ac, i) => {
-            const actualWeight = ac.axleUnitWeight;
-            const permittableWeight = singleAxleDimensions[i].permittable || 0;
-            const result = actualWeight <= permittableWeight;
-            const axleUnit = i + 1;
-            const message = `Weight for axle unit ${axleUnit} ${result ? 'is permittable' : `must not exceed ${permittableWeight} kgs`}`;
-            policyCheckResults.push({
-                id: policyId,
-                message: message,
-                result: result
-                    ? enum_1.PolicyCheckResultType.Pass
-                    : enum_1.PolicyCheckResultType.Fail,
-                axleUnit: axleUnit,
-                actualWeight: actualWeight,
-                thresholdWeight: permittableWeight,
-            });
-        });
-        return policyCheckResults;
-    }
-    // Explicit multi-axle ownership path supplied by the consuming application.
-    // This is the new way, using { vehicleIndex: num }
-    const axleUnitVehicleIndexes = (0, dimensions_helper_1.getAxleUnitVehicleIndexes)(policy, vehicleConfiguration, axleConfiguration);
-    axleConfiguration.forEach((ac, i) => {
-        const vehicleIndex = axleUnitVehicleIndexes[i];
-        const vehicleType = vehicleConfiguration[vehicleIndex];
-        const weight = vehicleIndex === 0
-            ? policy.getDefaultPowerUnitWeight(vehicleType, axleConfiguration[0].numberOfAxles * 10 +
-                axleConfiguration[1].numberOfAxles)
-            : policy.getDefaultTrailerWeight(vehicleType, ac.numberOfAxles);
-        const axleDimension = weight.length > 0
-            ? policy.selectCorrectWeightDimension(weight, vehicleConfiguration, axleConfiguration, i) || {}
-            : {};
-        const actualWeight = ac.axleUnitWeight;
-        const permittableWeight = axleDimension.permittable || 0;
-        const result = actualWeight <= permittableWeight;
-        const axleUnit = i + 1;
-        const message = `Weight for axle unit ${axleUnit} ${result ? 'is permittable' : `must not exceed ${permittableWeight} kgs`}`;
-        policyCheckResults.push({
+            else if (axleUnit.numberOfAxles === 3) {
+                const spreadQualifies = axleUnit.axleSpread !== undefined &&
+                    axleUnit.axleSpread >= QUALIFYING_TRIDEM_SPREAD_CM.MINIMUM &&
+                    axleUnit.axleSpread <= QUALIFYING_TRIDEM_SPREAD_CM.MAXIMUM;
+                const nextVehicleIndex = vehicleIndex + 1;
+                const hasImmediatelyFollowingBooster = vehicleConfiguration[nextVehicleIndex] ===
+                    enum_1.AccessoryVehicleType.Booster;
+                const boosterAxle = axleConfiguration.find((_, candidateIndex) => candidateIndex > axleIndex &&
+                    axleUnitVehicleIndexes[candidateIndex] === nextVehicleIndex);
+                const boosterQualifies = !hasImmediatelyFollowingBooster || (boosterAxle === null || boosterAxle === void 0 ? void 0 : boosterAxle.numberOfAxles) === 1;
+                permittableWeight =
+                    spreadQualifies && boosterQualifies
+                        ? PERMITTABLE_WEIGHT_MAXIMUM_KG.QUALIFYING_TRIDEM
+                        : PERMITTABLE_WEIGHT_MAXIMUM_KG.STANDARD_TRIDEM;
+            }
+        }
+        permittableWeight !== null && permittableWeight !== void 0 ? permittableWeight : (permittableWeight = getConfiguredAxleUnitWeightThreshold(policy, vehicleConfiguration, axleConfiguration, axleUnitVehicleIndexes, axleIndex, 'permittable'));
+        const result = axleUnit.axleUnitWeight <= permittableWeight;
+        const axleUnitNumber = axleIndex + 1;
+        return {
             id: policyId,
-            message: message,
+            message: `Weight for axle unit ${axleUnitNumber} ${result ? 'is permittable' : `must not exceed ${permittableWeight} kgs`}`,
             result: result ? enum_1.PolicyCheckResultType.Pass : enum_1.PolicyCheckResultType.Fail,
-            axleUnit: axleUnit,
-            actualWeight: actualWeight,
+            axleUnit: axleUnitNumber,
+            actualWeight: axleUnit.axleUnitWeight,
             thresholdWeight: permittableWeight,
-        });
+        };
     });
-    return policyCheckResults;
 }
 /**
  * Validates minimum steer axle weight requirements for single steer, tridem drive power units.
@@ -1092,6 +1215,7 @@ function CheckDriveJeepLoadEqualization(_policy, vehicleConfiguration, axleConfi
  * Currently includes:
  * - AxleGroupMaximumLegalWeightThreshold: Validates axle groups within 8 m against CTR 7.17
  * - BridgeFormula: Validates axle groups against bridge formula requirements
+ * - CheckLegalWeight: Validates axle units against legal weight limits
  * - 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
@@ -1116,6 +1240,7 @@ exports.policyCheckMap = new Map([
         enum_1.PolicyCheckId.AxleGroupMaximumLegalWeightThreshold,
         CheckAxleGroupMaximumLegalWeightThreshold,
     ],
+    [enum_1.PolicyCheckId.CheckLegalWeight, CheckLegalWeight],
     [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.22.1";
+export declare const version = "v2.23.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.22.1';
+exports.version = 'v2.23.0';

package/package.json

@@ -91,5 +91,5 @@
     ],
     "testEnvironment": "node"
   },
-  "version": "v2.22.1"
+  "version": "v2.23.0"
 }