@jetta/axle-load-calculator 0.1.3 → 0.3.1

package/src/core/orchestration/collision_checker.ts

@@ -1,86 +0,0 @@
-/**
- * Validates allocated items do not overlap (Java CollisionChecker parity for tests).
- * @param env_vehicle - Env vehicle with containers and items.
- */
-export function check_cargo_collision(env_vehicle: Record<string, unknown>): void
-{
-    const key = env_vehicle.conteiners ? 'conteiners' : 'containers'
-    const containers = env_vehicle[key] as Record<string, unknown>[] | undefined
-    if (!containers)
-    {
-        return
-    }
-    for (const container of containers)
-    {
-        check_container_items(container)
-    }
-}
-
-/**
- * @param container - Container with items.
- */
-function check_container_items(container: Record<string, unknown>): void
-{
-    const items = container.items as Record<string, unknown>[] | undefined
-    if (!items || items.length <= 1)
-    {
-        return
-    }
-    for (let i = 0; i < items.length - 1; i++)
-    {
-        for (let j = i + 1; j < items.length; j++)
-        {
-            if (items_intersect(items[i], items[j]))
-            {
-                throw new Error('Item overlap error')
-            }
-        }
-    }
-}
-
-/**
- * @param left - First item.
- * @param right - Second item.
- * @returns True when 3D boxes overlap (Java Item.intersect axes swap).
- */
-function items_intersect(left: Record<string, unknown>, right: Record<string, unknown>): boolean
-{
-    const left_box = item_intervals(left)
-    const right_box = item_intervals(right)
-    return intervals_overlap(left_box.x, right_box.x)
-        && intervals_overlap(left_box.y, right_box.y)
-        && intervals_overlap(left_box.z, right_box.z)
-}
-
-/**
- * @param item - Item JSON.
- * @returns Axis intervals using Java coordinate mapping.
- */
-function item_intervals(item: Record<string, unknown>): {
-    x: [number, number]
-    y: [number, number]
-    z: [number, number]
-}
-{
-    const x0 = Number(item.x ?? 0)
-    const width = Number(item.largura ?? item.width ?? 0)
-    const json_y = Number(item.y ?? 0)
-    const json_z = Number(item.z ?? 0)
-    const length = Number(item.comprimento ?? item.length ?? 0)
-    const height = Number(item.altura ?? item.height ?? 0)
-    return {
-        x: [x0, x0 + width],
-        y: [json_z, json_z + height],
-        z: [json_y, json_y + length]
-    }
-}
-
-/**
- * @param left - Interval.
- * @param right - Interval.
- * @returns True when open intervals overlap.
- */
-function intervals_overlap(left: [number, number], right: [number, number]): boolean
-{
-    return left[0] < right[1] && right[0] < left[1]
-}

package/src/core/orchestration/connector_payload_builder.ts

@@ -1,81 +0,0 @@
-import { WIRE_FLAGS } from '../contracts/wire_flags.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.
- */
-export function build_connector_payload(
-    env_vehicle: Record<string, unknown>,
-    center_of_mass_by_grouper: Record<number, { mass: number, z: number }>
-): Record<string, unknown>
-{
-    const center_of_mass = map_center_of_mass_wire(center_of_mass_by_grouper)
-    return {
-        [WIRE_FLAGS.CONTAINERS]: build_containers(env_vehicle),
-        [WIRE_FLAGS.AXLE_LIST]: build_axles(env_vehicle),
-        [WIRE_FLAGS.TRANSPORT_ID]: env_vehicle._id,
-        [WIRE_FLAGS.AMOUNT]: 1,
-        [WIRE_FLAGS.SUPPORTED_WEIGHT]: env_vehicle.pesoDeCarga,
-        [WIRE_FLAGS.FIRST_AXLE_DISTANCE]: env_vehicle.primeiroEixo,
-        [WIRE_FLAGS.VEHICLE_TYPE]: env_vehicle.tipoVeiculo,
-        [WIRE_FLAGS.VEHICLE_VERSION]: env_vehicle.tipoVersao,
-        [WIRE_FLAGS.SUSPENSION_TYPE]: env_vehicle.tipoSuspensao,
-        [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: Record<number, { mass: number, z: number }>
-): Record<string, { mass: number, z_position: number }>
-{
-    const center_of_mass: Record<string, { mass: number, z_position: number }> = {}
-    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,
-            [WIRE_FLAGS.CM_SERVICE_Z]: entry.z
-        }
-    }
-    return center_of_mass
-}
-
-/**
- * @param env_vehicle - Env vehicle JSON.
- * @returns Container wire list without items.
- */
-function build_containers(env_vehicle: Record<string, unknown>): Record<string, unknown>[]
-{
-    const list = env_vehicle.containers as Record<string, unknown>[]
-    return list.map((container) => ({
-        [WIRE_FLAGS.LENGTH]: container.comprimento,
-        [WIRE_FLAGS.WIDTH]: container.largura,
-        [WIRE_FLAGS.HEIGHT]: container.altura,
-        [WIRE_FLAGS.SEQUENCE]: container.sequencia,
-        [WIRE_FLAGS.MAIN_PIN_DISTANCE]: container.distPinoRei,
-        [WIRE_FLAGS.CONTAINER_DISTANCE_AHEAD]: container.containerDistanceAhead,
-        [WIRE_FLAGS.GROUPER]: container.grouper
-    }))
-}
-
-/**
- * @param env_vehicle - Env vehicle JSON.
- * @returns Axle wire list.
- */
-function build_axles(env_vehicle: Record<string, unknown>): Record<string, unknown>[]
-{
-    const list = env_vehicle.eixos as Record<string, unknown>[]
-    return list.map((axle) => ({
-        [WIRE_FLAGS.DISTANCE_FROM_ORIGIN]: axle.distanciaOrigem,
-        [WIRE_FLAGS.MAX_SUPPORTED_WEIGHT]: axle.pesoMaxSuportado,
-        [WIRE_FLAGS.SEQUENCE_CONTAINER]: axle.sequenciaContainer,
-        [WIRE_FLAGS.DNIT_WEIGHT]: axle.pesoDnit ?? axle.pesoMaxSuportado,
-        [WIRE_FLAGS.TARE]: axle.tara
-    }))
-}

package/src/core/orchestration/java_mass_center.ts

@@ -1,98 +0,0 @@
-import { CenterOfMass } from '../physics/items/center_of_mass.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).
- * @param env_vehicle - Single env vehicle object from weight_by_axis payload.
- * @returns Map of grouper id to center of mass.
- */
-export function mass_center_by_grouper_from_env(
-    env_vehicle: Record<string, unknown>
-): Record<number, CenterOfMass>
-{
-    const result: Record<number, CenterOfMass> = {}
-    const containers = env_vehicle.containers as Record<string, unknown>[] | undefined
-    if (!containers)
-    {
-        return result
-    }
-    for (const container of containers)
-    {
-        const grouper = Number(container.grouper)
-        // Java AxleWeightConnector overwrites per container in loop order (last wins).
-        result[grouper] = compute_container_mass_center(container)
-    }
-    return result
-}
-
-/**
- * @param container - Container object with items array.
- * @returns Center of mass for container items.
- */
-function compute_container_mass_center(container: Record<string, unknown>): CenterOfMass
-{
-    const center_of_mass = new CenterOfMass()
-    const items = container.items as Record<string, unknown>[] | undefined
-    if (!items || items.length === 0)
-    {
-        center_of_mass.mass = 0
-        center_of_mass.z = 0
-        return center_of_mass
-    }
-    const container_offset = read_container_longitudinal_offset(container)
-    let accumulated = 0
-    let mass = 0
-    for (const item of items)
-    {
-        const weight = read_item_weight(item)
-        const position = container_offset + read_item_longitudinal_position(item)
-        accumulated += weight * position
-        mass += weight
-    }
-    center_of_mass.mass = mass
-    center_of_mass.z = mass === 0 ? 0 : accumulated / mass
-    return center_of_mass
-}
-
-/**
- * @param container - Container JSON.
- * @returns Longitudinal offset of container body (first faixa z1 when present).
- */
-function read_container_longitudinal_offset(container: Record<string, unknown>): number
-{
-    const bands = container.faixas as Record<string, unknown>[] | undefined
-    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: Record<string, unknown>): number
-{
-    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: Record<string, unknown>): number
-{
-    const origin_y = Number(item.y ?? 0)
-    const custom = item.centerOfGravity as Record<string, unknown> | undefined
-    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/src/core/orchestration/output_builder.ts

@@ -1,18 +0,0 @@
-/**
- * @param envs - Output env list.
- * @returns Success JSON string.
- */
-export function build_success_output(envs: Record<string, unknown>[]): string
-{
-    return JSON.stringify({ envs })
-}
-
-/**
- * @param error - Thrown error.
- * @returns Error JSON string matching ms-faixas format.
- */
-export function build_error_output(error: unknown): string
-{
-    const message = error instanceof Error ? error.message : String(error)
-    return JSON.stringify({ msg: message, apiError: message })
-}

package/src/core/orchestration/request_schema.ts

@@ -1,26 +0,0 @@
-import { z } from 'zod'
-
-const env_schema = z.object({
-    _id: z.union([z.string(), z.number()]).optional(),
-    eixos: z.array(z.record(z.unknown())).min(1),
-    conteiners: z.array(z.record(z.unknown())).optional(),
-    containers: z.array(z.record(z.unknown())).optional()
-}).passthrough()
-
-const request_schema = z.object({
-    envs: z.array(env_schema).min(1),
-    config: z.record(z.unknown()).optional()
-}).passthrough()
-
-export type WeightByAxisRequest = z.infer<typeof request_schema>
-
-/**
- * Parses and validates weight-by-axis JSON at the library boundary.
- * @param json_data - Raw request string.
- * @returns Parsed request object.
- */
-export function parse_weight_by_axis_request(json_data: string): WeightByAxisRequest
-{
-    const parsed: unknown = JSON.parse(json_data)
-    return request_schema.parse(parsed)
-}

package/src/core/orchestration/weight_by_axis_task.ts

@@ -1,140 +0,0 @@
-import { calculate_loaded_weights_for_env } from './axle_weight_physics.js'
-import { build_success_output, build_error_output } from './output_builder.js'
-import { check_cargo_collision } from './collision_checker.js'
-import { parse_weight_by_axis_request } from './request_schema.js'
-
-/**
- * Runs weight-by-axis for ms-faixas JSON input (WeightByAxisTask.run contract).
- * @param json_data - Raw request JSON string.
- * @returns Response JSON string.
- */
-export function run_weight_by_axis_task(json_data: string): string
-{
-    try
-    {
-        const request = parse_weight_by_axis_request(json_data)
-        const envs = request.envs as Record<string, unknown>[]
-        const output_envs = []
-        for (const env of envs)
-        {
-            const loaded_weights = calculate_loaded_weights_for_env(env)
-            apply_loaded_weights_to_env(env, loaded_weights)
-            check_cargo_collision(env)
-            output_envs.push(strip_items_and_bands(env))
-        }
-        return build_success_output(output_envs)
-    }
-    catch (error)
-    {
-        return build_error_output(error)
-    }
-}
-
-/**
- * @param env - Env vehicle object.
- * @param loaded_weights - Forces per axle.
- */
-function apply_loaded_weights_to_env(
-    env: Record<string, unknown>,
-    loaded_weights: number[]
-): void
-{
-    const axles = env.eixos as Record<string, unknown>[]
-    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.conteiners ?? env.containers
-    if (!Array.isArray(containers))
-    {
-        return
-    }
-    apply_to_containers(containers as Record<string, unknown>[], 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: Record<string, unknown>[],
-    loaded_weights: number[],
-    axles: Record<string, unknown>[]
-): void
-{
-    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: Record<string, unknown>,
-    loaded_weights: number[],
-    axles: Record<string, unknown>[]
-): Record<string, unknown>[]
-{
-    const sequence = Number(container.sequencia)
-    const result: Record<string, unknown>[] = []
-    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: Record<string, unknown>,
-    cargo: number
-): Record<string, unknown>
-{
-    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
-    }
-}
-
-/**
- * @param env - Env with updated axle data.
- * @returns Env copy without items/faixas on containers.
- */
-function strip_items_and_bands(env: Record<string, unknown>): Record<string, unknown>
-{
-    const clone = JSON.parse(JSON.stringify(env)) as Record<string, unknown>
-    const key = clone.conteiners ? 'conteiners' : 'containers'
-    const containers = clone[key] as Record<string, unknown>[]
-    for (const container of containers)
-    {
-        container.items = []
-        container.faixas = []
-    }
-    clone.idCaminhao = clone._id
-    return clone
-}

package/src/core/physics/items/allocated_item.ts

@@ -1,41 +0,0 @@
-import type { RotationCode } from '../../contracts/rotation_enum.js'
-import { ROTATION } from '../../contracts/rotation_enum.js'
-import type { ItemTemplates } from './item_templates.js'
-
-/**
- * Allocated cargo item with position in container coordinates.
- */
-export class AllocatedItem
-{
-    xi = 0
-    yi = 0
-    zi = 0
-    rotation: RotationCode = ROTATION.POS1
-    readonly template_index: number
-    readonly templates: ItemTemplates
-
-    /**
-     * @param templates - Shared templates.
-     * @param template_index - Template index.
-     */
-    constructor(templates: ItemTemplates, template_index: number)
-    {
-        this.templates = templates
-        this.template_index = template_index
-    }
-
-    get weight(): number
-    {
-        return this.templates.weights[this.template_index]
-    }
-
-    get length(): number
-    {
-        return this.templates.get_length(this.template_index, this.rotation)
-    }
-
-    get center_of_gravity_z(): number
-    {
-        return this.zi + this.length / 2
-    }
-}

package/src/core/physics/items/allocated_item_manager.ts

@@ -1,50 +0,0 @@
-import { AllocatedItem } from './allocated_item.js'
-import type { ItemTemplates } from './item_templates.js'
-
-/**
- * Items allocated inside one container sequence.
- */
-export class AllocatedItemManager
-{
-    private items: AllocatedItem[] = []
-
-    /**
-     * @param templates - Item templates for this container.
-     */
-    constructor(readonly templates: ItemTemplates)
-    {
-    }
-
-    /**
-     * @param items - Items to add.
-     */
-    add_allocated_items(items: AllocatedItem[]): void
-    {
-        this.items.push(...items)
-    }
-
-    /**
-     * @returns Item count.
-     */
-    count_items(): number
-    {
-        return this.items.length
-    }
-
-    /**
-     * @returns Item indexes.
-     */
-    list_item_indexes(): number[]
-    {
-        return this.items.map((_item, index) => index)
-    }
-
-    /**
-     * @param item_index - Item index.
-     * @returns Item instance.
-     */
-    get_item(item_index: number): AllocatedItem
-    {
-        return this.items[item_index]
-    }
-}

package/src/core/physics/items/center_of_mass.ts

@@ -1,31 +0,0 @@
-import type { AllocatedItemManager } from './allocated_item_manager.js'
-
-/**
- * Center of mass for a load grouper (longitudinal z in chassis coordinates).
- */
-export class CenterOfMass
-{
-    mass = 0
-    z = 0
-
-    /**
-     * Computes center of mass from allocated items.
-     * @param allocated_items - Item manager for one grouper.
-     */
-    set_center_of_mass_with_allocated_items(allocated_items: AllocatedItemManager): void
-    {
-        let accumulated_weighted_positions = 0
-        this.mass = 0
-        for (const item_index of allocated_items.list_item_indexes())
-        {
-            const item = allocated_items.get_item(item_index)
-            accumulated_weighted_positions += item.center_of_gravity_z * item.weight
-            this.mass += item.weight
-        }
-        if (this.mass === 0)
-        {
-            return
-        }
-        this.z = accumulated_weighted_positions / this.mass
-    }
-}

package/src/core/physics/items/compute_grouper_center_of_mass.ts

@@ -1,44 +0,0 @@
-import type { Transport } from '../transports/transport.js'
-import { MergedContainers } from '../transports/merged_containers.js'
-import { CenterOfMass } from './center_of_mass.js'
-import type { MultiContainerAllocatedItems } from './multi_container_allocated_items.js'
-import type { ChassiForces } from '../models/chassi_forces.js'
-
-/**
- * @param multi_items - Allocated items across containers.
- * @param merged - Merged container layout.
- * @returns Center of mass map keyed by grouper id.
- */
-export function compute_center_of_mass_by_grouper(
-    multi_items: MultiContainerAllocatedItems,
-    merged: MergedContainers
-): Record<number, CenterOfMass>
-{
-    multi_items.merge_allocated_items(merged)
-    const result: Record<number, CenterOfMass> = {}
-    for (const grouper of merged.list_grouper_indexes())
-    {
-        const center_of_mass = new CenterOfMass()
-        center_of_mass.set_center_of_mass_with_allocated_items(
-            multi_items.get_allocated_items_by_grouper_index(grouper))
-        result[grouper] = center_of_mass
-    }
-    return result
-}
-
-/**
- * @param transport - Parsed transport.
- * @param multi_items - Allocated items.
- * @param solve - Model solver from CM map.
- * @returns Chassis forces.
- */
-export function calculate_chassi_forces_from_multi(
-    transport: Transport,
-    multi_items: MultiContainerAllocatedItems,
-    solve: (center_of_mass_by_grouper: Record<number, CenterOfMass>) => ChassiForces
-): ChassiForces
-{
-    const merged = new MergedContainers(transport)
-    const center_of_mass_by_grouper = compute_center_of_mass_by_grouper(multi_items, merged)
-    return solve(center_of_mass_by_grouper)
-}

package/src/core/physics/items/item_templates.ts

@@ -1,65 +0,0 @@
-import type { RotationCode } from '../../contracts/rotation_enum.js'
-import { ROTATION } from '../../contracts/rotation_enum.js'
-import { rotate_dimensions } from './rotation_transforms.js'
-
-/**
- * Item dimensions and weights keyed by template index.
- */
-export class ItemTemplates
-{
-    ids: string[] = []
-    weights: number[] = []
-    lengths: number[] = []
-    widths: number[] = []
-    heights: number[] = []
-    private dimensions: [number, number, number][] = []
-
-    /**
-     * @param item_id - Template id string.
-     * @returns Template index.
-     */
-    index_of(item_id: string): number
-    {
-        const index = this.ids.indexOf(item_id)
-        if (index < 0)
-        {
-            throw new Error(`Unknown item id ${item_id}`)
-        }
-        return index
-    }
-
-    /**
-     * @param item_data - Ms-faixas or math input item definition.
-     */
-    add_template_from_item_data(item_data: Record<string, unknown>): void
-    {
-        const id = String(item_data.id ?? item_data._id)
-        this.ids.push(id)
-        this.weights.push(Number(item_data.peso ?? item_data.weight ?? 0))
-        const width = Number(item_data.largura ?? item_data.width ?? 0)
-        const length = Number(item_data.comprimento ?? item_data.length ?? 0)
-        const height = Number(item_data.altura ?? item_data.height ?? 0)
-        this.widths.push(width)
-        this.lengths.push(length)
-        this.heights.push(height)
-        this.dimensions.push([width, length, height])
-    }
-
-    /**
-     * @param template_index - Template index.
-     * @param rotation - Rotation code.
-     * @returns Length along chassis z for rotation.
-     */
-    get_length(template_index: number, rotation: RotationCode = ROTATION.POS1): number
-    {
-        return rotate_dimensions(rotation, this.dimensions[template_index])[1]
-    }
-
-    /**
-     * @param item_data - Math input item row.
-     */
-    add_template_from_math_item(item_data: Record<string, unknown>): void
-    {
-        this.add_template_from_item_data(item_data)
-    }
-}