@loaders.gl/core 4.0.0-alpha.5 → 4.0.0-alpha.6

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

@@ -1,60 +1,78 @@
-import { isResponse, isBlob } from '../../javascript-utils/is-type';
-import { parseMIMEType, parseMIMETypeFromURL } from './mime-type-utils';
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getResourceContentLength = exports.getResourceUrlAndType = void 0;
+const is_type_1 = require("../../javascript-utils/is-type");
+const mime_type_utils_1 = require("./mime-type-utils");
 const QUERY_STRING_PATTERN = /\?.*/;
-export function getResourceUrlAndType(resource) {
-  if (isResponse(resource)) {
-    const url = stripQueryString(resource.url || '');
-    const contentTypeHeader = resource.headers.get('content-type') || '';
+/**
+ * Returns an object with `url` and (MIME) `type` fields
+ * If it cannot determine url or type, the corresponding value will be an empty string
+ *
+ * @param resource Any type, but only Responses, string URLs and data URLs are processed
+ *
+ * @todo string parameters are assumed to be URLs
+ */
+function getResourceUrlAndType(resource) {
+    // If resource is a response, it contains the information directly
+    if ((0, is_type_1.isResponse)(resource)) {
+        const url = stripQueryString(resource.url || '');
+        const contentTypeHeader = resource.headers.get('content-type') || '';
+        return {
+            url,
+            type: (0, mime_type_utils_1.parseMIMEType)(contentTypeHeader) || (0, mime_type_utils_1.parseMIMETypeFromURL)(url)
+        };
+    }
+    // If the resource is a Blob or a File (subclass of Blob)
+    if ((0, is_type_1.isBlob)(resource)) {
+        return {
+            // File objects have a "name" property. Blob objects don't have any
+            // url (name) information
+            url: stripQueryString(resource.name || ''),
+            type: resource.type || ''
+        };
+    }
+    if (typeof resource === 'string') {
+        return {
+            // TODO this could mess up data URL but it doesn't matter as it is just used for inference
+            url: stripQueryString(resource),
+            // If a data url
+            type: (0, mime_type_utils_1.parseMIMETypeFromURL)(resource)
+        };
+    }
+    // Unknown
     return {
-      url,
-      type: parseMIMEType(contentTypeHeader) || parseMIMETypeFromURL(url)
+        url: '',
+        type: ''
     };
-  }
-
-  if (isBlob(resource)) {
-    return {
-      url: stripQueryString(resource.name || ''),
-      type: resource.type || ''
-    };
-  }
-
-  if (typeof resource === 'string') {
-    return {
-      url: stripQueryString(resource),
-      type: parseMIMETypeFromURL(resource)
-    };
-  }
-
-  return {
-    url: '',
-    type: ''
-  };
 }
-export function getResourceContentLength(resource) {
-  if (isResponse(resource)) {
-    return resource.headers['content-length'] || -1;
-  }
-
-  if (isBlob(resource)) {
-    return resource.size;
-  }
-
-  if (typeof resource === 'string') {
-    return resource.length;
-  }
+exports.getResourceUrlAndType = getResourceUrlAndType;
+/**
+  * Returns (approximate) content length for a resource if it can be determined.
+  * Returns -1 if content length cannot be determined.
+  * @param resource
 
-  if (resource instanceof ArrayBuffer) {
-    return resource.byteLength;
-  }
-
-  if (ArrayBuffer.isView(resource)) {
-    return resource.byteLength;
-  }
-
-  return -1;
+  * @note string parameters are NOT assumed to be URLs
+  */
+function getResourceContentLength(resource) {
+    if ((0, is_type_1.isResponse)(resource)) {
+        return resource.headers['content-length'] || -1;
+    }
+    if ((0, is_type_1.isBlob)(resource)) {
+        return resource.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;
 }
-
+exports.getResourceContentLength = getResourceContentLength;
 function stripQueryString(url) {
-  return url.replace(QUERY_STRING_PATTERN, '');
+    return url.replace(QUERY_STRING_PATTERN, '');
 }
-//# sourceMappingURL=resource-utils.js.map

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

@@ -1,115 +1,114 @@
-import { isResponse } from '../../javascript-utils/is-type';
-import { getResourceContentLength, getResourceUrlAndType } from './resource-utils';
-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,
-    type
-  } = getResourceUrlAndType(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;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkResponseSync = exports.checkResponse = exports.makeResponse = void 0;
+const is_type_1 = require("../../javascript-utils/is-type");
+const resource_utils_1 = require("./resource-utils");
+/**
+ * Returns a Response object
+ * Adds content-length header when possible
+ *
+ * @param resource
+ */
+async function makeResponse(resource) {
+    if ((0, is_type_1.isResponse)(resource)) {
+        return resource;
+    }
+    // Add content-length header if possible
+    const headers = {};
+    const contentLength = (0, resource_utils_1.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, type } = (0, resource_utils_1.getResourceUrlAndType)(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;
 }
-export async function checkResponse(response) {
-  if (!response.ok) {
-    const message = await getResponseError(response);
-    throw new Error(message);
-  }
+exports.makeResponse = makeResponse;
+/**
+ * Checks response status (async) and throws a helpful error message if status is not OK.
+ * @param response
+ */
+async function checkResponse(response) {
+    if (!response.ok) {
+        const message = await getResponseError(response);
+        throw new Error(message);
+    }
 }
-export function checkResponseSync(response) {
-  if (!response.ok) {
-    let message = "".concat(response.status, " ").concat(response.statusText);
-    message = message.length > 60 ? "".concat(message.slice(60), "...") : message;
-    throw new Error(message);
-  }
+exports.checkResponse = checkResponse;
+/**
+ * Checks response status (sync) and throws a helpful error message if status is not OK.
+ * @param response
+ */
+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);
+    }
 }
-
+exports.checkResponseSync = checkResponseSync;
+// HELPERS
 async function getResponseError(response) {
-  let message = "Failed to fetch resource ".concat(response.url, " (").concat(response.status, "): ");
-
-  try {
-    const contentType = response.headers.get('Content-Type');
-    let text = response.statusText;
-
-    if (contentType.includes('application/json')) {
-      text += " ".concat(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 ? "".concat(message.slice(60), "...") : message;
-  } catch (error) {}
-
-  return message;
+    return message;
 }
-
 async function getInitialDataUrl(resource) {
-  const INITIAL_DATA_LENGTH = 5;
-
-  if (typeof resource === 'string') {
-    return "data:,".concat(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,".concat(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/null-loader.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"null-loader.d.ts","sourceRoot":"","sources":["../src/null-loader.ts"],"names":[],"mappings":"AAIA,OAAO,EAAC,MAAM,EAAE,gBAAgB,EAAC,MAAM,0BAA0B,CAAC;AAElE;;GAEG;AACH,eAAO,MAAM,gBAAgB,EAAE,MAY9B,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,UAAU,EAAE,gBAkBxB,CAAC"}
+{"version":3,"file":"null-loader.d.ts","sourceRoot":"","sources":["../src/null-loader.ts"],"names":[],"mappings":"AAIA,OAAO,EAAC,MAAM,EAAE,gBAAgB,EAAC,MAAM,0BAA0B,CAAC;AAElE;;GAEG;AACH,eAAO,MAAM,gBAAgB,EAAE,MAY9B,CAAC;AAYF;;GAEG;AACH,eAAO,MAAM,UAAU,EAAE,gBAoBxB,CAAC"}

package/dist/null-loader.js

@@ -1,34 +1,56 @@
-const VERSION = typeof "4.0.0-alpha.5" !== 'undefined' ? "4.0.0-alpha.5" : 'latest';
-export const NullWorkerLoader = {
-  name: 'Null loader',
-  id: 'null',
-  module: 'core',
-  version: VERSION,
-  worker: true,
-  mimeTypes: ['application/x.empty'],
-  extensions: ['null'],
-  tests: [() => false],
-  options: {
-    null: {}
-  }
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NullLoader = exports.NullWorkerLoader = void 0;
+// __VERSION__ is injected by babel-plugin-version-inline
+// @ts-ignore TS2304: Cannot find name '__VERSION__'.
+const VERSION = typeof __VERSION__ !== 'undefined' ? __VERSION__ : 'latest';
+/**
+ * Loads any data and returns null (or optionally passes through data unparsed)
+ */
+exports.NullWorkerLoader = {
+    name: 'Null loader',
+    id: 'null',
+    module: 'core',
+    version: VERSION,
+    worker: true,
+    mimeTypes: ['application/x.empty'],
+    extensions: ['null'],
+    tests: [() => false],
+    options: {
+        null: {}
+    }
 };
-export const NullLoader = {
-  name: 'Null loader',
-  id: 'null',
-  module: 'core',
-  version: VERSION,
-  mimeTypes: ['application/x.empty'],
-  extensions: ['null'],
-  parse: async arrayBuffer => arrayBuffer,
-  parseSync: arrayBuffer => arrayBuffer,
-  parseInBatches: async function* generator(asyncIterator) {
-    for await (const batch of asyncIterator) {
-      yield batch;
+/**
+ * Returns arguments passed to the parse API in a format that can be transfered to a
+ * web worker. The `context` parameter is stripped using JSON.stringify & parse.
+ */
+function parseSync(arrayBuffer, options, context) {
+    if (!options.null.echoParameters)
+        return null;
+    context = context && JSON.parse(JSON.stringify(context));
+    return { arrayBuffer, options, context };
+}
+/**
+ * Loads any data and returns null (or optionally passes through data unparsed)
+ */
+exports.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);
+        }
+    },
+    tests: [() => false],
+    options: {
+        null: {
+            echoParameters: false
+        }
     }
-  },
-  tests: [() => false],
-  options: {
-    null: {}
-  }
 };
-//# sourceMappingURL=null-loader.js.map

package/dist/null-worker.js

@@ -35,16 +35,33 @@
   }
 
   // ../worker-utils/src/lib/worker-farm/worker-body.ts
+  function getParentPort() {
+    let parentPort;
+    try {
+      eval("globalThis.parentPort = require('worker_threads').parentPort");
+      parentPort = globalThis.parentPort;
+    } catch {
+    }
+    return parentPort;
+  }
   var onMessageWrapperMap = new Map();
   var WorkerBody = class {
+    static inWorkerThread() {
+      return typeof self !== "undefined" || Boolean(getParentPort());
+    }
     static set onmessage(onMessage) {
-      self.onmessage = (message) => {
-        if (!isKnownMessage(message)) {
-          return;
-        }
-        const { type, payload } = message.data;
+      function handleMessage(message) {
+        const parentPort3 = getParentPort();
+        const { type, payload } = parentPort3 ? message : message.data;
         onMessage(type, payload);
-      };
+      }
+      const parentPort2 = getParentPort();
+      if (parentPort2) {
+        parentPort2.on("message", handleMessage);
+        parentPort2.on("exit", () => console.debug("Node worker closing"));
+      } else {
+        globalThis.onmessage = handleMessage;
+      }
     }
     static addEventListener(onMessage) {
       let onMessageWrapper = onMessageWrapperMap.get(onMessage);
@@ -53,22 +70,36 @@
           if (!isKnownMessage(message)) {
             return;
           }
-          const { type, payload } = message.data;
+          const parentPort3 = getParentPort();
+          const { type, payload } = parentPort3 ? message : message.data;
           onMessage(type, payload);
         };
       }
-      self.addEventListener("message", onMessageWrapper);
+      const parentPort2 = getParentPort();
+      if (parentPort2) {
+        console.error("not implemented");
+      } else {
+        globalThis.addEventListener("message", onMessageWrapper);
+      }
     }
     static removeEventListener(onMessage) {
       const onMessageWrapper = onMessageWrapperMap.get(onMessage);
       onMessageWrapperMap.delete(onMessage);
-      self.removeEventListener("message", onMessageWrapper);
+      const parentPort2 = getParentPort();
+      if (parentPort2) {
+        console.error("not implemented");
+      } else {
+        globalThis.removeEventListener("message", onMessageWrapper);
+      }
     }
     static postMessage(type, payload) {
-      if (self) {
-        const data = { source: "loaders.gl", type, payload };
-        const transferList = getTransferList(payload);
-        self.postMessage(data, transferList);
+      const data = { source: "loaders.gl", type, payload };
+      const transferList = getTransferList(payload);
+      const parentPort2 = getParentPort();
+      if (parentPort2) {
+        parentPort2.postMessage(data, transferList);
+      } else {
+        globalThis.postMessage(data, transferList);
       }
     }
   };
@@ -80,19 +111,20 @@
   // ../loader-utils/src/lib/worker-loader-utils/create-loader-worker.ts
   var requestId = 0;
   function createLoaderWorker(loader) {
-    if (typeof self === "undefined") {
+    if (!WorkerBody.inWorkerThread()) {
       return;
     }
     WorkerBody.onmessage = async (type, payload) => {
       switch (type) {
         case "process":
           try {
-            const { input, options = {} } = payload;
+            const { input, options = {}, context = {} } = payload;
             const result = await parseData({
               loader,
               arrayBuffer: input,
               options,
               context: {
+                ...context,
                 parse: parseOnMainThread
               }
             });
@@ -152,7 +184,13 @@
   }
 
   // src/null-loader.ts
-  var VERSION = true ? "4.0.0-alpha.5" : "latest";
+  var VERSION = true ? "4.0.0-alpha.6" : "latest";
+  function parseSync(arrayBuffer, options, context) {
+    if (!options.null.echoParameters)
+      return null;
+    context = context && JSON.parse(JSON.stringify(context));
+    return { arrayBuffer, options, context };
+  }
   var NullLoader = {
     name: "Null loader",
     id: "null",
@@ -160,16 +198,18 @@
     version: VERSION,
     mimeTypes: ["application/x.empty"],
     extensions: ["null"],
-    parse: async (arrayBuffer) => arrayBuffer,
-    parseSync: (arrayBuffer) => arrayBuffer,
-    parseInBatches: async function* generator(asyncIterator) {
+    parse: async (arrayBuffer, options, context) => parseSync(arrayBuffer, options, context),
+    parseSync,
+    parseInBatches: async function* generator(asyncIterator, options, context) {
       for await (const batch of asyncIterator) {
-        yield batch;
+        yield parseSync(batch, options, context);
       }
     },
     tests: [() => false],
     options: {
-      null: {}
+      null: {
+        echoParameters: false
+      }
     }
   };
 

package/dist/workers/null-worker.js

@@ -1,4 +1,5 @@
-import { createLoaderWorker } from '@loaders.gl/loader-utils';
-import { NullLoader } from '../null-loader';
-createLoaderWorker(NullLoader);
-//# sourceMappingURL=null-worker.js.map
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const loader_utils_1 = require("@loaders.gl/loader-utils");
+const null_loader_1 = require("../null-loader");
+(0, loader_utils_1.createLoaderWorker)(null_loader_1.NullLoader);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@loaders.gl/core",
-  "version": "4.0.0-alpha.5",
-  "description": "Framework-independent loaders for 3D graphics formats",
+  "version": "4.0.0-alpha.6",
+  "description": "The core API for working with loaders.gl loaders and writers",
   "license": "MIT",
   "publishConfig": {
     "access": "public"
@@ -18,8 +18,8 @@
     "point cloud"
   ],
   "types": "dist/index.d.ts",
-  "main": "dist/index.js",
-  "module": "dist/index.js",
+  "main": "dist/es5/index.js",
+  "module": "dist/esm/index.js",
   "sideEffects": false,
   "browser": {
     "fs": false,
@@ -42,9 +42,9 @@
   },
   "dependencies": {
     "@babel/runtime": "^7.3.1",
-    "@loaders.gl/loader-utils": "4.0.0-alpha.5",
-    "@loaders.gl/worker-utils": "4.0.0-alpha.5",
-    "probe.gl": "^3.4.0"
+    "@loaders.gl/loader-utils": "4.0.0-alpha.6",
+    "@loaders.gl/worker-utils": "4.0.0-alpha.6",
+    "@probe.gl/log": "^4.0.2"
   },
-  "gitHead": "7a71a54bdf1ddf985cc3af3db90b82e7fa97d025"
+  "gitHead": "acc1985050dfaa0f1f0c066f8da5bce7454a046c"
 }