onroute-policy-engine 2.24.2 → 2.25.0

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

@@ -7,15 +7,16 @@ 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",
+    LegalInteraxleSpacing = "legal-interaxle-spacing",
+    LegalWeight = "legal-weight",
     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",
+    PermittableWeight = "permittable-weight",
     PickerTruckTractorWeightRestrictions = "picker-truck-tractor-weight-restrictions",
     WheelbaseLegalLimits = "wheelbase-legal-limits"
 }

package/dist/enum/policy-check.js

@@ -12,15 +12,16 @@ 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["LegalInteraxleSpacing"] = "legal-interaxle-spacing";
+    PolicyCheckId["LegalWeight"] = "legal-weight";
     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["PermittableWeight"] = "permittable-weight";
     PolicyCheckId["PickerTruckTractorWeightRestrictions"] = "picker-truck-tractor-weight-restrictions";
     PolicyCheckId["WheelbaseLegalLimits"] = "wheelbase-legal-limits";
 })(PolicyCheckId || (exports.PolicyCheckId = PolicyCheckId = {}));

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

@@ -298,6 +298,11 @@ export declare function CheckWheelbaseLegalLimits(policy: Policy, vehicleConfigu
  * @returns Array of AxleGroupPolicyCheckResult objects for the applicable drive/jeep pair
  */
 export declare function CheckDriveJeepLoadEqualization(_policy: Policy, vehicleConfiguration: Array<string>, axleConfiguration: Array<AxleConfiguration>): Array<PolicyCheckResult>;
+/**
+ * Validates each axle unit against the minimum interaxle spacing for its
+ * current axle unit and the next axle unit, per Table II.
+ */
+export declare function CheckLegalInteraxleSpacing(_policy: Policy, _vehicleConfiguration: Array<string>, axleConfiguration: Array<AxleConfiguration>): Array<PolicyCheckResult>;
 /**
  * Map of policy check functions keyed by their corresponding PolicyCheckId.
  *

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

@@ -16,6 +16,7 @@ exports.CheckMaxTireLoad = CheckMaxTireLoad;
 exports.CheckBoosterAxleLimit = CheckBoosterAxleLimit;
 exports.CheckWheelbaseLegalLimits = CheckWheelbaseLegalLimits;
 exports.CheckDriveJeepLoadEqualization = CheckDriveJeepLoadEqualization;
+exports.CheckLegalInteraxleSpacing = CheckLegalInteraxleSpacing;
 const dimensions_helper_1 = require("./dimensions.helper");
 const ctr_717_helper_1 = require("./ctr-717.helper");
 const enum_1 = require("../enum");
@@ -40,6 +41,23 @@ const QUALIFYING_TRIDEM_SPREAD_CM = {
     MINIMUM: 240,
     MAXIMUM: 370,
 };
+const INTERAXLE_SPACING_MINIMUM_CM = {
+    SINGLE: {
+        SINGLE: 300,
+        TANDEM: 300,
+        TRIDEM: 300,
+    },
+    TANDEM: {
+        SINGLE: 300,
+        TANDEM: 500,
+        TRIDEM: 550,
+    },
+    TRIDEM: {
+        SINGLE: 300,
+        TANDEM: 550,
+        TRIDEM: 600,
+    },
+};
 /** Applies the standard lower-of rule or the exact 7.16(g) exception. */
 function getMaximumLegalAxleGroupWeightThreshold(individualLegalWeightSum, ctr717TableValue, isTandemDriveSingleJeepException) {
     const tandemDriveSingleJeepMinimumKg = 24000;
@@ -64,6 +82,10 @@ function getApplicableLegalWeightThreshold(policy, vehicleConfiguration, axleCon
     }
     return (_a = policy.selectCorrectWeightDimension(weights, vehicleConfiguration, axleConfiguration, axleIndex)) === null || _a === void 0 ? void 0 : _a.legal;
 }
+/**
+ * Returns an array of vehicle indexes for each axle unit.
+ * Each entry maps an axle unit to the vehicle in vehicleConfiguration that it belongs to.
+ */
 function getAxleUnitVehicleIndexLookup(policy, vehicleConfiguration, axleConfiguration) {
     return axleConfiguration.some((axleUnit) => axleUnit.vehicleIndex !== undefined)
         ? (0, dimensions_helper_1.getAxleUnitVehicleIndexes)(policy, vehicleConfiguration, axleConfiguration)
@@ -135,7 +157,7 @@ function getFeatureLegalPowerUnitWeightThreshold(vehicleType, axleConfiguration,
  * their configured legal weight lookup.
  */
 function CheckLegalWeight(policy, vehicleConfiguration, axleConfiguration) {
-    const policyId = enum_1.PolicyCheckId.CheckLegalWeight;
+    const policyId = enum_1.PolicyCheckId.LegalWeight;
     const powerUnitType = vehicleConfiguration[0];
     const axleUnitVehicleIndexes = getAxleUnitVehicleIndexLookup(policy, vehicleConfiguration, axleConfiguration);
     return axleConfiguration.map((axleUnit, axleIndex) => {
@@ -487,7 +509,7 @@ function CheckNumTiresPerAxle(_policy, _vehicleConfiguration, axleConfiguration)
  * @see SingleAxleDimension
  */
 function CheckPermittableWeight(policy, vehicleConfiguration, axleConfiguration) {
-    const policyId = enum_1.PolicyCheckId.CheckPermittableWeight;
+    const policyId = enum_1.PolicyCheckId.PermittableWeight;
     const axleUnitVehicleIndexes = getAxleUnitVehicleIndexLookup(policy, vehicleConfiguration, axleConfiguration);
     return axleConfiguration.map((axleUnit, axleIndex) => {
         const vehicleIndex = axleUnitVehicleIndexes[axleIndex];
@@ -1204,6 +1226,77 @@ function CheckDriveJeepLoadEqualization(_policy, vehicleConfiguration, axleConfi
     });
     return policyCheckResults;
 }
+function getAxleUnitType(numberOfAxles) {
+    if (numberOfAxles === 1) {
+        return 'SINGLE';
+    }
+    if (numberOfAxles === 2) {
+        return 'TANDEM';
+    }
+    return 'TRIDEM';
+}
+function getInteraxleSpacingRequirement(axleConfiguration, axleIndex) {
+    // the first axle unit will never have an interaxle spacing value or previous axle unit to compare against
+    if (axleIndex === 0) {
+        return undefined;
+    }
+    const axleUnit = axleConfiguration[axleIndex];
+    const previousAxleUnit = axleConfiguration[axleIndex - 1];
+    if (!Number.isFinite(axleUnit.interaxleSpacing) ||
+        !Number.isFinite(previousAxleUnit.numberOfAxles)) {
+        return undefined;
+    }
+    const previousAxleUnitType = getAxleUnitType(previousAxleUnit.numberOfAxles);
+    const currentAxleUnitType = getAxleUnitType(axleUnit.numberOfAxles);
+    return {
+        min: INTERAXLE_SPACING_MINIMUM_CM[previousAxleUnitType][currentAxleUnitType],
+    };
+}
+function formatMeters(cm) {
+    return (cm / 100).toFixed(2).replace(/\.0+$/u, '');
+}
+function getFailedInteraxleSpacingMessage(requirement, previousAxleUnitNumber, currentAxleUnitNumber) {
+    if (requirement.groupLabel) {
+        if (requirement.min && requirement.max) {
+            return `Interaxle Spacing for ${requirement.groupLabel} must be between ${formatMeters(requirement.min)} m and ${formatMeters(requirement.max)} m.`;
+        }
+        if (requirement.min) {
+            return `Interaxle Spacing for ${requirement.groupLabel} must be at least ${formatMeters(requirement.min)} m.`;
+        }
+    }
+    if (requirement.min) {
+        return `Interaxle Spacing between Axle Unit ${previousAxleUnitNumber} and Axle Unit ${currentAxleUnitNumber} must be at least ${formatMeters(requirement.min)} m.`;
+    }
+    return '';
+}
+/**
+ * Validates each axle unit against the minimum interaxle spacing for its
+ * current axle unit and the next axle unit, per Table II.
+ */
+function CheckLegalInteraxleSpacing(_policy, _vehicleConfiguration, axleConfiguration) {
+    const policyId = enum_1.PolicyCheckId.LegalInteraxleSpacing;
+    return axleConfiguration.map((axleUnit, axleIndex) => {
+        const requirement = getInteraxleSpacingRequirement(axleConfiguration, axleIndex);
+        // Pass when no requirement exists, interaxle spacing is missing, or interaxle spacing falls within the requirement's min/max bounds.
+        const shouldPass = !requirement ||
+            !axleUnit.interaxleSpacing ||
+            ((!requirement.min || axleUnit.interaxleSpacing >= requirement.min) &&
+                (!requirement.max || axleUnit.interaxleSpacing <= requirement.max));
+        const axleUnitNumber = axleIndex + 1;
+        const previousAxleUnitNumber = axleIndex;
+        const message = shouldPass
+            ? ''
+            : getFailedInteraxleSpacingMessage(requirement, previousAxleUnitNumber, axleUnitNumber);
+        return {
+            id: policyId,
+            message,
+            result: shouldPass
+                ? enum_1.PolicyCheckResultType.Pass
+                : enum_1.PolicyCheckResultType.Fail,
+            axleUnit: axleUnitNumber,
+        };
+    });
+}
 /**
  * Map of policy check functions keyed by their corresponding PolicyCheckId.
  *
@@ -1240,8 +1333,8 @@ exports.policyCheckMap = new Map([
         enum_1.PolicyCheckId.AxleGroupMaximumLegalWeightThreshold,
         CheckAxleGroupMaximumLegalWeightThreshold,
     ],
-    [enum_1.PolicyCheckId.CheckLegalWeight, CheckLegalWeight],
-    [enum_1.PolicyCheckId.CheckPermittableWeight, CheckPermittableWeight],
+    [enum_1.PolicyCheckId.LegalWeight, CheckLegalWeight],
+    [enum_1.PolicyCheckId.PermittableWeight, CheckPermittableWeight],
     [enum_1.PolicyCheckId.MaxTireLoad, CheckMaxTireLoad],
     [enum_1.PolicyCheckId.MinDriveAxleWeight, CheckMinDriveAxleWeight],
     [enum_1.PolicyCheckId.MinSteerAxleWeight, CheckMinSteerAxleWeight],
@@ -1251,6 +1344,7 @@ exports.policyCheckMap = new Map([
         CheckPickerTruckTractorWeightRestrictions,
     ],
     [enum_1.PolicyCheckId.NumberOfWheelsPerAxle, CheckNumTiresPerAxle],
+    [enum_1.PolicyCheckId.LegalInteraxleSpacing, CheckLegalInteraxleSpacing],
     [enum_1.PolicyCheckId.BoosterAxleLimit, CheckBoosterAxleLimit],
     [enum_1.PolicyCheckId.DriveJeepLoadEqualization, CheckDriveJeepLoadEqualization],
     [enum_1.PolicyCheckId.WheelbaseLegalLimits, CheckWheelbaseLegalLimits],

package/dist/policy-engine.js

@@ -93,7 +93,7 @@ class Policy {
             // has a no fee flag set.
             if ((_d = this.specialAuthorizations) === null || _d === void 0 ? void 0 : _d.noFeeType) {
                 const originalPermitCost = validationResults === null || validationResults === void 0 ? void 0 : validationResults.cost.reduce((accumulator, { cost }) => accumulator + (cost !== null && cost !== void 0 ? cost : 0), 0);
-                if (permit.permitType !== "STWSE") {
+                if (permit.permitType !== 'STWSE') {
                     // Clear the cost array and replace with zero cost
                     validationResults.cost.length = 0;
                     const newPermitCostResult = new validation_result_1.ValidationResult(enum_1.ValidationResultType.Cost, enum_1.ValidationResultCode.CostValue, cost_1.DEFAULT_COST_DESCRIPTION);
@@ -102,7 +102,7 @@ class Policy {
                 }
                 else {
                     // If permit type is STWSE, keep each of the cost objects, but set their costs to zero
-                    const newPermitCosts = validationResults.cost.map(cost => {
+                    const newPermitCosts = validationResults.cost.map((cost) => {
                         const newPermitCostResult = new validation_result_1.ValidationResult(enum_1.ValidationResultType.Cost, enum_1.ValidationResultCode.CostValue, cost.message);
                         newPermitCostResult.cost = 0;
                         return newPermitCostResult;

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const version = "v2.24.2";
+export declare const version = "v2.25.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.24.2';
+exports.version = 'v2.25.0';

package/package.json

@@ -91,5 +91,5 @@
     ],
     "testEnvironment": "node"
   },
-  "version": "v2.24.2"
+  "version": "v2.25.0"
 }