@idetik/core 0.1.0 → 0.2.0

package/dist/index.d.ts

@@ -70,14 +70,16 @@ declare class PromiseScheduler {
 declare const chunkDataTypes: readonly [Int8ArrayConstructor, Int16ArrayConstructor, Int32ArrayConstructor, Uint8ArrayConstructor, Uint16ArrayConstructor, Uint32ArrayConstructor, Float32ArrayConstructor];
 type ChunkDataConstructor = (typeof chunkDataTypes)[number];
 type ChunkData = InstanceType<ChunkDataConstructor>;
-type Chunk = {
-    data?: ChunkData;
-    state: "unloaded" | "queued" | "loading" | "loaded";
-    lod: number;
+type ChunkViewState = {
     visible: boolean;
     prefetch: boolean;
     priority: number | null;
     orderKey: number | null;
+};
+type Chunk = {
+    data?: ChunkData;
+    state: "unloaded" | "queued" | "loading" | "loaded";
+    lod: number;
     shape: {
         x: number;
         y: number;
@@ -102,7 +104,7 @@ type Chunk = {
         y: number;
         z: number;
     };
-};
+} & ChunkViewState;
 type SourceDimensionMap = {
     x: SourceDimension;
     y: SourceDimension;
@@ -146,6 +148,23 @@ type ChunkLoader = {
     getAttributes(): ReadonlyArray<LoaderAttributes>;
 };
 
+declare class ChunkStore {
+    private readonly chunks_;
+    private readonly loader_;
+    private readonly lowestResLOD_;
+    private readonly dimensions_;
+    constructor(loader: ChunkLoader);
+    getChunksAtTime(timeIndex: number): Chunk[];
+    getTimeIndex(sliceCoords: SliceCoordinates): number;
+    get lodCount(): number;
+    get dimensions(): SourceDimensionMap;
+    getLowestResLOD(): number;
+    loadChunkData(chunk: Chunk, signal: AbortSignal): Promise<void>;
+    private validateXYScaleRatios;
+    private getAndValidateTimeDimension;
+    private getAndValidateChannelDimension;
+}
+
 declare class Box3 {
     min: vec3;
     max: vec3;
@@ -243,6 +262,31 @@ declare class Color {
     private toHexComponent;
 }
 
+declare class Box2 {
+    min: vec2;
+    max: vec2;
+    /**
+     * Initializes as an empty box if no values are provided using the
+     * "empty-by-sentinel" pattern: min = +Infinity, max = -Infinity.
+     * This allows expansion functions to work without special-casing
+     * the first element, and avoids biasing toward (0,0).
+     */
+    constructor(min?: vec2, max?: vec2);
+    clone(): Box2;
+    isEmpty(): boolean;
+    static intersects(a: Box2, b: Box2): boolean;
+    static equals(a: Box2, b: Box2): boolean;
+    floor(): Box2;
+    toRect(): {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+}
+
+type CullingMode = "none" | "front" | "back" | "both";
+
 declare abstract class RenderableObject extends Node {
     wireframeEnabled: boolean;
     wireframeColor: Color;
@@ -252,6 +296,7 @@ declare abstract class RenderableObject extends Node {
     private geometry_;
     private wireframeGeometry_;
     private programName_;
+    private cullFaceMode_;
     setTexture(index: number, texture: Texture): void;
     popStaleTextures(): Texture[];
     get geometry(): Geometry;
@@ -262,6 +307,8 @@ declare abstract class RenderableObject extends Node {
     get programName(): Shader;
     get boundingBox(): Box3;
     protected set programName(programName: Shader);
+    get cullFaceMode(): CullingMode;
+    set cullFaceMode(mode: CullingMode);
     /**
      * Get uniforms for shader program. Override in derived classes that need custom uniforms.
      * @returns Object containing uniform name-value pairs
@@ -296,135 +343,6 @@ declare abstract class Camera extends RenderableObject {
     clipToWorld(position: vec3): vec3;
 }
 
-declare class Box2 {
-    min: vec2;
-    max: vec2;
-    /**
-     * Initializes as an empty box if no values are provided using the
-     * "empty-by-sentinel" pattern: min = +Infinity, max = -Infinity.
-     * This allows expansion functions to work without special-casing
-     * the first element, and avoids biasing toward (0,0).
-     */
-    constructor(min?: vec2, max?: vec2);
-    clone(): Box2;
-    isEmpty(): boolean;
-    static intersects(a: Box2, b: Box2): boolean;
-    static equals(a: Box2, b: Box2): boolean;
-    floor(): Box2;
-    toRect(): {
-        x: number;
-        y: number;
-        width: number;
-        height: number;
-    };
-}
-
-declare class OrthographicCamera extends Camera {
-    private width_;
-    private height_;
-    private viewportAspectRatio_;
-    private viewportSize_;
-    constructor(left: number, right: number, top: number, bottom: number, near?: number, far?: number);
-    get viewportSize(): [number, number];
-    setAspectRatio(aspectRatio: number): void;
-    setFrame(left: number, right: number, bottom: number, top: number): void;
-    get type(): CameraType;
-    zoom(factor: number): void;
-    getWorldViewRect(): Box2;
-    protected updateProjectionMatrix(): void;
-}
-
-declare const ALL_CATEGORIES: readonly ["fallbackVisible", "prefetchTime", "visibleCurrent", "fallbackBackground", "prefetchSpace"];
-type PriorityCategory = (typeof ALL_CATEGORIES)[number];
-type ImageSourcePolicyConfig = {
-    profile?: string;
-    prefetch: {
-        x: number;
-        y: number;
-        z?: number;
-        t?: number;
-    };
-    priorityOrder: PriorityCategory[];
-    lod?: {
-        min?: number;
-        max?: number;
-        bias?: number;
-    };
-};
-type ImageSourcePolicy = Readonly<{
-    profile: string;
-    prefetch: {
-        x: number;
-        y: number;
-        z: number;
-        t: number;
-    };
-    priorityOrder: readonly PriorityCategory[];
-    priorityMap: Readonly<Record<PriorityCategory, number>>;
-    lod: {
-        min: number;
-        max: number;
-        bias: number;
-    };
-}>;
-declare function createImageSourcePolicy(config: ImageSourcePolicyConfig): ImageSourcePolicy;
-declare function createExplorationPolicy(overrides?: Partial<ImageSourcePolicyConfig>): ImageSourcePolicy;
-declare function createPlaybackPolicy(overrides?: Partial<ImageSourcePolicyConfig>): ImageSourcePolicy;
-declare function createNoPrefetchPolicy(overrides?: Partial<ImageSourcePolicyConfig>): ImageSourcePolicy;
-
-declare class ChunkManagerSource {
-    private readonly chunks_;
-    private readonly loader_;
-    private readonly lowestResLOD_;
-    private readonly sliceCoords_;
-    private readonly dimensions_;
-    private readonly tIndicesWithQueuedChunks_;
-    private readonly sourceMaxSquareDistance2D_;
-    private policy_;
-    private policyChanged_;
-    private currentLOD_;
-    private lastViewBounds2D_;
-    private lastZBounds_?;
-    private lastTCoord_?;
-    constructor(loader: ChunkLoader, sliceCoords: SliceCoordinates, policy: ImageSourcePolicy);
-    getChunks(): Chunk[];
-    getChunksAtCurrentTime(): Chunk[];
-    private getCurrentTimeIndex;
-    allVisibleLowestLODLoaded(): boolean;
-    updateAndCollectChunkChanges(lodFactor: number, viewBounds2D: Box2): Chunk[];
-    get lodCount(): number;
-    get dimensions(): SourceDimensionMap;
-    get currentLOD(): number;
-    setImageSourcePolicy(newPolicy: ImageSourcePolicy, key: symbol): void;
-    loadChunkData(chunk: Chunk, signal: AbortSignal): Promise<void>;
-    private setLOD;
-    private updateAndCollectChunkChangesForCurrentLod;
-    private disposeStaleTimeChunks;
-    private updateChunksAtTimeIndex;
-    private markTimeChunksForPrefetch;
-    private isChunkChannelInSlice;
-    private shouldDispose;
-    private disposeChunk;
-    private computePriority;
-    private validateXYScaleRatios;
-    private getAndValidateTimeDimension;
-    private getAndValidateChannelDimension;
-    private isChunkWithinBounds;
-    private getZBounds;
-    private viewBounds2DChanged;
-    private zBoundsChanged;
-    private getPaddedBounds;
-    private squareDistance2D;
-}
-
-declare class ChunkManager {
-    private readonly sources_;
-    private readonly pendingSources_;
-    private readonly queue_;
-    addSource(source: ChunkSource, sliceCoords: SliceCoordinates, policy: ImageSourcePolicy): Promise<ChunkManagerSource>;
-    update(camera: OrthographicCamera, bufferWidth: number): void;
-}
-
 declare const eventTypes: readonly ["pointerdown", "pointermove", "pointerup", "pointercancel", "wheel"];
 type EventType = (typeof eventTypes)[number];
 declare class EventContext {
@@ -457,6 +375,9 @@ interface LayerOptions {
     opacity?: number;
     blendMode?: blendMode;
 }
+type RenderContext = {
+    viewport: Viewport;
+};
 declare abstract class Layer {
     abstract readonly type: string;
     private objects_;
@@ -468,10 +389,10 @@ declare abstract class Layer {
     constructor({ transparent, opacity, blendMode, }?: LayerOptions);
     get opacity(): number;
     set opacity(value: number);
-    abstract update(): void;
+    abstract update(context?: RenderContext): void;
     onEvent(_: EventContext): void;
     onAttached(_context: IdetikContext): Promise<void>;
-    onDetached(): void;
+    onDetached(_context: IdetikContext): void;
     get objects(): RenderableObject[];
     get state(): LayerState;
     addStateChangeCallback(callback: StateChangeCallback): void;
@@ -501,6 +422,21 @@ declare class LayerManager {
     removeLayersChangeCallback(callback: () => void): void;
 }
 
+declare class OrthographicCamera extends Camera {
+    private width_;
+    private height_;
+    private viewportAspectRatio_;
+    private viewportSize_;
+    constructor(left: number, right: number, top: number, bottom: number, near?: number, far?: number);
+    get viewportSize(): [number, number];
+    setAspectRatio(aspectRatio: number): void;
+    setFrame(left: number, right: number, bottom: number, top: number): void;
+    get type(): CameraType;
+    zoom(factor: number): void;
+    getWorldViewRect(): Box2;
+    protected updateProjectionMatrix(): void;
+}
+
 interface CameraControls {
     onEvent(event: EventContext): void;
 }
@@ -545,6 +481,91 @@ declare class Viewport {
 }
 declare function parseViewportConfigs(viewportConfigs: ViewportConfig[], canvas: HTMLCanvasElement, context: IdetikContext): Viewport[];
 
+declare const ALL_CATEGORIES: readonly ["fallbackVisible", "prefetchTime", "visibleCurrent", "fallbackBackground", "prefetchSpace"];
+type PriorityCategory = (typeof ALL_CATEGORIES)[number];
+type ImageSourcePolicyConfig = {
+    profile?: string;
+    prefetch: {
+        x: number;
+        y: number;
+        z?: number;
+        t?: number;
+    };
+    priorityOrder: PriorityCategory[];
+    lod?: {
+        min?: number;
+        max?: number;
+        bias?: number;
+    };
+};
+type ImageSourcePolicy = Readonly<{
+    profile: string;
+    prefetch: {
+        x: number;
+        y: number;
+        z: number;
+        t: number;
+    };
+    priorityOrder: readonly PriorityCategory[];
+    priorityMap: Readonly<Record<PriorityCategory, number>>;
+    lod: {
+        min: number;
+        max: number;
+        bias: number;
+    };
+}>;
+declare function createImageSourcePolicy(config: ImageSourcePolicyConfig): ImageSourcePolicy;
+declare function createExplorationPolicy(overrides?: Partial<ImageSourcePolicyConfig>): ImageSourcePolicy;
+declare function createPlaybackPolicy(overrides?: Partial<ImageSourcePolicyConfig>): ImageSourcePolicy;
+declare function createNoPrefetchPolicy(overrides?: Partial<ImageSourcePolicyConfig>): ImageSourcePolicy;
+
+declare class ChunkStoreView {
+    private readonly store_;
+    private policy_;
+    private policyChanged_;
+    private currentLOD_;
+    private lastViewBounds2D_;
+    private lastZBounds_?;
+    private lastTCoord_?;
+    private sourceMaxSquareDistance2D_;
+    private readonly chunkViewStates_;
+    constructor(store: ChunkStore, policy: ImageSourcePolicy);
+    get store(): ChunkStore;
+    get chunkViewStates(): ReadonlyMap<Chunk, ChunkViewState>;
+    getChunksToRender(sliceCoords: SliceCoordinates): Chunk[];
+    updateChunkStates(sliceCoords: SliceCoordinates, viewport: Viewport): void;
+    allVisibleLowestLODLoaded(sliceCoords: SliceCoordinates): boolean;
+    get currentLOD(): number;
+    maybeForgetChunk(chunk: Chunk): void;
+    setImageSourcePolicy(newPolicy: ImageSourcePolicy, key: symbol): void;
+    private setLOD;
+    private updateChunkViewStates;
+    private isChunkChannelInSlice;
+    private updateChunksAtTimeIndex;
+    private markTimeChunksForPrefetch;
+    private computePriority;
+    private isChunkWithinBounds;
+    private getZBounds;
+    private viewBounds2DChanged;
+    private zBoundsChanged;
+    private getPaddedBounds;
+    private squareDistance2D;
+}
+
+declare class ChunkManager {
+    private readonly stores_;
+    private readonly pendingStores_;
+    private readonly views_;
+    private readonly queue_;
+    addView(source: ChunkSource, policy: ImageSourcePolicy): Promise<ChunkStoreView>;
+    removeView(view: ChunkStoreView): void;
+    private addSource;
+    private getSourceForStore;
+    update(): void;
+    private updateAndCollectChunkChanges;
+    private aggregateChunkViewStates;
+}
+
 type Overlay = {
     update(idetik: Idetik, timestamp?: DOMHighResTimeStamp): void;
 };
@@ -788,7 +809,7 @@ declare class ChunkedImageLayer extends Layer implements ChannelsEnabled {
     private readonly channelChangeCallbacks_;
     private policy_;
     private channelProps_?;
-    private chunkManagerSource_?;
+    private chunkStoreView_?;
     private pointerDownPos_;
     private zPrevPointWorld_?;
     private debugMode_;
@@ -798,14 +819,15 @@ declare class ChunkedImageLayer extends Layer implements ChannelsEnabled {
     private readonly wireframeColors_;
     constructor({ source, sliceCoords, policy, channelProps, onPickValue, ...layerOptions }: ChunkedImageLayerProps);
     onAttached(context: IdetikContext): Promise<void>;
-    onDetached(): void;
-    update(): void;
+    onDetached(context: IdetikContext): void;
+    update(context?: RenderContext): void;
     private updateChunks;
     get lastPresentationTimeCoord(): number | undefined;
     private isPresentationStale;
     private resliceIfZChanged;
     onEvent(event: EventContext): void;
-    get chunkManagerSource(): ChunkManagerSource | undefined;
+    get chunkStoreView(): ChunkStoreView | undefined;
+    get sliceCoords(): SliceCoordinates;
     get source(): ChunkSource;
     get imageSourcePolicy(): Readonly<ImageSourcePolicy>;
     set imageSourcePolicy(newPolicy: ImageSourcePolicy);
@@ -1570,28 +1592,17 @@ type OmeroChannel = OmeroMetadata["channels"][number];
 declare function loadOmeroChannels(source: OmeZarrImageSource): Promise<OmeroChannel[]>;
 declare function loadOmeroDefaults(source: OmeZarrImageSource): Promise<OmeroMetadata["rdefs"]>;
 
-/** Options for customizing fetch requests, such as adding authentication headers for private S3 data */
-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. */
 declare class OmeZarrImageSource {
     readonly location: Location<Readable>;
     readonly version?: Version;
-    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?: Version, fetchOptions?: FetchOptions);
+    constructor(url: string, version?: Version);
     /**
      * @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
      */
@@ -1862,4 +1873,4 @@ declare class Texture3D extends Texture {
     static createWithChunk(chunk: Chunk): Texture3D;
 }
 
-export { AxesLayer, Box2, Box3, type CameraControls, type ChannelProps, type ChannelsEnabled, type Chunk, type ChunkLoader, ChunkedImageLayer, Color, type ColorLike, EventContext, type FetchOptions, Frustum, Idetik, ImageLayer, ImageSeriesLayer, type ImageSourcePolicy, type ImageSourcePolicyConfig, LabelImageLayer, Layer, LayerManager, type LayerState, Image as OmeZarrImage, OmeZarrImageSource, type OmeroChannel, type OmeroMetadata, OrthographicCamera, PanZoomControls, PerspectiveCamera, Plane, type PointPickingResult, Points, type PriorityCategory, ProjectedLineLayer, type Region, type SliceCoordinates, Spherical, Texture2DArray, Texture3D, TracksLayer, Viewport, type ViewportConfig, VolumeLayer, WebGLRenderer, createExplorationPolicy, createImageSourcePolicy, createNoPrefetchPolicy, createPlaybackPolicy, loadOmeZarrPlate, loadOmeZarrWell, loadOmeroChannels, loadOmeroDefaults, parseViewportConfigs };
+export { AxesLayer, Box2, Box3, type CameraControls, type ChannelProps, type ChannelsEnabled, type Chunk, type ChunkLoader, ChunkedImageLayer, Color, type ColorLike, EventContext, Frustum, Idetik, ImageLayer, ImageSeriesLayer, type ImageSourcePolicy, type ImageSourcePolicyConfig, LabelImageLayer, Layer, LayerManager, type LayerState, Image as OmeZarrImage, OmeZarrImageSource, type OmeroChannel, type OmeroMetadata, OrthographicCamera, PanZoomControls, PerspectiveCamera, Plane, type PointPickingResult, Points, type PriorityCategory, ProjectedLineLayer, type Region, type SliceCoordinates, Spherical, Texture2DArray, Texture3D, TracksLayer, Viewport, type ViewportConfig, VolumeLayer, WebGLRenderer, createExplorationPolicy, createImageSourcePolicy, createNoPrefetchPolicy, createPlaybackPolicy, loadOmeZarrPlate, loadOmeZarrWell, loadOmeroChannels, loadOmeroDefaults, parseViewportConfigs };