onroute-policy-engine 2.14.0 → 2.16.0

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

@@ -10,7 +10,9 @@ export declare enum PolicyCheckId {
     MaxTireLoad = "max-tire-load",
     MinDriveAxleWeight = "minimum-drive-axle-weight",
     MinSteerAxleWeight = "minimum-steer-axle-weight",
+    MinTandemSteerAxleWeight = "minimum-tandem-steer-axle-weight",
     NumberOfAxles = "number-of-axles",
     NumberOfWheelsPerAxle = "number-of-wheels",
+    PickerTruckTractorWeightRestrictions = "picker-truck-tractor-weight-restrictions",
     TruckTractorWheelbase = "truck-tractor-wheelbase"
 }

package/dist/enum/policy-check.js

@@ -15,7 +15,9 @@ var PolicyCheckId;
     PolicyCheckId["MaxTireLoad"] = "max-tire-load";
     PolicyCheckId["MinDriveAxleWeight"] = "minimum-drive-axle-weight";
     PolicyCheckId["MinSteerAxleWeight"] = "minimum-steer-axle-weight";
+    PolicyCheckId["MinTandemSteerAxleWeight"] = "minimum-tandem-steer-axle-weight";
     PolicyCheckId["NumberOfAxles"] = "number-of-axles";
     PolicyCheckId["NumberOfWheelsPerAxle"] = "number-of-wheels";
+    PolicyCheckId["PickerTruckTractorWeightRestrictions"] = "picker-truck-tractor-weight-restrictions";
     PolicyCheckId["TruckTractorWheelbase"] = "truck-tractor-wheelbase";
 })(PolicyCheckId || (exports.PolicyCheckId = PolicyCheckId = {}));

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

@@ -156,7 +156,7 @@ export declare function CheckPermittableWeight(policy: Policy, vehicleConfigurat
  * @example
  * // For a single steer, tridem drive configuration
  * const results = CheckMinSteerAxleWeight(policy, ['TRKTRAC'], [
- *   { numberOfAxles: 1, axleUnitWeight: 8000 },  // Steer axle
+ *   { numberOfAxles: 1, axleUnitWeight: 8000 },  // Single steer axle
  *   { numberOfAxles: 3, axleUnitWeight: 30000 }  // Tridem drive axle
  * ]);
  * // Returns pass if steer axle weight >= 27% of drive axle weight (8100 kgs)
@@ -165,6 +165,22 @@ export declare function CheckPermittableWeight(policy: Policy, vehicleConfigurat
  * @see AxleGroupPolicyCheckResult
  */
 export declare function CheckMinSteerAxleWeight(_policy: Policy, _vehicleConfiguration: Array<string>, axleConfiguration: Array<AxleConfiguration>): Array<PolicyCheckResult>;
+/**
+ * Validates minimum tandem steer axle weight requirements for tandem steer
+ * power units with tandem or tridem drive axle units. The tandem steer axle
+ * unit must carry at least 40% of the drive axle unit weight.
+ *
+ * @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 weight and axle count information
+ * @returns Array of AxleGroupPolicyCheckResult objects with validation results
+ */
+export declare function CheckMinTandemSteerAxleWeight(_policy: Policy, _vehicleConfiguration: Array<string>, axleConfiguration: Array<AxleConfiguration>): Array<PolicyCheckResult>;
+/**
+ * Applies the restricted weight rules for non-standard tandem steer/tridem
+ * drive picker truck tractors.
+ */
+export declare function CheckPickerTruckTractorWeightRestrictions(policy: Policy, vehicleConfiguration: Array<string>, axleConfiguration: Array<AxleConfiguration>): Array<AxleGroupPolicyCheckResult>;
 /**
  * Validates minimum drive axle weight requirements for tandem and tridem drive power units.
  *
@@ -284,6 +300,8 @@ export declare function CheckDriveJeepLoadEqualization(_policy: Policy, vehicleC
  * - 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
+ * - MinTandemSteerAxleWeight: Validates tandem steer minimum weight requirements
+ * - PickerTruckTractorWeightRestrictions: Validates non-standard picker truck tractor restrictions
  * - NumberOfAxles: Validates axle count per axle unit
  * - NumberOfWheelsPerAxle: Validates tire count per axle unit
  * - BoosterAxleLimit: Validates booster axle count against the preceding trailer

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

@@ -6,6 +6,8 @@ exports.CheckBridgeFormula = CheckBridgeFormula;
 exports.CheckNumTiresPerAxle = CheckNumTiresPerAxle;
 exports.CheckPermittableWeight = CheckPermittableWeight;
 exports.CheckMinSteerAxleWeight = CheckMinSteerAxleWeight;
+exports.CheckMinTandemSteerAxleWeight = CheckMinTandemSteerAxleWeight;
+exports.CheckPickerTruckTractorWeightRestrictions = CheckPickerTruckTractorWeightRestrictions;
 exports.CheckMinDriveAxleWeight = CheckMinDriveAxleWeight;
 exports.CheckMaxTireLoad = CheckMaxTireLoad;
 exports.CheckBoosterAxleLimit = CheckBoosterAxleLimit;
@@ -13,6 +15,9 @@ exports.CheckTruckTractorWheelbase = CheckTruckTractorWheelbase;
 exports.CheckDriveJeepLoadEqualization = CheckDriveJeepLoadEqualization;
 const dimensions_helper_1 = require("./dimensions.helper");
 const enum_1 = require("../enum");
+function meetsMinimumSteerPercentageOfDriveAxleWeight(steerAxle, driveAxle, minimumPercentage) {
+    return (steerAxle.axleUnitWeight >= driveAxle.axleUnitWeight * minimumPercentage);
+}
 /**
  * Validates the number of axles in each axle unit.
  *
@@ -303,7 +308,7 @@ function CheckPermittableWeight(policy, vehicleConfiguration, axleConfiguration)
  * @example
  * // For a single steer, tridem drive configuration
  * const results = CheckMinSteerAxleWeight(policy, ['TRKTRAC'], [
- *   { numberOfAxles: 1, axleUnitWeight: 8000 },  // Steer axle
+ *   { numberOfAxles: 1, axleUnitWeight: 8000 },  // Single steer axle
  *   { numberOfAxles: 3, axleUnitWeight: 30000 }  // Tridem drive axle
  * ]);
  * // Returns pass if steer axle weight >= 27% of drive axle weight (8100 kgs)
@@ -318,14 +323,13 @@ function CheckMinSteerAxleWeight(_policy, _vehicleConfiguration, axleConfigurati
     if (axleConfiguration[0].numberOfAxles === 1 &&
         axleConfiguration[1].numberOfAxles === 3) {
         // Check minimum load on steer axle
-        if (axleConfiguration[0].axleUnitWeight >=
-            axleConfiguration[1].axleUnitWeight * 0.27) {
-            message = 'Steer axle meets minimum weight requirements';
+        if (meetsMinimumSteerPercentageOfDriveAxleWeight(axleConfiguration[0], axleConfiguration[1], 0.27)) {
+            message = 'Single steer axle meets minimum weight requirements';
             result = enum_1.PolicyCheckResultType.Pass;
         }
         else {
             message =
-                'Steer axle must be a minimum of 27% of tridem drive axle weight';
+                'Single steer axle must be a minimum of 27% of tridem drive axle weight';
             result = enum_1.PolicyCheckResultType.Fail;
         }
     }
@@ -343,6 +347,136 @@ function CheckMinSteerAxleWeight(_policy, _vehicleConfiguration, axleConfigurati
     });
     return policyCheckResults;
 }
+/**
+ * Validates minimum tandem steer axle weight requirements for tandem steer
+ * power units with tandem or tridem drive axle units. The tandem steer axle
+ * unit must carry at least 40% of the drive axle unit weight.
+ *
+ * @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 weight and axle count information
+ * @returns Array of AxleGroupPolicyCheckResult objects with validation results
+ */
+function CheckMinTandemSteerAxleWeight(_policy, _vehicleConfiguration, axleConfiguration) {
+    const policyCheckResults = new Array();
+    const policyId = enum_1.PolicyCheckId.MinTandemSteerAxleWeight;
+    const steerAxle = axleConfiguration[0];
+    const driveAxle = axleConfiguration[1];
+    let message, result;
+    if (steerAxle.numberOfAxles === 2 &&
+        (driveAxle.numberOfAxles === 2 || driveAxle.numberOfAxles === 3)) {
+        if (meetsMinimumSteerPercentageOfDriveAxleWeight(steerAxle, driveAxle, 0.4)) {
+            message = 'Tandem steer axle meets minimum weight requirements';
+            result = enum_1.PolicyCheckResultType.Pass;
+        }
+        else {
+            message =
+                'Tandem steer axle must be a minimum of 40% of drive axle weight';
+            result = enum_1.PolicyCheckResultType.Fail;
+        }
+    }
+    else {
+        message = 'Policy check does not apply to this configuration';
+        result = enum_1.PolicyCheckResultType.Pass;
+    }
+    policyCheckResults.push({
+        id: policyId,
+        message: message,
+        result: result,
+        startAxleUnit: 1,
+        endAxleUnit: 2,
+    });
+    return policyCheckResults;
+}
+/**
+ * Applies the restricted weight rules for non-standard tandem steer/tridem
+ * drive picker truck tractors.
+ */
+function CheckPickerTruckTractorWeightRestrictions(policy, vehicleConfiguration, axleConfiguration) {
+    const policyId = enum_1.PolicyCheckId.PickerTruckTractorWeightRestrictions;
+    const MINIMUM_WHEELBASE_CM = 660;
+    const MINIMUM_STEER_AXLE_SPREAD_CM = 100;
+    const MINIMUM_DRIVE_AXLE_SPREAD_CM = 240;
+    const steerAxle = axleConfiguration[0];
+    const driveAxle = axleConfiguration[1];
+    const doesNotApply = (message = 'Policy check does not apply to this configuration') => [
+        {
+            id: policyId,
+            message,
+            result: enum_1.PolicyCheckResultType.Pass,
+            startAxleUnit: 1,
+            endAxleUnit: 2,
+        },
+    ];
+    if (vehicleConfiguration[0] !== 'PICKRTT' ||
+        !steerAxle ||
+        !driveAxle ||
+        steerAxle.numberOfAxles !== 2 ||
+        driveAxle.numberOfAxles !== 3) {
+        return doesNotApply();
+    }
+    const hasWheelbaseDimensions = Number.isFinite(steerAxle.axleSpread) &&
+        Number.isFinite(driveAxle.interaxleSpacing) &&
+        Number.isFinite(driveAxle.axleSpread);
+    const wheelbase = hasWheelbaseDimensions
+        ? steerAxle.axleSpread / 2 +
+            driveAxle.interaxleSpacing +
+            driveAxle.axleSpread / 2
+        : undefined;
+    const isNonStandard = (wheelbase !== undefined && wheelbase < MINIMUM_WHEELBASE_CM) ||
+        (steerAxle.axleSpread !== undefined &&
+            steerAxle.axleSpread < MINIMUM_STEER_AXLE_SPREAD_CM) ||
+        (driveAxle.axleSpread !== undefined &&
+            driveAxle.axleSpread < MINIMUM_DRIVE_AXLE_SPREAD_CM);
+    if (!isNonStandard) {
+        return doesNotApply();
+    }
+    const powerUnitWeights = policy.getDefaultPowerUnitWeight('PICKRTT', 23);
+    const steerWeightDimension = policy.selectCorrectWeightDimension(powerUnitWeights, vehicleConfiguration, axleConfiguration, 0);
+    const driveWeightDimension = policy.selectCorrectWeightDimension(powerUnitWeights, vehicleConfiguration, axleConfiguration, 1);
+    const steerPermittable = steerWeightDimension === null || steerWeightDimension === void 0 ? void 0 : steerWeightDimension.permittable;
+    const drivePermittable = driveWeightDimension === null || driveWeightDimension === void 0 ? void 0 : driveWeightDimension.permittable;
+    if (steerPermittable === undefined ||
+        drivePermittable === undefined ||
+        steerAxle.axleUnitWeight > steerPermittable ||
+        driveAxle.axleUnitWeight > drivePermittable) {
+        return doesNotApply('Policy check does not apply outside configured permittable axle weights');
+    }
+    const ratioPasses = meetsMinimumSteerPercentageOfDriveAxleWeight(steerAxle, driveAxle, 0.5);
+    const hasRealTrailer = vehicleConfiguration.slice(1).some((vehicleType) => {
+        const vehicleDefinition = policy.getVehicleDefinition(vehicleType);
+        return !(vehicleDefinition === null || vehicleDefinition === void 0 ? void 0 : vehicleDefinition.ignoreForAxleCalculation);
+    });
+    const exceedsLegalWeight = ((steerWeightDimension === null || steerWeightDimension === void 0 ? void 0 : steerWeightDimension.legal) !== undefined &&
+        steerAxle.axleUnitWeight > steerWeightDimension.legal) ||
+        ((driveWeightDimension === null || driveWeightDimension === void 0 ? void 0 : driveWeightDimension.legal) !== undefined &&
+            driveAxle.axleUnitWeight > driveWeightDimension.legal);
+    const trailerPasses = !hasRealTrailer || !exceedsLegalWeight;
+    return [
+        {
+            id: policyId,
+            message: ratioPasses
+                ? ''
+                : 'Axle Unit 1 must carry a minimum 50% of Axle Unit 2 axle unit weight.',
+            result: ratioPasses
+                ? enum_1.PolicyCheckResultType.Pass
+                : enum_1.PolicyCheckResultType.Fail,
+            startAxleUnit: 1,
+            endAxleUnit: 2,
+        },
+        {
+            id: policyId,
+            message: trailerPasses
+                ? ''
+                : 'Cannot tow a trailer if Axle Unit 1 and Axle Unit 2 are exceeding legal axle weights.',
+            result: trailerPasses
+                ? enum_1.PolicyCheckResultType.Pass
+                : enum_1.PolicyCheckResultType.Fail,
+            startAxleUnit: 1,
+            endAxleUnit: 2,
+        },
+    ];
+}
 /**
  * Validates minimum drive axle weight requirements for tandem and tridem drive power units.
  *
@@ -763,6 +897,8 @@ function CheckDriveJeepLoadEqualization(_policy, vehicleConfiguration, axleConfi
  * - 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
+ * - MinTandemSteerAxleWeight: Validates tandem steer minimum weight requirements
+ * - PickerTruckTractorWeightRestrictions: Validates non-standard picker truck tractor restrictions
  * - NumberOfAxles: Validates axle count per axle unit
  * - NumberOfWheelsPerAxle: Validates tire count per axle unit
  * - BoosterAxleLimit: Validates booster axle count against the preceding trailer
@@ -780,6 +916,11 @@ exports.policyCheckMap = new Map([
     [enum_1.PolicyCheckId.MaxTireLoad, CheckMaxTireLoad],
     [enum_1.PolicyCheckId.MinDriveAxleWeight, CheckMinDriveAxleWeight],
     [enum_1.PolicyCheckId.MinSteerAxleWeight, CheckMinSteerAxleWeight],
+    [enum_1.PolicyCheckId.MinTandemSteerAxleWeight, CheckMinTandemSteerAxleWeight],
+    [
+        enum_1.PolicyCheckId.PickerTruckTractorWeightRestrictions,
+        CheckPickerTruckTractorWeightRestrictions,
+    ],
     [enum_1.PolicyCheckId.NumberOfWheelsPerAxle, CheckNumTiresPerAxle],
     [enum_1.PolicyCheckId.BoosterAxleLimit, CheckBoosterAxleLimit],
     [enum_1.PolicyCheckId.TruckTractorWheelbase, CheckTruckTractorWheelbase],

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const version = "v2.14.0";
+export declare const version = "v2.16.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.14.0';
+exports.version = 'v2.16.0';

package/package.json

@@ -91,5 +91,5 @@
     ],
     "testEnvironment": "node"
   },
-  "version": "v2.14.0"
+  "version": "v2.16.0"
 }