onroute-policy-engine 2.0.1 → 2.1.1

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

@@ -0,0 +1,46 @@
+import { Policy } from 'onroute-policy-engine';
+import { AxleConfiguration } from 'onroute-policy-engine/types';
+/**
+ * Helper function to generate a vehicle display code based on the vehicle configuration and axle configuration.
+ *
+ * This function determines whether to generate a standard display code (for known vehicle types with
+ * configured display codes) or a universal display code (for complex or unknown configurations).
+ *
+ * @param policy The Policy instance containing vehicle definitions and display code defaults.
+ * @param configuration Array of vehicle type identifiers representing the vehicle configuration.
+ *                      The first element should be a power unit type, followed by trailer types.
+ * @param axleConfiguration Array of axle configurations corresponding to each vehicle in the configuration.
+ *                          Each axle configuration contains details like number of axles, spacing, etc.
+ * @returns A string representing the vehicle display code, or an empty string if the configuration is empty.
+ *
+ * @throws {Error} If vehicleDisplayCodeDefaults is not configured in the policy definition.
+ */
+export declare function getVehicleDisplayCodeHelper(policy: Policy, configuration: Array<string>, axleConfiguration: Array<AxleConfiguration>): string;
+/**
+ * Generates a universal display code for vehicle configurations that cannot use the standard display code format.
+ *
+ * Universal display codes are used when:
+ * - Vehicle types are unknown or don't have configured display codes
+ * - Axle configurations exceed the maximum standard axle count
+ * - Vehicle configuration doesn't match the expected pattern
+ *
+ * The universal format uses generic symbols and spacing indicators to represent the axle configuration
+ * in a standardized way that can handle complex or unusual vehicle setups.
+ *
+ * @param policy The Policy instance containing display code defaults configuration.
+ * @param axleConfiguration Array of axle configurations representing the vehicle's axle setup.
+ *                          Each configuration contains details like number of axles, spacing, etc.
+ * @returns A string representing the universal vehicle display code, or an empty string if the axle configuration is empty.
+ *
+ * @throws {Error} If vehicleDisplayCodeDefaults is not configured in the policy definition.
+ *
+ * @example
+ * // For a complex axle configuration
+ * const code = getUniversalDisplayCode(policy, [
+ *   { numberOfAxles: 2, interaxleSpacing: 1.8, ... },
+ *   { numberOfAxles: 3, interaxleSpacing: 4.2, ... },
+ *   { numberOfAxles: 5, interaxleSpacing: 3.0, ... } // Exceeds standard threshold
+ * ]);
+ * // Returns something like "U2U1MU3U2MU5+U3" where U represents universal axle codes
+ */
+export declare function getUniversalDisplayCode(policy: Policy, axleConfiguration: Array<AxleConfiguration>): string;

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

@@ -0,0 +1,255 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getVehicleDisplayCodeHelper = getVehicleDisplayCodeHelper;
+exports.getUniversalDisplayCode = getUniversalDisplayCode;
+/**
+ * Helper function to generate a vehicle display code based on the vehicle configuration and axle configuration.
+ *
+ * This function determines whether to generate a standard display code (for known vehicle types with
+ * configured display codes) or a universal display code (for complex or unknown configurations).
+ *
+ * @param policy The Policy instance containing vehicle definitions and display code defaults.
+ * @param configuration Array of vehicle type identifiers representing the vehicle configuration.
+ *                      The first element should be a power unit type, followed by trailer types.
+ * @param axleConfiguration Array of axle configurations corresponding to each vehicle in the configuration.
+ *                          Each axle configuration contains details like number of axles, spacing, etc.
+ * @returns A string representing the vehicle display code, or an empty string if the configuration is empty.
+ *
+ * @throws {Error} If vehicleDisplayCodeDefaults is not configured in the policy definition.
+ */
+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);
+    }
+}
+/**
+ * Generates a universal display code for vehicle configurations that cannot use the standard display code format.
+ *
+ * Universal display codes are used when:
+ * - Vehicle types are unknown or don't have configured display codes
+ * - Axle configurations exceed the maximum standard axle count
+ * - Vehicle configuration doesn't match the expected pattern
+ *
+ * The universal format uses generic symbols and spacing indicators to represent the axle configuration
+ * in a standardized way that can handle complex or unusual vehicle setups.
+ *
+ * @param policy The Policy instance containing display code defaults configuration.
+ * @param axleConfiguration Array of axle configurations representing the vehicle's axle setup.
+ *                          Each configuration contains details like number of axles, spacing, etc.
+ * @returns A string representing the universal vehicle display code, or an empty string if the axle configuration is empty.
+ *
+ * @throws {Error} If vehicleDisplayCodeDefaults is not configured in the policy definition.
+ *
+ * @example
+ * // For a complex axle configuration
+ * const code = getUniversalDisplayCode(policy, [
+ *   { numberOfAxles: 2, interaxleSpacing: 1.8, ... },
+ *   { numberOfAxles: 3, interaxleSpacing: 4.2, ... },
+ *   { numberOfAxles: 5, interaxleSpacing: 3.0, ... } // Exceeds standard threshold
+ * ]);
+ * // Returns something like "U2U1MU3U2MU5+U3" where U represents universal axle codes
+ */
+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('');
+}
+/**
+ * Determines whether a standard display code can be generated for the given vehicle configuration.
+ *
+ * A standard display code can be created when:
+ * - All vehicle types are known and have configured display codes
+ * - The power unit has all required display code properties (prefix, steer axle, drive axle)
+ * - All trailers have display codes (unless they're marked to ignore for axle calculation)
+ * - No axle configuration exceeds the maximum standard axle count
+ * - The number of axle configurations matches the number of non-ignorable vehicles plus one
+ *
+ * @param policy The Policy instance containing vehicle definitions and display code defaults.
+ * @param configuration Array of vehicle type identifiers representing the vehicle configuration.
+ *                      The first element should be a power unit type, followed by trailer types.
+ * @param axleConfiguration Array of axle configurations corresponding to each vehicle in the configuration.
+ *                          Each axle configuration contains details like number of axles, spacing, etc.
+ * @returns True if a standard display code can be generated, false if a universal display code is required.
+ *
+ * @example
+ * // Returns true for a standard truck-tractor with semi-trailer
+ * canCreateStandardCode(policy, ['TRKTRAC', 'SEMI'], [
+ *   { numberOfAxles: 2, ... }, // Steer axle
+ *   { numberOfAxles: 3, ... }, // Drive axle
+ *   { numberOfAxles: 3, ... }  // Trailer axle
+ * ]);
+ *
+ * // Returns false for unknown vehicle types or complex configurations
+ * canCreateStandardCode(policy, ['UNKNOWN'], [
+ *   { numberOfAxles: 10, ... } // Exceeds standard threshold
+ * ]);
+ */
+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,30 @@ export declare class Policy {
      * none are configured
      */
     getStandardTireSizes(): Array<StandardTireSize>;
+    /**
+     * Generates a vehicle display code based on the vehicle configuration and axle configuration.
+     *
+     * The display code is a string representation that describes the vehicle configuration
+     * in a standardized format. It can generate either a standard display code (for known
+     * vehicle types with configured display codes) or a universal display code (for complex
+     * or unknown configurations).
+     *
+     * @param configuration Array of vehicle type identifiers representing the vehicle configuration.
+     *                      The first element should be a power unit type, followed by trailer types.
+     * @param axleConfiguration Array of axle configurations corresponding to each vehicle in the configuration.
+     *                          Each axle configuration contains details like number of axles, spacing, etc.
+     * @returns A string representing the vehicle display code, or an empty string if the configuration is empty.
+     *
+     * @example
+     * // For a truck-tractor with 2-axle steer, 3-axle drive, and a 3-axle semi-trailer
+     * const code = policy.getVehicleDisplayCode(['TRKTRAC'], [
+     *   { numberOfAxles: 2, axleSpread: 1.8, ... },
+     *   { numberOfAxles: 3, axleSpread: 4.2, ... },
+     *   { numberOfAxles: 3, axleSpread: 3.0, ... }
+     * ]);
+     * // Returns something like "TT2S13D23T3"
+     *
+     * @throws {Error} If vehicleDisplayCodeDefaults is not configured in the policy definition.
+     */
+    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 {
     /**
@@ -748,5 +749,33 @@ class Policy {
             return new Array();
         }
     }
+    /**
+     * Generates a vehicle display code based on the vehicle configuration and axle configuration.
+     *
+     * The display code is a string representation that describes the vehicle configuration
+     * in a standardized format. It can generate either a standard display code (for known
+     * vehicle types with configured display codes) or a universal display code (for complex
+     * or unknown configurations).
+     *
+     * @param configuration Array of vehicle type identifiers representing the vehicle configuration.
+     *                      The first element should be a power unit type, followed by trailer types.
+     * @param axleConfiguration Array of axle configurations corresponding to each vehicle in the configuration.
+     *                          Each axle configuration contains details like number of axles, spacing, etc.
+     * @returns A string representing the vehicle display code, or an empty string if the configuration is empty.
+     *
+     * @example
+     * // For a truck-tractor with 2-axle steer, 3-axle drive, and a 3-axle semi-trailer
+     * const code = policy.getVehicleDisplayCode(['TRKTRAC'], [
+     *   { numberOfAxles: 2, axleSpread: 1.8, ... },
+     *   { numberOfAxles: 3, axleSpread: 4.2, ... },
+     *   { numberOfAxles: 3, axleSpread: 3.0, ... }
+     * ]);
+     * // Returns something like "TT2S13D23T3"
+     *
+     * @throws {Error} If vehicleDisplayCodeDefaults is not configured in the policy definition.
+     */
+    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.1";
+export declare const version = "v2.1.1";

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.1';
+exports.version = 'v2.1.1';

package/eslint.config.mjs

@@ -15,7 +15,7 @@ const compat = new FlatCompat({
 });
 
 export default [{
-    ignores: ["**/.eslintrc.cjs", "**/node_modules/", "**/dist/", "**/.eslintrc.cjs"],
+    ignores: ["**/.eslintrc.cjs", "**/node_modules/", "**/dist/", "**/.eslintrc.cjs,", "src/_examples/usage"],
 }, ...compat.extends("eslint:recommended", "plugin:@typescript-eslint/recommended", "prettier"), {
     plugins: {
         "@typescript-eslint": typescriptEslint,

package/package.json

@@ -90,5 +90,5 @@
     ],
     "testEnvironment": "node"
   },
-  "version": "v2.0.1"
+  "version": "v2.1.1"
 }