@jetta/axle-load-calculator 0.3.4 → 0.3.6

package/build-cjs/core/orchestration/ConnectorPayloadBuilder.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.build_connector_payload = build_connector_payload;
+const WireFlags_js_1 = require("../contracts/WireFlags.js");
+/**
+ * Builds axle-weight service payload from a prepared env vehicle (Java AxleWeightConnector).
+ * @param env_vehicle - Vehicle object inside envs[].
+ * @param center_of_mass_by_grouper - CM per grouper for CM service flag.
+ * @returns Transport record for CmAxleWeightService.
+ */
+function build_connector_payload(env_vehicle, center_of_mass_by_grouper) {
+    const center_of_mass = map_center_of_mass_wire(center_of_mass_by_grouper);
+    return {
+        [WireFlags_js_1.WIRE_FLAGS.CONTAINERS]: build_containers(env_vehicle),
+        [WireFlags_js_1.WIRE_FLAGS.AXLE_LIST]: build_axles(env_vehicle),
+        [WireFlags_js_1.WIRE_FLAGS.TRANSPORT_ID]: env_vehicle._id,
+        [WireFlags_js_1.WIRE_FLAGS.AMOUNT]: 1,
+        [WireFlags_js_1.WIRE_FLAGS.SUPPORTED_WEIGHT]: env_vehicle.pesoDeCarga,
+        [WireFlags_js_1.WIRE_FLAGS.FIRST_AXLE_DISTANCE]: env_vehicle.primeiroEixo,
+        [WireFlags_js_1.WIRE_FLAGS.VEHICLE_TYPE]: env_vehicle.tipoVeiculo,
+        [WireFlags_js_1.WIRE_FLAGS.VEHICLE_VERSION]: env_vehicle.tipoVersao,
+        [WireFlags_js_1.WIRE_FLAGS.SUSPENSION_TYPE]: env_vehicle.tipoSuspensao,
+        [WireFlags_js_1.WIRE_FLAGS.CM_SERVICE_CENTER_OF_MASS]: center_of_mass
+    };
+}
+/**
+ * @param center_of_mass_by_grouper - CM per grouper from Java MassCenter.
+ * @returns Wire map for CM service.
+ */
+function map_center_of_mass_wire(center_of_mass_by_grouper) {
+    const center_of_mass = {};
+    for (const grouper_key of Object.keys(center_of_mass_by_grouper)) {
+        const entry = center_of_mass_by_grouper[Number(grouper_key)];
+        center_of_mass[grouper_key] = {
+            mass: entry.mass,
+            [WireFlags_js_1.WIRE_FLAGS.CM_SERVICE_Z]: entry.z
+        };
+    }
+    return center_of_mass;
+}
+/**
+ * @param container - Env container record.
+ * @returns Wire container without items.
+ */
+function map_container_to_wire(container) {
+    return {
+        [WireFlags_js_1.WIRE_FLAGS.LENGTH]: container.comprimento,
+        [WireFlags_js_1.WIRE_FLAGS.WIDTH]: container.largura,
+        [WireFlags_js_1.WIRE_FLAGS.HEIGHT]: container.altura,
+        [WireFlags_js_1.WIRE_FLAGS.SEQUENCE]: container.sequencia,
+        [WireFlags_js_1.WIRE_FLAGS.MAIN_PIN_DISTANCE]: container.distPinoRei,
+        [WireFlags_js_1.WIRE_FLAGS.CONTAINER_DISTANCE_AHEAD]: container.containerDistanceAhead,
+        [WireFlags_js_1.WIRE_FLAGS.GROUPER]: container.grouper
+    };
+}
+/**
+ * @param axle - Env axle record.
+ * @returns Wire axle payload.
+ */
+function map_axle_to_wire(axle) {
+    return {
+        [WireFlags_js_1.WIRE_FLAGS.DISTANCE_FROM_ORIGIN]: axle.distanciaOrigem,
+        [WireFlags_js_1.WIRE_FLAGS.MAX_SUPPORTED_WEIGHT]: axle.pesoMaxSuportado,
+        [WireFlags_js_1.WIRE_FLAGS.SEQUENCE_CONTAINER]: axle.sequenciaContainer,
+        [WireFlags_js_1.WIRE_FLAGS.DNIT_WEIGHT]: axle.pesoDnit ?? axle.pesoMaxSuportado,
+        [WireFlags_js_1.WIRE_FLAGS.TARE]: axle.tara
+    };
+}
+/**
+ * @param env_vehicle - Env vehicle JSON.
+ * @returns Container wire list without items.
+ */
+function build_containers(env_vehicle) {
+    const list = env_vehicle.containers;
+    return list.map(map_container_to_wire);
+}
+/**
+ * @param env_vehicle - Env vehicle JSON.
+ * @returns Axle wire list.
+ */
+function build_axles(env_vehicle) {
+    const list = env_vehicle.eixos;
+    return list.map(map_axle_to_wire);
+}

package/build-cjs/core/orchestration/ItemOverlapError.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Raised when two allocated items occupy the same volume.
+ */
+export declare class ItemOverlapError extends Error {
+    constructor();
+}
+//# sourceMappingURL=ItemOverlapError.d.ts.map

package/build-cjs/core/orchestration/ItemOverlapError.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ItemOverlapError.d.ts","sourceRoot":"","sources":["../../../src/core/orchestration/ItemOverlapError.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,qBAAa,gBAAiB,SAAQ,KAAK;;CAO1C"}

package/build-cjs/core/orchestration/ItemOverlapError.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ItemOverlapError = void 0;
+/**
+ * Raised when two allocated items occupy the same volume.
+ */
+class ItemOverlapError extends Error {
+    constructor() {
+        super('Item overlap error');
+        this.name = 'ItemOverlapError';
+    }
+}
+exports.ItemOverlapError = ItemOverlapError;

package/build-cjs/core/orchestration/JavaMassCenter.d.ts

@@ -0,0 +1,10 @@
+import { CenterOfMass } from '../physics/items/CenterOfMass.js';
+/**
+ * Computes mass center per grouper using ms-faixas Java Item / MassCenter rules.
+ * Longitudinal position uses JSON `y` (maps to Ponto3D.z in Java CubeRepresentation).
+ * Same-grouper containers are merged; empty necks do not shift later beds (MS parity).
+ * @param env_vehicle - Single env vehicle object from weight_by_axis payload.
+ * @returns Map of grouper id to center of mass.
+ */
+export declare function mass_center_by_grouper_from_env(env_vehicle: Record<string, unknown>): Record<number, CenterOfMass>;
+//# sourceMappingURL=JavaMassCenter.d.ts.map

package/build-cjs/core/orchestration/JavaMassCenter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"JavaMassCenter.d.ts","sourceRoot":"","sources":["../../../src/core/orchestration/JavaMassCenter.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,kCAAkC,CAAA;AAE/D;;;;;;GAMG;AACH,wBAAgB,+BAA+B,CAC3C,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GACrC,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC,CAQ9B"}

package/build-cjs/core/orchestration/JavaMassCenter.js

@@ -0,0 +1,135 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mass_center_by_grouper_from_env = mass_center_by_grouper_from_env;
+const CenterOfMass_js_1 = require("../physics/items/CenterOfMass.js");
+/**
+ * Computes mass center per grouper using ms-faixas Java Item / MassCenter rules.
+ * Longitudinal position uses JSON `y` (maps to Ponto3D.z in Java CubeRepresentation).
+ * Same-grouper containers are merged; empty necks do not shift later beds (MS parity).
+ * @param env_vehicle - Single env vehicle object from weight_by_axis payload.
+ * @returns Map of grouper id to center of mass.
+ */
+function mass_center_by_grouper_from_env(env_vehicle) {
+    const containers = env_vehicle.containers;
+    if (!containers) {
+        return {};
+    }
+    return accumulate_grouper_mass_centers(sort_containers_by_sequence(containers));
+}
+/**
+ * @param containers - Containers sorted by sequencia.
+ * @returns Merged center of mass map keyed by grouper.
+ */
+function accumulate_grouper_mass_centers(containers) {
+    const result = {};
+    const longitudinal_offset_by_grouper = {};
+    for (const container of containers) {
+        absorb_container_into_grouper(result, longitudinal_offset_by_grouper, container);
+    }
+    return result;
+}
+/**
+ * @param result - Accumulated grouper centers (mutated).
+ * @param offsets - Longitudinal offset per grouper (mutated).
+ * @param container - Env container to absorb.
+ */
+function absorb_container_into_grouper(result, offsets, container) {
+    const grouper = Number(container.grouper);
+    const sequence_offset = offsets[grouper] ?? 0;
+    const container_center = compute_container_mass_center(container, sequence_offset);
+    result[grouper] = result[grouper]
+        ? merge_mass_centers(result[grouper], container_center)
+        : container_center;
+    if (container_center.mass > 0) {
+        offsets[grouper] = sequence_offset + Number(container.comprimento ?? 0);
+    }
+}
+/**
+ * @param containers - Env containers.
+ * @returns Containers sorted by sequencia ascending.
+ */
+function sort_containers_by_sequence(containers) {
+    return [...containers].sort((left, right) => Number(left.sequencia) - Number(right.sequencia));
+}
+/**
+ * @param left - Existing grouper center of mass.
+ * @param right - Additional container center of mass.
+ * @returns Combined center of mass.
+ */
+function merge_mass_centers(left, right) {
+    const merged = new CenterOfMass_js_1.CenterOfMass();
+    merged.mass = left.mass + right.mass;
+    if (merged.mass === 0) {
+        merged.z = 0;
+        return merged;
+    }
+    merged.z = (left.mass * left.z + right.mass * right.z) / merged.mass;
+    return merged;
+}
+/**
+ * @param container - Container object with items array.
+ * @param sequence_offset - Longitudinal offset from prior same-grouper containers.
+ * @returns Center of mass for container items.
+ */
+function compute_container_mass_center(container, sequence_offset) {
+    const center_of_mass = new CenterOfMass_js_1.CenterOfMass();
+    const items = container.items;
+    if (!items || items.length === 0) {
+        return center_of_mass;
+    }
+    const moments = accumulate_item_moments(items, sequence_offset, container);
+    center_of_mass.mass = moments.mass;
+    center_of_mass.z = moments.mass === 0 ? 0 : moments.accumulated / moments.mass;
+    return center_of_mass;
+}
+/**
+ * @param items - Container items.
+ * @param sequence_offset - Prior loaded length in grouper.
+ * @param container - Container for faixa offset.
+ * @returns Accumulated mass and first moment.
+ */
+function accumulate_item_moments(items, sequence_offset, container) {
+    const container_offset = sequence_offset + read_container_longitudinal_offset(container);
+    let accumulated = 0;
+    let mass = 0;
+    for (const item of items) {
+        const weight = read_item_weight(item);
+        accumulated += weight * (container_offset + read_item_longitudinal_position(item));
+        mass += weight;
+    }
+    return { accumulated, mass };
+}
+/**
+ * @param container - Container JSON.
+ * @returns Longitudinal offset of container body (first faixa z1 when present).
+ */
+function read_container_longitudinal_offset(container) {
+    const bands = container.faixas;
+    if (!bands || bands.length === 0) {
+        return 0;
+    }
+    return Number(bands[0].z1 ?? 0);
+}
+/**
+ * @param item - Ms-faixas item JSON.
+ * @returns Item weight.
+ */
+function read_item_weight(item) {
+    if (item.peso !== undefined) {
+        return Number(item.peso);
+    }
+    return Number(item.weight ?? 0);
+}
+/**
+ * @param item - Ms-faixas item JSON.
+ * @returns Longitudinal position for equilibrium (Java getZ on pontoDeInicio).
+ */
+function read_item_longitudinal_position(item) {
+    const origin_y = Number(item.y ?? 0);
+    const custom = item.centerOfGravity;
+    if (custom && custom.z !== undefined) {
+        return origin_y + Number(custom.z);
+    }
+    const length = Number(item.comprimento ?? item.length ?? 0);
+    return origin_y + length / 2;
+}

package/build-cjs/core/orchestration/OutputBuilder.d.ts

@@ -0,0 +1,7 @@
+import type { WeightByAxisSuccessOutput } from './WeightByAxisResponse.js';
+/**
+ * @param envs - Output env list.
+ * @returns Success response object.
+ */
+export declare function build_success_output(envs: Record<string, unknown>[]): WeightByAxisSuccessOutput;
+//# sourceMappingURL=OutputBuilder.d.ts.map

package/build-cjs/core/orchestration/OutputBuilder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"OutputBuilder.d.ts","sourceRoot":"","sources":["../../../src/core/orchestration/OutputBuilder.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,2BAA2B,CAAA;AAE1E;;;GAGG;AACH,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,GAAG,yBAAyB,CAG/F"}

package/build-cjs/core/orchestration/OutputBuilder.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.build_success_output = build_success_output;
+/**
+ * @param envs - Output env list.
+ * @returns Success response object.
+ */
+function build_success_output(envs) {
+    return { envs };
+}

package/build-cjs/core/orchestration/RequestSchema.d.ts

@@ -0,0 +1,57 @@
+import { z } from 'zod';
+declare const request_schema: z.ZodObject<{
+    envs: z.ZodArray<z.ZodObject<{
+        _id: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+        eixos: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>, "many">;
+        containers: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>, "many">;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        _id: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+        eixos: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>, "many">;
+        containers: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>, "many">;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        _id: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+        eixos: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>, "many">;
+        containers: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>, "many">;
+    }, z.ZodTypeAny, "passthrough">>, "many">;
+    config: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+    envs: z.ZodArray<z.ZodObject<{
+        _id: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+        eixos: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>, "many">;
+        containers: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>, "many">;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        _id: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+        eixos: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>, "many">;
+        containers: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>, "many">;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        _id: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+        eixos: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>, "many">;
+        containers: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>, "many">;
+    }, z.ZodTypeAny, "passthrough">>, "many">;
+    config: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+    envs: z.ZodArray<z.ZodObject<{
+        _id: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+        eixos: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>, "many">;
+        containers: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>, "many">;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        _id: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+        eixos: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>, "many">;
+        containers: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>, "many">;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        _id: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+        eixos: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>, "many">;
+        containers: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>, "many">;
+    }, z.ZodTypeAny, "passthrough">>, "many">;
+    config: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.ZodTypeAny, "passthrough">>;
+export type WeightByAxisRequest = z.infer<typeof request_schema>;
+export type WeightByAxisRequestInput = z.input<typeof request_schema>;
+/**
+ * Parses and validates weight-by-axis request data at the library boundary.
+ * @param data - JSON string or plain `{ envs, config? }` object.
+ * @returns Parsed request object.
+ */
+export declare function parse_weight_by_axis_request_data(data: WeightByAxisRequestInput): WeightByAxisRequest;
+export {};
+//# sourceMappingURL=RequestSchema.d.ts.map

package/build-cjs/core/orchestration/RequestSchema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RequestSchema.d.ts","sourceRoot":"","sources":["../../../src/core/orchestration/RequestSchema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAQvB,QAAA,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gCAGJ,CAAA;AAEhB,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAA;AAChE,MAAM,MAAM,wBAAwB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAA;AAErE;;;;GAIG;AACH,wBAAgB,iCAAiC,CAC7C,IAAI,EAAE,wBAAwB,GAC/B,mBAAmB,CAGrB"}

package/build-cjs/core/orchestration/RequestSchema.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parse_weight_by_axis_request_data = parse_weight_by_axis_request_data;
+const zod_1 = require("zod");
+const env_schema = zod_1.z.object({
+    _id: zod_1.z.union([zod_1.z.string(), zod_1.z.number()]).optional(),
+    eixos: zod_1.z.array(zod_1.z.record(zod_1.z.unknown())).min(1),
+    containers: zod_1.z.array(zod_1.z.record(zod_1.z.unknown())).min(1)
+}).passthrough();
+const request_schema = zod_1.z.object({
+    envs: zod_1.z.array(env_schema).min(1),
+    config: zod_1.z.record(zod_1.z.unknown()).optional()
+}).passthrough();
+/**
+ * Parses and validates weight-by-axis request data at the library boundary.
+ * @param data - JSON string or plain `{ envs, config? }` object.
+ * @returns Parsed request object.
+ */
+function parse_weight_by_axis_request_data(data) {
+    return request_schema.parse(data);
+}

package/build-cjs/core/orchestration/WeightByAxisResponse.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Successful weight-by-axis response payload.
+ */
+export type WeightByAxisSuccessOutput = {
+    envs: Record<string, unknown>[];
+};
+/**
+ * Weight-by-axis task success response.
+ */
+export type WeightByAxisResponse = WeightByAxisSuccessOutput;
+//# sourceMappingURL=WeightByAxisResponse.d.ts.map

package/build-cjs/core/orchestration/WeightByAxisResponse.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"WeightByAxisResponse.d.ts","sourceRoot":"","sources":["../../../src/core/orchestration/WeightByAxisResponse.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,MAAM,MAAM,yBAAyB,GAAG;IACpC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,CAAA;CAClC,CAAA;AAED;;GAEG;AACH,MAAM,MAAM,oBAAoB,GAAG,yBAAyB,CAAA"}

package/build-cjs/core/orchestration/WeightByAxisResponse.js

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

package/build-cjs/core/orchestration/WeightByAxisTask.d.ts

@@ -0,0 +1,18 @@
+import { type WeightByAxisRequestInput } from './RequestSchema.js';
+import type { WeightByAxisSuccessOutput } from './WeightByAxisResponse.js';
+/**
+ * Runs weight-by-axis for ms-faixas input (WeightByAxisTask.run contract).
+ * @param request_data - `{ envs, config? }` object.
+ * @returns Response object with envs and axle weights.
+ * @throws {import('zod').ZodError} When request validation fails.
+ * @throws {import('../physics/models/UnsupportedVehicleTypeError.js').UnsupportedVehicleTypeError} When physics rejects the vehicle type.
+ * @throws {import('../physics/models/UnrecognizedSuspensionTypeError.js').UnrecognizedSuspensionTypeError} When vanderleia suspension type is invalid.
+ * @throws {import('../physics/transports/GrouperNotFoundError.js').GrouperNotFoundError} When a merged-container grouper is missing.
+ * @throws {import('../physics/transports/ContainerSequenceNotFoundError.js').ContainerSequenceNotFoundError} When a container sequence is missing.
+ * @throws {import('../physics/transports/MissingContainerError.js').MissingContainerError} When a container lookup fails.
+ * @throws {import('../physics/items/UnknownItemIdError.js').UnknownItemIdError} When an item template id is unknown.
+ * @throws {import('../physics/models/deflection/DeflectionModelNotImplementedError.js').DeflectionModelNotImplementedError} When no deflection model exists.
+ * @throws {import('./ItemOverlapError.js').ItemOverlapError} When two allocated items occupy the same volume.
+ */
+export declare function run_weight_by_axis_task(request_data: WeightByAxisRequestInput): WeightByAxisSuccessOutput;
+//# sourceMappingURL=WeightByAxisTask.d.ts.map

package/build-cjs/core/orchestration/WeightByAxisTask.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"WeightByAxisTask.d.ts","sourceRoot":"","sources":["../../../src/core/orchestration/WeightByAxisTask.ts"],"names":[],"mappings":"AAGA,OAAO,EAEH,KAAK,wBAAwB,EAChC,MAAM,oBAAoB,CAAA;AAC3B,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,2BAA2B,CAAA;AAE1E;;;;;;;;;;;;;GAaG;AACH,wBAAgB,uBAAuB,CACnC,YAAY,EAAE,wBAAwB,GACvC,yBAAyB,CAa3B"}

package/build-cjs/core/orchestration/WeightByAxisTask.js

@@ -0,0 +1,110 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.run_weight_by_axis_task = run_weight_by_axis_task;
+const AxleWeightPhysics_js_1 = require("./AxleWeightPhysics.js");
+const CollisionChecker_js_1 = require("./CollisionChecker.js");
+const OutputBuilder_js_1 = require("./OutputBuilder.js");
+const RequestSchema_js_1 = require("./RequestSchema.js");
+/**
+ * Runs weight-by-axis for ms-faixas input (WeightByAxisTask.run contract).
+ * @param request_data - `{ envs, config? }` object.
+ * @returns Response object with envs and axle weights.
+ * @throws {import('zod').ZodError} When request validation fails.
+ * @throws {import('../physics/models/UnsupportedVehicleTypeError.js').UnsupportedVehicleTypeError} When physics rejects the vehicle type.
+ * @throws {import('../physics/models/UnrecognizedSuspensionTypeError.js').UnrecognizedSuspensionTypeError} When vanderleia suspension type is invalid.
+ * @throws {import('../physics/transports/GrouperNotFoundError.js').GrouperNotFoundError} When a merged-container grouper is missing.
+ * @throws {import('../physics/transports/ContainerSequenceNotFoundError.js').ContainerSequenceNotFoundError} When a container sequence is missing.
+ * @throws {import('../physics/transports/MissingContainerError.js').MissingContainerError} When a container lookup fails.
+ * @throws {import('../physics/items/UnknownItemIdError.js').UnknownItemIdError} When an item template id is unknown.
+ * @throws {import('../physics/models/deflection/DeflectionModelNotImplementedError.js').DeflectionModelNotImplementedError} When no deflection model exists.
+ * @throws {import('./ItemOverlapError.js').ItemOverlapError} When two allocated items occupy the same volume.
+ */
+function run_weight_by_axis_task(request_data) {
+    const request = (0, RequestSchema_js_1.parse_weight_by_axis_request_data)(request_data);
+    const envs = request.envs;
+    const output_envs = [];
+    for (const env of envs) {
+        const loaded_weights = (0, AxleWeightPhysics_js_1.calculate_loaded_weights_for_env)(env);
+        apply_loaded_weights_to_env(env, loaded_weights);
+        (0, CollisionChecker_js_1.check_cargo_collision)(env);
+        output_envs.push(strip_items_and_bands(env));
+    }
+    return (0, OutputBuilder_js_1.build_success_output)(output_envs);
+}
+/**
+ * Writes loaded axle and container pesoEixos fields on the env vehicle.
+ * @param env - Env vehicle object.
+ * @param loaded_weights - Forces per axle.
+ */
+function apply_loaded_weights_to_env(env, loaded_weights) {
+    const axles = env.eixos;
+    for (let index = 0; index < loaded_weights.length; index++) {
+        const cargo = loaded_weights[index];
+        const axle = axles[index];
+        const tare = Number(axle.tara ?? 0);
+        axle.pesoCarregado = cargo;
+        axle.pesoCarregadoFinal = tare + cargo;
+    }
+    const containers = env.containers;
+    apply_to_containers(containers, loaded_weights, axles);
+}
+/**
+ * @param containers - Container list on env.
+ * @param loaded_weights - Per-axle cargo load.
+ * @param axles - Vehicle axles list.
+ */
+function apply_to_containers(containers, loaded_weights, axles) {
+    for (const container of containers) {
+        const peso_eixos = build_peso_eixos_for_container(container, loaded_weights, axles);
+        container.pesoEixos = peso_eixos;
+    }
+}
+/**
+ * @param container - Container on env.
+ * @param loaded_weights - All axle loads.
+ * @param axles - Vehicle axles.
+ * @returns pesoEixos array for container.
+ */
+function build_peso_eixos_for_container(container, loaded_weights, axles) {
+    const sequence = Number(container.sequencia);
+    const result = [];
+    for (let index = 0; index < axles.length; index++) {
+        if (Number(axles[index].sequenciaContainer) !== sequence) {
+            continue;
+        }
+        result.push(build_peso_eixo_entry(axles[index], loaded_weights[index]));
+    }
+    return result;
+}
+/**
+ * @param axle - Axle record on env.
+ * @param cargo - Loaded cargo on axle.
+ * @returns Single pesoEixos entry.
+ */
+function build_peso_eixo_entry(axle, cargo) {
+    const tare = Number(axle.tara ?? 0);
+    return {
+        distanciaOrigem: axle.distanciaOrigem,
+        pesoMax: Number(axle.pesoMaxSuportado) - tare,
+        pesoMaxFinal: axle.pesoMaxSuportado,
+        tara: tare,
+        pesoCarregado: cargo,
+        pesoCarregadoFinal: tare + cargo,
+        distanciaOrigemSemPrimeiroEixo: axle.distanciaOrigemSemPrimeiroEixo ?? 0
+    };
+}
+/**
+ * Copies env vehicle for response, clearing items/faixas and setting idCaminhao.
+ * @param env - Env with updated axle data.
+ * @returns Env copy without items/faixas on containers.
+ */
+function strip_items_and_bands(env) {
+    const clone = JSON.parse(JSON.stringify(env));
+    const containers = clone.containers;
+    for (const container of containers) {
+        container.items = [];
+        container.faixas = [];
+    }
+    clone.idCaminhao = clone._id;
+    return clone;
+}

package/build-cjs/core/physics/items/AllocatedItem.d.ts

@@ -0,0 +1,22 @@
+import type { RotationCode } from '../../contracts/RotationEnum.js';
+import type { ItemTemplates } from './ItemTemplates.js';
+/**
+ * Allocated cargo item with position in container coordinates.
+ */
+export declare class AllocatedItem {
+    xi: number;
+    yi: number;
+    zi: number;
+    rotation: RotationCode;
+    readonly template_index: number;
+    readonly templates: ItemTemplates;
+    /**
+     * @param templates - Shared templates.
+     * @param template_index - Template index.
+     */
+    constructor(templates: ItemTemplates, template_index: number);
+    get weight(): number;
+    get length(): number;
+    get center_of_gravity_z(): number;
+}
+//# sourceMappingURL=AllocatedItem.d.ts.map

package/build-cjs/core/physics/items/AllocatedItem.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AllocatedItem.d.ts","sourceRoot":"","sources":["../../../../src/core/physics/items/AllocatedItem.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,iCAAiC,CAAA;AAEnE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAA;AAEvD;;GAEG;AACH,qBAAa,aAAa;IAEtB,EAAE,SAAI;IACN,EAAE,SAAI;IACN,EAAE,SAAI;IACN,QAAQ,EAAE,YAAY,CAAgB;IACtC,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAA;IAC/B,QAAQ,CAAC,SAAS,EAAE,aAAa,CAAA;IAEjC;;;OAGG;gBACS,SAAS,EAAE,aAAa,EAAE,cAAc,EAAE,MAAM;IAM5D,IAAI,MAAM,IAAI,MAAM,CAGnB;IAED,IAAI,MAAM,IAAI,MAAM,CAGnB;IAED,IAAI,mBAAmB,IAAI,MAAM,CAGhC;CACJ"}

package/build-cjs/core/physics/items/AllocatedItem.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AllocatedItem = void 0;
+const RotationEnum_js_1 = require("../../contracts/RotationEnum.js");
+/**
+ * Allocated cargo item with position in container coordinates.
+ */
+class AllocatedItem {
+    xi = 0;
+    yi = 0;
+    zi = 0;
+    rotation = RotationEnum_js_1.ROTATION.POS1;
+    template_index;
+    templates;
+    /**
+     * @param templates - Shared templates.
+     * @param template_index - Template index.
+     */
+    constructor(templates, template_index) {
+        this.templates = templates;
+        this.template_index = template_index;
+    }
+    get weight() {
+        return this.templates.weights[this.template_index];
+    }
+    get length() {
+        return this.templates.get_length(this.template_index, this.rotation);
+    }
+    get center_of_gravity_z() {
+        return this.zi + this.length / 2;
+    }
+}
+exports.AllocatedItem = AllocatedItem;

package/build-cjs/core/physics/items/AllocatedItemManager.d.ts

@@ -0,0 +1,31 @@
+import { AllocatedItem } from './AllocatedItem.js';
+import type { ItemTemplates } from './ItemTemplates.js';
+/**
+ * Items allocated inside one container sequence.
+ */
+export declare class AllocatedItemManager {
+    readonly templates: ItemTemplates;
+    private items;
+    /**
+     * @param templates - Item templates for this container.
+     */
+    constructor(templates: ItemTemplates);
+    /**
+     * @param items - Items to add.
+     */
+    add_allocated_items(items: AllocatedItem[]): void;
+    /**
+     * @returns Item count.
+     */
+    count_items(): number;
+    /**
+     * @returns Item indexes.
+     */
+    list_item_indexes(): number[];
+    /**
+     * @param item_index - Item index.
+     * @returns Item instance.
+     */
+    get_item(item_index: number): AllocatedItem;
+}
+//# sourceMappingURL=AllocatedItemManager.d.ts.map

package/build-cjs/core/physics/items/AllocatedItemManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AllocatedItemManager.d.ts","sourceRoot":"","sources":["../../../../src/core/physics/items/AllocatedItemManager.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAA;AAClD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAA;AAEvD;;GAEG;AACH,qBAAa,oBAAoB;IAOjB,QAAQ,CAAC,SAAS,EAAE,aAAa;IAL7C,OAAO,CAAC,KAAK,CAAsB;IAEnC;;OAEG;gBACkB,SAAS,EAAE,aAAa;IAI7C;;OAEG;IACH,mBAAmB,CAAC,KAAK,EAAE,aAAa,EAAE,GAAG,IAAI;IAKjD;;OAEG;IACH,WAAW,IAAI,MAAM;IAKrB;;OAEG;IACH,iBAAiB,IAAI,MAAM,EAAE;IAK7B;;;OAGG;IACH,QAAQ,CAAC,UAAU,EAAE,MAAM,GAAG,aAAa;CAI9C"}