@idetik/core 0.1.1 → 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;
@@ -324,112 +343,6 @@ declare abstract class Camera extends RenderableObject {
     clipToWorld(position: vec3): vec3;
 }
 
-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 {
@@ -462,6 +375,9 @@ interface LayerOptions {
     opacity?: number;
     blendMode?: blendMode;
 }
+type RenderContext = {
+    viewport: Viewport;
+};
 declare abstract class Layer {
     abstract readonly type: string;
     private objects_;
@@ -473,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;
@@ -506,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;
 }
@@ -550,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;
 };
@@ -793,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_;
@@ -803,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);