onroute-policy-engine 2.35.1 → 2.36.0

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

@@ -1,4 +1,28 @@
+import { Policy } from '../policy-engine';
 import { AxleConfiguration } from '../types/axle-configuration';
 import { InteraxleSpacingRequirement } from '../types/interaxle-spacing-requirement';
 export declare function getFailedInteraxleSpacingMessage(requirement: InteraxleSpacingRequirement, previousAxleUnitNumber: number, currentAxleUnitNumber: number): string;
-export declare function getInteraxleSpacingRequirement(axleConfiguration: Array<AxleConfiguration>, axleIndex: number, vehicleConfiguration: Array<string>, axleUnitVehicleIndexes: Array<number>): InteraxleSpacingRequirement | undefined;
+/**
+ * Resolves the legal interaxle spacing requirement for a given axle pair.
+ * Uses the configured policy defaults for the vehicle subtype, falling back to
+ * the global default for the matching axle combination when no subtype-specific
+ * override exists.
+ * @param policy The instantiated policy object with interaxle spacing configuration
+ * @param axleConfiguration Full axle configuration for the vehicle combination
+ * @param axleIndex Index of the current axle unit being evaluated
+ * @param vehicleConfiguration Array of vehicle IDs in sequence for the combination
+ * @param axleUnitVehicleIndexes Mapping of each axle unit to its parent vehicle
+ * @returns The minimum/maximum interaxle spacing requirement for the current axle pair, or undefined when no spacing rule applies
+ */
+export declare function getInteraxleSpacingRequirement(policy: Policy, axleConfiguration: Array<AxleConfiguration>, axleIndex: number, vehicleConfiguration: Array<string>, axleUnitVehicleIndexes: Array<number>): InteraxleSpacingRequirement | undefined;
+/**
+ * Helper function for getting the default interaxle spacing value,
+ * works for both power units and trailers based on the
+ * value of the isPowerUnit flag.
+ * @param policy The instantiated policy object with weight config
+ * @param subType Power Unit or Trailer subtype
+ * @param axles 2-digit numner representing the two axle units to which this requirement applies. The number of with the most significant digit representing the current axle unit and the least significant digit representing the next axle unit.
+ * @param isPowerUnit Whether this vehicle is a power unit
+ * @returns Array of interaxle spacing specifications
+ */
+export declare function getDefaultInteraxleSpacingHelper(policy: Policy, subType: string, axles: number, isPowerUnit: boolean): InteraxleSpacingRequirement;

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

@@ -2,19 +2,10 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getFailedInteraxleSpacingMessage = getFailedInteraxleSpacingMessage;
 exports.getInteraxleSpacingRequirement = getInteraxleSpacingRequirement;
-const interaxle_spacing_legal_minimums_1 = require("../constants/interaxle-spacing-legal-minimums");
-const trailer_codes_1 = require("../constants/trailer-codes");
-const axle_unit_type_1 = require("../types/axle-unit-type");
+exports.getDefaultInteraxleSpacingHelper = getDefaultInteraxleSpacingHelper;
+const power_unit_axle_code_multiplier_1 = require("../constants/power-unit-axle-code-multiplier");
 const format_meters_helper_1 = require("./format-meters.helper");
 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.`;
     }
@@ -23,32 +14,89 @@ function getFailedInteraxleSpacingMessage(requirement, previousAxleUnitNumber, c
     }
     return '';
 }
-function getInteraxleSpacingRequirement(axleConfiguration, axleIndex, vehicleConfiguration, axleUnitVehicleIndexes) {
+/**
+ * Resolves the legal interaxle spacing requirement for a given axle pair.
+ * Uses the configured policy defaults for the vehicle subtype, falling back to
+ * the global default for the matching axle combination when no subtype-specific
+ * override exists.
+ * @param policy The instantiated policy object with interaxle spacing configuration
+ * @param axleConfiguration Full axle configuration for the vehicle combination
+ * @param axleIndex Index of the current axle unit being evaluated
+ * @param vehicleConfiguration Array of vehicle IDs in sequence for the combination
+ * @param axleUnitVehicleIndexes Mapping of each axle unit to its parent vehicle
+ * @returns The minimum/maximum interaxle spacing requirement for the current axle pair, or undefined when no spacing rule applies
+ */
+function getInteraxleSpacingRequirement(policy, axleConfiguration, axleIndex, vehicleConfiguration, axleUnitVehicleIndexes) {
     // the first axle unit will never have an interaxle spacing value or previous axle unit to compare against
     if (axleIndex === 0) {
         return undefined;
     }
-    const axleUnit = axleConfiguration[axleIndex];
+    const currentAxleUnit = axleConfiguration[axleIndex];
     const previousAxleUnit = axleConfiguration[axleIndex - 1];
-    if (!Number.isFinite(axleUnit.interaxleSpacing) ||
+    const vehicleIndex = axleUnitVehicleIndexes[axleIndex];
+    const vehicleType = vehicleConfiguration[vehicleIndex];
+    const isPowerUnit = vehicleIndex === 0;
+    if (!Number.isFinite(currentAxleUnit.interaxleSpacing) ||
         !Number.isFinite(previousAxleUnit.numberOfAxles)) {
         return undefined;
     }
-    const previousAxleUnitType = (0, axle_unit_type_1.getAxleUnitType)(previousAxleUnit.numberOfAxles);
-    const currentAxleUnitType = (0, axle_unit_type_1.getAxleUnitType)(axleUnit.numberOfAxles);
-    const vehicleIndex = axleUnitVehicleIndexes[axleIndex];
-    const vehicleType = vehicleConfiguration[vehicleIndex];
-    const isSingleAxleJeep = vehicleType === trailer_codes_1.TRAILER_CODES.JEEPS &&
-        (0, axle_unit_type_1.getAxleUnitType)(axleConfiguration[2].numberOfAxles) === 'SINGLE';
-    const isTandemDrive = (0, axle_unit_type_1.getAxleUnitType)(axleConfiguration[1].numberOfAxles) === 'TANDEM';
-    // Tandem Drive with Single Axle Jeep Bridge Formula Exception
-    if (isSingleAxleJeep && isTandemDrive) {
-        return {
-            min: 120,
-            max: 350,
-        };
-    }
-    return {
-        min: interaxle_spacing_legal_minimums_1.INTERAXLE_SPACING_LEGAL_MINIMUMS[previousAxleUnitType][currentAxleUnitType],
-    };
+    const axles = previousAxleUnit.numberOfAxles * power_unit_axle_code_multiplier_1.POWER_UNIT_AXLE_CODE_MULTIPLIER +
+        currentAxleUnit.numberOfAxles;
+    // NOTE: This intentionally resolves to a single requirement for the current
+    // axle pair. This mirrors the current simple lookup pattern, but if modifier-
+    // based interaxle spacing rules are introduced later, this should follow the
+    // same selection pattern used by CheckLegalWeight via
+    // selectCorrectWeightDimensionHelper, which chooses the correct candidate
+    // before applying the min/max threshold. We may also eventually start using
+    // legalMin/legalMax/permittableMin/permittableMax fields in this contract.
+    const requirement = isPowerUnit
+        ? policy.getDefaultPowerUnitInteraxleSpacing(vehicleType, axles)
+        : policy.getDefaultTrailerInteraxleSpacing(vehicleType, axles);
+    // Defensive compatibility guard for older callers that may still hand us an
+    // array-shaped requirement. The validator expects a single object.
+    return Array.isArray(requirement) ? requirement[0] : requirement;
+}
+/**
+ * Helper function for getting the default interaxle spacing value,
+ * works for both power units and trailers based on the
+ * value of the isPowerUnit flag.
+ * @param policy The instantiated policy object with weight config
+ * @param subType Power Unit or Trailer subtype
+ * @param axles 2-digit numner representing the two axle units to which this requirement applies. The number of with the most significant digit representing the current axle unit and the least significant digit representing the next axle unit.
+ * @param isPowerUnit Whether this vehicle is a power unit
+ * @returns Array of interaxle spacing specifications
+ */
+function getDefaultInteraxleSpacingHelper(policy, subType, axles, isPowerUnit) {
+    var _a, _b, _c, _d;
+    const vehicleDefinition = isPowerUnit
+        ? policy.getPowerUnitDefinition(subType)
+        : policy.getTrailerDefinition(subType);
+    if (!vehicleDefinition) {
+        throw new Error(`No definition found for vehicle type '${subType}'`);
+    }
+    // Prefer specific power unit / trailer subtype interaxle spacing.
+    // The config stores these as arrays, but validation expects a single
+    // requirement object for the current axle pair.
+    const interaxleSpacings = (_a = vehicleDefinition.interaxleSpacings) === null || _a === void 0 ? void 0 : _a.filter((exception) => exception.axles === axles);
+    if (interaxleSpacings && interaxleSpacings.length > 0) {
+        return JSON.parse(JSON.stringify(interaxleSpacings[0]));
+    }
+    // Second preference is category interaxle spacing.
+    const vehicleCategories = isPowerUnit
+        ? (_b = policy.policyDefinition.vehicleCategories) === null || _b === void 0 ? void 0 : _b.powerUnitCategories
+        : (_c = policy.policyDefinition.vehicleCategories) === null || _c === void 0 ? void 0 : _c.trailerCategories;
+    const vehicleCategory = vehicleCategories === null || vehicleCategories === void 0 ? void 0 : vehicleCategories.find((c) => c.id === vehicleDefinition.category);
+    if (vehicleCategory) {
+        const overridesForAxle = (_d = vehicleCategory.interaxleSpacings) === null || _d === void 0 ? void 0 : _d.filter((override) => override.axles === axles);
+        if (overridesForAxle && overridesForAxle.length > 0) {
+            return JSON.parse(JSON.stringify(overridesForAxle[0]));
+        }
+    }
+    // Least preference is global interaxle defaults.
+    const globalDefaults = policy.policyDefinition.globalInteraxleSpacingDefaults;
+    const vehicleDefaults = globalDefaults === null || globalDefaults === void 0 ? void 0 : globalDefaults.filter((specification) => specification.axles === axles);
+    if (vehicleDefaults && vehicleDefaults.length > 0) {
+        return JSON.parse(JSON.stringify(vehicleDefaults[0]));
+    }
+    return {};
 }

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

@@ -1180,24 +1180,24 @@ function CheckLegalInteraxleSpacing(policy, vehicleConfiguration, axleConfigurat
     const policyId = enum_1.PolicyCheckId.LegalInteraxleSpacing;
     const axleUnitVehicleIndexes = (0, dimensions_helper_1.getAxleUnitVehicleIndexLookup)(policy, vehicleConfiguration, axleConfiguration);
     return axleConfiguration.map((axleUnit, axleIndex) => {
-        const requirement = (0, interaxle_spacing_helper_1.getInteraxleSpacingRequirement)(axleConfiguration, axleIndex, vehicleConfiguration, axleUnitVehicleIndexes);
+        const requirement = (0, interaxle_spacing_helper_1.getInteraxleSpacingRequirement)(policy, axleConfiguration, axleIndex, vehicleConfiguration, axleUnitVehicleIndexes);
         // Pass when no requirement exists, interaxle spacing is missing, or interaxle spacing falls within the requirement's min/max bounds.
         const shouldPass = !requirement ||
             !axleUnit.interaxleSpacing ||
             ((!requirement.min || axleUnit.interaxleSpacing >= requirement.min) &&
                 (!requirement.max || axleUnit.interaxleSpacing <= requirement.max));
-        const axleUnitNumber = axleIndex + 1;
+        const currentAxleUnitNumber = axleIndex + 1;
         const previousAxleUnitNumber = axleIndex;
         const message = shouldPass
             ? ''
-            : (0, interaxle_spacing_helper_1.getFailedInteraxleSpacingMessage)(requirement, previousAxleUnitNumber, axleUnitNumber);
+            : (0, interaxle_spacing_helper_1.getFailedInteraxleSpacingMessage)(requirement, previousAxleUnitNumber, currentAxleUnitNumber);
         return {
             id: policyId,
             message,
             result: shouldPass
                 ? enum_1.PolicyCheckResultType.Pass
                 : enum_1.PolicyCheckResultType.Fail,
-            axleUnit: axleUnitNumber,
+            axleUnit: currentAxleUnitNumber,
         };
     });
 }

package/dist/policy-engine.d.ts

@@ -2,6 +2,7 @@ import { PolicyDefinition, PermitType, Commodity, VehicleType, SizeDimension, Ax
 import { Engine } from 'json-rules-engine';
 import { ValidationResults } from './validation-results';
 import { SpecialAuthorizations } from './types/special-authorizations';
+import { InteraxleSpacingRequirement } from './types/interaxle-spacing-requirement';
 /** Class representing commercial vehicle policy. */
 export declare class Policy {
     /** Object representation of policy definition and rules. */
@@ -259,6 +260,36 @@ export declare class Policy {
      * if the number of axles is not configured in policy.
      */
     getDefaultPowerUnitWeight(subType: string, axles: number): Array<PowerUnitWeightDimension>;
+    /**
+     * Gets the default legal and permittable weights for a
+     * given power unit type and number of axles. The number of
+     * axles is supplied as a 2-digit number, with the most
+     * significant digit representing the current (steer) axle unit and the
+     * least significant digit representing the next (drive) axle unit.
+     * @param subType Power unit subtype
+     * @param axles Number of axles in the power unit axle units
+     * @returns Array of power unit weights. Multiple power unit
+     * weights may be returned if there are different weights
+     * depending on prior / subsequent vehicles in the
+     * configuration (weight modifiers). Will return an empty array
+     * if the number of axles is not configured in policy.
+     */
+    getDefaultPowerUnitInteraxleSpacing(subType: string, axles: number): InteraxleSpacingRequirement;
+    /**
+     * Gets the default legal and permittable weights for a
+     * given trailer type and number of axles. The number of
+     * axles is supplied as a 2-digit number, with the most
+     * significant digit representing the current axle unit and the
+     * least significant digit representing the next axle unit.
+     * @param subType Trailer subtype
+     * @param axles Number of axles in the trailer axle units
+     * @returns Array of trailer weights. Multiple trailer
+     * weights may be returned if there are different weights
+     * depending on prior / subsequent vehicles in the
+     * configuration (weight modifiers). Will return an empty array
+     * if the number of axles is not configured in policy.
+     */
+    getDefaultTrailerInteraxleSpacing(subType: string, axles: number): InteraxleSpacingRequirement;
     /**
      * Given a list of default weight dimensions and a vehicle
      * configuration, select the correct weight dimensions for

package/dist/policy-engine.js

@@ -24,6 +24,7 @@ const policy_check_helper_1 = require("./helper/policy-check.helper");
 const cost_1 = require("./constants/cost");
 const overload_helper_1 = require("./helper/overload.helper");
 const permit_codes_1 = require("./constants/permit-codes");
+const interaxle_spacing_helper_1 = require("./helper/interaxle-spacing.helper");
 /** Class representing commercial vehicle policy. */
 class Policy {
     /**
@@ -818,6 +819,40 @@ class Policy {
     getDefaultPowerUnitWeight(subType, axles) {
         return (0, dimensions_helper_2.getDefaultPowerUnitWeightHelper)(this, subType, axles);
     }
+    /**
+     * Gets the default legal and permittable weights for a
+     * given power unit type and number of axles. The number of
+     * axles is supplied as a 2-digit number, with the most
+     * significant digit representing the current (steer) axle unit and the
+     * least significant digit representing the next (drive) axle unit.
+     * @param subType Power unit subtype
+     * @param axles Number of axles in the power unit axle units
+     * @returns Array of power unit weights. Multiple power unit
+     * weights may be returned if there are different weights
+     * depending on prior / subsequent vehicles in the
+     * configuration (weight modifiers). Will return an empty array
+     * if the number of axles is not configured in policy.
+     */
+    getDefaultPowerUnitInteraxleSpacing(subType, axles) {
+        return (0, interaxle_spacing_helper_1.getDefaultInteraxleSpacingHelper)(this, subType, axles, true);
+    }
+    /**
+     * Gets the default legal and permittable weights for a
+     * given trailer type and number of axles. The number of
+     * axles is supplied as a 2-digit number, with the most
+     * significant digit representing the current axle unit and the
+     * least significant digit representing the next axle unit.
+     * @param subType Trailer subtype
+     * @param axles Number of axles in the trailer axle units
+     * @returns Array of trailer weights. Multiple trailer
+     * weights may be returned if there are different weights
+     * depending on prior / subsequent vehicles in the
+     * configuration (weight modifiers). Will return an empty array
+     * if the number of axles is not configured in policy.
+     */
+    getDefaultTrailerInteraxleSpacing(subType, axles) {
+        return (0, interaxle_spacing_helper_1.getDefaultInteraxleSpacingHelper)(this, subType, axles, false);
+    }
     /**
      * Given a list of default weight dimensions and a vehicle
      * configuration, select the correct weight dimensions for

package/dist/types/index.d.ts

@@ -23,3 +23,4 @@ export type { VehicleCategory, PowerUnitCategory, TrailerCategory, VehicleCatego
 export type { VehicleType, PowerUnitType, TrailerType, VehicleTypes, } from './vehicle-type';
 export type { TrailerDimensions, Vehicle, VehicleDimensions } from './vehicle';
 export type { WeightDimension, PowerUnitWeightDimension, TrailerWeightDimension, DefaultWeightDimensions, SingleAxleDimension, } from './weight-dimension';
+export type { InteraxleSpacingRequirement } from './interaxle-spacing-requirement';

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

@@ -1,5 +1,16 @@
-export interface InteraxleSpacingRequirement {
+import { DimensionModifier } from './dimension-modifier';
+import { SelfIssuable } from './self-issuable';
+/**
+ * Base interaxle spacing requirement with axle count and modifier
+ * Extends SelfIssuable to include self-issuance capability
+ */
+export type InteraxleSpacingRequirement = SelfIssuable & {
+    /** Number of axles applicable to this requirement */
+    axles: number;
+    /** The minimum interaxle spacing value (optional) */
     min?: number;
+    /** The maximum interaxle spacing value (optional) */
     max?: number;
-    groupLabel?: string;
-}
+    /** Dimension modifier for special configurations (optional) */
+    modifier?: DimensionModifier;
+};

package/dist/types/policy-definition.d.ts

@@ -7,6 +7,7 @@
  */
 import { GeographicRegion, PermitType, DefaultWeightDimensions, VehicleTypes, Commodity, SizeDimension, VehicleCategories, RangeMatrix, BridgeCalculationConstants, PermitConditionDefinition, StandardTireSize, VehicleDisplayCodeDefaults } from 'onroute-policy-engine/types';
 import { RuleProperties } from 'json-rules-engine';
+import { InteraxleSpacingRequirement } from './interaxle-spacing-requirement';
 /**
  * Complete policy definition containing all configuration data for the policy engine
  */
@@ -23,6 +24,8 @@ export type PolicyDefinition = {
     globalWeightDefaults: DefaultWeightDimensions;
     /** Global default size dimensions for vehicles */
     globalSizeDefaults: SizeDimension;
+    /** Global default interaxle spacing values for vehicles */
+    globalInteraxleSpacingDefaults: InteraxleSpacingRequirement[];
     /** Vehicle categories configuration */
     vehicleCategories: VehicleCategories;
     /** Vehicle types configuration */

package/dist/types/vehicle-category.d.ts

@@ -4,7 +4,7 @@
  * Defines the structure for vehicle categories including power units and trailers.
  * Extends IdentifiedObject with size and weight dimension defaults.
  */
-import { IdentifiedObject, SizeDimension, PowerUnitWeightDimension, TrailerWeightDimension, WeightDimension } from 'onroute-policy-engine/types';
+import { IdentifiedObject, SizeDimension, PowerUnitWeightDimension, TrailerWeightDimension, WeightDimension, InteraxleSpacingRequirement } from 'onroute-policy-engine/types';
 /**
  * Base vehicle category with identification and default dimensions
  * Extends IdentifiedObject with dimension defaults
@@ -14,6 +14,8 @@ export type VehicleCategory = IdentifiedObject & {
     defaultSizeDimensions?: SizeDimension;
     /** Default weight dimensions for this vehicle category (optional) */
     defaultWeightDimensions?: Array<WeightDimension>;
+    /** Interaxle spacing values for this vehicle category (optional) */
+    interaxleSpacings?: Array<InteraxleSpacingRequirement>;
 };
 /**
  * Power unit category with power unit specific weight dimensions

package/dist/types/vehicle-type.d.ts

@@ -4,7 +4,7 @@
  * Defines the structure for vehicle types including power units and trailers.
  * Extends IdentifiedObject with category, dimensions, and special configurations.
  */
-import { ConditionRequirement, IdentifiedObject, SizeDimension, PowerUnitWeightDimension, TrailerWeightDimension } from 'onroute-policy-engine/types';
+import { ConditionRequirement, IdentifiedObject, SizeDimension, PowerUnitWeightDimension, TrailerWeightDimension, InteraxleSpacingRequirement } from 'onroute-policy-engine/types';
 /**
  * Base vehicle type with identification and configuration options
  * Extends IdentifiedObject with vehicle-specific properties
@@ -24,6 +24,8 @@ export type VehicleType = IdentifiedObject & {
     conditions?: Array<ConditionRequirement>;
     /** Additional axle subtype identifier (optional) */
     additionalAxleSubType?: string;
+    /** Specfic interaxle spacing values for this vehicle type (optional) */
+    interaxleSpacings?: InteraxleSpacingRequirement[];
 };
 /**
  * Power unit type with power unit specific configurations

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const version = "v2.35.1";
+export declare const version = "v2.36.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.35.1';
+exports.version = 'v2.36.0';

package/package.json

@@ -91,5 +91,5 @@
     ],
     "testEnvironment": "node"
   },
-  "version": "v2.35.1"
+  "version": "v2.36.0"
 }

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

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

@@ -1,20 +0,0 @@
-"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,
-    },
-};