Rename internal snake_case identifiers to camelCase (#387)

* Rename internal snake_case identifiers to camelCase

The codebase inherited Python-style snake_case naming from zarr-python,
which created confusion about what is a zarr metadata field versus an
internal API. This change draws a clear boundary: zarr metadata types
(`ArrayMetadata`, `GroupMetadata`, `CodecMetadata`, etc.) retain
snake_case because they represent the on-disk JSON format, while all
internal function names, variable names, and interface properties use
idiomatic TypeScript camelCase.

The most visible breaking change is `CreateArrayOptions`, whose
properties move to camelCase:

    await zarr.create(store, {
      shape: [100, 100],
      chunkShape: [10, 10],   // was chunk_shape
      dataType: "float32",    // was data_type
      fillValue: 0,           // was fill_value
    })

Internal exports consumed by `@zarrita/ndarray` are also renamed
(`_zarrita_internal_getStrides`, `_zarrita_internal_sliceIndices`), and
the `Setter` type properties become `setScalar`/`setFromChunk`.

* Use camelCase for create options

CreateArrayOptions properties are now camelCase (chunkShape, fillValue,
chunkSeparator, dimensionNames). Array getters keep dtype and chunks to
match zarr-python.

Author: manzt

.changeset/camelcase-internals.md

@@ -0,0 +1,15 @@
+---
+"zarrita": minor
+---
+
+**BREAKING**: `zarr.create` options now use camelCase (`chunkShape`, `fillValue`, `chunkSeparator`, `dimensionNames`).
+
+```ts
+await zarr.create(store, {
+  dtype: "float32",            // was data_type
+  shape: [100, 100],
+  chunkShape: [10, 10],        // was chunk_shape
+  fillValue: 0,                // was fill_value
+  dimensionNames: ["y", "x"],  // was dimension_names
+})
+```

docs/cookbook.md

@@ -66,9 +66,9 @@ import { FileSystemStore } from "@zarrita/storage";
 
 const store = new FileSystemStore("tempstore");
 const arr = await zarr.create(store, {
-	shape: [10, 10],
-	chunks: [5, 5],
 	dtype: "int32",
+	shape: [10, 10],
+	chunkShape: [5, 5],
 });
 arr; // zarr.Array<"int32", FileSystemStore>
 ```

docs/packages/zarrita.md

@@ -145,9 +145,9 @@ import * as zarr from "zarrita";
 let root = zarr.root(new Map());
 let grp = await zarr.create(root);
 let arr = await zarr.create(root.resolve("foo"), {
-	data_type: "int32",
+	dtype: "int32",
 	shape: [4, 4],
-	chunk_shape: [2, 2],
+	chunkShape: [2, 2],
 });
 console.log(root.store);
 // Map(2) {
@@ -236,9 +236,10 @@ system correctly infers that the value of chunk `data` is a `BigInt64Array`:
 
 ```javascript
 let arr = await zarr.create(root.resolve("foo"), {
-	data_type: "int64",
+	dtype: "int64",
 	shape: [4, 4],
-	chunk_shape: [2, 2],
+	chunkShape: [2, 2],
+	dimensionNames: ["x", "y"],
 });
 let chunk = await arr.getChunk([0, 0]);
 // ^ Chunk<"int64">

packages/@zarrita-ndarray/__tests__/setter.test.ts

@@ -2,10 +2,10 @@ import ndarray, { type TypedArray } from "ndarray";
 import { assign } from "ndarray-ops";
 import { describe, expect, it } from "vitest";
 import {
-	_zarrita_internal_get_strides as get_strides,
+	_zarrita_internal_getStrides as get_strides,
 	type Projection,
 	slice,
-	_zarrita_internal_slice_indices as slice_indices,
+	_zarrita_internal_sliceIndices as slice_indices,
 } from "zarrita";
 
 import { _internal_setter } from "../src/index.js";
@@ -23,15 +23,15 @@ function to_c<T extends TypedArray>({
 }
 
 describe("setter", () => {
-	it("setter.set_scalar - fill", async () => {
+	it("setter.setScalar - fill", async () => {
 		let a = _internal_setter.prepare(
 			new Float32Array(2 * 3 * 4),
 			[2, 3, 4],
 			get_strides([2, 3, 4], "C"),
 		);
 
 		let sel = [2, 3, 4].map((size) => slice_indices(slice(null), size));
-		_internal_setter.set_scalar(a, sel, 1);
+		_internal_setter.setScalar(a, sel, 1);
 		// biome-ignore format: the array should not be formatted
 		expect(a.data).toStrictEqual(new Float32Array([
 			1, 1, 1, 1,
@@ -44,14 +44,14 @@ describe("setter", () => {
 		]));
 	});
 
-	it("setter.set_scalar - point", async () => {
+	it("setter.setScalar - point", async () => {
 		let a = _internal_setter.prepare(
 			new Float32Array(2 * 3 * 4),
 			[2, 3, 4],
 			get_strides([2, 3, 4], "C"),
 		);
 
-		_internal_setter.set_scalar(a, [0, 0, 0], 1);
+		_internal_setter.setScalar(a, [0, 0, 0], 1);
 		// biome-ignore format: the array should not be formatted
 		expect(a.data).toStrictEqual(new Float32Array([
 			1, 0, 0, 0,
@@ -63,7 +63,7 @@ describe("setter", () => {
 			0, 0, 0, 0,
 		]));
 
-		_internal_setter.set_scalar(a, [1, 1, 1], 2);
+		_internal_setter.setScalar(a, [1, 1, 1], 2);
 		// biome-ignore format: the array should not be formatted
 		expect(a.data).toStrictEqual(new Float32Array([
 			1, 0, 0, 0,
@@ -75,7 +75,7 @@ describe("setter", () => {
 			0, 0, 0, 0,
 		]));
 
-		_internal_setter.set_scalar(a, [1, 2, 3], 3);
+		_internal_setter.setScalar(a, [1, 2, 3], 3);
 		// biome-ignore format: the array should not be formatted
 		expect(a.data).toStrictEqual(new Float32Array([
 			1, 0, 0, 0,
@@ -87,7 +87,7 @@ describe("setter", () => {
 			0, 0, 0, 3,
 		]));
 
-		_internal_setter.set_scalar(a, [1, 2, 2], 4);
+		_internal_setter.setScalar(a, [1, 2, 2], 4);
 		// biome-ignore format: the array should not be formatted
 		expect(a.data).toStrictEqual(new Float32Array([
 			1, 0, 0, 0,
@@ -100,15 +100,15 @@ describe("setter", () => {
 		]));
 	});
 
-	it("setter.set_scalar - mixed", async () => {
+	it("setter.setScalar - mixed", async () => {
 		let a = _internal_setter.prepare(
 			new Float32Array(2 * 3 * 4),
 			[2, 3, 4],
 			get_strides([2, 3, 4], "C"),
 		);
 
 		let sel = [slice_indices(slice(null), 2), slice_indices(slice(2), 3), 0];
-		_internal_setter.set_scalar(a, sel, 1);
+		_internal_setter.setScalar(a, sel, 1);
 		// biome-ignore format: the array should not be formatted
 		expect(a.data).toStrictEqual(new Float32Array([
 			1, 0, 0, 0,
@@ -121,7 +121,7 @@ describe("setter", () => {
 		]));
 
 		sel = [0, slice_indices(slice(null), 3), slice_indices(slice(null), 4)];
-		_internal_setter.set_scalar(a, sel, 2);
+		_internal_setter.setScalar(a, sel, 2);
 
 		// biome-ignore format: the array should not be formatted
 		expect(a.data).toStrictEqual(new Float32Array([
@@ -135,15 +135,15 @@ describe("setter", () => {
 		]));
 	});
 
-	it("setter.set_scalar - mixed F order", async () => {
+	it("setter.setScalar - mixed F order", async () => {
 		let f = _internal_setter.prepare<"float32">(
 			new Float32Array(2 * 3 * 4),
 			[2, 3, 4],
 			get_strides([2, 3, 4], "F"),
 		);
 
 		let sel = [slice_indices(slice(null), 2), slice_indices(slice(2), 3), 0];
-		_internal_setter.set_scalar(f, sel, 1);
+		_internal_setter.setScalar(f, sel, 1);
 		// biome-ignore format: the array should not be formatted
 		expect(f.data).toStrictEqual(new Float32Array([
 			1, 1, 1, 1, 0, 0,
@@ -153,7 +153,7 @@ describe("setter", () => {
 		]));
 
 		sel = [0, slice_indices(slice(null), 3), slice_indices(slice(null), 4)];
-		_internal_setter.set_scalar(f, sel, 2);
+		_internal_setter.setScalar(f, sel, 2);
 
 		// biome-ignore format: the array should not be formatted
 		expect(f.data).toStrictEqual(new Float32Array([
@@ -175,7 +175,7 @@ describe("setter", () => {
 		]));
 	});
 
-	it("set_from_chunk - complete", async () => {
+	it("setFromChunk - complete", async () => {
 		let dest = _internal_setter.prepare(
 			new Float32Array(2 * 3 * 4),
 			[2, 3, 4],
@@ -194,7 +194,7 @@ describe("setter", () => {
 			{ from: [0, 2, 1], to: [0, 2, 1] },
 		];
 
-		_internal_setter.set_from_chunk(dest, src, mapping);
+		_internal_setter.setFromChunk(dest, src, mapping);
 		// biome-ignore format: the array should not be formatted
 		expect(dest.data).toStrictEqual(new Float32Array([
 			1, 1, 0, 0,
@@ -207,7 +207,7 @@ describe("setter", () => {
 		]));
 	});
 
-	it("set_from_chunk - from complete to strided", async () => {
+	it("setFromChunk - from complete to strided", async () => {
 		let dest = _internal_setter.prepare(
 			new Float32Array(2 * 3 * 4),
 			[2, 3, 4],
@@ -226,7 +226,7 @@ describe("setter", () => {
 			{ from: [0, 2, 1], to: [0, 4, 2] },
 		];
 
-		_internal_setter.set_from_chunk(dest, src, mapping);
+		_internal_setter.setFromChunk(dest, src, mapping);
 		// biome-ignore format: the array should not be formatted
 		expect(dest.data).toStrictEqual(new Float32Array([
 			2, 0, 2, 0,
@@ -239,7 +239,7 @@ describe("setter", () => {
 		]));
 	});
 
-	it("set_from_chunk - from strided to complete", async () => {
+	it("setFromChunk - from strided to complete", async () => {
 		let dest = _internal_setter.prepare(
 			new Float32Array(2 * 2 * 2),
 			[2, 2, 2],
@@ -267,11 +267,11 @@ describe("setter", () => {
 			{ to: [0, 2, 1], from: [0, 4, 2] },
 		];
 
-		_internal_setter.set_from_chunk(dest, src, mapping);
+		_internal_setter.setFromChunk(dest, src, mapping);
 		expect(dest.data).toStrictEqual(new Float32Array(2 * 2 * 2).fill(2));
 	});
 
-	it("set_from_chunk - src squeezed", async () => {
+	it("setFromChunk - src squeezed", async () => {
 		let dest = _internal_setter.prepare(
 			new Float32Array(2 * 3 * 4),
 			[2, 3, 4],
@@ -290,7 +290,7 @@ describe("setter", () => {
 			{ to: 1, from: null },
 		];
 
-		_internal_setter.set_from_chunk(dest, src, mapping);
+		_internal_setter.setFromChunk(dest, src, mapping);
 		// biome-ignore format: the array should not be formatted
 		expect(dest.data).toStrictEqual(new Float32Array([
 			0, 2, 0, 0,
@@ -303,7 +303,7 @@ describe("setter", () => {
 		]));
 	});
 
-	it("set_from_chunk - dest squeezed", async () => {
+	it("setFromChunk - dest squeezed", async () => {
 		let dest = _internal_setter.prepare(
 			new Float32Array(4),
 			[4],
@@ -331,11 +331,11 @@ describe("setter", () => {
 			{ from: 1, to: null },
 		];
 
-		_internal_setter.set_from_chunk(dest, src, mapping);
+		_internal_setter.setFromChunk(dest, src, mapping);
 		expect(dest.data).toStrictEqual(new Float32Array([2, 0, 0, 2]));
 	});
 
-	it("set_from_chunk - complete F order", async () => {
+	it("setFromChunk - complete F order", async () => {
 		let dest = _internal_setter.prepare<"float32">(
 			new Float32Array(2 * 3 * 4),
 			[2, 3, 4],
@@ -354,7 +354,7 @@ describe("setter", () => {
 			{ from: [0, 2, 1], to: [0, 2, 1] },
 		];
 
-		_internal_setter.set_from_chunk(dest, src, mapping);
+		_internal_setter.setFromChunk(dest, src, mapping);
 		// biome-ignore format: the array should not be formatted
 		expect(to_c(dest).data).toStrictEqual(new Float32Array([
 			1, 1, 0, 0,
@@ -367,7 +367,7 @@ describe("setter", () => {
 		]));
 	});
 
-	it("set_from_chunk - F order", async () => {
+	it("setFromChunk - F order", async () => {
 		let dest = _internal_setter.prepare<"float32">(
 			new Float32Array(2 * 3 * 4),
 			[2, 3, 4],
@@ -386,7 +386,7 @@ describe("setter", () => {
 			{ to: 1, from: null },
 		];
 
-		_internal_setter.set_from_chunk(dest, src, mapping);
+		_internal_setter.setFromChunk(dest, src, mapping);
 		// biome-ignore format: the array should not be formatted
 		expect(to_c(dest).data).toStrictEqual(new Float32Array([
 			0, 2, 0, 0,
@@ -399,7 +399,7 @@ describe("setter", () => {
 		]));
 	});
 
-	it("set_from_chunk - dest=F order, src=C order", async () => {
+	it("setFromChunk - dest=F order, src=C order", async () => {
 		let dest = _internal_setter.prepare<"float32">(
 			new Float32Array(2 * 3 * 4),
 			[2, 3, 4],
@@ -418,7 +418,7 @@ describe("setter", () => {
 			{ to: 1, from: null },
 		];
 
-		_internal_setter.set_from_chunk(dest, src, mapping);
+		_internal_setter.setFromChunk(dest, src, mapping);
 		// biome-ignore format: the array should not be formatted
 		expect(to_c(dest).data).toStrictEqual(new Float32Array([
 			0, 2, 0, 0,
@@ -431,7 +431,7 @@ describe("setter", () => {
 		]));
 	});
 
-	it("set_from_chunk - dest=C order, src=F order", async () => {
+	it("setFromChunk - dest=C order, src=F order", async () => {
 		let dest = _internal_setter.prepare<"float32">(
 			new Float32Array(2 * 3 * 4),
 			[2, 3, 4],
@@ -450,7 +450,7 @@ describe("setter", () => {
 			{ to: 1, from: null },
 		];
 
-		_internal_setter.set_from_chunk(dest, src, mapping);
+		_internal_setter.setFromChunk(dest, src, mapping);
 		// biome-ignore format: the array should not be formatted
 		expect(dest.data).toStrictEqual(new Float32Array([
 			0, 2, 0, 0,

packages/@zarrita-ndarray/__tests__/slice.test.ts

@@ -14,8 +14,8 @@ const DATA = {
 describe("builtin slice", async () => {
 	let arr = await create(new Map(), {
 		shape: [2, 3, 4],
-		data_type: "int32",
-		chunk_shape: [1, 2, 2],
+		dtype: "int32",
+		chunkShape: [1, 2, 2],
 	});
 	await set(arr, null, ndarray(DATA.data, DATA.shape, DATA.stride));
 

packages/@zarrita-ndarray/src/index.ts

@@ -11,32 +11,32 @@ export const _internal_setter: {
 		shape: number[],
 		stride: number[],
 	) => ndarray.NdArray<zarr.TypedArray<D>>;
-	set_scalar: <D extends zarr.DataType>(
+	setScalar: <D extends zarr.DataType>(
 		target: ndarray.NdArray<zarr.TypedArray<D>>,
 		selection: (zarr.Indices | number)[],
 		value: zarr.Scalar<D>,
 	) => void;
-	set_from_chunk: <D extends zarr.DataType>(
+	setFromChunk: <D extends zarr.DataType>(
 		a: ndarray.NdArray<zarr.TypedArray<D>>,
 		b: ndarray.NdArray<zarr.TypedArray<D>>,
 		proj: zarr.Projection[],
 	) => void;
 } = {
 	prepare: ndarray,
-	set_scalar<D extends zarr.DataType>(
+	setScalar<D extends zarr.DataType>(
 		dest: ndarray.NdArray<zarr.TypedArray<D>>,
 		selection: (number | zarr.Indices)[],
 		value: zarr.Scalar<D>,
 	) {
 		// @ts-expect-error - ndarray-ops types are incorrect
 		ops.assigns(view(dest, selection), value);
 	},
-	set_from_chunk<D extends zarr.DataType>(
+	setFromChunk<D extends zarr.DataType>(
 		dest: ndarray.NdArray<zarr.TypedArray<D>>,
 		src: ndarray.NdArray<zarr.TypedArray<D>>,
 		mapping: zarr.Projection[],
 	) {
-		const s = unzip_selections(mapping);
+		const s = unzipSelections(mapping);
 		ops.assign(view(dest, s.to), view(src, s.from));
 	},
 };
@@ -81,7 +81,7 @@ export async function set<D extends zarr.DataType>(
 	);
 }
 
-function unzip_selections(mapping: zarr.Projection[]): {
+function unzipSelections(mapping: zarr.Projection[]): {
 	to: (number | zarr.Indices)[];
 	from: (number | zarr.Indices)[];
 } {