onroute-policy-engine 2.1.1 → 2.2.0

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

@@ -1,4 +1,11 @@
 "use strict";
+/**
+ * Custom Operators for JSON Rules Engine
+ *
+ * This module defines custom operators that extend the functionality of the json-rules-engine
+ * library. These operators provide specialized validation and comparison logic for the
+ * onRouteBC policy engine.
+ */
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -7,23 +14,70 @@ exports.CustomOperators = void 0;
 const json_rules_engine_1 = require("json-rules-engine");
 const enum_1 = require("onroute-policy-engine/enum");
 const dayjs_1 = __importDefault(require("dayjs"));
+/**
+ * Validates that the input is a string type
+ * @param a - The value to validate
+ * @returns True if the value is a string, false otherwise
+ */
 function stringValidator(a) {
     return typeof a === 'string';
 }
+/**
+ * Validates that the input is a valid date string in the permit application format
+ * @param a - The date string to validate
+ * @returns True if the date string is valid, false otherwise
+ */
 function dateStringValidator(a) {
     const d = (0, dayjs_1.default)(a, enum_1.PermitAppInfo.PermitDateFormat.toString());
     return d.isValid();
 }
+/**
+ * Validates that the input is an array
+ * @param a - The value to validate
+ * @returns True if the value is an array, false otherwise
+ */
+function arrayValidator(a) {
+    return Array.isArray(a);
+}
+// Array to store all custom operators
 const CustomOperators = [];
 exports.CustomOperators = CustomOperators;
-CustomOperators.push(new json_rules_engine_1.Operator('stringMinimumLength', (a, b) => {
+/**
+ * String Minimum Length Operator
+ *
+ * Checks if a string has a minimum length after trimming whitespace.
+ * Returns false if the input is falsy (null, undefined, empty string).
+ */
+CustomOperators.push(new json_rules_engine_1.Operator(enum_1.CustomOperator.StringMinimumLength, (a, b) => {
+    // Return false for falsy values
     if (!a)
         return false;
+    // Check if trimmed string length meets minimum requirement
     return a.trim().length >= b;
 }, stringValidator));
-CustomOperators.push(new json_rules_engine_1.Operator('dateLessThan', (a, b) => {
+/**
+ * Date Less Than Operator
+ *
+ * Compares two date strings in permit application format.
+ * Returns true if the first date is before the second date.
+ */
+CustomOperators.push(new json_rules_engine_1.Operator(enum_1.CustomOperator.DateLessThan, (a, b) => {
+    // Parse both dates using the permit application date format
     const firstDate = (0, dayjs_1.default)(a, enum_1.PermitAppInfo.PermitDateFormat.toString());
     const secondDate = (0, dayjs_1.default)(b, enum_1.PermitAppInfo.PermitDateFormat.toString());
+    // Return true if first date is before second date (difference is negative)
     return firstDate.diff(secondDate) < 0;
 }, dateStringValidator));
-CustomOperators.push(new json_rules_engine_1.Operator('regex', (a, b) => RegExp(b).exec(a) !== null, stringValidator));
+/**
+ * Regular Expression Operator
+ *
+ * Tests if a string matches a regular expression pattern.
+ * Uses RegExp.exec() to check for matches.
+ */
+CustomOperators.push(new json_rules_engine_1.Operator(enum_1.CustomOperator.Regex, (a, b) => RegExp(b).exec(a) !== null, stringValidator));
+/**
+ * Is Empty Array Operator
+ *
+ * Checks if an array is empty (has length 0).
+ */
+CustomOperators.push(new json_rules_engine_1.Operator(enum_1.CustomOperator.IsEmptyArray, (arr) => arr.length === 0, arrayValidator));

package/dist/types/axle-calculation-results.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Axle Calculation Results Types
+ *
+ * These types define the structure for axle calculation results and policy check outcomes.
+ * Used for validating vehicle configurations against weight and axle requirements.
+ */
+import { PolicyCheckResultType } from 'onroute-policy-engine/enum';
+/**
+ * Complete results from axle calculations including all policy checks and total overload
+ */
+export type AxleCalcResults = {
+    /** Array of individual policy check results */
+    results: Array<PolicyCheckResult>;
+    /** Total weight overload across all axles in kilograms */
+    totalOverload: number;
+};
+/**
+ * Individual policy check result for a specific validation rule
+ */
+export type PolicyCheckResult = {
+    /** Actual weight measured/calculated in kilograms */
+    actualWeight?: number;
+    /** Maximum allowed weight threshold in kilograms */
+    thresholdWeight?: number;
+    /** Unique identifier for the policy check */
+    id: string;
+    /** Result of the policy check (pass/fail) */
+    result: PolicyCheckResultType;
+    /** Human-readable message describing the check result */
+    message: string;
+};
+/**
+ * Policy check result for a single axle unit
+ * Extends PolicyCheckResult with axle unit identification
+ */
+export type AxleUnitPolicyCheckResult = PolicyCheckResult & {
+    /** The axle unit number being checked */
+    axleUnit: number;
+};
+/**
+ * Policy check result for a group of axles
+ * Extends PolicyCheckResult with axle group range
+ */
+export type AxleGroupPolicyCheckResult = PolicyCheckResult & {
+    /** Starting axle unit number in the group */
+    startAxleUnit: number;
+    /** Ending axle unit number in the group */
+    endAxleUnit: number;
+};

package/dist/types/axle-calculation-results.js

@@ -0,0 +1,8 @@
+"use strict";
+/**
+ * Axle Calculation Results Types
+ *
+ * These types define the structure for axle calculation results and policy check outcomes.
+ * Used for validating vehicle configurations against weight and axle requirements.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -1,8 +1,20 @@
+/**
+ * Axle Configuration Type
+ *
+ * Defines the structure for individual axle configurations within a vehicle.
+ * Used for weight calculations, spacing requirements, and compliance validation.
+ */
 export type AxleConfiguration = {
+    /** Number of axles in this configuration (1 for single, 2+ for groups) */
     numberOfAxles: number;
+    /** Total spread between first and last axle in centimeters */
     axleSpread?: number;
+    /** Spacing from the previous axle unit in centimeters */
     interaxleSpacing?: number;
+    /** Weight carried by this axle unit in kilograms */
     axleUnitWeight: number;
+    /** Number of tires on this axle unit */
     numberOfTires?: number;
+    /** Tire size in inches */
     tireSize?: number;
 };

package/dist/types/axle-configuration.js

@@ -1,2 +1,8 @@
 "use strict";
+/**
+ * Axle Configuration Type
+ *
+ * Defines the structure for individual axle configurations within a vehicle.
+ * Used for weight calculations, spacing requirements, and compliance validation.
+ */
 Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/bridge-calculation-constants.d.ts

@@ -1,4 +1,12 @@
+/**
+ * Bridge Calculation Constants Type
+ *
+ * Defines constants used in bridge formula calculations for determining
+ * maximum allowable weights based on axle spacing and configuration.
+ */
 export type BridgeCalculationConstants = {
+    /** Multiplier factor for bridge formula calculations */
     multiplier: number;
+    /** Minimum weight threshold in kilograms */
     minWeight: number;
 };

package/dist/types/bridge-calculation-result.d.ts

@@ -1,7 +1,18 @@
+/**
+ * Bridge Calculation Result Type
+ *
+ * Defines the result structure for bridge formula calculations.
+ * Used to determine if a vehicle configuration meets bridge weight requirements.
+ */
 export type BridgeCalculationResult = {
+    /** Starting axle unit number in the calculation */
     startAxleUnit: number;
+    /** Ending axle unit number in the calculation */
     endAxleUnit: number;
+    /** Maximum allowable weight according to bridge formula in kilograms */
     maxBridge: number;
+    /** Actual weight being carried in kilograms */
     actualWeight: number;
+    /** Whether the configuration passes bridge formula requirements */
     success: boolean;
 };

package/dist/types/commodity.d.ts

@@ -1,4 +1,14 @@
+/**
+ * Commodity Type
+ *
+ * Defines the structure for permitted commodities that can be transported.
+ * Extends IdentifiedObject with vehicle dimension requirements.
+ */
 import { IdentifiedObject, VehicleDimensions } from 'onroute-policy-engine/types';
+/**
+ * A permitted commodity that can be transported with specific vehicle requirements
+ */
 export type Commodity = IdentifiedObject & {
+    /** Array of power unit dimensions required for this commodity */
     powerUnits: Array<VehicleDimensions>;
 };

package/dist/types/commodity.js

@@ -1,2 +1,8 @@
 "use strict";
+/**
+ * Commodity Type
+ *
+ * Defines the structure for permitted commodities that can be transported.
+ * Extends IdentifiedObject with vehicle dimension requirements.
+ */
 Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -1,4 +1,12 @@
+/**
+ * Cost Rule Type
+ *
+ * Defines the structure for cost calculation rules used in permit pricing.
+ * Maps facts to parameters for dynamic cost calculations.
+ */
 export type CostRule = {
+    /** The fact identifier used in the cost calculation */
     fact: string;
+    /** Parameters passed to the cost calculation function */
     params: Record<string, any>;
 };

package/dist/types/cost-rule.js

@@ -1,2 +1,8 @@
 "use strict";
+/**
+ * Cost Rule Type
+ *
+ * Defines the structure for cost calculation rules used in permit pricing.
+ * Maps facts to parameters for dynamic cost calculations.
+ */
 Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/dimension-modifier.d.ts

@@ -1,19 +1,46 @@
+/**
+ * Dimension Modifier Types
+ *
+ * Defines structures for modifying vehicle dimensions based on configuration
+ * and relationships between vehicle components.
+ */
 import { SelfIssuable } from 'onroute-policy-engine/types';
+/**
+ * Modifier for adjusting vehicle dimensions based on configuration
+ * Extends SelfIssuable to include self-issuance capability
+ */
 export type DimensionModifier = SelfIssuable & {
+    /** Position identifier for the modifier (e.g., 'first', 'last', 'next') */
     position: string;
+    /** Type of vehicle component being modified */
     type?: string;
+    /** Category of vehicle component being modified */
     category?: string;
+    /** Number of axles in the axle unit affected by this modifier */
     axles?: number;
+    /** Minimum interaxle spacing in millimeters */
     minInterAxleSpacing?: number;
+    /** Maximum interaxle spacing in millimeters */
     maxInterAxleSpacing?: number;
 };
+/**
+ * Defines relationships between vehicle components for dimension calculations
+ */
 export type VehicleRelatives = {
+    /** First vehicle type in the configuration */
     firstType: string;
+    /** Last vehicle type in the configuration */
     lastType?: string;
+    /** Next vehicle type in sequence */
     nextType?: string | null;
+    /** Previous vehicle type in sequence */
     prevType?: string | null;
+    /** First vehicle category in the configuration */
     firstCategory?: string | null;
+    /** Last vehicle category in the configuration */
     lastCategory?: string | null;
+    /** Next vehicle category in sequence */
     nextCategory?: string | null;
+    /** Previous vehicle category in sequence */
     prevCategory?: string | null;
 };

package/dist/types/dimension-modifier.js

@@ -1,2 +1,8 @@
 "use strict";
+/**
+ * Dimension Modifier Types
+ *
+ * Defines structures for modifying vehicle dimensions based on configuration
+ * and relationships between vehicle components.
+ */
 Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -1,18 +1,40 @@
+/**
+ * Vehicle Display Code Defaults Type
+ *
+ * Defines default values and formatting rules for generating vehicle display codes.
+ * Used for creating standardized vehicle identification codes across the system.
+ */
 export type VehicleDisplayCodeDefaults = {
+    /** Standard prefix for display codes */
     prefixStandard: string;
+    /** Universal prefix for display codes */
     prefixUniversal: string;
+    /** Standard padding character for display codes */
     paddingStandard: string;
+    /** Universal padding character for display codes */
     paddingUniversal: string;
+    /** Default spacing for universal display codes */
     spacingUniversalDefault: string;
+    /** Spacing for small universal display codes */
     spacingUniversalSmall: string;
+    /** Spacing for large universal display codes */
     spacingUniversalLarge: string;
+    /** Maximum threshold for small universal spacing */
     spacingUniversalSmallMax: number;
+    /** Minimum threshold for large universal spacing */
     spacingUniversalLargeMin: number;
+    /** Code for extra axles in universal format */
     extraAxleUniversal: string;
+    /** Code for end axles in universal format */
     endAxleUniversal: string;
+    /** Maximum number of axles for standard format */
     maxAxlesStandard: number;
+    /** Threshold number of axles for universal format */
     thresholdAxlesUniversal: number;
+    /** Code for over-threshold axles in universal format */
     overAxlesCodeUniversal: string;
+    /** Universal axle code format */
     universalAxleCode: string;
+    /** Prefix for multi-digit axle codes */
     multiDigitPrefix: string;
 };

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

@@ -1,2 +1,8 @@
 "use strict";
+/**
+ * Vehicle Display Code Defaults Type
+ *
+ * Defines default values and formatting rules for generating vehicle display codes.
+ * Used for creating standardized vehicle identification codes across the system.
+ */
 Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/facts.d.ts

@@ -1,10 +1,24 @@
+/**
+ * Permit Facts Type
+ *
+ * Defines the structure for permit application facts used in policy validation.
+ * Contains essential information about the permit application and vehicle.
+ */
 export type PermitFacts = {
+    /** Company name applying for the permit */
     companyName?: string;
+    /** Duration of the permit in days */
     duration?: number;
+    /** Type of permit being applied for */
     permitType?: string;
+    /** Start date of the permit (YYYY-MM-DD format) */
     startDate?: string;
+    /** Vehicle Identification Number */
     vehicleIdentificationNumber?: string;
+    /** Vehicle license plate number */
     vehiclePlate?: string;
+    /** Type of vehicle permitted (primary vehicle) (e.g., 'TRKTRAC') */
     vehicleType?: string;
+    /** Additional application data as a generic object */
     app?: object;
 };

package/dist/types/facts.js

@@ -1,2 +1,8 @@
 "use strict";
+/**
+ * Permit Facts Type
+ *
+ * Defines the structure for permit application facts used in policy validation.
+ * Contains essential information about the permit application and vehicle.
+ */
 Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/geographic-region.d.ts

@@ -1,4 +1,14 @@
+/**
+ * Geographic Region Type
+ *
+ * Defines the structure for geographic regions used in permit routing and validation.
+ * Extends IdentifiedObject with optional description for enhanced identification.
+ */
 import { IdentifiedObject } from 'onroute-policy-engine/types';
+/**
+ * A geographic region with identification and optional description
+ */
 export type GeographicRegion = IdentifiedObject & {
+    /** Optional description of the geographic region */
     description?: string;
 };

package/dist/types/geographic-region.js

@@ -1,2 +1,8 @@
 "use strict";
+/**
+ * Geographic Region Type
+ *
+ * Defines the structure for geographic regions used in permit routing and validation.
+ * Extends IdentifiedObject with optional description for enhanced identification.
+ */
 Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/identified-object.d.ts

@@ -1,4 +1,12 @@
+/**
+ * Identified Object Type
+ *
+ * Base type for objects that require unique identification and naming.
+ * Used as a foundation for many other types in the system.
+ */
 export type IdentifiedObject = {
+    /** Unique identifier for the object */
     id: string;
+    /** Human-readable name for the object */
     name: string;
 };

package/dist/types/identified-object.js

@@ -1,2 +1,8 @@
 "use strict";
+/**
+ * Identified Object Type
+ *
+ * Base type for objects that require unique identification and naming.
+ * Used as a foundation for many other types in the system.
+ */
 Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/index.d.ts

@@ -1,3 +1,4 @@
+export { AxleCalcResults, PolicyCheckResult, AxleUnitPolicyCheckResult, AxleGroupPolicyCheckResult, } from './axle-calculation-results';
 export { AxleConfiguration } from './axle-configuration';
 export { BridgeCalculationConstants } from './bridge-calculation-constants';
 export { BridgeCalculationResult } from './bridge-calculation-result';

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

@@ -1,93 +1,202 @@
+/**
+ * Permit Application Types
+ *
+ * Defines the complete structure for permit applications including contact details,
+ * vehicle information, routing, and configuration data.
+ */
 import { AxleConfiguration } from 'onroute-policy-engine/types';
+/**
+ * Mailing address for permit correspondence
+ */
 export type PermitMailingAddress = {
+    /** Primary address line */
     addressLine1: string;
+    /** Secondary address line (optional) */
     addressLine2?: string | null;
+    /** City name */
     city: string;
+    /** Province/state code (e.g., 'BC', 'AB') */
     provinceCode: string;
+    /** Country code (e.g., 'CA', 'US') */
     countryCode: string;
+    /** Postal/zip code */
     postalCode: string;
 };
+/**
+ * Contact information for the permit applicant
+ */
 export type PermitContactDetails = {
+    /** Contact's first name */
     firstName: string;
+    /** Contact's last name */
     lastName: string;
+    /** Primary phone number */
     phone1: string;
+    /** Primary phone extension (optional) */
     phone1Extension?: string | null;
+    /** Secondary phone number (optional) */
     phone2?: string | null;
+    /** Secondary phone extension (optional) */
     phone2Extension?: string | null;
+    /** Primary email address */
     email: string;
+    /** Additional email address (optional) */
     additionalEmail?: string | null;
+    /** Fax number (optional) */
     fax?: string | null;
 };
+/**
+ * Detailed information about the vehicle in the permit application
+ */
 export type PermitVehicleDetails = {
+    /** Internal vehicle identifier (optional) */
     vehicleId?: string | null;
+    /** Unit number for fleet vehicles (optional) */
     unitNumber?: string | null;
+    /** Vehicle Identification Number */
     vin: string;
+    /** License plate number */
     plate: string;
+    /** Vehicle make (optional) */
     make?: string | null;
+    /** Vehicle model year (optional) */
     year?: number | null;
+    /** Country code where vehicle is registered */
     countryCode: string;
+    /** Province/state code where vehicle is registered */
     provinceCode: string;
+    /** Type of vehicle (e.g., 'powerUnit', 'trailer') */
     vehicleType: string;
+    /** Subtype of vehicle (e.g., 'TRKTRAC', 'SEMITRL') */
     vehicleSubType: string;
+    /** Licensed Gross Vehicle Weight in kilograms (optional) */
     licensedGVW?: number | null;
+    /** Whether to save this vehicle to the inventory (optional) */
     saveVehicle?: boolean | null;
 };
+/**
+ * Commodity information for the permit application
+ */
 export type PermitCommodity = {
+    /** Description of the commodity being transported */
     description: string;
+    /** Special conditions for the commodity */
     condition: string;
+    /** Link to detailed commodity conditions */
     conditionLink: string;
+    /** Whether this commodity is selected */
     checked: boolean;
+    /** Whether this commodity option is disabled */
     disabled: boolean;
 };
+/**
+ * Complete permit data including all application details
+ */
 export type PermitData = {
+    /** Company name applying for the permit */
     companyName: string;
+    /** Doing Business As name (optional) */
     doingBusinessAs?: string;
+    /** Client number for the company */
     clientNumber: string;
+    /** Duration of the permit in days */
     permitDuration: number;
+    /** Array of commodities being transported */
     commodities: Array<PermitCommodity>;
+    /** Contact details for the applicant */
     contactDetails: PermitContactDetails;
+    /** Mailing address for correspondence */
     mailingAddress: PermitMailingAddress;
+    /** Detailed vehicle information */
     vehicleDetails: PermitVehicleDetails;
+    /** Fee summary information (optional) */
     feeSummary?: string | null;
+    /** Permit start date (YYYY-MM-DD format) */
     startDate: string;
+    /** Permit expiry date (YYYY-MM-DD format, optional) */
     expiryDate?: string | null;
+    /** Selected permitted commodity (optional) */
     permittedCommodity?: PermittedCommodity | null;
+    /** Vehicle configuration details (optional) */
     vehicleConfiguration?: VehicleConfiguration | null;
+    /** Permitted route information (optional) */
     permittedRoute?: PermittedRoute | null;
+    /** Additional application notes (optional) */
     applicationNotes?: string | null;
+    /** Third party liability information (optional) */
     thirdPartyLiability?: string | null;
+    /** Conditional licensing fee information (optional) */
     conditionalLicensingFee?: string | null;
 };
+/**
+ * Selected commodity for the permit with load description
+ */
 export type PermittedCommodity = {
+    /** Type of commodity being transported */
     commodityType: string;
+    /** Description of the load being transported */
     loadDescription: string;
 };
+/**
+ * Vehicle configuration within the permit application
+ */
 export type VehicleInConfiguration = {
+    /** Subtype of the vehicle */
     vehicleSubType: string;
 };
+/**
+ * Complete vehicle configuration including dimensions and axles
+ */
 export type VehicleConfiguration = {
+    /** Overall length in meters (optional) */
     overallLength?: number;
+    /** Overall width in meters (optional) */
     overallWidth?: number;
+    /** Overall height in meters (optional) */
     overallHeight?: number;
+    /** Front projection in meters (optional) */
     frontProjection?: number;
+    /** Rear projection in meters (optional) */
     rearProjection?: number;
+    /** Array of trailers in the configuration (optional) */
     trailers?: Array<VehicleInConfiguration> | null;
+    /** Loaded Gross Vehicle Weight in kilograms (optional) */
     loadedGVW?: number;
+    /** Net weight in kilograms (optional) */
     netWeight?: number;
+    /** Axle configuration details (optional) */
     axleConfiguration?: Array<AxleConfiguration>;
 };
+/**
+ * Route information for the permit
+ */
 export type PermittedRoute = {
+    /** Manual route details (optional) */
     manualRoute?: ManualRoute | null;
+    /** Additional route details (optional) */
     routeDetails?: string | null;
 };
+/**
+ * Manual route configuration with highway sequence
+ */
 export type ManualRoute = {
+    /** Sequence of highways for the route */
     highwaySequence: Array<string>;
+    /** Origin point of the route */
     origin: string;
+    /** Destination point of the route */
     destination: string;
+    /** Exit point from the route (optional) */
     exitPoint?: string;
+    /** Total distance in kilometers (optional) */
     totalDistance?: number;
 };
+/**
+ * Complete permit application structure
+ */
 export type PermitApplication = {
+    /** All permit data and details */
     permitData: PermitData;
+    /** Type of permit being applied for */
     permitType: string;
 };

package/dist/types/permit-application.js

@@ -1,2 +1,8 @@
 "use strict";
+/**
+ * Permit Application Types
+ *
+ * Defines the complete structure for permit applications including contact details,
+ * vehicle information, routing, and configuration data.
+ */
 Object.defineProperty(exports, "__esModule", { value: true });