@jetta/blocks-allocator 0.2.0 → 0.2.1-0

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@jetta/blocks-allocator",
-    "version": "0.2.0",
+    "version": "0.2.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/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
+]