onroute-policy-engine 2.8.0 → 2.9.0

package/README.md

@@ -301,6 +301,46 @@ npm test -- --coverage
 npm test -- validate-tros.spec.ts
 ```
 
+
+## Using npm link for local policy engine changes
+
+Use this when you want this frontend example, including the permit form application flow, to pick up local `onroute-policy-engine` changes without publishing a package.
+
+```bash
+# policy engine repo route
+# note: linking only works the BUILT files! so you must run `npm run build` after pulling down any PR, making any code changes, etc, to the policy engine
+npm run build
+# npm run build -- --watch  # optional for active library development; rebuilds dist on change
+npm link
+
+# this example app
+cd src/_examples/usage/react-frontend-example
+npm link onroute-policy-engine
+npm run dev
+
+
+# OPTIONAL - Now assume you have further changes to make to policy engine, or are switching policy engine branches, etc. To bring those changes in, you would:
+
+# in PE repo, after changes are made
+npm run build
+
+# in application repo, after build is done
+kill the npm run dev
+npm run dev
+
+# now that you've built + restarted the dev server, changes should be represented.
+```
+
+If Chrome DevTools shows import/module resolution issues after linking, add this to `vite.config.ts`:
+
+```ts
+export default defineConfig({
+  resolve: {
+    preserveSymlinks: true,
+  },
+});
+```
+
 ## License
 
 This project is licensed under the Apache License 2.0 - see the [LICENSE](LICENSE) file for details.

package/dist/helper/dimensions.helper.d.ts

@@ -85,4 +85,32 @@ export declare function selectCorrectWeightDimensionHelper(policy: Policy, weigh
  * to be returned.
  * @returns VehicleRelatives for the axle at the indicated axleIndex
  */
-export declare function getVehicleRelatives(policy: Policy, configuration: Array<string>, axleIndex: number): VehicleRelatives;
+export declare function getVehicleRelatives(policy: Policy, configuration: Array<string>, axleIndex: number, axleUnitVehicleIndexes?: Array<number>): VehicleRelatives;
+/**
+ * Maps each axle unit to the vehicle configuration index that owns it.
+ *
+ * Every axle unit must supply vehicleIndex and the values must be valid,
+ * front-to-back vehicle configuration indexes. This lets the consuming
+ * application state axle ownership explicitly instead of relying on
+ * policy-engine inference.
+ *
+ * @example
+ * // Additional power-unit axle: CONCRET owns all three axle units explicitly.
+ * getAxleUnitVehicleIndexes(policy, ['CONCRET'], [
+ *   { ...axleUnit, vehicleIndex: 0 },
+ *   { ...axleUnit, vehicleIndex: 0 },
+ *   { ...axleUnit, vehicleIndex: 0 },
+ * ]);
+ * // Returns [0, 0, 0]
+ *
+ * @example
+ * // Additional trailer axle: the trailer owns both trailer axle units explicitly.
+ * getAxleUnitVehicleIndexes(policy, ['TRKTRAC', 'STROPRT'], [
+ *   { ...axleUnit, vehicleIndex: 0 },
+ *   { ...axleUnit, vehicleIndex: 0 },
+ *   { ...axleUnit, vehicleIndex: 1 },
+ *   { ...axleUnit, vehicleIndex: 1 },
+ * ]);
+ * // Returns [0, 0, 1, 1]
+ */
+export declare function getAxleUnitVehicleIndexes(policy: Policy, configuration: Array<string>, axleConfiguration: Array<AxleConfiguration>): Array<number>;

package/dist/helper/dimensions.helper.js

@@ -6,6 +6,7 @@ exports.getDefaultPowerUnitWeightHelper = getDefaultPowerUnitWeightHelper;
 exports.getDefaultTrailerWeightHelper = getDefaultTrailerWeightHelper;
 exports.selectCorrectWeightDimensionHelper = selectCorrectWeightDimensionHelper;
 exports.getVehicleRelatives = getVehicleRelatives;
+exports.getAxleUnitVehicleIndexes = getAxleUnitVehicleIndexes;
 const enum_1 = require("onroute-policy-engine/enum");
 /**
  * Gets the maximum size dimensions for a given permit type, commodity,
@@ -263,7 +264,7 @@ function getDefaultVehicleWeightHelper(policy, subType, axles, isPowerUnit) {
     const vehicleCategory = vehicleCategories === null || vehicleCategories === void 0 ? void 0 : vehicleCategories.find((c) => c.id === vehicleDefinition.category);
     if (vehicleCategory) {
         const overridesForAxle = (_d = vehicleCategory.defaultWeightDimensions) === null || _d === void 0 ? void 0 : _d.filter((w) => w.axles === axles);
-        if (overridesForAxle) {
+        if (overridesForAxle && overridesForAxle.length > 0) {
             return JSON.parse(JSON.stringify(overridesForAxle));
         }
     }
@@ -272,7 +273,7 @@ function getDefaultVehicleWeightHelper(policy, subType, axles, isPowerUnit) {
         ? (_e = policy.policyDefinition.globalWeightDefaults) === null || _e === void 0 ? void 0 : _e.powerUnits
         : (_f = policy.policyDefinition.globalWeightDefaults) === null || _f === void 0 ? void 0 : _f.trailers;
     const vehicleDefaults = globalDefaults === null || globalDefaults === void 0 ? void 0 : globalDefaults.filter((w) => w.axles === axles);
-    if (vehicleDefaults) {
+    if (vehicleDefaults && vehicleDefaults.length > 0) {
         // Return a copy of the vehicle weights
         return JSON.parse(JSON.stringify(vehicleDefaults));
     }
@@ -311,23 +312,29 @@ function selectCorrectWeightDimensionHelper(policy, weightDimensions, configurat
     if (axleIndex >= axleConfiguration.length) {
         throw new Error('Invalid axle index value');
     }
-    const realVehicleConfig = configuration.filter((v) => {
-        const vehicleDef = policy.getVehicleDefinition(v);
-        return !(vehicleDef === null || vehicleDef === void 0 ? void 0 : vehicleDef.ignoreForAxleCalculation);
-    });
-    if (realVehicleConfig.length !== axleConfiguration.length - 1) {
-        // We expect the axle configuration array length to be one more
-        // than the real configuration length because the power unit has two
-        // axle units.
-        throw new Error('Wrong number of axles configured for vehicle configuration');
+    const hasVehicleIndexes = axleConfiguration.some((axleUnit) => axleUnit.vehicleIndex !== undefined);
+    const axleUnitVehicleIndexes = hasVehicleIndexes
+        ? getAxleUnitVehicleIndexes(policy, configuration, axleConfiguration)
+        : undefined;
+    const powerUnitAxleUnitCount = axleUnitVehicleIndexes
+        ? axleUnitVehicleIndexes.filter((vehicleIndex) => vehicleIndex === 0).length
+        : 2;
+    if (!axleUnitVehicleIndexes) {
+        const realVehicleConfig = configuration.filter((v) => {
+            const vehicleDef = policy.getVehicleDefinition(v);
+            return !(vehicleDef === null || vehicleDef === void 0 ? void 0 : vehicleDef.ignoreForAxleCalculation);
+        });
+        if (realVehicleConfig.length !== axleConfiguration.length - 1) {
+            throw new Error('Wrong number of axles configured for vehicle configuration');
+        }
     }
-    const relatives = getVehicleRelatives(policy, configuration, axleIndex);
+    const relatives = getVehicleRelatives(policy, configuration, axleIndex, axleUnitVehicleIndexes);
     for (const weightDimension of weightDimensions) {
         // Just renaming this for conciseness
         const m = weightDimension.modifier;
         if (!m) {
             // This dimension has no modifiers, so it is the default
-            if (axleIndex <= 1) {
+            if (axleIndex < powerUnitAxleUnitCount) {
                 const pwd = weightDimension;
                 matchingDimension = {
                     legal: axleIndex === 0 ? pwd.saLegal : pwd.daLegal,
@@ -436,8 +443,8 @@ function selectCorrectWeightDimensionHelper(policy, weightDimensions, configurat
  * to be returned.
  * @returns VehicleRelatives for the axle at the indicated axleIndex
  */
-function getVehicleRelatives(policy, configuration, axleIndex) {
-    var _a, _b;
+function getVehicleRelatives(policy, configuration, axleIndex, axleUnitVehicleIndexes) {
+    var _a, _b, _c;
     if (!configuration || configuration.length === 0) {
         throw new Error('Cannot get relatives with an empty configuration');
     }
@@ -452,22 +459,19 @@ function getVehicleRelatives(policy, configuration, axleIndex) {
         firstCategory: firstVehicle === null || firstVehicle === void 0 ? void 0 : firstVehicle.category,
         lastCategory: lastVehicle === null || lastVehicle === void 0 ? void 0 : lastVehicle.category,
     };
-    if (axleIndex <= 1) {
+    const vehicleIndex = (_a = axleUnitVehicleIndexes === null || axleUnitVehicleIndexes === void 0 ? void 0 : axleUnitVehicleIndexes[axleIndex]) !== null && _a !== void 0 ? _a : axleIndex - 1;
+    if (vehicleIndex <= 0) {
         // First two axles are for the power unit which has no
         // previous type (it is first in the configuration always)
         vehicleRelatives.prevType = null;
         vehicleRelatives.prevCategory = null;
     }
     else {
-        // Subtract 2 from the configuration index to account for
-        // the fact that the power unit has two axles. We walk the
-        // configuration here to jump over any pseudo vehicles like
-        // additional axle units.
-        const prevVehicleType = walk(policy, configuration, axleIndex - 2, -1);
+        const prevVehicleType = walk(policy, configuration, vehicleIndex - 1, -1);
         vehicleRelatives.prevType = prevVehicleType === null || prevVehicleType === void 0 ? void 0 : prevVehicleType.id;
-        vehicleRelatives.prevCategory = (_a = policy.getVehicleDefinition(vehicleRelatives.prevType)) === null || _a === void 0 ? void 0 : _a.category;
+        vehicleRelatives.prevCategory = (_b = policy.getVehicleDefinition(vehicleRelatives.prevType)) === null || _b === void 0 ? void 0 : _b.category;
     }
-    if (configuration.length === 1 || axleIndex === configuration.length) {
+    if (configuration.length === 1 || vehicleIndex >= configuration.length - 1) {
         // The axleIndex is for the last vehicle in the configuration,
         // so it has no next type.
         vehicleRelatives.nextType = null;
@@ -476,12 +480,75 @@ function getVehicleRelatives(policy, configuration, axleIndex) {
     else {
         // Walk the configuration towards the rear, to jump over any
         // pseudo vehicle in the line.
-        const nextVehicleType = walk(policy, configuration, axleIndex, 1);
+        const nextVehicleType = walk(policy, configuration, vehicleIndex + 1, 1);
         vehicleRelatives.nextType = nextVehicleType === null || nextVehicleType === void 0 ? void 0 : nextVehicleType.id;
-        vehicleRelatives.nextCategory = (_b = policy.getVehicleDefinition(vehicleRelatives.nextType)) === null || _b === void 0 ? void 0 : _b.category;
+        vehicleRelatives.nextCategory = (_c = policy.getVehicleDefinition(vehicleRelatives.nextType)) === null || _c === void 0 ? void 0 : _c.category;
     }
     return vehicleRelatives;
 }
+/**
+ * Maps each axle unit to the vehicle configuration index that owns it.
+ *
+ * Every axle unit must supply vehicleIndex and the values must be valid,
+ * front-to-back vehicle configuration indexes. This lets the consuming
+ * application state axle ownership explicitly instead of relying on
+ * policy-engine inference.
+ *
+ * @example
+ * // Additional power-unit axle: CONCRET owns all three axle units explicitly.
+ * getAxleUnitVehicleIndexes(policy, ['CONCRET'], [
+ *   { ...axleUnit, vehicleIndex: 0 },
+ *   { ...axleUnit, vehicleIndex: 0 },
+ *   { ...axleUnit, vehicleIndex: 0 },
+ * ]);
+ * // Returns [0, 0, 0]
+ *
+ * @example
+ * // Additional trailer axle: the trailer owns both trailer axle units explicitly.
+ * getAxleUnitVehicleIndexes(policy, ['TRKTRAC', 'STROPRT'], [
+ *   { ...axleUnit, vehicleIndex: 0 },
+ *   { ...axleUnit, vehicleIndex: 0 },
+ *   { ...axleUnit, vehicleIndex: 1 },
+ *   { ...axleUnit, vehicleIndex: 1 },
+ * ]);
+ * // Returns [0, 0, 1, 1]
+ */
+function getAxleUnitVehicleIndexes(policy, configuration, axleConfiguration) {
+    if (!configuration || configuration.length === 0) {
+        throw new Error('Missing configuration');
+    }
+    if (!axleConfiguration || axleConfiguration.length === 0) {
+        throw new Error('Missing axle configuration');
+    }
+    const vehicleIndexCount = axleConfiguration.filter((axleUnit) => axleUnit.vehicleIndex !== undefined).length;
+    if (vehicleIndexCount !== axleConfiguration.length) {
+        throw new Error('All axle units must include vehicleIndex');
+    }
+    const axleUnitVehicleIndexes = axleConfiguration.map((axleUnit) => {
+        const vehicleIndex = axleUnit.vehicleIndex;
+        if (vehicleIndex === undefined ||
+            !Number.isInteger(vehicleIndex) ||
+            vehicleIndex < 0 ||
+            vehicleIndex >= configuration.length) {
+            throw new Error('Invalid vehicleIndex in axle configuration');
+        }
+        const vehicleDef = policy.getVehicleDefinition(configuration[vehicleIndex]);
+        if (vehicleDef === null || vehicleDef === void 0 ? void 0 : vehicleDef.ignoreForAxleCalculation) {
+            throw new Error('vehicleIndex cannot reference ignored vehicle');
+        }
+        return vehicleIndex;
+    });
+    if (axleUnitVehicleIndexes.length >= 2 &&
+        (axleUnitVehicleIndexes[0] !== 0 || axleUnitVehicleIndexes[1] !== 0)) {
+        throw new Error('First two axle units must belong to the power unit');
+    }
+    for (let i = 1; i < axleUnitVehicleIndexes.length; i++) {
+        if (axleUnitVehicleIndexes[i] < axleUnitVehicleIndexes[i - 1]) {
+            throw new Error('Axle unit vehicleIndex values must be in vehicle order');
+        }
+    }
+    return axleUnitVehicleIndexes;
+}
 /**
  * Walks along the vehicle configuration from the start index
  * in the direction indicated by increment, which will typically

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

@@ -91,16 +91,17 @@ export declare function CheckNumTiresPerAxle(_policy: Policy, _vehicleConfigurat
  * Validates that each axle unit's weight does not exceed the permittable weight limits.
  *
  * This function performs weight validation for each axle unit in a vehicle configuration.
- * It retrieves the default weight dimensions for power units and trailers based on their
- * vehicle types and axle counts, then compares the actual axle unit weights against the
- * permittable weight limits. The function handles both power units (with steer and drive
- * axles) and trailers, ensuring compliance with weight regulations.
+ * It maps axle units to their owning vehicles, retrieves the default weight dimensions for
+ * those vehicles based on vehicle type and axle count, then compares actual axle unit
+ * weights against the permittable weight limits. Additional axle units require explicit
+ * vehicleIndex values on the axle configuration so ownership is not inferred.
  *
  * @param policy - The policy instance containing weight dimension configurations and validation rules
  * @param vehicleConfiguration - 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 containing weight and axle count information.
- *                           For power units, this includes both steer and drive axle configurations.
+ *                           For power units, this includes steer, drive, and any configured additional
+ *                           axle units.
  * @returns Array of AxleUnitPolicyCheckResult objects, one for each axle unit tested.
  *          Each result indicates whether the axle unit's weight is within permittable limits.
  *
@@ -121,6 +122,19 @@ export declare function CheckNumTiresPerAxle(_policy: Policy, _vehicleConfigurat
  * ]);
  * // Returns results for steer and drive axle units only
  *
+ * @example
+ * // For a configured power unit with an additional axle unit
+ * const results = CheckPermittableWeight(
+ *   policy,
+ *   ['CONCRET'],
+ *   [
+ *     { numberOfAxles: 1, axleUnitWeight: 5000, vehicleIndex: 0 },
+ *     { numberOfAxles: 1, axleUnitWeight: 5000, vehicleIndex: 0 },
+ *     { numberOfAxles: 1, axleUnitWeight: 5000, vehicleIndex: 0 }
+ *   ]
+ * );
+ * // Returns results for all configured power-unit axle units.
+ *
  * @see PolicyCheck
  * @see AxleUnitPolicyCheckResult
  * @see WeightDimension

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

@@ -9,6 +9,7 @@ exports.CheckMinSteerAxleWeight = CheckMinSteerAxleWeight;
 exports.CheckMinDriveAxleWeight = CheckMinDriveAxleWeight;
 exports.CheckMaxTireLoad = CheckMaxTireLoad;
 exports.CheckBoosterAxleLimit = CheckBoosterAxleLimit;
+const dimensions_helper_1 = require("./dimensions.helper");
 const enum_1 = require("../enum");
 /**
  * Validates the number of axles in each axle unit.
@@ -159,16 +160,17 @@ function CheckNumTiresPerAxle(_policy, _vehicleConfiguration, axleConfiguration)
  * Validates that each axle unit's weight does not exceed the permittable weight limits.
  *
  * This function performs weight validation for each axle unit in a vehicle configuration.
- * It retrieves the default weight dimensions for power units and trailers based on their
- * vehicle types and axle counts, then compares the actual axle unit weights against the
- * permittable weight limits. The function handles both power units (with steer and drive
- * axles) and trailers, ensuring compliance with weight regulations.
+ * It maps axle units to their owning vehicles, retrieves the default weight dimensions for
+ * those vehicles based on vehicle type and axle count, then compares actual axle unit
+ * weights against the permittable weight limits. Additional axle units require explicit
+ * vehicleIndex values on the axle configuration so ownership is not inferred.
  *
  * @param policy - The policy instance containing weight dimension configurations and validation rules
  * @param vehicleConfiguration - 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 containing weight and axle count information.
- *                           For power units, this includes both steer and drive axle configurations.
+ *                           For power units, this includes steer, drive, and any configured additional
+ *                           axle units.
  * @returns Array of AxleUnitPolicyCheckResult objects, one for each axle unit tested.
  *          Each result indicates whether the axle unit's weight is within permittable limits.
  *
@@ -189,6 +191,19 @@ function CheckNumTiresPerAxle(_policy, _vehicleConfiguration, axleConfiguration)
  * ]);
  * // Returns results for steer and drive axle units only
  *
+ * @example
+ * // For a configured power unit with an additional axle unit
+ * const results = CheckPermittableWeight(
+ *   policy,
+ *   ['CONCRET'],
+ *   [
+ *     { numberOfAxles: 1, axleUnitWeight: 5000, vehicleIndex: 0 },
+ *     { numberOfAxles: 1, axleUnitWeight: 5000, vehicleIndex: 0 },
+ *     { numberOfAxles: 1, axleUnitWeight: 5000, vehicleIndex: 0 }
+ *   ]
+ * );
+ * // Returns results for all configured power-unit axle units.
+ *
  * @see PolicyCheck
  * @see AxleUnitPolicyCheckResult
  * @see WeightDimension
@@ -197,33 +212,60 @@ function CheckNumTiresPerAxle(_policy, _vehicleConfiguration, axleConfiguration)
 function CheckPermittableWeight(policy, vehicleConfiguration, axleConfiguration) {
     const policyCheckResults = new Array();
     const policyId = enum_1.PolicyCheckId.CheckPermittableWeight;
-    const singleAxleDimensions = [];
-    vehicleConfiguration.forEach((vc, i) => {
-        let weight;
-        if (i === 0) {
-            // This is a power unit, concatenate the steer and drive axle numbers
-            const powerUnitAxles = axleConfiguration[0].numberOfAxles * 10 +
-                axleConfiguration[1].numberOfAxles;
-            weight = policy.getDefaultPowerUnitWeight(vc, powerUnitAxles);
-            const steerAxleDimension = policy.selectCorrectWeightDimension(weight, vehicleConfiguration, axleConfiguration, 0) || {};
-            singleAxleDimensions.push(steerAxleDimension);
-            const driveAxleDimension = policy.selectCorrectWeightDimension(weight, vehicleConfiguration, axleConfiguration, 1) || {};
-            singleAxleDimensions.push(driveAxleDimension);
-        }
-        else {
-            if (i + 1 < axleConfiguration.length) {
-                // We need this guard because the last trailer in a configuration may represent
-                // the pseudo-trailer 'None'; in this case the axleConfiguration length will
-                // be one fewer than normal because the 'None' trailer does not get an axleConfig entry
+    const hasVehicleIndexes = axleConfiguration.some((axleUnit) => axleUnit.vehicleIndex !== undefined);
+    // Legacy John Fletcher implementation, restored from:
+    // git show e4a9d6badd025dec844df43379f776a4995ad75b^:src/helper/policy-check.helper.ts
+    if (!hasVehicleIndexes) {
+        const singleAxleDimensions = [];
+        vehicleConfiguration.forEach((vc, i) => {
+            let weight;
+            if (i === 0) {
+                const powerUnitAxles = axleConfiguration[0].numberOfAxles * 10 +
+                    axleConfiguration[1].numberOfAxles;
+                weight = policy.getDefaultPowerUnitWeight(vc, powerUnitAxles);
+                const steerAxleDimension = policy.selectCorrectWeightDimension(weight, vehicleConfiguration, axleConfiguration, 0) || {};
+                singleAxleDimensions.push(steerAxleDimension);
+                const driveAxleDimension = policy.selectCorrectWeightDimension(weight, vehicleConfiguration, axleConfiguration, 1) || {};
+                singleAxleDimensions.push(driveAxleDimension);
+            }
+            else if (i + 1 < axleConfiguration.length) {
                 weight = policy.getDefaultTrailerWeight(vc, axleConfiguration[i + 1].numberOfAxles);
                 const trailerDimension = policy.selectCorrectWeightDimension(weight, vehicleConfiguration, axleConfiguration, i + 1) || {};
                 singleAxleDimensions.push(trailerDimension);
             }
-        }
-    });
+        });
+        axleConfiguration.forEach((ac, i) => {
+            const actualWeight = ac.axleUnitWeight;
+            const permittableWeight = singleAxleDimensions[i].permittable || 0;
+            const result = actualWeight <= permittableWeight;
+            const axleUnit = i + 1;
+            const message = `Weight for axle unit ${axleUnit} ${result ? 'is permittable' : `must not exceed ${permittableWeight} kgs`}`;
+            policyCheckResults.push({
+                id: policyId,
+                message: message,
+                result: result
+                    ? enum_1.PolicyCheckResultType.Pass
+                    : enum_1.PolicyCheckResultType.Fail,
+                axleUnit: axleUnit,
+                actualWeight: actualWeight,
+                thresholdWeight: permittableWeight,
+            });
+        });
+        return policyCheckResults;
+    }
+    // Explicit multi-axle ownership path supplied by the consuming application.
+    // This is the new way, using { vehicleIndex: num }
+    const axleUnitVehicleIndexes = (0, dimensions_helper_1.getAxleUnitVehicleIndexes)(policy, vehicleConfiguration, axleConfiguration);
     axleConfiguration.forEach((ac, i) => {
+        const vehicleIndex = axleUnitVehicleIndexes[i];
+        const vehicleType = vehicleConfiguration[vehicleIndex];
+        const weight = vehicleIndex === 0
+            ? policy.getDefaultPowerUnitWeight(vehicleType, axleConfiguration[0].numberOfAxles * 10 +
+                axleConfiguration[1].numberOfAxles)
+            : policy.getDefaultTrailerWeight(vehicleType, ac.numberOfAxles);
+        const axleDimension = policy.selectCorrectWeightDimension(weight, vehicleConfiguration, axleConfiguration, i) || {};
         const actualWeight = ac.axleUnitWeight;
-        const permittableWeight = singleAxleDimensions[i].permittable || 0;
+        const permittableWeight = axleDimension.permittable || 0;
         const result = actualWeight <= permittableWeight;
         const axleUnit = i + 1;
         const message = `Weight for axle unit ${axleUnit} ${result ? 'is permittable' : `must not exceed ${permittableWeight} kgs`}`;

package/dist/policy-engine.js

@@ -923,7 +923,7 @@ class Policy {
         if (!commodity) {
             throw new Error(`Invalid commodity type: '${commodityId}'`);
         }
-        const powerUnit = commodity.powerUnits.find(pu => pu.type === powerUnitSubtype);
+        const powerUnit = commodity.powerUnits.find((pu) => pu.type === powerUnitSubtype);
         if (!powerUnit) {
             throw new Error(`Invalid power unit: '${powerUnitSubtype}'`);
         }
@@ -955,7 +955,7 @@ class Policy {
         if (!commodity) {
             throw new Error(`Invalid commodity type: '${commodityId}'`);
         }
-        const powerUnit = commodity.powerUnits.find(pu => pu.type === powerUnitSubtype);
+        const powerUnit = commodity.powerUnits.find((pu) => pu.type === powerUnitSubtype);
         if (!powerUnit) {
             throw new Error(`Invalid power unit: '${powerUnitSubtype}'`);
         }

package/dist/types/axle-configuration.d.ts

@@ -17,6 +17,12 @@ export type AxleConfiguration = {
     numberOfTires?: number;
     /** Tire size in centimetres */
     tireSize?: number;
+    /**
+     * Index of the owning vehicle in the vehicleConfiguration array.
+     * Index 0 is the power unit; following indexes map to the same positions
+     * in vehicleConfiguration.
+     */
+    vehicleIndex?: number;
 };
 export type IndexedAxleConfiguration = AxleConfiguration & {
     /** Index of the vehicle carrying this axle unit, where 0 is the power unit */

package/dist/version.d.ts

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

package/package.json

@@ -91,5 +91,5 @@
     ],
     "testEnvironment": "node"
   },
-  "version": "v2.8.0"
+  "version": "v2.9.0"
 }