onroute-policy-engine 2.26.0 → 2.27.0

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

@@ -0,0 +1,30 @@
+export declare const AXLE_SPREAD_LEGAL_LIMITS: {
+    SINGLE: {
+        MINIMUM: number;
+        MAXIMUM: number;
+    };
+    TANDEM: {
+        MINIMUM: number;
+        MAXIMUM: number;
+        SPREAD_TANDEM_SEMI_TRAILER: {
+            MINIMUM: number;
+            MAXIMUM: number;
+        };
+    };
+    TRIDEM: {
+        MINIMUM: number;
+        MAXIMUM: number;
+        PONY_TRAILER: {
+            MAXIMUM: number;
+        };
+        SEMI_TRAILER: {
+            MAXIMUM: number;
+        };
+        POLE_TRAILER: {
+            MAXIMUM: number;
+        };
+        OILFIELD_BED_TRUCK: {
+            MAXIMUM: number;
+        };
+    };
+};

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

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AXLE_SPREAD_LEGAL_LIMITS = void 0;
+exports.AXLE_SPREAD_LEGAL_LIMITS = {
+    SINGLE: {
+        MINIMUM: 0,
+        MAXIMUM: 100,
+    },
+    TANDEM: {
+        MINIMUM: 100,
+        MAXIMUM: 185,
+        SPREAD_TANDEM_SEMI_TRAILER: {
+            MINIMUM: 186,
+            MAXIMUM: 307,
+        },
+    },
+    TRIDEM: {
+        MINIMUM: 240,
+        MAXIMUM: 280,
+        PONY_TRAILER: {
+            MAXIMUM: 250,
+        },
+        SEMI_TRAILER: {
+            MAXIMUM: 370,
+        },
+        POLE_TRAILER: {
+            MAXIMUM: 310,
+        },
+        OILFIELD_BED_TRUCK: {
+            MAXIMUM: 310,
+        },
+    },
+};

package/dist/constants/axle-weight-legal-maximums.d.ts

@@ -0,0 +1,9 @@
+export declare const AXLE_WEIGHT_LEGAL_MAXIMUMS: {
+    SINGLE_AXLE: number;
+    STANDARD_TRUCK_TRACTOR_STEER: number;
+    STANDARD_SINGLE_STEER_WITH_TRIDEM_DRIVE: number;
+    TANDEM_AXLE: number;
+    STANDARD_TANDEM_STEER_WITH_TRIDEM_DRIVE: number;
+    PME_TANDEM_STEER_WITH_TRIDEM_DRIVE: number;
+    TRIDEM_AXLE: number;
+};

package/dist/constants/axle-weight-legal-maximums.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AXLE_WEIGHT_LEGAL_MAXIMUMS = void 0;
+exports.AXLE_WEIGHT_LEGAL_MAXIMUMS = {
+    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,
+};

package/dist/constants/axle-weight-permittable-maximums.d.ts

@@ -0,0 +1,7 @@
+export declare const AXLE_WEIGHT_PERMITTABLE_MAXIMUMS: {
+    SINGLE_STEER: number;
+    SINGLE_NON_STEER: number;
+    TANDEM: number;
+    STANDARD_TRIDEM: number;
+    QUALIFYING_TRIDEM: number;
+};

package/dist/constants/axle-weight-permittable-maximums.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AXLE_WEIGHT_PERMITTABLE_MAXIMUMS = void 0;
+exports.AXLE_WEIGHT_PERMITTABLE_MAXIMUMS = {
+    SINGLE_STEER: 9100,
+    SINGLE_NON_STEER: 11000,
+    TANDEM: 23000,
+    STANDARD_TRIDEM: 28000,
+    QUALIFYING_TRIDEM: 29000,
+};

package/dist/constants/interaxle-spacing-legal-minimums.d.ts

@@ -0,0 +1,17 @@
+export declare const INTERAXLE_SPACING_LEGAL_MINIMUMS: {
+    readonly SINGLE: {
+        readonly SINGLE: 300;
+        readonly TANDEM: 300;
+        readonly TRIDEM: 300;
+    };
+    readonly TANDEM: {
+        readonly SINGLE: 300;
+        readonly TANDEM: 500;
+        readonly TRIDEM: 550;
+    };
+    readonly TRIDEM: {
+        readonly SINGLE: 300;
+        readonly TANDEM: 550;
+        readonly TRIDEM: 600;
+    };
+};

package/dist/constants/interaxle-spacing-legal-minimums.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.INTERAXLE_SPACING_LEGAL_MINIMUMS = void 0;
+exports.INTERAXLE_SPACING_LEGAL_MINIMUMS = {
+    SINGLE: {
+        SINGLE: 300,
+        TANDEM: 300,
+        TRIDEM: 300,
+    },
+    TANDEM: {
+        SINGLE: 300,
+        TANDEM: 500,
+        TRIDEM: 550,
+    },
+    TRIDEM: {
+        SINGLE: 300,
+        TANDEM: 550,
+        TRIDEM: 600,
+    },
+};

package/dist/constants/power-unit-axle-code-multiplier.d.ts

@@ -0,0 +1 @@
+export declare const POWER_UNIT_AXLE_CODE_MULTIPLIER = 10;

package/dist/constants/power-unit-axle-code-multiplier.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.POWER_UNIT_AXLE_CODE_MULTIPLIER = void 0;
+exports.POWER_UNIT_AXLE_CODE_MULTIPLIER = 10;

package/dist/constants/semi-trailer-types.d.ts

@@ -0,0 +1,2 @@
+export declare const SEMI_TRAILER_TYPES: Set<string>;
+export declare function isSemiTrailerType(vehicleType: string): boolean;

package/dist/constants/semi-trailer-types.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SEMI_TRAILER_TYPES = void 0;
+exports.isSemiTrailerType = isSemiTrailerType;
+exports.SEMI_TRAILER_TYPES = new Set([
+    // Expando Semi-Trailers
+    'EXPANDO',
+    // Fixed Equipment - Conveyors
+    'FECVYRX',
+    // Fixed Equipment - Counter Flow Asphalt Drum Mixers
+    'FEDRMMX',
+    // Fixed Equipment - Portable Asphalt Baghouses
+    'FEBGHSE',
+    // Fixed Equipment - Semi-Trailers
+    'FESEMTR',
+    // Fixed Equipment - Wheeler Semi-Trailers
+    'FEWHELR',
+    // Semi-Trailers - Hiboys/Expandos
+    'HIBOEXP',
+    // Semi-Trailers - Hiboys/Flat Decks
+    'HIBOFLT',
+    // Oil and Gas - Oversize Oilfield Flat Deck Semi-Trailers
+    'OGOSFDT',
+    // Platform Trailer
+    'PLATFRM',
+    // Platform Trailers - Wheelers
+    'PLATWHE',
+    // Pole Trailers
+    'POLETRL',
+    // Ready Mix Concrete Pump Semi-Trailers
+    'REDIMIX',
+    // Semi-Trailers
+    'SEMITRL',
+    // Semi-Trailers - Single Drop, Double Drop, Step Decks, Lowbed, Expandos, etc.
+    'STSDBDK',
+    // Semi-Trailers with Crane
+    'STCRANE',
+    // Semi-Trailers - Spread Tandem
+    'STWDTAN',
+    // Semi-Trailers - Wheelers
+    'STWHELR',
+    // Semi-Trailers - Wide Wheelers
+    'STWIDWH',
+]);
+function isSemiTrailerType(vehicleType) {
+    return exports.SEMI_TRAILER_TYPES.has(vehicleType);
+}

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

@@ -8,6 +8,7 @@ export declare enum PolicyCheckId {
     BoosterAxleLimit = "booster-axle-limit",
     BridgeFormula = "bridge-formula",
     DriveJeepLoadEqualization = "drive-jeep-load-equalization",
+    LegalAxleSpread = "legal-axle-spread",
     LegalInteraxleSpacing = "legal-interaxle-spacing",
     LegalWeight = "legal-weight",
     MaxTireLoad = "max-tire-load",

package/dist/enum/policy-check.js

@@ -13,6 +13,7 @@ var PolicyCheckId;
     PolicyCheckId["BoosterAxleLimit"] = "booster-axle-limit";
     PolicyCheckId["BridgeFormula"] = "bridge-formula";
     PolicyCheckId["DriveJeepLoadEqualization"] = "drive-jeep-load-equalization";
+    PolicyCheckId["LegalAxleSpread"] = "legal-axle-spread";
     PolicyCheckId["LegalInteraxleSpacing"] = "legal-interaxle-spacing";
     PolicyCheckId["LegalWeight"] = "legal-weight";
     PolicyCheckId["MaxTireLoad"] = "max-tire-load";

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

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

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

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTandemAxleSpreadThreshold = getTandemAxleSpreadThreshold;
+exports.getTridemAxleSpreadThreshold = getTridemAxleSpreadThreshold;
+exports.getAxleSpreadThreshold = getAxleSpreadThreshold;
+const axle_spread_legal_limits_1 = require("../constants/axle-spread-legal-limits");
+const semi_trailer_types_1 = require("../constants/semi-trailer-types");
+function getTandemAxleSpreadThreshold(vehicleConfiguration, vehicleIndex) {
+    const vehicleType = vehicleConfiguration[vehicleIndex];
+    const isSpreadTandemSemiTrailer = vehicleType === 'STWDTAN';
+    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,
+        };
+    }
+    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,
+    };
+}
+function getTridemAxleSpreadThreshold(vehicleConfiguration, vehicleIndex, axleConfiguration, axleIndex) {
+    const vehicleType = vehicleConfiguration[vehicleIndex];
+    const isDriveAxle = axleIndex === 1;
+    const isTridemDrive = axleConfiguration[1].numberOfAxles === 3;
+    const isPonyTrailer = vehicleType === 'PONYTRL';
+    const isPoleTrailer = vehicleType === 'POLETRL';
+    const isOilfieldBedTruck = vehicleType === 'OGBEDTK';
+    const isPowerUnitTruckTractor = vehicleConfiguration[0] === 'TRKTRAC';
+    if (isOilfieldBedTruck && isDriveAxle) {
+        return {
+            minCm: axle_spread_legal_limits_1.AXLE_SPREAD_LEGAL_LIMITS.TRIDEM.MINIMUM,
+            maxCm: axle_spread_legal_limits_1.AXLE_SPREAD_LEGAL_LIMITS.TRIDEM.OILFIELD_BED_TRUCK.MAXIMUM,
+        };
+    }
+    if (isPonyTrailer) {
+        return {
+            minCm: axle_spread_legal_limits_1.AXLE_SPREAD_LEGAL_LIMITS.TRIDEM.MINIMUM,
+            maxCm: axle_spread_legal_limits_1.AXLE_SPREAD_LEGAL_LIMITS.TRIDEM.PONY_TRAILER.MAXIMUM,
+        };
+    }
+    if (isPowerUnitTruckTractor && (0, semi_trailer_types_1.isSemiTrailerType)(vehicleType)) {
+        return {
+            minCm: axle_spread_legal_limits_1.AXLE_SPREAD_LEGAL_LIMITS.TRIDEM.MINIMUM,
+            maxCm: axle_spread_legal_limits_1.AXLE_SPREAD_LEGAL_LIMITS.TRIDEM.SEMI_TRAILER.MAXIMUM,
+        };
+    }
+    if (isPowerUnitTruckTractor && isTridemDrive && isPoleTrailer) {
+        return {
+            minCm: axle_spread_legal_limits_1.AXLE_SPREAD_LEGAL_LIMITS.TRIDEM.MINIMUM,
+            maxCm: axle_spread_legal_limits_1.AXLE_SPREAD_LEGAL_LIMITS.TRIDEM.POLE_TRAILER.MAXIMUM,
+        };
+    }
+    return {
+        minCm: axle_spread_legal_limits_1.AXLE_SPREAD_LEGAL_LIMITS.TRIDEM.MINIMUM,
+        maxCm: axle_spread_legal_limits_1.AXLE_SPREAD_LEGAL_LIMITS.TRIDEM.MAXIMUM,
+    };
+}
+function getAxleSpreadThreshold(vehicleConfiguration, axleUnitVehicleIndexes, axleConfiguration, axleIndex) {
+    const axleUnit = axleConfiguration[axleIndex];
+    if (!Number.isFinite(axleUnit.axleSpread)) {
+        return undefined;
+    }
+    const vehicleIndex = axleUnitVehicleIndexes[axleIndex];
+    const numberOfAxles = axleUnit.numberOfAxles;
+    const isSingleAxle = numberOfAxles === 1;
+    const isTandemAxle = numberOfAxles === 2;
+    const isTridemAxle = numberOfAxles === 3;
+    if (isSingleAxle) {
+        // the ASW table specifically disables the axleSpread input for single axle unit types, so this code will never run, but have left these in place in case something changes
+        return {
+            minCm: axle_spread_legal_limits_1.AXLE_SPREAD_LEGAL_LIMITS.SINGLE.MINIMUM,
+            maxCm: axle_spread_legal_limits_1.AXLE_SPREAD_LEGAL_LIMITS.SINGLE.MAXIMUM,
+        };
+    }
+    if (isTandemAxle) {
+        return getTandemAxleSpreadThreshold(vehicleConfiguration, vehicleIndex);
+    }
+    if (isTridemAxle) {
+        return getTridemAxleSpreadThreshold(vehicleConfiguration, vehicleIndex, axleConfiguration, axleIndex);
+    }
+    return undefined;
+}

package/dist/helper/format-meters.helper.d.ts

@@ -0,0 +1 @@
+export declare function formatMeters(cm: number): string;

package/dist/helper/format-meters.helper.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatMeters = formatMeters;
+function formatMeters(cm) {
+    return (cm / 100).toFixed(2).replace(/(\.\d)0$/u, '$1');
+}

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

@@ -0,0 +1,6 @@
+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;

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

@@ -0,0 +1,50 @@
+"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 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) {
+            return `Interaxle Spacing for ${requirement.groupLabel} must be between ${(0, format_meters_helper_1.formatMeters)(requirement.min)} m and ${(0, format_meters_helper_1.formatMeters)(requirement.max)} m.`;
+        }
+        if (requirement.min) {
+            return `Interaxle Spacing for ${requirement.groupLabel} must be at least ${(0, format_meters_helper_1.formatMeters)(requirement.min)} m.`;
+        }
+    }
+    if (requirement.min && requirement.max) {
+        return `Interaxle Spacing between Axle Unit ${previousAxleUnitNumber} and Axle Unit ${currentAxleUnitNumber} must be between ${(0, format_meters_helper_1.formatMeters)(requirement.min)} m and ${(0, format_meters_helper_1.formatMeters)(requirement.max)} m.`;
+    }
+    if (requirement.min) {
+        return `Interaxle Spacing between Axle Unit ${previousAxleUnitNumber} and Axle Unit ${currentAxleUnitNumber} must be at least ${(0, format_meters_helper_1.formatMeters)(requirement.min)} m.`;
+    }
+    return '';
+}
+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_legal_minimums_1.INTERAXLE_SPACING_LEGAL_MINIMUMS[previousAxleUnitType][currentAxleUnitType],
+    };
+}

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

@@ -283,7 +283,7 @@ export declare function CheckBoosterAxleLimit(_policy: Policy, vehicleConfigurat
 /**
  * Validates wheelbase legal limits for supported power unit vehicle sub-types.
  */
-export declare function CheckWheelbaseLegalLimits(policy: Policy, vehicleConfiguration: Array<string>, axleConfiguration: Array<AxleConfiguration>): Array<PolicyCheckResult>;
+export declare function CheckWheelbaseLegalLimits(_policy: Policy, vehicleConfiguration: Array<string>, axleConfiguration: Array<AxleConfiguration>): Array<PolicyCheckResult>;
 /**
  * Validates that the drive axle unit and first jeep axle unit are load equalized
  * within 1000 kg when they have the same number of axles.
@@ -303,6 +303,10 @@ export declare function CheckDriveJeepLoadEqualization(_policy: Policy, vehicleC
  * 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>;
+/**
+ * Validates each axle unit against its legal axle spread maximum.
+ */
+export declare function CheckLegalAxleSpread(policy: Policy, vehicleConfiguration: Array<string>, axleConfiguration: Array<AxleConfiguration>): Array<PolicyCheckResult>;
 /**
  * Map of policy check functions keyed by their corresponding PolicyCheckId.
  *
@@ -315,6 +319,7 @@ export declare function CheckLegalInteraxleSpacing(_policy: Policy, _vehicleConf
  * - 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
+ * - CheckLegalAxleSpread: Validates axle units against legal axle spread 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

@@ -17,47 +17,17 @@ exports.CheckBoosterAxleLimit = CheckBoosterAxleLimit;
 exports.CheckWheelbaseLegalLimits = CheckWheelbaseLegalLimits;
 exports.CheckDriveJeepLoadEqualization = CheckDriveJeepLoadEqualization;
 exports.CheckLegalInteraxleSpacing = CheckLegalInteraxleSpacing;
+exports.CheckLegalAxleSpread = CheckLegalAxleSpread;
 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,
-};
-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,
-    },
-};
+const axle_weight_legal_maximums_1 = require("../constants/axle-weight-legal-maximums");
+const axle_weight_permittable_maximums_1 = require("../constants/axle-weight-permittable-maximums");
+const power_unit_axle_code_multiplier_1 = require("../constants/power-unit-axle-code-multiplier");
+const axle_spread_helper_1 = require("./axle-spread.helper");
+const semi_trailer_types_1 = require("../constants/semi-trailer-types");
+const interaxle_spacing_helper_1 = require("./interaxle-spacing.helper");
+const format_meters_helper_1 = require("./format-meters.helper");
 /** Applies the standard lower-of rule or the exact 7.16(g) exception. */
 function getMaximumLegalAxleGroupWeightThreshold(individualLegalWeightSum, ctr717TableValue, isTandemDriveSingleJeepException) {
     const tandemDriveSingleJeepMinimumKg = 24000;
@@ -74,7 +44,7 @@ function getApplicableLegalWeightThreshold(policy, vehicleConfiguration, axleCon
         return undefined;
     }
     const weights = vehicleIndex === 0
-        ? policy.getDefaultPowerUnitWeight(vehicleType, axleConfiguration[0].numberOfAxles * POWER_UNIT_AXLE_CODE_MULTIPLIER +
+        ? policy.getDefaultPowerUnitWeight(vehicleType, axleConfiguration[0].numberOfAxles * power_unit_axle_code_multiplier_1.POWER_UNIT_AXLE_CODE_MULTIPLIER +
             axleConfiguration[1].numberOfAxles)
         : policy.getDefaultTrailerWeight(vehicleType, axle.numberOfAxles);
     if (weights.length === 0) {
@@ -101,7 +71,7 @@ function getConfiguredAxleUnitWeightThreshold(policy, vehicleConfiguration, axle
         return 0;
     }
     const weights = vehicleIndex === 0
-        ? policy.getDefaultPowerUnitWeight(vehicleType, axleConfiguration[0].numberOfAxles * POWER_UNIT_AXLE_CODE_MULTIPLIER +
+        ? policy.getDefaultPowerUnitWeight(vehicleType, axleConfiguration[0].numberOfAxles * power_unit_axle_code_multiplier_1.POWER_UNIT_AXLE_CODE_MULTIPLIER +
             axleConfiguration[1].numberOfAxles)
         : policy.getDefaultTrailerWeight(vehicleType, axleUnit.numberOfAxles);
     if (weights.length === 0) {
@@ -123,28 +93,28 @@ function getFeatureLegalPowerUnitWeightThreshold(vehicleType, axleConfiguration,
         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;
+                ? axle_weight_legal_maximums_1.AXLE_WEIGHT_LEGAL_MAXIMUMS.SINGLE_AXLE
+                : axle_weight_legal_maximums_1.AXLE_WEIGHT_LEGAL_MAXIMUMS.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;
+                ? axle_weight_legal_maximums_1.AXLE_WEIGHT_LEGAL_MAXIMUMS.SINGLE_AXLE
+                : axle_weight_legal_maximums_1.AXLE_WEIGHT_LEGAL_MAXIMUMS.STANDARD_SINGLE_STEER_WITH_TRIDEM_DRIVE;
         }
         if (steerAxle.numberOfAxles === 2 && driveAxle.numberOfAxles === 2) {
-            return LEGAL_WEIGHT_MAXIMUM_KG.TANDEM_AXLE;
+            return axle_weight_legal_maximums_1.AXLE_WEIGHT_LEGAL_MAXIMUMS.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;
+                ? axle_weight_legal_maximums_1.AXLE_WEIGHT_LEGAL_MAXIMUMS.PME_TANDEM_STEER_WITH_TRIDEM_DRIVE
+                : axle_weight_legal_maximums_1.AXLE_WEIGHT_LEGAL_MAXIMUMS.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,
+            1: axle_weight_legal_maximums_1.AXLE_WEIGHT_LEGAL_MAXIMUMS.SINGLE_AXLE,
+            2: axle_weight_legal_maximums_1.AXLE_WEIGHT_LEGAL_MAXIMUMS.TANDEM_AXLE,
+            3: axle_weight_legal_maximums_1.AXLE_WEIGHT_LEGAL_MAXIMUMS.TRIDEM_AXLE,
         }[driveAxle.numberOfAxles];
     }
     return undefined;
@@ -511,20 +481,24 @@ function CheckNumTiresPerAxle(_policy, _vehicleConfiguration, axleConfiguration)
 function CheckPermittableWeight(policy, vehicleConfiguration, axleConfiguration) {
     const policyId = enum_1.PolicyCheckId.PermittableWeight;
     const axleUnitVehicleIndexes = getAxleUnitVehicleIndexLookup(policy, vehicleConfiguration, axleConfiguration);
+    const QUALIFYING_TRIDEM_SPREAD_CM = {
+        MINIMUM: 240,
+        MAXIMUM: 370,
+    };
     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;
+            permittableWeight = axle_weight_permittable_maximums_1.AXLE_WEIGHT_PERMITTABLE_MAXIMUMS.SINGLE_STEER;
         }
         else if (!isTandemSteer) {
             if (axleUnit.numberOfAxles === 1) {
-                permittableWeight = PERMITTABLE_WEIGHT_MAXIMUM_KG.SINGLE_NON_STEER;
+                permittableWeight = axle_weight_permittable_maximums_1.AXLE_WEIGHT_PERMITTABLE_MAXIMUMS.SINGLE_NON_STEER;
             }
             else if (axleUnit.numberOfAxles === 2) {
-                permittableWeight = PERMITTABLE_WEIGHT_MAXIMUM_KG.TANDEM;
+                permittableWeight = axle_weight_permittable_maximums_1.AXLE_WEIGHT_PERMITTABLE_MAXIMUMS.TANDEM;
             }
             else if (axleUnit.numberOfAxles === 3) {
                 const spreadQualifies = axleUnit.axleSpread !== undefined &&
@@ -538,8 +512,8 @@ function CheckPermittableWeight(policy, vehicleConfiguration, axleConfiguration)
                 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;
+                        ? axle_weight_permittable_maximums_1.AXLE_WEIGHT_PERMITTABLE_MAXIMUMS.QUALIFYING_TRIDEM
+                        : axle_weight_permittable_maximums_1.AXLE_WEIGHT_PERMITTABLE_MAXIMUMS.STANDARD_TRIDEM;
             }
         }
         permittableWeight !== null && permittableWeight !== void 0 ? permittableWeight : (permittableWeight = getConfiguredAxleUnitWeightThreshold(policy, vehicleConfiguration, axleConfiguration, axleUnitVehicleIndexes, axleIndex, 'permittable'));
@@ -772,9 +746,12 @@ function CheckMinDriveAxleWeight(_policy, vehicleConfiguration, axleConfiguratio
     const driveAxle = axleConfiguration[1];
     const isTandemDrive = driveAxle.numberOfAxles === 2;
     const isTridemDrive = driveAxle.numberOfAxles === 3;
-    // TODO we need to add Truck with PME and Truck Tractor with PME when ready
     const isSupportedVehicleSubtype = (value) => {
-        return value === 'REGTRCK' || value === 'TRKTRAC' || value === 'PICKRTT';
+        return (value === 'REGTRCK' ||
+            value === 'TRKTRAC' ||
+            value === 'PICKRTT' ||
+            value === 'TRCKPME' ||
+            value === 'TRACPME');
     };
     if ((isTandemDrive || isTridemDrive) &&
         isSupportedVehicleSubtype(powerUnitSubtype)) {
@@ -975,6 +952,14 @@ function CheckMaxTireLoad(_policy, _vehicleConfiguration, axleConfiguration) {
             }
             return;
         }
+        // ORV2-5903 keeps this exact configuration as a grandfathered TPS case.
+        const hasGrandfatheredTpsTireLimit = ac.numberOfAxles === 2 &&
+            tireSize === 279.4 &&
+            numberOfTires === 8 &&
+            axleWeight <= 23000;
+        if (hasGrandfatheredTpsTireLimit) {
+            return;
+        }
         /**
          * Standard non-steering axle — all vehicles except Crane - All Terrain,
          * Mobile Crane (non-steering), Rubber Tired Loader
@@ -1060,7 +1045,7 @@ function CheckBoosterAxleLimit(_policy, vehicleConfiguration, axleConfiguration)
 /**
  * Validates wheelbase legal limits for supported power unit vehicle sub-types.
  */
-function CheckWheelbaseLegalLimits(policy, vehicleConfiguration, axleConfiguration) {
+function CheckWheelbaseLegalLimits(_policy, vehicleConfiguration, axleConfiguration) {
     var _a, _b, _c;
     const resultBase = {
         id: enum_1.PolicyCheckId.WheelbaseLegalLimits,
@@ -1070,12 +1055,13 @@ function CheckWheelbaseLegalLimits(policy, vehicleConfiguration, axleConfigurati
     const powerUnitSubtype = vehicleConfiguration[0];
     const steerAxle = Object.assign(Object.assign({}, axleConfiguration[0]), { axleSpread: (_a = axleConfiguration[0].axleSpread) !== null && _a !== void 0 ? _a : 0 });
     const driveAxle = Object.assign(Object.assign({}, axleConfiguration[1]), { axleSpread: (_b = axleConfiguration[1].axleSpread) !== null && _b !== void 0 ? _b : 0, interaxleSpacing: (_c = axleConfiguration[1].interaxleSpacing) !== null && _c !== void 0 ? _c : 0 });
-    // TODO we need to add Truck with PME and Truck Tractor with PME when ready
     const isSupportedVehicleSubtype = (value) => {
         return (value === 'REGTRCK' ||
             value === 'TRKTRAC' ||
             value === 'PICKRTT' ||
-            value === 'OGBEDTK');
+            value === 'OGBEDTK' ||
+            value === 'TRCKPME' ||
+            value === 'TRACPME');
     };
     const isSingleSteer = steerAxle.numberOfAxles === 1;
     const isTandemSteer = steerAxle.numberOfAxles === 2;
@@ -1083,6 +1069,8 @@ function CheckWheelbaseLegalLimits(policy, vehicleConfiguration, axleConfigurati
     const isTridemDrive = driveAxle.numberOfAxles === 3;
     const isTruckTractor = powerUnitSubtype === 'TRKTRAC';
     const isPickerTruckTractor = powerUnitSubtype === 'PICKRTT';
+    const isTruckWithPME = powerUnitSubtype === 'TRCKPME';
+    const isTruckTractorWithPME = powerUnitSubtype === 'TRACPME';
     const isOilfieldBedTruck = powerUnitSubtype === 'OGBEDTK';
     const wheelbase = isSingleSteer
         ? driveAxle.interaxleSpacing + driveAxle.axleSpread / 2
@@ -1100,12 +1088,10 @@ function CheckWheelbaseLegalLimits(policy, vehicleConfiguration, axleConfigurati
             ];
         }
         if (wheelbase >= 620) {
-            const hasDisallowedTrailer = vehicleConfiguration.slice(1).some((v) => {
-                const trailer = policy.getTrailerDefinition(v);
-                const isSemiTrailer = (trailer === null || trailer === void 0 ? void 0 : trailer.id) === 'SEMITRL';
-                return !isSemiTrailer;
-            });
             const hasTrailer = vehicleConfiguration.length > 1;
+            const hasDisallowedTrailer = vehicleConfiguration
+                .slice(1)
+                .some((vehicleType) => !(0, semi_trailer_types_1.isSemiTrailerType)(vehicleType));
             return [
                 Object.assign(Object.assign({}, resultBase), { result: hasDisallowedTrailer
                         ? enum_1.PolicyCheckResultType.Fail
@@ -1120,8 +1106,10 @@ function CheckWheelbaseLegalLimits(policy, vehicleConfiguration, axleConfigurati
     }
     if (isSupportedVehicleSubtype(powerUnitSubtype)) {
         if (isSingleSteer && isTridemDrive) {
-            // TODO we need to add Truck with PME and Truck Tractor with PME when ready
-            if (isTruckTractor || isPickerTruckTractor) {
+            if (isTruckTractor ||
+                isPickerTruckTractor ||
+                isTruckWithPME ||
+                isTruckTractorWithPME) {
                 if (wheelbase < 660) {
                     return [
                         Object.assign(Object.assign({}, resultBase), { result: enum_1.PolicyCheckResultType.Fail, message: 'Wheelbase for Axle Unit 1 is less than 6.6 m.' }),
@@ -1226,49 +1214,6 @@ 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.
@@ -1276,7 +1221,7 @@ function getFailedInteraxleSpacingMessage(requirement, previousAxleUnitNumber, c
 function CheckLegalInteraxleSpacing(_policy, _vehicleConfiguration, axleConfiguration) {
     const policyId = enum_1.PolicyCheckId.LegalInteraxleSpacing;
     return axleConfiguration.map((axleUnit, axleIndex) => {
-        const requirement = getInteraxleSpacingRequirement(axleConfiguration, axleIndex);
+        const requirement = (0, interaxle_spacing_helper_1.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 ||
@@ -1286,7 +1231,7 @@ function CheckLegalInteraxleSpacing(_policy, _vehicleConfiguration, axleConfigur
         const previousAxleUnitNumber = axleIndex;
         const message = shouldPass
             ? ''
-            : getFailedInteraxleSpacingMessage(requirement, previousAxleUnitNumber, axleUnitNumber);
+            : (0, interaxle_spacing_helper_1.getFailedInteraxleSpacingMessage)(requirement, previousAxleUnitNumber, axleUnitNumber);
         return {
             id: policyId,
             message,
@@ -1297,6 +1242,37 @@ function CheckLegalInteraxleSpacing(_policy, _vehicleConfiguration, axleConfigur
         };
     });
 }
+/**
+ * Validates each axle unit against its legal axle spread maximum.
+ */
+function CheckLegalAxleSpread(policy, vehicleConfiguration, axleConfiguration) {
+    const policyId = enum_1.PolicyCheckId.LegalAxleSpread;
+    const axleUnitVehicleIndexes = getAxleUnitVehicleIndexLookup(policy, vehicleConfiguration, axleConfiguration);
+    return axleConfiguration.flatMap((axleUnit, axleIndex) => {
+        const threshold = (0, axle_spread_helper_1.getAxleSpreadThreshold)(vehicleConfiguration, axleUnitVehicleIndexes, axleConfiguration, axleIndex);
+        if (!axleUnit.axleSpread ||
+            !threshold ||
+            !Number.isFinite(axleUnit.axleSpread)) {
+            return [];
+        }
+        const result = axleUnit.axleSpread >= threshold.minCm &&
+            axleUnit.axleSpread <= threshold.maxCm;
+        const axleUnitNumber = axleIndex + 1;
+        const message = result
+            ? ''
+            : `Axle Spread for Axle Unit ${axleUnitNumber} must be between ${(0, format_meters_helper_1.formatMeters)(threshold.minCm)} m and ${(0, format_meters_helper_1.formatMeters)(threshold.maxCm)} m.`;
+        return [
+            {
+                id: policyId,
+                result: result
+                    ? enum_1.PolicyCheckResultType.Pass
+                    : enum_1.PolicyCheckResultType.Fail,
+                message,
+                axleUnit: axleUnitNumber,
+            },
+        ];
+    });
+}
 /**
  * Map of policy check functions keyed by their corresponding PolicyCheckId.
  *
@@ -1309,6 +1285,7 @@ function CheckLegalInteraxleSpacing(_policy, _vehicleConfiguration, axleConfigur
  * - 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
+ * - CheckLegalAxleSpread: Validates axle units against legal axle spread 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
@@ -1333,6 +1310,7 @@ exports.policyCheckMap = new Map([
         enum_1.PolicyCheckId.AxleGroupMaximumLegalWeightThreshold,
         CheckAxleGroupMaximumLegalWeightThreshold,
     ],
+    [enum_1.PolicyCheckId.LegalAxleSpread, CheckLegalAxleSpread],
     [enum_1.PolicyCheckId.LegalWeight, CheckLegalWeight],
     [enum_1.PolicyCheckId.PermittableWeight, CheckPermittableWeight],
     [enum_1.PolicyCheckId.MaxTireLoad, CheckMaxTireLoad],

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

@@ -0,0 +1,6 @@
+export declare const AXLE_UNIT_TYPES: {
+    readonly SINGLE: 'SINGLE';
+    readonly TANDEM: 'TANDEM';
+    readonly TRIDEM: 'TRIDEM';
+};
+export type AxleUnitType = (typeof AXLE_UNIT_TYPES)[keyof typeof AXLE_UNIT_TYPES];

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

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

package/dist/types/interaxle-spacing-requirement.d.ts

@@ -0,0 +1,5 @@
+export interface InteraxleSpacingRequirement {
+    min?: number;
+    max?: number;
+    groupLabel?: string;
+}

package/dist/types/interaxle-spacing-requirement.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const version = "v2.26.0";
+export declare const version = "v2.27.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.26.0';
+exports.version = 'v2.27.0';

package/package.json

@@ -91,5 +91,5 @@
     ],
     "testEnvironment": "node"
   },
-  "version": "v2.26.0"
+  "version": "v2.27.0"
 }