@jetta/blocks-allocator 0.0.0-stage → 0.1.0

package/src/input_preparation/block_preparation/Block_Module_Name.js

@@ -0,0 +1,17 @@
+/**
+ * Block module vocabulary — keep in sync with block_modules/module_registry.js.
+ */
+const BLOCK_MODULE_NAME = Object.freeze({
+    MANUAL_BLOCKS: 'manual_blocks',
+    SPIRAL_BLOCKS: 'spiral_blocks',
+    TOWER_BLOCKS: 'tower_blocks',
+    SINGLE_ITEM_BLOCKS: 'single_item_blocks',
+    TIE_RATIO_BLOCKS: 'tie_ratio_blocks',
+})
+
+const VALID_BLOCK_MODULE_NAMES = Object.freeze(Object.values(BLOCK_MODULE_NAME))
+
+module.exports = {
+    BLOCK_MODULE_NAME,
+    VALID_BLOCK_MODULE_NAMES,
+}

package/src/input_preparation/block_preparation/Blocks_Creator.js

@@ -0,0 +1,101 @@
+const { Item, Rotations, Space }        = require('@jetta/empty-spaces-manager')
+const item_json_reader                  = require('../../models/item_json_reader')
+const transform_blocks_data_into_object = require('./Block_Data_To_Object_Transformer')
+const make_blocks                       = require('./Blocksmith')
+const create_input                      = require('./input/Input_Creator')
+const build_initial_blocks_filter_list  = require('../../space_and_block_chooser/blocks_filters/initial_blocks_filter/Initial_Blocks_Filter_List')
+const run_filters                       = require('../../space_and_block_chooser/blocks_filters/Filter_Runner')
+const {Logger} = require('@jetta/logger')
+const logger = new Logger('Blocks Creator')
+const { traced_step } = require('../../tracing/traced_step')
+const { TRACE_CONTEXT } = require('../../tracing/Trace_Context')
+
+async function create_all_blocks(block_path_list, transport, item_list, object_store)
+{
+    const input_data     = create_input(block_path_list, transport, item_list)
+    input_data.item_list = input_data.item_list.filter(item => any_rotation_fit(item, transport))
+    if (input_data.item_list.length === 0)
+    {
+        return []
+    }
+    const block_list = await make_blocks(input_data, object_store)
+    return block_list
+}
+
+function build_container_space_cache(container_list)
+{
+    const space_by_container = new Map()
+    for (const container of container_list)
+    {
+        const cache_key = `${container.largura}|${container.altura}|${container.comprimento}`
+        if (!space_by_container.has(cache_key))
+        {
+            space_by_container.set(cache_key, new Space({
+                x: 0,
+                y: 0,
+                z: 0,
+                width: container.largura,
+                height: container.altura,
+                length: container.comprimento
+            }))
+        }
+    }
+    return space_by_container
+}
+
+function any_rotation_fit(item, transport)
+{
+    const item_object = new Item(item_json_reader(item, Rotations.POS1))
+    const rotation_list = item_object.get_rotations()
+    const space_cache = build_container_space_cache(transport.containers)
+    return rotation_list.some(
+        rotation => does_any_rotation_fit_any_of_the_containers(
+            item_object,
+            rotation,
+            transport.containers,
+            space_cache
+        )
+    )
+}
+
+function does_any_rotation_fit_any_of_the_containers(item, rotation, container_list, space_cache)
+{
+    return container_list.some(container =>
+    {
+        const cache_key = `${container.largura}|${container.altura}|${container.comprimento}`
+        const container_as_es = space_cache.get(cache_key)
+        return container_as_es.fit_item(item, rotation)
+    })
+}
+
+module.exports = async function create_blocks(block_path_list, transport, item_list, object_store)
+{
+    return traced_step(TRACE_CONTEXT.BLOCKS_GENERATION, async () =>
+    {
+        logger.debug('creating blocks possibilities')
+        const block_data_list = await create_all_blocks(
+            block_path_list,
+            transport,
+            item_list,
+            object_store
+        )
+        if (block_data_list.length === 0)
+        {
+            return []
+        }
+
+        const available_blocks = await filter_transformed_blocks(block_data_list, item_list)
+        logger.debug('blocks created successfully')
+        return available_blocks
+    })
+}
+
+async function filter_transformed_blocks(block_data_list, item_list)
+{
+    const block_list = transform_blocks_data_into_object(block_data_list)
+    const filter_data = {
+        block_list,
+        item_list
+    }
+    return run_filters(build_initial_blocks_filter_list(), filter_data)
+}

package/src/input_preparation/block_preparation/Blocksmith.js

@@ -0,0 +1,19 @@
+const create_block_candidates = require('./block_modules/create_block_candidates')
+const create_manual_blocks = require('./manual_blocks/Manual_Blocks')
+
+/**
+ * Builds generated candidates and manual blocks for one preparation input.
+ * @param {object} input_data
+ * @param {{ get_object: Function }} [object_store]
+ * @returns {Promise<object[]>}
+ */
+async function build_block_list(input_data, object_store)
+{
+    const manual_block_promise = create_manual_blocks(input_data.block_path_list, object_store)
+    const block_list = create_block_candidates(input_data)
+    const manual_block_list = await manual_block_promise
+    block_list.push(...manual_block_list)
+    return block_list
+}
+
+module.exports = build_block_list

package/src/input_preparation/block_preparation/block_modules/create_block_candidates.js

@@ -0,0 +1,41 @@
+const { MODULE_REGISTRY, MODULE_NAME_LIST } = require('./module_registry')
+const Invalid_Block_Module_Config_Exception = require(
+    '../../../validation/exceptions/Invalid_Block_Module_Config_Exception'
+)
+const { Logger } = require('@jetta/logger')
+
+const logger = new Logger('create_block_candidates')
+
+/**
+ * Dispatches each name in config.block_module_list to a creator and concatenates results.
+ * @param {object} input_data blocksmith-shaped input (container, config, item_list)
+ * @param {{ registry?: Record<string, Function> }} [options]
+ * @returns {object[]}
+ */
+function create_block_candidates(input_data, options = {})
+{
+    const registry = options.registry || MODULE_REGISTRY
+    const module_name_list = input_data?.config?.block_module_list || []
+    const block_list = []
+
+    for (const module_name of module_name_list)
+    {
+        const create_module_blocks = registry[module_name]
+        if (!create_module_blocks)
+        {
+            logger.error(
+                `Unknown module: "${module_name}". Valid modules: ${MODULE_NAME_LIST.join(', ')}`
+            )
+            throw new Invalid_Block_Module_Config_Exception()
+        }
+        const created_blocks = create_module_blocks(input_data)
+        if (Array.isArray(created_blocks) && created_blocks.length > 0)
+        {
+            block_list.push(...created_blocks)
+        }
+    }
+
+    return block_list
+}
+
+module.exports = create_block_candidates

package/src/input_preparation/block_preparation/block_modules/manual_blocks.js

@@ -0,0 +1,10 @@
+/**
+ * Manual geometry is produced by BW Manual_Blocks.js, not this dispatcher.
+ * @returns {object[]}
+ */
+function create_manual_blocks()
+{
+    return []
+}
+
+module.exports = create_manual_blocks

package/src/input_preparation/block_preparation/block_modules/module_registry.js

@@ -0,0 +1,20 @@
+const create_tower_blocks = require('./tower_blocks')
+const create_spiral_blocks = require('./spiral_blocks')
+const create_single_item_blocks = require('./single_item_blocks')
+const create_tie_ratio_blocks = require('./tie_ratio_blocks')
+const create_manual_blocks = require('./manual_blocks')
+
+const MODULE_REGISTRY = Object.freeze({
+    manual_blocks: create_manual_blocks,
+    spiral_blocks: create_spiral_blocks,
+    tower_blocks: create_tower_blocks,
+    single_item_blocks: create_single_item_blocks,
+    tie_ratio_blocks: create_tie_ratio_blocks,
+})
+
+const MODULE_NAME_LIST = Object.freeze(Object.keys(MODULE_REGISTRY))
+
+module.exports = {
+    MODULE_REGISTRY,
+    MODULE_NAME_LIST,
+}

package/src/input_preparation/block_preparation/block_modules/run_creator.js

@@ -0,0 +1,34 @@
+/**
+ * Resolves CJS/ESM default export and invokes a block creator with input data.
+ * @param {unknown} imported_module
+ * @param {object} input_data
+ * @returns {object[]}
+ */
+function run_creator(imported_module, input_data)
+{
+    const create_blocks = resolve_create_blocks(imported_module)
+    const block_list = create_blocks(input_data)
+    return Array.isArray(block_list) ? block_list : []
+}
+
+/**
+ * @param {unknown} imported_module
+ * @returns {(input_data: object) => object[]}
+ */
+function resolve_create_blocks(imported_module)
+{
+    if (typeof imported_module === 'function')
+    {
+        return imported_module
+    }
+    if (imported_module && typeof imported_module.default === 'function')
+    {
+        return imported_module.default
+    }
+    throw new Error('Block creator module does not export a callable default')
+}
+
+module.exports = {
+    run_creator,
+    resolve_create_blocks,
+}

package/src/input_preparation/block_preparation/block_modules/single_item_blocks.js

@@ -0,0 +1,12 @@
+const { run_creator } = require('./run_creator')
+
+/**
+ * @param {object} input_data
+ * @returns {object[]}
+ */
+function create_single_item_blocks(input_data)
+{
+    return run_creator(require('@jettacargo/single-item-block-creator-core'), input_data)
+}
+
+module.exports = create_single_item_blocks

package/src/input_preparation/block_preparation/block_modules/spiral_blocks.js

@@ -0,0 +1,12 @@
+const { run_creator } = require('./run_creator')
+
+/**
+ * @param {object} input_data
+ * @returns {object[]}
+ */
+function create_spiral_blocks(input_data)
+{
+    return run_creator(require('@jettacargo/spiral-block-creator-core'), input_data)
+}
+
+module.exports = create_spiral_blocks

package/src/input_preparation/block_preparation/block_modules/tie_ratio_blocks.js

@@ -0,0 +1,12 @@
+const { run_creator } = require('./run_creator')
+
+/**
+ * @param {object} input_data
+ * @returns {object[]}
+ */
+function create_tie_ratio_blocks(input_data)
+{
+    return run_creator(require('@jetta/tie-ratio-block-creator-core'), input_data)
+}
+
+module.exports = create_tie_ratio_blocks

package/src/input_preparation/block_preparation/block_modules/tower_blocks.js

@@ -0,0 +1,12 @@
+const { run_creator } = require('./run_creator')
+
+/**
+ * @param {object} input_data
+ * @returns {object[]}
+ */
+function create_tower_blocks(input_data)
+{
+    return run_creator(require('@jettacargo/tower-block-creator-core'), input_data)
+}
+
+module.exports = create_tower_blocks

package/src/input_preparation/block_preparation/exceptions/Failed_To_Create_Block_Exception.js

@@ -0,0 +1,14 @@
+const { build_message_entry } = require('../../../messages/resolve_error_message_entry')
+const { ALLOCATOR_MESSAGE } = require('../../../messages/Allocator_Message')
+
+class Failed_To_Create_Block_Exception extends Error
+{
+    constructor()
+    {
+        const message_key = ALLOCATOR_MESSAGE.FAILED_TO_CREATE_BLOCKS
+        super(message_key)
+        this.message_entry = build_message_entry(message_key)
+    }
+}
+
+module.exports = Failed_To_Create_Block_Exception

package/src/input_preparation/block_preparation/exceptions/Failed_To_Retrieve_Block_Exception.js

@@ -0,0 +1,17 @@
+const { build_message_entry } = require('../../../messages/resolve_error_message_entry')
+const { ALLOCATOR_MESSAGE } = require('../../../messages/Allocator_Message')
+
+class Failed_To_Retrieve_Block_Exception extends Error
+{
+    /**
+     * @param {string} path
+     */
+    constructor(path)
+    {
+        const message_key = ALLOCATOR_MESSAGE.FAILED_TO_RETRIEVE_BLOCK
+        super(message_key)
+        this.message_entry = build_message_entry(message_key, [String(path)])
+    }
+}
+
+module.exports = Failed_To_Retrieve_Block_Exception

package/src/input_preparation/block_preparation/exceptions/Missing_Object_Store_Exception.js

@@ -0,0 +1,10 @@
+class Missing_Object_Store_Exception extends Error
+{
+    constructor()
+    {
+        super('Missing_Object_Store_Exception')
+        this.name = 'Missing_Object_Store_Exception'
+    }
+}
+
+module.exports = Missing_Object_Store_Exception

package/src/input_preparation/block_preparation/exceptions/No_Blocks_Were_Created_Exception.js

@@ -0,0 +1,14 @@
+const { build_message_entry } = require('../../../messages/resolve_error_message_entry')
+const { ALLOCATOR_MESSAGE } = require('../../../messages/Allocator_Message')
+
+class No_Blocks_Were_Created_Exception extends Error
+{
+    constructor()
+    {
+        const message_key = ALLOCATOR_MESSAGE.NO_BLOCKS_WERE_CREATED
+        super(message_key)
+        this.message_entry = build_message_entry(message_key)
+    }
+}
+
+module.exports = No_Blocks_Were_Created_Exception

package/src/input_preparation/block_preparation/input/Input_Creator.js

@@ -0,0 +1,96 @@
+const Config = require('../../../models/Cargo_Profile')
+
+module.exports = function create_blocksmith_input(block_path_list, transport, item_list)
+{
+    const item_data_list = create_input_item_list(item_list)
+
+    return {
+        container: create_container_data(transport),
+        config: create_config(),
+        item_list: item_data_list,
+        block_path_list: block_path_list
+    }
+}
+
+function create_config()
+{
+    const config = {
+        block_module_list: Config.block_module_list(),
+        max_tower_height_superior_gap: Config.max_tower_height_superior_gap(),
+        max_tower_height_inferior_gap: Config.max_tower_height_inferior_gap(),
+    }
+
+    if (Config.tie_ratio_allocate_remainder_as_partial_blocks())
+    {
+        config.allocate_remainder_as_partial_blocks = true
+    }
+
+    return config
+}
+
+function create_container_data(transport)
+{
+    const tallest_container = transport.containers.reduce((acc, cur) => cur.altura > acc.altura ? acc = cur : cur = cur, '')
+    return {
+        width: tallest_container.largura,
+        height: tallest_container.altura,
+        length: tallest_container.comprimento,
+    }
+}
+
+function create_input_item_list(item_list)
+{
+    return item_list.map(item => create_input_item_data(item))
+}
+
+function create_input_item_data(item)
+{
+    const item_json = item.get_json()
+    return {
+        'id': item_json._id,
+        'length': item_json.length || item_json.comprimento,
+        'width': item_json.width || item_json.largura,
+        'height': item_json.height || item_json.altura,
+        'weight': item_json.weight || item_json.peso,
+        'supported_weight': item_json.supported_weight || item_json.pesoMaxSuportado,
+        'maximum_stacking': item_json.maximum_stacking || item_json.empilhamentoMaximo,
+        'stacking_rule': get_stacking_unit(item_json.stackingUnit),
+        'amount': item_json.amount || item_json.qtd,
+        'type': item_json.type || item_json.tipo,
+        'priority': item_json.priority || item_json.prioridade,
+        'rotation_list': rotation_list(
+            item_json.rotacao !== undefined ? item_json.rotacao : item_json.rotation_list
+        )
+    }
+}
+
+function get_stacking_unit(value)
+{
+    if (value.toLowerCase() === 'supportedweight')
+    {
+        return 'SUPPORTED_WEIGHT'
+    }
+
+    if (value.toLowerCase() === 'maximumStacking')
+    {
+        return 'MAXIMUM_STACKING'
+    }
+
+    return 'BOTH'
+}
+
+function rotation_list(rotation_map)
+{
+    const rotation_list = []
+
+    for (const key in rotation_map)
+    {
+        if (rotation_map[key])
+        {
+            const rotation = key.replace('pos', 'position')
+            rotation_list.push(rotation)
+        }
+    }
+
+    return rotation_list
+}

package/src/input_preparation/block_preparation/manual_blocks/Manual_Blocks.js

@@ -0,0 +1,95 @@
+const Failed_To_Retrieve_Block_Exception = require('../exceptions/Failed_To_Retrieve_Block_Exception')
+const Missing_Object_Store_Exception = require('../exceptions/Missing_Object_Store_Exception')
+const is_valid_array = require('../../../tools/Array_Validator')
+const Config = require('../../../models/Cargo_Profile')
+const { Logger } = require('@jetta/logger')
+const logger = new Logger('Manual Blocks')
+
+/**
+ * Loads manually created blocks through the injected object store.
+ * @param {string[]} block_path_list
+ * @param {{ get_object: (bucket_name: string, object_key: string) => Promise<string>|string }} [object_store]
+ * @returns {Promise<object[]>}
+ */
+async function create_manual_blocks(block_path_list, object_store)
+{
+    if (!manual_blocks_requested(block_path_list))
+    {
+        logger.warn('it was not informed any path of the manually created blocks.')
+        return []
+    }
+
+    assert_object_store(object_store)
+    return read_manual_blocks(block_path_list, object_store)
+}
+
+/**
+ * @param {string[]} block_path_list
+ * @returns {boolean}
+ */
+function manual_blocks_requested(block_path_list)
+{
+    return is_valid_array(block_path_list) && Config.block_module_list().includes('manual_blocks')
+}
+
+/**
+ * @param {{ get_object?: Function }} object_store
+ * @returns {void}
+ */
+function assert_object_store(object_store)
+{
+    if (object_store == null || typeof object_store.get_object !== 'function')
+    {
+        throw new Missing_Object_Store_Exception()
+    }
+}
+
+/**
+ * @param {string[]} block_path_list
+ * @param {{ get_object: Function }} object_store
+ * @returns {Promise<object[]>}
+ */
+async function read_manual_blocks(block_path_list, object_store)
+{
+    for (const path of block_path_list)
+    {
+        try
+        {
+            const bucket_name = process.env.MANUAL_BLOCKS_BUCKET_NAME
+            const block_str_list = await object_store.get_object(bucket_name, path)
+            return read_output(block_str_list)
+        }
+        catch (error)
+        {
+            logger.error(error.message)
+            logger.error(error.stack)
+            throw new Failed_To_Retrieve_Block_Exception(path)
+        }
+    }
+
+    return []
+}
+
+/**
+ * @param {string} block_str_list
+ * @returns {object[]}
+ */
+function read_output(block_str_list)
+{
+    const block_data_list = JSON.parse(block_str_list)
+    return block_data_list.map(normalize_manual_block)
+}
+
+/**
+ * @param {object} block_data
+ * @returns {object}
+ */
+function normalize_manual_block(block_data)
+{
+    return {
+        ...block_data,
+        slot_list: block_data.positioned_items
+    }
+}
+
+module.exports = create_manual_blocks

package/src/input_preparation/build_empty_space_finder_options.js

@@ -0,0 +1,43 @@
+const mm_to_allocation_domain = require('../tools/mm_to_allocation_domain')
+const min_extents_from_items = require('./min_extents_from_items')
+const { merge_tolerance_from_operational_gaps } = require('@jetta/empty-spaces-manager')
+
+/**
+ * Optional third-argument shape for {@link EmptySpaceFinder} from request `config` and item rotation minima.
+ * Tolerance math lives in `@jetta/empty-spaces-manager` (`merge_tolerance_from_operational_gaps`).
+ * @param {object} config - Parsed `config` with `algoritmo` (may include `empty_space_merge_*` there).
+ * @param {Array} items_to_allocate - Items with `get_all_rotated_options`.
+ * @returns {{ merge_tolerance: { epsilon_x: number, epsilon_z: number, max_vertical_offset: number } }|undefined}
+ */
+function build_empty_space_finder_options(config, items_to_allocate)
+{
+    const algo = config.algoritmo ?? {}
+    const pct_w = algo.empty_space_merge_gap_percent_width ?? 0
+    const pct_l = algo.empty_space_merge_gap_percent_length ?? 0
+    const mm_gap = algo.empty_space_merge_max_vertical_offset_mm ?? 0
+    if (pct_w <= 0 && pct_l <= 0 && mm_gap <= 0)
+    {
+        return undefined
+    }
+    const mins = min_extents_from_items(items_to_allocate)
+    let max_vertical_offset = 0
+    if (mm_gap > 0)
+    {
+        max_vertical_offset = mm_to_allocation_domain(mm_gap)
+    }
+    const merge_tolerance = merge_tolerance_from_operational_gaps(
+        {
+            gap_percent_width: pct_w,
+            gap_percent_length: pct_l,
+            max_vertical_offset: max_vertical_offset
+        },
+        {min_width: mins.min_width, min_length: mins.min_length}
+    )
+    if (merge_tolerance === null)
+    {
+        return undefined
+    }
+    return { merge_tolerance }
+}
+
+module.exports = build_empty_space_finder_options

package/src/input_preparation/item_preparation/Items_Reader.js

@@ -0,0 +1,27 @@
+const Allocation_Item              = require('../../models/Allocation_Item')
+const create_input                 = require('../stackability_index/Stackability_Input_Creator')
+const calculate_stackability_index = require('@jettacargo/stackability-index-calculator-core').default
+
+module.exports = function(item_data_list)
+{
+    const item_input_list         = create_input(item_data_list)
+    const stackability_index_list = calculate_stackability_index(item_input_list)
+    set_stackability_index_to_items(item_data_list, stackability_index_list)
+    const item_object_list = create_item_object_list(item_data_list)
+    return item_object_list
+}
+
+function set_stackability_index_to_items(item_data_list, stackability_index_list)
+{
+    for (let index = 0; index < item_data_list.length; index++)
+    {
+        const stackability_index = stackability_index_list[index]
+        const item               = item_data_list[index]
+        item.stackability_index  = stackability_index
+    }
+}
+
+function create_item_object_list(item_data_list)
+{
+    return item_data_list.map(item_data => new Allocation_Item(item_data))
+}

package/src/input_preparation/min_extents_from_items.js

@@ -0,0 +1,29 @@
+/**
+ * Global minima of width (X), length (Z), and height (Y) over every allowed rotation of each item.
+ * @param {Array<{ get_all_rotated_options: () => Array<{ get_width: () => number, get_length: () => number, get_height: () => number }> }>} items_to_allocate - Prepared allocation items.
+ * @returns {{ min_width: number, min_length: number, min_height: number }}
+ */
+function min_extents_from_items(items_to_allocate)
+{
+    let min_width = Infinity
+    let min_length = Infinity
+    let min_height = Infinity
+    for (let i = 0; i < items_to_allocate.length; i++)
+    {
+        const rotations = items_to_allocate[i].get_all_rotated_options()
+        for (let r = 0; r < rotations.length; r++)
+        {
+            const ri = rotations[r]
+            min_width = Math.min(min_width, ri.get_width())
+            min_length = Math.min(min_length, ri.get_length())
+            min_height = Math.min(min_height, ri.get_height())
+        }
+    }
+    if (!Number.isFinite(min_width))
+    {
+        return {min_width: 0, min_length: 0, min_height: 0}
+    }
+    return {min_width, min_length, min_height}
+}
+
+module.exports = min_extents_from_items