@jetta/axle-load-calculator 0.1.3

package/.cursor/ai_changelog/INDEX.md

@@ -0,0 +1,13 @@
+# Feature knowledge index
+
+Agent-oriented notes for implemented features in this repository.
+
+| Ticket | Topic | Primary module | Doc |
+|--------|-------|----------------|-----|
+
+## How to add a doc
+
+1. Copy structure from [_TEMPLATE.md](./_TEMPLATE.md).
+2. Save as `JET-XXXX-short-slug.md` (lowercase slug, hyphens).
+3. Add a row to this table.
+4. In Cursor, invoke: `KB: JET-XXXX` or use the `document-feature-knowledge` skill.

package/.cursor/ai_changelog/_TEMPLATE.md

@@ -0,0 +1,55 @@
+# JET-XXXX — Short title
+
+## Problem / outcome
+
+One paragraph: what problem this solves and what changes for callers.
+
+## Scope
+
+- **In scope:**
+- **Out of scope / unchanged:**
+
+## Entry points
+
+| Role | Path |
+|------|------|
+| Main logic | `src/...` |
+| Integration | `src/...` |
+| Config accessors | `src/models/Cargo_Profile.js` |
+| Validation | `src/validation/schemas/...` |
+
+## Configuration
+
+Do not duplicate full key docs here. Link to [config.md](../../config.md) and list only behavior-specific notes.
+
+- Keys: `...`
+- Defaults:
+- Enabled when:
+
+## Behavior and invariants
+
+-
+- Fixed vocabulary: `src/.../Some_Strategy.js`
+
+## Flow (optional)
+
+```mermaid
+flowchart LR
+  A[Input] --> B[Step]
+```
+
+## Tests as specification
+
+| Type | Path | What it proves |
+|------|------|----------------|
+| Unit | `test/src/...` | |
+| Integration | `test/src/...` | |
+
+## Dependencies and related work
+
+- Tickets:
+- Packages:
+
+## Open questions
+
+- (only if still true)

package/.cursor/rules/code-standards.mdc

@@ -0,0 +1,103 @@
+---
+description: Project standards from GEMINI.md (language, naming, code rules, style, refactoring, testing, commit)
+alwaysApply: true
+---
+
+# General Standards
+
+## Languages
+
+1. English. Always.
+
+## Naming Conventions
+
+1. Use `snake_case` for all functions, variables, and parameters;
+2. Use `lowercase` for folder names;
+3. Prefer full words over abbreviations in variable and parameter names so intent stays obvious (e.g. `minimum_weight` rather than `min_w`). Narrow exceptions: ubiquitous forms such as `id`, conventional loop indices (`i`, `j`), or standard acronyms where spelling them out adds noise without clarity;
+
+## Code Rules
+
+1. Meaningful names only;
+2. Adhere to the SOLID principles;
+3. Maximum 2 statements per line (e.g. two assignments or two declarations). Chained method calls (e.g. `a().b().c()`) count each as one statement;
+4. Prefer the algorithm with the best time/space complexity that is still readable and maintainable;
+5. Maximum 25 lines per function. It does not apply to comments or blank lines;
+6. Maximum 125 lines per file. It does not apply to comments or blank lines;
+7. When a file or module gains multiple distinct responsibilities, split it into separate files so that each file has a single, clear responsibility (and the split keeps the design coherent) - that's an enforcement on SOLID principles;
+8. Adhere to modern and best practices standards;
+9. Prefer one of: return an empty collection (e.g. []), use an optional/Maybe type, return a Result/Either type, or throw a documented exception. Choose based on the API contract and language idioms.;
+10. Avoid anonymous functions being declared inside of another function, except trivial one-liners when readability is not harmed (e.g. `.map(x => x.id)`). Except anonymous callbacks that are a single expression with no side effects and that are passed directly to a well-known higher-order function (e.g. .map(x => x.id), .filter(Boolean)). If in doubt, extract to a named function;
+11. Avoid nested functions;
+12. Avoid multiple classes, interfaces or types in the same file: split them into a single one per file;
+13. Avoid generic exceptions. Create specialized exceptions instead.
+
+## Code Style
+
+1. Follow the rules defined in `eslint.config.js`.
+2. Document all public functions using JSDoc, explaining their purpose, parameters (`@param`), and return values (`@returns`);
+3. Follow the semicolon style defined in eslint.config.js;
+4. Run `npm run lint` before committing. Fix any reported issues before committing.
+
+## Error Handling
+
+1. Never suppress errors silently with empty `catch` blocks; either handle them meaningfully or rethrow;
+2. Log errors with enough context (operation, relevant identifiers, inputs) to make the failure diagnosable.
+
+## Performance
+
+1. Avoid expensive operations inside loops; hoist invariant computations out of the loop body, or use optimized array methods to prevent redundant processing.
+
+## API Design
+
+1. Use a standardized response format across all API endpoints to ensure consistency and predictability;
+2. Validate every incoming payload from user input or API clients using a robust validation schema (e.g., `zod`, already a project dependency);
+3. After validating a fixed-vocabulary field, normalize it to the shared constants object defined in **Fixed Vocabularies**; reject or default unknown values at the boundary, not in downstream consumers.
+
+## Fixed Vocabularies
+
+1. When a value belongs to a fixed, finite set (e.g. strategies, modes, statuses), define it once as a frozen constants object and reuse it across validation, readers, and consumers. Do not scatter the same string literals in multiple files;
+2. In plain JavaScript, use a frozen object as the enum (not TypeScript `enum`). Export both the named constants and, when useful, `Object.values(...)` for schema allow-lists;
+3. Keep external wire formats as strings (config JSON, API payloads). Map validated input to the shared constants at the boundary; internal code compares against the constants, not raw strings;
+4. Place the constants module next to the domain they describe (e.g. `src/Allocation_Optimization/density_groups/Density_Groups_Strategy.js`), not inside validation-only modules, unless the vocabulary is truly validation-specific;
+5. Document public accessors that return a vocabulary member with JSDoc union types referencing the constants (e.g. `@returns {typeof DENSITY_GROUPS_STRATEGY.ROUND_ROBIN | typeof DENSITY_GROUPS_STRATEGY.ADAPTIVE}`);
+6. Prefer the constants in tests as well (`expect(...).to.equal(DENSITY_GROUPS_STRATEGY.ADAPTIVE)`), so tests stay aligned with production code.
+
+## Security
+
+1. Never trust external input; validate and sanitize all data from users or API clients before using it, to prevent injection, XSS, and similar vulnerabilities.
+
+## Refactoring
+
+1. When refactoring, preserve behavior: do not change the observable semantics of the code. Refactoring is structure-only unless the user explicitly requests a behavior change;
+2. Prioritize readability and explicit logic over extreme conciseness;
+3. Simplify unnecessary abstractions, but do not sacrifice clarity for fewer lines of code.
+
+## Testing
+
+1. Write tests using Mocha and Chai;
+2. Structure tests with `describe` for test suites and `it` for individual test cases;
+3. Test descriptions should be clear, descriptive, and explain the expected behavior;
+4. Under `test/src`, mirror the directory structure of `src/` (e.g. `src/Allocation_Optimization/block_builder/` → `test/src/Allocation_Optimization/block_builder/`);
+5. Test data are to be created on root/test/data/src, then follow root/src's pattern of folder;
+6. Ensure tests cover the 'happy path', known edge cases, invalid inputs, and all expected Exception scenarios;
+7. Avoid redundant tests that assert the same logical branch;
+8. Avoid changing the main code behavior in tests, except when the user has explicitly asked for a behavior change;
+9. Always add intergration tests.
+
+## Commit
+
+This project adheres to:
+
+1. [SemVer](https://semver.org/)
+2. [Conventional Commits](https://www.conventionalcommits.org/en/)
+3. **Make atomic commits:** Each commit must represent a single, logical change (e.g., refactoring one component, deleting an unused file, or fixing a specific bug);
+4. **Never use `git add .` or `git commit -a`:** Always stage files individually (`git add <file>`) to ensure multiple distinct changes are not grouped in a single commit;
+5. **Irreversible commands:** Never use irreversible git commands (e.g., `git reset --hard`, `git clean -fd`) without explicit permission granted by the user;
+6. Avoid adding `Made-with: Cursor` to commit messages;
+7. Commit messages should be one concise phrase;
+8. Try to keep tests green after each commit, if possible;
+9. Never commit input from debug. i.e., `./debug/data/input.json`.
+
+## README
+
+1. must contain at least sections `how to install`, `usage`, `dependencies`, `requirements` (not necessarily in that order)

package/.cursor/rules/knowledge-base.mdc

@@ -0,0 +1,14 @@
+---
+description: Feature knowledge base location and doc shape for ai_changelog
+globs: .cursor/ai_changelog/**
+alwaysApply: false
+---
+
+# Knowledge base
+
+Feature knowledge lives in `.cursor/ai_changelog/`.
+
+- New docs: follow `_TEMPLATE.md`; filename `JET-XXXX-short-slug.md`.
+- Update `INDEX.md` when adding a doc.
+- Config keys: link to `config.md`, do not duplicate tables.
+- Prefer tests + code over stale PR text when they disagree.

package/.cursor/rules/planning-standards.mdc

@@ -0,0 +1,55 @@
+---
+description: Planning norms—investigation, scope, plan shape, clarifications, Plan Mode alignment (enable for design-heavy work)
+alwaysApply: false
+---
+
+# Planning Standards
+
+## Languages
+
+1. English. Always.
+
+## When to plan
+
+1. Produce a written plan before multi-file work, behavior changes, or ambiguous requirements;
+2. Prefer a short plan even for medium tasks when trade-offs or risks matter;
+3. Skip heavy planning for obvious one-line fixes when scope and approach are already clear.
+
+## Research first
+
+1. Investigate with read-only steps (read files, search the codebase) before proposing changes;
+2. Cite existing code using full repository paths and, when helpful, markdown links to files;
+3. When the session is in Plan Mode (or the user asked for a plan only), do not edit files, run mutating commands, or commit until the user approves the plan;
+4. Base the plan on evidence from the repo, not assumptions; state explicit assumptions when evidence is missing.
+
+## Scope and constraints
+
+1. State what is in scope and what is explicitly out of scope;
+2. Avoid drive-by refactors and unrelated file churn; every planned change should trace to the user request;
+3. Respect project rules in `code-standards.mdc` once implementation begins.
+
+## Clarification
+
+1. If requirements are ambiguous or multiple approaches differ materially, ask one or two critical questions before finalizing the plan;
+2. Surface trade-offs in the plan instead of hiding them in later implementation;
+3. Prefer structured multiple-choice when the product offers it for decisions that block planning;
+4. Avoid any assumption.
+
+## Plan document shape
+
+1. Start with a clear title and a short overview of the goal and outcome;
+2. List key files to touch with paths (markdown links where useful);
+3. Use ordered, actionable steps the implementer can follow;
+4. Call out risks, unknowns, and dependencies;
+5. Use mermaid or similar diagrams only when the flow or architecture is non-trivial;
+6. Keep the plan proportional to task complexity—do not over-engineer small changes.
+
+## Handoff to implementation
+
+1. After the user accepts the plan, implement following `.cursor/rules/code-standards.mdc` (code style, tests, commits);
+2. If the user revises the plan mid-task, treat updates as steering unless they clearly start a new task.
+
+## Tooling alignment
+
+1. When using the product’s plan workflow, the user-visible plan should satisfy the sections above without duplicating Cursor product documentation;
+2. Do not edit the plan artifact file itself unless the user explicitly asks to update that file.

package/.cursor/skills/document-feature-knowledge/SKILL.md

@@ -0,0 +1,51 @@
+---
+name: document-feature-knowledge
+description: >-
+  Create or update a feature knowledge doc under .cursor/ai_changelog from
+  code, tests, and config. Use when the user says "knowledge base", "KB:",
+  "document this feature", or names a JET ticket for condensation.
+disable-model-invocation: true
+---
+
+# Document feature knowledge
+
+## When to use
+
+The user explicitly asks to document a feature or branch in the knowledge base (e.g. "KB: JET-1977", "document density groups in the knowledge base").
+
+## Output location
+
+- Directory: `.cursor/ai_changelog/`
+- Filename: `JET-XXXX-short-slug.md` (lowercase slug, hyphens)
+- Template: copy structure from `_TEMPLATE.md`
+- Update `INDEX.md` with a new row when creating a file
+
+## Source-of-truth priority
+
+1. Integration and unit tests under `test/src/` (mirror of `src/`)
+2. `config.md` for keys, defaults, ranges
+3. Implementation under `src/`
+4. User-provided PR notes or chat decisions (label as "product decision" if not in code)
+
+Do not duplicate `config.md` key tables; link to sections instead.
+
+## Research steps
+
+1. Parse ticket id (JET-XXXX) and scope from the user message; ask if scope is ambiguous.
+2. If branch or commit range given, use read-only `git diff` / `git log` to bound changes.
+3. Find entry points: grep ticket slug, feature folder name, config keys.
+4. Read `Cargo_Profile` or schema validators for boundary normalization and fixed vocabularies.
+5. List tests that encode behavior; read integration tests first for business claims.
+6. Write the doc using `_TEMPLATE.md` sections; omit empty optional sections.
+7. Add or update `INDEX.md` row.
+
+## Quality bar
+
+Each doc must include: problem/outcome, scope, entry points table, behavior/invariants, tests table, backward-compat note if feature is flag-gated.
+
+## Non-goals
+
+- No install/usage README content
+- No full API reference (point to `config.md` and `doc/`)
+- No commit unless user asks
+- Never use `debug/data/input.json` as a source

package/README.md

@@ -0,0 +1,49 @@
+# axle-load-calculator
+
+TypeScript library that merges **ms-faixas-porcentuais** `weight_on_axles_physics` orchestration with the **axleweight** physics engine. v1 is in-process only (no HTTP).
+
+## Requirements
+
+- Node.js 20+
+- npm
+
+## How to install
+
+```bash
+npm install
+npm run build
+```
+
+## Usage
+
+```typescript
+import { calculate_weight_on_axles_physics } from '@jetta/axle-load-calculator'
+
+const response_json = calculate_weight_on_axles_physics(input_json_string)
+```
+
+**Contract:** same as `WeightByAxisTask.run()` in ms-faixas-porcentuais:
+
+- Input: JSON string `{ envs, config? }`
+- Success: `envs[].conteiners[].pesoEixos` filled; `items` and `faixas` cleared on containers
+- Error: `{ msg, apiError }`
+
+## Dependencies
+
+- [zod](https://github.com/colinhacks/zod) — request validation at the public boundary
+
+## Scripts
+
+| Command | Description |
+|---------|-------------|
+| `npm test` | Mocha tests (physics + Java integration fixtures) |
+| `npm run lint` | ESLint (`src`, `test/src`) |
+| `npm run build` | `tsc` → `build/` |
+
+## Layout
+
+- `src/index.ts` — public API
+- `src/core/physics/` — axleweight port (models, deflection, tare, services)
+- `src/core/orchestration/` — Java weight-by-axis glue (mass center, collision, output)
+- `src/service/` — reserved for future HTTP layer
+- `test/src/` — mirrors `src/`; fixtures under `test/data/src/`

package/bitbucket-pipelines.yml

@@ -0,0 +1,81 @@
+#version v0.0.4
+
+image: node:24
+
+definitions:
+  steps:
+    - step: &lint-step
+        name: 'Running lint'
+        script:
+          - echo "//registry.npmjs.org/:_authToken=${NPM_PUBLISH_TOKEN}" > .npmrc
+          - npm ci
+          - npm run lint
+    - step: &build-verify-step
+        name: 'Building ts'
+        caches:
+          - node
+        script:
+          - echo "//registry.npmjs.org/:_authToken=${NPM_PUBLISH_TOKEN}" > .npmrc
+          - npm ci
+          - npm run build
+    - step: &security-step
+        name: 'Running security scan'
+        script:
+          - echo "//registry.npmjs.org/:_authToken=${NPM_PUBLISH_TOKEN}" > .npmrc
+          - npm ci
+          - npm audit --omit=dev
+    - step: &test-step
+        name: 'Running tests'
+        caches:
+          - node
+        script:
+          - echo "//registry.npmjs.org/:_authToken=${NPM_PUBLISH_TOKEN}" > .npmrc
+          - npm ci
+          - npm run test
+
+pipelines:
+  pull-requests:
+    '{dev,stage,prod}': # Default pull request pipeline for all branches
+      - parallel:
+          - step: *lint-step
+          - step: *build-verify-step
+          - step: *security-step
+          - step: *test-step
+
+  tags:
+    # 1. Matches tags starting with 'alpha-' (e.g., alpha-v1.0.1-0)
+    'alpha-*':
+      - parallel:
+          - step: *lint-step
+          - step: *build-verify-step
+          - step: *security-step
+          - step: *test-step
+      - step:
+          name: Deploy Alpha
+          deployment: Test
+          script:
+            - echo "//registry.npmjs.org/:_authToken=${NPM_PUBLISH_TOKEN}" > .npmrc
+            - npm ci
+            - npm run build
+            - pipe: atlassian/npm-publish:0.3.2
+              variables:
+                NPM_TOKEN: $NPM_PUBLISH_TOKEN
+                EXTRA_ARGS: '--tag alpha'
+
+    # 2. Matches tags starting with 'v' (e.g., v1.0.1)
+    'v*':
+      - parallel:
+          - step: *lint-step
+          - step: *build-verify-step
+          - step: *security-step
+          - step: *test-step
+      - step:
+          name: Deploy to Production
+          deployment: Production
+          script:
+            - echo "//registry.npmjs.org/:_authToken=${NPM_PUBLISH_TOKEN}" > .npmrc
+            - npm ci
+            - npm run build
+            - pipe: atlassian/npm-publish:0.3.2
+              variables:
+                NPM_TOKEN: $NPM_PUBLISH_TOKEN

package/build/core/contracts/chassi_reference.d.ts

@@ -0,0 +1,7 @@
+export declare const CHASSI_REFERENCE: Readonly<{
+    GROUPER_1: "GROUPER_1";
+    GROUPER_2: "GROUPER_2";
+    TRACTOR: "TRACTOR";
+}>;
+export type ChassiReference = typeof CHASSI_REFERENCE[keyof typeof CHASSI_REFERENCE];
+//# sourceMappingURL=chassi_reference.d.ts.map

package/build/core/contracts/chassi_reference.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chassi_reference.d.ts","sourceRoot":"","sources":["../../../src/core/contracts/chassi_reference.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,gBAAgB;;;;EAI3B,CAAA;AAEF,MAAM,MAAM,eAAe,GAAG,OAAO,gBAAgB,CAAC,MAAM,OAAO,gBAAgB,CAAC,CAAA"}

package/build/core/contracts/chassi_reference.js

@@ -0,0 +1,5 @@
+export const CHASSI_REFERENCE = Object.freeze({
+    GROUPER_1: 'GROUPER_1',
+    GROUPER_2: 'GROUPER_2',
+    TRACTOR: 'TRACTOR'
+});

package/build/core/contracts/ms_faixas_contract.d.ts

@@ -0,0 +1,13 @@
+import { AllocatedItemManager } from '../physics/items/allocated_item_manager.js';
+/**
+ * Parses ms-faixas `{ envs: [...] }` payloads for axleweight services.
+ */
+export declare 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>);
+}
+//# sourceMappingURL=ms_faixas_contract.d.ts.map

package/build/core/contracts/ms_faixas_contract.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ms_faixas_contract.d.ts","sourceRoot":"","sources":["../../../src/core/contracts/ms_faixas_contract.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,oBAAoB,EAAE,MAAM,4CAA4C,CAAA;AAOjF;;GAEG;AACH,qBAAa,gBAAgB;IAEzB,cAAc,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IACvC,8BAA8B,EAAE,MAAM,CAAC,MAAM,EAAE,oBAAoB,CAAC,CAAA;IAEpE;;OAEG;gBACS,eAAe,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;CAOvD"}

package/build/core/contracts/ms_faixas_contract.js

@@ -0,0 +1,89 @@
+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;
+    allocated_items_by_sequence_id;
+    /**
+     * @param ms_faixas_input - Request with envs array.
+     */
+    constructor(ms_faixas_input) {
+        const envs = ms_faixas_input[TRANSPORT_LIST_FLAG];
+        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) {
+    const templates = build_item_templates(transport_data);
+    const result = {};
+    const containers = transport_data[CONTAINERS_FLAG];
+    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) {
+    const templates = new ItemTemplates();
+    const containers = transport_data[CONTAINERS_FLAG];
+    for (const container of containers) {
+        const items = container[ITEM_LIST_FLAG];
+        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, container) {
+    const manager = new AllocatedItemManager(templates);
+    const items = container[ITEM_LIST_FLAG];
+    if (!items) {
+        return manager;
+    }
+    const allocated = [];
+    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) {
+    const containers = transport_data[CONTAINERS_FLAG];
+    for (const container of containers) {
+        delete container[ITEM_LIST_FLAG];
+    }
+}

package/build/core/contracts/rotation_enum.d.ts

@@ -0,0 +1,11 @@
+/** Cargo rotation positions (carrierinterface RotationEnum). */
+export declare const ROTATION: Readonly<{
+    POS1: 1;
+    POS2: 2;
+    POS3: 3;
+    POS4: 4;
+    POS5: 5;
+    POS6: 6;
+}>;
+export type RotationCode = typeof ROTATION[keyof typeof ROTATION];
+//# sourceMappingURL=rotation_enum.d.ts.map

package/build/core/contracts/rotation_enum.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rotation_enum.d.ts","sourceRoot":"","sources":["../../../src/core/contracts/rotation_enum.ts"],"names":[],"mappings":"AAAA,gEAAgE;AAChE,eAAO,MAAM,QAAQ;;;;;;;EAOnB,CAAA;AAEF,MAAM,MAAM,YAAY,GAAG,OAAO,QAAQ,CAAC,MAAM,OAAO,QAAQ,CAAC,CAAA"}

package/build/core/contracts/rotation_enum.js

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

package/build/core/contracts/suspension_type.d.ts

@@ -0,0 +1,5 @@
+export declare const SUSPENSION_TYPE: Readonly<{
+    PNEUMATICA: "Pneumatica";
+    MECANICA: "Mecanica";
+}>;
+//# sourceMappingURL=suspension_type.d.ts.map

package/build/core/contracts/suspension_type.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"suspension_type.d.ts","sourceRoot":"","sources":["../../../src/core/contracts/suspension_type.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,eAAe;;;EAG1B,CAAA"}

package/build/core/contracts/suspension_type.js

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

package/build/core/contracts/transport_record.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Raw transport dict as received by axle-weight services (jettainterface wire format).
+ */
+export type TransportRecord = Record<string, unknown>;
+//# sourceMappingURL=transport_record.d.ts.map

package/build/core/contracts/transport_record.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transport_record.d.ts","sourceRoot":"","sources":["../../../src/core/contracts/transport_record.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,MAAM,MAAM,eAAe,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA"}

package/build/core/contracts/transport_record.js

@@ -0,0 +1 @@
+export {};

package/build/core/contracts/vehicle_type.d.ts

@@ -0,0 +1,12 @@
+export declare const VEHICLE_TYPE: Readonly<{
+    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];
+//# sourceMappingURL=vehicle_type.d.ts.map

package/build/core/contracts/vehicle_type.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vehicle_type.d.ts","sourceRoot":"","sources":["../../../src/core/contracts/vehicle_type.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,YAAY;;;;;;;;;EASvB,CAAA;AAEF,MAAM,MAAM,eAAe,GAAG,OAAO,YAAY,CAAC,MAAM,OAAO,YAAY,CAAC,CAAA"}

package/build/core/contracts/vehicle_type.js

@@ -0,0 +1,10 @@
+export const VEHICLE_TYPE = Object.freeze({
+    CONTAINER: 0,
+    SEMIREBOQUE: 1,
+    BITREM: 2,
+    RODOTREM: 3,
+    VANDERLEIA: 5,
+    REBAIXADO: 6,
+    CAMINHAO: 7,
+    VUC: 8
+});

package/build/core/contracts/vehicle_version.d.ts

@@ -0,0 +1,8 @@
+export declare const VEHICLE_VERSION: Readonly<{
+    DEFAULT: 0;
+    CAMINHAO_BITRUCK: 4;
+    SEMIREBOQUE_QUAD: 5;
+    SEMIREBOQUE_BITRUCK: 6;
+    SEMIREBOQUE_QUAD_ALT: 7;
+}>;
+//# sourceMappingURL=vehicle_version.d.ts.map

package/build/core/contracts/vehicle_version.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vehicle_version.d.ts","sourceRoot":"","sources":["../../../src/core/contracts/vehicle_version.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,eAAe;;;;;;EAM1B,CAAA"}

package/build/core/contracts/vehicle_version.js

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