@idetik/core 0.1.0

package/dist/types/src/data/ome_zarr/0.5/plate.d.ts

@@ -0,0 +1,229 @@
+import { z } from "zod";
+/**The zarr.json attributes key*/
+export declare const Plate: z.ZodObject<{
+    /**The versioned OME-Zarr Metadata namespace*/
+    ome: z.ZodObject<{
+        plate: z.ZodObject<{
+            /**The acquisitions for this plate*/
+            acquisitions: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                /**A unique identifier within the context of the plate*/
+                id: z.ZodNumber;
+                /**The maximum number of fields of view for the acquisition*/
+                maximumfieldcount: z.ZodOptional<z.ZodNumber>;
+                /**The name of the acquisition*/
+                name: z.ZodOptional<z.ZodString>;
+                /**The description of the acquisition*/
+                description: z.ZodOptional<z.ZodString>;
+                /**The start timestamp of the acquisition, expressed as epoch time i.e. the number seconds since the Epoch*/
+                starttime: z.ZodOptional<z.ZodNumber>;
+                /**The end timestamp of the acquisition, expressed as epoch time i.e. the number seconds since the Epoch*/
+                endtime: z.ZodOptional<z.ZodNumber>;
+            }, "strip", z.ZodTypeAny, {
+                id: number;
+                name?: string | undefined;
+                maximumfieldcount?: number | undefined;
+                description?: string | undefined;
+                starttime?: number | undefined;
+                endtime?: number | undefined;
+            }, {
+                id: number;
+                name?: string | undefined;
+                maximumfieldcount?: number | undefined;
+                description?: string | undefined;
+                starttime?: number | undefined;
+                endtime?: number | undefined;
+            }>, "many">>;
+            /**The maximum number of fields per view across all wells*/
+            field_count: z.ZodOptional<z.ZodNumber>;
+            /**The name of the plate*/
+            name: z.ZodOptional<z.ZodString>;
+            /**The columns of the plate*/
+            columns: z.ZodArray<z.ZodObject<{
+                /**The column name*/
+                name: z.ZodString;
+            }, "strip", z.ZodTypeAny, {
+                name: string;
+            }, {
+                name: string;
+            }>, "many">;
+            /**The rows of the plate*/
+            rows: z.ZodArray<z.ZodObject<{
+                /**The row name*/
+                name: z.ZodString;
+            }, "strip", z.ZodTypeAny, {
+                name: string;
+            }, {
+                name: string;
+            }>, "many">;
+            /**The wells of the plate*/
+            wells: z.ZodArray<z.ZodObject<{
+                /**The path to the well subgroup*/
+                path: z.ZodString;
+                /**The index of the well in the rows list*/
+                rowIndex: z.ZodNumber;
+                /**The index of the well in the columns list*/
+                columnIndex: z.ZodNumber;
+            }, "strip", z.ZodTypeAny, {
+                path: string;
+                rowIndex: number;
+                columnIndex: number;
+            }, {
+                path: string;
+                rowIndex: number;
+                columnIndex: number;
+            }>, "many">;
+        }, "strip", z.ZodTypeAny, {
+            columns: {
+                name: string;
+            }[];
+            rows: {
+                name: string;
+            }[];
+            wells: {
+                path: string;
+                rowIndex: number;
+                columnIndex: number;
+            }[];
+            name?: string | undefined;
+            acquisitions?: {
+                id: number;
+                name?: string | undefined;
+                maximumfieldcount?: number | undefined;
+                description?: string | undefined;
+                starttime?: number | undefined;
+                endtime?: number | undefined;
+            }[] | undefined;
+            field_count?: number | undefined;
+        }, {
+            columns: {
+                name: string;
+            }[];
+            rows: {
+                name: string;
+            }[];
+            wells: {
+                path: string;
+                rowIndex: number;
+                columnIndex: number;
+            }[];
+            name?: string | undefined;
+            acquisitions?: {
+                id: number;
+                name?: string | undefined;
+                maximumfieldcount?: number | undefined;
+                description?: string | undefined;
+                starttime?: number | undefined;
+                endtime?: number | undefined;
+            }[] | undefined;
+            field_count?: number | undefined;
+        }>;
+        /**The version of the OME-Zarr Metadata*/
+        version: z.ZodLiteral<"0.5">;
+    }, "strip", z.ZodTypeAny, {
+        version: "0.5";
+        plate: {
+            columns: {
+                name: string;
+            }[];
+            rows: {
+                name: string;
+            }[];
+            wells: {
+                path: string;
+                rowIndex: number;
+                columnIndex: number;
+            }[];
+            name?: string | undefined;
+            acquisitions?: {
+                id: number;
+                name?: string | undefined;
+                maximumfieldcount?: number | undefined;
+                description?: string | undefined;
+                starttime?: number | undefined;
+                endtime?: number | undefined;
+            }[] | undefined;
+            field_count?: number | undefined;
+        };
+    }, {
+        version: "0.5";
+        plate: {
+            columns: {
+                name: string;
+            }[];
+            rows: {
+                name: string;
+            }[];
+            wells: {
+                path: string;
+                rowIndex: number;
+                columnIndex: number;
+            }[];
+            name?: string | undefined;
+            acquisitions?: {
+                id: number;
+                name?: string | undefined;
+                maximumfieldcount?: number | undefined;
+                description?: string | undefined;
+                starttime?: number | undefined;
+                endtime?: number | undefined;
+            }[] | undefined;
+            field_count?: number | undefined;
+        };
+    }>;
+}, "strip", z.ZodTypeAny, {
+    ome: {
+        version: "0.5";
+        plate: {
+            columns: {
+                name: string;
+            }[];
+            rows: {
+                name: string;
+            }[];
+            wells: {
+                path: string;
+                rowIndex: number;
+                columnIndex: number;
+            }[];
+            name?: string | undefined;
+            acquisitions?: {
+                id: number;
+                name?: string | undefined;
+                maximumfieldcount?: number | undefined;
+                description?: string | undefined;
+                starttime?: number | undefined;
+                endtime?: number | undefined;
+            }[] | undefined;
+            field_count?: number | undefined;
+        };
+    };
+}, {
+    ome: {
+        version: "0.5";
+        plate: {
+            columns: {
+                name: string;
+            }[];
+            rows: {
+                name: string;
+            }[];
+            wells: {
+                path: string;
+                rowIndex: number;
+                columnIndex: number;
+            }[];
+            name?: string | undefined;
+            acquisitions?: {
+                id: number;
+                name?: string | undefined;
+                maximumfieldcount?: number | undefined;
+                description?: string | undefined;
+                starttime?: number | undefined;
+                endtime?: number | undefined;
+            }[] | undefined;
+            field_count?: number | undefined;
+        };
+    };
+}>;
+export type Plate = z.infer<typeof Plate>;
+//# sourceMappingURL=plate.d.ts.map

package/dist/types/src/data/ome_zarr/0.5/plate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plate.d.ts","sourceRoot":"","sources":["../../../../../../src/data/ome_zarr/0.5/plate.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,iCAAiC;AACjC,eAAO,MAAM,KAAK;IAEd,8CAA8C;;;YAIxC,oCAAoC;;gBAI9B,wDAAwD;;gBAQxD,6DAA6D;;gBAS7D,gCAAgC;;gBAKhC,uCAAuC;;gBAKvC,4GAA4G;;gBAS5G,0GAA0G;;;;;;;;;;;;;;;;;YAahH,2DAA2D;;YAO3D,0BAA0B;;YAE1B,6BAA6B;;gBAIvB,oBAAoB;;;;;;;YAS1B,0BAA0B;;gBAIpB,iBAAiB;;;;;;;YASvB,2BAA2B;;gBAIrB,kCAAkC;;gBAKlC,2CAA2C;;gBAM3C,8CAA8C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAWtD,yCAAyC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAON,CAAC;AAC5C,MAAM,MAAM,KAAK,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,KAAK,CAAC,CAAC"}

package/dist/types/src/data/ome_zarr/0.5/well.d.ts

@@ -0,0 +1,72 @@
+import { z } from "zod";
+/**JSON from OME-Zarr zarr.json*/
+export declare const Well: z.ZodObject<{
+    /**The versioned OME-Zarr Metadata namespace*/
+    ome: z.ZodObject<{
+        well: z.ZodObject<{
+            /**The fields of view for this well*/
+            images: z.ZodArray<z.ZodObject<{
+                /**A unique identifier within the context of the plate*/
+                acquisition: z.ZodOptional<z.ZodNumber>;
+                /**The path for this field of view subgroup*/
+                path: z.ZodString;
+            }, "strip", z.ZodTypeAny, {
+                path: string;
+                acquisition?: number | undefined;
+            }, {
+                path: string;
+                acquisition?: number | undefined;
+            }>, "many">;
+        }, "strip", z.ZodTypeAny, {
+            images: {
+                path: string;
+                acquisition?: number | undefined;
+            }[];
+        }, {
+            images: {
+                path: string;
+                acquisition?: number | undefined;
+            }[];
+        }>;
+        /**The version of the OME-Zarr Metadata*/
+        version: z.ZodLiteral<"0.5">;
+    }, "strip", z.ZodTypeAny, {
+        version: "0.5";
+        well: {
+            images: {
+                path: string;
+                acquisition?: number | undefined;
+            }[];
+        };
+    }, {
+        version: "0.5";
+        well: {
+            images: {
+                path: string;
+                acquisition?: number | undefined;
+            }[];
+        };
+    }>;
+}, "strip", z.ZodTypeAny, {
+    ome: {
+        version: "0.5";
+        well: {
+            images: {
+                path: string;
+                acquisition?: number | undefined;
+            }[];
+        };
+    };
+}, {
+    ome: {
+        version: "0.5";
+        well: {
+            images: {
+                path: string;
+                acquisition?: number | undefined;
+            }[];
+        };
+    };
+}>;
+export type Well = z.infer<typeof Well>;
+//# sourceMappingURL=well.d.ts.map

package/dist/types/src/data/ome_zarr/0.5/well.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"well.d.ts","sourceRoot":"","sources":["../../../../../../src/data/ome_zarr/0.5/well.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,iCAAiC;AACjC,eAAO,MAAM,IAAI;IAEb,8CAA8C;;;YAIxC,qCAAqC;;gBAI/B,wDAAwD;;gBAQxD,6CAA6C;;;;;;;;;;;;;;;;;;;;QAUrD,yCAAyC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAON,CAAC;AAC5C,MAAM,MAAM,IAAI,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,IAAI,CAAC,CAAC"}

package/dist/types/src/data/ome_zarr/image_loader.d.ts

@@ -0,0 +1,35 @@
+import * as zarr from "zarrita";
+import { Region } from "../region";
+import { Chunk, SourceDimensionMap, LoaderAttributes } from "../chunk";
+import { PromiseScheduler } from "../promise_scheduler";
+import { Image as OmeZarrImage } from "./0.5/image";
+import { Readable } from "@zarrita/storage";
+import { ZarrArrayParams } from "../zarr/open";
+export declare class PromiseQueue<T> {
+    private readonly promises_;
+    private readonly scheduler_;
+    constructor(scheduler: PromiseScheduler);
+    add(promise: () => Promise<T>): void;
+    onIdle(): Promise<Array<T>>;
+}
+type OmeZarrImageLoaderProps = {
+    metadata: OmeZarrImage["ome"]["multiscales"][number];
+    arrays: zarr.Array<zarr.DataType, Readable>[];
+    arrayParams: ZarrArrayParams[];
+};
+export declare class OmeZarrImageLoader {
+    private readonly metadata_;
+    private readonly arrays_;
+    private readonly arrayParams_;
+    private readonly loaderAttributes_;
+    private readonly dimensions_;
+    constructor(props: OmeZarrImageLoaderProps);
+    getSourceDimensionMap(): SourceDimensionMap;
+    loadChunkData(chunk: Chunk, signal: AbortSignal): Promise<void>;
+    private trimChunkPadding;
+    loadRegion(region: Region, lod: number, scheduler?: PromiseScheduler): Promise<Chunk>;
+    getAttributes(): ReadonlyArray<LoaderAttributes>;
+    private regionToIndices;
+}
+export {};
+//# sourceMappingURL=image_loader.d.ts.map

package/dist/types/src/data/ome_zarr/image_loader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"image_loader.d.ts","sourceRoot":"","sources":["../../../../../src/data/ome_zarr/image_loader.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,IAAI,MAAM,SAAS,CAAC;AAGhC,OAAO,EAAE,MAAM,EAAE,MAAM,WAAW,CAAC;AACnC,OAAO,EACL,KAAK,EAEL,kBAAkB,EAElB,gBAAgB,EAGjB,MAAM,UAAU,CAAC;AAElB,OAAO,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AAExD,OAAO,EAAE,KAAK,IAAI,YAAY,EAAE,MAAM,aAAa,CAAC;AAEpD,OAAO,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAC;AAC5C,OAAO,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC;AAK/C,qBAAa,YAAY,CAAC,CAAC;IACzB,OAAO,CAAC,QAAQ,CAAC,SAAS,CAA+B;IACzD,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAmB;gBAElC,SAAS,EAAE,gBAAgB;IAIvC,GAAG,CAAC,OAAO,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC;IAI7B,MAAM,IAAI,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;CAG5B;AAED,KAAK,uBAAuB,GAAG;IAC7B,QAAQ,EAAE,YAAY,CAAC,KAAK,CAAC,CAAC,aAAa,CAAC,CAAC,MAAM,CAAC,CAAC;IACrD,MAAM,EAAE,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,QAAQ,EAAE,QAAQ,CAAC,EAAE,CAAC;IAC9C,WAAW,EAAE,eAAe,EAAE,CAAC;CAChC,CAAC;AAIF,qBAAa,kBAAkB;IAC7B,OAAO,CAAC,QAAQ,CAAC,SAAS,CAA6C;IACvE,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAqD;IAC7E,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAiC;IAC9D,OAAO,CAAC,QAAQ,CAAC,iBAAiB,CAAkC;IACpE,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAqB;gBAErC,KAAK,EAAE,uBAAuB;IAQnC,qBAAqB,IAAI,kBAAkB;IAIrC,aAAa,CAAC,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,WAAW;IAwE5D,OAAO,CAAC,gBAAgB;IA0BX,UAAU,CACrB,MAAM,EAAE,MAAM,EACd,GAAG,EAAE,MAAM,EACX,SAAS,CAAC,EAAE,gBAAgB,GAC3B,OAAO,CAAC,KAAK,CAAC;IAiFV,aAAa,IAAI,aAAa,CAAC,gBAAgB,CAAC;IAIvD,OAAO,CAAC,eAAe;CA6BxB"}

package/dist/types/src/data/ome_zarr/image_source.d.ts

@@ -0,0 +1,33 @@
+import { Location } from "@zarrita/core";
+import { Readable } from "@zarrita/storage";
+import { OmeZarrImageLoader } from "./image_loader";
+import { Version as OmeZarrVersion } from "./metadata_loaders";
+/** Options for customizing fetch requests, such as adding authentication headers for private S3 data */
+export type FetchOptions = {
+    /** RequestInit overrides to customize fetch behavior (e.g., custom headers for S3 authentication) */
+    overrides?: RequestInit;
+    /** Whether to use suffix requests for range queries */
+    useSuffixRequest?: boolean;
+};
+/** Opens an OME-Zarr multiscale image Zarr group from either a URL or local directory. */
+export declare class OmeZarrImageSource {
+    readonly location: Location<Readable>;
+    readonly version?: OmeZarrVersion;
+    readonly fetchOptions?: FetchOptions;
+    /**
+     * @param url URL of Zarr root
+     * @param version OME-Zarr version
+     * @param fetchOptions Optional fetch configuration (e.g., authentication headers for private S3 data)
+     */
+    constructor(url: string, version?: OmeZarrVersion, fetchOptions?: FetchOptions);
+    /**
+     * @param directory return value of `window.showDirectoryPicker()` which gives the browser
+     *    permission to access a directory (only works in Chrome/Edge)
+     * @param version OME-Zarr version
+     * @param path path to image, beginning with "/". This argument allows the application to only
+     *    ask the user once for permission to the root directory
+     */
+    constructor(directory: FileSystemDirectoryHandle, version?: OmeZarrVersion, path?: `/${string}`);
+    open(): Promise<OmeZarrImageLoader>;
+}
+//# sourceMappingURL=image_source.d.ts.map

package/dist/types/src/data/ome_zarr/image_source.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"image_source.d.ts","sourceRoot":"","sources":["../../../../../src/data/ome_zarr/image_source.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AACzC,OAAO,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAC;AAQ5C,OAAO,EAAE,kBAAkB,EAAE,MAAM,gBAAgB,CAAC;AACpD,OAAO,EAGL,OAAO,IAAI,cAAc,EAC1B,MAAM,oBAAoB,CAAC;AAE5B,wGAAwG;AACxG,MAAM,MAAM,YAAY,GAAG;IACzB,qGAAqG;IACrG,SAAS,CAAC,EAAE,WAAW,CAAC;IACxB,uDAAuD;IACvD,gBAAgB,CAAC,EAAE,OAAO,CAAC;CAC5B,CAAC;AAEF,0FAA0F;AAC1F,qBAAa,kBAAkB;IAC7B,QAAQ,CAAC,QAAQ,EAAE,QAAQ,CAAC,QAAQ,CAAC,CAAC;IACtC,QAAQ,CAAC,OAAO,CAAC,EAAE,cAAc,CAAC;IAClC,QAAQ,CAAC,YAAY,CAAC,EAAE,YAAY,CAAC;IAErC;;;;OAIG;gBACS,GAAG,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,cAAc,EAAE,YAAY,CAAC,EAAE,YAAY;IAC9E;;;;;;OAMG;gBAED,SAAS,EAAE,yBAAyB,EACpC,OAAO,CAAC,EAAE,cAAc,EACxB,IAAI,CAAC,EAAE,IAAI,MAAM,EAAE;IAgCR,IAAI,IAAI,OAAO,CAAC,kBAAkB,CAAC;CAqCjD"}

package/dist/types/src/data/ome_zarr/metadata_loaders.d.ts

@@ -0,0 +1,20 @@
+import { Image } from "./0.5/image";
+import { Plate } from "./0.5/plate";
+import { Well } from "./0.5/well";
+import { OmeZarrImageSource } from "./image_source";
+import { Version as ZarrVersion } from "../zarr/open";
+declare const versions: readonly ["0.4", "0.5"];
+export type Version = (typeof versions)[number];
+type AdaptedOme<T> = T & {
+    originalVersion: Version;
+};
+export declare function omeZarrToZarrVersion(omeVersion: Version | undefined): ZarrVersion | undefined;
+export declare function loadOmeZarrPlate(url: string, version?: Version): Promise<AdaptedOme<Plate["ome"]>>;
+export declare function loadOmeZarrWell(url: string, path: string, version?: Version): Promise<AdaptedOme<Well["ome"]>>;
+export type OmeroMetadata = NonNullable<Image["ome"]["omero"]>;
+export type OmeroChannel = OmeroMetadata["channels"][number];
+export declare function loadOmeroChannels(source: OmeZarrImageSource): Promise<OmeroChannel[]>;
+export declare function loadOmeroDefaults(source: OmeZarrImageSource): Promise<OmeroMetadata["rdefs"]>;
+export declare function parseOmeZarrImage(attrs: Record<string, unknown>): AdaptedOme<Image["ome"]>;
+export {};
+//# sourceMappingURL=metadata_loaders.d.ts.map

package/dist/types/src/data/ome_zarr/metadata_loaders.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"metadata_loaders.d.ts","sourceRoot":"","sources":["../../../../../src/data/ome_zarr/metadata_loaders.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AACpC,OAAO,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AACpC,OAAO,EAAE,IAAI,EAAE,MAAM,YAAY,CAAC;AAClC,OAAO,EAAE,kBAAkB,EAAE,MAAM,gBAAgB,CAAC;AACpD,OAAO,EAAE,OAAO,IAAI,WAAW,EAAa,MAAM,cAAc,CAAC;AAEjE,QAAA,MAAM,QAAQ,yBAA0B,CAAC;AAEzC,MAAM,MAAM,OAAO,GAAG,CAAC,OAAO,QAAQ,CAAC,CAAC,MAAM,CAAC,CAAC;AAEhD,KAAK,UAAU,CAAC,CAAC,IAAI,CAAC,GAAG;IACvB,eAAe,EAAE,OAAO,CAAC;CAC1B,CAAC;AAqBF,wBAAgB,oBAAoB,CAClC,UAAU,EAAE,OAAO,GAAG,SAAS,GAC9B,WAAW,GAAG,SAAS,CAQzB;AAQD,wBAAsB,gBAAgB,CACpC,GAAG,EAAE,MAAM,EACX,OAAO,CAAC,EAAE,OAAO,GAChB,OAAO,CAAC,UAAU,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,CAWnC;AA4DD,wBAAsB,eAAe,CACnC,GAAG,EAAE,MAAM,EACX,IAAI,EAAE,MAAM,EACZ,OAAO,CAAC,EAAE,OAAO,GAChB,OAAO,CAAC,UAAU,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAWlC;AAED,MAAM,MAAM,aAAa,GAAG,WAAW,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC;AAC/D,MAAM,MAAM,YAAY,GAAG,aAAa,CAAC,UAAU,CAAC,CAAC,MAAM,CAAC,CAAC;AAE7D,wBAAsB,iBAAiB,CACrC,MAAM,EAAE,kBAAkB,GACzB,OAAO,CAAC,YAAY,EAAE,CAAC,CAKzB;AAED,wBAAsB,iBAAiB,CACrC,MAAM,EAAE,kBAAkB,GACzB,OAAO,CAAC,aAAa,CAAC,OAAO,CAAC,CAAC,CAKjC;AA4BD,wBAAgB,iBAAiB,CAC/B,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC7B,UAAU,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,CAM1B"}

package/dist/types/src/data/ome_zarr/worker_kernel.d.ts

@@ -0,0 +1,25 @@
+import * as zarr from "zarrita";
+import { ZarrArrayParams } from "../zarr/open";
+type ZarrWorkerMessageType = "getChunk" | "cancel";
+export type ZarrWorkerRequest = {
+    id: number;
+} & ({
+    type: "getChunk";
+    arrayParams: ZarrArrayParams;
+    index: number[];
+} | {
+    type: "cancel";
+});
+export type ZarrWorkerResponse = {
+    id: number;
+} & ({
+    success: true;
+    type: "getChunk";
+    chunk: zarr.Chunk<zarr.DataType>;
+} | {
+    success: false;
+    type: ZarrWorkerMessageType;
+    error: string;
+});
+export {};
+//# sourceMappingURL=worker_kernel.d.ts.map

package/dist/types/src/data/ome_zarr/worker_kernel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"worker_kernel.d.ts","sourceRoot":"","sources":["../../../../../src/data/ome_zarr/worker_kernel.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,IAAI,MAAM,SAAS,CAAC;AAEhC,OAAO,EAAuB,eAAe,EAAE,MAAM,cAAc,CAAC;AAEpE,KAAK,qBAAqB,GAAG,UAAU,GAAG,QAAQ,CAAC;AAEnD,MAAM,MAAM,iBAAiB,GAAG;IAC9B,EAAE,EAAE,MAAM,CAAC;CACZ,GAAG,CACA;IACE,IAAI,EAAE,UAAU,CAAC;IACjB,WAAW,EAAE,eAAe,CAAC;IAC7B,KAAK,EAAE,MAAM,EAAE,CAAC;CACjB,GACD;IACE,IAAI,EAAE,QAAQ,CAAC;CAChB,CACJ,CAAC;AAEF,MAAM,MAAM,kBAAkB,GAAG;IAC/B,EAAE,EAAE,MAAM,CAAC;CACZ,GAAG,CACA;IACE,OAAO,EAAE,IAAI,CAAC;IACd,IAAI,EAAE,UAAU,CAAC;IACjB,KAAK,EAAE,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;CAClC,GACD;IACE,OAAO,EAAE,KAAK,CAAC;IACf,IAAI,EAAE,qBAAqB,CAAC;IAC5B,KAAK,EAAE,MAAM,CAAC;CACf,CACJ,CAAC"}

package/dist/types/src/data/ome_zarr/worker_pool.d.ts

@@ -0,0 +1,8 @@
+import * as zarr from "zarrita";
+import { Readable } from "@zarrita/storage";
+import { ZarrArrayParams } from "../zarr/open";
+export declare function getChunk(array: zarr.Array<zarr.DataType, Readable>, arrayParams: ZarrArrayParams, chunkCoords: number[], options?: {
+    signal?: AbortSignal;
+}): Promise<zarr.Chunk<zarr.DataType>>;
+export declare function terminateWorkerPool(): void;
+//# sourceMappingURL=worker_pool.d.ts.map

package/dist/types/src/data/ome_zarr/worker_pool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"worker_pool.d.ts","sourceRoot":"","sources":["../../../../../src/data/ome_zarr/worker_pool.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,IAAI,MAAM,SAAS,CAAC;AAChC,OAAO,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAC;AAE5C,OAAO,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC;AAmO/C,wBAAsB,QAAQ,CAC5B,KAAK,EAAE,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,QAAQ,EAAE,QAAQ,CAAC,EAC1C,WAAW,EAAE,eAAe,EAC5B,WAAW,EAAE,MAAM,EAAE,EACrB,OAAO,CAAC,EAAE;IAAE,MAAM,CAAC,EAAE,WAAW,CAAA;CAAE,GACjC,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,CAcpC;AAED,wBAAgB,mBAAmB,IAAI,IAAI,CAM1C"}

package/dist/types/src/data/promise_scheduler.d.ts

@@ -0,0 +1,17 @@
+export declare class AbortError extends Error {
+    constructor(message: string);
+}
+export declare class PromiseScheduler {
+    private readonly maxConcurrent_;
+    private readonly pending_;
+    private readonly abortController_;
+    private numRunning_;
+    constructor(maxConcurrent: number);
+    submit<T>(task: () => Promise<T>): Promise<T>;
+    private maybeRunNext;
+    get abortSignal(): AbortSignal;
+    shutdown(): void;
+    get numRunning(): number;
+    get numPending(): number;
+}
+//# sourceMappingURL=promise_scheduler.d.ts.map

package/dist/types/src/data/promise_scheduler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"promise_scheduler.d.ts","sourceRoot":"","sources":["../../../../src/data/promise_scheduler.ts"],"names":[],"mappings":"AAAA,qBAAa,UAAW,SAAQ,KAAK;gBACvB,OAAO,EAAE,MAAM;CAO5B;AAGD,qBAAa,gBAAgB;IAC3B,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAS;IACxC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAkC;IAC3D,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAAyB;IAC1D,OAAO,CAAC,WAAW,CAAK;gBAEZ,aAAa,EAAE,MAAM;IAO3B,MAAM,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC;IAoBnD,OAAO,CAAC,YAAY;IAQpB,IAAI,WAAW,gBAEd;IAED,QAAQ;IAIR,IAAI,UAAU,WAEb;IAED,IAAI,UAAU,WAEb;CACF"}

package/dist/types/src/data/region.d.ts

@@ -0,0 +1,19 @@
+export type Point = {
+    type: "point";
+    value: number;
+};
+export type Interval = {
+    type: "interval";
+    start: number;
+    stop: number;
+};
+export type Full = {
+    type: "full";
+};
+export type Index = Point | Interval | Full;
+export type DimensionalIndex = {
+    dimension: string;
+    index: Index;
+};
+export type Region = Array<DimensionalIndex>;
+//# sourceMappingURL=region.d.ts.map

package/dist/types/src/data/region.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"region.d.ts","sourceRoot":"","sources":["../../../../src/data/region.ts"],"names":[],"mappings":"AACA,MAAM,MAAM,KAAK,GAAG;IAClB,IAAI,EAAE,OAAO,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAEF,MAAM,MAAM,QAAQ,GAAG;IACrB,IAAI,EAAE,UAAU,CAAC;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;CACd,CAAC;AAEF,MAAM,MAAM,IAAI,GAAG;IACjB,IAAI,EAAE,MAAM,CAAC;CACd,CAAC;AAEF,MAAM,MAAM,KAAK,GAAG,KAAK,GAAG,QAAQ,GAAG,IAAI,CAAC;AAK5C,MAAM,MAAM,gBAAgB,GAAG;IAC7B,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE,KAAK,CAAC;CACd,CAAC;AAGF,MAAM,MAAM,MAAM,GAAG,KAAK,CAAC,gBAAgB,CAAC,CAAC"}

package/dist/types/src/data/zarr/open.d.ts

@@ -0,0 +1,27 @@
+import * as zarr from "zarrita";
+import { Location } from "@zarrita/core";
+import { Readable } from "@zarrita/storage";
+export type Version = "v2" | "v3";
+export type ZarrArrayParams = {
+    arrayPath: string;
+    zarrVersion: Version | undefined;
+} & ({
+    type: "fetch";
+    url: string;
+    fetchOptions?: {
+        overrides?: RequestInit;
+        useSuffixRequest?: boolean;
+    };
+} | {
+    type: "filesystem";
+    directoryHandle: FileSystemDirectoryHandle;
+    path: string;
+});
+export declare function openGroup(location: zarr.Location<Readable>, version?: Version): Promise<zarr.Group<Readable>>;
+export declare function openArray(location: zarr.Location<Readable>, version?: Version): Promise<zarr.Array<zarr.DataType, Readable>>;
+export declare function openArrayFromParams(params: ZarrArrayParams): Promise<zarr.Array<zarr.DataType, Readable>>;
+export declare function createZarrArrayParams(location: Location<Readable>, arrayPath: string, zarrVersion: Version | undefined, fetchOptions?: {
+    overrides?: RequestInit;
+    useSuffixRequest?: boolean;
+}): ZarrArrayParams;
+//# sourceMappingURL=open.d.ts.map

package/dist/types/src/data/zarr/open.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"open.d.ts","sourceRoot":"","sources":["../../../../../src/data/zarr/open.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,IAAI,MAAM,SAAS,CAAC;AAChC,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AACzC,OAAO,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAC;AAI5C,MAAM,MAAM,OAAO,GAAG,IAAI,GAAG,IAAI,CAAC;AAElC,MAAM,MAAM,eAAe,GAAG;IAC5B,SAAS,EAAE,MAAM,CAAC;IAClB,WAAW,EAAE,OAAO,GAAG,SAAS,CAAC;CAClC,GAAG,CACA;IACE,IAAI,EAAE,OAAO,CAAC;IACd,GAAG,EAAE,MAAM,CAAC;IACZ,YAAY,CAAC,EAAE;QACb,SAAS,CAAC,EAAE,WAAW,CAAC;QACxB,gBAAgB,CAAC,EAAE,OAAO,CAAC;KAC5B,CAAC;CACH,GACD;IACE,IAAI,EAAE,YAAY,CAAC;IACnB,eAAe,EAAE,yBAAyB,CAAC;IAC3C,IAAI,EAAE,MAAM,CAAC;CACd,CACJ,CAAC;AAEF,wBAAsB,SAAS,CAC7B,QAAQ,EAAE,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC,EACjC,OAAO,CAAC,EAAE,OAAO,GAChB,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC,CAoB/B;AAED,wBAAsB,SAAS,CAC7B,QAAQ,EAAE,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC,EACjC,OAAO,CAAC,EAAE,OAAO,GAChB,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,QAAQ,EAAE,QAAQ,CAAC,CAAC,CAoB9C;AAED,wBAAsB,mBAAmB,CACvC,MAAM,EAAE,eAAe,GACtB,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,QAAQ,EAAE,QAAQ,CAAC,CAAC,CA4B9C;AAED,wBAAgB,qBAAqB,CACnC,QAAQ,EAAE,QAAQ,CAAC,QAAQ,CAAC,EAC5B,SAAS,EAAE,MAAM,EACjB,WAAW,EAAE,OAAO,GAAG,SAAS,EAChC,YAAY,CAAC,EAAE;IAAE,SAAS,CAAC,EAAE,WAAW,CAAC;IAAC,gBAAgB,CAAC,EAAE,OAAO,CAAA;CAAE,GACrE,eAAe,CAsBjB"}

package/dist/types/src/data/zarr/web_file_system_store.d.ts

@@ -0,0 +1,28 @@
+import type { AbsolutePath, AsyncReadable } from "@zarrita/storage";
+/**
+ * A store for zarrita based on the Web File System API.
+ *
+ * Note: usage requires prompting the user to select a directory to grant
+ * access to the Web File System API.
+ *
+ * @see {@link https://developer.mozilla.org/en-US/docs/Web/API/File_System_API}
+ *
+ * @example
+ * ```js
+ * import * as zarr from "zarrita";
+ * import WebFileSystemStore from "@zarrita/storage/web-fs";
+ *
+ * let directoryHandle = await globalThis.showDirectoryPicker();
+ * let store = new WebFileSystemStore(directoryHandle);
+ * let root = await zarr.root(store);
+ * let arr = await zarr.open(root.resolve("/foo"), { kind: "array" });
+ * ```
+ */
+declare class WebFileSystemStore implements AsyncReadable {
+    #private;
+    constructor(root: FileSystemDirectoryHandle);
+    get directoryHandle(): FileSystemDirectoryHandle;
+    get(key: AbsolutePath): Promise<Uint8Array | undefined>;
+}
+export default WebFileSystemStore;
+//# sourceMappingURL=web_file_system_store.d.ts.map

package/dist/types/src/data/zarr/web_file_system_store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"web_file_system_store.d.ts","sourceRoot":"","sources":["../../../../../src/data/zarr/web_file_system_store.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,YAAY,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAwBpE;;;;;;;;;;;;;;;;;;GAkBG;AACH,cAAM,kBAAmB,YAAW,aAAa;;gBAGnC,IAAI,EAAE,yBAAyB;IAI3C,IAAI,eAAe,IAAI,yBAAyB,CAE/C;IAEK,GAAG,CAAC,GAAG,EAAE,YAAY,GAAG,OAAO,CAAC,UAAU,GAAG,SAAS,CAAC;CAgB9D;AAED,eAAe,kBAAkB,CAAC"}

package/dist/types/src/idetik.d.ts

@@ -0,0 +1,89 @@
+import { ChunkManager } from "./core/chunk_manager";
+import { Viewport, ViewportConfig } from "./core/viewport";
+type Overlay = {
+    update(idetik: Idetik, timestamp?: DOMHighResTimeStamp): void;
+};
+type IdetikParams = {
+    canvas: HTMLCanvasElement;
+    viewports: [ViewportConfig, ...ViewportConfig[]];
+    overlays?: Overlay[];
+    showStats?: boolean;
+};
+export type IdetikContext = {
+    chunkManager: ChunkManager;
+};
+export declare class Idetik {
+    private lastAnimationId_?;
+    private readonly chunkManager_;
+    private readonly context_;
+    private readonly renderer_;
+    private readonly viewports_;
+    readonly canvas: HTMLCanvasElement;
+    readonly overlays: Overlay[];
+    private readonly stats_?;
+    private readonly sizeObserver_;
+    /**
+     * Creates a new Idetik visualization runtime instance.
+     *
+     * @param params - Configuration parameters for the Idetik instance
+     * @param params.canvas - HTMLCanvasElement to render to
+     * @param params.viewports - Array of viewport configurations. (At least one required.)
+     *   Each viewport renders with its own camera, layers, and controls.
+     *   The `element` property is optional and defaults to the canvas if not provided.
+     *   Elements must be unique across viewports.
+     *   The `id` property is optional but useful for referencing specific viewports later.
+     * @param params.overlays - Optional array of overlay objects that update each frame (e.g., for HUD elements)
+     * @param params.showStats - Optional flag to display performance statistics
+     *
+     * @example
+     * // Single viewport (element defaults to canvas)
+     * const camera = new OrthographicCamera(0, 1024, 0, 1024);
+     * const idetik = new Idetik({
+     *   canvas: document.querySelector('canvas')!,
+     *   viewports: [{
+     *     camera: camera,
+     *     layers: [imageLayer],
+     *     cameraControls: new PanZoomControls(camera)
+     *   }]
+     * });
+     *
+     * @example
+     * // Multiple viewports - one defaults to canvas, others use separate elements
+     * const idetik = new Idetik({
+     *   canvas: document.querySelector('canvas')!,
+     *   viewports: [
+     *     {
+     *       id: 'main',
+     *       // element omitted - defaults to canvas
+     *       camera: camera1,
+     *       layers: [layer1]
+     *     },
+     *     {
+     *       id: 'minimap',
+     *       element: document.querySelector('#minimap')!,
+     *       camera: camera2,
+     *       layers: [layer2]
+     *     }
+     *   ]
+     * });
+     *
+     * @throws {Error} If viewports array is empty or not provided
+     * @throws {Error} If viewports have duplicate IDs or shared elements
+     */
+    constructor(params: IdetikParams);
+    get renderedObjects(): number;
+    get width(): number;
+    get height(): number;
+    get textureInfo(): {
+        textures: number;
+        totalBytes: number;
+    };
+    get viewports(): readonly Viewport[];
+    getViewport(id: string): Viewport | undefined;
+    start(): this;
+    private animate;
+    stop(): void;
+    private updateSize;
+}
+export {};
+//# sourceMappingURL=idetik.d.ts.map