@jetta/blocks-allocator 0.0.0-stage → 0.1.0

package/src/space_and_block_chooser/blocks_filters/pre_selection_filter/max_tower_height/Max_Tower_Height.js

@@ -0,0 +1,82 @@
+
+const Config                       = require('../../../../models/Cargo_Profile')
+const calculate_stackability_index = require('@jettacargo/stackability-index-calculator-core').default
+const round                        = require('../../../../tools/Rounder')
+
+module.exports = function calculate_max_tower_height(container, item_list)
+{
+    // variable names were kept the same as the document
+    // which can be accessed here: https://docs.google.com/document/d/1-frn1tHfbjpTfN85Uc5laP50qBsazPyT2bZqzL0P7U4/edit?pli=1&tab=t.0
+    const A  = get_container_height(container, item_list)
+    const L  = get_measure_factor(container.get_width(), item_list)
+    const C  = get_measure_factor(container.get_length(), item_list)
+    const Af = (L * C * A) / (container.get_width() * container.get_length())
+    return round(Af)
+}
+
+function get_measure_factor(factor, item_data_list)
+{
+    const l  = get_item_width_mean(item_data_list)
+    const Xa = factor / (Config.max_tower_height_superior_gap() * l)
+    const Xb = factor / (Config.max_tower_height_inferior_gap() * l)
+
+    const Ka = Xa - Math.trunc(Xa)
+    const Kb = Xb - Math.trunc(Xb)
+    const ql = Ka < Kb ? Math.trunc(Xa) : Math.trunc(Xb)
+
+    return l * ql
+}
+
+function get_container_height(container, item_data_list)
+{
+    const Si = get_normalized_si(item_data_list)
+    const A  = container.get_height() * Si
+    return A
+}
+
+function get_item_width_mean(item_list)
+{
+    const item_qty = item_list.reduce((acc, cur) => acc + cur.get_amount(), 0)
+    return item_list.reduce((acc, cur) => acc + (cur.get_width() * cur.get_amount()), 0) / item_qty
+}
+
+function get_normalized_si(item_list)
+{
+    const item_data_list  = item_list.map(item => create_item_data(item.get_json()))
+    const Si      = calculate_stackability_index(item_data_list)
+    const Si_mean = Si.reduce((acc, cur) => acc + cur, 0) / Si.length
+
+    if (Si_mean <= 5)
+    {
+        return 0.8
+    }
+    if (Si_mean >= 20)
+    {
+        return 1
+    }
+
+    return 0.9
+}
+
+function create_item_data(item)
+{
+    return {
+        id: item._id,
+        amount: item.qtd,
+        width: item.largura,
+        height: item.altura,
+        length: item.comprimento,
+        weight: item.peso,
+        supported_weight: item.pesoMaxSuportado,
+        maximum_stacking: item.empilhamentoMaximo,
+        rotation_list: Object.keys(item.rotacao).filter(rotation => item.rotacao[rotation]),
+        stacking_unit: item.stackingUnit.toLowerCase(),
+        stacking_rules: {
+            family: item.stacking.family,
+            supported_families: item.stacking.supported_families,
+            only_stack_same_family: item.restricoes.empilharFamilias,
+            only_stack_same_area: item.restricoes.empilharAreaIgual,
+            only_stack_same_item: item.restricoes.empilharItemIgual
+        }
+    }
+}

package/src/space_and_block_chooser/build_allocated_item_snapshots.js

@@ -0,0 +1,19 @@
+/**
+ * Maps allocated container items to empty-space chooser snapshots.
+ * @param {object} container - Container with get_allocated_items().
+ * @returns {Array<{ x: number, y: number, z: number, width: number, height: number, length: number }>}
+ */
+function build_allocated_item_snapshots(container)
+{
+    const allocated_items = container.get_allocated_items?.() ?? []
+    return allocated_items.map(item => ({
+        x: item.get_x(),
+        y: item.get_y(),
+        z: item.get_z(),
+        width: item.get_width(),
+        height: item.get_height(),
+        length: item.get_length()
+    }))
+}
+
+module.exports = build_allocated_item_snapshots

package/src/space_and_block_chooser/compound_first_empty_space_branch.js

@@ -0,0 +1,61 @@
+const Cargo_Profile = require('../models/Cargo_Profile')
+const leftover_space_memory = require('./leftover_space_memory')
+const {
+    leftover_or_legacy_resolution,
+    skip_probe_resolution
+} = require('./leftover_unitary_empty_spaces')
+const { resolve_after_compound_probe_without_leftover_fill } = require(
+    './compound_first_without_leftover_fill'
+)
+const resolve_after_compound_probe = require('./compound_first_with_leftover_fill')
+
+/**
+ * Resolves chooser spaces and blocks when obligate-compound-first applies.
+ * @param {Function} run_filters
+ * @param {Object} filter_data
+ * @param {Array<Object>} empty_space_list
+ * @param {Array<Object>} pre_selected_block_list
+ * @returns {Promise<object>}
+ */
+async function resolve_empty_spaces_and_blocks_for_obligate_compound_first(
+    run_filters,
+    filter_data,
+    empty_space_list,
+    pre_selected_block_list
+)
+{
+    if (!Cargo_Profile.obligate_block_allocation_first())
+    {
+        return leftover_or_legacy_resolution(empty_space_list, pre_selected_block_list, [])
+    }
+    const use_leftover_fill = Cargo_Profile.leftover_sku_unitary_fill()
+    if (filter_data.obligate_compound_session?.skip_compound_probe === true)
+    {
+        if (use_leftover_fill)
+        {
+            return leftover_space_memory.skip_probe_or_leftover_resolution(
+                filter_data,
+                empty_space_list,
+                pre_selected_block_list
+            )
+        }
+        return skip_probe_resolution(empty_space_list, pre_selected_block_list)
+    }
+    if (use_leftover_fill)
+    {
+        return resolve_after_compound_probe(
+            run_filters,
+            filter_data,
+            empty_space_list,
+            pre_selected_block_list
+        )
+    }
+    return resolve_after_compound_probe_without_leftover_fill(
+        run_filters,
+        filter_data,
+        empty_space_list,
+        pre_selected_block_list
+    )
+}
+
+module.exports = resolve_empty_spaces_and_blocks_for_obligate_compound_first

package/src/space_and_block_chooser/compound_first_with_leftover_fill.js

@@ -0,0 +1,142 @@
+const leftover_unitary_blocks = require('./leftover_unitary_blocks')
+const empty_spaces_where_post_selection_keeps_blocks = require('./empty_spaces_where_post_selection_keeps_blocks')
+const leftover_space_memory = require('./leftover_space_memory')
+const {
+    leftover_unitary_empty_spaces,
+    leftover_or_legacy_resolution,
+    resolve_compound_first_or_leftover
+} = require('./leftover_unitary_empty_spaces')
+const { compound_blocks_from_list } = require('./compound_first_without_leftover_fill')
+
+/**
+ * Resolves chooser spaces after probing compounds and leftover unitaries.
+ * @param {Function} run_filters
+ * @param {object} filter_data
+ * @param {object[]} empty_space_list
+ * @param {object[]} pre_selected_block_list
+ * @returns {Promise<object>}
+ */
+async function resolve_after_compound_probe(
+    run_filters,
+    filter_data,
+    empty_space_list,
+    pre_selected_block_list
+)
+{
+    const compound_block_list = compound_blocks_from_list(pre_selected_block_list)
+    const leftover_block_list = leftover_unitary_blocks(
+        pre_selected_block_list,
+        compound_block_list,
+        filter_data.obligate_compound_session?.leftover_sku_shape_hashes
+    )
+    leftover_unitary_blocks.remember_leftover_sku_hashes(
+        filter_data.obligate_compound_session,
+        leftover_block_list,
+        compound_block_list
+    )
+    if (compound_block_list.length === 0)
+    {
+        return resolve_leftover_when_no_compounds(
+            run_filters,
+            filter_data,
+            empty_space_list,
+            pre_selected_block_list,
+            leftover_block_list
+        )
+    }
+    return resolve_leftover_after_compound_viable(
+        run_filters,
+        filter_data,
+        empty_space_list,
+        pre_selected_block_list,
+        compound_block_list
+    )
+}
+
+/**
+ * @param {Function} run_filters
+ * @param {object} filter_data
+ * @param {object[]} empty_space_list
+ * @param {object[]} pre_selected_block_list
+ * @param {object[]} leftover_block_list
+ * @returns {Promise<object>}
+ */
+async function resolve_leftover_when_no_compounds(
+    run_filters,
+    filter_data,
+    empty_space_list,
+    pre_selected_block_list,
+    leftover_block_list
+)
+{
+    const leftover_candidates = leftover_space_memory.spaces_matching_remembered_leftover(
+        empty_space_list,
+        filter_data.obligate_compound_session
+    )
+    const leftover_empty_spaces = await leftover_unitary_empty_spaces(
+        run_filters,
+        filter_data,
+        leftover_candidates.length > 0 ? leftover_candidates : empty_space_list,
+        leftover_block_list.length > 0 ? leftover_block_list : pre_selected_block_list,
+        []
+    )
+    leftover_space_memory.remember_leftover_empty_spaces(
+        filter_data.obligate_compound_session,
+        leftover_empty_spaces
+    )
+    return leftover_or_legacy_resolution(
+        empty_space_list,
+        pre_selected_block_list,
+        leftover_empty_spaces,
+        leftover_block_list
+    )
+}
+
+/**
+ * @param {Function} run_filters
+ * @param {object} filter_data
+ * @param {object[]} empty_space_list
+ * @param {object[]} pre_selected_block_list
+ * @param {object[]} compound_block_list
+ * @returns {Promise<object>}
+ */
+async function resolve_leftover_after_compound_viable(
+    run_filters,
+    filter_data,
+    empty_space_list,
+    pre_selected_block_list,
+    compound_block_list
+)
+{
+    const viable_spaces = await empty_spaces_where_post_selection_keeps_blocks(
+        run_filters,
+        filter_data,
+        empty_space_list,
+        compound_block_list
+    )
+    const leftover_empty_spaces = await leftover_unitary_empty_spaces(
+        run_filters,
+        filter_data,
+        empty_space_list,
+        pre_selected_block_list,
+        viable_spaces
+    )
+    leftover_space_memory.remember_leftover_empty_spaces(
+        filter_data.obligate_compound_session,
+        leftover_empty_spaces
+    )
+    const leftover_in_region = leftover_space_memory.spaces_matching_remembered_leftover(
+        leftover_empty_spaces,
+        filter_data.obligate_compound_session
+    )
+    return resolve_compound_first_or_leftover(
+        filter_data,
+        empty_space_list,
+        pre_selected_block_list,
+        compound_block_list,
+        viable_spaces,
+        leftover_in_region.length > 0 ? leftover_in_region : leftover_empty_spaces
+    )
+}
+
+module.exports = resolve_after_compound_probe

package/src/space_and_block_chooser/compound_first_without_leftover_fill.js

@@ -0,0 +1,56 @@
+const empty_spaces_where_post_selection_keeps_blocks = require('./empty_spaces_where_post_selection_keeps_blocks')
+const { leftover_or_legacy_resolution } = require('./leftover_unitary_empty_spaces')
+
+function compound_blocks_from_list(block_list)
+{
+    return block_list.filter(
+        block => typeof block.get_slot_list === 'function' && block.get_slot_list().length > 1
+    )
+}
+
+/**
+ * Prod compound-first: compounds when viable, else full lists (no leftover-SKU lock).
+ * @param {Function} run_filters
+ * @param {object} filter_data
+ * @param {object[]} empty_space_list
+ * @param {object[]} pre_selected_block_list
+ * @returns {Promise<object>}
+ */
+async function resolve_after_compound_probe_without_leftover_fill(
+    run_filters,
+    filter_data,
+    empty_space_list,
+    pre_selected_block_list
+)
+{
+    const compound_block_list = compound_blocks_from_list(pre_selected_block_list)
+    if (compound_block_list.length === 0)
+    {
+        return leftover_or_legacy_resolution(empty_space_list, pre_selected_block_list, [])
+    }
+    const viable_spaces = await empty_spaces_where_post_selection_keeps_blocks(
+        run_filters,
+        filter_data,
+        empty_space_list,
+        compound_block_list
+    )
+    if (viable_spaces.length > 0)
+    {
+        return {
+            empty_spaces_for_chooser: viable_spaces,
+            blocks_for_post_selection: compound_block_list,
+            leftover_empty_spaces: [],
+            skip_cluster_rank: false
+        }
+    }
+    if (filter_data.obligate_compound_session)
+    {
+        filter_data.obligate_compound_session.skip_compound_probe = true
+    }
+    return leftover_or_legacy_resolution(empty_space_list, pre_selected_block_list, [])
+}
+
+module.exports = {
+    compound_blocks_from_list,
+    resolve_after_compound_probe_without_leftover_fill
+}

package/src/space_and_block_chooser/empty_spaces_where_post_selection_keeps_blocks.js

@@ -0,0 +1,83 @@
+const pos_selection_filters = require('./blocks_filters/pos_selection_filters/Post_Selection_Filter_List')
+const Invalid_Space_To_Allocate_Exception = require('./exceptions/Invalid_Space_To_Allocate_Exception')
+const { borrow_empty_set, release_probe_set } = require('./probe_set_pool')
+const Cargo_Profile = require('../models/Cargo_Profile')
+const { build_supporters_by_top_y_index } = require('../Allocation_Optimization/tie_ratio/supporters_by_top_y_index')
+
+/**
+ * Returns empty spaces where at least one block from `block_list_for_probe` survives post-selection filters.
+ * Each probe uses fresh invalid and no_fillable sets so the caller's `filter_data` is not mutated.
+ *
+ * @param {Function} run_filters Same contract as `Filter_Runner`.
+ * @param {Object} filter_data Shared filter payload (container, item_list, spaces_to_avoid, etc.).
+ * @param {Array<Object>} empty_space_list Candidate empty spaces in iteration order.
+ * @param {Array<Object>} block_list_for_probe Blocks to test against each candidate space.
+ * @returns {Promise<Array<Object>>} Ordered subset of spaces that keep at least one block.
+ */
+async function empty_spaces_where_post_selection_keeps_blocks(
+    run_filters,
+    filter_data,
+    empty_space_list,
+    block_list_for_probe
+)
+{
+    const supporters_by_top_y_index = Cargo_Profile.allocate_intercalated()
+        ? build_supporters_by_top_y_index(filter_data.container.get_allocated_items())
+        : undefined
+    const viable_spaces = []
+    for (const candidate_space of empty_space_list)
+    {
+        const keeps_blocks = await probe_space_keeps_blocks_after_post_selection(
+            run_filters,
+            filter_data,
+            candidate_space,
+            block_list_for_probe,
+            supporters_by_top_y_index
+        )
+        if (keeps_blocks)
+        {
+            viable_spaces.push(candidate_space)
+        }
+    }
+    return viable_spaces
+}
+
+async function probe_space_keeps_blocks_after_post_selection(
+    run_filters,
+    filter_data,
+    candidate_space,
+    block_list_for_probe,
+    supporters_by_top_y_index
+)
+{
+    const spaces_to_avoid = borrow_empty_set()
+    const no_fillable_space_set = borrow_empty_set()
+    const probe_filter_data = {
+        ...filter_data,
+        block_list: block_list_for_probe,
+        empty_space: candidate_space,
+        spaces_to_avoid,
+        no_fillable_space_set,
+        supporters_by_top_y_index
+    }
+    try
+    {
+        await run_filters(pos_selection_filters, probe_filter_data)
+        return true
+    }
+    catch (error)
+    {
+        if (error instanceof Invalid_Space_To_Allocate_Exception)
+        {
+            return false
+        }
+        throw error
+    }
+    finally
+    {
+        release_probe_set(spaces_to_avoid)
+        release_probe_set(no_fillable_space_set)
+    }
+}
+
+module.exports = empty_spaces_where_post_selection_keeps_blocks

package/src/space_and_block_chooser/exceptions/Invalid_Space_To_Allocate_Exception.js

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

package/src/space_and_block_chooser/leftover_space_memory.js

@@ -0,0 +1,113 @@
+const leftover_unitary_blocks = require('./leftover_unitary_blocks')
+const {
+    leftover_or_legacy_resolution,
+    skip_probe_resolution
+} = require('./leftover_unitary_empty_spaces')
+
+const BBOX_TOLERANCE = 0.001
+
+/**
+ * Stores leftover-space bboxes on first leftover classification.
+ * @param {{ leftover_space_bboxes?: object[] }|undefined} session
+ * @param {object[]} leftover_empty_spaces
+ */
+function remember_leftover_empty_spaces(session, leftover_empty_spaces)
+{
+    if (!session || leftover_empty_spaces.length === 0)
+    {
+        return
+    }
+    if (session.leftover_space_bboxes?.length > 0)
+    {
+        return
+    }
+    const bboxes = leftover_empty_spaces.map(space_bbox).filter(Boolean)
+    if (bboxes.length === 0)
+    {
+        return
+    }
+    session.leftover_space_bboxes = bboxes
+}
+
+/**
+ * Pending spaces that match leftover pockets remembered during compound-first.
+ * @param {object[]} empty_space_list
+ * @param {{ leftover_space_bboxes?: object[] }|undefined} session
+ * @returns {object[]}
+ */
+function spaces_matching_remembered_leftover(empty_space_list, session)
+{
+    const bboxes = session?.leftover_space_bboxes
+    if (!bboxes?.length)
+    {
+        return []
+    }
+    return empty_space_list.filter(space => bboxes.some(bbox => space_contained_in_region(space, bbox)))
+}
+
+/**
+ * Skip-probe: leftover pocket + leftover SKUs when remembered; else all spaces and blocks.
+ * @param {object} filter_data
+ * @param {object[]} empty_space_list
+ * @param {object[]} pre_selected_block_list
+ * @returns {object}
+ */
+function skip_probe_or_leftover_resolution(filter_data, empty_space_list, pre_selected_block_list)
+{
+    const session = filter_data.obligate_compound_session
+    const leftover_spaces = spaces_matching_remembered_leftover(empty_space_list, session)
+    const leftover_block_list = leftover_unitary_blocks(
+        pre_selected_block_list,
+        pre_selected_block_list.filter(
+            block => typeof block.get_slot_list === 'function' && block.get_slot_list().length > 1
+        ),
+        session?.leftover_sku_shape_hashes
+    )
+    if (leftover_spaces.length > 0 && leftover_block_list.length > 0)
+    {
+        return leftover_or_legacy_resolution(
+            empty_space_list,
+            pre_selected_block_list,
+            leftover_spaces,
+            leftover_block_list
+        )
+    }
+    return skip_probe_resolution(empty_space_list, pre_selected_block_list)
+}
+
+function space_bbox(space)
+{
+    if (typeof space.get_x !== 'function')
+    {
+        return null
+    }
+    return {
+        x: space.get_x(),
+        y: space.get_y(),
+        z: space.get_z(),
+        w: space.get_width(),
+        h: space.get_height(),
+        l: space.get_length()
+    }
+}
+
+function space_contained_in_region(space, region)
+{
+    const current = space_bbox(space)
+    if (!current)
+    {
+        return false
+    }
+    return current.x >= region.x - BBOX_TOLERANCE
+        && current.y >= region.y - BBOX_TOLERANCE
+        && current.z >= region.z - BBOX_TOLERANCE
+        && current.x + current.w <= region.x + region.w + BBOX_TOLERANCE
+        && current.y + current.h <= region.y + region.h + BBOX_TOLERANCE
+        && current.z + current.l <= region.z + region.l + BBOX_TOLERANCE
+}
+
+module.exports = {
+    remember_leftover_empty_spaces,
+    spaces_matching_remembered_leftover,
+    skip_probe_or_leftover_resolution
+}