geotiff 3.0.0 → 3.0.1

package/dist-module/source/client/http.js

@@ -6,7 +6,7 @@ import { AbortError } from '../../utils.js';
 class HttpResponse extends BaseResponse {
     /**
      * BaseResponse facade for node HTTP/HTTPS API Response
-     * @param {http.ServerResponse} response
+     * @param {import('http').IncomingMessage} response
      */
     constructor(response, dataPromise) {
         super();
@@ -14,10 +14,10 @@ class HttpResponse extends BaseResponse {
         this.dataPromise = dataPromise;
     }
     get status() {
-        return this.response.statusCode;
+        return /** @type {number} */ (this.response.statusCode);
     }
     getHeader(name) {
-        return this.response.headers[name];
+        return /** @type {string|null} */ (this.response.headers[name]);
     }
     async getData() {
         const data = await this.dataPromise;
@@ -60,7 +60,7 @@ export class HttpClient extends BaseClient {
             }
         });
     }
-    async request({ headers, signal } = {}) {
+    async request({ headers = undefined, signal = undefined } = {}) {
         const response = await this.constructRequest(headers, signal);
         return response;
     }

package/dist-module/source/client/xhr.d.ts

@@ -1,6 +1,9 @@
 export class XHRClient extends BaseClient {
     constructRequest(headers: any, signal: any): Promise<any>;
-    request({ headers, signal }?: {}): Promise<any>;
+    request({ headers, signal }?: {
+        headers?: undefined;
+        signal?: undefined;
+    }): Promise<any>;
 }
 import { BaseClient } from './base.js';
 //# sourceMappingURL=xhr.d.ts.map

package/dist-module/source/client/xhr.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"xhr.d.ts","sourceRoot":"","sources":["../../../src/source/client/xhr.js"],"names":[],"mappings":"AA4BA;IACE,0DAyBC;IAED,gDAGC;CACF;2BA5DwC,WAAW"}
+{"version":3,"file":"xhr.d.ts","sourceRoot":"","sources":["../../../src/source/client/xhr.js"],"names":[],"mappings":"AA4BA;IACE,0DAyBC;IAED;;;qBAGC;CACF;2BA5DwC,WAAW"}

package/dist-module/source/client/xhr.js

@@ -46,7 +46,7 @@ export class XHRClient extends BaseClient {
             }
         });
     }
-    async request({ headers, signal } = {}) {
+    async request({ headers = undefined, signal = undefined } = {}) {
         const response = await this.constructRequest(headers, signal);
         return response;
     }

package/dist-module/source/file.js

@@ -1,7 +1,7 @@
 import fs from 'fs';
 import { BaseSource } from './basesource.js';
 function closeAsync(fd) {
-    return new Promise((resolve, reject) => {
+    return /** @type{Promise<void>} */ (new Promise((resolve, reject) => {
         fs.close(fd, (err) => {
             if (err) {
                 reject(err);
@@ -10,7 +10,7 @@ function closeAsync(fd) {
                 resolve();
             }
         });
-    });
+    }));
 }
 function openAsync(path, flags, mode = undefined) {
     return new Promise((resolve, reject) => {
@@ -24,9 +24,9 @@ function openAsync(path, flags, mode = undefined) {
         });
     });
 }
-function readAsync(...args) {
+function readAsync(_fd, _buffer, _offset, _length, _position) {
     return new Promise((resolve, reject) => {
-        fs.read(...args, (err, bytesRead, buffer) => {
+        fs.read(_fd, _buffer, _offset, _length, _position, (err, bytesRead, buffer) => {
             if (err) {
                 reject(err);
             }

package/dist-module/source/filereader.js

@@ -8,7 +8,7 @@ class FileReaderSource extends BaseSource {
         return new Promise((resolve, reject) => {
             const blob = this.file.slice(slice.offset, slice.offset + slice.length);
             const reader = new FileReader();
-            reader.onload = (event) => resolve(event.target.result);
+            reader.onload = () => resolve(reader.result);
             reader.onerror = reject;
             reader.onabort = reject;
             reader.readAsArrayBuffer(blob);

package/dist-module/source/httputils.d.ts

@@ -1,15 +1,23 @@
 /**
  * Parse a 'Content-Type' header value to the content-type and parameters
- * @param {String} rawContentType the raw string to parse from
- * @returns {Object} the parsed content type with the fields: type and params
+ * @param {string|null} rawContentType the raw string to parse from
+ * @returns {{type: string|null, params: Object}}}
+ *     the parsed content type with the fields: type and params
  */
-export function parseContentType(rawContentType: string): Object;
+export function parseContentType(rawContentType: string | null): {
+    type: string | null;
+    params: Object;
+};
 /**
  * Parse a 'Content-Range' header value to its start, end, and total parts
- * @param {String} rawContentRange the raw string to parse from
- * @returns {Object} the parsed parts
+ * @param {string|null} rawContentRange the raw string to parse from
+ * @returns {{start: number, end: number, total: number}} the parsed parts
  */
-export function parseContentRange(rawContentRange: string): Object;
+export function parseContentRange(rawContentRange: string | null): {
+    start: number;
+    end: number;
+    total: number;
+};
 /**
  * Parses a list of byteranges from the given 'multipart/byteranges' HTTP response.
  * Each item in the list has the following properties:

package/dist-module/source/httputils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"httputils.d.ts","sourceRoot":"","sources":["../../src/source/httputils.js"],"names":[],"mappings":"AAiCA;;;;GAIG;AACH,0DAFa,MAAM,CAMlB;AAED;;;;GAIG;AACH,4DAFa,MAAM,CAelB;AAED;;;;;;;;;;GAUG;AACH,qDAJW,WAAW,qBAET,MAAM,EAAE,CAuEpB"}
+{"version":3,"file":"httputils.d.ts","sourceRoot":"","sources":["../../src/source/httputils.js"],"names":[],"mappings":"AAiCA;;;;;GAKG;AACH,iDAJW,MAAM,GAAC,IAAI,GACT;IAAC,IAAI,EAAE,MAAM,GAAC,IAAI,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAC,CAU/C;AAED;;;;GAIG;AACH,mDAHW,MAAM,GAAC,IAAI,GACT;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAC,CAYvD;AAED;;;;;;;;;;GAUG;AACH,qDAJW,WAAW,qBAET,MAAM,EAAE,CAuEpB"}

package/dist-module/source/httputils.js

@@ -29,28 +29,29 @@ function parseHeaders(text) {
 }
 /**
  * Parse a 'Content-Type' header value to the content-type and parameters
- * @param {String} rawContentType the raw string to parse from
- * @returns {Object} the parsed content type with the fields: type and params
+ * @param {string|null} rawContentType the raw string to parse from
+ * @returns {{type: string|null, params: Object}}}
+ *     the parsed content type with the fields: type and params
  */
 export function parseContentType(rawContentType) {
+    if (!rawContentType) {
+        return { type: null, params: {} };
+    }
     const [type, ...rawParams] = rawContentType.split(';').map((s) => s.trim());
     const paramsItems = rawParams.map((param) => param.split('='));
     return { type, params: itemsToObject(paramsItems) };
 }
 /**
  * Parse a 'Content-Range' header value to its start, end, and total parts
- * @param {String} rawContentRange the raw string to parse from
- * @returns {Object} the parsed parts
+ * @param {string|null} rawContentRange the raw string to parse from
+ * @returns {{start: number, end: number, total: number}} the parsed parts
  */
 export function parseContentRange(rawContentRange) {
-    let start;
-    let end;
-    let total;
+    let start = NaN;
+    let end = NaN;
+    let total = NaN;
     if (rawContentRange) {
-        [, start, end, total] = rawContentRange.match(/bytes (\d+)-(\d+)\/(\d+)/);
-        start = parseInt(start, 10);
-        end = parseInt(end, 10);
-        total = parseInt(total, 10);
+        [, start, end, total] = (rawContentRange.match(/bytes (\d+)-(\d+)\/(\d+)/) || []).map(Number);
     }
     return { start, end, total };
 }
@@ -104,7 +105,7 @@ export function parseByteRanges(responseArrayBuffer, boundary) {
         const { start, end, total } = parseContentRange(headers['content-range']);
         // calculate the length of the slice and the next offset
         const startOfData = offset + startBoundary.length + endOfHeaders + CRLFCRLF.length;
-        const length = parseInt(end, 10) + 1 - parseInt(start, 10);
+        const length = end + 1 - start;
         out.push({
             headers,
             data: responseArrayBuffer.slice(startOfData, startOfData + length),

package/dist-module/source/remote.d.ts

@@ -1,27 +1,36 @@
-export function makeFetchSource(url: any, { headers, credentials, maxRanges, allowFullFile, ...blockOptions }?: {
-    headers?: {} | undefined;
-    maxRanges?: number | undefined;
-    allowFullFile?: boolean | undefined;
-}): any;
-export function makeXHRSource(url: any, { headers, maxRanges, allowFullFile, ...blockOptions }?: {
-    headers?: {} | undefined;
-    maxRanges?: number | undefined;
-    allowFullFile?: boolean | undefined;
-}): any;
-export function makeHttpSource(url: any, { headers, maxRanges, allowFullFile, ...blockOptions }?: {
-    headers?: {} | undefined;
-    maxRanges?: number | undefined;
-    allowFullFile?: boolean | undefined;
-}): any;
-export function makeCustomSource(client: any, { headers, maxRanges, allowFullFile, ...blockOptions }?: {
-    headers?: {} | undefined;
-    maxRanges?: number | undefined;
-    allowFullFile?: boolean | undefined;
-}): any;
+/**
+ * @param {string} url
+ * @param {RemoteSourceOptions & BlockedSourceOptions & { credentials?: RequestCredentials}} [param1]
+ * @returns {BaseSource}
+ */
+export function makeFetchSource(url: string, { headers, credentials, maxRanges, allowFullFile, ...blockOptions }?: RemoteSourceOptions & BlockedSourceOptions & {
+    credentials?: RequestCredentials;
+}): BaseSource;
+/**
+ * @param {string} url
+ * @param {RemoteSourceOptions & BlockedSourceOptions} [param1]
+ * @returns {BaseSource}
+ */
+export function makeXHRSource(url: string, { headers, maxRanges, allowFullFile, ...blockOptions }?: RemoteSourceOptions & BlockedSourceOptions): BaseSource;
+/**
+ * @param {string} url
+ * @param {RemoteSourceOptions & BlockedSourceOptions} [param1]
+ * @returns {BaseSource}
+ */
+export function makeHttpSource(url: string, { headers, maxRanges, allowFullFile, ...blockOptions }?: RemoteSourceOptions & BlockedSourceOptions): BaseSource;
+/**
+ * @param {import("../geotiff").BaseClient} client
+ * @param {RemoteSourceOptions & BlockedSourceOptions} [param1]
+ * @returns {BaseSource}
+ */
+export function makeCustomSource(client: import("../geotiff").BaseClient, { headers, maxRanges, allowFullFile, ...blockOptions }?: RemoteSourceOptions & BlockedSourceOptions): BaseSource;
 /**
  *
  * @param {string} url
- * @param {object} options
+ * @param {RemoteSourceOptions} options
  */
-export function makeRemoteSource(url: string, { forceXHR, ...clientOptions }?: object): any;
+export function makeRemoteSource(url: string, { forceXHR, ...clientOptions }?: RemoteSourceOptions): BaseSource;
+import type { RemoteSourceOptions } from '../geotiff.js';
+import type { BlockedSourceOptions } from '../geotiff.js';
+import { BaseSource } from './basesource.js';
 //# sourceMappingURL=remote.d.ts.map

package/dist-module/source/remote.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"remote.d.ts","sourceRoot":"","sources":["../../src/source/remote.js"],"names":[],"mappings":"AA+JA;;;;QAIC;AAED;;;;QAIC;AAED;;;;QAIC;AAED;;;;QAGC;AAED;;;;GAIG;AACH,sCAHW,MAAM,mCACN,MAAM,OAUhB"}
+{"version":3,"file":"remote.d.ts","sourceRoot":"","sources":["../../src/source/remote.js"],"names":[],"mappings":"AAoKA;;;;GAIG;AACH,qCAJW,MAAM,wEACN,mBAAmB,GAAG,oBAAoB,GAAG;IAAE,WAAW,CAAC,EAAE,kBAAkB,CAAA;CAAC,GAC9E,UAAU,CAMtB;AAED;;;;GAIG;AACH,mCAJW,MAAM,2DACN,mBAAmB,GAAG,oBAAoB,GACxC,UAAU,CAMtB;AAED;;;;GAIG;AACH,oCAJW,MAAM,2DACN,mBAAmB,GAAG,oBAAoB,GACxC,UAAU,CAMtB;AAED;;;;GAIG;AACH,yCAJW,OAAO,YAAY,EAAE,UAAU,2DAC/B,mBAAmB,GAAG,oBAAoB,GACxC,UAAU,CAKtB;AAED;;;;GAIG;AACH,sCAHW,MAAM,mCACN,mBAAmB,cAU7B;yCApN8D,eAAe;0CAAf,eAAe;2BAPnD,iBAAiB"}

package/dist-module/source/remote.js

@@ -4,15 +4,13 @@ import { BlockedSource } from './blockedsource.js';
 import { FetchClient } from './client/fetch.js';
 import { XHRClient } from './client/xhr.js';
 import { HttpClient } from './client/http.js';
+/** @import { RemoteSourceOptions, BlockedSourceOptions } from '../geotiff.js' */
 class RemoteSource extends BaseSource {
     /**
-     *
-     * @param {BaseClient} client
-     * @param {object} headers
-     * @param {numbers} maxRanges
-     * @param {boolean} allowFullFile
+     * @param {import("../geotiff").BaseClient} client
+     * @param {RemoteSourceOptions} options
      */
-    constructor(client, headers, maxRanges, allowFullFile) {
+    constructor(client, { headers, maxRanges = 0, allowFullFile } = {}) {
         super();
         this.client = client;
         this.headers = headers;
@@ -21,8 +19,9 @@ class RemoteSource extends BaseSource {
         this._fileSize = null;
     }
     /**
-     *
-     * @param {Slice[]} slices
+     * @param {import('./basesource.js').Slice[]} slices
+     * @param {AbortSignal} [signal]
+     * @returns {Promise<*[]>}
      */
     async fetch(slices, signal) {
         // if we allow multi-ranges, split the incoming request into that many sub-requests
@@ -134,35 +133,60 @@ class RemoteSource extends BaseSource {
         return this._fileSize;
     }
 }
+/**
+ * @param {BaseSource} source
+ * @param {BlockedSourceOptions} blockedSourceOptions
+ * @returns {BaseSource}
+ */
 function maybeWrapInBlockedSource(source, { blockSize, cacheSize }) {
     if (blockSize === null) {
         return source;
     }
     return new BlockedSource(source, { blockSize, cacheSize });
 }
+/**
+ * @param {string} url
+ * @param {RemoteSourceOptions & BlockedSourceOptions & { credentials?: RequestCredentials}} [param1]
+ * @returns {BaseSource}
+ */
 export function makeFetchSource(url, { headers = {}, credentials, maxRanges = 0, allowFullFile = false, ...blockOptions } = {}) {
     const client = new FetchClient(url, credentials);
-    const source = new RemoteSource(client, headers, maxRanges, allowFullFile);
+    const source = new RemoteSource(client, { headers, maxRanges, allowFullFile });
     return maybeWrapInBlockedSource(source, blockOptions);
 }
+/**
+ * @param {string} url
+ * @param {RemoteSourceOptions & BlockedSourceOptions} [param1]
+ * @returns {BaseSource}
+ */
 export function makeXHRSource(url, { headers = {}, maxRanges = 0, allowFullFile = false, ...blockOptions } = {}) {
     const client = new XHRClient(url);
-    const source = new RemoteSource(client, headers, maxRanges, allowFullFile);
+    const source = new RemoteSource(client, { headers, maxRanges, allowFullFile });
     return maybeWrapInBlockedSource(source, blockOptions);
 }
+/**
+ * @param {string} url
+ * @param {RemoteSourceOptions & BlockedSourceOptions} [param1]
+ * @returns {BaseSource}
+ */
 export function makeHttpSource(url, { headers = {}, maxRanges = 0, allowFullFile = false, ...blockOptions } = {}) {
     const client = new HttpClient(url);
-    const source = new RemoteSource(client, headers, maxRanges, allowFullFile);
+    const source = new RemoteSource(client, { headers, maxRanges, allowFullFile });
     return maybeWrapInBlockedSource(source, blockOptions);
 }
+/**
+ * @param {import("../geotiff").BaseClient} client
+ * @param {RemoteSourceOptions & BlockedSourceOptions} [param1]
+ * @returns {BaseSource}
+ */
 export function makeCustomSource(client, { headers = {}, maxRanges = 0, allowFullFile = false, ...blockOptions } = {}) {
-    const source = new RemoteSource(client, headers, maxRanges, allowFullFile);
+    const source = new RemoteSource(client, { headers, maxRanges, allowFullFile });
     return maybeWrapInBlockedSource(source, blockOptions);
 }
 /**
  *
  * @param {string} url
- * @param {object} options
+ * @param {RemoteSourceOptions} options
  */
 export function makeRemoteSource(url, { forceXHR = false, ...clientOptions } = {}) {
     if (typeof fetch === 'function' && !forceXHR) {

package/dist-module/utils.d.ts

@@ -19,7 +19,13 @@ export function parseContentRange(headerValue: any): {
     length: number | null;
 } | null;
 export function wait(milliseconds: any): Promise<any>;
-export function zip(a: any, b: any): any[][];
+/**
+ * @template T,U
+ * @param {Iterable<T>} a
+ * @param {Iterable<U>} b
+ * @returns {Array<[T, U]>}
+ */
+export function zip<T, U>(a: Iterable<T>, b: Iterable<U>): Array<[T, U]>;
 export function isTypedFloatArray(input: any): boolean;
 export function isTypedIntArray(input: any): boolean;
 export function isTypedUintArray(input: any): boolean;

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

@@ -1 +1 @@
-{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../src/utils.js"],"names":[],"mappings":"AAAA,uDAMC;AAED,2DAWC;AAED,oEAMC;AAED,wDAKC;AAED,wCASC;AAED,wCAMC;AAED,uDAMC;AAED,8CAOC;AAED,oDAKC;AAGD;;;;;;;;;;SAsCC;AAKD,sDAEC;AAED,6CAIC;AA4BD,uDAQC;AAED,qDAQC;AAED,sDAQC;AArDD;IACE,yBAUC;CACF;AAED;IACE,uCAKC;IAHC,YAAoB;IACpB,aAAsB;CAGzB;AAED,yDAAmD"}
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../src/utils.js"],"names":[],"mappings":"AAAA,uDAMC;AAED,2DAWC;AAED,oEAMC;AAED,wDAKC;AAED,wCASC;AAED,wCAMC;AAED,uDAMC;AAED,8CAOC;AAED,oDAKC;AAGD;;;;;;;;;;SAsCC;AAKD,sDAEC;AAED;;;;;GAKG;AACH,oBALa,CAAC,EAAC,CAAC,KACL,QAAQ,CAAC,CAAC,CAAC,KACX,QAAQ,CAAC,CAAC,CAAC,GACT,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAMzB;AA4BD,uDAQC;AAED,qDAQC;AAED,sDAQC;AArDD;IACE,yBAUC;CACF;AAED;IACE,uCAKC;IAHC,YAAoB;IACpB,aAAsB;CAGzB;AAED,yDAAmD"}

package/dist-module/utils.js

@@ -108,6 +108,12 @@ export function parseContentRange(headerValue) {
 export async function wait(milliseconds) {
     return new Promise((resolve) => setTimeout(resolve, milliseconds));
 }
+/**
+ * @template T,U
+ * @param {Iterable<T>} a
+ * @param {Iterable<U>} b
+ * @returns {Array<[T, U]>}
+ */
 export function zip(a, b) {
     const A = Array.isArray(a) ? a : Array.from(a);
     const B = Array.isArray(b) ? b : Array.from(b);