@jetta/blocks-allocator 0.0.0-stage → 0.1.0

package/src/input_preparation/Input_State_Preparation.js

@@ -0,0 +1,47 @@
+const get_list_of_items_to_allocate            = require('./item_preparation/Items_Reader')
+const create_blocks                            = require('./block_preparation/Blocks_Creator')
+const calculate_block_slots_stackability_index = require('./stackability_index/Blocks_Stackability_Index_Calculator')
+const format_block_list                        = require('./Block_Formatter')
+const create_transport = require('../models/transport/factory/Transport_Factory')
+const build_empty_space_finder_options = require('./build_empty_space_finder_options')
+
+/**
+ * Assembles the object consumed by `Allocation_flow`: transport, items, and prepared blocks.
+ * @param {object} input_data - Full allocation request (e.g. `envs`, `items`, `available_blocks`).
+ * @param {{ get_object: Function }} [object_store]
+ * @returns {Promise<object>} `input_state` with `transport`, `items_to_allocate`, and `blocks`.
+ */
+async function build_input_state(input_data, object_store)
+{
+    const item_list = get_list_of_items_to_allocate(input_data.items)
+    const empty_space_finder_options = build_empty_space_finder_options(
+        input_data.config,
+        item_list
+    )
+    const transport = create_transport({
+        transport_data: input_data.envs[0],
+        empty_space_finder_options,
+        item_list
+    })
+    const blocks = await get_blocks(
+        input_data.available_blocks,
+        input_data.envs[0],
+        item_list,
+        object_store
+    )
+    return {
+        items_to_allocate: item_list,
+        transport,
+        blocks
+    }
+}
+
+async function get_blocks(block_path_list, transport, item_list, object_store)
+{
+    const filtered_blocks = await create_blocks(block_path_list, transport, item_list, object_store)
+    const formatted_block_list = format_block_list(filtered_blocks)
+    calculate_block_slots_stackability_index(formatted_block_list, item_list)
+    return formatted_block_list
+}
+
+module.exports = build_input_state

package/src/input_preparation/State_Builder.js

@@ -0,0 +1,27 @@
+const Cargo_Profile      = require('../models/Cargo_Profile')
+const create_input_state = require('./Input_State_Preparation')
+
+/**
+ * Hydrates cargo profile and builds the allocation input state.
+ * @param {object} input_data
+ * @param {{ object_store?: { get_object: Function } }} [dependencies]
+ * @returns {Promise<object>}
+ */
+async function build_state(input_data, dependencies = {})
+{
+    build_config_state(input_data)
+    const input_state = await create_input_state(input_data, dependencies.object_store)
+    return input_state
+}
+
+module.exports = build_state
+
+function build_config_state(input_data)
+{
+    Cargo_Profile.reset()
+    const cargo_profile = {
+        ...input_data.config.algoritmo,
+        available_blocks: input_data.available_blocks
+    }
+    Cargo_Profile.read_cargo_profile(cargo_profile)
+}

package/src/input_preparation/block_formatter/align_flush_axis_config.js

@@ -0,0 +1,36 @@
+const Slot = require('../../models/Slot')
+
+/**
+ * Per-axis stacking: lower positive face, upper start, footprint on the other two dimensions.
+ */
+const ALIGN_FLUSH_AXIS = {
+    z: {
+        lower_face_end: s => s.get_z() + s.get_length(),
+        start: s => s.get_z(),
+        size: s => s.get_length(),
+        min: b => b.min_z,
+        max: b => b.max_z,
+        footprint_key: s => `${s.get_x()}|${s.get_y()}|${s.get_width()}|${s.get_height()}`,
+        with_start: (s, v) => new Slot(s.get_x(), s.get_y(), v, s.get_width(), s.get_height(), s.get_length())
+    },
+    x: {
+        lower_face_end: s => s.get_x() + s.get_width(),
+        start: s => s.get_x(),
+        size: s => s.get_width(),
+        min: b => b.min_x,
+        max: b => b.max_x,
+        footprint_key: s => `${s.get_y()}|${s.get_z()}|${s.get_height()}|${s.get_length()}`,
+        with_start: (s, v) => new Slot(v, s.get_y(), s.get_z(), s.get_width(), s.get_height(), s.get_length())
+    },
+    y: {
+        lower_face_end: s => s.get_y() + s.get_height(),
+        start: s => s.get_y(),
+        size: s => s.get_height(),
+        min: b => b.min_y,
+        max: b => b.max_y,
+        footprint_key: s => `${s.get_x()}|${s.get_z()}|${s.get_width()}|${s.get_length()}`,
+        with_start: (s, v) => new Slot(s.get_x(), v, s.get_z(), s.get_width(), s.get_height(), s.get_length())
+    }
+}
+
+module.exports = { ALIGN_FLUSH_AXIS }

package/src/input_preparation/block_formatter/align_flush_axis_single_round.js

@@ -0,0 +1,112 @@
+const Slot = require('../../models/Slot')
+const { ALIGN_FLUSH_AXIS } = require('./align_flush_axis_config')
+
+function align_flush_axes_one_round(slot_list, bounds, tolerance)
+{
+    let working = slot_list
+    working = align_flush_axis_pass(working, bounds, tolerance, 'z')
+    working = align_flush_axis_pass(working, bounds, tolerance, 'x')
+    working = align_flush_axis_pass(working, bounds, tolerance, 'y')
+    return working
+}
+
+function align_flush_axis_pass(slot_list, bounds, tolerance, axis_key)
+{
+    const cfg = ALIGN_FLUSH_AXIS[axis_key]
+    const snapshot = slot_list
+    const footprint_index = build_footprint_index(snapshot, cfg)
+    const next_slot_list = []
+    for (let upper_index = 0; upper_index < snapshot.length; upper_index++)
+    {
+        const upper_slot = snapshot[upper_index]
+        const bucket = footprint_index.get(cfg.footprint_key(upper_slot))
+        const best = find_best_lower_face_end(snapshot, upper_index, cfg, tolerance, bucket)
+        if (best === null)
+        {
+            next_slot_list.push(clone_slot_xyz(upper_slot))
+            continue
+        }
+        const clamped = clamp_start(best + tolerance, cfg.size(upper_slot), cfg.min(bounds), cfg.max(bounds))
+        next_slot_list.push(cfg.with_start(upper_slot, clamped))
+    }
+    return next_slot_list
+}
+
+function build_footprint_index(snapshot, cfg)
+{
+    const index = new Map()
+    for (let i = 0; i < snapshot.length; i++)
+    {
+        const key = cfg.footprint_key(snapshot[i])
+        let bucket = index.get(key)
+        if (bucket === undefined)
+        {
+            bucket = []
+            index.set(key, bucket)
+        }
+        bucket.push(i)
+    }
+    return index
+}
+
+function find_best_lower_face_end(snapshot, upper_index, cfg, tolerance, bucket)
+{
+    const upper_slot = snapshot[upper_index]
+    let best = null
+    for (const lower_index of bucket)
+    {
+        if (lower_index === upper_index)
+        {
+            continue
+        }
+        const candidate = evaluate_lower_candidate(upper_slot, snapshot[lower_index], cfg, tolerance)
+        if (candidate === null)
+        {
+            continue
+        }
+        if (best === null || candidate > best)
+        {
+            best = candidate
+        }
+    }
+    return best
+}
+
+function evaluate_lower_candidate(upper_slot, lower_slot, cfg, tolerance)
+{
+    const lower_face_end = cfg.lower_face_end(lower_slot)
+    const upper_start = cfg.start(upper_slot)
+    if (lower_face_end > upper_start + tolerance)
+    {
+        return null
+    }
+    if (Math.abs(upper_start - lower_face_end) > tolerance)
+    {
+        return null
+    }
+    return lower_face_end
+}
+
+function clamp_start(start, size, min_value, max_value)
+{
+    const max_start = max_value - size
+    if (max_start < min_value)
+    {
+        return min_value
+    }
+    return Math.min(Math.max(start, min_value), max_start)
+}
+
+function clone_slot_xyz(slot)
+{
+    return new Slot(
+        slot.get_x(),
+        slot.get_y(),
+        slot.get_z(),
+        slot.get_width(),
+        slot.get_height(),
+        slot.get_length()
+    )
+}
+
+module.exports = { align_flush_axes_one_round }

package/src/input_preparation/block_formatter/align_flush_stacked_slots.js

@@ -0,0 +1,67 @@
+const Slot = require('../../models/Slot')
+const { align_flush_axes_one_round } = require('./align_flush_axis_single_round')
+
+const FLOAT_EPSILON = 1e-9
+
+/**
+ * @param {import('../../models/Slot')[]} slot_list_a
+ * @param {import('../../models/Slot')[]} slot_list_b
+ * @returns {boolean}
+ */
+function are_slot_lists_xyz_equal(slot_list_a, slot_list_b)
+{
+    if (slot_list_a.length !== slot_list_b.length)
+    {
+        return false
+    }
+    for (let index = 0; index < slot_list_a.length; index++)
+    {
+        const a = slot_list_a[index]
+        const b = slot_list_b[index]
+        const same = Math.abs(a.get_x() - b.get_x()) <= FLOAT_EPSILON
+            && Math.abs(a.get_y() - b.get_y()) <= FLOAT_EPSILON
+            && Math.abs(a.get_z() - b.get_z()) <= FLOAT_EPSILON
+        if (!same)
+        {
+            return false
+        }
+    }
+    return true
+}
+
+/**
+ * Applies z, then x, then y per round; repeats until stable or `max_rounds`.
+ *
+ * @param {import('../../models/Slot')[]} slot_list
+ * @param {{ min_x: number, max_x: number, min_y: number, max_y: number, min_z: number, max_z: number }} bounds
+ * @param {number} tolerance
+ * @param {number} max_rounds
+ * @returns {import('../../models/Slot')[]}
+ */
+function align_flush_stacked_slots_stable(slot_list, bounds, tolerance, max_rounds)
+{
+    let current = slot_list.map(slot => new Slot(
+        slot.get_x(),
+        slot.get_y(),
+        slot.get_z(),
+        slot.get_width(),
+        slot.get_height(),
+        slot.get_length()
+    ))
+    for (let round = 0; round < max_rounds; round++)
+    {
+        const snapshot = current
+        const next = align_flush_axes_one_round(snapshot, bounds, tolerance)
+        if (are_slot_lists_xyz_equal(next, snapshot))
+        {
+            return next
+        }
+        current = next
+    }
+    return current
+}
+
+module.exports = {
+    align_flush_stacked_slots_stable,
+    are_slot_lists_xyz_equal
+}

package/src/input_preparation/block_formatter/overlapped_slots.js

@@ -0,0 +1,24 @@
+/**
+ * @param {import('../../models/Slot')[]} slot_list
+ * @returns {boolean} True when any pair of slots has positive-volume overlap.
+ */
+function slot_list_has_overlapped_slots(slot_list)
+{
+    for (let i = 0; i < slot_list.length; i++)
+    {
+        for (let j = i + 1; j < slot_list.length; j++)
+        {
+            const slot_a = slot_list[i]
+            const slot_b = slot_list[j]
+            if (slot_a.contains(slot_b) || slot_b.contains(slot_a))
+            {
+                return true
+            }
+        }
+    }
+    return false
+}
+
+module.exports = {
+    slot_list_has_overlapped_slots
+}

package/src/input_preparation/block_formatter/parallelepiped_shell.js

@@ -0,0 +1,38 @@
+const { evaluate_parallelepiped_shell_faces } = require('./shell_face_coverage')
+
+/**
+ * @param {import('../../models/Slot')[]} slot_list
+ * @param {{ min_x: number, max_x: number, min_y: number, max_y: number, min_z: number, max_z: number }} bounds
+ * @param {number} tolerance
+ * @returns {boolean}
+ */
+function has_parallelepiped_shell(slot_list, bounds, tolerance)
+{
+    return evaluate_parallelepiped_shell_faces(slot_list, bounds, tolerance)
+}
+
+/**
+ * @param {import('../../models/Slot')[]} slot_list
+ * @param {{ min_x: number, max_x: number, min_y: number, max_y: number, min_z: number, max_z: number }} bounds
+ * @param {number} tolerance
+ * @returns {boolean}
+ */
+function are_all_slots_inside_bounds(slot_list, bounds, tolerance)
+{
+    return slot_list.every(slot =>
+    {
+        const slot_end = slot.get_end_point()
+        const lower_x = slot.get_x() >= bounds.min_x - tolerance
+        const lower_y = slot.get_y() >= bounds.min_y - tolerance
+        const lower_z = slot.get_z() >= bounds.min_z - tolerance
+        const upper_x = slot_end.x <= bounds.max_x + tolerance
+        const upper_y = slot_end.y <= bounds.max_y + tolerance
+        const upper_z = slot_end.z <= bounds.max_z + tolerance
+        return lower_x && lower_y && lower_z && upper_x && upper_y && upper_z
+    })
+}
+
+module.exports = {
+    has_parallelepiped_shell,
+    are_all_slots_inside_bounds
+}

package/src/input_preparation/block_formatter/rectangle_coverage.js

@@ -0,0 +1,112 @@
+/**
+ * Checks whether a rectangular area is fully covered by the union of a list
+ * of rectangles, allowing each rectangle to be expanded by `tolerance` on
+ * every side. The check builds a coordinate grid from the rectangle edges
+ * and marks every cell that has at least one covering rectangle.
+ *
+ * @param {{ min_a: number, max_a: number, min_b: number, max_b: number }} area
+ * @param {Array<{ start_a: number, end_a: number, start_b: number, end_b: number }>} rectangle_list
+ * @param {number} tolerance
+ * @returns {boolean}
+ */
+function is_rectangle_fully_covered(area, rectangle_list, tolerance)
+{
+    const axis_a_list = create_axis_list(area.min_a, area.max_a, rectangle_list, 'a')
+    const axis_b_list = create_axis_list(area.min_b, area.max_b, rectangle_list, 'b')
+    const cols = axis_a_list.length - 1
+    const rows = axis_b_list.length - 1
+    const grid = new Uint8Array(cols * rows)
+    for (const rectangle of rectangle_list)
+    {
+        mark_rectangle_cells(grid, rectangle, axis_a_list, axis_b_list, tolerance)
+    }
+    return is_grid_fully_marked(grid)
+}
+
+function create_axis_list(min_value, max_value, rectangle_list, suffix)
+{
+    const axis_set = new Set([min_value, max_value])
+    for (const rectangle of rectangle_list)
+    {
+        axis_set.add(rectangle[`start_${suffix}`])
+        axis_set.add(rectangle[`end_${suffix}`])
+    }
+    return [...axis_set].sort((a, b) => a - b)
+}
+
+function mark_rectangle_cells(grid, rectangle, axis_a_list, axis_b_list, tolerance)
+{
+    const i_start = find_first_covered_cell(axis_a_list, rectangle.start_a - tolerance)
+    const i_end = find_last_covered_cell(axis_a_list, rectangle.end_a + tolerance)
+    const j_start = find_first_covered_cell(axis_b_list, rectangle.start_b - tolerance)
+    const j_end = find_last_covered_cell(axis_b_list, rectangle.end_b + tolerance)
+    if (i_start > i_end || j_start > j_end)
+    {
+        return
+    }
+    const cols = axis_a_list.length - 1
+    for (let j = j_start; j <= j_end; j++)
+    {
+        const row_offset = j * cols
+        for (let i = i_start; i <= i_end; i++)
+        {
+            grid[row_offset + i] = 1
+        }
+    }
+}
+
+function find_first_covered_cell(axis_list, lower_bound)
+{
+    const cell_count = axis_list.length - 1
+    let low = 0
+    let high = cell_count
+    while (low < high)
+    {
+        const mid = (low + high) >>> 1
+        const midpoint = (axis_list[mid] + axis_list[mid + 1]) / 2
+        if (midpoint >= lower_bound)
+        {
+            high = mid
+        }
+        else
+        {
+            low = mid + 1
+        }
+    }
+    return low
+}
+
+function find_last_covered_cell(axis_list, upper_bound)
+{
+    const cell_count = axis_list.length - 1
+    let low = -1
+    let high = cell_count - 1
+    while (low < high)
+    {
+        const mid = (low + high + 1) >>> 1
+        const midpoint = (axis_list[mid] + axis_list[mid + 1]) / 2
+        if (midpoint <= upper_bound)
+        {
+            low = mid
+        }
+        else
+        {
+            high = mid - 1
+        }
+    }
+    return low
+}
+
+function is_grid_fully_marked(grid)
+{
+    for (let index = 0; index < grid.length; index++)
+    {
+        if (grid[index] === 0)
+        {
+            return false
+        }
+    }
+    return true
+}
+
+module.exports = { is_rectangle_fully_covered }

package/src/input_preparation/block_formatter/shell_face_coverage.js

@@ -0,0 +1,64 @@
+const { is_rectangle_fully_covered } = require('./rectangle_coverage')
+
+/**
+ * @param {import('../../models/Slot')[]} slot_list
+ * @param {{ min_x: number, max_x: number, min_y: number, max_y: number, min_z: number, max_z: number }} bounds
+ * @param {number} tolerance
+ * @returns {boolean}
+ */
+function evaluate_parallelepiped_shell_faces(slot_list, bounds, tolerance)
+{
+    return face_has_full_coverage(slot_list, bounds, 'y', bounds.min_y, 'x', 'z', tolerance)
+        && face_has_full_coverage(slot_list, bounds, 'y_end', bounds.max_y, 'x', 'z', tolerance)
+        && face_has_full_coverage(slot_list, bounds, 'x', bounds.min_x, 'y', 'z', tolerance)
+        && face_has_full_coverage(slot_list, bounds, 'x_end', bounds.max_x, 'y', 'z', tolerance)
+        && face_has_full_coverage(slot_list, bounds, 'z', bounds.min_z, 'x', 'y', tolerance)
+        && face_has_full_coverage(slot_list, bounds, 'z_end', bounds.max_z, 'x', 'y', tolerance)
+}
+
+function face_has_full_coverage(slot_list, bounds, plane, plane_value, axis_a, axis_b, tolerance)
+{
+    const rectangle_list = collect_face_rectangles(slot_list, plane, plane_value, axis_a, axis_b, tolerance)
+    if (rectangle_list.length === 0)
+    {
+        return false
+    }
+    const area = { min_a: bounds[`min_${axis_a}`], max_a: bounds[`max_${axis_a}`], min_b: bounds[`min_${axis_b}`], max_b: bounds[`max_${axis_b}`] }
+    return is_rectangle_fully_covered(area, rectangle_list, tolerance)
+}
+
+function collect_face_rectangles(slot_list, plane, plane_value, axis_a, axis_b, tolerance)
+{
+    const rectangle_list = []
+    for (const slot of slot_list)
+    {
+        if (!is_slot_on_plane(slot, plane, plane_value, tolerance))
+        {
+            continue
+        }
+        rectangle_list.push({
+            start_a: slot[`get_${axis_a}`](),
+            end_a: slot[`get_${axis_a}`]() + slot[`get_${size_axis(axis_a)}`](),
+            start_b: slot[`get_${axis_b}`](),
+            end_b: slot[`get_${axis_b}`]() + slot[`get_${size_axis(axis_b)}`]()
+        })
+    }
+    return rectangle_list
+}
+
+function is_slot_on_plane(slot, plane, plane_value, tolerance)
+{
+    if (plane === 'x' || plane === 'y' || plane === 'z')
+    {
+        return Math.abs(slot[`get_${plane}`]() - plane_value) <= tolerance
+    }
+    const axis = plane.replace('_end', '')
+    return Math.abs(slot.get_end_point()[axis] - plane_value) <= tolerance
+}
+
+function size_axis(axis)
+{
+    return axis === 'y' ? 'height' : axis === 'x' ? 'width' : 'length'
+}
+
+module.exports = { evaluate_parallelepiped_shell_faces }

package/src/input_preparation/block_formatter/shell_snap_convergence.js

@@ -0,0 +1,104 @@
+const Slot = require('../../models/Slot')
+
+/**
+ * Repeats bounds → anchor → align flush → normalize until `has_parallelepiped_shell` passes,
+ * or positions stabilize, or `max_iterations` is reached. Only translations (no new slots).
+ *
+ * @param {object} params
+ * @param {number} params.max_iterations
+ * @param {number} params.touch_tolerance
+ * @param {number} params.align_flush_max_rounds
+ * @param {import('../../models/Slot')[]} params.slot_list
+ * @param {function} params.get_bounds
+ * @param {function} params.anchor_slots_to_bounds
+ * @param {function} params.align_flush_stacked_slots_stable
+ * @param {function} params.normalize_slot_list
+ * @param {function} params.are_all_slots_inside_bounds
+ * @param {function} params.has_parallelepiped_shell
+ * @param {function} params.are_slot_lists_xyz_equal
+ * @returns {{ normalized_slot_list: import('../../models/Slot')[], normalized_bounds: object, anchor_align_changed: boolean }}
+ */
+function run_shell_snap_convergence(params)
+{
+    const {
+        slot_list,
+        max_iterations,
+        touch_tolerance,
+        align_flush_max_rounds,
+        get_bounds,
+        anchor_slots_to_bounds,
+        align_flush_stacked_slots_stable,
+        normalize_slot_list,
+        are_all_slots_inside_bounds,
+        has_parallelepiped_shell,
+        are_slot_lists_xyz_equal
+    } = params
+    let working = clone_slot_list(slot_list)
+    let anchor_align_changed = false
+    let previous_normalized = null
+    for (let iteration = 0; iteration < max_iterations; iteration++)
+    {
+        const bounds = get_bounds(working)
+        const anchored_slot_list = anchor_slots_to_bounds(working, bounds)
+        if (!are_slot_lists_xyz_equal(working, anchored_slot_list))
+        {
+            anchor_align_changed = true
+        }
+        const anchored_bounds = get_bounds(anchored_slot_list)
+        const aligned_slot_list = align_flush_stacked_slots_stable(
+            anchored_slot_list,
+            anchored_bounds,
+            touch_tolerance,
+            align_flush_max_rounds
+        )
+        if (!are_slot_lists_xyz_equal(anchored_slot_list, aligned_slot_list))
+        {
+            anchor_align_changed = true
+        }
+        const aligned_bounds = get_bounds(aligned_slot_list)
+        const normalized_slot_list = normalize_slot_list(aligned_slot_list, aligned_bounds)
+        const normalized_bounds = get_bounds(normalized_slot_list)
+        working = normalized_slot_list
+        const slot_list_inside_bounds = are_all_slots_inside_bounds(working, normalized_bounds)
+        const shell_ok = has_parallelepiped_shell(working, normalized_bounds)
+        if (slot_list_inside_bounds && shell_ok)
+        {
+            return {
+                normalized_slot_list: working,
+                normalized_bounds,
+                anchor_align_changed
+            }
+        }
+        if (previous_normalized !== null && are_slot_lists_xyz_equal(previous_normalized, working))
+        {
+            return {
+                normalized_slot_list: working,
+                normalized_bounds,
+                anchor_align_changed
+            }
+        }
+        previous_normalized = clone_slot_list(working)
+    }
+    const final_bounds = get_bounds(working)
+    return {
+        normalized_slot_list: working,
+        normalized_bounds: final_bounds,
+        anchor_align_changed
+    }
+}
+
+function clone_slot_list(slot_list)
+{
+    return slot_list.map(slot => new Slot(
+        slot.get_x(),
+        slot.get_y(),
+        slot.get_z(),
+        slot.get_width(),
+        slot.get_height(),
+        slot.get_length()
+    ))
+}
+
+module.exports = {
+    run_shell_snap_convergence
+}

package/src/input_preparation/block_preparation/Block_Data_To_Object_Transformer.js

@@ -0,0 +1,57 @@
+const {Block}                          = require('../../models/Block')
+const Slot                             = require('../../models/Slot')
+const Failed_To_Create_Block_Exception = require('./exceptions/Failed_To_Create_Block_Exception')
+
+const transform_blocks_data_into_object = function transform_blocks_data_into_object(block_data_list)
+{
+    if (block_data_list.length === 0)
+    {
+        throw new Failed_To_Create_Block_Exception()
+    }
+    return block_data_list.map(block => create_block(block))
+}
+
+function create_block(block_data)
+{
+    const slot_list = create_slot_list_of_a_block(block_data.slot_list)
+    return new Block(block_data, slot_list)
+}
+
+function create_slot_list_of_a_block(slot_data_list)
+{
+    return slot_data_list.map(slot_data => create_slot(slot_data))
+}
+
+/**
+ * Reads slot height from JSON (`height` preferred; accepts common typo `heigth`).
+ *
+ * @param {object} item_data
+ * @returns {number|undefined}
+ */
+function read_slot_height(item_data)
+{
+    if (item_data.height !== undefined && item_data.height !== null)
+    {
+        return item_data.height
+    }
+    if (item_data.heigth !== undefined && item_data.heigth !== null)
+    {
+        return item_data.heigth
+    }
+    return undefined
+}
+
+function create_slot(item_data)
+{
+    return new Slot(
+        item_data.x,
+        item_data.y,
+        item_data.z,
+        item_data.width,
+        read_slot_height(item_data),
+        item_data.length,
+    )
+}
+
+module.exports = transform_blocks_data_into_object
+module.exports.read_slot_height = read_slot_height