onroute-policy-engine 2.1.1 → 2.2.1

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

@@ -0,0 +1,337 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.policyCheckMap = void 0;
+exports.CheckBridgeFormula = CheckBridgeFormula;
+exports.CheckNumTiresPerAxle = CheckNumTiresPerAxle;
+exports.CheckPermittableWeight = CheckPermittableWeight;
+exports.CheckMinSteerAxleWeight = CheckMinSteerAxleWeight;
+exports.CheckMinDriveAxleWeight = CheckMinDriveAxleWeight;
+const enum_1 = require("../enum");
+/**
+ * Performs bridge formula calculations on axle groups and returns policy check results.
+ *
+ * This function calculates the bridge formula for each axle group in the vehicle configuration
+ * and determines whether each group passes or fails the bridge formula requirements. The bridge
+ * formula is a provincial regulation that limits the weight that can be carried on a group of axles
+ * based on the distance between the first and last axles in the group.
+ *
+ * @param policy - The policy instance containing bridge calculation configuration
+ * @param _vehicleConfiguration - Vehicle configuration (unused in this check, but required by PolicyCheck type)
+ * @param axleConfiguration - Array of axle configurations containing spacing and weight information
+ * @returns Array of AxleGroupPolicyCheckResult objects, one for each axle group tested
+ *
+ * @example
+ * // For a vehicle with 3 axle groups
+ * const results = CheckBridgeFormula(policy, ['TRKTRAC', 'SEMITRL'], [
+ *   { numberOfAxles: 2, axleSpread: 1.8, weight: 12000 },
+ *   { numberOfAxles: 3, axleSpread: 4.2, weight: 34000 },
+ *   { numberOfAxles: 3, axleSpread: 3.0, weight: 34000 }
+ * ]);
+ * // Returns results for each axle group (e.g., axles 1-2, 1-3, 2-3)
+ *
+ * @see PolicyCheck
+ * @see AxleGroupPolicyCheckResult
+ * @see BridgeCalculationResult
+ */
+function CheckBridgeFormula(policy, _vehicleConfiguration, axleConfiguration) {
+    const policyCheckResults = new Array();
+    const policyId = enum_1.PolicyCheckId.BridgeFormula;
+    const bridgeCalcResults = policy.calculateBridge(axleConfiguration);
+    bridgeCalcResults.forEach((br) => {
+        const message = `Axle group ${br.startAxleUnit} to ${br.endAxleUnit} ${br.success ? 'passes' : 'does not pass'} bridge formula.`;
+        policyCheckResults.push({
+            id: policyId,
+            message: message,
+            result: br.success
+                ? enum_1.PolicyCheckResultType.Pass
+                : enum_1.PolicyCheckResultType.Fail,
+            startAxleUnit: br.startAxleUnit,
+            endAxleUnit: br.endAxleUnit,
+        });
+    });
+    return policyCheckResults;
+}
+/**
+ * Validates the number of tires per axle unit against regulatory requirements.
+ *
+ * This function checks that each axle unit has a valid number of tires based on
+ * the number of axles in that unit. The validation allows for 2, 4, or 8 tires
+ * per axle (2, 4, or 8 * number of axles). This ensures compliance with tire
+ * count regulations for commercial vehicles.
+ *
+ * @param _policy - The policy instance (unused in this check, but required by PolicyCheck type)
+ * @param _vehicleConfiguration - Vehicle configuration (unused in this check, but required by PolicyCheck type)
+ * @param axleConfiguration - Array of axle configurations containing tire count and axle count information
+ * @returns Array of AxleUnitPolicyCheckResult objects, one for each axle unit tested
+ *
+ * @example
+ * // For a vehicle with 2 axle units
+ * const results = CheckNumTiresPerAxle(policy, ['TRKTRAC'], [
+ *   { numberOfAxles: 2, numberOfTires: 4 },  // 2 axles × 2 tires = 4 (valid)
+ *   { numberOfAxles: 3, numberOfTires: 12 }  // 3 axles × 4 tires = 12 (valid)
+ * ]);
+ * // Returns pass results for both axle units
+ *
+ * @example
+ * // Invalid tire count example
+ * const results = CheckNumTiresPerAxle(policy, ['TRKTRAC'], [
+ *   { numberOfAxles: 2, numberOfTires: 6 }  // 2 axles × 3 tires = 6 (invalid - not 2, 4, or 8 per axle)
+ * ]);
+ * // Returns fail result for the axle unit
+ *
+ * @see PolicyCheck
+ * @see AxleUnitPolicyCheckResult
+ * @see AxleConfiguration
+ */
+function CheckNumTiresPerAxle(_policy, _vehicleConfiguration, axleConfiguration) {
+    const policyCheckResults = new Array();
+    const policyId = enum_1.PolicyCheckId.NumberOfWheelsPerAxle;
+    let axleNum = 1;
+    axleConfiguration.forEach((ac) => {
+        const numTires = ac.numberOfTires || 0;
+        const numAxles = ac.numberOfAxles;
+        // Default result to fail, set to pass explicitly if valid
+        let result = enum_1.PolicyCheckResultType.Fail;
+        let message;
+        if (!numAxles) {
+            // Invalid number of axles, cannot calculate
+            message = `Number of axles for axle unit ${axleNum} is not permittable.`;
+        }
+        else {
+            const checkResult = [numAxles * 2, numAxles * 4, numAxles * 8].includes(numTires);
+            message = `Number of wheels for axle unit ${axleNum} is ${checkResult ? '' : 'not '}permittable.`;
+            if (checkResult)
+                result = enum_1.PolicyCheckResultType.Pass;
+        }
+        policyCheckResults.push({
+            id: policyId,
+            message: message,
+            result: result,
+            axleUnit: axleNum,
+        });
+        axleNum++;
+    });
+    return policyCheckResults;
+}
+/**
+ * Validates that each axle unit's weight does not exceed the permittable weight limits.
+ *
+ * This function performs weight validation for each axle unit in a vehicle configuration.
+ * It retrieves the default weight dimensions for power units and trailers based on their
+ * vehicle types and axle counts, then compares the actual axle unit weights against the
+ * permittable weight limits. The function handles both power units (with steer and drive
+ * axles) and trailers, ensuring compliance with weight regulations.
+ *
+ * @param policy - The policy instance containing weight dimension configurations and validation rules
+ * @param vehicleConfiguration - Array of vehicle type identifiers representing the vehicle configuration.
+ *                              The first element should be a power unit type, followed by trailer types.
+ * @param axleConfiguration - Array of axle configurations containing weight and axle count information.
+ *                           For power units, this includes both steer and drive axle configurations.
+ * @returns Array of AxleUnitPolicyCheckResult objects, one for each axle unit tested.
+ *          Each result indicates whether the axle unit's weight is within permittable limits.
+ *
+ * @example
+ * // For a truck-tractor with 2-axle steer, 3-axle drive, and a 3-axle semi-trailer
+ * const results = CheckPermittableWeight(policy, ['TRKTRAC', 'SEMITRL'], [
+ *   { numberOfAxles: 2, axleUnitWeight: 12000 },  // Steer axle unit
+ *   { numberOfAxles: 3, axleUnitWeight: 34000 },  // Drive axle unit
+ *   { numberOfAxles: 3, axleUnitWeight: 34000 }   // Trailer axle unit
+ * ]);
+ * // Returns results for each axle unit indicating pass/fail status
+ *
+ * @example
+ * // For a single power unit with no trailers
+ * const results = CheckPermittableWeight(policy, ['TRKTRAC'], [
+ *   { numberOfAxles: 2, axleUnitWeight: 12000 },  // Steer axle unit
+ *   { numberOfAxles: 3, axleUnitWeight: 34000 }   // Drive axle unit
+ * ]);
+ * // Returns results for steer and drive axle units only
+ *
+ * @see PolicyCheck
+ * @see AxleUnitPolicyCheckResult
+ * @see WeightDimension
+ * @see SingleAxleDimension
+ */
+function CheckPermittableWeight(policy, vehicleConfiguration, axleConfiguration) {
+    const policyCheckResults = new Array();
+    const policyId = enum_1.PolicyCheckId.CheckPermittableWeight;
+    const singleAxleDimensions = [];
+    vehicleConfiguration.forEach((vc, i) => {
+        let weight;
+        if (i === 0) {
+            // This is a power unit, concatenate the steer and drive axle numbers
+            const powerUnitAxles = axleConfiguration[0].numberOfAxles * 10 +
+                axleConfiguration[1].numberOfAxles;
+            weight = policy.getDefaultPowerUnitWeight(vc, powerUnitAxles);
+            const steerAxleDimension = policy.selectCorrectWeightDimension(weight, vehicleConfiguration, axleConfiguration, 0) || {};
+            singleAxleDimensions.push(steerAxleDimension);
+            const driveAxleDimension = policy.selectCorrectWeightDimension(weight, vehicleConfiguration, axleConfiguration, 1) || {};
+            singleAxleDimensions.push(driveAxleDimension);
+        }
+        else {
+            if (i + 1 < axleConfiguration.length) {
+                // We need this guard because the last trailer in a configuration may represent
+                // the pseudo-trailer 'None'; in this case the axleConfiguration length will
+                // be one fewer than normal because the 'None' trailer does not get an axleConfig entry
+                weight = policy.getDefaultTrailerWeight(vc, axleConfiguration[i + 1].numberOfAxles);
+                const trailerDimension = policy.selectCorrectWeightDimension(weight, vehicleConfiguration, axleConfiguration, i + 1) || {};
+                singleAxleDimensions.push(trailerDimension);
+            }
+        }
+    });
+    axleConfiguration.forEach((ac, i) => {
+        const actualWeight = ac.axleUnitWeight;
+        const permittableWeight = singleAxleDimensions[i].permittable || 0;
+        const result = actualWeight <= permittableWeight;
+        const axleUnit = i + 1;
+        const message = `Weight for axle unit ${axleUnit} ${result ? 'is permittable' : `must not exceed ${permittableWeight} kgs`}`;
+        policyCheckResults.push({
+            id: policyId,
+            message: message,
+            result: result ? enum_1.PolicyCheckResultType.Pass : enum_1.PolicyCheckResultType.Fail,
+            axleUnit: axleUnit,
+            actualWeight: actualWeight,
+            thresholdWeight: permittableWeight,
+        });
+    });
+    return policyCheckResults;
+}
+/**
+ * Validates minimum steer axle weight requirements for single steer, tridem drive power units.
+ *
+ * This function checks that the steer axle meets minimum weight requirements when the vehicle
+ * configuration consists of a single steer axle followed by a tridem drive axle. The steer axle
+ * must carry at least 27% of the tridem drive axle weight.
+ *
+ * @param _policy - The policy instance (unused in this check, but required by PolicyCheck type)
+ * @param _vehicleConfiguration - Vehicle configuration (unused in this check, but required by PolicyCheck type)
+ * @param axleConfiguration - Array of axle configurations containing weight and axle count information
+ * @returns Array of AxleGroupPolicyCheckResult objects with validation results
+ *
+ * @example
+ * // For a single steer, tridem drive configuration
+ * const results = CheckMinSteerAxleWeight(policy, ['TRKTRAC'], [
+ *   { numberOfAxles: 1, axleUnitWeight: 8000 },  // Steer axle
+ *   { numberOfAxles: 3, axleUnitWeight: 30000 }  // Tridem drive axle
+ * ]);
+ * // Returns pass if steer axle weight >= 27% of drive axle weight (8100 kgs)
+ *
+ * @see PolicyCheck
+ * @see AxleGroupPolicyCheckResult
+ */
+function CheckMinSteerAxleWeight(_policy, _vehicleConfiguration, axleConfiguration) {
+    const policyCheckResults = new Array();
+    const policyId = enum_1.PolicyCheckId.MinSteerAxleWeight;
+    let message, result;
+    if (axleConfiguration[0].numberOfAxles === 1 &&
+        axleConfiguration[1].numberOfAxles === 3) {
+        // Check minimum load on steer axle
+        if (axleConfiguration[0].axleUnitWeight >=
+            axleConfiguration[1].axleUnitWeight * 0.27) {
+            message = 'Steer axle meets minimum weight requirements';
+            result = enum_1.PolicyCheckResultType.Pass;
+        }
+        else {
+            message =
+                'Steer axle must be a minimum of 27% of tridem drive axle weight';
+            result = enum_1.PolicyCheckResultType.Fail;
+        }
+    }
+    else {
+        // This policy check is only for single steer, tridem drive power units
+        message = 'Policy check does not apply to this configuration';
+        result = enum_1.PolicyCheckResultType.Pass;
+    }
+    policyCheckResults.push({
+        id: policyId,
+        message: message,
+        result: result,
+        startAxleUnit: 1,
+        endAxleUnit: 2,
+    });
+    return policyCheckResults;
+}
+/**
+ * Validates minimum drive axle weight requirements for tandem and tridem drive power units.
+ *
+ * This function checks that the drive axle meets minimum weight requirements based on the
+ * Gross Vehicle Combination Weight (GVCW). For tandem drive axles, the minimum is 20% of GVCW
+ * or 23,000 lbs (whichever is smaller). For tridem drive axles, the minimum is 20% of GVCW
+ * or 28,000 lbs (whichever is smaller).
+ *
+ * @param _policy - The policy instance (unused in this check, but required by PolicyCheck type)
+ * @param _vehicleConfiguration - Vehicle configuration (unused in this check, but required by PolicyCheck type)
+ * @param axleConfiguration - Array of axle configurations containing weight and axle count information
+ * @returns Array of AxleGroupPolicyCheckResult objects with validation results
+ *
+ * @example
+ * // For a tandem drive configuration with GVCW of 120,000 kgs
+ * const results = CheckMinDriveAxleWeight(policy, ['TRKTRAC'], [
+ *   { numberOfAxles: 1, axleUnitWeight: 12000 },  // Steer axle
+ *   { numberOfAxles: 2, axleUnitWeight: 24000 }   // Tandem drive axle
+ * ]);
+ * // Returns pass if drive axle weight >= min(20% of GVCW, 23,000 kgs)
+ *
+ * @see PolicyCheck
+ * @see AxleGroupPolicyCheckResult
+ */
+function CheckMinDriveAxleWeight(_policy, _vehicleConfiguration, axleConfiguration) {
+    const policyCheckResults = new Array();
+    const policyId = enum_1.PolicyCheckId.MinDriveAxleWeight;
+    const gvcw = axleConfiguration.reduce((w, curr) => w + curr.axleUnitWeight, 0);
+    let message, result;
+    if (axleConfiguration[1].numberOfAxles === 2 ||
+        axleConfiguration[1].numberOfAxles === 3) {
+        let targetMinWeight = gvcw * 0.2;
+        if (axleConfiguration[1].numberOfAxles === 2) {
+            targetMinWeight = Math.min(targetMinWeight, 23000);
+        }
+        else if (axleConfiguration[1].numberOfAxles === 3) {
+            targetMinWeight = Math.min(targetMinWeight, 28000);
+        }
+        if (axleConfiguration[1].axleUnitWeight >= targetMinWeight) {
+            message = 'Drive axle meets minimum weight requirements';
+            result = enum_1.PolicyCheckResultType.Pass;
+        }
+        else {
+            message = 'Drive axle must be a minimum 20% of the GVCW';
+            result = enum_1.PolicyCheckResultType.Fail;
+        }
+    }
+    else {
+        // This policy check is only for tandem or tridem drive power units
+        message = 'Policy check does not apply to this configuration';
+        result = enum_1.PolicyCheckResultType.Pass;
+    }
+    policyCheckResults.push({
+        id: policyId,
+        message: message,
+        result: result,
+        startAxleUnit: 1,
+        endAxleUnit: axleConfiguration.length,
+    });
+    return policyCheckResults;
+}
+/**
+ * Map of policy check functions keyed by their corresponding PolicyCheckId.
+ *
+ * This map contains all the registered policy check functions that are executed
+ * by the runAxleCalculation method. Each entry maps a PolicyCheckId to its
+ * corresponding validation function. New policy checks can be added by extending
+ * this map with additional entries.
+ *
+ * Currently includes:
+ * - BridgeFormula: Validates axle groups against bridge formula requirements
+ * - NumberOfWheelsPerAxle: Validates tire count per axle unit
+ *
+ * @see PolicyCheck
+ * @see PolicyCheckId
+ * @see runAxleCalculation
+ */
+exports.policyCheckMap = new Map([
+    [enum_1.PolicyCheckId.BridgeFormula, CheckBridgeFormula],
+    [enum_1.PolicyCheckId.CheckPermittableWeight, CheckPermittableWeight],
+    [enum_1.PolicyCheckId.MinDriveAxleWeight, CheckMinDriveAxleWeight],
+    [enum_1.PolicyCheckId.MinSteerAxleWeight, CheckMinSteerAxleWeight],
+    [enum_1.PolicyCheckId.NumberOfWheelsPerAxle, CheckNumTiresPerAxle],
+]);

package/dist/helper/vehicles.helper.d.ts

@@ -1,4 +1,4 @@
-import { VehicleTypes } from 'onroute-policy-engine/types';
+import { PermitVehicleDetails, VehicleConfiguration, VehicleTypes } from 'onroute-policy-engine/types';
 /**
  * Filters out all LCV vehicles from a supplied list of vehicle IDs.
  * @param vehicleList List of vehicle IDs to filter
@@ -14,3 +14,47 @@ export declare function filterOutLcv(vehicleList: Array<string>, vehicleTypes: V
  * @param type Type of vehicle to filter, either powerUnit or trailer
  */
 export declare function filterVehiclesByType(vehicleList: Array<string>, vehicleTypes: VehicleTypes, type: string): Array<string>;
+/**
+ * Converts detailed vehicle information into a simplified vehicle configuration array.
+ *
+ * This helper function takes the vehicle details (which contain the power unit information) and
+ * the vehicle configuration (which contains trailer information) and combines them into
+ * a single array of vehicle type identifiers. The resulting array represents the complete
+ * vehicle configuration in the order: [powerUnit, trailer1, trailer2, ...].
+ *
+ * @param vehicleDetails - The vehicle details containing power unit information including
+ *                        the vehicle subtype (e.g., 'TRKTRAC' for truck-tractor)
+ * @param vehicleConfiguration - The vehicle configuration containing trailer information
+ *                              and other vehicle configuration details
+ * @returns An array of vehicle type identifiers representing the complete vehicle configuration.
+ *          The first element is always the power unit type, followed by any attached trailer types.
+ *          Returns an empty array if no power unit type is found in vehicle details.
+ *
+ * @example
+ * // For a truck-tractor with a semi-trailer
+ * const config = getSimplifiedVehicleConfigurationHelper(
+ *   { vehicleSubType: 'TRKTRAC', ... },
+ *   { trailers: [{ vehicleSubType: 'SEMITRL' }] }
+ * );
+ * // Returns: ['TRKTRAC', 'SEMITRL']
+ *
+ * @example
+ * // For a single power unit with no trailers
+ * const config = getSimplifiedVehicleConfigurationHelper(
+ *   { vehicleSubType: 'TRKTRAC', ... },
+ *   { trailers: [] }
+ * );
+ * // Returns: ['TRKTRAC']
+ *
+ * @example
+ * // For a power unit with multiple trailers
+ * const config = getSimplifiedVehicleConfigurationHelper(
+ *   { vehicleSubType: 'TRKTRAC', ... },
+ *   { trailers: [
+ *     { vehicleSubType: 'SEMITRL' },
+ *     { vehicleSubType: 'BOOSTER' }
+ *   ]}
+ * );
+ * // Returns: ['TRKTRAC', 'SEMITRL', 'BOOSTER']
+ */
+export declare function getSimplifiedVehicleConfigurationHelper(vehicleDetails: PermitVehicleDetails, vehicleConfiguration: VehicleConfiguration): string[];

package/dist/helper/vehicles.helper.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.filterOutLcv = filterOutLcv;
 exports.filterVehiclesByType = filterVehiclesByType;
+exports.getSimplifiedVehicleConfigurationHelper = getSimplifiedVehicleConfigurationHelper;
 const enum_1 = require("onroute-policy-engine/enum");
 /**
  * Filters out all LCV vehicles from a supplied list of vehicle IDs.
@@ -56,3 +57,63 @@ function filterVehiclesByType(vehicleList, vehicleTypes, type) {
     });
     return filteredVehicles;
 }
+/**
+ * Converts detailed vehicle information into a simplified vehicle configuration array.
+ *
+ * This helper function takes the vehicle details (which contain the power unit information) and
+ * the vehicle configuration (which contains trailer information) and combines them into
+ * a single array of vehicle type identifiers. The resulting array represents the complete
+ * vehicle configuration in the order: [powerUnit, trailer1, trailer2, ...].
+ *
+ * @param vehicleDetails - The vehicle details containing power unit information including
+ *                        the vehicle subtype (e.g., 'TRKTRAC' for truck-tractor)
+ * @param vehicleConfiguration - The vehicle configuration containing trailer information
+ *                              and other vehicle configuration details
+ * @returns An array of vehicle type identifiers representing the complete vehicle configuration.
+ *          The first element is always the power unit type, followed by any attached trailer types.
+ *          Returns an empty array if no power unit type is found in vehicle details.
+ *
+ * @example
+ * // For a truck-tractor with a semi-trailer
+ * const config = getSimplifiedVehicleConfigurationHelper(
+ *   { vehicleSubType: 'TRKTRAC', ... },
+ *   { trailers: [{ vehicleSubType: 'SEMITRL' }] }
+ * );
+ * // Returns: ['TRKTRAC', 'SEMITRL']
+ *
+ * @example
+ * // For a single power unit with no trailers
+ * const config = getSimplifiedVehicleConfigurationHelper(
+ *   { vehicleSubType: 'TRKTRAC', ... },
+ *   { trailers: [] }
+ * );
+ * // Returns: ['TRKTRAC']
+ *
+ * @example
+ * // For a power unit with multiple trailers
+ * const config = getSimplifiedVehicleConfigurationHelper(
+ *   { vehicleSubType: 'TRKTRAC', ... },
+ *   { trailers: [
+ *     { vehicleSubType: 'SEMITRL' },
+ *     { vehicleSubType: 'BOOSTER' }
+ *   ]}
+ * );
+ * // Returns: ['TRKTRAC', 'SEMITRL', 'BOOSTER']
+ */
+function getSimplifiedVehicleConfigurationHelper(vehicleDetails, vehicleConfiguration) {
+    // Retrieve the power unit type from vehicle details
+    const powerUnitType = vehicleDetails.vehicleSubType;
+    // Retrieve the list of trailers from configuration
+    const trailerList = vehicleConfiguration.trailers || [];
+    // If no power unit type is found, return empty array
+    if (!powerUnitType) {
+        return [];
+    }
+    // Start with the power unit type as the base configuration
+    const fullVehicleConfiguration = [powerUnitType];
+    // Add any attached trailers to the configuration
+    if (trailerList) {
+        fullVehicleConfiguration.push(...trailerList.map((t) => t.vehicleSubType));
+    }
+    return fullVehicleConfiguration;
+}

package/dist/policy-engine.d.ts

@@ -1,4 +1,4 @@
-import { PolicyDefinition, PermitType, Commodity, VehicleType, SizeDimension, AxleConfiguration, BridgeCalculationResult, ConditionForPermit, TrailerType, PowerUnitType, TrailerWeightDimension, PowerUnitWeightDimension, WeightDimension, SingleAxleDimension, StandardTireSize, TrailerDimensions } from 'onroute-policy-engine/types';
+import { PolicyDefinition, PermitType, Commodity, VehicleType, SizeDimension, AxleConfiguration, BridgeCalculationResult, ConditionForPermit, TrailerType, PowerUnitType, TrailerWeightDimension, PowerUnitWeightDimension, WeightDimension, SingleAxleDimension, StandardTireSize, TrailerDimensions, AxleCalcResults, PermitVehicleDetails, VehicleConfiguration } from 'onroute-policy-engine/types';
 import { Engine } from 'json-rules-engine';
 import { ValidationResults } from './validation-results';
 import { SpecialAuthorizations } from './types/special-authorizations';
@@ -186,6 +186,42 @@ export declare class Policy {
      * axle group in the vehicle configuration
      */
     calculateBridge(axleConfig: Array<AxleConfiguration>): Array<BridgeCalculationResult>;
+    /**
+     * Runs all configured axle calculation policy checks against a vehicle configuration.
+     *
+     * This method iterates through all registered policy check functions (such as bridge formula
+     * calculations and tire count validations) and applies them to the provided vehicle and axle
+     * configurations. The results are aggregated into a single AxleCalcResults object containing
+     * all policy check outcomes and a total overload calculation.
+     *
+     * @param vehicleConfiguration Array of vehicle type identifiers representing the vehicle configuration.
+     *                            The first element should be a power unit type, followed by trailer types.
+     *                            Example: ['TRKTRAC', 'SEMITRL'] for a truck tractor with semi-trailer.
+     * @param axleConfiguration Array of axle configurations corresponding to each vehicle in the configuration.
+     *                          Each axle configuration contains details like number of axles, spacing, tire count, etc.
+     *                          The length should match the vehicleConfiguration array plus one (since the first
+     *                          vehicle in the configuration is a power unit with two axle units).
+     * @returns AxleCalcResults object containing:
+     *          - results: Array of PolicyCheckResult objects, each representing the outcome of a specific policy check
+     *          - totalOverload: Numeric value representing the total overload across all axle calculations
+     *
+     * @example
+     * // For a truck-tractor with 2-axle steer, 3-axle drive, and a 3-axle semi-trailer
+     * const results = policy.runAxleCalculation(
+     *   ['TRKTRAC', 'SEMITRL'],
+     *   [
+     *     { numberOfAxles: 2, axleSpread: 1.8, numberOfTires: 4 },
+     *     { numberOfAxles: 3, axleSpread: 4.2, numberOfTires: 12 },
+     *     { numberOfAxles: 3, axleSpread: 3.0, numberOfTires: 12 }
+     *   ]
+     * );
+     * // Returns results with bridge formula checks, tire count validations, etc.
+     *
+     * @see AxleCalcResults
+     * @see PolicyCheckResult
+     * @see AxleConfiguration
+     */
+    runAxleCalculation(vehicleConfiguration: Array<string>, axleConfiguration: Array<AxleConfiguration>): AxleCalcResults;
     /**
      * Gets the list of allowed vehicles separated into two maps, one
      * for trailers and one for power units. This will filter out LCV
@@ -271,4 +307,37 @@ export declare class Policy {
      * @throws {Error} If vehicleDisplayCodeDefaults is not configured in the policy definition.
      */
     getVehicleDisplayCode(configuration: Array<string>, axleConfiguration: Array<AxleConfiguration>): string;
+    /**
+     * Converts detailed vehicle information into a simplified vehicle configuration array.
+     *
+     * This method takes the vehicle details (which contain the power unit information) and
+     * the vehicle configuration (which contains trailer information) and combines them into
+     * a single array of vehicle type identifiers. The resulting array represents the complete
+     * vehicle configuration in the order: [powerUnit, trailer1, trailer2, ...].
+     *
+     * @param vehicleDetails - The vehicle details containing power unit information including
+     *                        the vehicle subtype (e.g., 'TRKTRAC' for truck-tractor)
+     * @param vehicleConfiguration - The vehicle configuration containing trailer information
+     *                              and other vehicle configuration details
+     * @returns An array of vehicle type identifiers representing the complete vehicle configuration.
+     *          The first element is always the power unit type, followed by any attached trailer types.
+     *          Returns an empty array if no power unit type is found in vehicle details.
+     *
+     * @example
+     * // For a truck-tractor with a semi-trailer
+     * const config = policy.getSimplifiedVehicleConfiguration(
+     *   { vehicleSubType: 'TRKTRAC', ... },
+     *   { trailers: [{ vehicleSubType: 'SEMITRL' }] }
+     * );
+     * // Returns: ['TRKTRAC', 'SEMITRL']
+     *
+     * @example
+     * // For a single power unit with no trailers
+     * const config = policy.getSimplifiedVehicleConfiguration(
+     *   { vehicleSubType: 'TRKTRAC', ... },
+     *   { trailers: [] }
+     * );
+     * // Returns: ['TRKTRAC']
+     */
+    getSimplifiedVehicleConfiguration(vehicleDetails: PermitVehicleDetails, vehicleConfiguration: VehicleConfiguration): string[];
 }

package/dist/policy-engine.js

@@ -20,6 +20,7 @@ const conditions_helper_1 = require("./helper/conditions.helper");
 const dimensions_helper_1 = require("./helper/dimensions.helper");
 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");
 /** Class representing commercial vehicle policy. */
 class Policy {
     /**
@@ -657,6 +658,48 @@ class Policy {
         }
         return bridgeResults;
     }
+    /**
+     * Runs all configured axle calculation policy checks against a vehicle configuration.
+     *
+     * This method iterates through all registered policy check functions (such as bridge formula
+     * calculations and tire count validations) and applies them to the provided vehicle and axle
+     * configurations. The results are aggregated into a single AxleCalcResults object containing
+     * all policy check outcomes and a total overload calculation.
+     *
+     * @param vehicleConfiguration Array of vehicle type identifiers representing the vehicle configuration.
+     *                            The first element should be a power unit type, followed by trailer types.
+     *                            Example: ['TRKTRAC', 'SEMITRL'] for a truck tractor with semi-trailer.
+     * @param axleConfiguration Array of axle configurations corresponding to each vehicle in the configuration.
+     *                          Each axle configuration contains details like number of axles, spacing, tire count, etc.
+     *                          The length should match the vehicleConfiguration array plus one (since the first
+     *                          vehicle in the configuration is a power unit with two axle units).
+     * @returns AxleCalcResults object containing:
+     *          - results: Array of PolicyCheckResult objects, each representing the outcome of a specific policy check
+     *          - totalOverload: Numeric value representing the total overload across all axle calculations
+     *
+     * @example
+     * // For a truck-tractor with 2-axle steer, 3-axle drive, and a 3-axle semi-trailer
+     * const results = policy.runAxleCalculation(
+     *   ['TRKTRAC', 'SEMITRL'],
+     *   [
+     *     { numberOfAxles: 2, axleSpread: 1.8, numberOfTires: 4 },
+     *     { numberOfAxles: 3, axleSpread: 4.2, numberOfTires: 12 },
+     *     { numberOfAxles: 3, axleSpread: 3.0, numberOfTires: 12 }
+     *   ]
+     * );
+     * // Returns results with bridge formula checks, tire count validations, etc.
+     *
+     * @see AxleCalcResults
+     * @see PolicyCheckResult
+     * @see AxleConfiguration
+     */
+    runAxleCalculation(vehicleConfiguration, axleConfiguration) {
+        const axleCalcResults = { results: [], totalOverload: 0 };
+        for (const [, func] of policy_check_helper_1.policyCheckMap) {
+            axleCalcResults.results.push(...func(this, vehicleConfiguration, axleConfiguration));
+        }
+        return axleCalcResults;
+    }
     /**
      * Gets the list of allowed vehicles separated into two maps, one
      * for trailers and one for power units. This will filter out LCV
@@ -777,5 +820,40 @@ class Policy {
     getVehicleDisplayCode(configuration, axleConfiguration) {
         return (0, display_code_helper_1.getVehicleDisplayCodeHelper)(this, configuration, axleConfiguration);
     }
+    /**
+     * Converts detailed vehicle information into a simplified vehicle configuration array.
+     *
+     * This method takes the vehicle details (which contain the power unit information) and
+     * the vehicle configuration (which contains trailer information) and combines them into
+     * a single array of vehicle type identifiers. The resulting array represents the complete
+     * vehicle configuration in the order: [powerUnit, trailer1, trailer2, ...].
+     *
+     * @param vehicleDetails - The vehicle details containing power unit information including
+     *                        the vehicle subtype (e.g., 'TRKTRAC' for truck-tractor)
+     * @param vehicleConfiguration - The vehicle configuration containing trailer information
+     *                              and other vehicle configuration details
+     * @returns An array of vehicle type identifiers representing the complete vehicle configuration.
+     *          The first element is always the power unit type, followed by any attached trailer types.
+     *          Returns an empty array if no power unit type is found in vehicle details.
+     *
+     * @example
+     * // For a truck-tractor with a semi-trailer
+     * const config = policy.getSimplifiedVehicleConfiguration(
+     *   { vehicleSubType: 'TRKTRAC', ... },
+     *   { trailers: [{ vehicleSubType: 'SEMITRL' }] }
+     * );
+     * // Returns: ['TRKTRAC', 'SEMITRL']
+     *
+     * @example
+     * // For a single power unit with no trailers
+     * const config = policy.getSimplifiedVehicleConfiguration(
+     *   { vehicleSubType: 'TRKTRAC', ... },
+     *   { trailers: [] }
+     * );
+     * // Returns: ['TRKTRAC']
+     */
+    getSimplifiedVehicleConfiguration(vehicleDetails, vehicleConfiguration) {
+        return (0, vehicles_helper_1.getSimplifiedVehicleConfigurationHelper)(vehicleDetails, vehicleConfiguration);
+    }
 }
 exports.Policy = Policy;

package/dist/rule-operator/custom-operators.d.ts

@@ -1,3 +1,10 @@
+/**
+ * Custom Operators for JSON Rules Engine
+ *
+ * This module defines custom operators that extend the functionality of the json-rules-engine
+ * library. These operators provide specialized validation and comparison logic for the
+ * onRouteBC policy engine.
+ */
 import { Operator } from 'json-rules-engine';
 declare const CustomOperators: Array<Operator>;
 export { CustomOperators };