@jetta/axle-load-calculator 0.1.3 → 0.2.0

package/src/core/contracts/ms_faixas_contract.ts

@@ -1,114 +0,0 @@
-import { AllocatedItem } from '../physics/items/allocated_item.js'
-import { AllocatedItemManager } from '../physics/items/allocated_item_manager.js'
-import { ItemTemplates } from '../physics/items/item_templates.js'
-
-const TRANSPORT_LIST_FLAG = 'envs'
-const CONTAINERS_FLAG = 'containers'
-const ITEM_LIST_FLAG = 'items'
-
-/**
- * Parses ms-faixas `{ envs: [...] }` payloads for axleweight services.
- */
-export class MsFaixasContract
-{
-    transport_data: Record<string, unknown>
-    allocated_items_by_sequence_id: Record<number, AllocatedItemManager>
-
-    /**
-     * @param ms_faixas_input - Request with envs array.
-     */
-    constructor(ms_faixas_input: Record<string, unknown>)
-    {
-        const envs = ms_faixas_input[TRANSPORT_LIST_FLAG] as Record<string, unknown>[]
-        this.transport_data = { ...envs[0] }
-        this.allocated_items_by_sequence_id = build_allocated_items(this.transport_data)
-        strip_items_from_transport(this.transport_data)
-    }
-}
-
-/**
- * @param transport_data - Env vehicle data.
- * @returns Allocated items keyed by sequence index.
- */
-function build_allocated_items(
-    transport_data: Record<string, unknown>
-): Record<number, AllocatedItemManager>
-{
-    const templates = build_item_templates(transport_data)
-    const result: Record<number, AllocatedItemManager> = {}
-    const containers = transport_data[CONTAINERS_FLAG] as Record<string, unknown>[]
-    for (let index = 0; index < containers.length; index++)
-    {
-        const container = containers[index]
-        const sequence = Number(container.sequencia ?? index + 1)
-        result[sequence] = build_container_items(templates, container)
-    }
-    return result
-}
-
-/**
- * @param transport_data - Env vehicle.
- * @returns Item templates from all container items.
- */
-function build_item_templates(transport_data: Record<string, unknown>): ItemTemplates
-{
-    const templates = new ItemTemplates()
-    const containers = transport_data[CONTAINERS_FLAG] as Record<string, unknown>[]
-    for (const container of containers)
-    {
-        const items = container[ITEM_LIST_FLAG] as Record<string, unknown>[] | undefined
-        if (!items)
-        {
-            continue
-        }
-        for (const item of items)
-        {
-            templates.add_template_from_item_data(item)
-        }
-    }
-    return templates
-}
-
-/**
- * @param templates - Shared templates.
- * @param container - Container JSON.
- * @returns Allocated item manager for container.
- */
-function build_container_items(
-    templates: ItemTemplates,
-    container: Record<string, unknown>
-): AllocatedItemManager
-{
-    const manager = new AllocatedItemManager(templates)
-    const items = container[ITEM_LIST_FLAG] as Record<string, unknown>[] | undefined
-    if (!items)
-    {
-        return manager
-    }
-    const allocated: AllocatedItem[] = []
-    for (const item_data of items)
-    {
-        const item_id = String(item_data.id ?? item_data._id)
-        const template_index = templates.index_of(item_id)
-        const item = new AllocatedItem(templates, template_index)
-        item.xi = Number(item_data.x ?? 0)
-        item.yi = Number(item_data.y ?? 0)
-        // Ms-faixas stores longitudinal position in `y` (jettainterface maps y→chassis z).
-        item.zi = Number(item_data.y ?? item_data.z ?? 0)
-        allocated.push(item)
-    }
-    manager.add_allocated_items(allocated)
-    return manager
-}
-
-/**
- * @param transport_data - Env vehicle to strip item lists from.
- */
-function strip_items_from_transport(transport_data: Record<string, unknown>): void
-{
-    const containers = transport_data[CONTAINERS_FLAG] as Record<string, unknown>[]
-    for (const container of containers)
-    {
-        delete container[ITEM_LIST_FLAG]
-    }
-}

package/src/core/contracts/rotation_enum.ts

@@ -1,11 +0,0 @@
-/** Cargo rotation positions (carrierinterface RotationEnum). */
-export const ROTATION = Object.freeze({
-    POS1: 1,
-    POS2: 2,
-    POS3: 3,
-    POS4: 4,
-    POS5: 5,
-    POS6: 6
-})
-
-export type RotationCode = typeof ROTATION[keyof typeof ROTATION]

package/src/core/contracts/suspension_type.ts

@@ -1,4 +0,0 @@
-export const SUSPENSION_TYPE = Object.freeze({
-    PNEUMATICA: 'Pneumatica',
-    MECANICA: 'Mecanica'
-})

package/src/core/contracts/transport_record.ts

@@ -1,4 +0,0 @@
-/**
- * Raw transport dict as received by axle-weight services (jettainterface wire format).
- */
-export type TransportRecord = Record<string, unknown>

package/src/core/contracts/vehicle_type.ts

@@ -1,12 +0,0 @@
-export const VEHICLE_TYPE = Object.freeze({
-    CONTAINER: 0,
-    SEMIREBOQUE: 1,
-    BITREM: 2,
-    RODOTREM: 3,
-    VANDERLEIA: 5,
-    REBAIXADO: 6,
-    CAMINHAO: 7,
-    VUC: 8
-})
-
-export type VehicleTypeCode = typeof VEHICLE_TYPE[keyof typeof VEHICLE_TYPE]

package/src/core/contracts/vehicle_version.ts

@@ -1,7 +0,0 @@
-export const VEHICLE_VERSION = Object.freeze({
-    DEFAULT: 0,
-    CAMINHAO_BITRUCK: 4,
-    SEMIREBOQUE_QUAD: 5,
-    SEMIREBOQUE_BITRUCK: 6,
-    SEMIREBOQUE_QUAD_ALT: 7
-})

package/src/core/contracts/wire_flags.ts

@@ -1,26 +0,0 @@
-export const WIRE_FLAGS = Object.freeze({
-    TRANSPORT_ID: '_id',
-    CONTAINERS: 'containers',
-    AXLE_LIST: 'eixos',
-    MAIN_PIN_DISTANCE: 'distPinoRei',
-    CONTAINER_DISTANCE_AHEAD: 'containerDistanceAhead',
-    FIRST_AXLE_DISTANCE: 'primeiroEixo',
-    VEHICLE_TYPE: 'tipoVeiculo',
-    VEHICLE_VERSION: 'tipoVersao',
-    SUSPENSION_TYPE: 'tipoSuspensao',
-    SUPPORTED_WEIGHT: 'pesoDeCarga',
-    AMOUNT: 'qtd',
-    LENGTH: 'comprimento',
-    WIDTH: 'largura',
-    HEIGHT: 'altura',
-    SEQUENCE: 'sequencia',
-    GROUPER: 'grouper',
-    DISTANCE_FROM_ORIGIN: 'distanciaOrigem',
-    MAX_SUPPORTED_WEIGHT: 'pesoMaxSuportado',
-    SEQUENCE_CONTAINER: 'sequenciaContainer',
-    DNIT_WEIGHT: 'pesoDnit',
-    TARE: 'tara',
-    CM_SERVICE_CENTER_OF_MASS: 'center_of_mass',
-    CM_SERVICE_Z: 'z_position',
-    CM_SERVICE_MASS: 'mass'
-})

package/src/core/math/float_tools.ts

@@ -1,17 +0,0 @@
-/**
- * Converts nested float lists to a plain number matrix (NumPy float_list_to_np_array equivalent).
- * @param float_list - Nested numeric list.
- * @returns Plain number matrix or vector.
- */
-export function float_list_to_matrix(float_list: number[] | number[][]): number[] | number[][]
-{
-    if (float_list.length === 0)
-    {
-        return []
-    }
-    if (typeof float_list[0] === 'number')
-    {
-        return float_list as number[]
-    }
-    return (float_list as number[][]).map((row) => row.map((value) => Number(value)))
-}

package/src/core/math/gaussian_elimination.ts

@@ -1,104 +0,0 @@
-/**
- * Solves Ax = b for square matrix A using Gaussian elimination (NumPy-compatible order).
- * @param matrix - Coefficient matrix row-major n×n.
- * @param independent - Right-hand side vector length n.
- * @returns Solution vector length n.
- */
-export function solve_linear_system(matrix: number[][], independent: number[]): number[]
-{
-    const size = independent.length
-    const augmented = matrix.map((row, row_index) => [...row, independent[row_index]])
-    for (let pivot_column = 0; pivot_column < size; pivot_column++)
-    {
-        forward_eliminate(augmented, pivot_column, size)
-    }
-    return back_substitute(augmented, size)
-}
-
-/**
- * @param augmented - Augmented matrix.
- * @param pivot_column - Current pivot column index.
- * @param size - System size.
- */
-function forward_eliminate(augmented: number[][], pivot_column: number, size: number): void
-{
-    const pivot_row = find_pivot_row(augmented, pivot_column, size)
-    swap_rows(augmented, pivot_row, pivot_column)
-    eliminate_below(augmented, pivot_column, size)
-}
-
-/**
- * @param augmented - Augmented matrix.
- * @param pivot_column - Pivot column.
- * @param size - System size.
- * @returns Row index with largest absolute pivot.
- */
-function find_pivot_row(augmented: number[][], pivot_column: number, size: number): number
-{
-    let pivot_row = pivot_column
-    let max_abs = Math.abs(augmented[pivot_column][pivot_column])
-    for (let row = pivot_column + 1; row < size; row++)
-    {
-        const candidate = Math.abs(augmented[row][pivot_column])
-        if (candidate > max_abs)
-        {
-            max_abs = candidate
-            pivot_row = row
-        }
-    }
-    return pivot_row
-}
-
-/**
- * @param augmented - Augmented matrix.
- * @param pivot_row - Row to swap to pivot position.
- * @param pivot_column - Pivot column index.
- */
-function swap_rows(augmented: number[][], pivot_row: number, pivot_column: number): void
-{
-    if (pivot_row === pivot_column)
-    {
-        return
-    }
-    const temp = augmented[pivot_column]
-    augmented[pivot_column] = augmented[pivot_row]
-    augmented[pivot_row] = temp
-}
-
-/**
- * @param augmented - Augmented matrix.
- * @param pivot_column - Pivot column index.
- * @param size - System size.
- */
-function eliminate_below(augmented: number[][], pivot_column: number, size: number): void
-{
-    const pivot_value = augmented[pivot_column][pivot_column]
-    for (let row = pivot_column + 1; row < size; row++)
-    {
-        const factor = augmented[row][pivot_column] / pivot_value
-        for (let column = pivot_column; column <= size; column++)
-        {
-            augmented[row][column] -= factor * augmented[pivot_column][column]
-        }
-    }
-}
-
-/**
- * @param augmented - Row-echelon augmented matrix.
- * @param size - System size.
- * @returns Solution vector.
- */
-function back_substitute(augmented: number[][], size: number): number[]
-{
-    const solution = new Array<number>(size).fill(0)
-    for (let row = size - 1; row >= 0; row--)
-    {
-        let sum = augmented[row][size]
-        for (let column = row + 1; column < size; column++)
-        {
-            sum -= augmented[row][column] * solution[column]
-        }
-        solution[row] = sum / augmented[row][row]
-    }
-    return solution
-}

package/src/core/orchestration/axle_weight_physics.ts

@@ -1,37 +0,0 @@
-import { CmAxleWeightService } from '../physics/services/cm_axle_weight_service.js'
-import { CenterOfMass } from '../physics/items/center_of_mass.js'
-import { build_connector_payload } from './connector_payload_builder.js'
-import { mass_center_by_grouper_from_env } from './java_mass_center.js'
-
-/**
- * Calculates loaded weights per vehicle axle (in-process, no HTTP).
- * @param env_vehicle - Single env from weight_by_axis payload.
- * @returns Loaded cargo weight per axle index.
- */
-export function calculate_loaded_weights_for_env(
-    env_vehicle: Record<string, unknown>
-): number[]
-{
-    const center_of_mass_by_grouper = mass_center_by_grouper_from_env(env_vehicle)
-    const wire_center_of_mass = map_center_of_mass_wire(center_of_mass_by_grouper)
-    const payload = build_connector_payload(env_vehicle, wire_center_of_mass)
-    return new CmAxleWeightService().calculate(payload)
-}
-
-/**
- * @param center_of_mass_by_grouper - CM objects keyed by grouper.
- * @returns Plain mass/z map for wire builder.
- */
-function map_center_of_mass_wire(
-    center_of_mass_by_grouper: Record<number, CenterOfMass>
-): Record<number, { mass: number, z: number }>
-{
-    const wire: Record<number, { mass: number, z: number }> = {}
-    for (const grouper of Object.keys(center_of_mass_by_grouper))
-    {
-        const id = Number(grouper)
-        const entry = center_of_mass_by_grouper[id]
-        wire[id] = { mass: entry.mass, z: entry.z }
-    }
-    return wire
-}

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)
-}