@jetta/axle-load-calculator 0.3.4 → 0.3.6

package/build-cjs/core/physics/transports/Transport.js

@@ -0,0 +1,115 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Transport = void 0;
+const WireFlags_js_1 = require("../../contracts/WireFlags.js");
+const VehicleType_js_1 = require("../../contracts/VehicleType.js");
+const VehicleVersion_js_1 = require("../../contracts/VehicleVersion.js");
+const AxleManager_js_1 = require("./AxleManager.js");
+const ContainerRecord_js_1 = require("./ContainerRecord.js");
+const ContainerSequenceNotFoundError_js_1 = require("./ContainerSequenceNotFoundError.js");
+/**
+ * Parsed transport matching jettainterface.Transport behavior used by axleweight.
+ */
+class Transport {
+    id;
+    containers;
+    amount;
+    supported_weight;
+    tare;
+    axle_manager;
+    first_axle_distance;
+    vehicle_type;
+    vehicle_version;
+    suspension_type;
+    /**
+     * @param transport_data - Raw transport dict.
+     */
+    constructor(transport_data) {
+        this.id = String(transport_data[WireFlags_js_1.WIRE_FLAGS.TRANSPORT_ID]);
+        this.containers = read_containers(transport_data);
+        this.amount = Number(transport_data[WireFlags_js_1.WIRE_FLAGS.AMOUNT] ?? 0);
+        this.supported_weight = Number(transport_data[WireFlags_js_1.WIRE_FLAGS.SUPPORTED_WEIGHT]);
+        this.tare = Number(transport_data.tara ?? 0);
+        this.axle_manager = new AxleManager_js_1.AxleManager(transport_data);
+        this.first_axle_distance = Number(transport_data[WireFlags_js_1.WIRE_FLAGS.FIRST_AXLE_DISTANCE] ?? 0);
+        this.vehicle_type = read_vehicle_type(transport_data);
+        this.vehicle_version = read_vehicle_version(transport_data);
+        this.suspension_type = read_suspension_type(transport_data);
+    }
+    /**
+     * @returns Sorted container sequence indexes.
+     */
+    list_containers_sequence_indexes() {
+        return [...this.containers.keys()].sort((left, right) => left - right);
+    }
+    /**
+     * @param sequence_index - Container sequence.
+     * @returns Container record.
+     */
+    get_container_by_sequence_index(sequence_index) {
+        const container = this.containers.get(sequence_index);
+        if (!container) {
+            throw new ContainerSequenceNotFoundError_js_1.ContainerSequenceNotFoundError(sequence_index);
+        }
+        return container;
+    }
+}
+exports.Transport = Transport;
+/**
+ * @param transport_data - Raw transport dict.
+ * @returns Containers keyed by sequence.
+ */
+function read_containers(transport_data) {
+    const map = new Map();
+    const list = transport_data[WireFlags_js_1.WIRE_FLAGS.CONTAINERS];
+    if (!Array.isArray(list)) {
+        return map;
+    }
+    for (const entry of list) {
+        const container = new ContainerRecord_js_1.ContainerRecord(entry);
+        map.set(container.sequence_index, container);
+    }
+    return map;
+}
+/**
+ * @param transport_data - Raw transport dict.
+ * @returns Vehicle type code.
+ */
+function read_vehicle_type(transport_data) {
+    const raw = transport_data[WireFlags_js_1.WIRE_FLAGS.VEHICLE_TYPE];
+    if (raw === undefined || raw === null) {
+        return VehicleType_js_1.VEHICLE_TYPE.CONTAINER;
+    }
+    return Number(raw);
+}
+/**
+ * @param transport_data - Raw transport dict.
+ * @returns Resolved vehicle version code.
+ */
+function read_vehicle_version(transport_data) {
+    const vehicle_type = read_vehicle_type(transport_data);
+    const version_code = Number(transport_data[WireFlags_js_1.WIRE_FLAGS.VEHICLE_VERSION] ?? 0);
+    if (vehicle_type === VehicleType_js_1.VEHICLE_TYPE.CAMINHAO && version_code === 4) {
+        return VehicleVersion_js_1.VEHICLE_VERSION.CAMINHAO_BITRUCK;
+    }
+    if (vehicle_type === VehicleType_js_1.VEHICLE_TYPE.SEMIREBOQUE) {
+        if (version_code === 5 || version_code === 7) {
+            return VehicleVersion_js_1.VEHICLE_VERSION.SEMIREBOQUE_QUAD;
+        }
+        if (version_code === 6) {
+            return VehicleVersion_js_1.VEHICLE_VERSION.SEMIREBOQUE_BITRUCK;
+        }
+    }
+    return VehicleVersion_js_1.VEHICLE_VERSION.DEFAULT;
+}
+/**
+ * @param transport_data - Raw transport dict.
+ * @returns Suspension wire string or null.
+ */
+function read_suspension_type(transport_data) {
+    const raw = transport_data[WireFlags_js_1.WIRE_FLAGS.SUSPENSION_TYPE];
+    if (raw === undefined || raw === null) {
+        return null;
+    }
+    return String(raw);
+}

package/build-cjs/core/physics/transports/containerweight/ContainerMaxWeightCalculator.d.ts

@@ -0,0 +1,21 @@
+import type { GroupedContainers } from '../GroupedContainers.js';
+import type { MaxWeightInput } from './MaxWeightInput.js';
+/**
+ * Applies neck weight cap and redistributes excess to second container.
+ */
+export declare class ContainerMaxWeightCalculator {
+    private readonly grouped_containers;
+    private neck_weight_reduction;
+    /**
+     * @param grouped_containers - Grouper containers.
+     */
+    constructor(grouped_containers: GroupedContainers);
+    /**
+     * @param input - Sequence, share, capacity, and tare.
+     * @returns Max supported weight for container.
+     */
+    calculate(input: MaxWeightInput): number;
+    private is_neck;
+    private is_second_container;
+}
+//# sourceMappingURL=ContainerMaxWeightCalculator.d.ts.map

package/build-cjs/core/physics/transports/containerweight/ContainerMaxWeightCalculator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ContainerMaxWeightCalculator.d.ts","sourceRoot":"","sources":["../../../../../src/core/physics/transports/containerweight/ContainerMaxWeightCalculator.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAA;AAChE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAA;AAIzD;;GAEG;AACH,qBAAa,4BAA4B;IAOzB,OAAO,CAAC,QAAQ,CAAC,kBAAkB;IAL/C,OAAO,CAAC,qBAAqB,CAAI;IAEjC;;OAEG;gBAC0B,kBAAkB,EAAE,iBAAiB;IAGlE;;;OAGG;IACH,SAAS,CAAC,KAAK,EAAE,cAAc,GAAG,MAAM;IAmBxC,OAAO,CAAC,OAAO;IAMf,OAAO,CAAC,mBAAmB;CAK9B"}

package/build-cjs/core/physics/transports/containerweight/ContainerMaxWeightCalculator.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContainerMaxWeightCalculator = void 0;
+const MAX_NECK_SUPPORTED = 6000;
+/**
+ * Applies neck weight cap and redistributes excess to second container.
+ */
+class ContainerMaxWeightCalculator {
+    grouped_containers;
+    neck_weight_reduction = 0;
+    /**
+     * @param grouped_containers - Grouper containers.
+     */
+    constructor(grouped_containers) {
+        this.grouped_containers = grouped_containers;
+    }
+    /**
+     * @param input - Sequence, share, capacity, and tare.
+     * @returns Max supported weight for container.
+     */
+    calculate(input) {
+        const max_supported = input.total_max_supported_weight * input.percentage_of_weight;
+        if (this.is_neck(input.sequence_index)) {
+            const supported = max_supported - input.tare;
+            if (supported > MAX_NECK_SUPPORTED) {
+                this.neck_weight_reduction = supported - MAX_NECK_SUPPORTED;
+                return input.tare + MAX_NECK_SUPPORTED;
+            }
+        }
+        else if (this.is_second_container(input.sequence_index)) {
+            return max_supported + this.neck_weight_reduction;
+        }
+        return max_supported;
+    }
+    is_neck(sequence_index) {
+        const list = this.grouped_containers.list_containers_sequence_indexes();
+        return list.length >= 2 && list[0] === sequence_index;
+    }
+    is_second_container(sequence_index) {
+        const list = this.grouped_containers.list_containers_sequence_indexes();
+        return list.length >= 2 && list[1] === sequence_index;
+    }
+}
+exports.ContainerMaxWeightCalculator = ContainerMaxWeightCalculator;

package/build-cjs/core/physics/transports/containerweight/ContainerTareCalculator.d.ts

@@ -0,0 +1,28 @@
+import type { Transport } from '../Transport.js';
+import type { GroupedContainers } from '../GroupedContainers.js';
+/**
+ * Distributes grouper tare across containers (neck gets axle-1 share).
+ */
+export declare class ContainerTareCalculator {
+    private readonly transport;
+    private readonly grouped_containers;
+    private revised_tare_percentage;
+    private first_neck_tare;
+    /**
+     * @param transport - Parsed transport.
+     * @param grouped_containers - Grouper containers.
+     */
+    constructor(transport: Transport, grouped_containers: GroupedContainers);
+    /**
+     * @param sequence_index - Container sequence.
+     * @param percentage_of_weight - Lateral area share.
+     * @param total_tare - Grouper total tare.
+     * @returns Container tare.
+     */
+    calculate(sequence_index: number, percentage_of_weight: number, total_tare: number): number;
+    private is_first_neck;
+    private calculate_tare_of_first_neck;
+    private tare_percentage_review;
+    private axle1_on_neck_tare_contribution;
+}
+//# sourceMappingURL=ContainerTareCalculator.d.ts.map

package/build-cjs/core/physics/transports/containerweight/ContainerTareCalculator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ContainerTareCalculator.d.ts","sourceRoot":"","sources":["../../../../../src/core/physics/transports/containerweight/ContainerTareCalculator.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAA;AAChD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAA;AAIhE;;GAEG;AACH,qBAAa,uBAAuB;IAU5B,OAAO,CAAC,QAAQ,CAAC,SAAS;IAC1B,OAAO,CAAC,QAAQ,CAAC,kBAAkB;IATvC,OAAO,CAAC,uBAAuB,CAAI;IACnC,OAAO,CAAC,eAAe,CAAI;IAE3B;;;OAGG;gBAEkB,SAAS,EAAE,SAAS,EACpB,kBAAkB,EAAE,iBAAiB;IAI1D;;;;;OAKG;IACH,SAAS,CACL,cAAc,EAAE,MAAM,EACtB,oBAAoB,EAAE,MAAM,EAC5B,UAAU,EAAE,MAAM,GACnB,MAAM;IAWT,OAAO,CAAC,aAAa;IAMrB,OAAO,CAAC,4BAA4B;IAUpC,OAAO,CAAC,sBAAsB;IAQ9B,OAAO,CAAC,+BAA+B;CAO1C"}

package/build-cjs/core/physics/transports/containerweight/ContainerTareCalculator.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContainerTareCalculator = void 0;
+const NECK_SEQUENCE = 1;
+/**
+ * Distributes grouper tare across containers (neck gets axle-1 share).
+ */
+class ContainerTareCalculator {
+    transport;
+    grouped_containers;
+    revised_tare_percentage = 0;
+    first_neck_tare = 0;
+    /**
+     * @param transport - Parsed transport.
+     * @param grouped_containers - Grouper containers.
+     */
+    constructor(transport, grouped_containers) {
+        this.transport = transport;
+        this.grouped_containers = grouped_containers;
+    }
+    /**
+     * @param sequence_index - Container sequence.
+     * @param percentage_of_weight - Lateral area share.
+     * @param total_tare - Grouper total tare.
+     * @returns Container tare.
+     */
+    calculate(sequence_index, percentage_of_weight, total_tare) {
+        if (this.is_first_neck(sequence_index)) {
+            this.calculate_tare_of_first_neck(percentage_of_weight);
+            this.tare_percentage_review(percentage_of_weight, total_tare);
+            return this.first_neck_tare;
+        }
+        return (percentage_of_weight + this.revised_tare_percentage) * total_tare;
+    }
+    is_first_neck(sequence_index) {
+        return this.grouped_containers.list_containers_sequence_indexes().length >= 2
+            && sequence_index === NECK_SEQUENCE;
+    }
+    calculate_tare_of_first_neck(percentage_of_weight) {
+        const neck = this.grouped_containers.get_container_by_sequence_index(NECK_SEQUENCE);
+        const axle1 = this.axle1_on_neck_tare_contribution(neck.length);
+        const remaining = percentage_of_weight * (this.transport.axle_manager.get_axle(1).tare
+            + this.transport.axle_manager.get_axle(2).tare);
+        this.first_neck_tare = axle1 + remaining;
+    }
+    tare_percentage_review(percentage_of_weight, total_tare) {
+        const tare = percentage_of_weight * total_tare;
+        const change = (this.first_neck_tare - tare) / total_tare;
+        const count = this.grouped_containers.list_containers_sequence_indexes().length;
+        this.revised_tare_percentage = -change / (count - 1);
+    }
+    axle1_on_neck_tare_contribution(neck_length) {
+        const end_container = this.transport.first_axle_distance + neck_length;
+        const end_grouper = this.transport.first_axle_distance + this.grouped_containers.length;
+        const share = end_container / end_grouper;
+        return share * this.transport.axle_manager.get_axle(0).tare;
+    }
+}
+exports.ContainerTareCalculator = ContainerTareCalculator;

package/build-cjs/core/physics/transports/containerweight/ContainerWeightModel.d.ts

@@ -0,0 +1,15 @@
+import type { Transport } from '../Transport.js';
+/**
+ * Computes per-container supported cargo capacity.
+ */
+export declare class ContainerWeightModel {
+    private readonly transport;
+    private readonly merged_containers;
+    /**
+     * @param transport - Parsed transport.
+     */
+    constructor(transport: Transport);
+    /** Updates container supported_weight on transport. */
+    calculate(): void;
+}
+//# sourceMappingURL=ContainerWeightModel.d.ts.map

package/build-cjs/core/physics/transports/containerweight/ContainerWeightModel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ContainerWeightModel.d.ts","sourceRoot":"","sources":["../../../../../src/core/physics/transports/containerweight/ContainerWeightModel.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAA;AAKhD;;GAEG;AACH,qBAAa,oBAAoB;IAOjB,OAAO,CAAC,QAAQ,CAAC,SAAS;IALtC,OAAO,CAAC,QAAQ,CAAC,iBAAiB,CAAkB;IAEpD;;OAEG;gBAC0B,SAAS,EAAE,SAAS;IAKjD,uDAAuD;IACvD,SAAS,IAAI,IAAI;CAgBpB"}

package/build-cjs/core/physics/transports/containerweight/ContainerWeightModel.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContainerWeightModel = void 0;
+const MergedContainers_js_1 = require("../MergedContainers.js");
+const MergedContainersWeightCalculator_js_1 = require("./MergedContainersWeightCalculator.js");
+const SingleContainerWeightCalculator_js_1 = require("./SingleContainerWeightCalculator.js");
+/**
+ * Computes per-container supported cargo capacity.
+ */
+class ContainerWeightModel {
+    transport;
+    merged_containers;
+    /**
+     * @param transport - Parsed transport.
+     */
+    constructor(transport) {
+        this.transport = transport;
+        this.merged_containers = new MergedContainers_js_1.MergedContainers(transport);
+    }
+    /** Updates container supported_weight on transport. */
+    calculate() {
+        const axles = this.transport.axle_manager.list_axles_indexes()
+            .map((index) => this.transport.axle_manager.get_axle(index));
+        new MergedContainersWeightCalculator_js_1.MergedContainersWeightCalculator(this.merged_containers, axles).calculate();
+        for (const grouper of this.merged_containers.list_grouper_indexes()) {
+            const grouped = this.merged_containers.get_container_by_grouper_index(grouper);
+            new SingleContainerWeightCalculator_js_1.SingleContainerWeightCalculator(this.transport, grouped).calculate();
+        }
+        for (const sequence of this.transport.list_containers_sequence_indexes()) {
+            const container = this.transport.get_container_by_sequence_index(sequence);
+            container.supported_weight = container.max_supported_weight - container.tare;
+        }
+    }
+}
+exports.ContainerWeightModel = ContainerWeightModel;

package/build-cjs/core/physics/transports/containerweight/MaxWeightInput.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Inputs for per-container max supported weight calculation.
+ */
+export type MaxWeightInput = {
+    sequence_index: number;
+    percentage_of_weight: number;
+    total_max_supported_weight: number;
+    tare: number;
+};
+//# sourceMappingURL=MaxWeightInput.d.ts.map

package/build-cjs/core/physics/transports/containerweight/MaxWeightInput.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MaxWeightInput.d.ts","sourceRoot":"","sources":["../../../../../src/core/physics/transports/containerweight/MaxWeightInput.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,MAAM,MAAM,cAAc,GAAG;IACzB,cAAc,EAAE,MAAM,CAAA;IACtB,oBAAoB,EAAE,MAAM,CAAA;IAC5B,0BAA0B,EAAE,MAAM,CAAA;IAClC,IAAI,EAAE,MAAM,CAAA;CACf,CAAA"}

package/build-cjs/core/physics/transports/containerweight/MaxWeightInput.js

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

package/build-cjs/core/physics/transports/containerweight/MergedContainersWeightCalculator.d.ts

@@ -0,0 +1,17 @@
+import type { MergedContainers } from '../MergedContainers.js';
+import type { AxleRecord } from '../AxleRecord.js';
+/**
+ * Sums axle capacity and tare onto merged grouper containers.
+ */
+export declare class MergedContainersWeightCalculator {
+    private readonly merged_containers;
+    private readonly transport_axles_list;
+    /**
+     * @param merged_containers - Grouper layout.
+     * @param transport_axles_list - All axles.
+     */
+    constructor(merged_containers: MergedContainers, transport_axles_list: AxleRecord[]);
+    /** Applies summed max weight and tare to each merged grouper container. */
+    calculate(): void;
+}
+//# sourceMappingURL=MergedContainersWeightCalculator.d.ts.map

package/build-cjs/core/physics/transports/containerweight/MergedContainersWeightCalculator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MergedContainersWeightCalculator.d.ts","sourceRoot":"","sources":["../../../../../src/core/physics/transports/containerweight/MergedContainersWeightCalculator.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAA;AAC9D,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAA;AAElD;;GAEG;AACH,qBAAa,gCAAgC;IAOrC,OAAO,CAAC,QAAQ,CAAC,iBAAiB;IAClC,OAAO,CAAC,QAAQ,CAAC,oBAAoB;IANzC;;;OAGG;gBAEkB,iBAAiB,EAAE,gBAAgB,EACnC,oBAAoB,EAAE,UAAU,EAAE;IAIvD,2EAA2E;IAC3E,SAAS,IAAI,IAAI;CAmBpB"}

package/build-cjs/core/physics/transports/containerweight/MergedContainersWeightCalculator.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MergedContainersWeightCalculator = void 0;
+/**
+ * Sums axle capacity and tare onto merged grouper containers.
+ */
+class MergedContainersWeightCalculator {
+    merged_containers;
+    transport_axles_list;
+    /**
+     * @param merged_containers - Grouper layout.
+     * @param transport_axles_list - All axles.
+     */
+    constructor(merged_containers, transport_axles_list) {
+        this.merged_containers = merged_containers;
+        this.transport_axles_list = transport_axles_list;
+    }
+    /** Applies summed max weight and tare to each merged grouper container. */
+    calculate() {
+        for (const grouper of this.merged_containers.list_grouper_indexes()) {
+            const grouped = this.merged_containers.get_container_by_grouper_index(grouper);
+            const sequences = grouped.list_containers_sequence_indexes();
+            const merged = grouped.merged_container;
+            merged.max_supported_weight = 0;
+            merged.tare = 0;
+            for (const axle of this.transport_axles_list) {
+                if (sequences.includes(axle.sequence_index)) {
+                    merged.max_supported_weight += axle.max_supported_weight;
+                    merged.tare += axle.tare;
+                }
+            }
+        }
+    }
+}
+exports.MergedContainersWeightCalculator = MergedContainersWeightCalculator;

package/build-cjs/core/physics/transports/containerweight/SingleContainerWeightCalculator.d.ts

@@ -0,0 +1,20 @@
+import type { Transport } from '../Transport.js';
+import type { GroupedContainers } from '../GroupedContainers.js';
+/**
+ * Splits grouper capacity across containers by lateral area.
+ */
+export declare class SingleContainerWeightCalculator {
+    private readonly grouped_containers;
+    private readonly tare_calculator;
+    private readonly max_calculator;
+    /**
+     * @param transport - Parsed transport.
+     * @param grouped_containers - Grouper containers.
+     */
+    constructor(transport: Transport, grouped_containers: GroupedContainers);
+    /** Assigns max_supported_weight and tare per container in grouper. */
+    calculate(): void;
+    private total_lateral_area;
+    private lateral_area;
+}
+//# sourceMappingURL=SingleContainerWeightCalculator.d.ts.map

package/build-cjs/core/physics/transports/containerweight/SingleContainerWeightCalculator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SingleContainerWeightCalculator.d.ts","sourceRoot":"","sources":["../../../../../src/core/physics/transports/containerweight/SingleContainerWeightCalculator.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAA;AAChD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAA;AAKhE;;GAEG;AACH,qBAAa,+BAA+B;IAWpC,OAAO,CAAC,QAAQ,CAAC,kBAAkB;IATvC,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAyB;IACzD,OAAO,CAAC,QAAQ,CAAC,cAAc,CAA8B;IAE7D;;;OAGG;gBAEC,SAAS,EAAE,SAAS,EACH,kBAAkB,EAAE,iBAAiB;IAO1D,sEAAsE;IACtE,SAAS,IAAI,IAAI;IAqBjB,OAAO,CAAC,kBAAkB;IAW1B,OAAO,CAAC,YAAY;CAIvB"}

package/build-cjs/core/physics/transports/containerweight/SingleContainerWeightCalculator.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SingleContainerWeightCalculator = void 0;
+const ContainerTareCalculator_js_1 = require("./ContainerTareCalculator.js");
+const ContainerMaxWeightCalculator_js_1 = require("./ContainerMaxWeightCalculator.js");
+/**
+ * Splits grouper capacity across containers by lateral area.
+ */
+class SingleContainerWeightCalculator {
+    grouped_containers;
+    tare_calculator;
+    max_calculator;
+    /**
+     * @param transport - Parsed transport.
+     * @param grouped_containers - Grouper containers.
+     */
+    constructor(transport, grouped_containers) {
+        this.grouped_containers = grouped_containers;
+        this.tare_calculator = new ContainerTareCalculator_js_1.ContainerTareCalculator(transport, grouped_containers);
+        this.max_calculator = new ContainerMaxWeightCalculator_js_1.ContainerMaxWeightCalculator(grouped_containers);
+    }
+    /** Assigns max_supported_weight and tare per container in grouper. */
+    calculate() {
+        const total_area = this.total_lateral_area();
+        const merged = this.grouped_containers.merged_container;
+        const total_max = merged.max_supported_weight;
+        const total_tare = merged.tare;
+        for (const sequence of this.grouped_containers.list_containers_sequence_indexes()) {
+            const container = this.grouped_containers.get_container_by_sequence_index(sequence);
+            const share = this.lateral_area(container) / total_area;
+            const tare = this.tare_calculator.calculate(sequence, share, total_tare);
+            container.max_supported_weight = this.max_calculator.calculate({
+                sequence_index: sequence,
+                percentage_of_weight: share,
+                total_max_supported_weight: total_max,
+                tare
+            });
+            container.tare = tare;
+        }
+    }
+    total_lateral_area() {
+        let total = 0;
+        for (const sequence of this.grouped_containers.list_containers_sequence_indexes()) {
+            total += this.lateral_area(this.grouped_containers.get_container_by_sequence_index(sequence));
+        }
+        return total;
+    }
+    lateral_area(container) {
+        return container.length * container.height;
+    }
+}
+exports.SingleContainerWeightCalculator = SingleContainerWeightCalculator;

package/build-cjs/core/physics/transports/tare/BitremAxleSplit.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Bitrem shared-axle split multipliers.
+ */
+export type BitremAxleSplit = {
+    mult: number;
+    on_axle_3: boolean;
+};
+//# sourceMappingURL=BitremAxleSplit.d.ts.map

package/build-cjs/core/physics/transports/tare/BitremAxleSplit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BitremAxleSplit.d.ts","sourceRoot":"","sources":["../../../../../src/core/physics/transports/tare/BitremAxleSplit.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,MAAM,MAAM,eAAe,GAAG;IAC1B,IAAI,EAAE,MAAM,CAAA;IACZ,SAAS,EAAE,OAAO,CAAA;CACrB,CAAA"}

package/build-cjs/core/physics/transports/tare/BitremAxleSplit.js

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

package/build-cjs/core/physics/transports/tare/BitremAxleSplitTarget.d.ts

@@ -0,0 +1,12 @@
+import type { AxleRecord } from '../AxleRecord.js';
+import type { BitremAxleSplit } from './BitremAxleSplit.js';
+/**
+ * Axle records and split multipliers for bitrem shared-axle redistribution.
+ */
+export type BitremAxleSplitTarget = {
+    old: AxleRecord;
+    axle_3: AxleRecord;
+    axle_4: AxleRecord;
+    split: BitremAxleSplit;
+};
+//# sourceMappingURL=BitremAxleSplitTarget.d.ts.map

package/build-cjs/core/physics/transports/tare/BitremAxleSplitTarget.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BitremAxleSplitTarget.d.ts","sourceRoot":"","sources":["../../../../../src/core/physics/transports/tare/BitremAxleSplitTarget.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAA;AAClD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAA;AAE3D;;GAEG;AACH,MAAM,MAAM,qBAAqB,GAAG;IAChC,GAAG,EAAE,UAAU,CAAA;IACf,MAAM,EAAE,UAAU,CAAA;IAClB,MAAM,EAAE,UAAU,CAAA;IAClB,KAAK,EAAE,eAAe,CAAA;CACzB,CAAA"}

package/build-cjs/core/physics/transports/tare/BitremAxleSplitTarget.js

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

package/build-cjs/core/physics/transports/tare/BitremAxleSplitter.d.ts

@@ -0,0 +1,26 @@
+import type { Transport } from '../Transport.js';
+import { AxleRecord } from '../AxleRecord.js';
+/** Splits bitrem shared axle 3 into two axles (DRAGON-98). */
+export declare class BitremAxleSplitter {
+    private readonly transport;
+    readonly new_axle_3: AxleRecord;
+    readonly new_axle_4: AxleRecord;
+    readonly new_axle_5: AxleRecord;
+    private readonly chassi;
+    /**
+     * @param transport - Parsed transport.
+     */
+    constructor(transport: Transport);
+    /**
+     * @returns Five axle wire rows after split.
+     */
+    generate_splitted_axles_data(): Record<string, unknown>[];
+    calculate_first_proportion(): number;
+    calculate_second_proportion(): number;
+    private generate_new_weight_attributes;
+    private generate_new_axle_distances;
+    private generate_new_axle_container_sequences;
+    private generate_merged_axle_connection;
+    private distance_from_axle_3_to_pin_2;
+}
+//# sourceMappingURL=BitremAxleSplitter.d.ts.map

package/build-cjs/core/physics/transports/tare/BitremAxleSplitter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BitremAxleSplitter.d.ts","sourceRoot":"","sources":["../../../../../src/core/physics/transports/tare/BitremAxleSplitter.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAA;AAGhD,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAA;AAG7C,8DAA8D;AAC9D,qBAAa,kBAAkB;IAUf,OAAO,CAAC,QAAQ,CAAC,SAAS;IARtC,QAAQ,CAAC,UAAU,EAAE,UAAU,CAAA;IAC/B,QAAQ,CAAC,UAAU,EAAE,UAAU,CAAA;IAC/B,QAAQ,CAAC,UAAU,EAAE,UAAU,CAAA;IAC/B,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAQ;IAE/B;;OAEG;gBAC0B,SAAS,EAAE,SAAS;IAQjD;;OAEG;IACH,4BAA4B,IAAI,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE;IAezD,0BAA0B,IAAI,MAAM;IAOpC,2BAA2B,IAAI,MAAM;IAQrC,OAAO,CAAC,8BAA8B;IActC,OAAO,CAAC,2BAA2B;IAQnC,OAAO,CAAC,qCAAqC;IAS7C,OAAO,CAAC,+BAA+B;IAKvC,OAAO,CAAC,6BAA6B;CAMxC"}

package/build-cjs/core/physics/transports/tare/BitremAxleSplitter.js

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BitremAxleSplitter = void 0;
+const ChassiReference_js_1 = require("../../../contracts/ChassiReference.js");
+const Chassi_js_1 = require("../Chassi.js");
+const MergedContainers_js_1 = require("../MergedContainers.js");
+const AxleRecord_js_1 = require("../AxleRecord.js");
+const BitremAxleWeightSplit_js_1 = require("./BitremAxleWeightSplit.js");
+/** Splits bitrem shared axle 3 into two axles (DRAGON-98). */
+class BitremAxleSplitter {
+    transport;
+    new_axle_3;
+    new_axle_4;
+    new_axle_5;
+    chassi;
+    /**
+     * @param transport - Parsed transport.
+     */
+    constructor(transport) {
+        this.transport = transport;
+        this.chassi = new Chassi_js_1.Chassi(transport);
+        this.new_axle_3 = clone_axle(transport.axle_manager.get_axle(2));
+        this.new_axle_4 = clone_axle(transport.axle_manager.get_axle(2));
+        this.new_axle_5 = clone_axle(transport.axle_manager.get_axle(3));
+    }
+    /**
+     * @returns Five axle wire rows after split.
+     */
+    generate_splitted_axles_data() {
+        this.generate_new_weight_attributes();
+        this.generate_new_axle_distances();
+        this.generate_new_axle_container_sequences();
+        this.generate_merged_axle_connection();
+        return [
+            this.transport.axle_manager.get_axle(0).to_wire(),
+            this.transport.axle_manager.get_axle(1).to_wire(),
+            this.new_axle_3.to_wire(),
+            this.new_axle_4.to_wire(),
+            this.new_axle_5.to_wire()
+        ];
+    }
+    calculate_first_proportion() {
+        const a = this.chassi.get_axle_position(1, ChassiReference_js_1.CHASSI_REFERENCE.GROUPER_1);
+        const b = this.chassi.get_axle_position(2, ChassiReference_js_1.CHASSI_REFERENCE.GROUPER_1) - a;
+        return a / b;
+    }
+    calculate_second_proportion() {
+        const axle_3 = this.chassi.get_axle_position(2, ChassiReference_js_1.CHASSI_REFERENCE.TRACTOR);
+        const axle_4 = this.chassi.get_axle_position(3, ChassiReference_js_1.CHASSI_REFERENCE.TRACTOR);
+        const end = this.chassi.get_grouper_end(2, ChassiReference_js_1.CHASSI_REFERENCE.TRACTOR);
+        return (end - axle_4) / (axle_4 - axle_3);
+    }
+    generate_new_weight_attributes() {
+        const old = this.transport.axle_manager.get_axle(2);
+        const split = (0, BitremAxleWeightSplit_js_1.compute_bitrem_axle_split)(this.calculate_first_proportion(), this.calculate_second_proportion());
+        (0, BitremAxleWeightSplit_js_1.apply_bitrem_axle_split)({
+            old,
+            axle_3: this.new_axle_3,
+            axle_4: this.new_axle_4,
+            split
+        });
+    }
+    generate_new_axle_distances() {
+        const old_4 = this.transport.axle_manager.get_axle(3);
+        this.new_axle_4.distance_from_previous_axle = this.distance_from_axle_3_to_pin_2();
+        this.new_axle_5.distance_from_previous_axle = old_4.distance_from_previous_axle
+            - this.new_axle_4.distance_from_previous_axle;
+    }
+    generate_new_axle_container_sequences() {
+        const merged = new MergedContainers_js_1.MergedContainers(this.transport);
+        this.new_axle_3.sequence_index = merged.get_container_by_grouper_index(1)
+            .list_containers_sequence_indexes()[0];
+        this.new_axle_4.sequence_index = merged.get_container_by_grouper_index(2)
+            .list_containers_sequence_indexes()[0];
+    }
+    generate_merged_axle_connection() {
+        this.new_axle_4.is_connected_to = 2;
+    }
+    distance_from_axle_3_to_pin_2() {
+        const axle_3 = this.chassi.get_axle_position(2, ChassiReference_js_1.CHASSI_REFERENCE.TRACTOR);
+        const pin_2 = this.chassi.get_pin_position(1, ChassiReference_js_1.CHASSI_REFERENCE.TRACTOR);
+        return pin_2 - axle_3;
+    }
+}
+exports.BitremAxleSplitter = BitremAxleSplitter;
+function clone_axle(source) {
+    return new AxleRecord_js_1.AxleRecord(source.to_wire());
+}