onroute-policy-engine 0.1.0 → 0.2.0

package/dist/policy-engine.js

@@ -35,10 +35,9 @@ class Policy {
         else {
             // Add facts specific to this run of the validation (e.g. validation
             // date for comparison against start date of the permit).
-            (0, facts_helper_1.addRuntimeFacts)(engine);
-            const permitFacts = (0, facts_helper_1.transformPermitFacts)(permit);
+            (0, facts_helper_1.addRuntimeFacts)(engine, this);
             // Run the json-rules-engine against the permit facts
-            const engineResult = await engine.run(permitFacts);
+            const engineResult = await engine.run(permit);
             // Wrap the json-rules-engine result in a ValidationResult object
             return new validation_results_1.ValidationResults(engineResult);
         }
@@ -63,13 +62,507 @@ class Policy {
      * Gets a list of all configured commodities in the policy definition.
      * @param permitTypeId Return only commodities valid for this permit type.
      *   If not supplied, return all commodities configured in policy. If permit
-     *   type does not require commodity (e.g. 'TROS'), return all commodities.
+     *   type does not require commodity (e.g. 'TROS'), return empty map.
      * @returns Map of commodity IDs to commodity names.
      */
     getCommodities(permitTypeId) {
         const permitType = this.getPermitTypeDefinition(permitTypeId);
-        const commodities = (0, lists_helper_1.extractIdentifiedObjects)(this.policyDefinition.commodities, permitType === null || permitType === void 0 ? void 0 : permitType.allowedCommodities);
-        return commodities;
+        if (!permitTypeId) {
+            // Permit type not supplied, return all commodities
+            return (0, lists_helper_1.extractIdentifiedObjects)(this.policyDefinition.commodities);
+        }
+        else if (!permitType) {
+            // Permit type invalid, throw error
+            throw new Error(`Invalid permit type supplied: '${permitTypeId}'`);
+        }
+        else if (!permitType.commodityRequired) {
+            return new Map();
+        }
+        else {
+            // Commodities for oversize permits are those which have at least one
+            // power unit defined in the size dimension object of the commodity.
+            const commoditiesForOS = (0, lists_helper_1.extractIdentifiedObjects)(this.policyDefinition.commodities.filter((c) => {
+                if (c.size) {
+                    if (c.size.powerUnits) {
+                        if (c.size.powerUnits.length > 0) {
+                            return true;
+                        }
+                    }
+                }
+                return false;
+            }), permitType.allowedCommodities);
+            // TODO when implementing overweight. Stub for now.
+            const commoditiesForOW = new Map();
+            if (permitType.sizeDimensionRequired &&
+                permitType.weightDimensionRequired) {
+                return (0, lists_helper_1.intersectIdMaps)(commoditiesForOS, commoditiesForOW);
+            }
+            else if (permitType.sizeDimensionRequired) {
+                return commoditiesForOS;
+            }
+            else if (permitType.weightDimensionRequired) {
+                return commoditiesForOW;
+            }
+            else {
+                // This permit type requires commodity selection, but does not
+                // require size or weight dimensions. For these permit types, the
+                // allowedCommodities must be configured in policy. Return these.
+                const commodities = (0, lists_helper_1.extractIdentifiedObjects)(this.policyDefinition.commodities, permitType.allowedCommodities);
+                return commodities;
+            }
+        }
+    }
+    /**
+     * Gets a list of all allowable vehicle types for the given permit type
+     * and commodity. Includes all power units and trailers.
+     * @param permitTypeId ID of the permit type to get vehicles for
+     * @param commodityId ID of the commodity to get vehicles for
+     * @returns Map of two separate maps, one keyed on 'powerUnits' and the
+     * other keyed on 'trailers'. Each map consists of a string id for the
+     * vehicle, and a string common name for the vehicle.
+     */
+    getPermittableVehicleTypes(permitTypeId, commodityId) {
+        var _a, _b, _c, _d;
+        if (!permitTypeId || !commodityId) {
+            throw new Error('Missing permitTypeId and/or commodityId');
+        }
+        const permitType = this.getPermitTypeDefinition(permitTypeId);
+        if (!permitType) {
+            throw new Error(`Invalid permit type: '${permitTypeId}'`);
+        }
+        if (!permitType.commodityRequired) {
+            // If commodity is not required, this method cannot calculate the
+            // permittable vehicle types since they will not be configured.
+            throw new Error(`Permit type '${permitTypeId}' does not require a commodity`);
+        }
+        let puTypes;
+        let trTypes;
+        const allowableCommodities = this.getCommodities(permitTypeId);
+        if (!allowableCommodities.has(commodityId)) {
+            // If the commodity is not allowed for the permit type, no power
+            // units or trailers are allowed.
+            puTypes = new Map();
+            trTypes = new Map();
+        }
+        else {
+            const commodity = this.getCommodityDefinition(commodityId);
+            if (!commodity) {
+                throw new Error(`Commodity id '${commodityId}' is not correctly configured in the policy definition`);
+            }
+            const puTypeIdsOS = (_b = (_a = commodity.size) === null || _a === void 0 ? void 0 : _a.powerUnits) === null || _b === void 0 ? void 0 : _b.map((p) => p.type);
+            const trTypeIdsOS = [];
+            (_d = (_c = commodity.size) === null || _c === void 0 ? void 0 : _c.powerUnits) === null || _d === void 0 ? void 0 : _d.forEach((pu) => {
+                const trForPu = pu.trailers.map((t) => t.type);
+                if (trForPu)
+                    trTypeIdsOS.concat(trForPu);
+            });
+            // TODO: implement along with overweight permits. Stub for now.
+            const puTypeIdsOW = [];
+            const trTypeIdsOW = [];
+            const puTypesOS = (0, lists_helper_1.extractIdentifiedObjects)(this.policyDefinition.vehicleTypes.powerUnitTypes, puTypeIdsOS);
+            const trTypesOS = (0, lists_helper_1.extractIdentifiedObjects)(this.policyDefinition.vehicleTypes.trailerTypes, trTypeIdsOS);
+            const puTypesOW = (0, lists_helper_1.extractIdentifiedObjects)(this.policyDefinition.vehicleTypes.powerUnitTypes, puTypeIdsOW);
+            const trTypesOW = (0, lists_helper_1.extractIdentifiedObjects)(this.policyDefinition.vehicleTypes.trailerTypes, trTypeIdsOW);
+            if (permitType.sizeDimensionRequired &&
+                permitType.weightDimensionRequired) {
+                puTypes = (0, lists_helper_1.intersectIdMaps)(puTypesOS, puTypesOW);
+                trTypes = (0, lists_helper_1.intersectIdMaps)(trTypesOS, trTypesOW);
+            }
+            else if (permitType.sizeDimensionRequired) {
+                puTypes = puTypesOS;
+                trTypes = trTypesOS;
+            }
+            else if (permitType.weightDimensionRequired) {
+                puTypes = puTypesOW;
+                trTypes = trTypesOW;
+            }
+            else {
+                // This permit type requires commodity selection, but does not
+                // require size or weight dimensions. For these permit types, the
+                // allowedVehicles must be configured in policy. Return all power
+                // units and trailers from this list.
+                puTypes = (0, lists_helper_1.extractIdentifiedObjects)(this.policyDefinition.vehicleTypes.powerUnitTypes, permitType.allowedVehicles);
+                trTypes = (0, lists_helper_1.extractIdentifiedObjects)(this.policyDefinition.vehicleTypes.trailerTypes, permitType.allowedVehicles);
+            }
+        }
+        const vehicleTypes = new Map();
+        vehicleTypes.set(enum_1.VehicleTypes.PowerUnits, puTypes);
+        vehicleTypes.set(enum_1.VehicleTypes.Trailers, trTypes);
+        return vehicleTypes;
+    }
+    /**
+     * Gets a list of all allowable power unit types for the given permit type
+     * and commodity.
+     * @param permitTypeId ID of the permit type to get power units for
+     * @param commodityId ID of the commodity to get power units for
+     * @returns Map of power unit IDs to power unit names.
+     */
+    getPermittablePowerUnitTypes(permitTypeId, commodityId) {
+        const vehicleTypes = this.getPermittableVehicleTypes(permitTypeId, commodityId);
+        const puTypes = vehicleTypes.get(enum_1.VehicleTypes.PowerUnits);
+        return puTypes !== null && puTypes !== void 0 ? puTypes : new Map();
+    }
+    /**
+     * Gets the next permittable vehicles based on the supplied permit type,
+     * commodity, and current configuration.
+     * If the permit type does not require commodity or if the commodity
+     * is not valid for the permit type, this will return an empty map
+     * (meaning no vehicles are permittable).
+     * @param permitTypeId ID of the permit type to get vehicles for
+     * @param commodityId ID of the commodity to get vehicles for
+     * @param currentConfiguration Current vehicle configuration to which will be
+     * added the next permittable vehicle
+     * @returns Map of vehicle ID to vehicle name. Includes both power units and
+     * trailers in a single return value (if applicable).
+     */
+    getNextPermittableVehicles(permitTypeId, commodityId, currentConfiguration) {
+        var _a, _b, _c, _d;
+        if (!permitTypeId || !commodityId || !currentConfiguration) {
+            throw new Error('Missing permitTypeId and/or commodityId and/or currentConfiguration');
+        }
+        const permitType = this.getPermitTypeDefinition(permitTypeId);
+        if (!permitType) {
+            throw new Error(`Invalid permit type: '${permitTypeId}'`);
+        }
+        if (!permitType.commodityRequired) {
+            // If commodity is not required, this method cannot calculate the
+            // permittable vehicle types since they will not be configured.
+            throw new Error(`Permit type '${permitTypeId}' does not require a commodity`);
+        }
+        const commodity = this.getCommodityDefinition(commodityId);
+        if (!commodity) {
+            throw new Error(`Invalid commodity type: '${commodityId}'`);
+        }
+        if (!this.isConfigurationValid(permitTypeId, commodityId, currentConfiguration, true)) {
+            // Invalid configuration, no vehicles permitted
+            return new Map();
+        }
+        let vehicleTypes = new Map();
+        let vehicleTypeIds;
+        const allVehicles = this.policyDefinition.vehicleTypes.powerUnitTypes.concat(this.policyDefinition.vehicleTypes.trailerTypes);
+        if (currentConfiguration.length == 0) {
+            // The current configuration is empty, so return only the
+            // allowable power units.
+            vehicleTypeIds = (_b = (_a = commodity.size) === null || _a === void 0 ? void 0 : _a.powerUnits) === null || _b === void 0 ? void 0 : _b.map((p) => p.type);
+        }
+        else {
+            const powerUnit = (_d = (_c = commodity.size) === null || _c === void 0 ? void 0 : _c.powerUnits) === null || _d === void 0 ? void 0 : _d.find((p) => p.type == currentConfiguration[0]);
+            const trailerIds = powerUnit === null || powerUnit === void 0 ? void 0 : powerUnit.trailers.map((t) => t.type);
+            if (currentConfiguration.length == 1) {
+                // Just a power unit, return the list of trailerIds for the
+                // power unit, plus jeep if any of the trailer Ids allow
+                // a jeep.
+                if ((powerUnit === null || powerUnit === void 0 ? void 0 : powerUnit.trailers) &&
+                    (powerUnit === null || powerUnit === void 0 ? void 0 : powerUnit.trailers.filter((t) => t.jeep).length) > 0) {
+                    trailerIds === null || trailerIds === void 0 ? void 0 : trailerIds.push(enum_1.AccessoryVehicleType.Jeep);
+                }
+                vehicleTypeIds = trailerIds;
+            }
+            else {
+                const lastVehicleId = currentConfiguration[currentConfiguration.length - 1];
+                switch (lastVehicleId) {
+                    case enum_1.AccessoryVehicleType.Jeep:
+                        // If there is one jeep, there can be more
+                        trailerIds === null || trailerIds === void 0 ? void 0 : trailerIds.push(enum_1.AccessoryVehicleType.Jeep);
+                        vehicleTypeIds = trailerIds;
+                        break;
+                    case enum_1.AccessoryVehicleType.Booster:
+                        // If there is one booster, there can be more
+                        vehicleTypeIds = [enum_1.AccessoryVehicleType.Booster];
+                        break;
+                    default:
+                        {
+                            const trailer = powerUnit === null || powerUnit === void 0 ? void 0 : powerUnit.trailers.find((t) => t.type == lastVehicleId);
+                            if (trailer && trailer.booster) {
+                                vehicleTypeIds = [enum_1.AccessoryVehicleType.Booster];
+                            }
+                            else {
+                                vehicleTypeIds = new Array();
+                            }
+                        }
+                        break;
+                }
+            }
+        }
+        vehicleTypes = (0, lists_helper_1.extractIdentifiedObjects)(allVehicles, vehicleTypeIds);
+        return vehicleTypes;
+    }
+    /**
+     * Returns whether the supplied configuration is valid for the given permit type
+     * and commodity. If the permit type does not require a commodity, this method
+     * will return false. This will not validate incomplete configurations - if the
+     * current configuration has only a power unit this will return false even if the
+     * power unit is acceptable because there is no trailer which is mandatory.
+     * If this is called for a permit type that does not require commodity, or with
+     * a commodity not permitted for the permit type, it will return false.
+     * @param permitTypeId ID of the permit type to validate the configuration against
+     * @param commodityId ID of the commodity used for the configuration
+     * @param currentConfiguration Current vehicle configuration to validate
+     * @param validatePartial Whether to validate a partial configuration (e.g. one
+     * that does not include a trailer). This will just return whether or not there
+     * are any invalid vehicles in the configuration. If true, an empty current
+     * configuration will return true from this method.
+     */
+    isConfigurationValid(permitTypeId, commodityId, currentConfiguration, validatePartial = false) {
+        var _a, _b;
+        if (!permitTypeId || !commodityId || !currentConfiguration) {
+            throw new Error('Missing permitTypeId and/or commodityId and/or currentConfiguration');
+        }
+        const permitType = this.getPermitTypeDefinition(permitTypeId);
+        if (!permitType) {
+            throw new Error(`Invalid permit type: '${permitTypeId}'`);
+        }
+        if (!permitType.commodityRequired) {
+            // If commodity is not required, this method cannot calculate the
+            // permittable vehicle types since they will not be configured.
+            throw new Error(`Permit type '${permitTypeId}' does not require a commodity`);
+        }
+        const commodity = this.getCommodityDefinition(commodityId);
+        if (!commodity) {
+            throw new Error(`Invalid commodity type: '${commodityId}'`);
+        }
+        if (currentConfiguration.length == 0) {
+            // The current configuration is empty. Fine for partial, but
+            // invalid as a complete configuration.
+            return validatePartial;
+        }
+        const powerUnit = (_b = (_a = commodity.size) === null || _a === void 0 ? void 0 : _a.powerUnits) === null || _b === void 0 ? void 0 : _b.find((p) => p.type == currentConfiguration[0]);
+        if (!powerUnit) {
+            // The power unit is not allowed for the commodity
+            return false;
+        }
+        let trailerIds = powerUnit.trailers.map((t) => t.type);
+        let jeepAllowed = true;
+        let trailerAllowed = true;
+        let boosterAllowed = false;
+        for (let i = 1; i < currentConfiguration.length; i++) {
+            switch (currentConfiguration[i]) {
+                case enum_1.AccessoryVehicleType.Jeep:
+                    if (!jeepAllowed) {
+                        return false;
+                    }
+                    // Filter allowed trailers to only those that allow jeeps
+                    trailerIds = powerUnit.trailers
+                        .filter((t) => t.jeep)
+                        .map((t) => t.type);
+                    break;
+                case enum_1.AccessoryVehicleType.Booster:
+                    if (!boosterAllowed) {
+                        return false;
+                    }
+                    break;
+                default:
+                    if (!trailerAllowed) {
+                        return false;
+                    }
+                    {
+                        const trailer = powerUnit.trailers.find((t) => t.type == currentConfiguration[i]);
+                        if (!trailer || !trailerIds.includes(currentConfiguration[i])) {
+                            // This trailer is not permitted for this power unit
+                            return false;
+                        }
+                        jeepAllowed = false;
+                        trailerAllowed = false;
+                        boosterAllowed = trailer.booster;
+                    }
+                    break;
+            }
+        }
+        // We are still here, so configuration is valid. If there is a trailer
+        // it is a valid final configuration, otherwise it is a valid partial
+        // configuration.
+        return !trailerAllowed || validatePartial;
+    }
+    /**
+     * Gets the maximum size dimensions for a given permit type, commodity,
+     * and vehicle configuration. A vehicle configuration's size dimension is
+     * dictated by the configuration on the trailer. For configurations that
+     * are just a power unit, a pseudo trailer type 'NONE' is used and the
+     * size dimension is configured on that. Accessory category trailers
+     * (e.g. jeeps and boosters) are not used for configuration since they
+     * do not impact the size dimension in policy.
+     * @param permitTypeId ID of the permit type to get size dimension for
+     * @param commodityId ID of the commodity to get size dimension for
+     * @param currentConfiguration Current vehicle configuration to get size dimension for
+     * @param regions List of regions the vehicle will be traveling in. If not
+     * supplied this defaults to the most restrictive size dimension (if multiple
+     * are configured).
+     * @returns SizeDimension for the given permit type, commodity, and configuration
+     */
+    getSizeDimension(permitTypeId, commodityId, configuration, regions) {
+        var _a, _b, _c;
+        // Initialize the sizeDimension with global defaults
+        let sizeDimension = null;
+        // Validate that the configuration is permittable
+        if (this.isConfigurationValid(permitTypeId, commodityId, configuration)) {
+            // Get the power unit that has the size configuration
+            const commodity = this.getCommodityDefinition(commodityId);
+            const powerUnit = (_b = (_a = commodity === null || commodity === void 0 ? void 0 : commodity.size) === null || _a === void 0 ? void 0 : _a.powerUnits) === null || _b === void 0 ? void 0 : _b.find((pu) => pu.type == configuration[0]);
+            if (!powerUnit) {
+                throw new Error(`Configuration error: could not find power unit '${configuration[0]}'`);
+            }
+            // Get the last trailer in the configuration that can be used for size calculations
+            const sizeTrailer = Array.from(configuration)
+                .reverse()
+                .find((vehicleId) => {
+                var _a;
+                const trailerType = (_a = this.policyDefinition.vehicleTypes.trailerTypes) === null || _a === void 0 ? void 0 : _a.find((v) => v.id == vehicleId);
+                return !(trailerType === null || trailerType === void 0 ? void 0 : trailerType.ignoreForSizeDimensions);
+            });
+            if (sizeTrailer) {
+                // Get the trailer size dimension array for the commodity
+                const trailer = (_c = powerUnit.trailers) === null || _c === void 0 ? void 0 : _c.find((t) => t.type == sizeTrailer);
+                let sizeDimensions;
+                if (trailer &&
+                    trailer.sizeDimensions &&
+                    trailer.sizeDimensions.length > 0) {
+                    sizeDimensions = trailer.sizeDimensions;
+                }
+                else {
+                    sizeDimensions = new Array();
+                }
+                const sizeDimensionConfigured = this.selectCorrectSizeDimension(sizeDimensions, configuration, sizeTrailer);
+                if (sizeDimensionConfigured) {
+                    // Adjust the size dimensions for the regions travelled, if needed
+                    if (!regions) {
+                        // If we are not provided a list of regions, assume we are
+                        // traveling through all regions (will take the most restrictive
+                        // of all dimensions in all cases).
+                        console.log('Assuming all regions for size dimension lookup');
+                        regions = this.policyDefinition.geographicRegions.map((g) => g.id);
+                    }
+                    else {
+                        console.log(`Using '${regions}' as regions for size lookup`);
+                    }
+                    const valueOverrides = [];
+                    regions === null || regions === void 0 ? void 0 : regions.forEach((r) => {
+                        var _a, _b, _c, _d;
+                        let valueOverride;
+                        // Check to see if this region has specific size dimensions
+                        const regionOverride = (_a = sizeDimensionConfigured.regions) === null || _a === void 0 ? void 0 : _a.find((cr) => cr.region == r);
+                        if (!regionOverride) {
+                            // The region travelled does not have an override, so it assumes
+                            // the dimensions of the bc default.
+                            valueOverride = {
+                                region: r,
+                                h: sizeDimensionConfigured.h,
+                                w: sizeDimensionConfigured.w,
+                                l: sizeDimensionConfigured.l,
+                            };
+                        }
+                        else {
+                            // There is a region override with one or more dimensions. Use this
+                            // value preferentially, using default dimension if not supplied
+                            valueOverride = {
+                                region: r,
+                                h: (_b = regionOverride.h) !== null && _b !== void 0 ? _b : sizeDimensionConfigured.h,
+                                w: (_c = regionOverride.w) !== null && _c !== void 0 ? _c : sizeDimensionConfigured.w,
+                                l: (_d = regionOverride.l) !== null && _d !== void 0 ? _d : sizeDimensionConfigured.l,
+                            };
+                        }
+                        valueOverrides.push(valueOverride);
+                    });
+                    // At this point we have a complete set of size dimensions for each of
+                    // the regions that will be traversed. Take the minimum value of each
+                    // dimension for the final value.
+                    const minimumOverrides = valueOverrides.reduce((accumulator, currentValue) => {
+                        if (typeof currentValue.h !== 'undefined') {
+                            if (typeof accumulator.h === 'undefined') {
+                                accumulator.h = currentValue.h;
+                            }
+                            else {
+                                accumulator.h = Math.min(accumulator.h, currentValue.h);
+                            }
+                        }
+                        if (typeof currentValue.w !== 'undefined') {
+                            if (typeof accumulator.w === 'undefined') {
+                                accumulator.w = currentValue.w;
+                            }
+                            else {
+                                accumulator.w = Math.min(accumulator.w, currentValue.w);
+                            }
+                        }
+                        if (typeof currentValue.l !== 'undefined') {
+                            if (typeof accumulator.l === 'undefined') {
+                                accumulator.l = currentValue.l;
+                            }
+                            else {
+                                accumulator.l = Math.min(accumulator.l, currentValue.l);
+                            }
+                        }
+                        return accumulator;
+                    }, { region: '' });
+                    sizeDimension = {
+                        rp: sizeDimensionConfigured.rp,
+                        fp: sizeDimensionConfigured.fp,
+                        h: minimumOverrides.h,
+                        w: minimumOverrides.w,
+                        l: minimumOverrides.l,
+                    };
+                }
+                else {
+                    console.log('Size dimension not configured for trailer');
+                }
+            }
+            else {
+                console.log('Could not locate trailer to use for size dimension');
+            }
+        }
+        else {
+            console.log('Configuration is invalid, returning null size dimension');
+        }
+        return sizeDimension;
+    }
+    /**
+     * Selects the correct size dimension from a list of potential candidates, based
+     * on the modifier of each dimension. If none of the modifiers match, returns
+     * null.
+     * @param sizeDimensions Size dimension options to choose from
+     * @param currentConfiguration The full vehicle configuration
+     */
+    selectCorrectSizeDimension(sizeDimensions, configuration, sizeTrailer) {
+        var _a;
+        let matchingDimension = null;
+        if ((sizeDimensions === null || sizeDimensions === void 0 ? void 0 : sizeDimensions.length) > 0 && (configuration === null || configuration === void 0 ? void 0 : configuration.length) > 0) {
+            for (const sizeDimension of sizeDimensions) {
+                if (!sizeDimension.modifiers) {
+                    // This dimension has no modifiers, so it is the default if none of
+                    // the other specific modifiers match.
+                    matchingDimension = sizeDimension;
+                    console.log('Using default size dimension, no modifiers specified');
+                }
+                else {
+                    const sizeTrailerIndex = configuration.findIndex((c) => sizeTrailer == c);
+                    const isMatch = (_a = sizeDimension.modifiers) === null || _a === void 0 ? void 0 : _a.every((m) => {
+                        if (!m.type) {
+                            return false;
+                        }
+                        switch (m.position) {
+                            case enum_1.RelativePosition.First.toString():
+                                return configuration[0] == m.type;
+                            case enum_1.RelativePosition.Last.toString():
+                                return configuration[configuration.length - 1] == m.type;
+                            case enum_1.RelativePosition.Before.toString():
+                                return configuration[sizeTrailerIndex - 1] == m.type;
+                            case enum_1.RelativePosition.After.toString():
+                                return configuration[sizeTrailerIndex + 1] == m.type;
+                            default:
+                                return false;
+                        }
+                    });
+                    // As soon as we find a dimension with matching modifiers,
+                    // set it and return it.
+                    if (isMatch) {
+                        matchingDimension = sizeDimension;
+                        break;
+                    }
+                }
+            }
+        }
+        else {
+            console.log('Either size dimensions or configuration array is null, no matching dimension returned');
+        }
+        return matchingDimension;
     }
     /**
      * Gets a list of all configured power unit types in the policy definition.
@@ -104,5 +597,22 @@ class Policy {
             return null;
         }
     }
+    /**
+     * Gets a full Commodity definition by ID
+     * @param type Type ID of the commodity to return.
+     * @returns Commodity definition for the supplied ID.
+     */
+    getCommodityDefinition(type) {
+        let commodity;
+        if (this.policyDefinition.commodities) {
+            commodity = this.policyDefinition.commodities.find((c) => c.id === type);
+        }
+        if (commodity) {
+            return commodity;
+        }
+        else {
+            return null;
+        }
+    }
 }
 exports.Policy = Policy;

package/dist/rule-operator/custom-operators.js

@@ -16,7 +16,11 @@ function dateStringValidator(a) {
 }
 const CustomOperators = [];
 exports.CustomOperators = CustomOperators;
-CustomOperators.push(new json_rules_engine_1.Operator('stringMinimumLength', (a, b) => a.trim().length >= b, stringValidator));
+CustomOperators.push(new json_rules_engine_1.Operator('stringMinimumLength', (a, b) => {
+    if (!a)
+        return false;
+    return a.trim().length >= b;
+}, stringValidator));
 CustomOperators.push(new json_rules_engine_1.Operator('dateLessThan', (a, b) => {
     const firstDate = (0, dayjs_1.default)(a, enum_1.PermitAppInfo.PermitDateFormat.toString());
     const secondDate = (0, dayjs_1.default)(b, enum_1.PermitAppInfo.PermitDateFormat.toString());

package/dist/types/commodity.d.ts

@@ -1,5 +1,12 @@
-import { IdentifiedObject, PowerUnit, Trailer } from 'onroute-policy-engine/types';
+import { IdentifiedObject, VehicleSizeConfiguration, PowerUnitWeight, TrailerWeight } from 'onroute-policy-engine/types';
 export type Commodity = IdentifiedObject & {
-    powerUnits?: Array<PowerUnit>;
-    trailers?: Array<Trailer>;
+    size?: CommoditySize;
+    weight?: CommodityWeight;
+};
+export type CommoditySize = {
+    powerUnits?: Array<VehicleSizeConfiguration>;
+};
+export type CommodityWeight = {
+    powerUnits?: Array<PowerUnitWeight>;
+    trailers?: Array<TrailerWeight>;
 };

package/dist/types/cost-rule.d.ts

@@ -0,0 +1,4 @@
+export type CostRule = {
+    fact: string;
+    params: Record<string, any>;
+};

package/dist/types/cost-rule.js

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

package/dist/types/index.d.ts

@@ -1,14 +1,16 @@
-export { Commodity } from './commodity';
+export { Commodity, CommoditySize, CommodityWeight } from './commodity';
+export { CostRule } from './cost-rule';
 export { DimensionModifier } from './dimension-modifier';
 export { PermitFacts } from './facts';
 export { GeographicRegion } from './geographic-region';
 export { IdentifiedObject } from './identified-object';
 export { PermitType } from './permit-type';
 export { PolicyDefinition } from './policy-definition';
+export { Matrix, RangeMatrix } from './range-matrix';
 export { RegionSizeOverride } from './region-size-override';
 export { SelfIssuable } from './self-issuable';
 export { SizeDimension } from './size-dimension';
 export { VehicleCategory, PowerUnitCategory, TrailerCategory, VehicleCategories, } from './vehicle-category';
 export { VehicleType, PowerUnitType, TrailerType, VehicleTypes, } from './vehicle-type';
-export { Vehicle, PowerUnit, Trailer } from './vehicle';
+export { Vehicle, VehicleSizeConfiguration, TrailerSize, PowerUnitWeight, TrailerWeight, } from './vehicle';
 export { WeightDimension, PowerUnitWeightDimension, TrailerWeightDimension, DefaultWeightDimensions, } from './weight-dimension';

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

@@ -1,5 +1,5 @@
 import { RuleProperties } from 'json-rules-engine';
-import { IdentifiedObject } from 'onroute-policy-engine/types';
+import { CostRule, IdentifiedObject } from 'onroute-policy-engine/types';
 export type PermitType = IdentifiedObject & {
     routingRequired: boolean;
     weightDimensionRequired: boolean;
@@ -8,4 +8,5 @@ export type PermitType = IdentifiedObject & {
     allowedVehicles: Array<string>;
     allowedCommodities?: Array<string>;
     rules?: Array<RuleProperties>;
+    costRules?: Array<CostRule>;
 };

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

@@ -1,4 +1,4 @@
-import { GeographicRegion, PermitType, DefaultWeightDimensions, VehicleTypes, Commodity, SizeDimension, VehicleCategories } from 'onroute-policy-engine/types';
+import { GeographicRegion, PermitType, DefaultWeightDimensions, VehicleTypes, Commodity, SizeDimension, VehicleCategories, RangeMatrix } from 'onroute-policy-engine/types';
 import { RuleProperties } from 'json-rules-engine';
 export type PolicyDefinition = {
     version: string;
@@ -10,4 +10,5 @@ export type PolicyDefinition = {
     vehicleCategories: VehicleCategories;
     vehicleTypes: VehicleTypes;
     commodities: Array<Commodity>;
+    rangeMatrices?: Array<RangeMatrix>;
 };

package/dist/types/range-matrix.d.ts

@@ -0,0 +1,9 @@
+import { IdentifiedObject } from 'onroute-policy-engine/types';
+export type RangeMatrix = IdentifiedObject & {
+    matrix: Matrix[];
+};
+export type Matrix = {
+    min?: number;
+    max?: number;
+    value: number;
+};

package/dist/types/range-matrix.js

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

package/dist/types/region-size-override.d.ts

@@ -1,6 +1,6 @@
 export type RegionSizeOverride = {
     region: string;
-    width?: number;
-    height?: number;
-    length?: number;
+    w?: number;
+    h?: number;
+    l?: number;
 };

package/dist/types/self-issuable.d.ts

@@ -1,3 +1,3 @@
 export type SelfIssuable = {
-    canSelfIssue?: boolean;
+    selfIssue?: boolean;
 };