onroute-policy-engine 2.0.0 → 2.1.0

package/dist/helper/display-code-helper.d.ts

@@ -0,0 +1,4 @@
+import { Policy } from 'onroute-policy-engine';
+import { AxleConfiguration } from 'onroute-policy-engine/types';
+export declare function getVehicleDisplayCodeHelper(policy: Policy, configuration: Array<string>, axleConfiguration: Array<AxleConfiguration>): string;
+export declare function getUniversalDisplayCode(policy: Policy, axleConfiguration: Array<AxleConfiguration>): string;

package/dist/helper/display-code-helper.js

@@ -0,0 +1,183 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getVehicleDisplayCodeHelper = getVehicleDisplayCodeHelper;
+exports.getUniversalDisplayCode = getUniversalDisplayCode;
+function getVehicleDisplayCodeHelper(policy, configuration, axleConfiguration) {
+    if (!policy.policyDefinition.vehicleDisplayCodeDefaults) {
+        throw new Error('Unable to construct vehicle display code; missing vehicleDisplayCodeDefaults in policy configuration');
+    }
+    // Empty configuration, empty display code
+    if (configuration.length === 0) {
+        return '';
+    }
+    if (canCreateStandardCode(policy, configuration, axleConfiguration)) {
+        const defs = policy.policyDefinition.vehicleDisplayCodeDefaults;
+        const displayCodeTokens = [];
+        displayCodeTokens.push(defs.prefixStandard || '');
+        const powerUnit = policy.getPowerUnitDefinition(configuration[0]);
+        // Add the power unit display code, e.g. TT
+        displayCodeTokens.push((powerUnit === null || powerUnit === void 0 ? void 0 : powerUnit.displayCodePrefix) || '');
+        // Add the number of axles in the steer axle unit
+        displayCodeTokens.push(axleConfiguration[0].numberOfAxles.toString());
+        // Add the power unit steer axle display code, e.g. S
+        displayCodeTokens.push((powerUnit === null || powerUnit === void 0 ? void 0 : powerUnit.displayCodeSteerAxle) || '');
+        // Add the steer axle unit index label (first axle unit)
+        displayCodeTokens.push('1');
+        // Add the padding if necessary. Padding is added once for
+        // every axle above 1 in the steer axle unit.
+        displayCodeTokens.push(defs.paddingStandard.repeat(axleConfiguration[0].numberOfAxles - 1));
+        // Add the number of axles in the drive axle unit
+        displayCodeTokens.push(axleConfiguration[1].numberOfAxles.toString());
+        // Add the power unit drive axle display code, e.g. D
+        displayCodeTokens.push((powerUnit === null || powerUnit === void 0 ? void 0 : powerUnit.displayCodeDriveAxle) || '');
+        // Add the drive axle unit index label (second axle unit)
+        displayCodeTokens.push('2');
+        // Add the padding if necessary. Padding is added once for
+        // every axle above 1 in the drive axle unit.
+        if (axleConfiguration.length > 2) {
+            displayCodeTokens.push(defs.paddingStandard.repeat(axleConfiguration[1].numberOfAxles - 1));
+        }
+        let currentAxleIndex = 2;
+        configuration.slice(1).forEach((v) => {
+            const trailer = policy.getTrailerDefinition(v);
+            if (!(trailer === null || trailer === void 0 ? void 0 : trailer.ignoreForAxleCalculation)) {
+                // Add the number of axles of the trailer
+                displayCodeTokens.push(axleConfiguration[currentAxleIndex].numberOfAxles.toString());
+                // Add the trailer display code, e.g. T
+                displayCodeTokens.push((trailer === null || trailer === void 0 ? void 0 : trailer.displayCode) || '');
+                // Add the axle unit index label, with prefix if axle unit
+                // number is more than a single digit, e.g. '.10'
+                if (currentAxleIndex >= 9) {
+                    displayCodeTokens.push(defs.multiDigitPrefix);
+                }
+                displayCodeTokens.push((currentAxleIndex + 1).toString());
+                // Add the padding if necessary. Padding is added once for
+                // every axle above 1 in the drive axle unit.
+                if (axleConfiguration.length > currentAxleIndex + 1) {
+                    displayCodeTokens.push(defs.paddingStandard.repeat(axleConfiguration[currentAxleIndex].numberOfAxles - 1));
+                }
+                currentAxleIndex++;
+            }
+        });
+        return displayCodeTokens.join('');
+    }
+    else {
+        return getUniversalDisplayCode(policy, axleConfiguration);
+    }
+}
+function getUniversalDisplayCode(policy, axleConfiguration) {
+    const defs = policy.policyDefinition.vehicleDisplayCodeDefaults;
+    if (!defs) {
+        throw new Error('Unable to construct vehicle display code; missing vehicleDisplayCodeDefaults in policy configuration');
+    }
+    // Empty axle configuration, empty display code
+    if (axleConfiguration.length === 0) {
+        return '';
+    }
+    const displayCodeTokens = [];
+    displayCodeTokens.push(defs.prefixUniversal || '');
+    let currentAxleIndex = 0;
+    axleConfiguration.forEach((a) => {
+        if (currentAxleIndex > 0) {
+            // Add the universal spacing glyph, e.g. 'MU' , if this is
+            // not the first axle unit
+            if (a.interaxleSpacing &&
+                a.interaxleSpacing <= defs.spacingUniversalSmallMax) {
+                displayCodeTokens.push(defs.spacingUniversalSmall);
+            }
+            else if (a.interaxleSpacing &&
+                a.interaxleSpacing >= defs.spacingUniversalLargeMin) {
+                displayCodeTokens.push(defs.spacingUniversalLarge);
+            }
+            else {
+                displayCodeTokens.push(defs.spacingUniversalDefault);
+            }
+        }
+        if (a.numberOfAxles >= defs.thresholdAxlesUniversal) {
+            // The number of axles in this axle unit is above the threshold
+            // for the number of axles that can be represented by the simple
+            // universal formula
+            displayCodeTokens.push(defs.thresholdAxlesUniversal.toString());
+            // Add the over axles code, e.g. '+'
+            displayCodeTokens.push(defs.overAxlesCodeUniversal);
+            // Add the universal axle code, e.g. 'U'
+            displayCodeTokens.push(defs.universalAxleCode);
+            // Add the axle unit index label, with prefix if axle unit
+            // number is more than a single digit, e.g. '.10'
+            if (currentAxleIndex >= 9) {
+                displayCodeTokens.push(defs.multiDigitPrefix);
+            }
+            displayCodeTokens.push((currentAxleIndex + 1).toString());
+            // Add the padding. Padding is added once for every axle
+            // above 1, up to the universal threshold.
+            displayCodeTokens.push(defs.paddingUniversal.repeat(defs.thresholdAxlesUniversal - 1));
+            // Add the extra axle unit glyps, e.g. 'XU', for
+            // each axle unit above the universal threshold
+            for (let i = defs.thresholdAxlesUniversal + 1; i < a.numberOfAxles; i++) {
+                displayCodeTokens.push(defs.extraAxleUniversal);
+            }
+            // Add the end axle unit glyph, e.g. 'EU'
+            displayCodeTokens.push(defs.endAxleUniversal);
+        }
+        else {
+            // Add the number of axles in the axle unit, e.g. '2'
+            displayCodeTokens.push(a.numberOfAxles.toString());
+            // Add the universal axle code, e.g. 'U'
+            displayCodeTokens.push(defs.universalAxleCode);
+            // Add the axle unit index label, with prefix if axle unit
+            // number is more than a single digit, e.g. '.10'
+            if (currentAxleIndex >= 9) {
+                displayCodeTokens.push(defs.multiDigitPrefix);
+            }
+            displayCodeTokens.push((currentAxleIndex + 1).toString());
+            // Add the padding if necessary. Padding is added once for
+            // every axle above 1 in the axle unit.
+            if (axleConfiguration.length > currentAxleIndex + 1) {
+                displayCodeTokens.push(defs.paddingUniversal.repeat(axleConfiguration[currentAxleIndex].numberOfAxles - 1));
+            }
+        }
+        currentAxleIndex++;
+    });
+    return displayCodeTokens.join('');
+}
+function canCreateStandardCode(policy, configuration, axleConfiguration) {
+    var _a;
+    // Check that all of the vehicle types are known,
+    // and that all have display codes configured
+    const powerUnit = policy.getPowerUnitDefinition(configuration[0]);
+    if (!powerUnit ||
+        !powerUnit.displayCodePrefix ||
+        !powerUnit.displayCodeSteerAxle ||
+        !powerUnit.displayCodeDriveAxle) {
+        return false;
+    }
+    // Check all the trailers (if there are any)
+    for (let i = 1; i < configuration.length; i++) {
+        const trailer = policy.getTrailerDefinition(configuration[i]);
+        if (!trailer ||
+            (!trailer.displayCode && !trailer.ignoreForAxleCalculation)) {
+            return false;
+        }
+    }
+    // Check that none of the axles exceed the max standard
+    const maxAxles = ((_a = policy.policyDefinition.vehicleDisplayCodeDefaults) === null || _a === void 0 ? void 0 : _a.maxAxlesStandard) || 0;
+    for (let j = 0; j < axleConfiguration.length; j++) {
+        if (axleConfiguration[j].numberOfAxles > maxAxles) {
+            return false;
+        }
+    }
+    // Count all non-ignorable vehicles
+    const vehicleCount = configuration.filter((v) => {
+        const vehicle = policy.getVehicleDefinition(v);
+        if (vehicle && !vehicle.ignoreForAxleCalculation) {
+            return true;
+        }
+        return false;
+    }).length;
+    // The vehicle list does not correspond with the number of non-
+    // ignorable axles, so the universal diagram is the only option
+    if (axleConfiguration.length !== vehicleCount + 1) {
+        return false;
+    }
+    return true;
+}

package/dist/helper/facts.helper.js

@@ -94,7 +94,6 @@ function addRuntimeFacts(engine, policy) {
         const dateFrom = (0, dayjs_1.default)(dateFromStr, enum_1.PermitAppInfo.PermitDateFormat);
         const dateTo = (0, dayjs_1.default)(dateToStr, enum_1.PermitAppInfo.PermitDateFormat);
         const daysBetween = dateTo.diff(dateFrom, 'day');
-        console.log(`Calculated daysBetween '${dateFromStr}' and '${dateToStr}' as '${daysBetween}'`);
         return daysBetween;
     });
     /**

package/dist/policy-engine.d.ts

@@ -245,4 +245,5 @@ export declare class Policy {
      * none are configured
      */
     getStandardTireSizes(): Array<StandardTireSize>;
+    getVehicleDisplayCode(configuration: Array<string>, axleConfiguration: Array<AxleConfiguration>): string;
 }

package/dist/policy-engine.js

@@ -19,6 +19,7 @@ const vehicles_helper_1 = require("./helper/vehicles.helper");
 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");
 /** Class representing commercial vehicle policy. */
 class Policy {
     /**
@@ -26,18 +27,19 @@ class Policy {
      * @param definition Policy definition to validate permits against
      */
     constructor(definition, authorizations) {
+        const cleanVersion = (0, valid_1.default)(version_1.version);
         // Check compatibility of the policy engine with the policy config
-        if (!(0, valid_1.default)(version_1.version)) {
+        if (!cleanVersion) {
             throw new Error(`Cannot determine the version of the policy engine for compatibility: invalid semver: ${version_1.version}`);
         }
         else if (!(0, valid_1.default)(definition.minPEVersion)) {
             throw new Error(`Cannot determine the minimum PE version for the configuration: invalid semver: ${definition.minPEVersion}`);
         }
-        else if ((0, lt_1.default)(version_1.version, definition.minPEVersion)) {
-            throw new Error(`Current policy engine version is less than minimum version required for policy config: ${version_1.version} > ${definition.minPEVersion}`);
+        else if ((0, lt_1.default)(cleanVersion, definition.minPEVersion)) {
+            throw new Error(`Current policy engine version is less than minimum version required for policy config: ${cleanVersion} > ${definition.minPEVersion}`);
         }
-        else if ((0, major_1.default)(version_1.version) > (0, major_1.default)(definition.minPEVersion)) {
-            throw new Error(`Current policy config minimum version is at least one major version behind policy engine: major(${definition.minPEVersion}) < major(${version_1.version}))`);
+        else if ((0, major_1.default)(cleanVersion) > (0, major_1.default)(definition.minPEVersion)) {
+            throw new Error(`Current policy config minimum version is at least one major version behind policy engine: major(${definition.minPEVersion}) < major(${cleanVersion}))`);
         }
         this.policyDefinition = definition;
         this.setSpecialAuthorizations(authorizations);
@@ -747,5 +749,8 @@ class Policy {
             return new Array();
         }
     }
+    getVehicleDisplayCode(configuration, axleConfiguration) {
+        return (0, display_code_helper_1.getVehicleDisplayCodeHelper)(this, configuration, axleConfiguration);
+    }
 }
 exports.Policy = Policy;

package/dist/types/display-code-defaults.d.ts

@@ -0,0 +1,18 @@
+export type VehicleDisplayCodeDefaults = {
+    prefixStandard: string;
+    prefixUniversal: string;
+    paddingStandard: string;
+    paddingUniversal: string;
+    spacingUniversalDefault: string;
+    spacingUniversalSmall: string;
+    spacingUniversalLarge: string;
+    spacingUniversalSmallMax: number;
+    spacingUniversalLargeMin: number;
+    extraAxleUniversal: string;
+    endAxleUniversal: string;
+    maxAxlesStandard: number;
+    thresholdAxlesUniversal: number;
+    overAxlesCodeUniversal: string;
+    universalAxleCode: string;
+    multiDigitPrefix: string;
+};

package/dist/types/display-code-defaults.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/index.d.ts

@@ -4,6 +4,7 @@ export { BridgeCalculationResult } from './bridge-calculation-result';
 export { Commodity } from './commodity';
 export { CostRule } from './cost-rule';
 export { DimensionModifier, VehicleRelatives } from './dimension-modifier';
+export { VehicleDisplayCodeDefaults } from './display-code-defaults';
 export { PermitFacts } from './facts';
 export { GeographicRegion } from './geographic-region';
 export { IdentifiedObject } from './identified-object';

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

@@ -1,4 +1,4 @@
-import { GeographicRegion, PermitType, DefaultWeightDimensions, VehicleTypes, Commodity, SizeDimension, VehicleCategories, RangeMatrix, BridgeCalculationConstants, PermitConditionDefinition, StandardTireSize } from 'onroute-policy-engine/types';
+import { GeographicRegion, PermitType, DefaultWeightDimensions, VehicleTypes, Commodity, SizeDimension, VehicleCategories, RangeMatrix, BridgeCalculationConstants, PermitConditionDefinition, StandardTireSize, VehicleDisplayCodeDefaults } from 'onroute-policy-engine/types';
 import { RuleProperties } from 'json-rules-engine';
 export type PolicyDefinition = {
     minPEVersion: string;
@@ -14,4 +14,5 @@ export type PolicyDefinition = {
     bridgeCalculationConstants: BridgeCalculationConstants;
     conditions?: Array<PermitConditionDefinition>;
     standardTireSizes?: Array<StandardTireSize>;
+    vehicleDisplayCodeDefaults?: VehicleDisplayCodeDefaults;
 };

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

@@ -3,15 +3,20 @@ export type VehicleType = IdentifiedObject & {
     category: string;
     defaultSizeDimensions?: SizeDimension;
     ignoreForSizeDimensions?: boolean;
+    ignoreForAxleCalculation?: boolean;
     isLcv?: boolean;
     conditions?: Array<ConditionRequirement>;
     additionalAxleSubType?: string;
 };
 export type PowerUnitType = VehicleType & {
     defaultWeightDimensions?: Array<PowerUnitWeightDimension>;
+    displayCodePrefix?: string;
+    displayCodeSteerAxle?: string;
+    displayCodeDriveAxle?: string;
 };
 export type TrailerType = VehicleType & {
     defaultWeightDimensions?: Array<TrailerWeightDimension>;
+    displayCode?: string;
 };
 export type VehicleTypes = {
     powerUnitTypes: Array<PowerUnitType>;

package/dist/version.d.ts

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

package/package.json

@@ -90,5 +90,5 @@
     ],
     "testEnvironment": "node"
   },
-  "version": "v2.0.0"
+  "version": "v2.1.0"
 }