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

package/dist/lib/progress/fetch-progress.js

@@ -1,52 +1,59 @@
-export async function fetchProgress(response, onProgress) {
-  let onDone = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : () => {};
-  let onError = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : () => {};
-  response = await response;
-  if (!response.ok) {
-    return response;
-  }
-  const body = response.body;
-  if (!body) {
-    return response;
-  }
-  const contentLength = response.headers.get('content-length') || 0;
-  const totalBytes = contentLength ? parseInt(contentLength) : 0;
-  if (!(totalBytes > 0)) {
-    return response;
-  }
-  if (typeof ReadableStream === 'undefined' || !body.getReader) {
-    return response;
-  }
-  const progressStream = new ReadableStream({
-    async start(controller) {
-      const reader = body.getReader();
-      await read(controller, reader, 0, totalBytes, onProgress, onDone, onError);
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+// Forked from github AnthumChris/fetch-progress-indicators under MIT license
+/**
+ * Intercepts the Response stream and creates a new Response
+ */
+export async function fetchProgress(response, onProgress, // TODO better callback types
+onDone = () => { }, onError = () => { }) {
+    response = await response;
+    if (!response.ok) {
+        // ERROR checking needs to be done separately
+        return response;
     }
-  });
-  return new Response(progressStream);
+    const body = response.body;
+    if (!body) {
+        // 'ReadableStream not yet supported in this browser.
+        return response;
+    }
+    const contentLength = response.headers.get('content-length') || 0;
+    const totalBytes = contentLength ? parseInt(contentLength) : 0;
+    if (!(totalBytes > 0)) {
+        return response;
+    }
+    // Currently override only implemented in browser
+    if (typeof ReadableStream === 'undefined' || !body.getReader) {
+        return response;
+    }
+    // Create a new stream that invisbly wraps original stream
+    const progressStream = new ReadableStream({
+        async start(controller) {
+            const reader = body.getReader();
+            await read(controller, reader, 0, totalBytes, onProgress, onDone, onError);
+        }
+    });
+    return new Response(progressStream);
 }
+// Forward to original streams controller
+// TODO - this causes a crazy deep "async stack"... rewrite as async iterator?
+// eslint-disable-next-line max-params
 async function read(controller, reader, loadedBytes, totalBytes, onProgress, onDone, onError) {
-  try {
-    const {
-      done,
-      value
-    } = await reader.read();
-    if (done) {
-      onDone();
-      controller.close();
-      return;
+    try {
+        const { done, value } = await reader.read();
+        if (done) {
+            onDone();
+            controller.close();
+            return;
+        }
+        loadedBytes += value.byteLength;
+        const percent = Math.round((loadedBytes / totalBytes) * 100);
+        onProgress(percent, { loadedBytes, totalBytes });
+        controller.enqueue(value);
+        await read(controller, reader, loadedBytes, totalBytes, onProgress, onDone, onError);
+    }
+    catch (error) {
+        controller.error(error);
+        onError(error);
     }
-    loadedBytes += value.byteLength;
-    const percent = Math.round(loadedBytes / totalBytes * 100);
-    onProgress(percent, {
-      loadedBytes,
-      totalBytes
-    });
-    controller.enqueue(value);
-    await read(controller, reader, loadedBytes, totalBytes, onProgress, onDone, onError);
-  } catch (error) {
-    controller.error(error);
-    onError(error);
-  }
 }
-//# sourceMappingURL=fetch-progress.js.map

package/dist/lib/utils/log.js

@@ -1,5 +1,5 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
 import { Log } from '@probe.gl/log';
-export const log = new Log({
-  id: 'loaders.gl'
-});
-//# sourceMappingURL=log.js.map
+export const log = new Log({ id: 'loaders.gl' });

package/dist/lib/utils/mime-type-utils.js

@@ -1,17 +1,40 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+// TODO - build/integrate proper MIME type parsing
+// https://mimesniff.spec.whatwg.org/
 const DATA_URL_PATTERN = /^data:([-\w.]+\/[-\w.+]+)(;|,)/;
 const MIME_TYPE_PATTERN = /^([-\w.]+\/[-\w.+]+)/;
+/**
+ * Remove extra data like `charset` from MIME types
+ * @param mimeString
+ * @returns A clean MIME type, or an empty string
+ *
+ * @todo - handle more advanced MIMETYpes, multiple types
+ * @todo - extract charset etc
+ */
 export function parseMIMEType(mimeString) {
-  const matches = MIME_TYPE_PATTERN.exec(mimeString);
-  if (matches) {
-    return matches[1];
-  }
-  return mimeString;
+    // If resource is a data url, extract any embedded mime type
+    const matches = MIME_TYPE_PATTERN.exec(mimeString);
+    if (matches) {
+        return matches[1];
+    }
+    return mimeString;
 }
+/**
+ * Extract MIME type from data URL
+ *
+ * @param mimeString
+ * @returns A clean MIME type, or an empty string
+ *
+ * @todo - handle more advanced MIMETYpes, multiple types
+ * @todo - extract charset etc
+ */
 export function parseMIMETypeFromURL(url) {
-  const matches = DATA_URL_PATTERN.exec(url);
-  if (matches) {
-    return matches[1];
-  }
-  return '';
+    // If resource is a data URL, extract any embedded mime type
+    const matches = DATA_URL_PATTERN.exec(url);
+    if (matches) {
+        return matches[1];
+    }
+    return '';
 }
-//# sourceMappingURL=mime-type-utils.js.map

package/dist/lib/utils/resource-utils.js

@@ -1,54 +1,86 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
 import { isResponse, isBlob } from "../../javascript-utils/is-type.js";
 import { parseMIMEType, parseMIMETypeFromURL } from "./mime-type-utils.js";
 import { stripQueryString } from "./url-utils.js";
+/**
+ * Returns the URL associated with this resource.
+ * The returned value may include a query string and need further processing.
+ * If it cannot determine url, the corresponding value will be an empty string
+ *
+ * @todo string parameters are assumed to be URLs
+ */
 export function getResourceUrl(resource) {
-  if (isResponse(resource)) {
-    const response = resource;
-    return response.url;
-  }
-  if (isBlob(resource)) {
-    const blob = resource;
-    return blob.name || '';
-  }
-  if (typeof resource === 'string') {
-    return resource;
-  }
-  return '';
+    // If resource is a `Response`, it contains the information directly as a field
+    if (isResponse(resource)) {
+        const response = resource;
+        return response.url;
+    }
+    // If the resource is a Blob or a File (subclass of Blob)
+    if (isBlob(resource)) {
+        const blob = resource;
+        // File objects have a "name" property. Blob objects don't have any
+        // url (name) information
+        return blob.name || '';
+    }
+    if (typeof resource === 'string') {
+        return resource;
+    }
+    // Unknown
+    return '';
 }
+/**
+ * Returns the URL associated with this resource.
+ * The returned value may include a query string and need further processing.
+ * If it cannot determine url, the corresponding value will be an empty string
+ *
+ * @todo string parameters are assumed to be URLs
+ */
 export function getResourceMIMEType(resource) {
-  if (isResponse(resource)) {
-    const response = resource;
-    const contentTypeHeader = response.headers.get('content-type') || '';
-    const noQueryUrl = stripQueryString(response.url);
-    return parseMIMEType(contentTypeHeader) || parseMIMETypeFromURL(noQueryUrl);
-  }
-  if (isBlob(resource)) {
-    const blob = resource;
-    return blob.type || '';
-  }
-  if (typeof resource === 'string') {
-    return parseMIMETypeFromURL(resource);
-  }
-  return '';
+    // If resource is a response, it contains the information directly
+    if (isResponse(resource)) {
+        const response = resource;
+        const contentTypeHeader = response.headers.get('content-type') || '';
+        const noQueryUrl = stripQueryString(response.url);
+        return parseMIMEType(contentTypeHeader) || parseMIMETypeFromURL(noQueryUrl);
+    }
+    // If the resource is a Blob or a File (subclass of Blob)
+    if (isBlob(resource)) {
+        const blob = resource;
+        return blob.type || '';
+    }
+    if (typeof resource === 'string') {
+        return parseMIMETypeFromURL(resource);
+    }
+    // Unknown
+    return '';
 }
+/**
+  * Returns (approximate) content length for a resource if it can be determined.
+  * Returns -1 if content length cannot be determined.
+  * @param resource
+
+  * @note string parameters are NOT assumed to be URLs
+  */
 export function getResourceContentLength(resource) {
-  if (isResponse(resource)) {
-    const response = resource;
-    return response.headers['content-length'] || -1;
-  }
-  if (isBlob(resource)) {
-    const blob = resource;
-    return blob.size;
-  }
-  if (typeof resource === 'string') {
-    return resource.length;
-  }
-  if (resource instanceof ArrayBuffer) {
-    return resource.byteLength;
-  }
-  if (ArrayBuffer.isView(resource)) {
-    return resource.byteLength;
-  }
-  return -1;
+    if (isResponse(resource)) {
+        const response = resource;
+        return response.headers['content-length'] || -1;
+    }
+    if (isBlob(resource)) {
+        const blob = resource;
+        return blob.size;
+    }
+    if (typeof resource === 'string') {
+        // TODO - handle data URL?
+        return resource.length;
+    }
+    if (resource instanceof ArrayBuffer) {
+        return resource.byteLength;
+    }
+    if (ArrayBuffer.isView(resource)) {
+        return resource.byteLength;
+    }
+    return -1;
 }
-//# sourceMappingURL=resource-utils.js.map

package/dist/lib/utils/response-utils.js

@@ -1,89 +1,112 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
 import { isResponse } from "../../javascript-utils/is-type.js";
 import { getResourceContentLength, getResourceUrl, getResourceMIMEType } from "./resource-utils.js";
+/**
+ * Returns a Response object
+ * Adds content-length header when possible
+ *
+ * @param resource
+ */
 export async function makeResponse(resource) {
-  if (isResponse(resource)) {
-    return resource;
-  }
-  const headers = {};
-  const contentLength = getResourceContentLength(resource);
-  if (contentLength >= 0) {
-    headers['content-length'] = String(contentLength);
-  }
-  const url = getResourceUrl(resource);
-  const type = getResourceMIMEType(resource);
-  if (type) {
-    headers['content-type'] = type;
-  }
-  const initialDataUrl = await getInitialDataUrl(resource);
-  if (initialDataUrl) {
-    headers['x-first-bytes'] = initialDataUrl;
-  }
-  if (typeof resource === 'string') {
-    resource = new TextEncoder().encode(resource);
-  }
-  const response = new Response(resource, {
-    headers
-  });
-  Object.defineProperty(response, 'url', {
-    value: url
-  });
-  return response;
+    if (isResponse(resource)) {
+        return resource;
+    }
+    // Add content-length header if possible
+    const headers = {};
+    const contentLength = getResourceContentLength(resource);
+    if (contentLength >= 0) {
+        headers['content-length'] = String(contentLength);
+    }
+    // `new Response(File)` does not preserve content-type and URL
+    // so we add them here
+    const url = getResourceUrl(resource);
+    const type = getResourceMIMEType(resource);
+    if (type) {
+        headers['content-type'] = type;
+    }
+    // Add a custom header with initial bytes if available
+    const initialDataUrl = await getInitialDataUrl(resource);
+    if (initialDataUrl) {
+        headers['x-first-bytes'] = initialDataUrl;
+    }
+    // TODO - is this the best way of handling strings?
+    // Maybe package as data URL instead?
+    if (typeof resource === 'string') {
+        // Convert to ArrayBuffer to avoid Response treating it as a URL
+        resource = new TextEncoder().encode(resource);
+    }
+    // Attempt to create a Response from the resource, adding headers and setting url
+    const response = new Response(resource, { headers });
+    // We can't control `Response.url` via constructor, use a property override to record URL.
+    Object.defineProperty(response, 'url', { value: url });
+    return response;
 }
+/**
+ * Checks response status (async) and throws a helpful error message if status is not OK.
+ * @param response
+ */
 export async function checkResponse(response) {
-  if (!response.ok) {
-    const message = await getResponseError(response);
-    throw new Error(message);
-  }
+    if (!response.ok) {
+        const message = await getResponseError(response);
+        throw new Error(message);
+    }
 }
+/**
+ * Checks response status (sync) and throws a helpful error message if status is not OK.
+ * @param response
+ */
 export function checkResponseSync(response) {
-  if (!response.ok) {
-    let message = `${response.status} ${response.statusText}`;
-    message = message.length > 60 ? `${message.slice(0, 60)}...` : message;
-    throw new Error(message);
-  }
+    if (!response.ok) {
+        let message = `${response.status} ${response.statusText}`;
+        message = message.length > 60 ? `${message.slice(0, 60)}...` : message;
+        throw new Error(message);
+    }
 }
+// HELPERS
 async function getResponseError(response) {
-  let message = `Failed to fetch resource ${response.url} (${response.status}): `;
-  try {
-    const contentType = response.headers.get('Content-Type');
-    let text = response.statusText;
-    if (contentType !== null && contentType !== void 0 && contentType.includes('application/json')) {
-      text += ` ${await response.text()}`;
+    let message = `Failed to fetch resource ${response.url} (${response.status}): `;
+    try {
+        const contentType = response.headers.get('Content-Type');
+        let text = response.statusText;
+        if (contentType?.includes('application/json')) {
+            text += ` ${await response.text()}`;
+        }
+        message += text;
+        message = message.length > 60 ? `${message.slice(0, 60)}...` : message;
+    }
+    catch (error) {
+        // eslint forbids return in a finally statement, so we just catch here
     }
-    message += text;
-    message = message.length > 60 ? `${message.slice(0, 60)}...` : message;
-  } catch (error) {}
-  return message;
+    return message;
 }
 async function getInitialDataUrl(resource) {
-  const INITIAL_DATA_LENGTH = 5;
-  if (typeof resource === 'string') {
-    return `data:,${resource.slice(0, INITIAL_DATA_LENGTH)}`;
-  }
-  if (resource instanceof Blob) {
-    const blobSlice = resource.slice(0, 5);
-    return await new Promise(resolve => {
-      const reader = new FileReader();
-      reader.onload = event => {
-        var _event$target;
-        return resolve(event === null || event === void 0 ? void 0 : (_event$target = event.target) === null || _event$target === void 0 ? void 0 : _event$target.result);
-      };
-      reader.readAsDataURL(blobSlice);
-    });
-  }
-  if (resource instanceof ArrayBuffer) {
-    const slice = resource.slice(0, INITIAL_DATA_LENGTH);
-    const base64 = arrayBufferToBase64(slice);
-    return `data:base64,${base64}`;
-  }
-  return null;
+    const INITIAL_DATA_LENGTH = 5;
+    if (typeof resource === 'string') {
+        return `data:,${resource.slice(0, INITIAL_DATA_LENGTH)}`;
+    }
+    if (resource instanceof Blob) {
+        const blobSlice = resource.slice(0, 5);
+        return await new Promise((resolve) => {
+            const reader = new FileReader();
+            reader.onload = (event) => resolve(event?.target?.result);
+            reader.readAsDataURL(blobSlice);
+        });
+    }
+    if (resource instanceof ArrayBuffer) {
+        const slice = resource.slice(0, INITIAL_DATA_LENGTH);
+        const base64 = arrayBufferToBase64(slice);
+        return `data:base64,${base64}`;
+    }
+    return null;
 }
+// https://stackoverflow.com/questions/9267899/arraybuffer-to-base64-encoded-string
 function arrayBufferToBase64(buffer) {
-  let binary = '';
-  const bytes = new Uint8Array(buffer);
-  for (let i = 0; i < bytes.byteLength; i++) {
-    binary += String.fromCharCode(bytes[i]);
-  }
-  return btoa(binary);
+    let binary = '';
+    const bytes = new Uint8Array(buffer);
+    for (let i = 0; i < bytes.byteLength; i++) {
+        binary += String.fromCharCode(bytes[i]);
+    }
+    return btoa(binary);
 }
-//# sourceMappingURL=response-utils.js.map

package/dist/lib/utils/url-utils.js

@@ -1,9 +1,11 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
 const QUERY_STRING_PATTERN = /\?.*/;
 export function extractQueryString(url) {
-  const matches = url.match(QUERY_STRING_PATTERN);
-  return matches && matches[0];
+    const matches = url.match(QUERY_STRING_PATTERN);
+    return matches && matches[0];
 }
 export function stripQueryString(url) {
-  return url.replace(QUERY_STRING_PATTERN, '');
+    return url.replace(QUERY_STRING_PATTERN, '');
 }
-//# sourceMappingURL=url-utils.js.map

package/dist/null-loader.js

@@ -1,37 +1,51 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+// __VERSION__ is injected by babel-plugin-version-inline
+// @ts-ignore TS2304: Cannot find name '__VERSION__'.
 const VERSION = typeof "4.2.0-alpha.4" !== 'undefined' ? "4.2.0-alpha.4" : 'latest';
+/**
+ * Loads any data and returns null (or optionally passes through data unparsed)
+ */
 export const NullWorkerLoader = {
-  name: 'Null loader',
-  id: 'null',
-  module: 'core',
-  version: VERSION,
-  worker: true,
-  mimeTypes: ['application/x.empty'],
-  extensions: ['null'],
-  tests: [() => false],
-  options: {
-    null: {}
-  }
+    name: 'Null loader',
+    id: 'null',
+    module: 'core',
+    version: VERSION,
+    worker: true,
+    mimeTypes: ['application/x.empty'],
+    extensions: ['null'],
+    tests: [() => false],
+    options: {
+        null: {}
+    }
 };
+/**
+ * Loads any data and returns null (or optionally passes through data unparsed)
+ */
 export const NullLoader = {
-  name: 'Null loader',
-  id: 'null',
-  module: 'core',
-  version: VERSION,
-  mimeTypes: ['application/x.empty'],
-  extensions: ['null'],
-  parse: async (arrayBuffer, options, context) => parseSync(arrayBuffer, options || {}, context),
-  parseSync,
-  parseInBatches: async function* generator(asyncIterator, options, context) {
-    for await (const batch of asyncIterator) {
-      yield parseSync(batch, options, context);
+    name: 'Null loader',
+    id: 'null',
+    module: 'core',
+    version: VERSION,
+    mimeTypes: ['application/x.empty'],
+    extensions: ['null'],
+    parse: async (arrayBuffer, options, context) => parseSync(arrayBuffer, options || {}, context),
+    parseSync,
+    parseInBatches: async function* generator(asyncIterator, options, context) {
+        for await (const batch of asyncIterator) {
+            yield parseSync(batch, options, context);
+        }
+    },
+    tests: [() => false],
+    options: {
+        null: {}
     }
-  },
-  tests: [() => false],
-  options: {
-    null: {}
-  }
 };
+/**
+ * Returns arguments passed to the parse API in a format that can be transferred to a
+ * web worker. The `context` parameter is stripped using JSON.stringify & parse.
+ */
 function parseSync(arrayBuffer, options, context) {
-  return null;
+    return null;
 }
-//# sourceMappingURL=null-loader.js.map

package/dist/workers/null-worker-node.js

@@ -1,4 +1,6 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
 import { createLoaderWorker } from '@loaders.gl/loader-utils';
 import { NullLoader } from "../null-loader.js";
 createLoaderWorker(NullLoader);
-//# sourceMappingURL=null-worker-node.js.map

package/dist/workers/null-worker.js

@@ -1,4 +1,6 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
 import { createLoaderWorker } from '@loaders.gl/loader-utils';
 import { NullLoader } from "../null-loader.js";
 createLoaderWorker(NullLoader);
-//# sourceMappingURL=null-worker.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@loaders.gl/core",
-  "version": "4.2.0-alpha.4",
+  "version": "4.2.0-alpha.5",
   "description": "The core API for working with loaders.gl loaders and writers",
   "license": "MIT",
   "type": "module",
@@ -48,16 +48,16 @@
     "README.md"
   ],
   "scripts": {
-    "pre-build": "npm run build-bundle && npm run build-bundle -- --env=dev && npm run build-worker && npm run build-worker-node",
-    "build-bundle": "ocular-bundle ./src/index.ts",
+    "pre-build": "npm run build-bundle && npm run build-bundle-dev && npm run build-worker && npm run build-worker-node",
+    "build-bundle": "ocular-bundle ./bundle.ts --output=dist/dist.min.js",
+    "build-bundle-dev": "ocular-bundle ./bundle.ts --env=dev --output=dist/dist.dev.js",
     "build-worker": "esbuild src/workers/null-worker.ts --outfile=dist/null-worker.js --bundle --target=esnext --define:__VERSION__=\\\"$npm_package_version\\\"",
     "build-worker-node": "esbuild src/workers/null-worker.ts --outfile=dist/null-worker-node.js --bundle --platform=node --target=node16 --define:__VERSION__=\\\"$npm_package_version\\\""
   },
   "dependencies": {
-    "@babel/runtime": "^7.3.1",
-    "@loaders.gl/loader-utils": "4.2.0-alpha.4",
-    "@loaders.gl/worker-utils": "4.2.0-alpha.4",
+    "@loaders.gl/loader-utils": "4.2.0-alpha.5",
+    "@loaders.gl/worker-utils": "4.2.0-alpha.5",
     "@probe.gl/log": "^4.0.2"
   },
-  "gitHead": "6c52dee5c3f005648a394cc4aee7fc37005c8e83"
+  "gitHead": "32d95a81971f104e4dfeb88ab57065f05321a76a"
 }

package/src/lib/loader-utils/option-utils.ts

@@ -26,7 +26,9 @@ export function getGlobalLoaderState(): GlobalLoaderState {
   const {loaders} = globalThis;
 
   // Add _state object to keep separate from modules added to globalThis.loaders
-  loaders._state = loaders._state || {};
+  if (!loaders._state) {
+    loaders._state = {};
+  }
   return loaders._state;
 }
 

package/dist/core-addons/README.md

@@ -1 +0,0 @@
-These experimental classes should be moved to another module.