@jetta/blocks-allocator 0.2.1-1 → 0.2.1-3

package/src/space_and_block_chooser/leftover_unitary_blocks.js

@@ -1,114 +1,90 @@
-const { cube_map_function } = require('../Blocks_Preparation/Cube_Map_Function')
-const round = require('../tools/Rounder')
+const {
+    remember_leftover_sku_hashes,
+    leftover_sku_shape_hashes,
+    to_hash_set,
+    compound_slot_shape_hashes,
+    is_unitary_matching_hashes,
+    cube_map_function,
+    swapped_length_width_hash
+} = require('./leftover_sku_hashes')
+const {
+    unite_with_hidden_unitaries,
+    unitaries_outside_remembered_hashes,
+    blocks_are_remembered_unitaries_only
+} = require('./leftover_unitary_admission')
 
 /**
  * 1-slot blocks of leftover SKUs: not used by remaining compounds, or remembered after compounds are gone.
+ * When `admit_other_unitaries` is true, other 1-slot blocks are included without changing stored hashes.
  * @param {object[]} pre_selected_block_list
  * @param {object[]} compound_block_list
  * @param {Set<string>|string[]} [remembered_sku_hashes]
+ * @param {boolean} [admit_other_unitaries]
  * @returns {object[]}
  */
-function leftover_unitary_blocks(pre_selected_block_list, compound_block_list, remembered_sku_hashes)
+function leftover_unitary_blocks(
+    pre_selected_block_list,
+    compound_block_list,
+    remembered_sku_hashes,
+    admit_other_unitaries
+)
 {
-    const remembered = to_hash_set(remembered_sku_hashes)
-    if (remembered.size > 0)
+    const remembered_matches = remembered_or_current_unitaries(
+        pre_selected_block_list,
+        compound_block_list,
+        remembered_sku_hashes
+    )
+    if (admit_other_unitaries !== true)
     {
-        return pre_selected_block_list.filter(block => is_unitary_matching_hashes(block, remembered))
+        return remembered_matches
     }
-    return pre_selected_block_list.filter(
-        block => is_leftover_unitary_block(block, compound_slot_shape_hashes(compound_block_list))
+    return unite_with_hidden_unitaries(
+        pre_selected_block_list,
+        remembered_matches,
+        remembered_sku_hashes
     )
 }
 
 /**
- * Stores leftover SKU shape hashes while compounds still remain.
- * @param {{ leftover_sku_shape_hashes?: string[] }|undefined} session
- * @param {object[]} leftover_block_list
+ * Applies the session allow-list, including hidden unitaries after the one-shot release.
+ * @param {object[]} pre_selected_block_list
  * @param {object[]} compound_block_list
+ * @param {{ leftover_sku_shape_hashes?: string[], admit_non_remembered_unitaries?: boolean }|undefined} session
+ * @returns {object[]}
  */
-function remember_leftover_sku_hashes(session, leftover_block_list, compound_block_list)
+function leftover_unitary_blocks_from_session(pre_selected_block_list, compound_block_list, session)
 {
-    if (!session || compound_block_list.length === 0 || leftover_block_list.length === 0)
-    {
-        return
-    }
-    if (session.leftover_sku_shape_hashes?.length > 0)
-    {
-        return
-    }
-    session.leftover_sku_shape_hashes = [...leftover_sku_shape_hashes(leftover_block_list)]
+    return leftover_unitary_blocks(
+        pre_selected_block_list,
+        compound_block_list,
+        session?.leftover_sku_shape_hashes,
+        session?.admit_non_remembered_unitaries === true
+    )
 }
 
 /**
- * Width/height/length hashes for leftover 1-slot blocks, including swapped floor axes.
- * @param {object[]} leftover_block_list
- * @returns {Set<string>}
+ * @param {object[]} pre_selected_block_list
+ * @param {object[]} compound_block_list
+ * @param {Set<string>|string[]|undefined} remembered_sku_hashes
+ * @returns {object[]}
  */
-function leftover_sku_shape_hashes(leftover_block_list)
-{
-    const hashes = new Set()
-    for (const block of leftover_block_list)
-    {
-        add_slot_orientation_hashes(hashes, block)
-    }
-    return hashes
-}
-
-function add_slot_orientation_hashes(hashes, block)
-{
-    if (typeof block.get_slot_list !== 'function')
-    {
-        return
-    }
-    const slot_list = block.get_slot_list()
-    if (slot_list.length !== 1 || typeof slot_list[0].get_width !== 'function')
-    {
-        return
-    }
-    hashes.add(cube_map_function(slot_list[0]))
-    hashes.add(swapped_length_width_hash(slot_list[0]))
-}
-
-function swapped_length_width_hash(slot)
-{
-    return round(slot.get_length()) + ';' + round(slot.get_height()) + ';' + round(slot.get_width())
-}
-
-function to_hash_set(remembered_sku_hashes)
+function remembered_or_current_unitaries(pre_selected_block_list, compound_block_list, remembered_sku_hashes)
 {
-    if (!remembered_sku_hashes)
-    {
-        return new Set()
-    }
-    if (remembered_sku_hashes instanceof Set)
-    {
-        return remembered_sku_hashes
-    }
-    return new Set(remembered_sku_hashes)
-}
-
-function compound_slot_shape_hashes(compound_block_list)
-{
-    const hashes = new Set()
-    for (const block of compound_block_list)
+    const remembered = to_hash_set(remembered_sku_hashes)
+    if (remembered.size > 0)
     {
-        if (typeof block.get_slot_list !== 'function')
-        {
-            continue
-        }
-        for (const slot of block.get_slot_list())
-        {
-            if (typeof slot.get_width !== 'function')
-            {
-                continue
-            }
-            hashes.add(cube_map_function(slot))
-            hashes.add(swapped_length_width_hash(slot))
-        }
+        return pre_selected_block_list.filter(block => is_unitary_matching_hashes(block, remembered))
     }
-    return hashes
+    return pre_selected_block_list.filter(
+        block => is_leftover_unitary_block(block, compound_slot_shape_hashes(compound_block_list))
+    )
 }
 
+/**
+ * @param {object} block
+ * @param {Set<string>} compound_slot_hashes
+ * @returns {boolean}
+ */
 function is_leftover_unitary_block(block, compound_slot_hashes)
 {
     if (typeof block.get_slot_list !== 'function')
@@ -128,26 +104,25 @@ function is_leftover_unitary_block(block, compound_slot_hashes)
     {
         return true
     }
-    return !compound_slot_hashes.has(cube_map_function(slot_list[0]))
-        && !compound_slot_hashes.has(swapped_length_width_hash(slot_list[0]))
+    return slot_shape_is_absent(slot_list[0], compound_slot_hashes)
 }
 
-function is_unitary_matching_hashes(block, remembered)
+/**
+ * @param {object} slot
+ * @param {Set<string>} compound_slot_hashes
+ * @returns {boolean}
+ */
+function slot_shape_is_absent(slot, compound_slot_hashes)
 {
-    if (typeof block.get_slot_list !== 'function')
-    {
-        return false
-    }
-    const slot_list = block.get_slot_list()
-    if (slot_list.length !== 1 || typeof slot_list[0].get_width !== 'function')
-    {
-        return false
-    }
-    return remembered.has(cube_map_function(slot_list[0]))
-        || remembered.has(swapped_length_width_hash(slot_list[0]))
+    const matches_cube = compound_slot_hashes.has(cube_map_function(slot))
+    const matches_swap = compound_slot_hashes.has(swapped_length_width_hash(slot))
+    return !matches_cube && !matches_swap
 }
 
 leftover_unitary_blocks.remember_leftover_sku_hashes = remember_leftover_sku_hashes
 leftover_unitary_blocks.leftover_sku_shape_hashes = leftover_sku_shape_hashes
+leftover_unitary_blocks.from_session = leftover_unitary_blocks_from_session
+leftover_unitary_blocks.unitaries_outside_remembered_hashes = unitaries_outside_remembered_hashes
+leftover_unitary_blocks.blocks_are_remembered_unitaries_only = blocks_are_remembered_unitaries_only
 
 module.exports = leftover_unitary_blocks

package/src/space_and_block_chooser/leftover_unitary_empty_spaces.js

@@ -119,10 +119,10 @@ function resolve_compound_first_or_leftover(
         empty_space_list,
         pre_selected_block_list,
         leftover_empty_spaces,
-        leftover_unitary_blocks(
+        leftover_unitary_blocks.from_session(
             pre_selected_block_list,
             compound_block_list,
-            filter_data.obligate_compound_session?.leftover_sku_shape_hashes
+            filter_data.obligate_compound_session
         )
     )
 }