onroute-policy-engine 2.26.1 → 2.28.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/index.d.ts

@@ -2,6 +2,7 @@ export { AccessoryVehicleType } from './accessory-vehicle-type';
 export { CustomOperator } from './custom-operator';
 export { PolicyFacts, CostFacts } from './facts';
 export { PermitAppInfo } from './permit-app-info';
+export { OverloadCalculationDetailKind } from './overload-calculation-detail-kind';
 export { PolicyCheckResultType, PolicyCheckId } from './policy-check';
 export { RelativePosition } from './relative-position';
 export { ValidationResultCode } from './validation-result-code';

package/dist/enum/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.VehicleTypes = exports.VehicleCategory = exports.ValidationResultType = exports.ValidationResultCode = exports.RelativePosition = exports.PolicyCheckId = exports.PolicyCheckResultType = exports.PermitAppInfo = exports.CostFacts = exports.PolicyFacts = exports.CustomOperator = exports.AccessoryVehicleType = void 0;
+exports.VehicleTypes = exports.VehicleCategory = exports.ValidationResultType = exports.ValidationResultCode = exports.RelativePosition = exports.PolicyCheckId = exports.PolicyCheckResultType = exports.OverloadCalculationDetailKind = exports.PermitAppInfo = exports.CostFacts = exports.PolicyFacts = exports.CustomOperator = exports.AccessoryVehicleType = void 0;
 var accessory_vehicle_type_1 = require("./accessory-vehicle-type");
 Object.defineProperty(exports, "AccessoryVehicleType", { enumerable: true, get: function () { return accessory_vehicle_type_1.AccessoryVehicleType; } });
 var custom_operator_1 = require("./custom-operator");
@@ -10,6 +10,8 @@ Object.defineProperty(exports, "PolicyFacts", { enumerable: true, get: function
 Object.defineProperty(exports, "CostFacts", { enumerable: true, get: function () { return facts_1.CostFacts; } });
 var permit_app_info_1 = require("./permit-app-info");
 Object.defineProperty(exports, "PermitAppInfo", { enumerable: true, get: function () { return permit_app_info_1.PermitAppInfo; } });
+var overload_calculation_detail_kind_1 = require("./overload-calculation-detail-kind");
+Object.defineProperty(exports, "OverloadCalculationDetailKind", { enumerable: true, get: function () { return overload_calculation_detail_kind_1.OverloadCalculationDetailKind; } });
 var policy_check_1 = require("./policy-check");
 Object.defineProperty(exports, "PolicyCheckResultType", { enumerable: true, get: function () { return policy_check_1.PolicyCheckResultType; } });
 Object.defineProperty(exports, "PolicyCheckId", { enumerable: true, get: function () { return policy_check_1.PolicyCheckId; } });

package/dist/enum/overload-calculation-detail-kind.d.ts

@@ -0,0 +1,4 @@
+export declare enum OverloadCalculationDetailKind {
+    AxleWeight = "axle-weight",
+    LicensedGvw = "licensed-gvw"
+}

package/dist/enum/overload-calculation-detail-kind.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OverloadCalculationDetailKind = void 0;
+var OverloadCalculationDetailKind;
+(function (OverloadCalculationDetailKind) {
+    OverloadCalculationDetailKind["AxleWeight"] = "axle-weight";
+    OverloadCalculationDetailKind["LicensedGvw"] = "licensed-gvw";
+})(OverloadCalculationDetailKind || (exports.OverloadCalculationDetailKind = OverloadCalculationDetailKind = {}));

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/overload.helper.d.ts

@@ -0,0 +1,5 @@
+import { AxleGroupPolicyCheckResult, OverloadCalculationDetail } from '../types';
+export declare const calculateOverload: (results: Array<AxleGroupPolicyCheckResult>, totalGCVW: number, licensedGVW: number, axleUnitCount: number) => {
+    overload: number;
+    overloadDetails: Array<OverloadCalculationDetail>;
+};

package/dist/helper/overload.helper.js

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calculateOverload = void 0;
+const enum_1 = require("../enum");
+const EMPTY_SELECTION = {
+    details: [],
+    overload: 0,
+    individualCount: 0,
+};
+const compareSelections = (first, second) => {
+    if (first.overload !== second.overload) {
+        return first.overload > second.overload ? first : second;
+    }
+    if (first.individualCount !== second.individualCount) {
+        return first.individualCount > second.individualCount ? first : second;
+    }
+    // Keep output deterministic when equivalent policy checks are reordered.
+    const firstKey = first.details
+        .map(({ startAxleUnit, endAxleUnit }) => `${startAxleUnit}:${endAxleUnit}`)
+        .join('|');
+    const secondKey = second.details
+        .map(({ startAxleUnit, endAxleUnit }) => `${startAxleUnit}:${endAxleUnit}`)
+        .join('|');
+    return firstKey <= secondKey ? first : second;
+};
+const getAxleOverloadCandidates = (results) => results
+    .filter(({ id, result, actualWeight, thresholdWeight }) => ((id === enum_1.PolicyCheckId.LegalWeight &&
+    result === enum_1.PolicyCheckResultType.Warning) ||
+    (id === enum_1.PolicyCheckId.AxleGroupMaximumLegalWeightThreshold &&
+        result === enum_1.PolicyCheckResultType.Fail)) &&
+    Number.isFinite(actualWeight) &&
+    Number.isFinite(thresholdWeight) &&
+    thresholdWeight > 0 &&
+    actualWeight > thresholdWeight)
+    .map(({ startAxleUnit, endAxleUnit, actualWeight, thresholdWeight }) => ({
+    kind: enum_1.OverloadCalculationDetailKind.AxleWeight,
+    startAxleUnit,
+    endAxleUnit,
+    actualWeight: actualWeight,
+    legalMaxWeight: thresholdWeight,
+    overload: actualWeight - thresholdWeight,
+}))
+    .sort((first, second) => first.endAxleUnit - second.endAxleUnit ||
+    first.startAxleUnit - second.startAxleUnit);
+const selectAxleOverloadDetails = (candidates) => {
+    const bestThroughCandidate = new Array(candidates.length + 1);
+    bestThroughCandidate[0] = EMPTY_SELECTION;
+    candidates.forEach((candidate, candidateIndex) => {
+        let predecessorIndex = candidateIndex - 1;
+        while (predecessorIndex >= 0 &&
+            candidates[predecessorIndex].endAxleUnit >= candidate.startAxleUnit) {
+            predecessorIndex--;
+        }
+        const predecessor = bestThroughCandidate[predecessorIndex + 1];
+        const withCandidate = {
+            details: [...predecessor.details, candidate],
+            overload: predecessor.overload + candidate.overload,
+            individualCount: predecessor.individualCount +
+                Number(candidate.startAxleUnit === candidate.endAxleUnit),
+        };
+        bestThroughCandidate[candidateIndex + 1] = compareSelections(bestThroughCandidate[candidateIndex], withCandidate);
+    });
+    return bestThroughCandidate[candidates.length];
+};
+const calculateOverload = (results, totalGCVW, licensedGVW, axleUnitCount) => {
+    const axleSelection = selectAxleOverloadDetails(getAxleOverloadCandidates(results));
+    const licensedGvwOverload = Math.max(0, totalGCVW - licensedGVW);
+    // Licensed GVW intentionally wins an exact tie with the axle calculation. We have
+    // to pick one, so this one made sense.
+    if (licensedGvwOverload > 0 && licensedGvwOverload >= axleSelection.overload) {
+        return {
+            overload: licensedGvwOverload,
+            overloadDetails: [
+                {
+                    kind: enum_1.OverloadCalculationDetailKind.LicensedGvw,
+                    startAxleUnit: 1,
+                    endAxleUnit: axleUnitCount,
+                    licensedGVW,
+                    totalGCVW,
+                    overload: licensedGvwOverload,
+                },
+            ],
+        };
+    }
+    return {
+        overload: axleSelection.overload,
+        overloadDetails: axleSelection.details,
+    };
+};
+exports.calculateOverload = calculateOverload;

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;
@@ -171,7 +141,12 @@ function CheckLegalWeight(policy, vehicleConfiguration, axleConfiguration) {
         return {
             id: policyId,
             message: `Weight for axle unit ${axleUnitNumber} ${result ? 'is legal' : `must not exceed ${legalWeight} kgs`}`,
-            result: result ? enum_1.PolicyCheckResultType.Pass : enum_1.PolicyCheckResultType.Fail,
+            // We intentionally only return Pass/Warning, as we should never 
+            // show an error for being above legal amount, only permitable 
+            // amount. But it's still useful info for things like OCD table.
+            result: result
+                ? enum_1.PolicyCheckResultType.Pass
+                : enum_1.PolicyCheckResultType.Warning,
             axleUnit: axleUnitNumber,
             actualWeight: axleUnit.axleUnitWeight,
             thresholdWeight: legalWeight,
@@ -511,20 +486,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 +517,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 +751,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)) {
@@ -976,8 +958,10 @@ function CheckMaxTireLoad(_policy, _vehicleConfiguration, axleConfiguration) {
             return;
         }
         // ORV2-5903 keeps this exact configuration as a grandfathered TPS case.
+        // The application stores the 279.4 mm option as 279 to match f
+        const hasGrandfatheredTpsTireSize = tireSize === 279.4 || tireSize === 279;
         const hasGrandfatheredTpsTireLimit = ac.numberOfAxles === 2 &&
-            tireSize === 279.4 &&
+            hasGrandfatheredTpsTireSize &&
             numberOfTires === 8 &&
             axleWeight <= 23000;
         if (hasGrandfatheredTpsTireLimit) {
@@ -1068,7 +1052,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,
@@ -1078,12 +1062,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;
@@ -1091,6 +1076,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
@@ -1108,12 +1095,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
@@ -1128,8 +1113,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.' }),
@@ -1234,49 +1221,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.
@@ -1284,7 +1228,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 ||
@@ -1294,7 +1238,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,
@@ -1305,6 +1249,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.
  *
@@ -1317,6 +1292,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
@@ -1341,6 +1317,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/policy-engine.js

@@ -22,6 +22,7 @@ const dimensions_helper_2 = require("./helper/dimensions.helper");
 const display_code_helper_1 = require("./helper/display-code-helper");
 const policy_check_helper_1 = require("./helper/policy-check.helper");
 const cost_1 = require("./constants/cost");
+const overload_helper_1 = require("./helper/overload.helper");
 /** Class representing commercial vehicle policy. */
 class Policy {
     /**
@@ -717,8 +718,14 @@ class Policy {
         const axleCalcResults = {
             results: [],
             overload: 0,
+            overloadDetails: [],
             totalGCVW: 0,
         };
+        const updateOverloadCalculation = () => {
+            const { overload, overloadDetails } = (0, overload_helper_1.calculateOverload)(axleCalcResults.results, axleCalcResults.totalGCVW, licensedGVW, axleConfiguration.length);
+            axleCalcResults.overload = overload;
+            axleCalcResults.overloadDetails = overloadDetails;
+        };
         // This is a little helper closure that just converts any PolicyCheckResult into an AxleGroupPolicyCheckResult,
         // basically giving us startAxleUnit and endAxleUnit, which can help with frontend form highlighting.
         const toAxleGroupPolicyCheckResult = (result) => {
@@ -731,11 +738,11 @@ class Policy {
             return Object.assign(Object.assign({}, result), { startAxleUnit: 1, endAxleUnit: axleConfiguration.length });
         };
         const gvcw = axleConfiguration.reduce((w, curr) => w + curr.axleUnitWeight, 0);
-        axleCalcResults.overload = Math.max(axleCalcResults.overload, gvcw - licensedGVW);
         axleCalcResults.totalGCVW = gvcw;
         const axleCountResults = (0, policy_check_helper_1.CheckNumberOfAxles)(this, vehicleConfiguration, axleConfiguration);
         axleCalcResults.results.push(...axleCountResults.map(toAxleGroupPolicyCheckResult));
         if (axleCountResults.some((r) => r.result === enum_1.PolicyCheckResultType.Fail)) {
+            updateOverloadCalculation();
             return axleCalcResults;
         }
         for (const [policyCheckId, policyCheck] of policy_check_helper_1.policyCheckMap) {
@@ -744,6 +751,7 @@ class Policy {
             }
             axleCalcResults.results.push(...policyCheck(this, vehicleConfiguration, axleConfiguration).map(toAxleGroupPolicyCheckResult));
         }
+        updateOverloadCalculation();
         return axleCalcResults;
     }
     /**

package/dist/types/axle-calculation-results.d.ts

@@ -4,7 +4,7 @@
  * These types define the structure for axle calculation results and policy check outcomes.
  * Used for validating vehicle configurations against weight and axle requirements.
  */
-import { PolicyCheckId, PolicyCheckResultType } from 'onroute-policy-engine/enum';
+import { OverloadCalculationDetailKind, PolicyCheckId, PolicyCheckResultType } from 'onroute-policy-engine/enum';
 /**
  * Complete results from axle calculations including all policy checks and total overload
  */
@@ -13,9 +13,30 @@ export type AxleCalcResults = {
     results: Array<AxleGroupPolicyCheckResult>;
     /** Total weight overload across all axles in kilograms */
     overload: number;
+    /** Details for only the selected overload calculation */
+    overloadDetails: Array<OverloadCalculationDetail>;
     /** Total Gross Combined Vehicle Weight across all axles in kilograms */
     totalGCVW: number;
 };
+/** Licensed-GVW overload selected across the complete axle configuration. */
+export type LicensedGvwOverloadCalculationDetail = {
+    kind: OverloadCalculationDetailKind.LicensedGvw;
+    startAxleUnit: number;
+    endAxleUnit: number;
+    licensedGVW: number;
+    totalGCVW: number;
+    overload: number;
+};
+/** Legal-weight overload selected for an axle unit or axle-unit group. */
+export type AxleWeightOverloadCalculationDetail = {
+    kind: OverloadCalculationDetailKind.AxleWeight;
+    startAxleUnit: number;
+    endAxleUnit: number;
+    actualWeight: number;
+    legalMaxWeight: number;
+    overload: number;
+};
+export type OverloadCalculationDetail = LicensedGvwOverloadCalculationDetail | AxleWeightOverloadCalculationDetail;
 /**
  * Individual policy check result for a specific validation rule
  */

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/index.d.ts

@@ -1,4 +1,4 @@
-export type { AxleCalcResults, PolicyCheckResult, AxleUnitPolicyCheckResult, AxleGroupPolicyCheckResult, } from './axle-calculation-results';
+export type { AxleCalcResults, PolicyCheckResult, AxleUnitPolicyCheckResult, AxleGroupPolicyCheckResult, OverloadCalculationDetail, LicensedGvwOverloadCalculationDetail, AxleWeightOverloadCalculationDetail, } from './axle-calculation-results';
 export type { AxleConfiguration, IndexedAxleConfiguration, } from './axle-configuration';
 export type { BridgeCalculationConstants } from './bridge-calculation-constants';
 export type { BridgeCalculationResult } from './bridge-calculation-result';

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.1";
+export declare const version = "v2.28.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.1';
+exports.version = 'v2.28.0';

package/package.json

@@ -91,5 +91,5 @@
     ],
     "testEnvironment": "node"
   },
-  "version": "v2.26.1"
+  "version": "v2.28.0"
 }