onroute-policy-engine 2.30.1 → 2.32.0

package/dist/constants/axle-spread-legal-limits.d.ts

@@ -10,6 +10,10 @@ export declare const AXLE_SPREAD_LEGAL_LIMITS: {
             MINIMUM: number;
             MAXIMUM: number;
         };
+        DRIVE_AXLE_WITH_SINGLE_AXLE_JEEP: {
+            MINIMUM: number;
+            MAXIMUM: number;
+        };
     };
     TRIDEM: {
         MINIMUM: number;

package/dist/constants/axle-spread-legal-limits.js

@@ -13,6 +13,10 @@ exports.AXLE_SPREAD_LEGAL_LIMITS = {
             MINIMUM: 186,
             MAXIMUM: 307,
         },
+        DRIVE_AXLE_WITH_SINGLE_AXLE_JEEP: {
+            MINIMUM: 240,
+            MAXIMUM: 370,
+        },
     },
     TRIDEM: {
         MINIMUM: 240,

package/dist/enum/facts.d.ts

@@ -17,6 +17,7 @@ export declare enum CostFacts {
     CostPerKilometre = "costPerKilometre",
     CostPerMonth = "costPerMonth",
     FixedCost = "fixedCost",
+    OverloadAxleCost = "overloadAxleCost",
     OverloadGvwCost = "overloadGvwCost",
     OverloadWeightCost = "overloadWeightCost",
     RangeMatrixCostLookup = "rangeMatrixCostLookup"

package/dist/enum/facts.js

@@ -22,6 +22,7 @@ var CostFacts;
     CostFacts["CostPerKilometre"] = "costPerKilometre";
     CostFacts["CostPerMonth"] = "costPerMonth";
     CostFacts["FixedCost"] = "fixedCost";
+    CostFacts["OverloadAxleCost"] = "overloadAxleCost";
     CostFacts["OverloadGvwCost"] = "overloadGvwCost";
     CostFacts["OverloadWeightCost"] = "overloadWeightCost";
     CostFacts["RangeMatrixCostLookup"] = "rangeMatrixCostLookup";

package/dist/helper/axle-spread.helper.d.ts

@@ -1,5 +1,5 @@
 import { AxleConfiguration } from '../types/axle-configuration';
-export declare function getTandemAxleSpreadThreshold(vehicleConfiguration: Array<string>, vehicleIndex: number): {
+export declare function getTandemAxleSpreadThreshold(vehicleConfiguration: Array<string>, vehicleIndex: number, axleConfiguration: Array<AxleConfiguration>, axleIndex: number): {
     minCm: number;
     maxCm: number;
 };

package/dist/helper/axle-spread.helper.js

@@ -7,15 +7,27 @@ const axle_spread_legal_limits_1 = require("../constants/axle-spread-legal-limit
 const power_unit_codes_1 = require("../constants/power-unit-codes");
 const semi_trailer_codes_1 = require("../constants/semi-trailer-codes");
 const trailer_codes_1 = require("../constants/trailer-codes");
-function getTandemAxleSpreadThreshold(vehicleConfiguration, vehicleIndex) {
+function getTandemAxleSpreadThreshold(vehicleConfiguration, vehicleIndex, axleConfiguration, axleIndex) {
     const vehicleType = vehicleConfiguration[vehicleIndex];
     const isSpreadTandemSemiTrailer = vehicleType === trailer_codes_1.TRAILER_CODES.SEMI_TRAILERS_SPREAD_TANDEMS;
+    const isDriveAxle = axleIndex === 1;
+    const hasSingleAxleJeep = vehicleConfiguration[1] === trailer_codes_1.TRAILER_CODES.JEEPS &&
+        axleConfiguration[2].numberOfAxles === 1;
     if (isSpreadTandemSemiTrailer) {
         return {
             minCm: axle_spread_legal_limits_1.AXLE_SPREAD_LEGAL_LIMITS.TANDEM.SPREAD_TANDEM_SEMI_TRAILER.MINIMUM,
             maxCm: axle_spread_legal_limits_1.AXLE_SPREAD_LEGAL_LIMITS.TANDEM.SPREAD_TANDEM_SEMI_TRAILER.MAXIMUM,
         };
     }
+    // Tandem Drive with Single Axle Jeep Bridge Formula Exception
+    if (isDriveAxle && hasSingleAxleJeep) {
+        return {
+            minCm: axle_spread_legal_limits_1.AXLE_SPREAD_LEGAL_LIMITS.TANDEM.DRIVE_AXLE_WITH_SINGLE_AXLE_JEEP
+                .MINIMUM,
+            maxCm: axle_spread_legal_limits_1.AXLE_SPREAD_LEGAL_LIMITS.TANDEM.DRIVE_AXLE_WITH_SINGLE_AXLE_JEEP
+                .MAXIMUM,
+        };
+    }
     return {
         minCm: axle_spread_legal_limits_1.AXLE_SPREAD_LEGAL_LIMITS.TANDEM.MINIMUM,
         maxCm: axle_spread_legal_limits_1.AXLE_SPREAD_LEGAL_LIMITS.TANDEM.MAXIMUM,
@@ -76,7 +88,7 @@ function getAxleSpreadThreshold(vehicleConfiguration, axleUnitVehicleIndexes, ax
         };
     }
     if (isTandemAxle) {
-        return getTandemAxleSpreadThreshold(vehicleConfiguration, vehicleIndex);
+        return getTandemAxleSpreadThreshold(vehicleConfiguration, vehicleIndex, axleConfiguration, axleIndex);
     }
     if (isTridemAxle) {
         return getTridemAxleSpreadThreshold(vehicleConfiguration, vehicleIndex, axleConfiguration, axleIndex);

package/dist/helper/bridge-calculation.helper.d.ts

@@ -5,9 +5,9 @@ import { Policy } from 'onroute-policy-engine';
  * Evaluates the weight against all possible axle group combinations and returns
  * the result of each group comparison, with an indicator of whether or not the
  * axle group failed the bridge calculation.
- * @param axleConfig Vehicle dimensions and weights per axle
+ * @param axleConfiguration Vehicle dimensions and weights per axle
  * @param policy Policy Enging object initialized with policy config
  * @returns Array of BridgeCalculationResult objects, one for each
  * axle group in the vehicle configuration
  */
-export declare function runBridgeFormula(axleConfig: Array<AxleConfiguration>, policy: Policy): Array<BridgeCalculationResult>;
+export declare function runBridgeFormula(policy: Policy, axleConfiguration: Array<AxleConfiguration>, vehicleConfiguration: Array<string>): Array<BridgeCalculationResult>;

package/dist/helper/bridge-calculation.helper.js

@@ -1,42 +1,44 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.runBridgeFormula = runBridgeFormula;
+const trailer_codes_1 = require("../constants/trailer-codes");
+const axle_unit_type_1 = require("../types/axle-unit-type");
 /**
  * Runs the bridge formula against the supplied vehicle axle configuration.
  * Evaluates the weight against all possible axle group combinations and returns
  * the result of each group comparison, with an indicator of whether or not the
  * axle group failed the bridge calculation.
- * @param axleConfig Vehicle dimensions and weights per axle
+ * @param axleConfiguration Vehicle dimensions and weights per axle
  * @param policy Policy Enging object initialized with policy config
  * @returns Array of BridgeCalculationResult objects, one for each
  * axle group in the vehicle configuration
  */
-function runBridgeFormula(axleConfig, policy) {
+function runBridgeFormula(policy, axleConfiguration, vehicleConfiguration) {
     const BRIDGE_MULTIPLIER = policy.policyDefinition.bridgeCalculationConstants.multiplier;
     const BRIDGE_MIN_WEIGHT = policy.policyDefinition.bridgeCalculationConstants.minWeight;
     const results = [];
     let index = 0;
-    if (!axleConfig || axleConfig.length < 2) {
+    if (!axleConfiguration || axleConfiguration.length < 2) {
         throw new Error('Invalid axle configuration, bridge formula requires a minimum of two axle units');
     }
     // Loop through each axle unit in the configuration, and
     // calculate the bridge formula for each other axle unit. The
     // number of axle groups calculated will be the Nth triangular
     // number, where N = (number of axle units) - 1.
-    axleConfig.forEach((axle) => {
+    axleConfiguration.forEach((axle) => {
         var _a;
         // Do not process once we reach the last axle unit
         // in the configuration, as they have all been calculated
         // by then.
-        if (index <= axleConfig.length) {
+        if (index <= axleConfiguration.length) {
             // Initialize the variables for our start axle
-            const firstAxle = index + 1;
-            let nextAxle = firstAxle + 1;
+            const currentAxleIdex = index + 1;
+            let nextAxleIndex = currentAxleIdex + 1;
             if (!axle.numberOfAxles || axle.numberOfAxles < 0) {
-                throw new Error(`Invalid or missing number of axles for axle unit number ${firstAxle}`);
+                throw new Error(`Invalid or missing number of axles for axle unit number ${currentAxleIdex}`);
             }
             if (!axle.axleUnitWeight || axle.axleUnitWeight < 0) {
-                throw new Error(`Invalid or missing weight for axle unit number ${firstAxle}`);
+                throw new Error(`Invalid or missing weight for axle unit number ${currentAxleIdex}`);
             }
             let totalWeight = axle.axleUnitWeight;
             // Spread may be zero or undefined if the axle unit
@@ -45,7 +47,7 @@ function runBridgeFormula(axleConfig, policy) {
             // since it describes the spacing from the previous axle
             // unit in the configuration.
             if (axle.numberOfAxles > 1 && (!axle.axleSpread || axle.axleSpread < 0)) {
-                throw new Error(`Invalid or missing axle spread for axle unit number ${firstAxle}`);
+                throw new Error(`Invalid or missing axle spread for axle unit number ${currentAxleIdex}`);
             }
             if (axle.numberOfAxles == 1 && axle.axleSpread && axle.axleSpread < 0) {
                 throw new Error(`Invalid axle spread for single axle unit, cannot be a negative number`);
@@ -53,32 +55,61 @@ function runBridgeFormula(axleConfig, policy) {
             let wheelbase = (_a = axle.axleSpread) !== null && _a !== void 0 ? _a : 0;
             // Now loop through all of the next axles, building up a group
             // for each.
-            axleConfig.slice(firstAxle).forEach((axleN) => {
-                var _a;
+            axleConfiguration.slice(currentAxleIdex).forEach((axleN) => {
+                var _a, _b, _c, _d;
+                var _e, _f, _g;
                 if (!axleN.axleUnitWeight || axleN.axleUnitWeight < 0) {
-                    throw new Error(`Invalid or missing weight for axle unit number ${nextAxle}`);
+                    throw new Error(`Invalid or missing weight for axle unit number ${nextAxleIndex}`);
                 }
                 totalWeight += axleN.axleUnitWeight;
                 if (axleN.numberOfAxles > 1 &&
                     (!axleN.axleSpread || axleN.axleSpread < 0)) {
-                    throw new Error(`Invalid or missing axle spread for axle unit number ${nextAxle}`);
+                    throw new Error(`Invalid or missing axle spread for axle unit number ${nextAxleIndex}`);
                 }
                 if (!axleN.interaxleSpacing || axleN.interaxleSpacing < 0) {
-                    throw new Error(`Invalid or missing axle spacing between axle units ${firstAxle} and ${nextAxle}`);
+                    throw new Error(`Invalid or missing axle spacing between axle units ${currentAxleIdex} and ${nextAxleIndex}`);
+                }
+                wheelbase += ((_e = axleN.axleSpread) !== null && _e !== void 0 ? _e : 0) + axleN.interaxleSpacing;
+                // Tandem Drive with Single Axle Jeep Bridge Formula Exception
+                const hasSingleAxleJeep = vehicleConfiguration[1] === trailer_codes_1.TRAILER_CODES.JEEPS &&
+                    (0, axle_unit_type_1.getAxleUnitType)((_a = axleConfiguration[2]) === null || _a === void 0 ? void 0 : _a.numberOfAxles) === 'SINGLE';
+                const hasTandemDrive = (0, axle_unit_type_1.getAxleUnitType)((_b = axleConfiguration[1]) === null || _b === void 0 ? void 0 : _b.numberOfAxles) === 'TANDEM';
+                const driveAxleSpread = (_f = (_c = axleConfiguration[1]) === null || _c === void 0 ? void 0 : _c.axleSpread) !== null && _f !== void 0 ? _f : 0;
+                const isDriveAxle = currentAxleIdex === 1;
+                const isJeepAxle = hasSingleAxleJeep && currentAxleIdex === 2;
+                const firstTrailerInteraxleSpacing = (_g = (_d = axleConfiguration[2]) === null || _d === void 0 ? void 0 : _d.interaxleSpacing) !== null && _g !== void 0 ? _g : 0;
+                const isTandemDriveSingleAxleJeepException = (isDriveAxle || isJeepAxle) && hasTandemDrive && hasSingleAxleJeep;
+                const isLowerTandemDriveSingleAxleJeepException = isTandemDriveSingleAxleJeepException &&
+                    driveAxleSpread >= 240 &&
+                    driveAxleSpread <= 300 &&
+                    firstTrailerInteraxleSpacing >= 120 &&
+                    firstTrailerInteraxleSpacing <= 300;
+                const isUpperTandemDriveSingleAxleJeepException = isTandemDriveSingleAxleJeepException &&
+                    driveAxleSpread > 300 &&
+                    driveAxleSpread <= 370 &&
+                    firstTrailerInteraxleSpacing > 300 &&
+                    firstTrailerInteraxleSpacing <= 350;
+                // Calculate standard bridge formula result
+                const formulaMaxBridge = BRIDGE_MULTIPLIER * wheelbase + BRIDGE_MIN_WEIGHT;
+                // Apply the Tandem Drive + Single Axle Jeep policy exception only when
+                // it increases the permitted weight (i.e. it's an allowance override).
+                let maxBridge = formulaMaxBridge;
+                if (isLowerTandemDriveSingleAxleJeepException) {
+                    maxBridge = Math.max(formulaMaxBridge, 28000);
+                }
+                else if (isUpperTandemDriveSingleAxleJeepException) {
+                    maxBridge = Math.max(formulaMaxBridge, 29000);
                 }
-                wheelbase += ((_a = axleN.axleSpread) !== null && _a !== void 0 ? _a : 0) + axleN.interaxleSpacing;
-                // The magic is in the next line
-                const maxBridge = BRIDGE_MULTIPLIER * wheelbase + BRIDGE_MIN_WEIGHT;
                 // Push the axle group result to the results array, including
                 // a convenience success indicator.
                 results.push({
-                    startAxleUnit: firstAxle,
-                    endAxleUnit: nextAxle,
+                    startAxleUnit: currentAxleIdex,
+                    endAxleUnit: nextAxleIndex,
                     maxBridge: maxBridge,
                     actualWeight: totalWeight,
                     success: totalWeight <= maxBridge,
                 });
-                nextAxle++;
+                nextAxleIndex++;
             });
         }
         index++;

package/dist/helper/dimensions.helper.d.ts

@@ -114,3 +114,8 @@ export declare function getVehicleRelatives(policy: Policy, configuration: Array
  * // Returns [0, 0, 1, 1]
  */
 export declare function getAxleUnitVehicleIndexes(policy: Policy, configuration: Array<string>, axleConfiguration: Array<AxleConfiguration>): Array<number>;
+/**
+ * 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.
+ */
+export declare function getAxleUnitVehicleIndexLookup(policy: Policy, vehicleConfiguration: Array<string>, axleConfiguration: Array<AxleConfiguration>): Array<number>;

package/dist/helper/dimensions.helper.js

@@ -7,6 +7,7 @@ exports.getDefaultTrailerWeightHelper = getDefaultTrailerWeightHelper;
 exports.selectCorrectWeightDimensionHelper = selectCorrectWeightDimensionHelper;
 exports.getVehicleRelatives = getVehicleRelatives;
 exports.getAxleUnitVehicleIndexes = getAxleUnitVehicleIndexes;
+exports.getAxleUnitVehicleIndexLookup = getAxleUnitVehicleIndexLookup;
 const enum_1 = require("onroute-policy-engine/enum");
 /**
  * Gets the maximum size dimensions for a given permit type, commodity,
@@ -554,6 +555,15 @@ function getAxleUnitVehicleIndexes(policy, configuration, axleConfiguration) {
     }
     return axleUnitVehicleIndexes;
 }
+/**
+ * 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)
+        ? getAxleUnitVehicleIndexes(policy, vehicleConfiguration, axleConfiguration)
+        : axleConfiguration.map((_, axleIndex) => axleIndex < 2 ? 0 : axleIndex - 1);
+}
 /**
  * Walks along the vehicle configuration from the start index
  * in the direction indicated by increment, which will typically

package/dist/helper/facts.helper.js

@@ -339,6 +339,17 @@ function addRuntimeFacts(engine, policy) {
         }
         return getOverloadCost(overloadKg, distance);
     });
+    /**
+     * Calculate the STOW fee from the same selected overload used by OCD.
+     */
+    engine.addFact(enum_1.CostFacts.OverloadAxleCost.toString(), async function (params, almanac) {
+        const axleResults = await almanac.factValue(stgvwi_1.AXLE_CALC_RESULTS_FACT);
+        const totalDistance = await almanac.factValue(enum_1.PermitAppInfo.PermitData, {}, enum_1.PermitAppInfo.TotalDistance);
+        if (!totalDistance) {
+            return 0;
+        }
+        return getOverloadCost(axleResults.overload, totalDistance);
+    });
     /**
      * Add runtime fact to calculate the overload fee for STWSE permits
      * based on the Weight over 27.5m and Total Distance.

package/dist/helper/interaxle-spacing.helper.d.ts

@@ -1,6 +1,4 @@
-import { INTERAXLE_SPACING_LEGAL_MINIMUMS } from '../constants/interaxle-spacing-legal-minimums';
 import { AxleConfiguration } from '../types/axle-configuration';
 import { InteraxleSpacingRequirement } from '../types/interaxle-spacing-requirement';
-export declare function getAxleUnitType(numberOfAxles: number): keyof typeof INTERAXLE_SPACING_LEGAL_MINIMUMS;
 export declare function getFailedInteraxleSpacingMessage(requirement: InteraxleSpacingRequirement, previousAxleUnitNumber: number, currentAxleUnitNumber: number): string;
-export declare function getInteraxleSpacingRequirement(axleConfiguration: Array<AxleConfiguration>, axleIndex: number): InteraxleSpacingRequirement | undefined;
+export declare function getInteraxleSpacingRequirement(axleConfiguration: Array<AxleConfiguration>, axleIndex: number, vehicleConfiguration: Array<string>, axleUnitVehicleIndexes: Array<number>): InteraxleSpacingRequirement | undefined;

package/dist/helper/interaxle-spacing.helper.js

@@ -1,19 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getAxleUnitType = getAxleUnitType;
 exports.getFailedInteraxleSpacingMessage = getFailedInteraxleSpacingMessage;
 exports.getInteraxleSpacingRequirement = getInteraxleSpacingRequirement;
 const interaxle_spacing_legal_minimums_1 = require("../constants/interaxle-spacing-legal-minimums");
+const trailer_codes_1 = require("../constants/trailer-codes");
+const axle_unit_type_1 = require("../types/axle-unit-type");
 const format_meters_helper_1 = require("./format-meters.helper");
-function getAxleUnitType(numberOfAxles) {
-    if (numberOfAxles === 1) {
-        return 'SINGLE';
-    }
-    if (numberOfAxles === 2) {
-        return 'TANDEM';
-    }
-    return 'TRIDEM';
-}
 function getFailedInteraxleSpacingMessage(requirement, previousAxleUnitNumber, currentAxleUnitNumber) {
     if (requirement.groupLabel) {
         if (requirement.min && requirement.max) {
@@ -31,7 +23,7 @@ function getFailedInteraxleSpacingMessage(requirement, previousAxleUnitNumber, c
     }
     return '';
 }
-function getInteraxleSpacingRequirement(axleConfiguration, axleIndex) {
+function getInteraxleSpacingRequirement(axleConfiguration, axleIndex, vehicleConfiguration, axleUnitVehicleIndexes) {
     // the first axle unit will never have an interaxle spacing value or previous axle unit to compare against
     if (axleIndex === 0) {
         return undefined;
@@ -42,8 +34,20 @@ function getInteraxleSpacingRequirement(axleConfiguration, axleIndex) {
         !Number.isFinite(previousAxleUnit.numberOfAxles)) {
         return undefined;
     }
-    const previousAxleUnitType = getAxleUnitType(previousAxleUnit.numberOfAxles);
-    const currentAxleUnitType = getAxleUnitType(axleUnit.numberOfAxles);
+    const previousAxleUnitType = (0, axle_unit_type_1.getAxleUnitType)(previousAxleUnit.numberOfAxles);
+    const currentAxleUnitType = (0, axle_unit_type_1.getAxleUnitType)(axleUnit.numberOfAxles);
+    const vehicleIndex = axleUnitVehicleIndexes[axleIndex];
+    const vehicleType = vehicleConfiguration[vehicleIndex];
+    const isSingleAxleJeep = vehicleType === trailer_codes_1.TRAILER_CODES.JEEPS &&
+        (0, axle_unit_type_1.getAxleUnitType)(axleConfiguration[2].numberOfAxles) === 'SINGLE';
+    const isTandemDrive = (0, axle_unit_type_1.getAxleUnitType)(axleConfiguration[1].numberOfAxles) === 'TANDEM';
+    // Tandem Drive with Single Axle Jeep Bridge Formula Exception
+    if (isSingleAxleJeep && isTandemDrive) {
+        return {
+            min: 120,
+            max: 350,
+        };
+    }
     return {
         min: interaxle_spacing_legal_minimums_1.INTERAXLE_SPACING_LEGAL_MINIMUMS[previousAxleUnitType][currentAxleUnitType],
     };

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

@@ -68,7 +68,7 @@ export declare function CheckNumberOfAxles(_policy: Policy, _vehicleConfiguratio
  * @see AxleGroupPolicyCheckResult
  * @see BridgeCalculationResult
  */
-export declare function CheckBridgeFormula(policy: Policy, _vehicleConfiguration: Array<string>, axleConfiguration: Array<AxleConfiguration>): Array<PolicyCheckResult>;
+export declare function CheckBridgeFormula(policy: Policy, vehicleConfiguration: Array<string>, axleConfiguration: Array<AxleConfiguration>): Array<PolicyCheckResult>;
 /**
  * Validates the number of tires per axle unit against regulatory requirements.
  *
@@ -302,7 +302,7 @@ export declare function CheckDriveJeepLoadEqualization(_policy: Policy, vehicleC
  * 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>;
+export declare function CheckLegalInteraxleSpacing(policy: Policy, vehicleConfiguration: Array<string>, axleConfiguration: Array<AxleConfiguration>): Array<PolicyCheckResult>;
 /**
  * Validates each axle unit against its legal axle spread maximum.
  */

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

@@ -53,15 +53,6 @@ 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)
-        : axleConfiguration.map((_, axleIndex) => axleIndex < 2 ? 0 : axleIndex - 1);
-}
 function getConfiguredAxleUnitWeightThreshold(policy, vehicleConfiguration, axleConfiguration, axleUnitVehicleIndexes, axleIndex, threshold) {
     var _a;
     var _b;
@@ -131,7 +122,7 @@ function getFeatureLegalPowerUnitWeightThreshold(vehicleType, axleConfiguration,
 function CheckLegalWeight(policy, vehicleConfiguration, axleConfiguration) {
     const policyId = enum_1.PolicyCheckId.LegalWeight;
     const powerUnitType = vehicleConfiguration[0];
-    const axleUnitVehicleIndexes = getAxleUnitVehicleIndexLookup(policy, vehicleConfiguration, axleConfiguration);
+    const axleUnitVehicleIndexes = (0, dimensions_helper_1.getAxleUnitVehicleIndexLookup)(policy, vehicleConfiguration, axleConfiguration);
     return axleConfiguration.map((axleUnit, axleIndex) => {
         const featureThreshold = axleUnitVehicleIndexes[axleIndex] === 0 &&
             isFeatureLegalWeightPowerUnit(powerUnitType)
@@ -342,14 +333,14 @@ function getBridgeFormulaInputFailure(axleConfiguration) {
  * @see AxleGroupPolicyCheckResult
  * @see BridgeCalculationResult
  */
-function CheckBridgeFormula(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);
+    const bridgeCalcResults = policy.calculateBridge(axleConfiguration, vehicleConfiguration);
     bridgeCalcResults.forEach((br) => {
         const message = `Axle group ${br.startAxleUnit} to ${br.endAxleUnit} ${br.success ? 'passes' : 'does not pass'} bridge formula.`;
         policyCheckResults.push({
@@ -487,7 +478,7 @@ function CheckNumTiresPerAxle(_policy, _vehicleConfiguration, axleConfiguration)
  */
 function CheckPermittableWeight(policy, vehicleConfiguration, axleConfiguration) {
     const policyId = enum_1.PolicyCheckId.PermittableWeight;
-    const axleUnitVehicleIndexes = getAxleUnitVehicleIndexLookup(policy, vehicleConfiguration, axleConfiguration);
+    const axleUnitVehicleIndexes = (0, dimensions_helper_1.getAxleUnitVehicleIndexLookup)(policy, vehicleConfiguration, axleConfiguration);
     const QUALIFYING_TRIDEM_SPREAD_CM = {
         MINIMUM: 240,
         MAXIMUM: 370,
@@ -1227,10 +1218,11 @@ function CheckDriveJeepLoadEqualization(_policy, vehicleConfiguration, axleConfi
  * 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) {
+function CheckLegalInteraxleSpacing(policy, vehicleConfiguration, axleConfiguration) {
     const policyId = enum_1.PolicyCheckId.LegalInteraxleSpacing;
+    const axleUnitVehicleIndexes = (0, dimensions_helper_1.getAxleUnitVehicleIndexLookup)(policy, vehicleConfiguration, axleConfiguration);
     return axleConfiguration.map((axleUnit, axleIndex) => {
-        const requirement = (0, interaxle_spacing_helper_1.getInteraxleSpacingRequirement)(axleConfiguration, axleIndex);
+        const requirement = (0, interaxle_spacing_helper_1.getInteraxleSpacingRequirement)(axleConfiguration, axleIndex, vehicleConfiguration, axleUnitVehicleIndexes);
         // 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 ||
@@ -1256,7 +1248,7 @@ function CheckLegalInteraxleSpacing(_policy, _vehicleConfiguration, axleConfigur
  */
 function CheckLegalAxleSpread(policy, vehicleConfiguration, axleConfiguration) {
     const policyId = enum_1.PolicyCheckId.LegalAxleSpread;
-    const axleUnitVehicleIndexes = getAxleUnitVehicleIndexLookup(policy, vehicleConfiguration, axleConfiguration);
+    const axleUnitVehicleIndexes = (0, dimensions_helper_1.getAxleUnitVehicleIndexLookup)(policy, vehicleConfiguration, axleConfiguration);
     return axleConfiguration.flatMap((axleUnit, axleIndex) => {
         const threshold = (0, axle_spread_helper_1.getAxleSpreadThreshold)(vehicleConfiguration, axleUnitVehicleIndexes, axleConfiguration, axleIndex);
         if (!axleUnit.axleSpread ||

package/dist/policy-engine.d.ts

@@ -181,11 +181,11 @@ export declare class Policy {
     /**
      * Convenience method of policy that delegates the bridge calculation
      * to the helper method.
-     * @param axleConfig Vehicle dimensions and weights per axle
+     * @param axleConfiguration Vehicle dimensions and weights per axle
      * @returns Array of BridgeCalculationResult objects, one for each
      * axle group in the vehicle configuration
      */
-    calculateBridge(axleConfig: Array<AxleConfiguration>): Array<BridgeCalculationResult>;
+    calculateBridge(axleConfiguration: Array<AxleConfiguration>, vehicleConfiguration: Array<string>): Array<BridgeCalculationResult>;
     /**
      * Runs all configured axle calculation policy checks against a vehicle configuration.
      *

package/dist/policy-engine.js

@@ -667,14 +667,14 @@ class Policy {
     /**
      * Convenience method of policy that delegates the bridge calculation
      * to the helper method.
-     * @param axleConfig Vehicle dimensions and weights per axle
+     * @param axleConfiguration Vehicle dimensions and weights per axle
      * @returns Array of BridgeCalculationResult objects, one for each
      * axle group in the vehicle configuration
      */
-    calculateBridge(axleConfig) {
+    calculateBridge(axleConfiguration, vehicleConfiguration) {
         let bridgeResults;
         try {
-            bridgeResults = (0, bridge_calculation_helper_1.runBridgeFormula)(axleConfig, this);
+            bridgeResults = (0, bridge_calculation_helper_1.runBridgeFormula)(this, axleConfiguration, vehicleConfiguration);
         }
         catch (e) {
             console.log(`Error calculating bridge formula: ${e.message}`);

package/dist/types/axle-unit-type.d.ts

@@ -4,3 +4,4 @@ export declare const AXLE_UNIT_TYPES: {
     readonly TRIDEM: 'TRIDEM';
 };
 export type AxleUnitType = (typeof AXLE_UNIT_TYPES)[keyof typeof AXLE_UNIT_TYPES];
+export declare function getAxleUnitType(numberOfAxles: number): AxleUnitType;

package/dist/types/axle-unit-type.js

@@ -1,8 +1,18 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AXLE_UNIT_TYPES = void 0;
+exports.getAxleUnitType = getAxleUnitType;
 exports.AXLE_UNIT_TYPES = {
     SINGLE: 'SINGLE',
     TANDEM: 'TANDEM',
     TRIDEM: 'TRIDEM',
 };
+function getAxleUnitType(numberOfAxles) {
+    if (numberOfAxles === 1) {
+        return 'SINGLE';
+    }
+    if (numberOfAxles === 2) {
+        return 'TANDEM';
+    }
+    return 'TRIDEM';
+}

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const version = "v2.30.1";
+export declare const version = "v2.32.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.30.1';
+exports.version = 'v2.32.0';

package/package.json

@@ -91,5 +91,5 @@
     ],
     "testEnvironment": "node"
   },
-  "version": "v2.30.1"
+  "version": "v2.32.0"
 }