@loaders.gl/core 4.2.0-alpha.4 → 4.2.0-alpha.6

package/dist/lib/filesystems/browser-filesystem.js

@@ -1,79 +1,137 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
 import { BlobFile } from '@loaders.gl/loader-utils';
+/**
+ * FileSystem adapter for a browser FileList.
+ * Holds a list of browser 'File' objects.
+ */
 export class BrowserFileSystem {
-  constructor(files, options) {
-    this._fetch = void 0;
-    this.files = {};
-    this.lowerCaseFiles = {};
-    this.usedFiles = {};
-    this._fetch = (options === null || options === void 0 ? void 0 : options.fetch) || fetch;
-    for (let i = 0; i < files.length; ++i) {
-      const file = files[i];
-      this.files[file.name] = file;
-      this.lowerCaseFiles[file.name.toLowerCase()] = file;
-      this.usedFiles[file.name] = false;
+    _fetch;
+    files = {};
+    lowerCaseFiles = {};
+    usedFiles = {};
+    /**
+     * A FileSystem API wrapper around a list of browser 'File' objects
+     * @param files
+     * @param options
+     */
+    constructor(files, options) {
+        this._fetch = options?.fetch || fetch;
+        for (let i = 0; i < files.length; ++i) {
+            const file = files[i];
+            this.files[file.name] = file;
+            this.lowerCaseFiles[file.name.toLowerCase()] = file;
+            this.usedFiles[file.name] = false;
+        }
+        this.fetch = this.fetch.bind(this);
     }
-    this.fetch = this.fetch.bind(this);
-  }
-  async fetch(path, options) {
-    if (path.includes('://')) {
-      return this._fetch(path, options);
+    // implements IFileSystem
+    /**
+     * Implementation of fetch against this file system
+     * Delegates to global fetch for http{s}:// or data://
+     */
+    async fetch(path, options) {
+        // Fallback to handle https:/http:/data: etc fetches
+        if (path.includes('://')) {
+            return this._fetch(path, options);
+        }
+        // Local fetches are served from the list of files
+        const file = this.files[path];
+        if (!file) {
+            return new Response(path, { status: 400, statusText: 'NOT FOUND' });
+        }
+        const headers = new Headers(options?.headers);
+        const range = headers.get('Range');
+        const bytes = range && /bytes=($1)-($2)/.exec(range);
+        if (bytes) {
+            const start = parseInt(bytes[1]);
+            const end = parseInt(bytes[2]);
+            // The trick when reading File objects is to read successive "slices" of the File
+            // Per spec https://w3c.github.io/FileAPI/, slicing a File should only update the start and end fields
+            // Actually reading from file should happen in `readAsArrayBuffer` (and as far we can tell it does)
+            const data = await file.slice(start, end).arrayBuffer();
+            const response = new Response(data);
+            Object.defineProperty(response, 'url', { value: path });
+            return response;
+        }
+        // return makeResponse()
+        const response = new Response(file);
+        Object.defineProperty(response, 'url', { value: path });
+        return response;
     }
-    const file = this.files[path];
-    if (!file) {
-      return new Response(path, {
-        status: 400,
-        statusText: 'NOT FOUND'
-      });
+    /**
+     * List filenames in this filesystem
+     * @param dirname
+     * @returns
+     */
+    async readdir(dirname) {
+        const files = [];
+        for (const path in this.files) {
+            files.push(path);
+        }
+        // TODO filter by dirname
+        return files;
     }
-    const headers = new Headers(options === null || options === void 0 ? void 0 : options.headers);
-    const range = headers.get('Range');
-    const bytes = range && /bytes=($1)-($2)/.exec(range);
-    if (bytes) {
-      const start = parseInt(bytes[1]);
-      const end = parseInt(bytes[2]);
-      const data = await file.slice(start, end).arrayBuffer();
-      const response = new Response(data);
-      Object.defineProperty(response, 'url', {
-        value: path
-      });
-      return response;
+    /**
+     * Return information (size) about files in this file system
+     */
+    async stat(path, options) {
+        const file = this.files[path];
+        if (!file) {
+            throw new Error(path);
+        }
+        return { size: file.size };
     }
-    const response = new Response(file);
-    Object.defineProperty(response, 'url', {
-      value: path
-    });
-    return response;
-  }
-  async readdir(dirname) {
-    const files = [];
-    for (const path in this.files) {
-      files.push(path);
+    /**
+     * Just removes the file from the list
+     */
+    async unlink(path) {
+        delete this.files[path];
+        delete this.lowerCaseFiles[path];
+        this.usedFiles[path] = true;
     }
-    return files;
-  }
-  async stat(path, options) {
-    const file = this.files[path];
-    if (!file) {
-      throw new Error(path);
+    // implements IRandomAccessFileSystem
+    // RANDOM ACCESS
+    async openReadableFile(pathname, flags) {
+        return new BlobFile(this.files[pathname]);
     }
-    return {
-      size: file.size
-    };
-  }
-  async unlink(path) {
-    delete this.files[path];
-    delete this.lowerCaseFiles[path];
-    this.usedFiles[path] = true;
-  }
-  async openReadableFile(pathname, flags) {
-    return new BlobFile(this.files[pathname]);
-  }
-  _getFile(path, used) {
-    const file = this.files[path] || this.lowerCaseFiles[path];
-    if (file && used) {
-      this.usedFiles[path] = true;
+    // PRIVATE
+    // Supports case independent paths, and file usage tracking
+    _getFile(path, used) {
+        // Prefer case match, but fall back to case independent.
+        const file = this.files[path] || this.lowerCaseFiles[path];
+        if (file && used) {
+            this.usedFiles[path] = true;
+        }
+        return file;
     }
-    return file;
-  }
 }
-//# sourceMappingURL=browser-filesystem.js.map
+/*
+   * Read a range into a buffer
+   * @todo - handle position memory
+   * @param buffer is the buffer that the data (read from the fd) will be written to.
+   * @param offset is the offset in the buffer to start writing at.
+   * @param length is an integer specifying the number of bytes to read.
+   * @param position is an argument specifying where to begin reading from in the file. If position is null, data will be read from the current file position, and the file position will be updated. If position is an integer, the file position will remain unchanged.
+   *
+  async read(
+    fd: any,
+    buffer: ArrayBuffer,
+    offset: number = 0,
+    length: number = buffer.byteLength,
+    position: number | null = null
+  ): Promise<{bytesRead: number; buffer: ArrayBuffer}> {
+    const file = fd as File;
+    const startPosition = 0; // position
+    const arrayBuffer = await file.slice(startPosition, startPosition + length).arrayBuffer();
+    // copy into target buffer
+    return {bytesRead: length, buffer: arrayBuffer};
+  }
+
+  async close(fd: number): Promise<void> {
+    // NO OP
+  }
+
+  // fstat(fd: number): Promise<object>; // Stat
+  */

package/dist/lib/filesystems/read-array-buffer.js

@@ -1,8 +1,16 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+/**
+ * Read a slice of a Blob or File, without loading the entire file into memory
+ * The trick when reading File objects is to read successive "slices" of the File
+ * Per spec https://w3c.github.io/FileAPI/, slicing a File only updates the start and end fields
+ * @param file to read
+ */
 export async function readArrayBuffer(file, start, length) {
-  if (file instanceof Blob) {
-    const slice = file.slice(start, start + length);
-    return await slice.arrayBuffer();
-  }
-  return await file.read(start, start + length);
+    if (file instanceof Blob) {
+        const slice = file.slice(start, start + length);
+        return await slice.arrayBuffer();
+    }
+    return await file.read(start, start + length);
 }
-//# sourceMappingURL=read-array-buffer.js.map

package/dist/lib/init.js

@@ -1,11 +1,17 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
 import { log } from "./utils/log.js";
-const version = typeof "4.2.0-alpha.4" !== 'undefined' ? "4.2.0-alpha.4" : '';
+// @ts-ignore TS2304: Cannot find name '__VERSION__'.
+const version = typeof "4.2.0-alpha.5" !== 'undefined' ? "4.2.0-alpha.5" : '';
+// @ts-ignore
 if (!globalThis.loaders) {
-  log.log(1, `loaders.gl ${version}`)();
-  globalThis.loaders = Object.assign(globalThis.loaders || {}, {
-    VERSION: version,
-    log
-  });
+    log.log(1, `loaders.gl ${version}`)();
+    // @ts-ignore TS2339: Property 'loaders' does not exist on type 'Window & typeof globalThis'.
+    globalThis.loaders = Object.assign(globalThis.loaders || {}, {
+        VERSION: version,
+        log
+    });
 }
+// @ts-ignore
 export default globalThis.loaders;
-//# sourceMappingURL=init.js.map

package/dist/lib/loader-utils/check-errors.js

@@ -1,22 +1,43 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+/**
+ * Check reponse status, if not OK extract error message and throw error
+ * @param response
+ */
 export async function checkFetchResponseStatus(response) {
-  if (!response.ok) {
-    let errorMessage = `fetch failed ${response.status} ${response.statusText}`;
-    try {
-      const text = await response.text();
-      if (text) {
-        errorMessage += `: ${getErrorText(text)}`;
-      }
-    } catch (error) {}
-    throw new Error(errorMessage);
-  }
+    if (!response.ok) {
+        let errorMessage = `fetch failed ${response.status} ${response.statusText}`;
+        try {
+            const text = await response.text();
+            if (text) {
+                errorMessage += `: ${getErrorText(text)}`;
+            }
+        }
+        catch (error) {
+            // ignore error
+        }
+        throw new Error(errorMessage);
+    }
 }
+/**
+ * Check response status synchronously, if not OK extract error message and throw error
+ * Not able to extract as good an error message as the async version
+ * @param response
+ */
 export function checkFetchResponseStatusSync(response) {
-  if (!response.ok) {
-    throw new Error(`fetch failed ${response.status}`);
-  }
+    if (!response.ok) {
+        throw new Error(`fetch failed ${response.status}`);
+    }
 }
+/**
+ * Ad-hoc error message extractor
+ * @todo Handle XML, JSON, etc
+ * @param text
+ * @returns
+ */
 function getErrorText(text) {
-  const matches = /<pre>(.*)<\/pre>/.exec(text);
-  return matches ? matches[1] : ` ${text.slice(0, 10)}...`;
+    // Look for HTML error texts
+    const matches = /<pre>(.*)<\/pre>/.exec(text);
+    return matches ? matches[1] : ` ${text.slice(0, 10)}...`;
 }
-//# sourceMappingURL=check-errors.js.map

package/dist/lib/loader-utils/get-data.js

@@ -1,103 +1,125 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
 import { concatenateArrayBuffersAsync } from '@loaders.gl/loader-utils';
 import { isResponse, isReadableStream, isAsyncIterable, isIterable, isIterator, isBlob, isBuffer } from "../../javascript-utils/is-type.js";
 import { makeIterator } from "../../iterators/make-iterator/make-iterator.js";
 import { checkResponse, makeResponse } from "../utils/response-utils.js";
 const ERR_DATA = 'Cannot convert supplied data type';
+// eslint-disable-next-line complexity
 export function getArrayBufferOrStringFromDataSync(data, loader, options) {
-  if (loader.text && typeof data === 'string') {
-    return data;
-  }
-  if (isBuffer(data)) {
-    data = data.buffer;
-  }
-  if (data instanceof ArrayBuffer) {
-    const arrayBuffer = data;
-    if (loader.text && !loader.binary) {
-      const textDecoder = new TextDecoder('utf8');
-      return textDecoder.decode(arrayBuffer);
-    }
-    return arrayBuffer;
-  }
-  if (ArrayBuffer.isView(data)) {
-    if (loader.text && !loader.binary) {
-      const textDecoder = new TextDecoder('utf8');
-      return textDecoder.decode(data);
-    }
-    let arrayBuffer = data.buffer;
-    const byteLength = data.byteLength || data.length;
-    if (data.byteOffset !== 0 || byteLength !== arrayBuffer.byteLength) {
-      arrayBuffer = arrayBuffer.slice(data.byteOffset, data.byteOffset + byteLength);
-    }
-    return arrayBuffer;
-  }
-  throw new Error(ERR_DATA);
+    if (loader.text && typeof data === 'string') {
+        return data;
+    }
+    if (isBuffer(data)) {
+        // @ts-ignore
+        data = data.buffer;
+    }
+    if (data instanceof ArrayBuffer) {
+        const arrayBuffer = data;
+        if (loader.text && !loader.binary) {
+            const textDecoder = new TextDecoder('utf8');
+            return textDecoder.decode(arrayBuffer);
+        }
+        return arrayBuffer;
+    }
+    // We may need to handle offsets
+    if (ArrayBuffer.isView(data)) {
+        // TextDecoder is invoked on typed arrays and will handle offsets
+        if (loader.text && !loader.binary) {
+            const textDecoder = new TextDecoder('utf8');
+            return textDecoder.decode(data);
+        }
+        let arrayBuffer = data.buffer;
+        // Since we are returning the underlying arrayBuffer, we must create a new copy
+        // if this typed array / Buffer is a partial view into the ArryayBuffer
+        // TODO - this is a potentially unnecessary copy
+        const byteLength = data.byteLength || data.length;
+        if (data.byteOffset !== 0 || byteLength !== arrayBuffer.byteLength) {
+            // console.warn(`loaders.gl copying arraybuffer of length ${byteLength}`);
+            arrayBuffer = arrayBuffer.slice(data.byteOffset, data.byteOffset + byteLength);
+        }
+        return arrayBuffer;
+    }
+    throw new Error(ERR_DATA);
 }
+// Convert async iterator to a promise
 export async function getArrayBufferOrStringFromData(data, loader, options) {
-  const isArrayBuffer = data instanceof ArrayBuffer || ArrayBuffer.isView(data);
-  if (typeof data === 'string' || isArrayBuffer) {
-    return getArrayBufferOrStringFromDataSync(data, loader, options);
-  }
-  if (isBlob(data)) {
-    data = await makeResponse(data);
-  }
-  if (isResponse(data)) {
-    const response = data;
-    await checkResponse(response);
-    return loader.binary ? await response.arrayBuffer() : await response.text();
-  }
-  if (isReadableStream(data)) {
-    data = makeIterator(data, options);
-  }
-  if (isIterable(data) || isAsyncIterable(data)) {
-    return concatenateArrayBuffersAsync(data);
-  }
-  throw new Error(ERR_DATA);
+    const isArrayBuffer = data instanceof ArrayBuffer || ArrayBuffer.isView(data);
+    if (typeof data === 'string' || isArrayBuffer) {
+        return getArrayBufferOrStringFromDataSync(data, loader, options);
+    }
+    // Blobs and files are FileReader compatible
+    if (isBlob(data)) {
+        data = await makeResponse(data);
+    }
+    if (isResponse(data)) {
+        const response = data;
+        await checkResponse(response);
+        return loader.binary ? await response.arrayBuffer() : await response.text();
+    }
+    if (isReadableStream(data)) {
+        // @ts-expect-error TS2559 options type
+        data = makeIterator(data, options);
+    }
+    if (isIterable(data) || isAsyncIterable(data)) {
+        // Assume arrayBuffer iterator - attempt to concatenate
+        return concatenateArrayBuffersAsync(data);
+    }
+    throw new Error(ERR_DATA);
 }
 export async function getAsyncIterableFromData(data, options) {
-  if (isIterator(data)) {
-    return data;
-  }
-  if (isResponse(data)) {
-    const response = data;
-    await checkResponse(response);
-    const body = await response.body;
-    return makeIterator(body, options);
-  }
-  if (isBlob(data) || isReadableStream(data)) {
-    return makeIterator(data, options);
-  }
-  if (isAsyncIterable(data)) {
-    return data;
-  }
-  return getIterableFromData(data);
+    if (isIterator(data)) {
+        return data;
+    }
+    if (isResponse(data)) {
+        const response = data;
+        // Note Since this function is not async, we currently can't load error message, just status
+        await checkResponse(response);
+        // TODO - bug in polyfill, body can be a Promise under Node.js
+        // eslint-disable-next-line @typescript-eslint/await-thenable
+        const body = await response.body;
+        // TODO - body can be null?
+        return makeIterator(body, options);
+    }
+    if (isBlob(data) || isReadableStream(data)) {
+        return makeIterator(data, options);
+    }
+    if (isAsyncIterable(data)) {
+        return data;
+    }
+    return getIterableFromData(data);
 }
 export async function getReadableStream(data) {
-  if (isReadableStream(data)) {
-    return data;
-  }
-  if (isResponse(data)) {
-    return data.body;
-  }
-  const response = await makeResponse(data);
-  return response.body;
+    if (isReadableStream(data)) {
+        return data;
+    }
+    if (isResponse(data)) {
+        // @ts-ignore
+        return data.body;
+    }
+    const response = await makeResponse(data);
+    // @ts-ignore
+    return response.body;
 }
+// HELPERS
 function getIterableFromData(data) {
-  if (ArrayBuffer.isView(data)) {
-    return function* oneChunk() {
-      yield data.buffer;
-    }();
-  }
-  if (data instanceof ArrayBuffer) {
-    return function* oneChunk() {
-      yield data;
-    }();
-  }
-  if (isIterator(data)) {
-    return data;
-  }
-  if (isIterable(data)) {
-    return data[Symbol.iterator]();
-  }
-  throw new Error(ERR_DATA);
+    // generate an iterator that emits a single chunk
+    if (ArrayBuffer.isView(data)) {
+        return (function* oneChunk() {
+            yield data.buffer;
+        })();
+    }
+    if (data instanceof ArrayBuffer) {
+        return (function* oneChunk() {
+            yield data;
+        })();
+    }
+    if (isIterator(data)) {
+        return data;
+    }
+    if (isIterable(data)) {
+        return data[Symbol.iterator]();
+    }
+    throw new Error(ERR_DATA);
 }
-//# sourceMappingURL=get-data.js.map

package/dist/lib/loader-utils/get-fetch-function.js

@@ -1,18 +1,29 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
 import { isObject } from "../../javascript-utils/is-type.js";
 import { fetchFile } from "../fetch/fetch-file.js";
 import { getGlobalLoaderOptions } from "./option-utils.js";
+/**
+ * Gets the current fetch function from options and context
+ * @param options
+ * @param context
+ */
 export function getFetchFunction(options, context) {
-  const globalOptions = getGlobalLoaderOptions();
-  const loaderOptions = options || globalOptions;
-  if (typeof loaderOptions.fetch === 'function') {
-    return loaderOptions.fetch;
-  }
-  if (isObject(loaderOptions.fetch)) {
-    return url => fetchFile(url, loaderOptions.fetch);
-  }
-  if (context !== null && context !== void 0 && context.fetch) {
-    return context === null || context === void 0 ? void 0 : context.fetch;
-  }
-  return fetchFile;
+    const globalOptions = getGlobalLoaderOptions();
+    const loaderOptions = options || globalOptions;
+    // options.fetch can be a function
+    if (typeof loaderOptions.fetch === 'function') {
+        return loaderOptions.fetch;
+    }
+    // options.fetch can be an options object
+    if (isObject(loaderOptions.fetch)) {
+        return (url) => fetchFile(url, loaderOptions.fetch);
+    }
+    // else refer to context (from parent loader) if available
+    if (context?.fetch) {
+        return context?.fetch;
+    }
+    // else return the default fetch function
+    return fetchFile;
 }
-//# sourceMappingURL=get-fetch-function.js.map