onroute-policy-engine 2.27.0 → 2.29.0

package/dist/enum/index.d.ts

@@ -2,9 +2,11 @@ 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';
+export { ValidationResultId } from './validation-result-id';
 export { ValidationResultType } from './validation-result-type';
 export { VehicleCategory } from './vehicle-category';
 export { VehicleTypes } from './vehicle-types';

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.ValidationResultId = 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; } });
@@ -17,6 +19,8 @@ var relative_position_1 = require("./relative-position");
 Object.defineProperty(exports, "RelativePosition", { enumerable: true, get: function () { return relative_position_1.RelativePosition; } });
 var validation_result_code_1 = require("./validation-result-code");
 Object.defineProperty(exports, "ValidationResultCode", { enumerable: true, get: function () { return validation_result_code_1.ValidationResultCode; } });
+var validation_result_id_1 = require("./validation-result-id");
+Object.defineProperty(exports, "ValidationResultId", { enumerable: true, get: function () { return validation_result_id_1.ValidationResultId; } });
 var validation_result_type_1 = require("./validation-result-type");
 Object.defineProperty(exports, "ValidationResultType", { enumerable: true, get: function () { return validation_result_type_1.ValidationResultType; } });
 var vehicle_category_1 = require("./vehicle-category");

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

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

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

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

package/dist/enum/validation-result-id.d.ts

@@ -0,0 +1,4 @@
+/** Identifies validation results that require specific consumer processing. */
+export declare enum ValidationResultId {
+    AxleWeightSpacing = "axle-weight-spacing"
+}

package/dist/enum/validation-result-id.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ValidationResultId = void 0;
+/** Identifies validation results that require specific consumer processing. */
+var ValidationResultId;
+(function (ValidationResultId) {
+    ValidationResultId["AxleWeightSpacing"] = "axle-weight-spacing";
+})(ValidationResultId || (exports.ValidationResultId = ValidationResultId = {}));

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

@@ -1,5 +1,17 @@
-import { Engine } from 'json-rules-engine';
+import { Engine, EngineResult, Event } from 'json-rules-engine';
 import { Policy } from 'onroute-policy-engine';
+/** This returns the "Event", eg the axleCalcViolations event, in the _current-config.json. Helps
+ * identify an object like this from the JSON and return it for in-memory modification
+ *
+ *  This is the structure of the object we retrieve with this function
+ *   "conditions": {
+ *         "not": {
+ *         "fact": "axleCalcViolations",
+ *         "operator": "isEmptyArray",
+ *         "value": true
+ *       }
+ */
+export declare function getSuccessfulEventByFact(engineResult: EngineResult, fact: string): Event | undefined;
 /**
  * Creates a json-rules-engine Engine object for each permit type specified in
  * the policy definition, added to a Map. All rules specific to each permit type

package/dist/helper/rules-engine.helper.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSuccessfulEventByFact = getSuccessfulEventByFact;
 exports.getRulesEngines = getRulesEngines;
 const json_rules_engine_1 = require("json-rules-engine");
 const custom_operators_1 = require("../rule-operator/custom-operators");
@@ -19,6 +20,23 @@ function getEngine(policyDefinition) {
     policyDefinition.commonRules.forEach((r) => engine.addRule(r));
     return engine;
 }
+/** This returns the "Event", eg the axleCalcViolations event, in the _current-config.json. Helps
+ * identify an object like this from the JSON and return it for in-memory modification
+ *
+ *  This is the structure of the object we retrieve with this function
+ *   "conditions": {
+ *         "not": {
+ *         "fact": "axleCalcViolations",
+ *         "operator": "isEmptyArray",
+ *         "value": true
+ *       }
+ */
+function getSuccessfulEventByFact(engineResult, fact) {
+    var _a;
+    return (_a = engineResult.results.find(({ conditions }) => 'not' in conditions &&
+        'fact' in conditions.not &&
+        conditions.not.fact === fact)) === null || _a === void 0 ? void 0 : _a.event;
+}
 /**
  * Creates a json-rules-engine Engine object for each permit type specified in
  * the policy definition, added to a Map. All rules specific to each permit type

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 {
     /**
@@ -77,6 +78,10 @@ class Policy {
             (0, facts_helper_1.addRuntimeFacts)(engine, this);
             // Run the json-rules-engine against the permit facts
             const engineResult = await engine.run(permit);
+            const axleCalculationEvent = (0, rules_engine_helper_1.getSuccessfulEventByFact)(engineResult, enum_1.PolicyFacts.AxleCalcViolations);
+            if (axleCalculationEvent === null || axleCalculationEvent === void 0 ? void 0 : axleCalculationEvent.params) {
+                axleCalculationEvent.params.id = enum_1.ValidationResultId.AxleWeightSpacing;
+            }
             // Wrap the json-rules-engine result in a ValidationResult object
             const validationResults = new validation_results_1.ValidationResults(engineResult);
             const shouldIncludeAxleCalculationResults = permit.permitType === 'STOW' &&
@@ -717,8 +722,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 +742,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 +755,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/validation-result.d.ts

@@ -15,6 +15,8 @@ export declare class ValidationResult {
     type: string;
     code: string;
     message: string;
+    /** Stable identifier for validation classes requiring specific processing. */
+    id?: string;
     fieldReference?: string;
     cost?: number;
     details?: Array<string>;

package/dist/validation-results.js

@@ -36,15 +36,16 @@ class ValidationResults {
         this.cost = [];
         if (engineResult) {
             engineResult.events.forEach((e) => {
-                var _a, _b, _c, _d, _e;
-                var _f, _g, _h;
-                const message = (_f = (_a = e.params) === null || _a === void 0 ? void 0 : _a.message) !== null && _f !== void 0 ? _f : `Unknown message: params=${JSON.stringify(e.params)}`;
-                const code = (_g = (_b = e.params) === null || _b === void 0 ? void 0 : _b.code) !== null && _g !== void 0 ? _g : validation_result_code_1.ValidationResultCode.GeneralResult;
-                const type = (_h = e.type) !== null && _h !== void 0 ? _h : validation_result_type_1.ValidationResultType.Violation.toString();
+                var _a, _b, _c, _d, _e, _f;
+                var _g, _h, _j;
+                const message = (_g = (_a = e.params) === null || _a === void 0 ? void 0 : _a.message) !== null && _g !== void 0 ? _g : `Unknown message: params=${JSON.stringify(e.params)}`;
+                const code = (_h = (_b = e.params) === null || _b === void 0 ? void 0 : _b.code) !== null && _h !== void 0 ? _h : validation_result_code_1.ValidationResultCode.GeneralResult;
+                const type = (_j = e.type) !== null && _j !== void 0 ? _j : validation_result_type_1.ValidationResultType.Violation.toString();
                 const result = new validation_result_1.ValidationResult(type, code, message);
-                result.fieldReference = (_c = e.params) === null || _c === void 0 ? void 0 : _c.fieldReference;
-                result.cost = (_d = e.params) === null || _d === void 0 ? void 0 : _d.cost;
-                result.details = (_e = e.params) === null || _e === void 0 ? void 0 : _e.details;
+                result.id = (_c = e.params) === null || _c === void 0 ? void 0 : _c.id;
+                result.fieldReference = (_d = e.params) === null || _d === void 0 ? void 0 : _d.fieldReference;
+                result.cost = (_e = e.params) === null || _e === void 0 ? void 0 : _e.cost;
+                result.details = (_f = e.params) === null || _f === void 0 ? void 0 : _f.details;
                 switch (type) {
                     case validation_result_type_1.ValidationResultType.Violation:
                         this.violations.push(result);

package/dist/version.d.ts

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

package/package.json

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