onroute-policy-engine 2.27.0 → 2.28.0

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/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.js

@@ -141,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,
@@ -953,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) {

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

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

package/package.json

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