Refactor: Extract calculateDefaultChunks to shared Utils class

Co-authored-by: brokkoli71 <44113112+brokkoli71@users.noreply.github.com>

Author: Copilot

src/main/java/dev/zarr/zarrjava/utils/Utils.java

@@ -107,4 +107,38 @@ public static int[] inversePermutation(int[] origin) {
         }
         return inverse;
     }
+
+    /**
+     * Calculate default chunk shape when not specified.
+     * This implements JZarr's ArrayParams.build() logic, targeting chunks of approximately 512 elements.
+     * 
+     * The algorithm divides each dimension by 512 to determine the number of ~512-sized chunks,
+     * then calculates chunk sizes that will cover the dimension. Note that the total coverage
+     * may slightly exceed the dimension size (e.g., for shape=1024, chunks=342 results in 
+     * 3 chunks covering 1026 elements). This is intentional and matches JZarr behavior - 
+     * Zarr handles out-of-bounds gracefully, and the goal is approximate chunk sizes rather 
+     * than perfect tiling.
+     * 
+     * @param shape the shape of the array
+     * @return the calculated default chunk shape
+     */
+    public static int[] calculateDefaultChunks(long[] shape) {
+        int[] chunks = new int[shape.length];
+        for (int i = 0; i < shape.length; i++) {
+            long shapeDim = shape[i];
+            int numChunks = (int) (shapeDim / 512);
+            if (numChunks > 0) {
+                int chunkDim = (int) (shapeDim / (numChunks + 1));
+                if (shapeDim % chunkDim == 0) {
+                    chunks[i] = chunkDim;
+                } else {
+                    chunks[i] = chunkDim + 1;
+                }
+            } else {
+                // If dimension is smaller than 512, use the full dimension
+                chunks[i] = (int) shapeDim;
+            }
+        }
+        return chunks;
+    }
 }

src/main/java/dev/zarr/zarrjava/v2/ArrayMetadataBuilder.java

@@ -4,6 +4,7 @@
 import dev.zarr.zarrjava.ZarrException;
 import dev.zarr.zarrjava.core.Attributes;
 import dev.zarr.zarrjava.core.chunkkeyencoding.Separator;
+import dev.zarr.zarrjava.utils.Utils;
 import dev.zarr.zarrjava.v2.codec.Codec;
 import dev.zarr.zarrjava.v2.codec.core.BloscCodec;
 import dev.zarr.zarrjava.v2.codec.core.ZlibCodec;
@@ -152,7 +153,7 @@ public ArrayMetadata build() throws ZarrException {
 
         // If chunks are not specified, calculate default chunks
         if (chunks == null) {
-            chunks = calculateDefaultChunks(shape);
+            chunks = Utils.calculateDefaultChunks(shape);
         }
 
         return new ArrayMetadata(
@@ -168,35 +169,4 @@ public ArrayMetadata build() throws ZarrException {
                 attributes
         );
     }
-    
-    /**
-     * Calculate default chunk shape when not specified.
-     * This implements JZarr's ArrayParams.build() logic, targeting chunks of approximately 512 elements.
-     * 
-     * The algorithm divides each dimension by 512 to determine the number of ~512-sized chunks,
-     * then calculates chunk sizes that will cover the dimension. Note that the total coverage
-     * may slightly exceed the dimension size (e.g., for shape=1024, chunks=342 results in 
-     * 3 chunks covering 1026 elements). This is intentional and matches JZarr behavior - 
-     * Zarr handles out-of-bounds gracefully, and the goal is approximate chunk sizes rather 
-     * than perfect tiling.
-     */
-    private int[] calculateDefaultChunks(long[] shape) {
-        int[] chunks = new int[shape.length];
-        for (int i = 0; i < shape.length; i++) {
-            long shapeDim = shape[i];
-            int numChunks = (int) (shapeDim / 512);
-            if (numChunks > 0) {
-                int chunkDim = (int) (shapeDim / (numChunks + 1));
-                if (shapeDim % chunkDim == 0) {
-                    chunks[i] = chunkDim;
-                } else {
-                    chunks[i] = chunkDim + 1;
-                }
-            } else {
-                // If dimension is smaller than 512, use the full dimension
-                chunks[i] = (int) shapeDim;
-            }
-        }
-        return chunks;
-    }
 }

src/main/java/dev/zarr/zarrjava/v3/ArrayMetadataBuilder.java

@@ -4,6 +4,7 @@
 import dev.zarr.zarrjava.core.Attributes;
 import dev.zarr.zarrjava.core.chunkkeyencoding.Separator;
 import dev.zarr.zarrjava.core.codec.core.BytesCodec.Endian;
+import dev.zarr.zarrjava.utils.Utils;
 import dev.zarr.zarrjava.v3.chunkgrid.ChunkGrid;
 import dev.zarr.zarrjava.v3.chunkgrid.RegularChunkGrid;
 import dev.zarr.zarrjava.v3.chunkkeyencoding.ChunkKeyEncoding;
@@ -164,7 +165,7 @@ public ArrayMetadata build() throws ZarrException {
 
         // If chunk grid is not specified, calculate default chunks
         if (chunkGrid == null) {
-            int[] defaultChunks = calculateDefaultChunks(shape);
+            int[] defaultChunks = Utils.calculateDefaultChunks(shape);
             chunkGrid = new RegularChunkGrid(new RegularChunkGrid.Configuration(defaultChunks));
         }
 
@@ -174,35 +175,4 @@ public ArrayMetadata build() throws ZarrException {
                 storageTransformers
         );
     }
-    
-    /**
-     * Calculate default chunk shape when not specified.
-     * This implements JZarr's ArrayParams.build() logic, targeting chunks of approximately 512 elements.
-     * 
-     * The algorithm divides each dimension by 512 to determine the number of ~512-sized chunks,
-     * then calculates chunk sizes that will cover the dimension. Note that the total coverage
-     * may slightly exceed the dimension size (e.g., for shape=1024, chunks=342 results in 
-     * 3 chunks covering 1026 elements). This is intentional and matches JZarr behavior - 
-     * Zarr handles out-of-bounds gracefully, and the goal is approximate chunk sizes rather 
-     * than perfect tiling.
-     */
-    private int[] calculateDefaultChunks(long[] shape) {
-        int[] chunks = new int[shape.length];
-        for (int i = 0; i < shape.length; i++) {
-            long shapeDim = shape[i];
-            int numChunks = (int) (shapeDim / 512);
-            if (numChunks > 0) {
-                int chunkDim = (int) (shapeDim / (numChunks + 1));
-                if (shapeDim % chunkDim == 0) {
-                    chunks[i] = chunkDim;
-                } else {
-                    chunks[i] = chunkDim + 1;
-                }
-            } else {
-                // If dimension is smaller than 512, use the full dimension
-                chunks[i] = (int) shapeDim;
-            }
-        }
-        return chunks;
-    }
 }