@jetta/axle-load-calculator 0.1.3

package/build/core/physics/services/axle_weight_service.js

@@ -0,0 +1,91 @@
+import { MsFaixasContract } from '../../contracts/ms_faixas_contract.js';
+import { Transport } from '../transports/transport.js';
+import { Chassi } from '../transports/chassi.js';
+import { MergedContainers } from '../transports/merged_containers.js';
+import { AxleWeightModel } from '../models/axle_weight_model.js';
+import { build_axle_weights_output, select_axles_for_grouper } from './axle_weight_output_builder.js';
+const TRANSPORT_LIST_FLAG = 'envs';
+const TRANSPORT_ID_FLAG = 'idCaminhao';
+const CONTAINERS_FLAG = 'conteiners';
+const SEQUENCE_FLAG = 'sequencia';
+const FAIXAS_FLAG = 'faixas';
+const TARE_FLAG = 'tara';
+const ITEMS_FLAG = 'items';
+const MAX_SUPPORTED_FLAG = 'pesoSuportado';
+const CENTER_OF_GRAVITY_FLAG = 'centroGravidade';
+const AXLE_WEIGHTS_FLAG = 'pesoEixos';
+/**
+ * Full ms-faixas axle weight pipeline (Python AxleWeightService port).
+ */
+export class AxleWeightService {
+    transport;
+    chassi;
+    allocated_by_sequence;
+    /**
+     * @param input_data - Ms-faixas payload with envs.
+     */
+    constructor(input_data) {
+        const contract = new MsFaixasContract(input_data);
+        this.transport = new Transport(contract.transport_data);
+        this.chassi = new Chassi(this.transport);
+        this.allocated_by_sequence = contract.allocated_items_by_sequence_id;
+    }
+    /**
+     * @returns Math output with envs and pesoEixos per container.
+     */
+    run() {
+        return {
+            [TRANSPORT_LIST_FLAG]: [{
+                    [TRANSPORT_ID_FLAG]: this.transport.id,
+                    [CONTAINERS_FLAG]: this.build_containers_data()
+                }]
+        };
+    }
+    build_containers_data() {
+        const weights_by_sequence = this.evaluate_weight_on_axles();
+        const center_of_gravity = {};
+        for (const sequence of this.transport.list_containers_sequence_indexes()) {
+            center_of_gravity[sequence] = 0;
+        }
+        return this.transport.list_containers_sequence_indexes().map((sequence) => {
+            const container = this.transport.get_container_by_sequence_index(sequence);
+            return {
+                [SEQUENCE_FLAG]: container.sequence_index,
+                [FAIXAS_FLAG]: [],
+                [TARE_FLAG]: 0,
+                [ITEMS_FLAG]: [],
+                [MAX_SUPPORTED_FLAG]: container.max_supported_weight,
+                [CENTER_OF_GRAVITY_FLAG]: center_of_gravity[sequence],
+                [AXLE_WEIGHTS_FLAG]: weights_by_sequence[sequence] ?? []
+            };
+        });
+    }
+    evaluate_weight_on_axles() {
+        const model = new AxleWeightModel(this.transport);
+        const weight_on_axles = model.calculate_weight_on_axles(this.allocated_by_sequence);
+        const merged = new MergedContainers(this.transport);
+        const result = {};
+        for (const grouper of merged.list_grouper_indexes()) {
+            this.assign_grouper_axle_outputs({
+                grouper,
+                grouped: merged.get_container_by_grouper_index(grouper),
+                weight_on_axles,
+                result
+            });
+        }
+        return result;
+    }
+    assign_grouper_axle_outputs(input) {
+        const sequences = input.grouped.list_containers_sequence_indexes();
+        const axles = select_axles_for_grouper(this.transport, input.grouper);
+        input.result[sequences[0]] = build_axle_weights_output({
+            transport: this.transport,
+            chassi: this.chassi,
+            axles_indexes: axles,
+            weight_on_axles: input.weight_on_axles
+        });
+        for (let index = 1; index < sequences.length; index++) {
+            input.result[sequences[index]] = [];
+        }
+    }
+}

package/build/core/physics/services/cm_axle_weight_service.d.ts

@@ -0,0 +1,12 @@
+import type { TransportRecord } from '../../contracts/transport_record.js';
+/**
+ * Center-of-mass-driven axle weight service (port of CMAxleWeightService).
+ */
+export declare class CmAxleWeightService {
+    /**
+     * @param cm_axle_weight_data - Transport dict with center_of_mass map.
+     * @returns Loaded cargo weight per axle.
+     */
+    calculate(cm_axle_weight_data: TransportRecord): number[];
+}
+//# sourceMappingURL=cm_axle_weight_service.d.ts.map

package/build/core/physics/services/cm_axle_weight_service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cm_axle_weight_service.d.ts","sourceRoot":"","sources":["../../../../src/core/physics/services/cm_axle_weight_service.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,qCAAqC,CAAA;AAI1E;;GAEG;AACH,qBAAa,mBAAmB;IAE5B;;;OAGG;IACH,SAAS,CAAC,mBAAmB,EAAE,eAAe,GAAG,MAAM,EAAE;CAU5D"}

package/build/core/physics/services/cm_axle_weight_service.js

@@ -0,0 +1,33 @@
+import { WIRE_FLAGS } from '../../contracts/wire_flags.js';
+import { CenterOfMass } from '../items/center_of_mass.js';
+import { AxleWeightModel } from '../models/axle_weight_model.js';
+/**
+ * Center-of-mass-driven axle weight service (port of CMAxleWeightService).
+ */
+export class CmAxleWeightService {
+    /**
+     * @param cm_axle_weight_data - Transport dict with center_of_mass map.
+     * @returns Loaded cargo weight per axle.
+     */
+    calculate(cm_axle_weight_data) {
+        const model = new AxleWeightModel(cm_axle_weight_data);
+        const center_of_mass_by_grouper = read_center_of_mass_map(cm_axle_weight_data[WIRE_FLAGS.CM_SERVICE_CENTER_OF_MASS]);
+        const chassi_forces = model.calculate_chassi_forces_with_load_center_of_mass(center_of_mass_by_grouper);
+        return chassi_forces.list_axles_indexes().map((index) => chassi_forces.get_force_on_axle(index));
+    }
+}
+/**
+ * @param cm_data - Wire center_of_mass map.
+ * @returns Grouper id to CenterOfMass.
+ */
+function read_center_of_mass_map(cm_data) {
+    const result = {};
+    for (const grouper_key of Object.keys(cm_data)) {
+        const entry = cm_data[grouper_key];
+        const center_of_mass = new CenterOfMass();
+        center_of_mass.mass = Number(entry[WIRE_FLAGS.CM_SERVICE_MASS]);
+        center_of_mass.z = Number(entry[WIRE_FLAGS.CM_SERVICE_Z]);
+        result[Number(grouper_key)] = center_of_mass;
+    }
+    return result;
+}

package/build/core/physics/services/container_corner_forces.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Container corner force distribution (ISSUE-349).
+ */
+export declare class ContainerCornerForces {
+    private readonly input_data;
+    private readonly x_box_center;
+    private readonly z_box_center;
+    private readonly y_box_center;
+    private readonly weight_box;
+    private total_mass;
+    private x_cm;
+    private y_cm;
+    private z_cm;
+    private force_on_door;
+    private force_on_right_corner_door;
+    private force_on_left_corner_door;
+    private force_on_end_wall;
+    private force_on_right_corner_end_wall;
+    private force_on_left_corner_end_wall;
+    /**
+     * @param input_data - Items and container dimensions.
+     */
+    constructor(input_data: Record<string, unknown>);
+    /** Computes center of gravity from item boxes. */
+    calculate_cm(): void;
+    /** Computes corner reaction forces including container tare split. */
+    calculate_corner_forces(): void;
+    /**
+     * @returns Response JSON.
+     */
+    json(): Record<string, unknown>;
+}
+//# sourceMappingURL=container_corner_forces.d.ts.map

package/build/core/physics/services/container_corner_forces.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"container_corner_forces.d.ts","sourceRoot":"","sources":["../../../../src/core/physics/services/container_corner_forces.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,qBAAa,qBAAqB;IAoBlB,OAAO,CAAC,QAAQ,CAAC,UAAU;IAlBvC,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAe;IAC5C,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAe;IAC5C,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAe;IAC5C,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAe;IAC1C,OAAO,CAAC,UAAU,CAAI;IACtB,OAAO,CAAC,IAAI,CAAI;IAChB,OAAO,CAAC,IAAI,CAAI;IAChB,OAAO,CAAC,IAAI,CAAI;IAChB,OAAO,CAAC,aAAa,CAAsB;IAC3C,OAAO,CAAC,0BAA0B,CAAI;IACtC,OAAO,CAAC,yBAAyB,CAAI;IACrC,OAAO,CAAC,iBAAiB,CAAI;IAC7B,OAAO,CAAC,8BAA8B,CAAI;IAC1C,OAAO,CAAC,6BAA6B,CAAI;IAEzC;;OAEG;gBAC0B,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;IAahE,kDAAkD;IAClD,YAAY,IAAI,IAAI;IAOpB,sEAAsE;IACtE,uBAAuB,IAAI,IAAI;IAkB/B;;OAEG;IACH,IAAI,IAAI,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;CAkBlC"}

package/build/core/physics/services/container_corner_forces.js

@@ -0,0 +1,84 @@
+/**
+ * Container corner force distribution (ISSUE-349).
+ */
+export class ContainerCornerForces {
+    input_data;
+    x_box_center = [];
+    z_box_center = [];
+    y_box_center = [];
+    weight_box = [];
+    total_mass = 0;
+    x_cm = 0;
+    y_cm = 0;
+    z_cm = 0;
+    force_on_door = null;
+    force_on_right_corner_door = 0;
+    force_on_left_corner_door = 0;
+    force_on_end_wall = 0;
+    force_on_right_corner_end_wall = 0;
+    force_on_left_corner_end_wall = 0;
+    /**
+     * @param input_data - Items and container dimensions.
+     */
+    constructor(input_data) {
+        this.input_data = input_data;
+        const items = input_data.items;
+        for (const item of items) {
+            this.x_box_center.push(Number(item.x) + 0.5 * Number(item.width));
+            this.z_box_center.push(Number(item.z) + 0.5 * Number(item.length));
+            this.y_box_center.push(Number(item.y) + 0.5 * Number(item.height));
+            this.weight_box.push(Number(item.weight));
+        }
+        this.total_mass = this.weight_box.reduce((sum, weight) => sum + weight, 0);
+    }
+    /** Computes center of gravity from item boxes. */
+    calculate_cm() {
+        this.x_cm = dot(this.x_box_center, this.weight_box) / this.total_mass;
+        this.z_cm = dot(this.z_box_center, this.weight_box) / this.total_mass;
+        this.y_cm = dot(this.y_box_center, this.weight_box) / this.total_mass;
+    }
+    /** Computes corner reaction forces including container tare split. */
+    calculate_corner_forces() {
+        const container = this.input_data.container;
+        const container_length = Number(container.length);
+        const container_width = Number(container.width);
+        this.force_on_door = (this.z_cm * this.total_mass) / container_length;
+        this.force_on_right_corner_door = (this.x_cm * this.force_on_door) / container_width;
+        this.force_on_left_corner_door = this.force_on_door - this.force_on_right_corner_door;
+        this.force_on_end_wall = this.total_mass - this.force_on_door;
+        this.force_on_right_corner_end_wall = (this.x_cm * this.force_on_end_wall) / container_width;
+        this.force_on_left_corner_end_wall = this.force_on_end_wall - this.force_on_right_corner_end_wall;
+        const tare_quarter = 0.25 * Number(container.tare);
+        this.force_on_right_corner_door += tare_quarter;
+        this.force_on_left_corner_door += tare_quarter;
+        this.force_on_right_corner_end_wall += tare_quarter;
+        this.force_on_left_corner_end_wall += tare_quarter;
+    }
+    /**
+     * @returns Response JSON.
+     */
+    json() {
+        const response = {
+            centerOfGravity: { x: this.x_cm, y: this.y_cm, z: this.z_cm }
+        };
+        if (this.force_on_door !== null) {
+            response.corner_forces = {
+                force_on_door: this.force_on_door,
+                force_on_right_corner_door: this.force_on_right_corner_door,
+                force_on_left_corner_door: this.force_on_left_corner_door,
+                force_on_end_wall: this.force_on_end_wall,
+                force_on_right_corner_end_wall: this.force_on_right_corner_end_wall,
+                force_on_left_corner_end_wall: this.force_on_left_corner_end_wall
+            };
+        }
+        return response;
+    }
+}
+/**
+ * @param values - Value list.
+ * @param weights - Weight list.
+ * @returns Weighted sum.
+ */
+function dot(values, weights) {
+    return values.reduce((sum, value, index) => sum + value * weights[index], 0);
+}

package/build/core/physics/transports/axle_manager.d.ts

@@ -0,0 +1,22 @@
+import { AxleRecord } from './axle_record.js';
+import type { TransportRecord } from '../../contracts/transport_record.js';
+/**
+ * Ordered axle list for a transport.
+ */
+export declare class AxleManager {
+    axles: AxleRecord[];
+    /**
+     * @param transport_data - Raw transport JSON.
+     */
+    constructor(transport_data: TransportRecord);
+    /**
+     * @returns Axle index list [0..n-1].
+     */
+    list_axles_indexes(): number[];
+    /**
+     * @param axle_index - Zero-based axle index.
+     * @returns Axle at index.
+     */
+    get_axle(axle_index: number): AxleRecord;
+}
+//# sourceMappingURL=axle_manager.d.ts.map

package/build/core/physics/transports/axle_manager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"axle_manager.d.ts","sourceRoot":"","sources":["../../../../src/core/physics/transports/axle_manager.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAA;AAC7C,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,qCAAqC,CAAA;AAE1E;;GAEG;AACH,qBAAa,WAAW;IAEpB,KAAK,EAAE,UAAU,EAAE,CAAA;IAEnB;;OAEG;gBACS,cAAc,EAAE,eAAe;IAc3C;;OAEG;IACH,kBAAkB,IAAI,MAAM,EAAE;IAK9B;;;OAGG;IACH,QAAQ,CAAC,UAAU,EAAE,MAAM,GAAG,UAAU;CAI3C"}

package/build/core/physics/transports/axle_manager.js

@@ -0,0 +1,34 @@
+import { WIRE_FLAGS } from '../../contracts/wire_flags.js';
+import { AxleRecord } from './axle_record.js';
+/**
+ * Ordered axle list for a transport.
+ */
+export class AxleManager {
+    axles;
+    /**
+     * @param transport_data - Raw transport JSON.
+     */
+    constructor(transport_data) {
+        const axles_data = transport_data[WIRE_FLAGS.AXLE_LIST];
+        this.axles = [];
+        if (!Array.isArray(axles_data)) {
+            return;
+        }
+        for (const axle_data of axles_data) {
+            this.axles.push(new AxleRecord(axle_data));
+        }
+    }
+    /**
+     * @returns Axle index list [0..n-1].
+     */
+    list_axles_indexes() {
+        return this.axles.map((_axle, index) => index);
+    }
+    /**
+     * @param axle_index - Zero-based axle index.
+     * @returns Axle at index.
+     */
+    get_axle(axle_index) {
+        return this.axles[axle_index];
+    }
+}

package/build/core/physics/transports/axle_record.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Single axle geometry and capacity from wire JSON.
+ */
+export declare class AxleRecord {
+    distance_from_previous_axle: number;
+    max_supported_weight: number;
+    sequence_index: number;
+    dnit_weight_limit: number;
+    tare: number;
+    loaded_weight: number;
+    is_connected_to: number | null;
+    /**
+     * @param axle_data - Raw axle object from transport JSON.
+     */
+    constructor(axle_data: Record<string, unknown>);
+    /**
+     * @returns Shallow copy of axle wire fields.
+     */
+    to_wire(): Record<string, unknown>;
+}
+//# sourceMappingURL=axle_record.d.ts.map

package/build/core/physics/transports/axle_record.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"axle_record.d.ts","sourceRoot":"","sources":["../../../../src/core/physics/transports/axle_record.ts"],"names":[],"mappings":"AAEA;;GAEG;AACH,qBAAa,UAAU;IAEnB,2BAA2B,EAAE,MAAM,CAAA;IACnC,oBAAoB,EAAE,MAAM,CAAA;IAC5B,cAAc,EAAE,MAAM,CAAA;IACtB,iBAAiB,EAAE,MAAM,CAAA;IACzB,IAAI,EAAE,MAAM,CAAA;IACZ,aAAa,EAAE,MAAM,CAAA;IACrB,eAAe,EAAE,MAAM,GAAG,IAAI,CAAA;IAE9B;;OAEG;gBACS,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;IAW9C;;OAEG;IACH,OAAO,IAAI,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;CAWrC"}

package/build/core/physics/transports/axle_record.js

@@ -0,0 +1,57 @@
+import { WIRE_FLAGS } from '../../contracts/wire_flags.js';
+/**
+ * Single axle geometry and capacity from wire JSON.
+ */
+export class AxleRecord {
+    distance_from_previous_axle;
+    max_supported_weight;
+    sequence_index;
+    dnit_weight_limit;
+    tare;
+    loaded_weight;
+    is_connected_to;
+    /**
+     * @param axle_data - Raw axle object from transport JSON.
+     */
+    constructor(axle_data) {
+        this.distance_from_previous_axle = read_number(axle_data, WIRE_FLAGS.DISTANCE_FROM_ORIGIN);
+        this.max_supported_weight = read_number(axle_data, WIRE_FLAGS.MAX_SUPPORTED_WEIGHT);
+        this.sequence_index = read_number(axle_data, WIRE_FLAGS.SEQUENCE_CONTAINER);
+        this.dnit_weight_limit = read_number(axle_data, WIRE_FLAGS.DNIT_WEIGHT);
+        this.tare = read_number(axle_data, WIRE_FLAGS.TARE);
+        this.loaded_weight = read_optional_number(axle_data, 'pesoCarregado') ?? 0;
+        this.is_connected_to = read_optional_number(axle_data, 'mergeOnAxleIndex');
+    }
+    /**
+     * @returns Shallow copy of axle wire fields.
+     */
+    to_wire() {
+        return {
+            distanciaOrigem: this.distance_from_previous_axle,
+            pesoMaxSuportado: this.max_supported_weight,
+            pesoDnit: this.dnit_weight_limit,
+            tara: this.tare,
+            sequenciaContainer: this.sequence_index,
+            mergeOnAxleIndex: this.is_connected_to
+        };
+    }
+}
+/**
+ * @param data - Source object.
+ * @param key - Field key.
+ * @returns Parsed number.
+ */
+function read_number(data, key) {
+    return Number(data[key]);
+}
+/**
+ * @param data - Source object.
+ * @param key - Field key.
+ * @returns Parsed number or null.
+ */
+function read_optional_number(data, key) {
+    if (data[key] === undefined || data[key] === null) {
+        return null;
+    }
+    return Number(data[key]);
+}

package/build/core/physics/transports/chassi.d.ts

@@ -0,0 +1,52 @@
+import { type ChassiReference } from '../../contracts/chassi_reference.js';
+import type { Transport } from './transport.js';
+/**
+ * Chassis geometry reference frame for equilibrium models.
+ */
+export declare class Chassi {
+    private first_axle_distance;
+    private axle_positions;
+    private pin_positions;
+    private grouper_start;
+    private grouper_end;
+    /**
+     * @param transport - Parsed transport.
+     */
+    constructor(transport: Transport);
+    /**
+     * @param axle_index - Zero-based axle index.
+     * @param chassi_reference - Reference frame.
+     * @returns Axle position.
+     */
+    get_axle_position(axle_index: number, chassi_reference: ChassiReference): number;
+    /**
+     * @param pin_index - Zero-based pin index.
+     * @param chassi_reference - Reference frame.
+     * @returns Pin position.
+     */
+    get_pin_position(pin_index: number, chassi_reference: ChassiReference): number;
+    /**
+     * @param grouper_index - Grouper id (1-based).
+     * @param chassi_reference - Reference frame.
+     * @returns Grouper end position.
+     */
+    get_grouper_end(grouper_index: number, chassi_reference: ChassiReference): number;
+    /**
+     * @param chassi_reference - Reference frame.
+     * @returns Offset for reference change.
+     */
+    private chassi_reference_change_value;
+    /**
+     * @param transport - Parsed transport.
+     */
+    private calculate_axles_positions;
+    /**
+     * @param merged_containers - Merged grouper geometry.
+     */
+    private calculate_groupers_positions;
+    /**
+     * @param merged_containers - Merged grouper geometry.
+     */
+    private calculate_pins_positions;
+}
+//# sourceMappingURL=chassi.d.ts.map

package/build/core/physics/transports/chassi.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chassi.d.ts","sourceRoot":"","sources":["../../../../src/core/physics/transports/chassi.ts"],"names":[],"mappings":"AAAA,OAAO,EAAoB,KAAK,eAAe,EAAE,MAAM,qCAAqC,CAAA;AAC5F,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAA;AAG/C;;GAEG;AACH,qBAAa,MAAM;IAEf,OAAO,CAAC,mBAAmB,CAAQ;IACnC,OAAO,CAAC,cAAc,CAAe;IACrC,OAAO,CAAC,aAAa,CAAe;IACpC,OAAO,CAAC,aAAa,CAAe;IACpC,OAAO,CAAC,WAAW,CAAe;IAElC;;OAEG;gBACS,SAAS,EAAE,SAAS;IAShC;;;;OAIG;IACH,iBAAiB,CAAC,UAAU,EAAE,MAAM,EAAE,gBAAgB,EAAE,eAAe,GAAG,MAAM;IAMhF;;;;OAIG;IACH,gBAAgB,CAAC,SAAS,EAAE,MAAM,EAAE,gBAAgB,EAAE,eAAe,GAAG,MAAM;IAM9E;;;;OAIG;IACH,eAAe,CAAC,aAAa,EAAE,MAAM,EAAE,gBAAgB,EAAE,eAAe,GAAG,MAAM;IAMjF;;;OAGG;IACH,OAAO,CAAC,6BAA6B;IAarC;;OAEG;IACH,OAAO,CAAC,yBAAyB;IAYjC;;OAEG;IACH,OAAO,CAAC,4BAA4B;IAepC;;OAEG;IACH,OAAO,CAAC,wBAAwB;CAgBnC"}

package/build/core/physics/transports/chassi.js

@@ -0,0 +1,105 @@
+import { CHASSI_REFERENCE } from '../../contracts/chassi_reference.js';
+import { MergedContainers } from './merged_containers.js';
+/**
+ * Chassis geometry reference frame for equilibrium models.
+ */
+export class Chassi {
+    first_axle_distance;
+    axle_positions = [];
+    pin_positions = [];
+    grouper_start = [];
+    grouper_end = [];
+    /**
+     * @param transport - Parsed transport.
+     */
+    constructor(transport) {
+        this.first_axle_distance = transport.first_axle_distance;
+        const merged = new MergedContainers(transport);
+        this.calculate_groupers_positions(merged);
+        this.calculate_axles_positions(transport);
+        this.calculate_pins_positions(merged);
+    }
+    /**
+     * @param axle_index - Zero-based axle index.
+     * @param chassi_reference - Reference frame.
+     * @returns Axle position.
+     */
+    get_axle_position(axle_index, chassi_reference) {
+        return this.axle_positions[axle_index]
+            + this.chassi_reference_change_value(chassi_reference);
+    }
+    /**
+     * @param pin_index - Zero-based pin index.
+     * @param chassi_reference - Reference frame.
+     * @returns Pin position.
+     */
+    get_pin_position(pin_index, chassi_reference) {
+        return this.pin_positions[pin_index]
+            + this.chassi_reference_change_value(chassi_reference);
+    }
+    /**
+     * @param grouper_index - Grouper id (1-based).
+     * @param chassi_reference - Reference frame.
+     * @returns Grouper end position.
+     */
+    get_grouper_end(grouper_index, chassi_reference) {
+        return this.grouper_end[grouper_index - 1]
+            + this.chassi_reference_change_value(chassi_reference);
+    }
+    /**
+     * @param chassi_reference - Reference frame.
+     * @returns Offset for reference change.
+     */
+    chassi_reference_change_value(chassi_reference) {
+        if (chassi_reference === CHASSI_REFERENCE.GROUPER_1) {
+            return 0;
+        }
+        if (chassi_reference === CHASSI_REFERENCE.GROUPER_2) {
+            return -this.grouper_start[1];
+        }
+        return this.first_axle_distance;
+    }
+    /**
+     * @param transport - Parsed transport.
+     */
+    calculate_axles_positions(transport) {
+        this.axle_positions = [-this.first_axle_distance];
+        const indexes = transport.axle_manager.list_axles_indexes();
+        for (let index = 1; index < indexes.length; index++) {
+            const axle = transport.axle_manager.get_axle(index);
+            const previous = this.axle_positions[index - 1];
+            this.axle_positions.push(previous + axle.distance_from_previous_axle);
+        }
+    }
+    /**
+     * @param merged_containers - Merged grouper geometry.
+     */
+    calculate_groupers_positions(merged_containers) {
+        const first = merged_containers.get_container_by_grouper_index(1);
+        this.grouper_start = [0];
+        this.grouper_end = [first.length];
+        if (merged_containers.list_grouper_indexes().length <= 1) {
+            return;
+        }
+        const second = merged_containers.get_container_by_grouper_index(2);
+        const second_start = this.grouper_end[0] + (second.container_distance_ahead ?? 0);
+        this.grouper_start.push(second_start);
+        this.grouper_end.push(second_start + second.length);
+    }
+    /**
+     * @param merged_containers - Merged grouper geometry.
+     */
+    calculate_pins_positions(merged_containers) {
+        const first = merged_containers.get_container_by_grouper_index(1);
+        this.pin_positions = [first.main_pin_distance ?? 0];
+        if (merged_containers.list_grouper_indexes().length <= 1) {
+            return;
+        }
+        const second = merged_containers.get_container_by_grouper_index(2);
+        if (second.main_pin_distance === null) {
+            return;
+        }
+        const second_pin = this.grouper_start[1] + second.main_pin_distance;
+        this.pin_positions.push(second_pin);
+    }
+}

package/build/core/physics/transports/container_record.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Container segment from wire JSON.
+ */
+export declare class ContainerRecord {
+    length: number;
+    width: number;
+    height: number;
+    sequence_index: number;
+    main_pin_distance: number | null;
+    container_distance_ahead: number | null;
+    grouper: number;
+    max_supported_weight: number;
+    tare: number;
+    supported_weight: number;
+    raw: Record<string, unknown>;
+    /**
+     * @param data - Raw container object.
+     */
+    constructor(data: Record<string, unknown>);
+    /**
+     * @returns Container volume (length × width × height).
+     */
+    volume(): number;
+}
+//# sourceMappingURL=container_record.d.ts.map

package/build/core/physics/transports/container_record.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"container_record.d.ts","sourceRoot":"","sources":["../../../../src/core/physics/transports/container_record.ts"],"names":[],"mappings":"AAEA;;GAEG;AACH,qBAAa,eAAe;IAExB,MAAM,EAAE,MAAM,CAAA;IACd,KAAK,EAAE,MAAM,CAAA;IACb,MAAM,EAAE,MAAM,CAAA;IACd,cAAc,EAAE,MAAM,CAAA;IACtB,iBAAiB,EAAE,MAAM,GAAG,IAAI,CAAA;IAChC,wBAAwB,EAAE,MAAM,GAAG,IAAI,CAAA;IACvC,OAAO,EAAE,MAAM,CAAA;IACf,oBAAoB,EAAE,MAAM,CAAA;IAC5B,IAAI,EAAE,MAAM,CAAA;IACZ,gBAAgB,EAAE,MAAM,CAAA;IACxB,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IAE5B;;OAEG;gBACS,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;IAezC;;OAEG;IACH,MAAM,IAAI,MAAM;CAInB"}

package/build/core/physics/transports/container_record.js

@@ -0,0 +1,49 @@
+import { WIRE_FLAGS } from '../../contracts/wire_flags.js';
+/**
+ * Container segment from wire JSON.
+ */
+export class ContainerRecord {
+    length;
+    width;
+    height;
+    sequence_index;
+    main_pin_distance;
+    container_distance_ahead;
+    grouper;
+    max_supported_weight;
+    tare;
+    supported_weight;
+    raw;
+    /**
+     * @param data - Raw container object.
+     */
+    constructor(data) {
+        this.length = Number(data[WIRE_FLAGS.LENGTH]);
+        this.width = Number(data[WIRE_FLAGS.WIDTH]);
+        this.height = Number(data[WIRE_FLAGS.HEIGHT]);
+        this.sequence_index = Number(data[WIRE_FLAGS.SEQUENCE]);
+        this.main_pin_distance = read_optional(data[WIRE_FLAGS.MAIN_PIN_DISTANCE]);
+        this.container_distance_ahead = read_optional(data[WIRE_FLAGS.CONTAINER_DISTANCE_AHEAD]);
+        this.grouper = Number(data[WIRE_FLAGS.GROUPER]);
+        this.max_supported_weight = Number(data[WIRE_FLAGS.MAX_SUPPORTED_WEIGHT] ?? 0);
+        this.tare = Number(data[WIRE_FLAGS.TARE] ?? 0);
+        this.supported_weight = this.max_supported_weight - this.tare;
+        this.raw = { ...data };
+    }
+    /**
+     * @returns Container volume (length × width × height).
+     */
+    volume() {
+        return this.length * this.width * this.height;
+    }
+}
+/**
+ * @param value - Wire field value.
+ * @returns Number or null.
+ */
+function read_optional(value) {
+    if (value === undefined || value === null) {
+        return null;
+    }
+    return Number(value);
+}