refactor(ts): rename DaskArray to LazyArray

Author: thewtex

ts/src/io/zarr_reader.ts

@@ -2,7 +2,7 @@ import * as zarr from "zarrita";
 import { Multiscales } from "../types/multiscales.ts";
 import { NgffImage } from "../types/ngff_image.ts";
 import type { Metadata } from "../types/zarr_metadata.ts";
-import { DaskArray } from "../types/dask_array.ts";
+import { LazyArray } from "../types/lazy_array.ts";
 import { MetadataSchema } from "../schemas/zarr_metadata.ts";
 
 export interface ZarrReaderOptions {
@@ -18,37 +18,38 @@ export class ZarrReader {
 
   async fromNgffZarr(
     storePath: string,
-    options: ZarrReaderOptions = {},
+    options: ZarrReaderOptions = {}
   ): Promise<Multiscales> {
     const validate = options.validate ?? this.validate;
 
     try {
       const store = new zarr.FetchStore(storePath);
       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(zarr.root(consolidatedRoot), { kind: "group" });
+
+      const group = await zarr.open(zarr.root(consolidatedRoot), {
+        kind: "group",
+      });
       const attrs = group.attrs as unknown;
 
       if (!attrs || !(attrs as Record<string, unknown>).multiscales) {
         throw new Error("No multiscales metadata found in Zarr store");
       }
 
-      const multiscalesMetadata = (attrs as Record<string, unknown>).multiscales?.[0] as unknown;
+      const multiscalesMetadata = (attrs as Record<string, unknown>)
+        .multiscales?.[0] as unknown;
 
       if (validate) {
         const result = MetadataSchema.safeParse(multiscalesMetadata);
         if (!result.success) {
-          throw new Error(
-            `Invalid OME-Zarr metadata: ${result.error.message}`,
-          );
+          throw new Error(`Invalid OME-Zarr metadata: ${result.error.message}`);
         }
       }
 
@@ -61,7 +62,7 @@ export class ZarrReader {
           kind: "array",
         });
 
-        const daskArray = new DaskArray({
+        const lazyArray = new LazyArray({
           shape: zarrArray.shape,
           dtype: zarrArray.dtype,
           chunks: [zarrArray.chunks],
@@ -96,7 +97,7 @@ export class ZarrReader {
         }, {} as Record<string, string>);
 
         const ngffImage = new NgffImage({
-          data: daskArray,
+          data: lazyArray,
           dims,
           scale,
           translation,
@@ -119,15 +120,15 @@ export class ZarrReader {
       throw new Error(
         `Failed to read OME-Zarr: ${
           error instanceof Error ? error.message : String(error)
-        }`,
+        }`
       );
     }
   }
 
   async readArrayData(
     storePath: string,
     arrayPath: string,
-    selection?: unknown[],
+    selection?: unknown[]
   ): Promise<unknown> {
     try {
       const store = new zarr.FetchStore(storePath);
@@ -145,7 +146,7 @@ export class ZarrReader {
       throw new Error(
         `Failed to read array data: ${
           error instanceof Error ? error.message : String(error)
-        }`,
+        }`
       );
     }
   }

ts/src/mod.ts

@@ -1,13 +1,13 @@
 export * from "./types/units.ts";
 export * from "./types/methods.ts";
-export * from "./types/dask_array.ts";
+export * from "./types/lazy_array.ts";
 export * from "./types/zarr_metadata.ts";
 export * from "./types/ngff_image.ts";
 export * from "./types/multiscales.ts";
 
 export * from "./schemas/units.ts";
 export * from "./schemas/methods.ts";
-export * from "./schemas/dask_array.ts";
+export * from "./schemas/lazy_array.ts";
 export * from "./schemas/zarr_metadata.ts";
 export * from "./schemas/ngff_image.ts";
 export * from "./schemas/multiscales.ts";

ts/src/schemas/dask_array.ts renamed to ts/src/schemas/lazy_array.ts

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

ts/src/schemas/ngff_image.ts

@@ -1,9 +1,9 @@
 import { z } from "zod";
 import { UnitsSchema } from "./units.ts";
-import { DaskArrayMetadataSchema } from "./dask_array.ts";
+import { LazyArrayMetadataSchema } from "./lazy_array.ts";
 
 export const NgffImageOptionsSchema = z.object({
-  data: DaskArrayMetadataSchema,
+  data: LazyArrayMetadataSchema,
   dims: z.array(z.string()),
   scale: z.record(z.string(), z.number()),
   translation: z.record(z.string(), z.number()),

ts/src/types/dask_array.ts

@@ -1,17 +1,17 @@
-export interface DaskArrayMetadata {
+export interface LazyArrayMetadata {
   shape: number[];
   dtype: string;
   chunks: number[][];
   name: string;
 }
 
-export class DaskArray {
+export class LazyArray {
   public readonly shape: number[];
   public readonly dtype: string;
   public readonly chunks: number[][];
   public readonly name: string;
 
-  constructor(metadata: DaskArrayMetadata) {
+  constructor(metadata: LazyArrayMetadata) {
     this.shape = [...metadata.shape];
     this.dtype = metadata.dtype;
     this.chunks = metadata.chunks.map((chunk) => [...chunk]);
@@ -31,11 +31,12 @@ export class DaskArray {
   }
 
   toString(): string {
-    const chunkStr = this.chunksize.length > 0
-      ? `chunksize=(${this.chunksize.join(", ")})`
-      : "chunksize=()";
-    return `dask.array<${this.name}, shape=(${
-      this.shape.join(", ")
-    }), dtype=${this.dtype}, ${chunkStr}, chunktype=TypedArray>`;
+    const chunkStr =
+      this.chunksize.length > 0
+        ? `chunksize=(${this.chunksize.join(", ")})`
+        : "chunksize=()";
+    return `dask.array<${this.name}, shape=(${this.shape.join(", ")}), dtype=${
+      this.dtype
+    }, ${chunkStr}, chunktype=TypedArray>`;
   }
 }

ts/src/types/lazy_array.ts

@@ -0,0 +1,41 @@
+export interface LazyArrayMetadata {
+  shape: number[];
+  dtype: string;
+  chunks: number[][];
+  name: string;
+}
+
+export class LazyArray {
+  public readonly shape: number[];
+  public readonly dtype: string;
+  public readonly chunks: number[][];
+  public readonly name: string;
+
+  constructor(metadata: LazyArrayMetadata) {
+    this.shape = [...metadata.shape];
+    this.dtype = metadata.dtype;
+    this.chunks = metadata.chunks.map((chunk) => [...chunk]);
+    this.name = metadata.name;
+  }
+
+  get ndim(): number {
+    return this.shape.length;
+  }
+
+  get size(): number {
+    return this.shape.reduce((acc, dim) => acc * dim, 1);
+  }
+
+  get chunksize(): number[] {
+    return this.chunks[0] || [];
+  }
+
+  toString(): string {
+    const chunkStr = this.chunksize.length > 0
+      ? `chunksize=(${this.chunksize.join(", ")})`
+      : "chunksize=()";
+    return `dask.array<${this.name}, shape=(${
+      this.shape.join(", ")
+    }), dtype=${this.dtype}, ${chunkStr}, chunktype=TypedArray>`;
+  }
+}

ts/src/types/ngff_image.ts

@@ -1,10 +1,10 @@
-import type { DaskArray } from "./dask_array.ts";
+import type { LazyArray } from "./lazy_array.ts";
 import type { Units } from "./units.ts";
 
 export type ComputedCallback = () => void;
 
 export interface NgffImageOptions {
-  data: DaskArray;
+  data: LazyArray;
   dims: string[];
   scale: Record<string, number>;
   translation: Record<string, number>;
@@ -14,7 +14,7 @@ export interface NgffImageOptions {
 }
 
 export class NgffImage {
-  public readonly data: DaskArray;
+  public readonly data: LazyArray;
   public readonly dims: string[];
   public readonly scale: Record<string, number>;
   public readonly translation: Record<string, number>;

ts/src/utils/factory.ts

@@ -1,4 +1,4 @@
-import { DaskArray } from "../types/dask_array.ts";
+import { LazyArray } from "../types/lazy_array.ts";
 import { NgffImage } from "../types/ngff_image.ts";
 import { Multiscales } from "../types/multiscales.ts";
 import type {
@@ -18,17 +18,17 @@ export function createNgffImage(
   dims: string[],
   scale: Record<string, number>,
   translation: Record<string, number>,
-  name = "image",
+  name = "image"
 ): NgffImage {
-  const daskArray = new DaskArray({
+  const lazyArray = new LazyArray({
     shape,
     dtype,
     chunks: [shape],
     name,
   });
 
   return new NgffImage({
-    data: daskArray,
+    data: lazyArray,
     dims,
     scale,
     translation,
@@ -41,7 +41,7 @@ export function createNgffImage(
 export function createAxis(
   name: SupportedDims,
   type: AxesType,
-  unit?: Units,
+  unit?: Units
 ): Axis {
   return {
     name,
@@ -67,7 +67,7 @@ export function createTranslation(translation: number[]): Translation {
 export function createDataset(
   path: string,
   scale: number[],
-  translation: number[],
+  translation: number[]
 ): Dataset {
   return {
     path,
@@ -82,7 +82,7 @@ export function createMetadata(
   axes: Axis[],
   datasets: Dataset[],
   name = "image",
-  version = "0.4",
+  version = "0.4"
 ): Metadata {
   return {
     axes: [...axes],
@@ -98,7 +98,7 @@ export function createMultiscales(
   images: NgffImage[],
   metadata: Metadata,
   scaleFactors?: (Record<string, number> | number)[],
-  method?: Methods,
+  method?: Methods
 ): Multiscales {
   return new Multiscales({
     images: [...images],

ts/test/schemas_test.ts

@@ -7,7 +7,7 @@ import {
   TranslationSchema,
 } from "../src/schemas/zarr_metadata.ts";
 import { MethodsSchema } from "../src/schemas/methods.ts";
-import { DaskArrayMetadataSchema } from "../src/schemas/dask_array.ts";
+import { LazyArrayMetadataSchema } from "../src/schemas/lazy_array.ts";
 
 Deno.test("AxisSchema validation", () => {
   const validAxis = {
@@ -90,13 +90,15 @@ Deno.test("MetadataSchema validation", () => {
       { name: "y", type: "space" },
       { name: "x", type: "space" },
     ],
-    datasets: [{
-      path: "0",
-      coordinateTransformations: [
-        { type: "scale", scale: [1.0, 1.0] },
-        { type: "translation", translation: [0.0, 0.0] },
-      ],
-    }],
+    datasets: [
+      {
+        path: "0",
+        coordinateTransformations: [
+          { type: "scale", scale: [1.0, 1.0] },
+          { type: "translation", translation: [0.0, 0.0] },
+        ],
+      },
+    ],
     name: "test_image",
     version: "0.4",
   };
@@ -116,27 +118,32 @@ Deno.test("MethodsSchema validation", () => {
   assertThrows(() => MethodsSchema.parse("invalid_method"));
 });
 
-Deno.test("DaskArrayMetadataSchema validation", () => {
+Deno.test("LazyArrayMetadataSchema validation", () => {
   const validMetadata = {
     shape: [256, 256],
     dtype: "uint8",
-    chunks: [[64, 64], [64, 64], [64, 64], [64, 64]],
+    chunks: [
+      [64, 64],
+      [64, 64],
+      [64, 64],
+      [64, 64],
+    ],
     name: "test_array",
   };
 
-  const result = DaskArrayMetadataSchema.parse(validMetadata);
+  const result = LazyArrayMetadataSchema.parse(validMetadata);
   assertEquals(result.shape, [256, 256]);
   assertEquals(result.dtype, "uint8");
   assertEquals(result.name, "test_array");
 });
 
-Deno.test("DaskArrayMetadataSchema validation - negative shape", () => {
+Deno.test("LazyArrayMetadataSchema validation - negative shape", () => {
   const invalidMetadata = {
     shape: [-256, 256],
     dtype: "uint8",
     chunks: [[64, 64]],
     name: "test_array",
   };
 
-  assertThrows(() => DaskArrayMetadataSchema.parse(invalidMetadata));
+  assertThrows(() => LazyArrayMetadataSchema.parse(invalidMetadata));
 });