@cornerstonejs/core 2.0.0-beta.2 → 2.0.0-beta.20

package/dist/esm/types/StackViewportProperties.d.ts

@@ -1,8 +1,7 @@
 import InterpolationType from '../enums/InterpolationType';
 import { ViewportProperties } from './ViewportProperties';
-declare type StackViewportProperties = ViewportProperties & {
+type StackViewportProperties = ViewportProperties & {
     interpolationType?: InterpolationType;
-    rotation?: number;
     suppressEvents?: boolean;
     isComputedVOI?: boolean;
 };

package/dist/esm/types/StackViewportProperties.js

@@ -1,2 +1 @@
 export {};
-//# sourceMappingURL=StackViewportProperties.js.map

package/dist/esm/types/SurfaceData.d.ts

@@ -0,0 +1,12 @@
+import Point3 from './Point3';
+type PublicSurfaceData = {
+    id: string;
+    data: SurfaceData;
+    frameOfReferenceUID: string;
+    color?: Point3;
+};
+type SurfaceData = {
+    points: number[];
+    polys: number[];
+};
+export type { PublicSurfaceData, SurfaceData };

package/dist/esm/types/SurfaceData.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/types/TransformMatrix2D.d.ts

@@ -1,2 +1,2 @@
-declare type TransformMatrix2D = [number, number, number, number, number, number];
+type TransformMatrix2D = [number, number, number, number, number, number];
 export default TransformMatrix2D;

package/dist/esm/types/TransformMatrix2D.js

@@ -1,2 +1 @@
 export {};
-//# sourceMappingURL=TransformMatrix2D.js.map

package/dist/esm/types/VideoViewportProperties.d.ts

@@ -0,0 +1,10 @@
+import { ViewportProperties } from './ViewportProperties';
+import Point2 from './Point2';
+type VideoViewportProperties = ViewportProperties & {
+    loop?: boolean;
+    muted?: boolean;
+    pan?: Point2;
+    playbackRate?: number;
+    scrollSpeed?: number;
+};
+export default VideoViewportProperties;

package/dist/esm/types/VideoViewportProperties.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/types/VideoViewportTypes.d.ts

@@ -0,0 +1,18 @@
+import { ViewportType } from '../enums';
+import Point2 from './Point2';
+export type InternalVideoCamera = {
+    panWorld?: Point2;
+    parallelScale?: number;
+};
+export type VideoViewportInput = {
+    id: string;
+    renderingEngineId: string;
+    type: ViewportType;
+    element: HTMLDivElement;
+    sx: number;
+    sy: number;
+    sWidth: number;
+    sHeight: number;
+    defaultOptions: any;
+    canvas: HTMLCanvasElement;
+};

package/dist/esm/types/VideoViewportTypes.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/types/ViewportInputOptions.d.ts

@@ -2,7 +2,7 @@ import { OrientationAxis } from '../enums';
 import OrientationVectors from './OrientationVectors';
 import DisplayArea from './displayArea';
 import RGB from './RGB';
-declare type ViewportInputOptions = {
+type ViewportInputOptions = {
     background?: RGB;
     orientation?: OrientationAxis | OrientationVectors;
     displayArea?: DisplayArea;

package/dist/esm/types/ViewportInputOptions.js

@@ -1,2 +1 @@
 export {};
-//# sourceMappingURL=ViewportInputOptions.js.map

package/dist/esm/types/ViewportPreset.js

@@ -1,2 +1 @@
 export {};
-//# sourceMappingURL=ViewportPreset.js.map

package/dist/esm/types/ViewportProperties.d.ts

@@ -1,9 +1,10 @@
 import { InterpolationType, VOILUTFunctionType } from '../enums';
 import { VOIRange } from './voi';
-declare type ViewportProperties = {
+import { ColormapPublic } from './Colormap';
+export type ViewportProperties = {
     voiRange?: VOIRange;
     VOILUTFunction?: VOILUTFunctionType;
     invert?: boolean;
+    colormap?: ColormapPublic;
     interpolationType?: InterpolationType;
 };
-export type { ViewportProperties };

package/dist/esm/types/ViewportProperties.js

@@ -1,2 +1 @@
 export {};
-//# sourceMappingURL=ViewportProperties.js.map

package/dist/esm/types/VolumeLoaderFn.d.ts

@@ -1,4 +1,4 @@
-declare type VolumeLoaderFn = (volumeId: string, options?: Record<string, any>) => {
+type VolumeLoaderFn = (volumeId: string, options?: Record<string, any>) => {
     promise: Promise<Record<string, any>>;
     cancelFn?: () => void | undefined;
     decache?: () => void | undefined;

package/dist/esm/types/VolumeLoaderFn.js

@@ -1,2 +1 @@
 export {};
-//# sourceMappingURL=VolumeLoaderFn.js.map

package/dist/esm/types/VolumeProps.d.ts

@@ -0,0 +1,27 @@
+import type { vtkImageData } from '@kitware/vtk.js/Common/DataModel/ImageData';
+import type Point3 from './Point3';
+import type Metadata from './Metadata';
+import Mat3 from './Mat3';
+import { PixelDataTypedArray } from './PixelDataTypedArray';
+interface VolumeProps {
+    volumeId: string;
+    metadata: Metadata;
+    dimensions: Point3;
+    spacing: Point3;
+    origin: Point3;
+    direction: Mat3;
+    imageData?: vtkImageData;
+    scalarData: PixelDataTypedArray | Array<PixelDataTypedArray>;
+    sizeInBytes?: number;
+    additionalDetails?: Record<string, any>;
+    scaling?: {
+        PT?: {
+            SUVlbmFactor?: number;
+            SUVbsaFactor?: number;
+            suvbwToSuvlbm?: number;
+            suvbwToSuvbsa?: number;
+        };
+    };
+    referencedVolumeId?: string;
+}
+export { VolumeProps };

package/dist/esm/types/VolumeProps.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/types/VolumeViewportProperties.d.ts

@@ -1,7 +1,8 @@
-import { ColormapPublic } from './Colormap';
 import { ViewportProperties } from './ViewportProperties';
-declare type VolumeViewportProperties = ViewportProperties & {
-    colormap?: ColormapPublic;
+import { OrientationAxis } from '../enums';
+type VolumeViewportProperties = ViewportProperties & {
     preset?: string;
+    slabThickness?: number;
+    orientation?: OrientationAxis;
 };
 export default VolumeViewportProperties;

package/dist/esm/types/VolumeViewportProperties.js

@@ -1,2 +1 @@
 export {};
-//# sourceMappingURL=VolumeViewportProperties.js.map

package/dist/esm/types/displayArea.d.ts

@@ -1,9 +1,13 @@
-declare type DisplayArea = {
-    imageArea: [number, number];
-    imageCanvasPoint: {
+import InterpolationType from '../enums/InterpolationType';
+type DisplayArea = {
+    type?: 'SCALE' | 'FIT';
+    scale?: number;
+    interpolationType?: InterpolationType;
+    imageArea?: [number, number];
+    imageCanvasPoint?: {
         imagePoint: [number, number];
-        canvasPoint: [number, number];
+        canvasPoint?: [number, number];
     };
-    storeAsInitialCamera: boolean;
+    storeAsInitialCamera?: boolean;
 };
 export default DisplayArea;

package/dist/esm/types/displayArea.js

@@ -1,2 +1 @@
 export {};
-//# sourceMappingURL=displayArea.js.map

package/dist/esm/types/index.d.ts

@@ -2,7 +2,7 @@ import type Cornerstone3DConfig from './Cornerstone3DConfig';
 import type ICamera from './ICamera';
 import type IEnabledElement from './IEnabledElement';
 import type ICache from './ICache';
-import type { IVolume, VolumeScalarData } from './IVolume';
+import type { IVolume } from './IVolume';
 import type { VOI, VOIRange } from './voi';
 import type DisplayArea from './displayArea';
 import type ImageLoaderFn from './ImageLoaderFn';
@@ -12,14 +12,17 @@ import type VolumeLoaderFn from './VolumeLoaderFn';
 import type IRegisterImageLoader from './IRegisterImageLoader';
 import type IStreamingVolumeProperties from './IStreamingVolumeProperties';
 import type CustomEventType from './CustomEventType';
-import type { IViewport, PublicViewportInput } from './IViewport';
-import type { VolumeActor, Actor, ActorEntry } from './IActor';
+import type { IViewport, PublicViewportInput, ViewReferenceSpecifier, ReferenceCompatibleOptions, ViewReference, ViewPresentation, ViewPresentationSelector } from './IViewport';
+import type { VolumeActor, Actor, ActorEntry, ImageActor, ICanvasActor } from './IActor';
 import type { IImageLoadObject, IVolumeLoadObject, IGeometryLoadObject } from './ILoadObject';
 import type Metadata from './Metadata';
 import type OrientationVectors from './OrientationVectors';
+import type AABB2 from './AABB2';
+import type AABB3 from './AABB3';
 import type Point2 from './Point2';
 import type Point3 from './Point3';
 import type Point4 from './Point4';
+import type { PointsXYZ } from './Point3';
 import type Mat3 from './Mat3';
 import type Plane from './Plane';
 import type IStreamingImageVolume from './IStreamingImageVolume';
@@ -51,20 +54,34 @@ import type CPUFallbackLookupTable from './CPUFallbackLookupTable';
 import type CPUFallbackLUT from './CPUFallbackLUT';
 import type CPUFallbackRenderingTools from './CPUFallbackRenderingTools';
 import type { IVolumeInput, VolumeInputCallback } from './IVolumeInput';
+import type { IStackInput, StackInputCallback } from './IStackInput';
 import type * as EventTypes from './EventTypes';
 import type IRenderingEngine from './IRenderingEngine';
 import type ActorSliceRange from './ActorSliceRange';
 import type ImageSliceData from './ImageSliceData';
 import type IGeometry from './IGeometry';
 import type { PublicContourSetData, ContourSetData, ContourData } from './ContourData';
+import type { PublicSurfaceData, SurfaceData } from './SurfaceData';
 import type ICachedGeometry from './ICachedGeometry';
 import type { IContourSet } from './IContourSet';
 import type { IContour } from './IContour';
 import type RGB from './RGB';
 import { ColormapPublic, ColormapRegistration } from './Colormap';
 import type { ViewportProperties } from './ViewportProperties';
-import type { PixelDataTypedArray } from './PixelDataTypedArray';
+import type { PixelDataTypedArray, PixelDataTypedArrayString } from './PixelDataTypedArray';
 import type { ImagePixelModule } from './ImagePixelModule';
 import type { ImagePlaneModule } from './ImagePlaneModule';
 import type { AffineMatrix } from './AffineMatrix';
-export type { Cornerstone3DConfig, ICamera, IStackViewport, IVolumeViewport, IEnabledElement, ICache, IVolume, VolumeScalarData, IViewportId, IImageVolume, IDynamicImageVolume, IRenderingEngine, ScalingParameters, PTScaling, Scaling, IStreamingImageVolume, IImage, IImageData, IImageCalibration, CPUIImageData, CPUImageData, EventTypes, ImageLoaderFn, VolumeLoaderFn, IRegisterImageLoader, IStreamingVolumeProperties, IViewport, StackViewportProperties, VolumeViewportProperties, ViewportProperties, PublicViewportInput, VolumeActor, Actor, ActorEntry, IImageLoadObject, IVolumeLoadObject, IVolumeInput, VolumeInputCallback, ViewportPreset, Metadata, OrientationVectors, Point2, Point3, Point4, Mat3, Plane, ViewportInputOptions, VOIRange, VOI, DisplayArea, FlipDirection, ICachedImage, ICachedVolume, CPUFallbackEnabledElement, CPUFallbackViewport, CPUFallbackTransform, CPUFallbackColormapData, CPUFallbackViewportDisplayedArea, CPUFallbackColormapsData, CPUFallbackColormap, TransformMatrix2D, CPUFallbackLookupTable, CPUFallbackLUT, CPUFallbackRenderingTools, CustomEventType, ActorSliceRange, ImageSliceData, IGeometry, IGeometryLoadObject, ICachedGeometry, PublicContourSetData, ContourSetData, ContourData, IContourSet, IContour, RGB, ColormapPublic, ColormapRegistration, PixelDataTypedArray, ImagePixelModule, ImagePlaneModule, AffineMatrix, };
+export type { RetrieveStage, RetrieveOptions, RangeRetrieveOptions, StreamingRetrieveOptions, NearbyFrames, IRetrieveConfiguration, IImagesLoader, } from './IRetrieveConfiguration';
+import type { ImageLoadListener } from './ImageLoadListener';
+import type { Color, ColorLUT } from './Color';
+import type VideoViewportProperties from './VideoViewportProperties';
+import type IVideoViewport from './IVideoViewport';
+import type { InternalVideoCamera, VideoViewportInput } from './VideoViewportTypes';
+import { ISurface } from './ISurface';
+import type BoundsIJK from './BoundsIJK';
+import type { ImageVolumeProps } from './ImageVolumeProps';
+import type { VolumeProps } from './VolumeProps';
+import type BoundsLPS from './BoundsLPS';
+import type PointsManager from '../utilities/PointsManager';
+export type { Cornerstone3DConfig, ICamera, IStackViewport, IVideoViewport, IVolumeViewport, IEnabledElement, ICache, IVolume, IViewportId, IImageVolume, ImageVolumeProps, IDynamicImageVolume, IRenderingEngine, ScalingParameters, PTScaling, PointsManager, Scaling, IStreamingImageVolume, IImage, IImageData, IImageCalibration, CPUIImageData, CPUImageData, EventTypes, ImageLoaderFn, VolumeLoaderFn, IRegisterImageLoader, IStreamingVolumeProperties, IViewport, ViewReference, ViewPresentation, ViewPresentationSelector, ReferenceCompatibleOptions, ViewReferenceSpecifier, StackViewportProperties, VolumeViewportProperties, ViewportProperties, PublicViewportInput, VolumeActor, Actor, ActorEntry, ImageActor, ICanvasActor, IImageLoadObject, IVolumeLoadObject, IVolumeInput, VolumeInputCallback, IStackInput, StackInputCallback, ViewportPreset, Metadata, OrientationVectors, AABB2, AABB3, Point2, Point3, PointsXYZ, Point4, Mat3, Plane, ViewportInputOptions, VideoViewportProperties, VOIRange, VOI, DisplayArea, FlipDirection, ICachedImage, ICachedVolume, CPUFallbackEnabledElement, CPUFallbackViewport, CPUFallbackTransform, CPUFallbackColormapData, CPUFallbackViewportDisplayedArea, CPUFallbackColormapsData, CPUFallbackColormap, TransformMatrix2D, CPUFallbackLookupTable, CPUFallbackLUT, CPUFallbackRenderingTools, CustomEventType, ActorSliceRange, ImageSliceData, IGeometry, IGeometryLoadObject, ICachedGeometry, PublicContourSetData, ContourSetData, ContourData, IContourSet, IContour, PublicSurfaceData, SurfaceData, ISurface, RGB, ColormapPublic, ColormapRegistration, PixelDataTypedArray, PixelDataTypedArrayString, ImagePixelModule, ImagePlaneModule, AffineMatrix, ImageLoadListener, InternalVideoCamera, VideoViewportInput, BoundsIJK, BoundsLPS, Color, ColorLUT, VolumeProps, };

package/dist/esm/types/index.js

@@ -1,2 +1 @@
 export {};
-//# sourceMappingURL=index.js.map

package/dist/esm/types/voi.d.ts

@@ -1,8 +1,8 @@
-declare type VOI = {
+type VOI = {
     windowWidth: number;
     windowCenter: number;
 };
-declare type VOIRange = {
+type VOIRange = {
     upper: number;
     lower: number;
 };

package/dist/esm/types/voi.js

@@ -1,2 +1 @@
 export {};
-//# sourceMappingURL=voi.js.map

package/dist/esm/utilities/PointsManager.d.ts

@@ -0,0 +1,33 @@
+import type { Point2, Point3, PointsXYZ } from '../types';
+export type PolyDataPointConfiguration = {
+    dimensions?: number;
+    initialSize?: number;
+    growSize?: number;
+};
+export default class PointsManager<T> {
+    kIndex: number;
+    sources: PointsManager<T>[];
+    data: Float32Array;
+    _dimensions: number;
+    _length: number;
+    _byteSize: number;
+    growSize: number;
+    array: ArrayBuffer;
+    constructor(configuration?: PolyDataPointConfiguration);
+    forEach(func: (value: T, index: number) => void): void;
+    get length(): number;
+    get dimensions(): number;
+    get dimensionLength(): number;
+    getPoint(index: number): T;
+    getPointArray(index: number): T;
+    protected grow(additionalSize?: number, growSize?: number): void;
+    reverse(): void;
+    push(point: T): void;
+    map<R>(f: (value: any, index: number) => R): R[];
+    get points(): T[];
+    toXYZ(): PointsXYZ;
+    static fromXYZ({ x, y, z }: PointsXYZ): PointsManager<Point3>;
+    subselect(count?: number, offset?: number): PointsManager<T>;
+    static create3(initialSize?: number): PointsManager<Point3>;
+    static create2(initialSize?: number): PointsManager<Point2>;
+}

package/dist/esm/utilities/PointsManager.js

@@ -0,0 +1,137 @@
+export default class PointsManager {
+    constructor(configuration = {}) {
+        this._dimensions = 3;
+        this._length = 0;
+        this._byteSize = 4;
+        this.growSize = 128;
+        const { initialSize = 1024, dimensions = 3, growSize = 128, } = configuration;
+        const itemLength = initialSize * dimensions;
+        this.growSize = growSize;
+        this.array = new ArrayBuffer(itemLength * this._byteSize);
+        this.data = new Float32Array(this.array);
+        this._dimensions = dimensions;
+    }
+    forEach(func) {
+        for (let i = 0; i < this._length; i++) {
+            func(this.getPoint(i), i);
+        }
+    }
+    get length() {
+        return this._length;
+    }
+    get dimensions() {
+        return this._dimensions;
+    }
+    get dimensionLength() {
+        return this._length * this._dimensions;
+    }
+    getPoint(index) {
+        if (index < 0) {
+            index += this._length;
+        }
+        if (index < 0 || index >= this._length) {
+            return;
+        }
+        const offset = this._dimensions * index;
+        return this.data.subarray(offset, offset + this._dimensions);
+    }
+    getPointArray(index) {
+        const array = [];
+        if (index < 0) {
+            index += this._length;
+        }
+        if (index < 0 || index >= this._length) {
+            return;
+        }
+        const offset = this._dimensions * index;
+        for (let i = 0; i < this._dimensions; i++) {
+            array.push(this.data[i + offset]);
+        }
+        return array;
+    }
+    grow(additionalSize = 1, growSize = this.growSize) {
+        if (this.dimensionLength + additionalSize * this._dimensions <=
+            this.data.length) {
+            return;
+        }
+        const newSize = this.data.length + growSize;
+        const newArray = new ArrayBuffer(newSize * this._dimensions * this._byteSize);
+        const newData = new Float32Array(newArray);
+        newData.set(this.data);
+        this.data = newData;
+        this.array = newArray;
+    }
+    reverse() {
+        const midLength = Math.floor(this._length / 2);
+        for (let i = 0; i < midLength; i++) {
+            const indexStart = i * this._dimensions;
+            const indexEnd = (this._length - 1 - i) * this._dimensions;
+            for (let dimension = 0; dimension < this._dimensions; dimension++) {
+                const valueStart = this.data[indexStart + dimension];
+                this.data[indexStart + dimension] = this.data[indexEnd + dimension];
+                this.data[indexEnd + dimension] = valueStart;
+            }
+        }
+    }
+    push(point) {
+        this.grow(1);
+        const offset = this.length * this._dimensions;
+        for (let i = 0; i < this._dimensions; i++) {
+            this.data[i + offset] = point[i];
+        }
+        this._length++;
+    }
+    map(f) {
+        const mapData = [];
+        for (let i = 0; i < this._length; i++) {
+            mapData.push(f(this.getPoint(i), i));
+        }
+        return mapData;
+    }
+    get points() {
+        return this.map((p) => p);
+    }
+    toXYZ() {
+        const xyz = { x: [], y: [] };
+        if (this._dimensions >= 3) {
+            xyz.z = [];
+        }
+        const { x, y, z } = xyz;
+        this.forEach((p) => {
+            x.push(p[0]);
+            y.push(p[1]);
+            if (z) {
+                z.push(p[2]);
+            }
+        });
+        return xyz;
+    }
+    static fromXYZ({ x, y, z }) {
+        const array = PointsManager.create3(x.length);
+        let offset = 0;
+        for (let i = 0; i < x.length; i++) {
+            array.data[offset++] = x[i];
+            array.data[offset++] = y[i];
+            array.data[offset++] = z ? z[i] : 0;
+        }
+        array._length = x.length;
+        return array;
+    }
+    subselect(count = 10, offset = 0) {
+        const selected = new PointsManager({
+            initialSize: count,
+            dimensions: this._dimensions,
+        });
+        for (let i = 0; i < count; i++) {
+            const index = (offset + Math.floor((this.length * i) / count)) % this.length;
+            selected.push(this.getPoint(index));
+        }
+        return selected;
+    }
+    static create3(initialSize = 128) {
+        return new PointsManager({ initialSize, dimensions: 3 });
+    }
+    static create2(initialSize = 128) {
+        return new PointsManager({ initialSize, dimensions: 2 });
+    }
+}

package/dist/esm/utilities/ProgressiveIterator.d.ts

@@ -0,0 +1,24 @@
+export declare class PromiseIterator<T> extends Promise<T> {
+    iterator?: ProgressiveIterator<T>;
+}
+export type ErrorCallback = (message: string | Error) => void;
+export default class ProgressiveIterator<T> {
+    done: any;
+    name?: string;
+    private nextValue;
+    private waiting;
+    private rejectReason;
+    constructor(name?: any);
+    static as(promise: any): any;
+    add(x: T, done?: boolean): void;
+    resolve(): void;
+    reject(reason: Error): void;
+    getRecent(): T;
+    [Symbol.asyncIterator](): AsyncGenerator<any, void, unknown>;
+    forEach(callback: any, errorCallback: any): Promise<void>;
+    generate(processFunction: any, errorCallback?: ErrorCallback): Promise<any>;
+    nextPromise(): Promise<T>;
+    donePromise(): Promise<T>;
+    getNextPromise(): PromiseIterator<T>;
+    getDonePromise(): PromiseIterator<T>;
+}

package/dist/esm/utilities/ProgressiveIterator.js

@@ -0,0 +1,139 @@
+export class PromiseIterator extends Promise {
+}
+export default class ProgressiveIterator {
+    constructor(name) {
+        this.name = name || 'unknown';
+    }
+    static as(promise) {
+        if (promise.iterator) {
+            return promise.iterator;
+        }
+        const iterator = new ProgressiveIterator('as iterator');
+        promise.then((v) => {
+            try {
+                iterator.add(v, true);
+            }
+            catch (e) {
+                iterator.reject(e);
+            }
+        }, (reason) => iterator.reject(reason));
+        return iterator;
+    }
+    add(x, done = false) {
+        this.nextValue = x;
+        this.done ||= done;
+        if (this.waiting) {
+            this.waiting.resolve(x);
+            this.waiting = undefined;
+        }
+    }
+    resolve() {
+        this.done = true;
+        if (this.waiting) {
+            this.waiting.resolve(this.nextValue);
+            this.waiting = undefined;
+        }
+    }
+    reject(reason) {
+        this.rejectReason = reason;
+        this.waiting?.reject(reason);
+    }
+    getRecent() {
+        if (this.rejectReason) {
+            throw this.rejectReason;
+        }
+        return this.nextValue;
+    }
+    async *[Symbol.asyncIterator]() {
+        while (!this.done) {
+            if (this.rejectReason) {
+                throw this.rejectReason;
+            }
+            if (this.nextValue !== undefined) {
+                yield this.nextValue;
+                if (this.done) {
+                    break;
+                }
+            }
+            if (!this.waiting) {
+                this.waiting = {};
+                this.waiting.promise = new Promise((resolve, reject) => {
+                    this.waiting.resolve = resolve;
+                    this.waiting.reject = reject;
+                });
+            }
+            await this.waiting.promise;
+        }
+        yield this.nextValue;
+    }
+    async forEach(callback, errorCallback) {
+        let index = 0;
+        try {
+            for await (const value of this) {
+                const { done } = this;
+                try {
+                    await callback(value, done, index);
+                    index++;
+                }
+                catch (e) {
+                    if (!done) {
+                        console.warn('Caught exception in intermediate value', e);
+                        continue;
+                    }
+                    if (errorCallback) {
+                        errorCallback(e, done);
+                    }
+                    else {
+                        throw e;
+                    }
+                }
+            }
+        }
+        catch (e) {
+            if (errorCallback) {
+                errorCallback(e, true);
+            }
+            else {
+                throw e;
+            }
+        }
+    }
+    generate(processFunction, errorCallback) {
+        return processFunction(this, this.reject.bind(this)).then(() => {
+            if (!this.done) {
+                this.resolve();
+            }
+        }, (reason) => {
+            this.reject(reason);
+            if (errorCallback) {
+                errorCallback(reason);
+            }
+            else {
+                console.warn("Couldn't process because", reason);
+            }
+        });
+    }
+    async nextPromise() {
+        for await (const i of this) {
+            if (i) {
+                return i;
+            }
+        }
+        return this.nextValue;
+    }
+    async donePromise() {
+        for await (const i of this) {
+        }
+        return this.nextValue;
+    }
+    getNextPromise() {
+        const promise = this.nextPromise();
+        promise.iterator = this;
+        return promise;
+    }
+    getDonePromise() {
+        const promise = this.donePromise();
+        promise.iterator = this;
+        return promise;
+    }
+}

package/dist/esm/utilities/RLEVoxelMap.d.ts

@@ -0,0 +1,26 @@
+import { PixelDataTypedArray } from '../types';
+export type RLERun<T> = {
+    value: T;
+    start: number;
+    end: number;
+};
+export default class RLEVoxelMap<T> {
+    protected rows: Map<number, RLERun<T>[]>;
+    protected height: number;
+    protected width: number;
+    protected depth: number;
+    protected jMultiple: number;
+    protected kMultiple: number;
+    protected numComps: number;
+    defaultValue: T;
+    pixelDataConstructor: Uint8ArrayConstructor;
+    constructor(width: number, height: number, depth?: number);
+    get: (index: number) => T;
+    protected getRLE(i: number, j: number, k?: number): RLERun<T>;
+    protected findIndex(row: RLERun<T>[], i: number): number;
+    getRun: (j: number, k: number) => RLERun<T>[];
+    set: (index: number, value: T) => void;
+    clear(): void;
+    keys(): number[];
+    getPixelData(k?: number, pixelData?: PixelDataTypedArray): PixelDataTypedArray;
+}