geotiff 3.0.0 → 3.0.1

package/dist-module/geotiff.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"geotiff.d.ts","sourceRoot":"","sources":["../src/geotiff.js"],"names":[],"mappings":"AAohBA;;;;;;;;GAQG;AACH,6BAPW,MAAM,YACN,MAAM,WAEN,WAAW,GAET,OAAO,CAAC,OAAO,CAAC,CAI5B;AAED;;;;;;;;GAQG;AACH,yCAPW,UAAU,YACV,MAAM,WAEN,WAAW,GAET,OAAO,CAAC,OAAO,CAAC,CAI5B;AAED;;;;;;;GAOG;AACH,6CALW,WAAW,WACX,WAAW,GAET,OAAO,CAAC,OAAO,CAAC,CAI5B;AAED;;;;;;;;;;;GAWG;AACH,+BALW,MAAM,WACN,WAAW,GAET,OAAO,CAAC,OAAO,CAAC,CAI5B;AAED;;;;;;;;;GASG;AACH,+BALW,IAAI,GAAC,IAAI,WACT,WAAW,GAET,OAAO,CAAC,OAAO,CAAC,CAI5B;AAED;;;;;;;;;;GAUG;AACH,kCATW,MAAM,iBACN,MAAM,EAAE,YACR,MAAM,WAGN,WAAW,GAET,OAAO,CAAC,YAAY,CAAC,CASjC;AAED;;;;GAIG;AACH,kEAEC;;;yBAtlBY,UAAU,GAAG,SAAS,GAAG,WAAW,GAAG,UAAU,GAAG,WAAW,GAAG,UAAU,GAAG,YAAY,GAAG,YAAY;yBAK1G;IAAE,MAAM,EAAC,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE;;;;;;uCAOhC,UAAU,GAAG,UAAU;;;;;;4CAOvB,UAAU,EAAE,GAAG,UAAU;;;;;;+BAOzB,wBAAwB,GAAG,6BAA6B;;;;;;;AAgMrE;;;GAGG;AAEH;;;GAGG;AACH;IA6IE;;;;;;;OAOG;IACH,0BALW,GAAC,YACD,cAAc,WACd,WAAW,oBAmCrB;IApLD;;;;;;;;OAQG;IACH,oBAPW,GAAC,gBACD,OAAO,WACP,OAAO,kBACP,MAAM,YAEN,cAAc,EAYxB;IARC,YAAoB;IACpB,iCAAgF;IAChF,sBAAgC;IAChC,iBAAsB;IACtB,uBAAoC;IACpC,eAAmC;IACnC,mBAAqB;IACrB,uBAAuB;IAGzB,qDAWC;IAED,qCAkCC;IAED;;;;;OAKG;IACH,iBAHW,MAAM,GACJ,OAAO,CAAC,YAAY,CAAC,CAOjC;IAED;;;;OAIG;IACH,iBAFa,OAAO,CAAC,MAAM,CAAC,CAmB3B;IAED;;;;OAIG;IACH,kBAFa,OAAO,CAAC,MAAM,CAAC,CA4B3B;IA4CD;;;;OAIG;IACH,aAKC;CACF;2BAxbwC,yBAAyB;AA6blE;;;GAGG;AACH;IACE;;;;OAIG;IACH,sBAHW,OAAO,iBACP,OAAO,EAAE,EAWnB;IAPC,kBAAwB;IACxB,yBAAkC;IAClC,sBAAkD;IAElD,sFAAkC;IAClC,mCAAyC;IACzC,0BAAsB;IAGxB,+FAMC;IAED;;;;;OAKG;IACH,iBAHW,MAAM,GACJ,OAAO,CAAC,YAAY,CAAC,CAuBjC;IAED;;;;OAIG;IACH,iBAFa,OAAO,CAAC,MAAM,CAAC,CAW3B;IAHC,kCAA8C;CAIjD;yBAhgBwB,cAAc;4BAFmB,cAAc;qBAGnD,UAAU;2BACQ,wBAAwB;2BAAxB,wBAAwB;0BACrC,cAAc;iBAfvB,WAAW;yBAHH,mBAAmB;6BASH,yBAAyB;AAiIlE;IACE;;;;;;;;;;;OAWG;IACH,sBAHW,OAAO,gBAAgB,EAAE,iBAAiB,GACxC,OAAO,CAAC,gBAAgB,CAAC,CA8FrC;CACF;yCAzOwC,yBAAyB;sBAT5C,gBAAgB"}
+{"version":3,"file":"geotiff.d.ts","sourceRoot":"","sources":["../src/geotiff.js"],"names":[],"mappings":"AAsnBA;;;;;;;;GAQG;AACH,6BAPW,MAAM,YACN,mBAAmB,WAEnB,WAAW,GAET,OAAO,CAAC,OAAO,CAAC,CAI5B;AAED;;;;;;;;GAQG;AACH,yCAPW,UAAU,YACV,mBAAmB,WAEnB,WAAW,GAET,OAAO,CAAC,OAAO,CAAC,CAI5B;AAED;;;;;;;GAOG;AACH,6CALW,WAAW,WACX,WAAW,GAET,OAAO,CAAC,OAAO,CAAC,CAI5B;AAED;;;;;;;;;;;GAWG;AACH,+BALW,MAAM,WACN,WAAW,GAET,OAAO,CAAC,OAAO,CAAC,CAI5B;AAED;;;;;;;;;GASG;AACH,+BALW,IAAI,GAAC,IAAI,WACT,WAAW,GAET,OAAO,CAAC,OAAO,CAAC,CAI5B;AAED;;;;;;;;;;GAUG;AACH,kCATW,MAAM,iBACN,MAAM,EAAE,YACR,mBAAmB,WAGnB,WAAW,GAET,OAAO,CAAC,YAAY,CAAC,CASjC;AAED;;;;;GAKG;AACH,0DAHW,MAAM,GACJ,WAAW,CAIvB;;;yBAxrBY,UAAU,GAAG,SAAS,GAAG,WAAW,GAAG,UAAU,GAAG,WAAW,GAAG,UAAU,GAAG,YAAY,GAAG,YAAY;yBAK1G;IAAE,MAAM,EAAC,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE;;;;;;uCAOhC,UAAU,GAAG,UAAU;;;;;;4CAOvB,UAAU,EAAE,GAAG,UAAU;;;;;;+BAOzB,wBAAwB,GAAG,6BAA6B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6RrE;;;GAGG;AAEH;;GAEG;AACH;IA8IE;;;;;;;OAOG;IACH,0BALW,UAAU,YACV,cAAc,WACd,WAAW,oBAmCrB;IArLD;;;;;;;;OAQG;IACH,oBAPW,UAAU,gBACV,OAAO,WACP,OAAO,kBACP,MAAM,YAEN,cAAc,EAYxB;IARC,mBAAoB;IACpB,iCAAgF;IAChF,sBAAgC;IAChC,iBAAsB;IACtB,uBAAoC;IACpC,eAAmC;IACnC,mBAAqB;IACrB,oBAAuB;IAGzB,qDAWC;IAED,qCAkCC;IAuCD;;;;OAIG;IACH,kBAFa,OAAO,CAAC,MAAM,CAAC,CA6B3B;IA4CD;;;;OAIG;IACH,+BAKC;CACF;2BAthBwC,yBAAyB;AA2hBlE;;;GAGG;AACH;IACE;;;;OAIG;IACH,sBAHW,OAAO,iBACP,OAAO,EAAE,EAWnB;IAPC,kBAAwB;IACxB,yBAAkC;IAClC,sBAAkD;IAElD,sFAAkC;IAClC,mCAAyC;IACzC,0BAAsB;IAGxB,+FAMC;IA8CC,kCAA8C;CAIjD;yBAlmBwB,cAAc;4BAFmB,cAAc;qBAGnD,UAAU;2BACQ,wBAAwB;2BAAxB,wBAAwB;0BACrC,cAAc;iBAfvB,WAAW;yBAHH,mBAAmB;6BASH,yBAAyB;AAwMlE;IACE;;;OAGG;IACH,kBAHW,MAAM,GACJ,OAAO,CAAC,YAAY,CAAC,CAIjC;IAED;;OAEG;IACH,iBAFa,OAAO,CAAC,MAAM,CAAC,CAI3B;IAED;;;;;;OAMG;IAEH;;;;;;;;;;;OAWG;IACH,sBAHW,kBAAkB;;;;;;;;;;;;;;KAA2B,GAC3C,OAAO,CAAC,gBAAgB,CAAC,CA8FrC;CACF;gCA/T+B,wBAAwB;yCARf,yBAAyB;sBAT5C,gBAAgB"}

package/dist-module/geotiff.js

@@ -15,6 +15,7 @@ import * as globals from './globals.js';
 import * as rgb from './rgb.js';
 import { getDecoder, addDecoder } from './compression/index.js';
 import { setLogger } from './logging.js';
+/** @import { BaseSource } from './source/basesource.js' */
 export { globals };
 export { registerTag };
 export { rgb };
@@ -46,7 +47,69 @@ export { setLogger };
  * `(TypedArray | TypedArray[]) & { height: number; width: number}`
  * @typedef {TypedArrayWithDimensions | TypedArrayArrayWithDimensions} ReadRasterResult
  */
+/**
+ * @typedef {Object} ReadRastersOptions
+ * @property {Array<number>} [window] the subset to read data from in pixels. Whole window if not specified.
+ * @property {Array<number>} [samples] the selection of samples to read from. Default is all samples.
+ *     All samples if not specified.
+ * @property {Pool|null} [pool=null] The optional decoder pool to use.
+ * @property {number} [width] The desired width of the output. When the width is not the
+ *                                 same as the images, resampling will be performed.
+ * @property {number} [height] The desired height of the output. When the width is not the
+ *                                  same as the images, resampling will be performed.
+ * @property {string} [resampleMethod='nearest'] The desired resampling method.
+ * @property {AbortSignal} [signal] An AbortSignal that may be signalled if the request is
+ *                                       to be aborted
+ * @property {number|number[]} [fillValue] The value to use for parts of the image
+ *     outside of the images extent. When multiple samples are requested and `interleave` is
+ *     `false`, an array of fill values can be passed.
+ * @property {boolean|true|false} [interleave] whether the data shall be read
+ *     in one single array or separate arrays.
+ */
+/**
+ * @typedef {Object} ReadRGBOptions
+ * @property {Array<number>} [window] the subset to read data from in pixels. Whole window if not specified.
+ * @property {Pool|null} [pool=null] The optional decoder pool to use.
+ * @property {number} [width] The desired width of the output. When the width is no the
+ *                                 same as the images, resampling will be performed.
+ * @property {number} [height] The desired height of the output. When the width is no the
+ *                                  same as the images, resampling will be performed.
+ * @property {string} [resampleMethod='nearest'] The desired resampling method.
+ * @property {boolean} [enableAlpha=false] Enable reading alpha channel if present.
+ * @property {AbortSignal} [signal] An AbortSignal that may be signalled if the request is
+ *                                       to be aborted
+ * @property {boolean|true|false} [interleave] whether the data shall be read
+ *     in one single array or separate arrays.
+ */
+/**
+ * @typedef {Object} BlockedSourceOptions
+ * @property {number|null} [blockSize=null] Block size for a BlockedSource.
+ * @property {number} [cacheSize=100] The number of blocks to cache.
+ */
+/**
+ * @typedef {Object} RemoteSourceOptions
+ * @property {Object} [headers={}] Additional headers to add to each request
+ * @property {number} [maxRanges=0] Maximum number of ranges to request in a single HTTP request. 0 means no multi-range requests.
+ * @property {boolean} [allowFullFile=false] Whether to allow full file responses when requesting ranges
+ * @property {boolean} [forceXHR=false] When the Fetch API would be used, force using XMLHttpRequest instead.
+ */
+/**
+ * @overload
+ * @param {DataSlice} dataSlice
+ * @param {0x0002} fieldType
+ * @param {number} count
+ * @param {number} offset
+ * @returns {string}
+ */
+/**
+ * @param {DataSlice} dataSlice
+ * @param {import('./globals.js').FieldType} fieldType
+ * @param {number} count
+ * @param {number} offset
+ * @returns {TypedArray|Array<number>|string}
+ */
 function getValues(dataSlice, fieldType, count, offset) {
+    /** @type {TypedArray|Array|null} */
     let values = null;
     let readMethod = null;
     const fieldTypeLength = getFieldTypeSize(fieldType);
@@ -104,7 +167,10 @@ function getValues(dataSlice, fieldType, count, offset) {
             readMethod = dataSlice.readFloat64;
             break;
         default:
-            throw new RangeError(`Invalid field type: ${fieldType}`);
+        // will throw below
+    }
+    if (values === null || readMethod === null) {
+        throw new RangeError(`Invalid field type: ${fieldType}`);
     }
     // normal fields
     if (!(fieldType === fieldTypes.RATIONAL || fieldType === fieldTypes.SRATIONAL)) {
@@ -119,7 +185,7 @@ function getValues(dataSlice, fieldType, count, offset) {
         }
     }
     if (fieldType === fieldTypes.ASCII) {
-        return new TextDecoder('utf-8').decode(values);
+        return new TextDecoder('utf-8').decode(/** @type {Uint8Array} */ (values));
     }
     return values;
 }
@@ -134,6 +200,26 @@ class GeoTIFFImageIndexError extends Error {
     }
 }
 class GeoTIFFBase {
+    /**
+     * @param {number} [_index=0] the index of the image to return.
+     * @returns {Promise<GeoTIFFImage>} the image at the given index
+     */
+    async getImage(_index = 0) {
+        throw new Error('Not implemented');
+    }
+    /**
+     * @returns {Promise<number>} the number of internal subfile images
+     */
+    async getImageCount() {
+        throw new Error('Not implemented');
+    }
+    /**
+     * @typedef {Object} ReadRastersWindowOptions
+     * @property {number} [resX] desired Y resolution (world units per pixel)
+     * @property {number} [resY] desired X resolution (world units per pixel)
+     * @property {Array<number>} [bbox] the subset to read data from in
+     *     geographical coordinates. Whole image if not specified.
+     */
     /**
      * (experimental) Reads raster data from the best fitting image. This function uses
      * the image with the lowest resolution that is still a higher resolution than the
@@ -143,7 +229,7 @@ class GeoTIFFBase {
      * Then, the [readRasters]{@link GeoTIFFImage#readRasters} method of the selected
      * image is called and the result returned.
      * @see GeoTIFFImage.readRasters
-     * @param {import('./geotiffimage').ReadRasterOptions} [options={}] optional parameters
+     * @param {ReadRastersOptions & ReadRastersWindowOptions} options optional parameters
      * @returns {Promise<ReadRasterResult>} the decoded array(s), with `height` and `width`, as a promise
      */
     async readRasters(options = {}) {
@@ -233,12 +319,11 @@ class GeoTIFFBase {
  */
 /**
  * The abstraction for a whole GeoTIFF file.
- * @augments GeoTIFFBase
  */
 class GeoTIFF extends GeoTIFFBase {
     /**
      * @constructor
-     * @param {*} source The datasource to read from.
+     * @param {BaseSource} source The datasource to read from.
      * @param {boolean} littleEndian Whether the image uses little endian.
      * @param {boolean} bigTiff Whether the image uses bigTIFF conventions.
      * @param {number} firstIFDOffset The numeric byte-offset from the start of the image
@@ -308,7 +393,7 @@ class GeoTIFF extends GeoTIFFBase {
      * @returns {Promise<GeoTIFFImage>} the image at the given index
      */
     async getImage(index = 0) {
-        return new GeoTIFFImage(await this.requestIFD(index), this.dataView, this.littleEndian, this.cache, this.source);
+        return new GeoTIFFImage(await this.requestIFD(index), this.littleEndian, this.cache, this.source);
     }
     /**
      * Returns the count of the internal subfiles.
@@ -356,6 +441,7 @@ class GeoTIFF extends GeoTIFFBase {
                 slice = await this.getSlice(offset, metadataSize);
             }
             const fullString = getValues(slice, fieldTypes.ASCII, metadataSize, offset);
+            /** @type {Object} */
             this.ghostValues = {};
             fullString
                 .split('\n')
@@ -370,7 +456,7 @@ class GeoTIFF extends GeoTIFFBase {
     /**
      * Parse a (Geo)TIFF file from the given source.
      *
-     * @param {*} source The source of data to parse from.
+     * @param {BaseSource} source The source of data to parse from.
      * @param {GeoTIFFOptions} [options] Additional options.
      * @param {AbortSignal} [signal] An AbortSignal that may be signalled if the request is
      *                               to be aborted
@@ -455,7 +541,11 @@ class MultiGeoTIFF extends GeoTIFFBase {
      * @returns {Promise<GeoTIFFImage>} the image at the given index
      */
     async getImage(index = 0) {
+        // Initialize this.imageCounts if not yet done
         await this.getImageCount();
+        if (!this.imageCounts) {
+            throw new Error('Image counts not available');
+        }
         await this.parseFileDirectoriesPerFile();
         let visited = 0;
         let relativeIndex = 0;
@@ -463,7 +553,7 @@ class MultiGeoTIFF extends GeoTIFFBase {
             const imageFile = this.imageFiles[i];
             for (let ii = 0; ii < this.imageCounts[i]; ii++) {
                 if (index === visited) {
-                    return new GeoTIFFImage(await imageFile.requestIFD(relativeIndex), imageFile.dataView, imageFile.littleEndian, imageFile.cache, imageFile.source);
+                    return new GeoTIFFImage(await imageFile.requestIFD(relativeIndex), imageFile.littleEndian, imageFile.cache, imageFile.source);
                 }
                 visited++;
                 relativeIndex++;
@@ -492,26 +582,26 @@ export { MultiGeoTIFF };
 /**
  * Creates a new GeoTIFF from a remote URL.
  * @param {string} url The URL to access the image from
- * @param {object} [options] Additional options to pass to the source.
+ * @param {RemoteSourceOptions} [options] Additional options to pass to the source.
  *                           See {@link makeRemoteSource} for details.
  * @param {AbortSignal} [signal] An AbortSignal that may be signalled if the request is
  *                               to be aborted
  * @returns {Promise<GeoTIFF>} The resulting GeoTIFF file.
  */
 export async function fromUrl(url, options = {}, signal) {
-    return GeoTIFF.fromSource(makeRemoteSource(url, options), signal);
+    return GeoTIFF.fromSource(makeRemoteSource(url, options), undefined, signal);
 }
 /**
  * Creates a new GeoTIFF from a custom {@link BaseClient}.
  * @param {BaseClient} client The client.
- * @param {object} [options] Additional options to pass to the source.
+ * @param {RemoteSourceOptions} [options] Additional options to pass to the source.
  *                           See {@link makeRemoteSource} for details.
  * @param {AbortSignal} [signal] An AbortSignal that may be signalled if the request is
  *                               to be aborted
  * @returns {Promise<GeoTIFF>} The resulting GeoTIFF file.
  */
 export async function fromCustomClient(client, options = {}, signal) {
-    return GeoTIFF.fromSource(makeCustomSource(client, options), signal);
+    return GeoTIFF.fromSource(makeCustomSource(client, options), undefined, signal);
 }
 /**
  * Construct a new GeoTIFF from an
@@ -522,7 +612,7 @@ export async function fromCustomClient(client, options = {}, signal) {
  * @returns {Promise<GeoTIFF>} The resulting GeoTIFF file.
  */
 export async function fromArrayBuffer(arrayBuffer, signal) {
-    return GeoTIFF.fromSource(makeBufferSource(arrayBuffer), signal);
+    return GeoTIFF.fromSource(makeBufferSource(arrayBuffer), undefined, signal);
 }
 /**
  * Construct a GeoTIFF from a local file path. This uses the node
@@ -537,7 +627,7 @@ export async function fromArrayBuffer(arrayBuffer, signal) {
  * @returns {Promise<GeoTIFF>} The resulting GeoTIFF file.
  */
 export async function fromFile(path, signal) {
-    return GeoTIFF.fromSource(makeFileSource(path), signal);
+    return GeoTIFF.fromSource(makeFileSource(path), undefined, signal);
 }
 /**
  * Construct a GeoTIFF from an HTML
@@ -550,13 +640,13 @@ export async function fromFile(path, signal) {
  * @returns {Promise<GeoTIFF>} The resulting GeoTIFF file.
  */
 export async function fromBlob(blob, signal) {
-    return GeoTIFF.fromSource(makeFileReaderSource(blob), signal);
+    return GeoTIFF.fromSource(makeFileReaderSource(blob), undefined, signal);
 }
 /**
  * Construct a MultiGeoTIFF from the given URLs.
  * @param {string} mainUrl The URL for the main file.
  * @param {string[]} overviewUrls An array of URLs for the overview images.
- * @param {Object} [options] Additional options to pass to the source.
+ * @param {RemoteSourceOptions} [options] Additional options to pass to the source.
  *                           See [makeRemoteSource]{@link module:source.makeRemoteSource}
  *                           for details.
  * @param {AbortSignal} [signal] An AbortSignal that may be signalled if the request is
@@ -564,14 +654,15 @@ export async function fromBlob(blob, signal) {
  * @returns {Promise<MultiGeoTIFF>} The resulting MultiGeoTIFF file.
  */
 export async function fromUrls(mainUrl, overviewUrls = [], options = {}, signal) {
-    const mainFile = await GeoTIFF.fromSource(makeRemoteSource(mainUrl, options), signal);
-    const overviewFiles = await Promise.all(overviewUrls.map((url) => GeoTIFF.fromSource(makeRemoteSource(url, options))));
+    const mainFile = await GeoTIFF.fromSource(makeRemoteSource(mainUrl, options), undefined, signal);
+    const overviewFiles = await Promise.all(overviewUrls.map((url) => GeoTIFF.fromSource(makeRemoteSource(url, options), undefined, signal)));
     return new MultiGeoTIFF(mainFile, overviewFiles);
 }
 /**
  * Main creating function for GeoTIFF files.
- * @param {(Array)} array of pixel values
- * @returns {metadata} metadata
+ * @param {Array} values of pixel values
+ * @param {Object} metadata
+ * @returns {ArrayBuffer}
  */
 export function writeArrayBuffer(values, metadata) {
     return writeGeotiff(values, metadata);

package/dist-module/geotiffimage.d.ts

@@ -1,87 +1,33 @@
 export default GeoTIFFImage;
-export type ReadRasterOptions = {
-    /**
-     * window] the subset to read data from in pixels.
-     */
-    window?: number[] | undefined;
-    /**
-     * image] the subset to read data from in
-     *      geographical coordinates.
-     */
-    bbox?: number[] | undefined;
-    /**
-     * samples] the selection of samples to read from. Default is all samples.
-     */
-    samples?: number[] | undefined;
-    /**
-     * whether the data shall be read
-     *       in one single array or separate
-     *       arrays.
-     */
-    interleave?: boolean | undefined;
-    /**
-     * The optional decoder pool to use.
-     */
-    pool?: Pool;
-    /**
-     * The desired width of the output. When the width is not the
-     *       same as the images, resampling will be performed.
-     */
-    width?: number | undefined;
-    /**
-     * The desired height of the output. When the width is not the
-     *       same as the images, resampling will be performed.
-     */
-    height?: number | undefined;
-    /**
-     * The desired resampling method.
-     */
-    resampleMethod?: string | undefined;
-    /**
-     * An AbortSignal that may be signalled if the request is
-     *       to be aborted
-     */
-    signal?: AbortSignal | undefined;
-    /**
-     * The value to use for parts of the image
-     *       outside of the images extent. When multiple
-     *       samples are requested, an array of fill values
-     *       can be passed.
-     */
-    fillValue?: number | number[] | undefined;
-};
-export type TypedArray = import("./geotiff.js").TypedArray;
-export type ReadRasterResult = import("./geotiff.js").ReadRasterResult;
 /**
  * GeoTIFF sub-file image.
  */
 declare class GeoTIFFImage {
     /**
      * @constructor
-     * @param {import("./imagefiledirectory.js").ImageFileDirectory} fileDirectory The parsed file directory
-     * @param {DataView} dataView The DataView for the underlying file.
+     * @param {import("./imagefiledirectory").ImageFileDirectory} fileDirectory The parsed file directory
      * @param {Boolean} littleEndian Whether the file is encoded in little or big endian
      * @param {Boolean} cache Whether or not decoded tiles shall be cached
-     * @param {import('./source/basesource').BaseSource} source The datasource to read from
+     * @param {import('./source/basesource.js').BaseSource} source The datasource to read from
      */
-    constructor(fileDirectory: import("./imagefiledirectory.js").ImageFileDirectory, dataView: DataView, littleEndian: boolean, cache: boolean, source: import("./source/basesource").BaseSource);
-    fileDirectory: import("./imagefiledirectory.js").ImageFileDirectory;
-    dataView: DataView<ArrayBufferLike>;
+    constructor(fileDirectory: import("./imagefiledirectory").ImageFileDirectory, littleEndian: boolean, cache: boolean, source: import("./source/basesource.js").BaseSource);
+    fileDirectory: import("./imagefiledirectory").ImageFileDirectory;
     littleEndian: boolean;
     tiles: {} | null;
     isTiled: boolean;
-    planarConfiguration: any;
-    source: import("./source/basesource").BaseSource;
+    /** @type {1 | 2} */
+    planarConfiguration: 1 | 2;
+    source: import("./source/basesource.js").BaseSource;
     /**
      * Returns the associated parsed file directory.
-     * @returns {import("./imagefiledirectory.js").ImageFileDirectory} the parsed file directory
+     * @returns {import("./imagefiledirectory").ImageFileDirectory} the parsed file directory
      */
-    getFileDirectory(): import("./imagefiledirectory.js").ImageFileDirectory;
+    getFileDirectory(): import("./imagefiledirectory").ImageFileDirectory;
     /**
      * Returns the associated parsed geo keys.
-     * @returns {Record<import('./globals.js').GeoKeyName, *>|null} the parsed geo keys
+     * @returns {Partial<Record<import('./globals.js').GeoKeyName, *>>|null} the parsed geo keys
      */
-    getGeoKeys(): Record<import("./globals.js").GeoKeyName, any> | null;
+    getGeoKeys(): Partial<Record<import("./globals.js").GeoKeyName, any>> | null;
     /**
      * Returns the width of the image.
      * @returns {Number} the width of the image
@@ -142,59 +88,76 @@ declare class GeoTIFFImage {
      * @param {Array} imageWindow The image window in pixel coordinates
      * @param {Array} samples The selected samples (0-based indices)
      * @param {TypedArray|TypedArray[]} valueArrays The array(s) to write into
-     * @param {Boolean} interleave Whether or not to write in an interleaved manner
-     * @param {import("./geotiff").Pool|AbstractDecoder} poolOrDecoder the decoder or decoder pool
-     * @param {number} width the width of window to be read into
-     * @param {number} height the height of window to be read into
-     * @param {number} resampleMethod the resampling method to be used when interpolating
+     * @param {boolean|undefined} interleave Whether or not to write in an interleaved manner
+     * @param {import("./geotiff").Pool|import("./geotiff").BaseDecoder} poolOrDecoder the decoder or decoder pool
+     * @param {number} [width] the width of window to be read into
+     * @param {number} [height] the height of window to be read into
+     * @param {string} [resampleMethod] the resampling method to be used when interpolating
      * @param {AbortSignal} [signal] An AbortSignal that may be signalled if the request is
      *                               to be aborted
      * @returns {Promise<ReadRasterResult>}
      */
     private _readRaster;
     /**
-     * Reads raster data from the image. This function reads all selected samples
-     * into separate arrays of the correct type for that sample or into a single
-     * combined array when `interleave` is set. When provided, only a subset
-     * of the raster is read for each sample.
-     *
-     * @param {ReadRasterOptions} [options={}] optional parameters
+     * @overload
+     * @param {ReadRastersOptions & {interleave: true}} options optional parameters
+     * @returns {Promise<import("./geotiff").TypedArrayWithDimensions>} the decoded arrays as a promise
+     */
+    readRasters(options: ReadRastersOptions & {
+        interleave: true;
+    }): Promise<import("./geotiff").TypedArrayWithDimensions>;
+    /**
+     * @overload
+     * @param {ReadRastersOptions & {interleave: false}} options optional parameters
+     * @returns {Promise<import("./geotiff").TypedArrayArrayWithDimensions>} the decoded arrays as a promise
+     */
+    readRasters(options: ReadRastersOptions & {
+        interleave: false;
+    }): Promise<import("./geotiff").TypedArrayArrayWithDimensions>;
+    /**
+     * @overload
+     * @param {ReadRastersOptions & {interleave: boolean}} options optional parameters
      * @returns {Promise<ReadRasterResult>} the decoded arrays as a promise
      */
-    readRasters({ window: wnd, samples, interleave, pool, width, height, resampleMethod, fillValue, signal, }?: ReadRasterOptions): Promise<ReadRasterResult>;
+    readRasters(options: ReadRastersOptions & {
+        interleave: boolean;
+    }): Promise<ReadRasterResult>;
+    /**
+     * @overload
+     * @param {ReadRastersOptions} [options={}] optional parameters
+     * @returns {Promise<import("./geotiff").TypedArrayArrayWithDimensions>} the decoded arrays as a promise
+     */
+    readRasters(options?: ReadRastersOptions | undefined): Promise<import("./geotiff").TypedArrayArrayWithDimensions>;
     /**
-     * Reads raster data from the image as RGB.
-     * Colorspaces other than RGB will be transformed to RGB, color maps expanded.
-     * When no other method is applicable, the first sample is used to produce a
-     * grayscale image.
-     * When provided, only a subset of the raster is read for each sample.
-     *
-     * @param {Object} [options] optional parameters
-     * @param {Array<number>} [options.window] the subset to read data from in pixels.
-     * @param {boolean} [options.interleave=true] whether the data shall be read
-     *                                             in one single array or separate
-     *                                             arrays.
-     * @param {import("./geotiff").Pool} [options.pool=null] The optional decoder pool to use.
-     * @param {number} [options.width] The desired width of the output. When the width is no the
-     *                                 same as the images, resampling will be performed.
-     * @param {number} [options.height] The desired height of the output. When the width is no the
-     *                                  same as the images, resampling will be performed.
-     * @param {string} [options.resampleMethod='nearest'] The desired resampling method.
-     * @param {boolean} [options.enableAlpha=false] Enable reading alpha channel if present.
-     * @param {AbortSignal} [options.signal] An AbortSignal that may be signalled if the request is
-     *                                       to be aborted
+     * @overload
+     * @param {ReadRGBOptions & {interleave: true}} options optional parameters
+     * @returns {Promise<import("./geotiff").TypedArrayWithDimensions>} the RGB array as a Promise
+     */
+    readRGB(options: ReadRGBOptions & {
+        interleave: true;
+    }): Promise<import("./geotiff").TypedArrayWithDimensions>;
+    /**
+     * @overload
+     * @param {ReadRGBOptions & {interleave: false}} options optional parameters
+     * @returns {Promise<import("./geotiff").TypedArrayArrayWithDimensions>} the RGB array as a Promise
+     */
+    readRGB(options: ReadRGBOptions & {
+        interleave: false;
+    }): Promise<import("./geotiff").TypedArrayArrayWithDimensions>;
+    /**
+     * @overload
+     * @param {ReadRGBOptions & {interleave: boolean}} options optional parameters
      * @returns {Promise<ReadRasterResult>} the RGB array as a Promise
      */
-    readRGB({ window, interleave, pool, width, height, resampleMethod, enableAlpha, signal }?: {
-        window?: number[] | undefined;
-        interleave?: boolean | undefined;
-        pool?: import("./pool.js").default | undefined;
-        width?: number | undefined;
-        height?: number | undefined;
-        resampleMethod?: string | undefined;
-        enableAlpha?: boolean | undefined;
-        signal?: AbortSignal | undefined;
+    readRGB(options: ReadRGBOptions & {
+        interleave: boolean;
     }): Promise<ReadRasterResult>;
+    /**
+     * @overload
+     * @param {ReadRGBOptions} [options={}] optional parameters
+     * @returns {Promise<import("./geotiff").TypedArrayArrayWithDimensions>} the RGB array as a Promise
+     */
+    readRGB(options?: ReadRGBOptions | undefined): Promise<import("./geotiff").TypedArrayArrayWithDimensions>;
     /**
      * Returns an array of tiepoints.
      * @returns {Promise<Object[]>}
@@ -206,10 +169,10 @@ declare class GeoTIFFImage {
      * If sample is passed to null, dataset-level metadata will be returned.
      * Otherwise only metadata specific to the provided sample will be returned.
      *
-     * @param {number} [sample=null] The sample index.
+     * @param {number|null} [sample=null] The sample index.
      * @returns {Promise<Object>}
      */
-    getGDALMetadata(sample?: number): Promise<Object>;
+    getGDALMetadata(sample?: number | null): Promise<Object>;
     /**
      * Returns the GDAL nodata value
      * @returns {number|null}
@@ -224,12 +187,12 @@ declare class GeoTIFFImage {
     /**
      * Returns the image resolution as a XYZ-vector. When the image has no affine
      * transformation, then an exception is thrown.
-     * @param {GeoTIFFImage} [referenceImage=null] A reference image to calculate the resolution from
+     * @param {GeoTIFFImage|null} [referenceImage=null] A reference image to calculate the resolution from
      *                                             in cases when the current image does not have the
      *                                             required tags on its own.
      * @returns {Array<number>} The resolution as a vector
      */
-    getResolution(referenceImage?: GeoTIFFImage): Array<number>;
+    getResolution(referenceImage?: GeoTIFFImage | null): Array<number>;
     /**
      * Returns whether or not the pixels of the image depict an area (or point).
      * @returns {Boolean} Whether the pixels are a point
@@ -245,4 +208,7 @@ declare class GeoTIFFImage {
      */
     getBoundingBox(tilegrid?: boolean): Array<number>;
 }
+import type { ReadRastersOptions } from "./geotiff";
+import type { ReadRasterResult } from "./geotiff";
+import type { ReadRGBOptions } from "./geotiff";
 //# sourceMappingURL=geotiffimage.d.ts.map

package/dist-module/geotiffimage.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"geotiffimage.d.ts","sourceRoot":"","sources":["../src/geotiffimage.js"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;WAmBc,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;yBAcJ,OAAO,cAAc,EAAE,UAAU;+BACjC,OAAO,cAAc,EAAE,gBAAgB;AA0IrD;;GAEG;AACH;IACE;;;;;;;OAOG;IACH,2BANW,OAAO,yBAAyB,EAAE,kBAAkB,YACpD,QAAQ,iDAGR,OAAO,qBAAqB,EAAE,UAAU,EAelD;IAZC,oEAAkC;IAClC,oCAAwB;IACxB,sBAAgC;IAChC,iBAA8B;IAC9B,iBAAoD;IAEpD,yBAAiG;IAKjG,iDAAoB;IAGtB;;;OAGG;IACH,oBAFa,OAAO,yBAAyB,EAAE,kBAAkB,CAIhE;IAED;;;OAGG;IACH,cAFa,MAAM,CAAC,OAAO,cAAc,EAAE,UAAU,EAAE,GAAC,CAAC,GAAC,IAAI,CAI7D;IAED;;;OAGG;IACH,mBAEC;IAED;;;OAGG;IACH,oBAEC;IAED;;;OAGG;IACH,6BAGC;IAED;;;OAGG;IACH,uBAEC;IAED;;;OAGG;IACH,wBAQC;IAED,wBAEC;IAED,+BAMC;IAED;;;;OAIG;IACH,2BAQC;IAED,kCAMC;IAED,6FAyCC;IAED,2CAGC;IAED,4CAEC;IAED,mMAIC;IAED;;;;;;;;;OASG;IACH,oEALW,OAAO,WAAW,EAAE,IAAI,GAAC,OAAO,WAAW,EAAE,WAAW,WACxD,WAAW,GAET,OAAO,CAAE;QAAC,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,WAAW,CAAA;KAAC,CAAC,CAkE/E;IAED;;;;;;;;;;;;;;OAcG;IACH,oBAsHC;IAED;;;;;;;;OAQG;IACH,4GAHW,iBAAiB,GACf,OAAO,CAAC,gBAAgB,CAAC,CA6DrC;IAED;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,2FAfG;QAAgC,MAAM;QACZ,UAAU;QAGO,IAAI;QACtB,KAAK;QAEL,MAAM;QAEN,cAAc;QACb,WAAW;QACP,MAAM;KAEpC,GAAU,OAAO,CAAC,gBAAgB,CAAC,CA0GrC;IAED;;;OAGG;IACH,gBAFa,OAAO,CAAC,MAAM,EAAE,CAAC,CAoB7B;IAED;;;;;;;;OAQG;IACH,yBAHW,MAAM,GACJ,OAAO,CAAC,MAAM,CAAC,CAsB3B;IAED;;;OAGG;IACH,iBAFa,MAAM,GAAC,IAAI,CAQvB;IAED;;;;OAIG;IACH,aAFa,KAAK,CAAC,MAAM,CAAC,CAoBzB;IAED;;;;;;;OAOG;IACH,+BALW,YAAY,GAGV,KAAK,CAAC,MAAM,CAAC,CAuCzB;IAED;;;OAGG;IACH,uBAEC;IAED;;;;;;;OAOG;IACH,0BAJW,OAAO,GAEL,KAAK,CAAC,MAAM,CAAC,CAgDzB;CACF"}
+{"version":3,"file":"geotiffimage.d.ts","sourceRoot":"","sources":["../src/geotiffimage.js"],"names":[],"mappings":";AAuJA;;GAEG;AACH;IACE;;;;;;OAMG;IACH,2BALW,OAAO,sBAAsB,EAAE,kBAAkB,iDAGjD,OAAO,wBAAwB,EAAE,UAAU,EAerD;IAZC,iEAAkC;IAClC,sBAAgC;IAChC,iBAA8B;IAC9B,iBAAoD;IAKpD,oBAAoB;IACpB,qBADW,CAAC,GAAG,CAAC,CAC8B;IAE9C,oDAAoB;IAGtB;;;OAGG;IACH,oBAFa,OAAO,sBAAsB,EAAE,kBAAkB,CAI7D;IAED;;;OAGG;IACH,cAFa,OAAO,CAAC,MAAM,CAAC,OAAO,cAAc,EAAE,UAAU,EAAE,GAAC,CAAC,CAAC,GAAC,IAAI,CAItE;IAED;;;OAGG;IACH,mBAEC;IAED;;;OAGG;IACH,oBAEC;IAED;;;OAGG;IACH,6BAGC;IAED;;;OAGG;IACH,uBAEC;IAED;;;OAGG;IACH,wBAQC;IAED,wBAEC;IAED,+BAMC;IAED;;;;OAIG;IACH,2BAQC;IAED,kCAMC;IAED,6FAyCC;IAED,2CAGC;IAED,4CAEC;IAED,mMAIC;IAED;;;;;;;;;OASG;IACH,oEALW,OAAO,WAAW,EAAE,IAAI,GAAC,OAAO,WAAW,EAAE,WAAW,WACxD,WAAW,GAET,OAAO,CAAE;QAAC,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,WAAW,CAAA;KAAC,CAAC,CAqE/E;IAED;;;;;;;;;;;;;;OAcG;IACH,oBA6HC;;;;;;IAGE,qBACQ,kBAAkB,GAAG;QAAC,UAAU,EAAE,IAAI,CAAA;KAAC,GACrC,OAAO,CAAC,OAAO,WAAW,EAAE,wBAAwB,CAAC,CACjE;;;;;;IAGE,qBACQ,kBAAkB,GAAG;QAAC,UAAU,EAAE,KAAK,CAAA;KAAC,GACtC,OAAO,CAAC,OAAO,WAAW,EAAE,6BAA6B,CAAC,CACtE;;;;;;IAGE,qBACQ,kBAAkB,GAAG;QAAC,UAAU,EAAE,OAAO,CAAA;KAAC,GACxC,OAAO,CAAC,gBAAgB,CAAC,CACrC;;;;;;IAGE,uDAEU,OAAO,CAAC,OAAO,WAAW,EAAE,6BAA6B,CAAC,CACtE;;;;;;IA+EE,iBACQ,cAAc,GAAG;QAAC,UAAU,EAAE,IAAI,CAAA;KAAC,GACjC,OAAO,CAAC,OAAO,WAAW,EAAE,wBAAwB,CAAC,CACjE;;;;;;IAGE,iBACQ,cAAc,GAAG;QAAC,UAAU,EAAE,KAAK,CAAA;KAAC,GAClC,OAAO,CAAC,OAAO,WAAW,EAAE,6BAA6B,CAAC,CACtE;;;;;;IAGE,iBACQ,cAAc,GAAG;QAAC,UAAU,EAAE,OAAO,CAAA;KAAC,GACpC,OAAO,CAAC,gBAAgB,CAAC,CACrC;;;;;;IAGE,+CAEU,OAAO,CAAC,OAAO,WAAW,EAAE,6BAA6B,CAAC,CACtE;IA2HD;;;OAGG;IACH,gBAFa,OAAO,CAAC,MAAM,EAAE,CAAC,CAoB7B;IAED;;;;;;;;OAQG;IACH,yBAHW,MAAM,GAAC,IAAI,GACT,OAAO,CAAC,MAAM,CAAC,CAsB3B;IAED;;;OAGG;IACH,iBAFa,MAAM,GAAC,IAAI,CAQvB;IAED;;;;OAIG;IACH,aAFa,KAAK,CAAC,MAAM,CAAC,CAoBzB;IAED;;;;;;;OAOG;IACH,+BALW,YAAY,GAAC,IAAI,GAGf,KAAK,CAAC,MAAM,CAAC,CAuCzB;IAED;;;OAGG;IACH,uBAEC;IAED;;;;;;;OAOG;IACH,0BAJW,OAAO,GAEL,KAAK,CAAC,MAAM,CAAC,CAgDzB;CACF;wCA79BqC,WAAW;sCADb,WAAW;oCAEb,WAAW"}