@fideus-labs/ngff-zarr 0.0.1

package/LICENSE

@@ -0,0 +1,10 @@
+MIT License
+
+Copyright (c) 2025-present Fideus Labs LLC <info@fideus.io>
+Copyright (c) 2022-2024 NumFOCUS <info@numfocus.org>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/README.md

@@ -0,0 +1,73 @@
+# ngff-zarr
+
+[![PyPI - Version](https://img.shields.io/pypi/v/ngff-zarr.svg)](https://pypi.org/project/ngff-zarr)
+[![PyPI - Python Version](https://img.shields.io/pypi/pyversions/ngff-zarr.svg)](https://pypi.org/project/ngff-zarr)
+[![Test](https://github.com/thewtex/ngff-zarr/actions/workflows/pixi-test.yml/badge.svg)](https://github.com/thewtex/ngff-zarr/actions/workflows/pixi-test.yml)
+[![DOI](https://zenodo.org/badge/541840158.svg)](https://zenodo.org/badge/latestdoi/541840158)
+[![Documentation Status](https://readthedocs.org/projects/ngff-zarr/badge/?version=latest)](https://ngff-zarr.readthedocs.io/en/latest/?badge=latest)
+
+---
+
+A multi-language implementation of the
+[Open Microscopy Environment (OME) Next Generation File Format (NGFF) Zarr](https://ngff.openmicroscopy.org)
+specification.
+
+## Repository Structure
+
+This repository contains multiple packages implementing NGFF-Zarr support:
+
+- **[`py/`](./py/)** - Python package (ngff-zarr) - A lean and kind NGFF-Zarr
+  implementation
+- **[`mcp/`](./mcp/)** - Model Context Protocol (MCP) server (ngff-zarr-mcp) for
+  AI integration
+- **TypeScript package** - Coming soon
+
+## Python Package (`py/`)
+
+The main Python package provides:
+
+✨ **Features**
+
+- Minimal dependencies
+- Work with arbitrary Zarr store types
+- Lazy, parallel, and web ready -- no local filesystem required
+- Process extremely large datasets
+- Conversion of most bioimaging file formats
+- Multiple downscaling methods
+- Supports Python>=3.9
+- Reads OME-Zarr v0.1 to v0.5 into simple Python data classes with Dask arrays
+- Optional OME-Zarr data model validation during reading
+- Writes OME-Zarr v0.4 to v0.5
+- [Sharded Zarr] stores
+- Optional writing via [tensorstore]
+- **Model Context Protocol (MCP) server** for AI agent integration
+
+📖 **Documentation**
+
+More information about command line usage, the Python API, library features, and
+how to contribute can be found in
+[our documentation](https://ngff-zarr.readthedocs.io/).
+
+## MCP Server (`mcp/`)
+
+The Model Context Protocol server enables AI assistants like Claude to interact
+with NGFF-Zarr files. See the [MCP documentation](./mcp/README.md) for setup and
+usage instructions.
+
+## See also
+
+- [ome-zarr-py](https://github.com/ome/ome-zarr-py)
+- [multiscale-spatial-image](https://github.com/spatial-image/multiscale-spatial-image)
+- [itk-ioomezarrngff](https://github.com/InsightSoftwareConsortium/ITKIOOMEZarrNGFF)
+- [iohub](https://czbiohub-sf.github.io/iohub/)
+- [pydantic-ome-ngff](https://janeliascicomp.github.io/pydantic-ome-ngff/)
+- [aicsimageio](https://allencellmodeling.github.io/aicsimageio/)
+- [bfio](https://bfio.readthedocs.io/)
+
+## License
+
+`ngff-zarr` is distributed under the terms of the
+[MIT](https://spdx.org/licenses/MIT.html) license.
+
+[Sharded Zarr]: https://zarr.dev/zeps/accepted/ZEP0002.html
+[tensorstore]: https://google.github.io/tensorstore/

package/esm/_dnt.shims.d.ts

@@ -0,0 +1,2 @@
+export declare const dntGlobalThis: Omit<typeof globalThis, never>;
+//# sourceMappingURL=_dnt.shims.d.ts.map

package/esm/_dnt.shims.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"_dnt.shims.d.ts","sourceRoot":"","sources":["../src/_dnt.shims.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,aAAa,gCAA2C,CAAC"}

package/esm/_dnt.shims.js

@@ -0,0 +1,57 @@
+const dntGlobals = {};
+export const dntGlobalThis = createMergeProxy(globalThis, dntGlobals);
+function createMergeProxy(baseObj, extObj) {
+    return new Proxy(baseObj, {
+        get(_target, prop, _receiver) {
+            if (prop in extObj) {
+                return extObj[prop];
+            }
+            else {
+                return baseObj[prop];
+            }
+        },
+        set(_target, prop, value) {
+            if (prop in extObj) {
+                delete extObj[prop];
+            }
+            baseObj[prop] = value;
+            return true;
+        },
+        deleteProperty(_target, prop) {
+            let success = false;
+            if (prop in extObj) {
+                delete extObj[prop];
+                success = true;
+            }
+            if (prop in baseObj) {
+                delete baseObj[prop];
+                success = true;
+            }
+            return success;
+        },
+        ownKeys(_target) {
+            const baseKeys = Reflect.ownKeys(baseObj);
+            const extKeys = Reflect.ownKeys(extObj);
+            const extKeysSet = new Set(extKeys);
+            return [...baseKeys.filter((k) => !extKeysSet.has(k)), ...extKeys];
+        },
+        defineProperty(_target, prop, desc) {
+            if (prop in extObj) {
+                delete extObj[prop];
+            }
+            Reflect.defineProperty(baseObj, prop, desc);
+            return true;
+        },
+        getOwnPropertyDescriptor(_target, prop) {
+            if (prop in extObj) {
+                return Reflect.getOwnPropertyDescriptor(extObj, prop);
+            }
+            else {
+                return Reflect.getOwnPropertyDescriptor(baseObj, prop);
+            }
+        },
+        has(_target, prop) {
+            return prop in extObj || prop in baseObj;
+        },
+    });
+}

package/esm/io/from_ngff_zarr.d.ts

@@ -0,0 +1,7 @@
+import { Multiscales } from "../types/multiscales.js";
+export interface FromNgffZarrOptions {
+    validate?: boolean;
+}
+export declare function fromNgffZarr(storePath: string, options?: FromNgffZarrOptions): Promise<Multiscales>;
+export declare function readArrayData(storePath: string, arrayPath: string, selection?: (number | null)[]): Promise<unknown>;
+//# sourceMappingURL=from_ngff_zarr.d.ts.map

package/esm/io/from_ngff_zarr.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"from_ngff_zarr.d.ts","sourceRoot":"","sources":["../../src/io/from_ngff_zarr.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAC;AAOtD,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB;AAED,wBAAsB,YAAY,CAChC,SAAS,EAAE,MAAM,EACjB,OAAO,GAAE,mBAAwB,GAChC,OAAO,CAAC,WAAW,CAAC,CAyItB;AAED,wBAAsB,aAAa,CACjC,SAAS,EAAE,MAAM,EACjB,SAAS,EAAE,MAAM,EACjB,SAAS,CAAC,EAAE,CAAC,MAAM,GAAG,IAAI,CAAC,EAAE,GAC5B,OAAO,CAAC,OAAO,CAAC,CAoBlB"}

package/esm/io/from_ngff_zarr.js

@@ -0,0 +1,140 @@
+import * as dntShim from "../_dnt.shims.js";
+import * as zarr from "zarrita";
+import { Multiscales } from "../types/multiscales.js";
+import { NgffImage } from "../types/ngff_image.js";
+import { LazyArray } from "../types/lazy_array.js";
+import { MetadataSchema } from "../schemas/zarr_metadata.js";
+export async function fromNgffZarr(storePath, options = {}) {
+    const validate = options.validate ?? false;
+    try {
+        // Determine the appropriate store type based on the path
+        let store;
+        if (storePath.startsWith("http://") || storePath.startsWith("https://")) {
+            // Use FetchStore for HTTP/HTTPS URLs
+            store = new zarr.FetchStore(storePath);
+        }
+        else {
+            // For local paths, check if we're in a browser environment
+            if (typeof dntShim.dntGlobalThis !== "undefined") {
+                throw new Error("Local file paths are not supported in browser environments. Use HTTP/HTTPS URLs instead.");
+            }
+            // Use dynamic import for FileSystemStore in Node.js/Deno environments
+            try {
+                const { FileSystemStore } = await import("@zarrita/storage");
+                store = new FileSystemStore(storePath);
+            }
+            catch (error) {
+                throw new Error(`Failed to load FileSystemStore: ${error}. Use HTTP/HTTPS URLs for browser compatibility.`);
+            }
+        }
+        const root = zarr.root(store);
+        // Try to use consolidated metadata for better performance
+        let consolidatedRoot;
+        try {
+            consolidatedRoot = await zarr.tryWithConsolidated(store);
+        }
+        catch {
+            consolidatedRoot = store;
+        }
+        const group = await zarr.open.v2(zarr.root(consolidatedRoot), {
+            kind: "group",
+        });
+        const attrs = group.attrs;
+        if (!attrs || !attrs.multiscales) {
+            throw new Error("No multiscales metadata found in Zarr store");
+        }
+        const multiscalesArray = attrs
+            .multiscales;
+        if (!Array.isArray(multiscalesArray) || multiscalesArray.length === 0) {
+            throw new Error("No multiscales metadata found in Zarr store");
+        }
+        const multiscalesMetadata = multiscalesArray[0];
+        if (validate) {
+            const result = MetadataSchema.safeParse(multiscalesMetadata);
+            if (!result.success) {
+                throw new Error(`Invalid OME-Zarr metadata: ${result.error.message}`);
+            }
+        }
+        const metadata = multiscalesMetadata;
+        // Extract omero metadata from root attributes if present
+        if (attrs.omero) {
+            metadata.omero = attrs.omero;
+        }
+        const images = [];
+        for (const dataset of metadata.datasets) {
+            const arrayPath = dataset.path;
+            const zarrArray = await zarr.open.v2(root.resolve(arrayPath), {
+                kind: "array",
+            });
+            const lazyArray = new LazyArray({
+                shape: zarrArray.shape,
+                dtype: zarrArray.dtype,
+                chunks: [zarrArray.chunks],
+                name: arrayPath,
+            });
+            const scale = {};
+            const translation = {};
+            for (const transform of dataset.coordinateTransformations) {
+                if (transform.type === "scale") {
+                    metadata.axes.forEach((axis, i) => {
+                        if (i < transform.scale.length) {
+                            scale[axis.name] = transform.scale[i];
+                        }
+                    });
+                }
+                else if (transform.type === "translation") {
+                    metadata.axes.forEach((axis, i) => {
+                        if (i < transform.translation.length) {
+                            translation[axis.name] = transform.translation[i];
+                        }
+                    });
+                }
+            }
+            const dims = metadata.axes.map((axis) => axis.name);
+            const axesUnits = metadata.axes.reduce((acc, axis) => {
+                if (axis.unit) {
+                    acc[axis.name] = axis.unit;
+                }
+                return acc;
+            }, {});
+            const ngffImage = new NgffImage({
+                data: lazyArray,
+                dims,
+                scale,
+                translation,
+                name: metadata.name,
+                axesUnits: Object.keys(axesUnits).length > 0 ? axesUnits : undefined,
+                computedCallbacks: undefined,
+            });
+            images.push(ngffImage);
+        }
+        return new Multiscales({
+            images,
+            metadata,
+            scaleFactors: undefined,
+            method: undefined,
+            chunks: undefined,
+        });
+    }
+    catch (error) {
+        throw new Error(`Failed to read OME-Zarr: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+export async function readArrayData(storePath, arrayPath, selection) {
+    try {
+        const store = new zarr.FetchStore(storePath);
+        const root = zarr.root(store);
+        const zarrArray = await zarr.open.v2(root.resolve(arrayPath), {
+            kind: "array",
+        });
+        if (selection) {
+            return await zarr.get(zarrArray, selection);
+        }
+        else {
+            return await zarr.get(zarrArray);
+        }
+    }
+    catch (error) {
+        throw new Error(`Failed to read array data: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}

package/esm/io/to_ngff_zarr.d.ts

@@ -0,0 +1,9 @@
+import type { Multiscales } from "../types/multiscales.js";
+export interface ToNgffZarrOptions {
+    overwrite?: boolean;
+    version?: "0.4" | "0.5";
+    useTensorstore?: boolean;
+    chunksPerShard?: number | number[] | Record<string, number>;
+}
+export declare function toNgffZarr(_storePath: string, _multiscales: Multiscales, options?: ToNgffZarrOptions): Promise<void>;
+//# sourceMappingURL=to_ngff_zarr.d.ts.map

package/esm/io/to_ngff_zarr.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"to_ngff_zarr.d.ts","sourceRoot":"","sources":["../../src/io/to_ngff_zarr.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAC;AAG3D,MAAM,WAAW,iBAAiB;IAChC,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,OAAO,CAAC,EAAE,KAAK,GAAG,KAAK,CAAC;IACxB,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,cAAc,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAC7D;AAED,wBAAgB,UAAU,CACxB,UAAU,EAAE,MAAM,EAClB,YAAY,EAAE,WAAW,EACzB,OAAO,GAAE,iBAAsB,GAC9B,OAAO,CAAC,IAAI,CAAC,CAuBf"}

package/esm/io/to_ngff_zarr.js

@@ -0,0 +1,57 @@
+import * as zarr from "zarrita";
+export function toNgffZarr(_storePath, _multiscales, options = {}) {
+    const _overwrite = options.overwrite ?? true;
+    const _version = options.version ?? "0.4";
+    try {
+        // TODO: Implement using zarrita v0.5.2 API
+        // Example implementation would be:
+        // 1. Create a writable store (e.g., FileSystemStore for local files)
+        // 2. Use zarr.root(store) to create a Location
+        // 3. Use zarr.create(root, { attributes: { multiscales: [...] } }) to create group
+        // 4. For each image, use zarr.create(root.resolve(path), { shape, data_type, chunk_shape })
+        // 5. Use zarr.set() to write actual data
+        throw new Error("Writing OME-Zarr files is not yet fully implemented with zarrita v0.5.2");
+    }
+    catch (error) {
+        throw new Error(`Failed to write OME-Zarr: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+async function _writeImage(group, image, arrayPath) {
+    try {
+        const chunks = getChunksFromImage(image);
+        // TODO: Update to use zarrita v0.5.2 API properly
+        // The new API would use:
+        // const location = (group as { resolve: (path: string) => Location }).resolve(arrayPath);
+        // const zarrArray = await zarr.create(location, { ... });
+        // Then use zarr.set(zarrArray, data, selection) to write data
+        const resolvedPath = group.resolve(arrayPath);
+        // @ts-ignore - zarrita API types are complex, this is a temporary workaround
+        const _zarrArray = await zarr.create(resolvedPath, {
+            shape: image.data.shape,
+            data_type: image.data.dtype,
+            chunk_shape: chunks,
+            fill_value: 0,
+        });
+        // Note: With zarrita v0.5.2, attributes can be set during creation
+        // or updated using the store's set method for metadata files
+    }
+    catch (error) {
+        throw new Error(`Failed to write image array: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+function getChunksFromImage(image) {
+    if (image.data.chunks.length > 0 && image.data.chunks[0].length > 0) {
+        return image.data.chunks[0];
+    }
+    return image.data.shape.map((dim) => Math.min(dim, 1024));
+}
+function _writeArrayData(_storePath, _arrayPath, _data, _selection) {
+    try {
+        // Note: zarrita doesn't have a direct set method for arrays
+        // This would need to be implemented differently
+        throw new Error("Writing array data not yet implemented with zarrita");
+    }
+    catch (error) {
+        throw new Error(`Failed to write array data: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}

package/esm/mod.d.ts

@@ -0,0 +1,17 @@
+export * from "./types/units.js";
+export * from "./types/methods.js";
+export * from "./types/lazy_array.js";
+export * from "./types/zarr_metadata.js";
+export * from "./types/ngff_image.js";
+export * from "./types/multiscales.js";
+export * from "./schemas/units.js";
+export * from "./schemas/methods.js";
+export * from "./schemas/lazy_array.js";
+export * from "./schemas/zarr_metadata.js";
+export * from "./schemas/ngff_image.js";
+export * from "./schemas/multiscales.js";
+export { isValidDimension, isValidUnit, validateMetadata, } from "./utils/validation.js";
+export { createAxis, createDataset, createMetadata, createMultiscales, createNgffImage, } from "./utils/factory.js";
+export * from "./io/from_ngff_zarr.js";
+export * from "./io/to_ngff_zarr.js";
+//# sourceMappingURL=mod.d.ts.map

package/esm/mod.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mod.d.ts","sourceRoot":"","sources":["../src/mod.ts"],"names":[],"mappings":"AAAA,cAAc,kBAAkB,CAAC;AACjC,cAAc,oBAAoB,CAAC;AACnC,cAAc,uBAAuB,CAAC;AACtC,cAAc,0BAA0B,CAAC;AACzC,cAAc,uBAAuB,CAAC;AACtC,cAAc,wBAAwB,CAAC;AAEvC,cAAc,oBAAoB,CAAC;AACnC,cAAc,sBAAsB,CAAC;AACrC,cAAc,yBAAyB,CAAC;AACxC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,yBAAyB,CAAC;AACxC,cAAc,0BAA0B,CAAC;AAEzC,OAAO,EACL,gBAAgB,EAChB,WAAW,EACX,gBAAgB,GACjB,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EACL,UAAU,EACV,aAAa,EACb,cAAc,EACd,iBAAiB,EACjB,eAAe,GAChB,MAAM,oBAAoB,CAAC;AAE5B,cAAc,wBAAwB,CAAC;AACvC,cAAc,sBAAsB,CAAC"}

package/esm/mod.js

@@ -0,0 +1,16 @@
+export * from "./types/units.js";
+export * from "./types/methods.js";
+export * from "./types/lazy_array.js";
+export * from "./types/zarr_metadata.js";
+export * from "./types/ngff_image.js";
+export * from "./types/multiscales.js";
+export * from "./schemas/units.js";
+export * from "./schemas/methods.js";
+export * from "./schemas/lazy_array.js";
+export * from "./schemas/zarr_metadata.js";
+export * from "./schemas/ngff_image.js";
+export * from "./schemas/multiscales.js";
+export { isValidDimension, isValidUnit, validateMetadata, } from "./utils/validation.js";
+export { createAxis, createDataset, createMetadata, createMultiscales, createNgffImage, } from "./utils/factory.js";
+export * from "./io/from_ngff_zarr.js";
+export * from "./io/to_ngff_zarr.js";

package/esm/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "module"
+}

package/esm/schemas/lazy_array.d.ts

@@ -0,0 +1,8 @@
+import { z } from "zod";
+export declare const LazyArrayMetadataSchema: z.ZodObject<{
+    shape: z.ZodArray<z.ZodNumber>;
+    dtype: z.ZodString;
+    chunks: z.ZodArray<z.ZodArray<z.ZodNumber>>;
+    name: z.ZodString;
+}>;
+//# sourceMappingURL=lazy_array.d.ts.map

package/esm/schemas/lazy_array.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lazy_array.d.ts","sourceRoot":"","sources":["../../src/schemas/lazy_array.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,uBAAuB,EAAE,CAAC,CAAC,SAAS,CAAC;IAChD,KAAK,EAAE,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC;IAC/B,KAAK,EAAE,CAAC,CAAC,SAAS,CAAC;IACnB,MAAM,EAAE,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC;IAC5C,IAAI,EAAE,CAAC,CAAC,SAAS,CAAC;CACnB,CAKC,CAAC"}

package/esm/schemas/lazy_array.js

@@ -0,0 +1,7 @@
+import { z } from "zod";
+export const LazyArrayMetadataSchema = z.object({
+    shape: z.array(z.number().int().nonnegative()),
+    dtype: z.string(),
+    chunks: z.array(z.array(z.number().int().nonnegative())),
+    name: z.string(),
+});

package/esm/schemas/methods.d.ts

@@ -0,0 +1,3 @@
+import { z } from "zod";
+export declare const MethodsSchema: z.ZodTypeAny;
+//# sourceMappingURL=methods.d.ts.map

package/esm/schemas/methods.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"methods.d.ts","sourceRoot":"","sources":["../../src/schemas/methods.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,aAAa,EAAE,CAAC,CAAC,UAI5B,CAAC"}

package/esm/schemas/methods.js

@@ -0,0 +1,6 @@
+import { z } from "zod";
+export const MethodsSchema = z.enum([
+    "itkwasm_gaussian",
+    "itkwasm_bin_shrink",
+    "itkwasm_label_image",
+]);

package/esm/schemas/multiscales.d.ts

@@ -0,0 +1,4 @@
+import { z } from "zod";
+export declare const ChunkSpecSchema: z.ZodTypeAny;
+export declare const MultiscalesOptionsSchema: z.ZodTypeAny;
+//# sourceMappingURL=multiscales.d.ts.map

package/esm/schemas/multiscales.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"multiscales.d.ts","sourceRoot":"","sources":["../../src/schemas/multiscales.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAKxB,eAAO,MAAM,eAAe,EAAE,CAAC,CAAC,UAK9B,CAAC;AAEH,eAAO,MAAM,wBAAwB,EAAE,CAAC,CAAC,UAQvC,CAAC"}

package/esm/schemas/multiscales.js

@@ -0,0 +1,19 @@
+import { z } from "zod";
+import { NgffImageOptionsSchema } from "./ngff_image.js";
+import { MetadataSchema } from "./zarr_metadata.js";
+import { MethodsSchema } from "./methods.js";
+export const ChunkSpecSchema = z.union([
+    z.number(),
+    z.array(z.number()),
+    z.array(z.array(z.number())),
+    z.record(z.string(), z.union([z.number(), z.array(z.number())]).optional()),
+]);
+export const MultiscalesOptionsSchema = z.object({
+    images: z.array(NgffImageOptionsSchema),
+    metadata: MetadataSchema,
+    scaleFactors: z
+        .array(z.union([z.record(z.string(), z.number()), z.number()]))
+        .optional(),
+    method: MethodsSchema.optional(),
+    chunks: ChunkSpecSchema.optional(),
+});

package/esm/schemas/ngff_image.d.ts

@@ -0,0 +1,13 @@
+import { z } from "zod";
+import { UnitsSchema } from "./units.js";
+import { LazyArrayMetadataSchema } from "./lazy_array.js";
+export declare const NgffImageOptionsSchema: z.ZodObject<{
+    data: typeof LazyArrayMetadataSchema;
+    dims: z.ZodArray<z.ZodString>;
+    scale: z.ZodRecord<z.ZodString, z.ZodNumber>;
+    translation: z.ZodRecord<z.ZodString, z.ZodNumber>;
+    name: z.ZodDefault<z.ZodString>;
+    axesUnits: z.ZodOptional<z.ZodRecord<z.ZodString, typeof UnitsSchema>>;
+    computedCallbacks: z.ZodDefault<z.ZodArray<z.ZodAny>>;
+}>;
+//# sourceMappingURL=ngff_image.d.ts.map

package/esm/schemas/ngff_image.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ngff_image.d.ts","sourceRoot":"","sources":["../../src/schemas/ngff_image.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AACzC,OAAO,EAAE,uBAAuB,EAAE,MAAM,iBAAiB,CAAC;AAE1D,eAAO,MAAM,sBAAsB,EAAE,CAAC,CAAC,SAAS,CAAC;IAC/C,IAAI,EAAE,OAAO,uBAAuB,CAAC;IACrC,IAAI,EAAE,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC;IAC9B,KAAK,EAAE,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,SAAS,EAAE,CAAC,CAAC,SAAS,CAAC,CAAC;IAC7C,WAAW,EAAE,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,SAAS,EAAE,CAAC,CAAC,SAAS,CAAC,CAAC;IACnD,IAAI,EAAE,CAAC,CAAC,UAAU,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC;IAChC,SAAS,EAAE,CAAC,CAAC,WAAW,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,SAAS,EAAE,OAAO,WAAW,CAAC,CAAC,CAAC;IACvE,iBAAiB,EAAE,CAAC,CAAC,UAAU,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC;CACvD,CAQC,CAAC"}

package/esm/schemas/ngff_image.js

@@ -0,0 +1,12 @@
+import { z } from "zod";
+import { UnitsSchema } from "./units.js";
+import { LazyArrayMetadataSchema } from "./lazy_array.js";
+export const NgffImageOptionsSchema = z.object({
+    data: LazyArrayMetadataSchema,
+    dims: z.array(z.string()),
+    scale: z.record(z.string(), z.number()),
+    translation: z.record(z.string(), z.number()),
+    name: z.string().default("image"),
+    axesUnits: z.record(z.string(), UnitsSchema).optional(),
+    computedCallbacks: z.array(z.any()).default([]),
+});

package/esm/schemas/units.d.ts

@@ -0,0 +1,13 @@
+import { z } from "zod";
+export declare const SupportedDimsSchema: z.ZodTypeAny;
+export declare const SpatialDimsSchema: z.ZodTypeAny;
+export declare const AxesTypeSchema: z.ZodTypeAny;
+export declare const SpaceUnitsSchema: z.ZodTypeAny;
+export declare const TimeUnitsSchema: z.ZodTypeAny;
+export declare const UnitsSchema: z.ZodUnion<[
+    typeof SpaceUnitsSchema,
+    typeof TimeUnitsSchema
+]>;
+export declare const dimensionValidator: z.ZodTypeAny;
+export declare const unitValidator: z.ZodTypeAny;
+//# sourceMappingURL=units.d.ts.map

package/esm/schemas/units.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"units.d.ts","sourceRoot":"","sources":["../../src/schemas/units.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AASxB,eAAO,MAAM,mBAAmB,EAAE,CAAC,CAAC,UAMlC,CAAC;AAEH,eAAO,MAAM,iBAAiB,EAAE,CAAC,CAAC,UAAoC,CAAC;AAEvE,eAAO,MAAM,cAAc,EAAE,CAAC,CAAC,UAI7B,CAAC;AAEH,eAAO,MAAM,gBAAgB,EAAE,CAAC,CAAC,UA2B/B,CAAC;AAEH,eAAO,MAAM,eAAe,EAAE,CAAC,CAAC,UAwB9B,CAAC;AAEH,eAAO,MAAM,WAAW,EAAE,CAAC,CAAC,QAAQ,CAClC;IAAC,OAAO,gBAAgB;IAAE,OAAO,eAAe;CAAC,CACH,CAAC;AAEjD,eAAO,MAAM,kBAAkB,EAAE,CAAC,CAAC,UAKhC,CAAC;AAEJ,eAAO,MAAM,aAAa,EAAE,CAAC,CAAC,UAM3B,CAAC"}

package/esm/schemas/units.js

@@ -0,0 +1,75 @@
+import { z } from "zod";
+import { spaceUnits, supportedDims, timeUnits, } from "../types/units.js";
+export const SupportedDimsSchema = z.enum([
+    "c",
+    "x",
+    "y",
+    "z",
+    "t",
+]);
+export const SpatialDimsSchema = z.enum(["x", "y", "z"]);
+export const AxesTypeSchema = z.enum([
+    "time",
+    "space",
+    "channel",
+]);
+export const SpaceUnitsSchema = z.enum([
+    "angstrom",
+    "attometer",
+    "centimeter",
+    "decimeter",
+    "exameter",
+    "femtometer",
+    "foot",
+    "gigameter",
+    "hectometer",
+    "inch",
+    "kilometer",
+    "megameter",
+    "meter",
+    "micrometer",
+    "mile",
+    "millimeter",
+    "nanometer",
+    "parsec",
+    "petameter",
+    "picometer",
+    "terameter",
+    "yard",
+    "yoctometer",
+    "yottameter",
+    "zeptometer",
+    "zettameter",
+]);
+export const TimeUnitsSchema = z.enum([
+    "attosecond",
+    "centisecond",
+    "day",
+    "decisecond",
+    "exasecond",
+    "femtosecond",
+    "gigasecond",
+    "hectosecond",
+    "hour",
+    "kilosecond",
+    "megasecond",
+    "microsecond",
+    "millisecond",
+    "minute",
+    "nanosecond",
+    "petasecond",
+    "picosecond",
+    "second",
+    "terasecond",
+    "yoctosecond",
+    "yottasecond",
+    "zeptosecond",
+    "zettasecond",
+]);
+export const UnitsSchema = z.union([SpaceUnitsSchema, TimeUnitsSchema]);
+export const dimensionValidator = z
+    .string()
+    .refine((dim) => supportedDims.includes(dim), { message: "Dimension must be one of: c, x, y, z, t" });
+export const unitValidator = z
+    .string()
+    .refine((unit) => [...timeUnits, ...spaceUnits].includes(unit), { message: "Unit must be a valid time or space unit" });