@jetta/blocks-allocator 0.1.0-0 → 0.1.1-0

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@jetta/blocks-allocator",
-    "version": "0.1.0-0",
+    "version": "0.1.1-0",
     "description": "Blocks wall allocation library",
     "main": "src/index.js",
     "exports": {
@@ -46,7 +46,7 @@
         "@jetta/lp-framework": "2.1.0-6",
         "@jetta/number-compare": "^3.0.2-4",
         "@jetta/stacking-constraints": "^1.1.0",
-        "@jetta/tie-ratio-block-creator-core": "1.2.2-3",
+        "@jetta/tie-ratio-block-creator-core": "1.2.2-5",
         "@jetta/z-intersected-block-creator": "^0.0.1-42",
         "@jettacargo/single-item-block-creator-core": "2.0.1-0",
         "@jettacargo/spiral-block-creator-core": "2.1.2",

package/src/Allocation_Optimization/lp_model/model_builder/restrictions/Container_Supported_Weight_Restriction.js

@@ -1,42 +1,86 @@
 const { VariableType, create_variable, create_restriction } = require('@jetta/lp-framework')
-const {
-    get_dimension_to_max_weight_map,
-    calculate_block_potential_weight
-} = require('../../../Block_Potential_Weight')
+const create_item_assignment_variables = require('../Item_Assignment_Variables')
 
 /**
- * Creates a single LP restriction to ensure the total weight of items in the chosen blocks
- * does not exceed the container's supported weight.
- * @param {object} container - The container object, with a supported_weight() method.
- * @param {object[]} block_list - An array of Block objects.
- * @param {object[]} item_list - An array of Item objects.
- * @returns {Restriction[]} An array containing the single weight restriction.
+ * Creates one LP restriction so the weight of items assigned to chosen blocks
+ * stays within the container supported weight.
+ * Each assignment variable is weighted by that item's own weight.
+ * @param {object} container - Container with supported_weight() or a supported_weight number.
+ * @param {object[]} block_list - Block objects.
+ * @param {object[]} item_list - Item objects with get_id() and get_weight().
+ * @returns {object[]} One restriction, or an empty list when no positive item weight applies.
  */
 module.exports = function create_container_supported_weight_restriction(container, block_list, item_list)
 {
-    const dimension_to_max_weight_map = get_dimension_to_max_weight_map(item_list)
+    const assignment = create_item_assignment_variables(block_list, item_list)
+    const variable_list = build_item_weight_variables(assignment.slot_demand_list, item_list)
+    if (variable_list.length === 0)
+    {
+        return []
+    }
+    return [create_restriction(
+        'container_supported_weight',
+        variable_list,
+        {lower_limit: 0, upper_limit: read_supported_weight(container)}
+    )]
+}
+
+/**
+ * @param {Array<{compatibility_list: Array<{item_id: string, variable_name: string}>}>} slot_demand_list
+ * @param {object[]} item_list
+ * @returns {object[]}
+ */
+function build_item_weight_variables(slot_demand_list, item_list)
+{
+    const weight_by_item_id = map_item_weight(item_list)
     const variable_list = []
+    for (const slot_demand of slot_demand_list)
+    {
+        append_slot_item_weights(variable_list, slot_demand.compatibility_list, weight_by_item_id)
+    }
+    return variable_list
+}
 
-    for (const block of block_list)
+/**
+ * @param {object[]} item_list
+ * @returns {Map<string, number>}
+ */
+function map_item_weight(item_list)
+{
+    const weight_by_item_id = new Map()
+    for (const item of item_list)
     {
-        const block_potential_weight = calculate_block_potential_weight(block, dimension_to_max_weight_map)
+        weight_by_item_id.set(item.get_id(), item.get_weight())
+    }
+    return weight_by_item_id
+}
 
-        if (block_potential_weight > 0)
+/**
+ * @param {object[]} variable_list
+ * @param {Array<{item_id: string, variable_name: string}>} compatibility_list
+ * @param {Map<string, number>} weight_by_item_id
+ */
+function append_slot_item_weights(variable_list, compatibility_list, weight_by_item_id)
+{
+    for (const entry of compatibility_list)
+    {
+        const item_weight = weight_by_item_id.get(entry.item_id) || 0
+        if (item_weight > 0)
         {
-            variable_list.push(create_variable(block.get_id(), block_potential_weight, VariableType.INTEGER))
+            variable_list.push(create_variable(entry.variable_name, item_weight, VariableType.INTEGER))
         }
     }
+}
 
-    if (variable_list.length === 0)
+/**
+ * @param {object} container
+ * @returns {number}
+ */
+function read_supported_weight(container)
+{
+    if (typeof container.supported_weight === 'function')
     {
-        return []
+        return container.supported_weight()
     }
-
-    const supported_weight = typeof container.supported_weight === 'function'
-        ? container.supported_weight()
-        : container.supported_weight
-
-    const name = 'container_supported_weight'
-    const restriction = create_restriction(name, variable_list, {lower_limit: 0, upper_limit: supported_weight})
-    return [restriction]
+    return container.supported_weight
 }

package/src/Allocation_Optimization/tie_ratio/Same_Height_Tie_Ratio_Filter.js

@@ -0,0 +1,28 @@
+const Block_Filter_Interface = require('../../space_and_block_chooser/blocks_filters/Block_Filter_Interface')
+const Cargo_Profile = require('../../models/Cargo_Profile')
+const filter_out_mixed_height_tie_ratio = require('./filter_out_mixed_height_tie_ratio')
+const has_stocked_same_height_tie_ratio = require('./has_stocked_same_height_tie_ratio')
+
+/**
+ * Post-selection filter: prefer same-height tie-ratio over mixed-height when stock allows.
+ */
+module.exports = class Same_Height_Tie_Ratio_Filter extends Block_Filter_Interface
+{
+    static run(filter_data)
+    {
+        if (!Cargo_Profile.prefer_same_height_tie_ratio_slots())
+        {
+            return filter_data.block_list
+        }
+
+        if (!has_stocked_same_height_tie_ratio(
+            filter_data.block_list,
+            filter_data.item_list || []
+        ))
+        {
+            return filter_data.block_list
+        }
+
+        return filter_out_mixed_height_tie_ratio(filter_data.block_list)
+    }
+}

package/src/Allocation_Optimization/tie_ratio/filter_out_mixed_height_tie_ratio.js

@@ -0,0 +1,20 @@
+const is_tie_ratio_block = require('./is_tie_ratio_block')
+
+/**
+ * Drops mixed-height tie-ratio blocks; keeps same-height tie-ratio and non-tie-ratio.
+ * @param {Array<object>} block_list
+ * @returns {Array<object>}
+ */
+function filter_out_mixed_height_tie_ratio(block_list)
+{
+    return block_list.filter((block) =>
+    {
+        if (!is_tie_ratio_block(block))
+        {
+            return true
+        }
+        return block.is_slots_of_same_measure()
+    })
+}
+
+module.exports = filter_out_mixed_height_tie_ratio

package/src/Allocation_Optimization/tie_ratio/has_stocked_same_height_tie_ratio.js

@@ -0,0 +1,40 @@
+const is_tie_ratio_block = require('./is_tie_ratio_block')
+const max_tie_ratio_slot_count = require('./max_tie_ratio_slot_count')
+const tie_ratio_block_has_shape_stock = require('./tie_ratio_block_has_shape_stock')
+
+/**
+ * True when a same-height tie-ratio at the max slot count has enough shape stock.
+ * Smaller same-height partials must not hide larger mixed walls.
+ * @param {Array<object>} block_list
+ * @param {Array<object>} item_list
+ * @returns {boolean}
+ */
+function has_stocked_same_height_tie_ratio(block_list, item_list)
+{
+    const target_slot_count = max_tie_ratio_slot_count(block_list)
+
+    if (target_slot_count === 0)
+    {
+        return false
+    }
+
+    for (const block of block_list)
+    {
+        if (!is_tie_ratio_block(block) || !block.is_slots_of_same_measure())
+        {
+            continue
+        }
+        if (block.get_slot_list().length !== target_slot_count)
+        {
+            continue
+        }
+        if (tie_ratio_block_has_shape_stock(block, item_list))
+        {
+            return true
+        }
+    }
+
+    return false
+}
+
+module.exports = has_stocked_same_height_tie_ratio

package/src/Allocation_Optimization/tie_ratio/is_tie_ratio_block.js

@@ -0,0 +1,12 @@
+/**
+ * True when the block reports itself as a tie-ratio block.
+ * Probe objects without the method are not tie-ratio blocks.
+ * @param {object} block
+ * @returns {boolean}
+ */
+function is_tie_ratio_block(block)
+{
+    return typeof block.is_tie_ratio_block === 'function' && block.is_tie_ratio_block()
+}
+
+module.exports = is_tie_ratio_block

package/src/Allocation_Optimization/tie_ratio/max_tie_ratio_slot_count.js

@@ -0,0 +1,24 @@
+const is_tie_ratio_block = require('./is_tie_ratio_block')
+
+/**
+ * Returns the largest slot count among tie-ratio blocks in the list.
+ * @param {Array<object>} block_list
+ * @returns {number}
+ */
+function max_tie_ratio_slot_count(block_list)
+{
+    let maximum = 0
+
+    for (const block of block_list)
+    {
+        if (!is_tie_ratio_block(block))
+        {
+            continue
+        }
+        maximum = Math.max(maximum, block.get_slot_list().length)
+    }
+
+    return maximum
+}
+
+module.exports = max_tie_ratio_slot_count

package/src/Allocation_Optimization/tie_ratio/tie_ratio_block_has_shape_stock.js

@@ -0,0 +1,113 @@
+const { cube_map_function } = require('../../Blocks_Preparation/Cube_Map_Function')
+
+/**
+ * Builds required shape amounts from a block's slots.
+ * @param {object} block
+ * @returns {Map<string, number>}
+ */
+function build_required_shapes(block)
+{
+    const required_shapes = new Map()
+    for (const slot of block.get_slot_list())
+    {
+        const shape_hash = cube_map_function(slot)
+        required_shapes.set(shape_hash, (required_shapes.get(shape_hash) || 0) + 1)
+    }
+    return required_shapes
+}
+
+/**
+ * Builds available shape amounts (amount counted once per SKU per unique rotation hash).
+ * @param {Array<object>} item_list
+ * @returns {Map<string, number>}
+ */
+function build_available_shapes(item_list)
+{
+    const available_shapes = new Map()
+    for (const item of item_list)
+    {
+        const unique_shape_hashes = new Set()
+        for (const rotated_item of item.get_all_rotated_options())
+        {
+            unique_shape_hashes.add(cube_map_function(rotated_item))
+        }
+        const item_amount = item.get_amount()
+        for (const shape_hash of unique_shape_hashes)
+        {
+            available_shapes.set(
+                shape_hash,
+                (available_shapes.get(shape_hash) || 0) + item_amount
+            )
+        }
+    }
+    return available_shapes
+}
+
+/**
+ * Counts units that can form any required shape (once per SKU).
+ * @param {Map<string, number>} required_shapes
+ * @param {Array<object>} item_list
+ * @returns {number}
+ */
+function count_capable_item_amount(required_shapes, item_list)
+{
+    let capable_amount = 0
+
+    for (const item of item_list)
+    {
+        const amount = item.get_amount()
+        if (amount <= 0)
+        {
+            continue
+        }
+        const can_form = item.get_all_rotated_options().some((rotated_item) =>
+            required_shapes.has(cube_map_function(rotated_item)))
+        if (can_form)
+        {
+            capable_amount += amount
+        }
+    }
+
+    return capable_amount
+}
+
+/**
+ * True when remaining item_list stock can fill the block.
+ * Combines total capable units with per-shape availability so rotation
+ * double-counting cannot keep a stale same-height five-slot alive.
+ * @param {object} block
+ * @param {Array<object>} item_list
+ * @returns {boolean}
+ */
+function tie_ratio_block_has_shape_stock(block, item_list)
+{
+    const required_shapes = build_required_shapes(block)
+    if (required_shapes.size === 0)
+    {
+        return false
+    }
+
+    let total_required = 0
+    for (const required_amount of required_shapes.values())
+    {
+        total_required += required_amount
+    }
+
+    if (count_capable_item_amount(required_shapes, item_list) < total_required)
+    {
+        return false
+    }
+
+    const available_shapes = build_available_shapes(item_list)
+    for (const [shape_hash, required_amount] of required_shapes)
+    {
+        if ((available_shapes.get(shape_hash) || 0) < required_amount)
+        {
+            return false
+        }
+    }
+
+    return true
+}
+
+module.exports = tie_ratio_block_has_shape_stock

package/src/models/Cargo_Profile.js

@@ -362,6 +362,21 @@ class Cargo_Profile
         return str_to_bool(this.#instance[key], false)
     }
 
+    /**
+     * Prefer same-height tie-ratio blocks over mixed-height when both fit.
+     * Default true when omitted.
+     * @returns {boolean}
+     */
+    static prefer_same_height_tie_ratio_slots()
+    {
+        if (Cargo_Profile.#instance === null)
+        {
+            return true
+        }
+        const key = 'allocation.blocks.prefer_same_height_tie_ratio_slots'
+        return str_to_bool(this.#instance[key], true)
+    }
+
     static tie_ratio_allocate_remainder_as_partial_blocks()
     {
         if (Cargo_Profile.#instance === null)

package/src/space_and_block_chooser/blocks_filters/pos_selection_filters/Post_Selection_Filter_List.js

@@ -1,9 +1,11 @@
 const Blocks_Bigger_Than_Space_Filter = require('./Blocks_Bigger_Than_Space_Filter')
 const Tie_Ratio_Orientation_Filter = require('../../../Allocation_Optimization/tie_ratio/Tie_Ratio_Orientation_Filter')
 const Tie_Ratio_Vertical_Stack_Filter = require('../../../Allocation_Optimization/tie_ratio/Tie_Ratio_Vertical_Stack_Filter')
+const Same_Height_Tie_Ratio_Filter = require('../../../Allocation_Optimization/tie_ratio/Same_Height_Tie_Ratio_Filter')
 
 module.exports = [
     Blocks_Bigger_Than_Space_Filter,
     Tie_Ratio_Orientation_Filter,
-    Tie_Ratio_Vertical_Stack_Filter
-]
+    Tie_Ratio_Vertical_Stack_Filter,
+    Same_Height_Tie_Ratio_Filter
+]