onroute-policy-engine 2.15.0 → 2.17.0

package/dist/enum/facts.d.ts

@@ -1,5 +1,6 @@
 export declare enum PolicyFacts {
     AllowedVehicles = "allowedVehicles",
+    AxleCalcResults = "axleCalcResults",
     AxleCalcViolations = "axleCalcViolations",
     ConfigurationIsValid = "configurationIsValid",
     DaysBetween = "daysBetween",

package/dist/enum/facts.js

@@ -4,6 +4,7 @@ exports.CostFacts = exports.PolicyFacts = void 0;
 var PolicyFacts;
 (function (PolicyFacts) {
     PolicyFacts["AllowedVehicles"] = "allowedVehicles";
+    PolicyFacts["AxleCalcResults"] = "axleCalcResults";
     PolicyFacts["AxleCalcViolations"] = "axleCalcViolations";
     PolicyFacts["ConfigurationIsValid"] = "configurationIsValid";
     PolicyFacts["DaysBetween"] = "daysBetween";

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

@@ -13,5 +13,6 @@ export declare enum PolicyCheckId {
     MinTandemSteerAxleWeight = "minimum-tandem-steer-axle-weight",
     NumberOfAxles = "number-of-axles",
     NumberOfWheelsPerAxle = "number-of-wheels",
+    PickerTruckTractorWeightRestrictions = "picker-truck-tractor-weight-restrictions",
     TruckTractorWheelbase = "truck-tractor-wheelbase"
 }

package/dist/enum/policy-check.js

@@ -18,5 +18,6 @@ var PolicyCheckId;
     PolicyCheckId["MinTandemSteerAxleWeight"] = "minimum-tandem-steer-axle-weight";
     PolicyCheckId["NumberOfAxles"] = "number-of-axles";
     PolicyCheckId["NumberOfWheelsPerAxle"] = "number-of-wheels";
+    PolicyCheckId["PickerTruckTractorWeightRestrictions"] = "picker-truck-tractor-weight-restrictions";
     PolicyCheckId["TruckTractorWheelbase"] = "truck-tractor-wheelbase";
 })(PolicyCheckId || (exports.PolicyCheckId = PolicyCheckId = {}));

package/dist/helper/facts.helper.js

@@ -9,6 +9,25 @@ const quarterOfYear_1 = __importDefault(require("dayjs/plugin/quarterOfYear"));
 const enum_1 = require("onroute-policy-engine/enum");
 const policy_check_helper_1 = require("./policy-check.helper");
 dayjs_1.default.extend(quarterOfYear_1.default);
+const AXLE_CALC_RESULTS_FACT = 'axleCalcResults';
+const getAxleCalculationInputs = async (policy, almanac) => {
+    var _a, _b;
+    const vehicleDetails = await almanac.factValue(enum_1.PermitAppInfo.PermitData, {}, enum_1.PermitAppInfo.VehicleDetails);
+    const vehicleConfigurationData = await almanac.factValue(enum_1.PermitAppInfo.PermitData, {}, enum_1.PermitAppInfo.VehicleConfiguration);
+    const vehicleConfiguration = policy.getSimplifiedVehicleConfiguration(vehicleDetails, vehicleConfigurationData);
+    const powerUnitAxleConfiguration = (_a = vehicleConfigurationData === null || vehicleConfigurationData === void 0 ? void 0 : vehicleConfigurationData.axleConfiguration) !== null && _a !== void 0 ? _a : [];
+    const trailers = (_b = vehicleConfigurationData === null || vehicleConfigurationData === void 0 ? void 0 : vehicleConfigurationData.trailers) !== null && _b !== void 0 ? _b : [];
+    const hasNestedTrailerAxleConfiguration = trailers.some((trailer) => Array.isArray(trailer.axleConfiguration) &&
+        trailer.axleConfiguration.length > 0);
+    const axleConfiguration = hasNestedTrailerAxleConfiguration
+        ? policy.combineAxleConfigurations(powerUnitAxleConfiguration, trailers)
+        : powerUnitAxleConfiguration;
+    return {
+        vehicleConfiguration,
+        axleConfiguration,
+        licensedGVW: vehicleDetails.licensedGVW || 0,
+    };
+};
 /**
  * Adds runtime facts for the validation. For example, adds the
  * validation date for comparison against startDate of the permit.
@@ -112,8 +131,7 @@ function addRuntimeFacts(engine, policy) {
      * weight by summing the weights of the individual axle units.
      */
     engine.addFact(enum_1.PolicyFacts.GrossVehicleCombinationWeight, async function (params, almanac) {
-        // Retrieve the axle configuration from permit data
-        const axleConfiguration = await almanac.factValue(enum_1.PermitAppInfo.PermitData, {}, enum_1.PermitAppInfo.AxleConfiguration);
+        const { axleConfiguration } = await getAxleCalculationInputs(policy, almanac);
         return axleConfiguration.reduce((w, curr) => w + curr.axleUnitWeight, 0);
     });
     /**
@@ -122,10 +140,7 @@ function addRuntimeFacts(engine, policy) {
      * Returns true if all policy check results are 'pass', false otherwise.
      */
     engine.addFact(enum_1.PolicyFacts.PolicyCheckPassed.toString(), async function (params, almanac) {
-        // Retrieve the complete vehicle configuration (power unit + trailers)
-        const vehicleConfiguration = await almanac.factValue(enum_1.PolicyFacts.VehicleConfiguration);
-        // Retrieve the axle configuration from permit data
-        const axleConfiguration = await almanac.factValue(enum_1.PermitAppInfo.PermitData, {}, enum_1.PermitAppInfo.AxleConfiguration);
+        const { vehicleConfiguration, axleConfiguration } = await getAxleCalculationInputs(policy, almanac);
         // Get the specific policy check ID from parameters
         const policyCheckId = params.policyId;
         // Look up the policy check function from the policy check map
@@ -144,19 +159,20 @@ function addRuntimeFacts(engine, policy) {
         return policyCheckResults.every((r) => r.result === enum_1.PolicyCheckResultType.Pass);
     });
     /**
-     * Add runtime fact to return an array of all messages that result from
-     * all combined policy checks for axle calculation. This is used in
-     * permit validation, returned in the details param for that rule for
-     * overweight permit types.
+     * Add runtime fact to return the complete runAxleCalculation result. This
+     * is the structured ASW validation detail exposed by validate().
+     */
+    engine.addFact(AXLE_CALC_RESULTS_FACT, async function (params, almanac) {
+        const { vehicleConfiguration, axleConfiguration, licensedGVW } = await getAxleCalculationInputs(policy, almanac);
+        return policy.runAxleCalculation(vehicleConfiguration, axleConfiguration, licensedGVW);
+    });
+    /**
+     * Add runtime fact to return messages from failed axle calculation checks.
+     * This keeps the generic validation violation as the gating signal while
+     * axleCalcResults carries the structured ASW detail.
      */
     engine.addFact(enum_1.PolicyFacts.AxleCalcViolations, async function (params, almanac) {
-        // Retrieve the complete vehicle configuration (power unit + trailers)
-        const vehicleConfiguration = await almanac.factValue(enum_1.PolicyFacts.VehicleConfiguration);
-        // Retrieve the axle configuration from permit data
-        const axleConfiguration = await almanac.factValue(enum_1.PermitAppInfo.PermitData, {}, enum_1.PermitAppInfo.AxleConfiguration);
-        // Retrieve licensed GVW from permit data
-        const vehicleDetails = await almanac.factValue(enum_1.PermitAppInfo.PermitData, {}, enum_1.PermitAppInfo.VehicleDetails);
-        const results = policy.runAxleCalculation(vehicleConfiguration, axleConfiguration, vehicleDetails.licensedGVW || 0);
+        const results = await almanac.factValue(AXLE_CALC_RESULTS_FACT);
         const violations = results.results.filter((r) => r.result === enum_1.PolicyCheckResultType.Fail);
         return violations.map((v) => v.message);
     });

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

@@ -176,6 +176,11 @@ export declare function CheckMinSteerAxleWeight(_policy: Policy, _vehicleConfigu
  * @returns Array of AxleGroupPolicyCheckResult objects with validation results
  */
 export declare function CheckMinTandemSteerAxleWeight(_policy: Policy, _vehicleConfiguration: Array<string>, axleConfiguration: Array<AxleConfiguration>): Array<PolicyCheckResult>;
+/**
+ * Applies the restricted weight rules for non-standard tandem steer/tridem
+ * drive picker truck tractors.
+ */
+export declare function CheckPickerTruckTractorWeightRestrictions(policy: Policy, vehicleConfiguration: Array<string>, axleConfiguration: Array<AxleConfiguration>): Array<AxleGroupPolicyCheckResult>;
 /**
  * Validates minimum drive axle weight requirements for tandem and tridem drive power units.
  *
@@ -296,6 +301,7 @@ export declare function CheckDriveJeepLoadEqualization(_policy: Policy, vehicleC
  * - MinDriveAxleWeight: Validates minimum weight requirements for drive axles
  * - MinSteerAxleWeight: Validates minimum weight requirements for steer axles
  * - MinTandemSteerAxleWeight: Validates tandem steer minimum weight requirements
+ * - PickerTruckTractorWeightRestrictions: Validates non-standard picker truck tractor restrictions
  * - NumberOfAxles: Validates axle count per axle unit
  * - NumberOfWheelsPerAxle: Validates tire count per axle unit
  * - BoosterAxleLimit: Validates booster axle count against the preceding trailer

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

@@ -7,6 +7,7 @@ exports.CheckNumTiresPerAxle = CheckNumTiresPerAxle;
 exports.CheckPermittableWeight = CheckPermittableWeight;
 exports.CheckMinSteerAxleWeight = CheckMinSteerAxleWeight;
 exports.CheckMinTandemSteerAxleWeight = CheckMinTandemSteerAxleWeight;
+exports.CheckPickerTruckTractorWeightRestrictions = CheckPickerTruckTractorWeightRestrictions;
 exports.CheckMinDriveAxleWeight = CheckMinDriveAxleWeight;
 exports.CheckMaxTireLoad = CheckMaxTireLoad;
 exports.CheckBoosterAxleLimit = CheckBoosterAxleLimit;
@@ -387,6 +388,95 @@ function CheckMinTandemSteerAxleWeight(_policy, _vehicleConfiguration, axleConfi
     });
     return policyCheckResults;
 }
+/**
+ * Applies the restricted weight rules for non-standard tandem steer/tridem
+ * drive picker truck tractors.
+ */
+function CheckPickerTruckTractorWeightRestrictions(policy, vehicleConfiguration, axleConfiguration) {
+    const policyId = enum_1.PolicyCheckId.PickerTruckTractorWeightRestrictions;
+    const MINIMUM_WHEELBASE_CM = 660;
+    const MINIMUM_STEER_AXLE_SPREAD_CM = 100;
+    const MINIMUM_DRIVE_AXLE_SPREAD_CM = 240;
+    const steerAxle = axleConfiguration[0];
+    const driveAxle = axleConfiguration[1];
+    const doesNotApply = (message = 'Policy check does not apply to this configuration') => [
+        {
+            id: policyId,
+            message,
+            result: enum_1.PolicyCheckResultType.Pass,
+            startAxleUnit: 1,
+            endAxleUnit: 2,
+        },
+    ];
+    if (vehicleConfiguration[0] !== 'PICKRTT' ||
+        !steerAxle ||
+        !driveAxle ||
+        steerAxle.numberOfAxles !== 2 ||
+        driveAxle.numberOfAxles !== 3) {
+        return doesNotApply();
+    }
+    const hasWheelbaseDimensions = Number.isFinite(steerAxle.axleSpread) &&
+        Number.isFinite(driveAxle.interaxleSpacing) &&
+        Number.isFinite(driveAxle.axleSpread);
+    const wheelbase = hasWheelbaseDimensions
+        ? steerAxle.axleSpread / 2 +
+            driveAxle.interaxleSpacing +
+            driveAxle.axleSpread / 2
+        : undefined;
+    const isNonStandard = (wheelbase !== undefined && wheelbase < MINIMUM_WHEELBASE_CM) ||
+        (steerAxle.axleSpread !== undefined &&
+            steerAxle.axleSpread < MINIMUM_STEER_AXLE_SPREAD_CM) ||
+        (driveAxle.axleSpread !== undefined &&
+            driveAxle.axleSpread < MINIMUM_DRIVE_AXLE_SPREAD_CM);
+    if (!isNonStandard) {
+        return doesNotApply();
+    }
+    const powerUnitWeights = policy.getDefaultPowerUnitWeight('PICKRTT', 23);
+    const steerWeightDimension = policy.selectCorrectWeightDimension(powerUnitWeights, vehicleConfiguration, axleConfiguration, 0);
+    const driveWeightDimension = policy.selectCorrectWeightDimension(powerUnitWeights, vehicleConfiguration, axleConfiguration, 1);
+    const steerPermittable = steerWeightDimension === null || steerWeightDimension === void 0 ? void 0 : steerWeightDimension.permittable;
+    const drivePermittable = driveWeightDimension === null || driveWeightDimension === void 0 ? void 0 : driveWeightDimension.permittable;
+    if (steerPermittable === undefined ||
+        drivePermittable === undefined ||
+        steerAxle.axleUnitWeight > steerPermittable ||
+        driveAxle.axleUnitWeight > drivePermittable) {
+        return doesNotApply('Policy check does not apply outside configured permittable axle weights');
+    }
+    const ratioPasses = meetsMinimumSteerPercentageOfDriveAxleWeight(steerAxle, driveAxle, 0.5);
+    const hasRealTrailer = vehicleConfiguration.slice(1).some((vehicleType) => {
+        const vehicleDefinition = policy.getVehicleDefinition(vehicleType);
+        return !(vehicleDefinition === null || vehicleDefinition === void 0 ? void 0 : vehicleDefinition.ignoreForAxleCalculation);
+    });
+    const exceedsLegalWeight = ((steerWeightDimension === null || steerWeightDimension === void 0 ? void 0 : steerWeightDimension.legal) !== undefined &&
+        steerAxle.axleUnitWeight > steerWeightDimension.legal) ||
+        ((driveWeightDimension === null || driveWeightDimension === void 0 ? void 0 : driveWeightDimension.legal) !== undefined &&
+            driveAxle.axleUnitWeight > driveWeightDimension.legal);
+    const trailerPasses = !hasRealTrailer || !exceedsLegalWeight;
+    return [
+        {
+            id: policyId,
+            message: ratioPasses
+                ? ''
+                : 'Axle Unit 1 must carry a minimum 50% of Axle Unit 2 axle unit weight.',
+            result: ratioPasses
+                ? enum_1.PolicyCheckResultType.Pass
+                : enum_1.PolicyCheckResultType.Fail,
+            startAxleUnit: 1,
+            endAxleUnit: 2,
+        },
+        {
+            id: policyId,
+            message: trailerPasses
+                ? ''
+                : 'Cannot tow a trailer if Axle Unit 1 and Axle Unit 2 are exceeding legal axle weights.',
+            result: trailerPasses
+                ? enum_1.PolicyCheckResultType.Pass
+                : enum_1.PolicyCheckResultType.Fail,
+            startAxleUnit: 1,
+            endAxleUnit: 2,
+        },
+    ];
+}
 /**
  * Validates minimum drive axle weight requirements for tandem and tridem drive power units.
  *
@@ -808,6 +898,7 @@ function CheckDriveJeepLoadEqualization(_policy, vehicleConfiguration, axleConfi
  * - MinDriveAxleWeight: Validates minimum weight requirements for drive axles
  * - MinSteerAxleWeight: Validates minimum weight requirements for steer axles
  * - MinTandemSteerAxleWeight: Validates tandem steer minimum weight requirements
+ * - PickerTruckTractorWeightRestrictions: Validates non-standard picker truck tractor restrictions
  * - NumberOfAxles: Validates axle count per axle unit
  * - NumberOfWheelsPerAxle: Validates tire count per axle unit
  * - BoosterAxleLimit: Validates booster axle count against the preceding trailer
@@ -826,6 +917,10 @@ exports.policyCheckMap = new Map([
     [enum_1.PolicyCheckId.MinDriveAxleWeight, CheckMinDriveAxleWeight],
     [enum_1.PolicyCheckId.MinSteerAxleWeight, CheckMinSteerAxleWeight],
     [enum_1.PolicyCheckId.MinTandemSteerAxleWeight, CheckMinTandemSteerAxleWeight],
+    [
+        enum_1.PolicyCheckId.PickerTruckTractorWeightRestrictions,
+        CheckPickerTruckTractorWeightRestrictions,
+    ],
     [enum_1.PolicyCheckId.NumberOfWheelsPerAxle, CheckNumTiresPerAxle],
     [enum_1.PolicyCheckId.BoosterAxleLimit, CheckBoosterAxleLimit],
     [enum_1.PolicyCheckId.TruckTractorWheelbase, CheckTruckTractorWheelbase],

package/dist/policy-engine.js

@@ -60,7 +60,7 @@ class Policy {
      * @returns Results of the validation of the permit application
      */
     async validate(permit) {
-        var _a, _b;
+        var _a, _b, _c, _d;
         const engine = this.rulesEngines.get(permit.permitType);
         if (!engine) {
             // If the permit type being validated has no configuration in the
@@ -78,13 +78,19 @@ class Policy {
             const engineResult = await engine.run(permit);
             // Wrap the json-rules-engine result in a ValidationResult object
             const validationResults = new validation_results_1.ValidationResults(engineResult);
+            const shouldIncludeAxleCalculationResults = permit.permitType === 'STOW' &&
+                ((_b = (_a = permit.permitData) === null || _a === void 0 ? void 0 : _a.vehicleConfiguration) === null || _b === void 0 ? void 0 : _b.axleConfiguration);
+            if (shouldIncludeAxleCalculationResults) {
+                validationResults.axleCalculationResults =
+                    await engineResult.almanac.factValue('axleCalcResults');
+            }
             // Include an informational message if the client is an LCV carrier
-            if ((_a = this.specialAuthorizations) === null || _a === void 0 ? void 0 : _a.isLcvAllowed) {
+            if ((_c = this.specialAuthorizations) === null || _c === void 0 ? void 0 : _c.isLcvAllowed) {
                 validationResults.information.push(new validation_result_1.ValidationResult(enum_1.ValidationResultType.Information, enum_1.ValidationResultCode.IsLcvCarrier, `Policy validation allowing long combination vehicle permitting for client '${this.specialAuthorizations.companyId}'`));
             }
             // Include an informational message and adjust the cost if the client
             // has a no fee flag set.
-            if ((_b = this.specialAuthorizations) === null || _b === void 0 ? void 0 : _b.noFeeType) {
+            if ((_d = this.specialAuthorizations) === null || _d === void 0 ? void 0 : _d.noFeeType) {
                 const originalPermitCost = validationResults === null || validationResults === void 0 ? void 0 : validationResults.cost.reduce((accumulator, { cost }) => accumulator + (cost !== null && cost !== void 0 ? cost : 0), 0);
                 // Clear the cost array and replace with zero cost
                 validationResults.cost.length = 0;

package/dist/validation-results.d.ts

@@ -1,5 +1,6 @@
 import { EngineResult } from 'json-rules-engine';
 import { ValidationResult } from './validation-result';
+import { AxleCalcResults } from './types/axle-calculation-results';
 /** Represents the results of a permit application validation against policy */
 export declare class ValidationResults {
     /** Array of policy violations found during validation. */
@@ -23,6 +24,12 @@ export declare class ValidationResults {
      * one cost message, all should be summed to get the total permit cost.
      */
     cost: Array<ValidationResult>;
+    /**
+     * Structured axle-spacing-and-weights policy-check results. This mirrors
+     * runAxleCalculation() so consumers can highlight ASW fields while
+     * violations remains the coarse validation-gating signal.
+     */
+    axleCalculationResults?: AxleCalcResults;
     /**
      * Creates a new ValidationResults from the json-rules-engine result.
      * Populates the violations, requirements, warnings, and messages arrays

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const version = "v2.15.0";
+export declare const version = "v2.17.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.15.0';
+exports.version = 'v2.17.0';

package/package.json

@@ -91,5 +91,5 @@
     ],
     "testEnvironment": "node"
   },
-  "version": "v2.15.0"
+  "version": "v2.17.0"
 }